From ee7040fd9b056ef61c538717c11c3eab48d86ac5 Mon Sep 17 00:00:00 2001
From: Alessandro Ghedini <alessandro@ghedini.me>
Date: Wed, 20 Nov 2013 14:11:44 +0100
Subject: ssh: add support for ssh-agent authentication

---
 src/transports/cred.c | 22 +++++++++++++++++++++
 src/transports/ssh.c  | 54 +++++++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 74 insertions(+), 2 deletions(-)

diff --git a/src/transports/cred.c b/src/transports/cred.c
index 05d2c8dc6..abae70b51 100644
--- a/src/transports/cred.c
+++ b/src/transports/cred.c
@@ -165,6 +165,28 @@ int git_cred_ssh_key_new(
 	return 0;
 }
 
+int git_cred_ssh_key_from_agent(git_cred **cred, const char *username) {
+	git_cred_ssh_key *c;
+
+	assert(cred);
+
+	c = git__calloc(1, sizeof(git_cred_ssh_key));
+	GITERR_CHECK_ALLOC(c);
+
+	c->parent.credtype = GIT_CREDTYPE_SSH_KEY;
+	c->parent.free = ssh_key_free;
+
+	if (username) {
+		c->username = git__strdup(username);
+		GITERR_CHECK_ALLOC(c->username);
+	}
+
+	c->privatekey = NULL;
+
+	*cred = &c->parent;
+	return 0;
+}
+
 int git_cred_ssh_custom_new(
 	git_cred **cred,
 	const char *username,
diff --git a/src/transports/ssh.c b/src/transports/ssh.c
index 4a905e3c9..37f17080a 100644
--- a/src/transports/ssh.c
+++ b/src/transports/ssh.c
@@ -235,6 +235,50 @@ static int git_ssh_extract_url_parts(
 	return 0;
 }
 
+static int ssh_agent_auth(LIBSSH2_SESSION *session, git_cred_ssh_key *c) {
+	int rc = LIBSSH2_ERROR_NONE;
+
+	struct libssh2_agent_publickey *curr, *prev = NULL;
+
+	LIBSSH2_AGENT *agent = libssh2_agent_init(session);
+
+	if (agent == NULL)
+		return -1;
+
+	rc = libssh2_agent_connect(agent);
+
+	if (rc != LIBSSH2_ERROR_NONE)
+		goto shutdown;
+
+	rc = libssh2_agent_list_identities(agent);
+
+	if (rc != LIBSSH2_ERROR_NONE)
+		goto shutdown;
+
+	while (1) {
+		rc = libssh2_agent_get_identity(agent, &curr, prev);
+
+		if (rc < 0)
+			goto shutdown;
+
+		if (rc == 1)
+			goto shutdown;
+
+		rc = libssh2_agent_userauth(agent, c->username, curr);
+
+		if (rc == 0)
+			break;
+
+		prev = curr;
+	}
+
+shutdown:
+	libssh2_agent_disconnect(agent);
+	libssh2_agent_free(agent);
+
+	return rc;
+}
+
 static int _git_ssh_authenticate_session(
 	LIBSSH2_SESSION* session,
 	const char *user,
@@ -253,8 +297,14 @@ static int _git_ssh_authenticate_session(
 		case GIT_CREDTYPE_SSH_KEY: {
 			git_cred_ssh_key *c = (git_cred_ssh_key *)cred;
 			user = c->username ? c->username : user;
-			rc = libssh2_userauth_publickey_fromfile(
-				session, c->username, c->publickey, c->privatekey, c->passphrase);
+
+			if (c->privatekey)
+				rc = libssh2_userauth_publickey_fromfile(
+					session, c->username, c->publickey,
+					c->privatekey, c->passphrase);
+			else
+				rc = ssh_agent_auth(session, c);
+
 			break;
 		}
 		case GIT_CREDTYPE_SSH_CUSTOM: {
-- 
cgit v1.2.3


From 138e014c389a750715cf4f60cceef96692b4ea51 Mon Sep 17 00:00:00 2001
From: Alessandro Ghedini <alessandro@ghedini.me>
Date: Wed, 20 Nov 2013 14:20:32 +0100
Subject: transport: document ssh-agent authentication

---
 include/git2/transport.h | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/include/git2/transport.h b/include/git2/transport.h
index caabd0465..039321088 100644
--- a/include/git2/transport.h
+++ b/include/git2/transport.h
@@ -130,6 +130,18 @@ GIT_EXTERN(int) git_cred_ssh_key_new(
 	const char *privatekey,
 	const char *passphrase);
 
+/**
+ * Create a new ssh key credential object used for querying an ssh-agent.
+ * The supplied credential parameter will be internally duplicated.
+ *
+ * @param out The newly created credential object.
+ * @param username username to use to authenticate
+ * @return 0 for success or an error code for failure
+ */
+GIT_EXTERN(int) git_cred_ssh_key_from_agent(
+	git_cred **out,
+	const char *username);
+
 /**
  * Create an ssh key credential with a custom signing function.
  *
-- 
cgit v1.2.3


From 92f95a170c76ffde80010cbbd6b03c0bf8dded1d Mon Sep 17 00:00:00 2001
From: nulltoken <emeric.fermas@gmail.com>
Date: Sun, 12 May 2013 14:16:13 +0200
Subject: refs: Centralize reference creation logic

---
 src/refs.c | 51 ++++++++++++++++++++++++++-------------------------
 1 file changed, 26 insertions(+), 25 deletions(-)

diff --git a/src/refs.c b/src/refs.c
index 472a79890..7b4730cd8 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -335,6 +335,8 @@ static int reference__create(
 	git_reference *ref = NULL;
 	int error = 0;
 
+	assert(repo && name);
+
 	if (ref_out)
 		*ref_out = NULL;
 
@@ -347,10 +349,29 @@ static int reference__create(
 		return error;
 
 	if (oid != NULL) {
+		git_odb *odb;
+
 		assert(symbolic == NULL);
-		ref = git_reference__alloc(normalized, oid, NULL);
+
+		/* Sanity check the reference being created - target must exist. */
+		if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
+			return error;
+
+		if (!git_odb_exists(odb, oid)) {
+			giterr_set(GITERR_REFERENCE,
+				"Target OID for the reference doesn't exist on the repository");
+			return -1;
+		}
+
+		ref = git_reference__alloc(name, oid, NULL);
 	} else {
-		ref = git_reference__alloc_symbolic(normalized, symbolic);
+		char normalized_target[GIT_REFNAME_MAX];
+
+		if ((error = git_reference__normalize_name_lax(
+			normalized_target, sizeof(normalized_target), symbolic)) < 0)
+			return error;
+
+		ref = git_reference__alloc_symbolic(name, normalized_target);
 	}
 
 	GITERR_CHECK_ALLOC(ref);
@@ -375,20 +396,7 @@ int git_reference_create(
 	const git_oid *oid,
 	int force)
 {
-	git_odb *odb;
-	int error = 0;
-
-	assert(repo && name && oid);
-
-	/* Sanity check the reference being created - target must exist. */
-	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
-		return error;
-
-	if (!git_odb_exists(odb, oid)) {
-		giterr_set(GITERR_REFERENCE,
-			"Target OID for the reference doesn't exist on the repository");
-		return -1;
-	}
+	assert(oid);
 
 	return reference__create(ref_out, repo, name, oid, NULL, force);
 }
@@ -400,16 +408,9 @@ int git_reference_symbolic_create(
 	const char *target,
 	int force)
 {
-	char normalized[GIT_REFNAME_MAX];
-	int error = 0;
-
-	assert(repo && name && target);
-
-	if ((error = git_reference__normalize_name_lax(
-		normalized, sizeof(normalized), target)) < 0)
-		return error;
+	assert(target);
 
-	return reference__create(ref_out, repo, name, NULL, normalized, force);
+	return reference__create(ref_out, repo, name, NULL, target, force);
 }
 
 int git_reference_set_target(
-- 
cgit v1.2.3


From bba25f39a29c7913bab97fa6e8ac2ccb78ea33b6 Mon Sep 17 00:00:00 2001
From: nulltoken <emeric.fermas@gmail.com>
Date: Mon, 13 May 2013 16:21:09 +0200
Subject: refs: Introduce git_reference_create_with_log()

---
 include/git2/refs.h        | 43 ++++++++++++++++++++++++++++++++++
 src/refs.c                 | 58 +++++++++++++++++++++++++++++++++++++++++++---
 tests/refs/createwithlog.c | 52 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 150 insertions(+), 3 deletions(-)
 create mode 100644 tests/refs/createwithlog.c

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 4041947f6..049b7fa72 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -130,6 +130,49 @@ GIT_EXTERN(int) git_reference_symbolic_create(git_reference **out, git_repositor
  */
 GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force);
 
+/**
+ * Create a new direct reference and update the reflog with a given
+ * message.
+ *
+ * A direct reference (also called an object id reference) refers directly
+ * to a specific object id (a.k.a. OID or SHA) in the repository.  The id
+ * permanently refers to the object (although the reference itself can be
+ * moved).  For example, in libgit2 the direct ref "refs/tags/v0.17.0"
+ * refers to OID 5b9fac39d8a76b9139667c26a63e6b3f204b3977.
+ *
+ * The direct reference will be created in the repository and written to
+ * the disk.  The generated reference object must be freed by the user.
+ *
+ * Valid reference names must follow one of two patterns:
+ *
+ * 1. Top-level names must contain only capital letters and underscores,
+ *    and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
+ * 2. Names prefixed with "refs/" can be almost anything.  You must avoid
+ *    the characters '~', '^', ':', '\\', '?', '[', and '*', and the
+ *    sequences ".." and "@{" which have special meaning to revparse.
+ *
+ * This function will return an error if a reference already exists with the
+ * given name unless `force` is true, in which case it will be overwritten.
+ *
+ * @param out Pointer to the newly created reference
+ * @param repo Repository where that reference will live
+ * @param name The name of the reference
+ * @param id The object id pointed to by the reference.
+ * @param force Overwrite existing references
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message that has to be appended
+ * to the reflog
+ * @return 0 on success, EEXISTS, EINVALIDSPEC or an error code
+ */
+GIT_EXTERN(int) git_reference_create_with_log(
+	git_reference **out,
+	git_repository *repo,
+	const char *name,
+	const git_oid *id,
+	int force,
+	const git_signature *signature,
+	const char *log_message);
+
 /**
  * Get the OID pointed to by a direct reference.
  *
diff --git a/src/refs.c b/src/refs.c
index 7b4730cd8..e00041581 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -322,13 +322,44 @@ const char *git_reference_symbolic_target(const git_reference *ref)
 	return ref->target.symbolic;
 }
 
+static int feed_reflog(
+	const git_reference *ref,
+	const git_signature *signature,
+	const char *log_message)
+{
+
+	git_reflog *reflog = NULL;
+	git_oid peeled_ref_oid;
+	int error;
+
+	if ((error = git_reflog_read(&reflog, ref)) < 0)
+		goto cleanup;
+
+	if ((error = git_reference_name_to_id(&peeled_ref_oid,
+		git_reference_owner(ref), git_reference_name(ref))) < 0)
+			goto cleanup;
+
+	if ((error = git_reflog_append(reflog, &peeled_ref_oid, 
+		signature, log_message)) < 0)
+			goto cleanup;
+
+	error = git_reflog_write(reflog);
+
+cleanup:
+	git_reflog_free(reflog);
+
+	return 0;
+}
+
 static int reference__create(
 	git_reference **ref_out,
 	git_repository *repo,
 	const char *name,
 	const git_oid *oid,
 	const char *symbolic,
-	int force)
+	int force,
+	const git_signature *signature,
+	const char *log_message)
 {
 	char normalized[GIT_REFNAME_MAX];
 	git_refdb *refdb;
@@ -336,6 +367,7 @@ static int reference__create(
 	int error = 0;
 
 	assert(repo && name);
+	assert(!((signature == NULL) ^ (log_message == NULL)));
 
 	if (ref_out)
 		*ref_out = NULL;
@@ -381,6 +413,11 @@ static int reference__create(
 		return error;
 	}
 
+	if (log_message && (error = feed_reflog(ref, signature, log_message)) < 0) {
+		git_reference_free(ref);
+		return error;
+	}
+
 	if (ref_out == NULL)
 		git_reference_free(ref);
 	else
@@ -398,7 +435,22 @@ int git_reference_create(
 {
 	assert(oid);
 
-	return reference__create(ref_out, repo, name, oid, NULL, force);
+	return reference__create(ref_out, repo, name, oid, NULL, force, NULL, NULL);
+}
+
+int git_reference_create_with_log(
+	git_reference **ref_out,
+	git_repository *repo,
+	const char *name,
+	const git_oid *oid,
+	int force,
+	const git_signature *signature,
+	const char *log_message)
+{
+	assert(oid && signature && log_message);
+
+	return reference__create(
+		ref_out, repo, name, oid, NULL, force, signature, log_message);
 }
 
 int git_reference_symbolic_create(
@@ -410,7 +462,7 @@ int git_reference_symbolic_create(
 {
 	assert(target);
 
-	return reference__create(ref_out, repo, name, NULL, target, force);
+	return reference__create(ref_out, repo, name, NULL, target, force, NULL, NULL);
 }
 
 int git_reference_set_target(
diff --git a/tests/refs/createwithlog.c b/tests/refs/createwithlog.c
new file mode 100644
index 000000000..10e10cec8
--- /dev/null
+++ b/tests/refs/createwithlog.c
@@ -0,0 +1,52 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+#include "ref_helpers.h"
+
+static const char *current_master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
+static const char *current_head_target = "refs/heads/master";
+
+static git_repository *g_repo;
+
+void test_refs_createwithlog__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo.git");
+}
+
+void test_refs_createwithlog__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+void test_refs_createwithlog__creating_a_direct_reference_adds_a_reflog_entry(void)
+{
+	git_reference *reference;
+	git_oid id;
+	git_signature *signature;
+	git_reflog *reflog;
+	const git_reflog_entry *entry;
+
+	const char *name = "refs/heads/new-head";
+	const char *message = "You've been logged, mate!";
+
+	git_oid_fromstr(&id, current_master_tip);
+
+	cl_git_pass(git_signature_now(&signature, "foo", "foo@bar"));
+
+	cl_git_pass(
+		git_reference_create_with_log(&reference, g_repo, name, &id, 0, signature, message));
+
+	cl_git_pass(git_reflog_read(&reflog, reference));
+	cl_assert_equal_sz(1, git_reflog_entrycount(reflog));
+
+	entry = git_reflog_entry_byindex(reflog, 0);
+	cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) == 0);
+	cl_assert(git_oid_cmp(&id, &entry->oid_cur) == 0);
+	cl_assert_equal_s(message, entry->msg);
+
+	git_reflog_free(reflog);
+	git_reference_free(reference);
+	git_signature_free(signature);
+}
-- 
cgit v1.2.3


From 56ad3782e08cd1b2d26eee4014e77fac7a6c2414 Mon Sep 17 00:00:00 2001
From: nulltoken <emeric.fermas@gmail.com>
Date: Mon, 13 May 2013 17:44:39 +0200
Subject: refs: Introduce git_reference_symbolic_create_with_log()

---
 include/git2/refs.h        | 42 ++++++++++++++++++++++++++++++++++++++++++
 src/refs.c                 | 15 +++++++++++++++
 tests/refs/createwithlog.c | 31 +++++++++++++++++++++++++++++++
 3 files changed, 88 insertions(+)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 049b7fa72..e47077354 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -98,6 +98,48 @@ GIT_EXTERN(int) git_reference_dwim(git_reference **out, git_repository *repo, co
  */
 GIT_EXTERN(int) git_reference_symbolic_create(git_reference **out, git_repository *repo, const char *name, const char *target, int force);
 
+/**
+ * Create a new symbolic reference and update the reflog with a given
+ * message.
+ *
+ * A symbolic reference is a reference name that refers to another
+ * reference name.  If the other name moves, the symbolic name will move,
+ * too.  As a simple example, the "HEAD" reference might refer to
+ * "refs/heads/master" while on the "master" branch of a repository.
+ *
+ * The symbolic reference will be created in the repository and written to
+ * the disk.  The generated reference object must be freed by the user.
+ *
+ * Valid reference names must follow one of two patterns:
+ *
+ * 1. Top-level names must contain only capital letters and underscores,
+ *    and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
+ * 2. Names prefixed with "refs/" can be almost anything.  You must avoid
+ *    the characters '~', '^', ':', '\\', '?', '[', and '*', and the
+ *    sequences ".." and "@{" which have special meaning to revparse.
+ *
+ * This function will return an error if a reference already exists with the
+ * given name unless `force` is true, in which case it will be overwritten.
+ *
+ * @param out Pointer to the newly created reference
+ * @param repo Repository where that reference will live
+ * @param name The name of the reference
+ * @param target The target of the reference
+ * @param force Overwrite existing references
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message that has to be appended
+ * to the reflog
+ * @return 0 on success, EEXISTS, EINVALIDSPEC or an error code
+ */
+GIT_EXTERN(int) git_reference_symbolic_create_with_log(
+	git_reference **out,
+	git_repository *repo,
+	const char *name,
+	const char *target,
+	int force,
+	const git_signature *signature,
+	const char *log_message);
+
 /**
  * Create a new direct reference.
  *
diff --git a/src/refs.c b/src/refs.c
index e00041581..7c97c1627 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -465,6 +465,21 @@ int git_reference_symbolic_create(
 	return reference__create(ref_out, repo, name, NULL, target, force, NULL, NULL);
 }
 
+int git_reference_symbolic_create_with_log(
+	git_reference **ref_out,
+	git_repository *repo,
+	const char *name,
+	const char *target,
+	int force,
+	const git_signature *signature,
+	const char* log_message)
+{
+	assert(target && signature && log_message);
+
+	return reference__create(
+		ref_out, repo, name, NULL, target, force, signature, log_message);
+}
+
 int git_reference_set_target(
 	git_reference **out,
 	git_reference *ref,
diff --git a/tests/refs/createwithlog.c b/tests/refs/createwithlog.c
index 10e10cec8..34ab8067f 100644
--- a/tests/refs/createwithlog.c
+++ b/tests/refs/createwithlog.c
@@ -50,3 +50,34 @@ void test_refs_createwithlog__creating_a_direct_reference_adds_a_reflog_entry(vo
 	git_reference_free(reference);
 	git_signature_free(signature);
 }
+
+void test_refs_createwithlog__creating_a_symbolic_reference_adds_a_reflog_entry(void)
+{
+	git_reference *reference;
+	git_oid id;
+	git_signature *signature;
+	git_reflog *reflog;
+	const git_reflog_entry *entry;
+
+	const char *name = "ANOTHER_HEAD_TRACKER";
+	const char *message = "You've been logged, mate!";
+
+	git_oid_fromstr(&id, current_master_tip);
+
+	cl_git_pass(git_signature_now(&signature, "foo", "foo@bar"));
+
+	cl_git_pass(git_reference_symbolic_create_with_log(&reference, g_repo,
+		name, current_head_target, 0, signature, message));
+
+	cl_git_pass(git_reflog_read(&reflog, reference));
+	cl_assert_equal_sz(1, git_reflog_entrycount(reflog));
+
+	entry = git_reflog_entry_byindex(reflog, 0);
+	cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) == 0);
+	cl_assert(git_oid_cmp(&id, &entry->oid_cur) == 0);
+	cl_assert_equal_s(message, entry->msg);
+
+	git_reflog_free(reflog);
+	git_reference_free(reference);
+	git_signature_free(signature);
+}
-- 
cgit v1.2.3


From 14ab0e100e9474c5d1fda37fb0f4eec9ee0e9d13 Mon Sep 17 00:00:00 2001
From: nulltoken <emeric.fermas@gmail.com>
Date: Tue, 14 May 2013 16:07:33 +0200
Subject: refs: Introduce git_reference_set_target_with_log()

---
 include/git2/refs.h           | 23 ++++++++++++++++++
 src/refs.c                    | 36 ++++++++++++++++++++++++----
 tests/refs/settargetwithlog.c | 55 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 110 insertions(+), 4 deletions(-)
 create mode 100644 tests/refs/settargetwithlog.c

diff --git a/include/git2/refs.h b/include/git2/refs.h
index e47077354..172fdd284 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -334,6 +334,29 @@ GIT_EXTERN(int) git_reference_set_target(
 	git_reference *ref,
 	const git_oid *id);
 
+/**
+ * Create a new reference with the same name as the given reference but a
+ * different OID target and update the reflog with a given message.
+ *
+ * The reference must be a direct reference, otherwise this will fail.
+ *
+ * The new reference will be written to disk, overwriting the given reference.
+ *
+ * @param out Pointer to the newly created reference
+ * @param ref The reference
+ * @param id The new target OID for the reference
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message that has to be appended
+ * to the reflog
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_reference_set_target_with_log(
+	git_reference **out,
+	git_reference *ref,
+	const git_oid *id,
+	const git_signature *signature,
+	const char *log_message);
+
 /**
  * Rename an existing reference.
  *
diff --git a/src/refs.c b/src/refs.c
index 7c97c1627..75a7e1b95 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -480,21 +480,49 @@ int git_reference_symbolic_create_with_log(
 		ref_out, repo, name, NULL, target, force, signature, log_message);
 }
 
+static int ensure_is_an_updatable_direct_reference(git_reference *ref)
+{
+	if (ref->type == GIT_REF_OID)
+		return 0;
+
+	giterr_set(GITERR_REFERENCE, "Cannot set OID on symbolic reference");
+	return -1;
+}
+
 int git_reference_set_target(
 	git_reference **out,
 	git_reference *ref,
 	const git_oid *id)
 {
+	int error;
+
 	assert(out && ref && id);
 
-	if (ref->type != GIT_REF_OID) {
-		giterr_set(GITERR_REFERENCE, "Cannot set OID on symbolic reference");
-		return -1;
-	}
+	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
+		return error;
 
 	return git_reference_create(out, ref->db->repo, ref->name, id, 1);
 }
 
+int git_reference_set_target_with_log(
+	git_reference **out,
+	git_reference *ref,
+	const git_oid *id,
+	const git_signature *signature,
+	const char *log_message)
+{
+	int error;
+
+	assert(out && ref && id);
+	assert(signature && log_message);
+
+	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
+		return error;
+
+	return git_reference_create_with_log(
+		out, ref->db->repo, ref->name, id, 1, signature, log_message);
+}
+
 int git_reference_symbolic_set_target(
 	git_reference **out,
 	git_reference *ref,
diff --git a/tests/refs/settargetwithlog.c b/tests/refs/settargetwithlog.c
new file mode 100644
index 000000000..7bdd6d50b
--- /dev/null
+++ b/tests/refs/settargetwithlog.c
@@ -0,0 +1,55 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+#include "ref_helpers.h"
+
+static const char *br2_tip = "a4a7dce85cf63874e984719f4fdd239f5145052f";
+static const char *master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
+static const char *br2_name = "refs/heads/br2";
+
+static git_repository *g_repo;
+
+void test_refs_settargetwithlog__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo.git");
+}
+
+void test_refs_settargetwithlog__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+void test_refs_settargetwithlog__updating_a_direct_reference_adds_a_reflog_entry(void)
+{
+	git_reference *reference, *reference_out;
+	git_oid current_id, target_id;
+	git_signature *signature;
+	git_reflog *reflog;
+	const git_reflog_entry *entry;
+
+	const char *message = "You've been logged, mate!";
+
+	git_oid_fromstr(&current_id, br2_tip);
+	git_oid_fromstr(&target_id, master_tip);
+
+	cl_git_pass(git_reference_lookup(&reference, g_repo, br2_name));
+
+	cl_git_pass(git_signature_now(&signature, "foo", "foo@bar"));
+
+	cl_git_pass(git_reference_set_target_with_log(
+		&reference_out, reference, &target_id, signature, message));
+
+	cl_git_pass(git_reflog_read(&reflog, reference_out));
+
+	entry = git_reflog_entry_byindex(reflog, 0);
+	cl_assert(git_oid_cmp(&current_id, &entry->oid_old) == 0);
+	cl_assert(git_oid_cmp(&target_id, &entry->oid_cur) == 0);
+	cl_assert_equal_s(message, entry->msg);
+
+	git_reflog_free(reflog);
+	git_reference_free(reference_out);
+	git_reference_free(reference);
+	git_signature_free(signature);
+}
-- 
cgit v1.2.3


From ca84e058505a25b8f789ee1298a83e818b297ecc Mon Sep 17 00:00:00 2001
From: nulltoken <emeric.fermas@gmail.com>
Date: Tue, 14 May 2013 16:40:09 +0200
Subject: refs: Introduce git_reference_symbolic_set_target_with_log()

---
 include/git2/refs.h           | 25 +++++++++++++++++++++++++
 src/refs.c                    | 37 ++++++++++++++++++++++++++++++++-----
 tests/refs/settargetwithlog.c | 39 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 96 insertions(+), 5 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 172fdd284..2dc137692 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -317,6 +317,31 @@ GIT_EXTERN(int) git_reference_symbolic_set_target(
 	git_reference *ref,
 	const char *target);
 
+/**
+ * Create a new reference with the same name as the given reference but a
+ * different symbolic target  and update the reflog with a given message.
+ *
+ * The reference must be a symbolic reference, otherwise this will fail.
+ *
+ * The new reference will be written to disk, overwriting the given reference.
+ *
+ * The target name will be checked for validity.
+ * See `git_reference_create_symbolic()` for rules about valid names.
+ *
+ * @param out Pointer to the newly created reference
+ * @param ref The reference
+ * @param target The new target for the reference
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message that has to be appended
+ * @return 0 on success, EINVALIDSPEC or an error code
+ */
+GIT_EXTERN(int) git_reference_symbolic_set_target_with_log(
+	git_reference **out,
+	git_reference *ref,
+	const char *target,
+	const git_signature *signature,
+	const char *log_message);
+
 /**
  * Create a new reference with the same name as the given reference but a
  * different OID target. The reference must be a direct reference, otherwise
diff --git a/src/refs.c b/src/refs.c
index 75a7e1b95..eff6b3356 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -523,22 +523,49 @@ int git_reference_set_target_with_log(
 		out, ref->db->repo, ref->name, id, 1, signature, log_message);
 }
 
+static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
+{
+	if (ref->type == GIT_REF_SYMBOLIC)
+		return 0;
+
+	giterr_set(GITERR_REFERENCE, "Cannot set symbolic target on a direct reference");
+	return -1;
+}
+
 int git_reference_symbolic_set_target(
 	git_reference **out,
 	git_reference *ref,
 	const char *target)
 {
+	int error;
+
 	assert(out && ref && target);
 
-	if (ref->type != GIT_REF_SYMBOLIC) {
-		giterr_set(GITERR_REFERENCE,
-			"Cannot set symbolic target on a direct reference");
-		return -1;
-	}
+	if ((error = ensure_is_an_updatable_symbolic_reference(ref)) < 0)
+		return error;
 
 	return git_reference_symbolic_create(out, ref->db->repo, ref->name, target, 1);
 }
 
+int git_reference_symbolic_set_target_with_log(
+	git_reference **out,
+	git_reference *ref,
+	const char *target,
+	const git_signature *signature,
+	const char *log_message)
+{
+	int error;
+
+	assert(out && ref && target);
+	assert(signature && log_message);
+
+	if ((error = ensure_is_an_updatable_symbolic_reference(ref)) < 0)
+		return error;
+
+	return git_reference_symbolic_create_with_log(
+		out, ref->db->repo, ref->name, target, 1, signature, log_message);
+}
+
 int git_reference_rename(
 	git_reference **out,
 	git_reference *ref,
diff --git a/tests/refs/settargetwithlog.c b/tests/refs/settargetwithlog.c
index 7bdd6d50b..e1f73db56 100644
--- a/tests/refs/settargetwithlog.c
+++ b/tests/refs/settargetwithlog.c
@@ -53,3 +53,42 @@ void test_refs_settargetwithlog__updating_a_direct_reference_adds_a_reflog_entry
 	git_reference_free(reference);
 	git_signature_free(signature);
 }
+
+void test_refs_settargetwithlog__updating_a_symbolic_reference_adds_a_reflog_entry(void)
+{
+	git_reference *reference, *reference_out;
+	git_oid id;
+	git_signature *signature;
+	git_reflog *reflog;
+	const git_reflog_entry *entry;
+
+	const char *name = "HEAD";
+	const char *message = "You've been logged, mate!";
+
+	git_oid_fromstr(&id, br2_tip);
+
+	cl_git_pass(git_signature_now(&signature, "foo", "foo@bar"));
+	
+	cl_git_pass(git_reference_lookup(&reference, g_repo, name));
+
+	cl_assert_equal_s(
+		"refs/heads/master", git_reference_symbolic_target(reference));
+
+	cl_git_pass(git_reference_symbolic_set_target_with_log(&reference_out,
+		reference, br2_name, signature, message));
+
+	cl_assert_equal_s(
+		br2_name, git_reference_symbolic_target(reference_out));
+
+	cl_git_pass(git_reflog_read(&reflog, reference));
+
+	entry = git_reflog_entry_byindex(reflog, 0);
+	cl_assert(git_oid_streq(&entry->oid_old, master_tip) == 0);
+	cl_assert(git_oid_streq(&entry->oid_cur, br2_tip) == 0);
+	cl_assert_equal_s(message, entry->msg);
+
+	git_reflog_free(reflog);
+	git_reference_free(reference_out);
+	git_reference_free(reference);
+	git_signature_free(signature);
+}
-- 
cgit v1.2.3


From a6b508080cf73df7139c951feebb2281b9027752 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 30 Oct 2013 17:24:36 +0100
Subject: refs: adjust to the new reflog API

---
 src/refs.c                    | 18 +++---------------
 tests/refs/createwithlog.c    |  4 ++--
 tests/refs/settargetwithlog.c |  4 ++--
 3 files changed, 7 insertions(+), 19 deletions(-)

diff --git a/src/refs.c b/src/refs.c
index eff6b3356..d3d072cef 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -328,27 +328,15 @@ static int feed_reflog(
 	const char *log_message)
 {
 
-	git_reflog *reflog = NULL;
 	git_oid peeled_ref_oid;
 	int error;
 
-	if ((error = git_reflog_read(&reflog, ref)) < 0)
-		goto cleanup;
-
 	if ((error = git_reference_name_to_id(&peeled_ref_oid,
 		git_reference_owner(ref), git_reference_name(ref))) < 0)
-			goto cleanup;
-
-	if ((error = git_reflog_append(reflog, &peeled_ref_oid, 
-		signature, log_message)) < 0)
-			goto cleanup;
-
-	error = git_reflog_write(reflog);
-
-cleanup:
-	git_reflog_free(reflog);
+		return error;
 
-	return 0;
+	return git_reflog_append_to(git_reference_owner(ref), git_reference_name(ref),
+				    &peeled_ref_oid, signature, log_message);
 }
 
 static int reference__create(
diff --git a/tests/refs/createwithlog.c b/tests/refs/createwithlog.c
index 34ab8067f..ff36ffdcd 100644
--- a/tests/refs/createwithlog.c
+++ b/tests/refs/createwithlog.c
@@ -38,7 +38,7 @@ void test_refs_createwithlog__creating_a_direct_reference_adds_a_reflog_entry(vo
 	cl_git_pass(
 		git_reference_create_with_log(&reference, g_repo, name, &id, 0, signature, message));
 
-	cl_git_pass(git_reflog_read(&reflog, reference));
+	cl_git_pass(git_reflog_read(&reflog, g_repo, name));
 	cl_assert_equal_sz(1, git_reflog_entrycount(reflog));
 
 	entry = git_reflog_entry_byindex(reflog, 0);
@@ -69,7 +69,7 @@ void test_refs_createwithlog__creating_a_symbolic_reference_adds_a_reflog_entry(
 	cl_git_pass(git_reference_symbolic_create_with_log(&reference, g_repo,
 		name, current_head_target, 0, signature, message));
 
-	cl_git_pass(git_reflog_read(&reflog, reference));
+	cl_git_pass(git_reflog_read(&reflog, g_repo, name));
 	cl_assert_equal_sz(1, git_reflog_entrycount(reflog));
 
 	entry = git_reflog_entry_byindex(reflog, 0);
diff --git a/tests/refs/settargetwithlog.c b/tests/refs/settargetwithlog.c
index e1f73db56..99377dad7 100644
--- a/tests/refs/settargetwithlog.c
+++ b/tests/refs/settargetwithlog.c
@@ -41,7 +41,7 @@ void test_refs_settargetwithlog__updating_a_direct_reference_adds_a_reflog_entry
 	cl_git_pass(git_reference_set_target_with_log(
 		&reference_out, reference, &target_id, signature, message));
 
-	cl_git_pass(git_reflog_read(&reflog, reference_out));
+	cl_git_pass(git_reflog_read(&reflog, g_repo, br2_name));
 
 	entry = git_reflog_entry_byindex(reflog, 0);
 	cl_assert(git_oid_cmp(&current_id, &entry->oid_old) == 0);
@@ -80,7 +80,7 @@ void test_refs_settargetwithlog__updating_a_symbolic_reference_adds_a_reflog_ent
 	cl_assert_equal_s(
 		br2_name, git_reference_symbolic_target(reference_out));
 
-	cl_git_pass(git_reflog_read(&reflog, reference));
+	cl_git_pass(git_reflog_read(&reflog, g_repo, name));
 
 	entry = git_reflog_entry_byindex(reflog, 0);
 	cl_assert(git_oid_streq(&entry->oid_old, master_tip) == 0);
-- 
cgit v1.2.3


From 110df89317b56267b956574216d6611637860446 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 13 Nov 2013 13:36:37 +0100
Subject: refdb: add a `message` parameter for appending to the log

This is as yet unused.
---
 include/git2/sys/refdb_backend.h |  6 ++++--
 src/refdb.c                      |  9 ++++----
 src/refdb.h                      |  5 +++--
 src/refdb_fs.c                   | 46 ++++++++++++++++++++++++++++------------
 src/refs.c                       |  4 ++--
 5 files changed, 46 insertions(+), 24 deletions(-)

diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index 9cf5073fb..d5611d01e 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -93,11 +93,13 @@ struct git_refdb_backend {
 	 * must provide this function.
 	 */
 	int (*write)(git_refdb_backend *backend,
-		const git_reference *ref, int force);
+		     const git_reference *ref, int force,
+		     const char *message);
 
 	int (*rename)(
 		git_reference **out, git_refdb_backend *backend,
-		const char *old_name, const char *new_name, int force);
+		const char *old_name, const char *new_name, int force,
+		const char *message);
 
 	/**
 	 * Deletes the given reference from the refdb.  A refdb implementation
diff --git a/src/refdb.c b/src/refdb.c
index adb58806e..8f002ebcc 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -167,14 +167,14 @@ void git_refdb_iterator_free(git_reference_iterator *iter)
 	iter->free(iter);
 }
 
-int git_refdb_write(git_refdb *db, git_reference *ref, int force)
+int git_refdb_write(git_refdb *db, git_reference *ref, int force, const char *message)
 {
 	assert(db && db->backend);
 
 	GIT_REFCOUNT_INC(db);
 	ref->db = db;
 
-	return db->backend->write(db->backend, ref, force);
+	return db->backend->write(db->backend, ref, force, message);
 }
 
 int git_refdb_rename(
@@ -182,12 +182,13 @@ int git_refdb_rename(
 	git_refdb *db,
 	const char *old_name,
 	const char *new_name,
-	int force)
+	int force,
+	const char *message)
 {
 	int error;
 
 	assert(db && db->backend);
-	error = db->backend->rename(out, db->backend, old_name, new_name, force);
+	error = db->backend->rename(out, db->backend, old_name, new_name, force, message);
 	if (error < 0)
 		return error;
 
diff --git a/src/refdb.h b/src/refdb.h
index 0ee60d911..4dea20bd9 100644
--- a/src/refdb.h
+++ b/src/refdb.h
@@ -33,14 +33,15 @@ int git_refdb_rename(
 	git_refdb *db,
 	const char *old_name,
 	const char *new_name,
-	int force);
+	int force,
+	const char *message);
 
 int git_refdb_iterator(git_reference_iterator **out, git_refdb *db, const char *glob);
 int git_refdb_iterator_next(git_reference **out, git_reference_iterator *iter);
 int git_refdb_iterator_next_name(const char **out, git_reference_iterator *iter);
 void git_refdb_iterator_free(git_reference_iterator *iter);
 
-int git_refdb_write(git_refdb *refdb, git_reference *ref, int force);
+int git_refdb_write(git_refdb *refdb, git_reference *ref, int force, const char *message);
 int git_refdb_delete(git_refdb *refdb, const char *ref_name);
 
 int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name);
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 62d5c1047..6eb6ec418 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -910,7 +910,8 @@ fail:
 static int refdb_fs_backend__write(
 	git_refdb_backend *_backend,
 	const git_reference *ref,
-	int force)
+	int force,
+	const char *message)
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	int error;
@@ -974,7 +975,8 @@ static int refdb_fs_backend__rename(
 	git_refdb_backend *_backend,
 	const char *old_name,
 	const char *new_name,
-	int force)
+	int force,
+	const char *message)
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_reference *old, *new;
@@ -1264,6 +1266,32 @@ static int serialize_reflog_entry(
 	return git_buf_oom(buf);
 }
 
+static int lock_reflog(git_filebuf *file, refdb_fs_backend *backend, const char *refname)
+{
+	git_repository *repo;
+	git_buf log_path = GIT_BUF_INIT;
+	int error;
+
+	repo = backend->repo;
+
+	if (retrieve_reflog_path(&log_path, repo, refname) < 0)
+		return -1;
+
+	if (!git_path_isfile(git_buf_cstr(&log_path))) {
+		giterr_set(GITERR_INVALID,
+			"Log file for reference '%s' doesn't exist.", refname);
+		error = -1;
+		goto cleanup;
+	}
+
+	error = git_filebuf_open(file, git_buf_cstr(&log_path), 0, GIT_REFLOG_FILE_MODE);
+
+cleanup:
+	git_buf_free(&log_path);
+
+	return error;
+}
+
 static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflog)
 {
 	int error = -1;
@@ -1271,7 +1299,6 @@ static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflo
 	git_reflog_entry *entry;
 	git_repository *repo;
 	refdb_fs_backend *backend;
-	git_buf log_path = GIT_BUF_INIT;
 	git_buf log = GIT_BUF_INIT;
 	git_filebuf fbuf = GIT_FILEBUF_INIT;
 
@@ -1280,18 +1307,9 @@ static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflo
 	backend = (refdb_fs_backend *) _backend;
 	repo = backend->repo;
 
-	if (retrieve_reflog_path(&log_path, repo, reflog->ref_name) < 0)
+	if ((error = lock_reflog(&fbuf, backend, reflog->ref_name)) < 0)
 		return -1;
 
-	if (!git_path_isfile(git_buf_cstr(&log_path))) {
-		giterr_set(GITERR_INVALID,
-			"Log file for reference '%s' doesn't exist.", reflog->ref_name);
-		goto cleanup;
-	}
-
-	if ((error = git_filebuf_open(&fbuf, git_buf_cstr(&log_path), 0, GIT_REFLOG_FILE_MODE)) < 0)
-		goto cleanup;
-
 	git_vector_foreach(&reflog->entries, i, entry) {
 		if (serialize_reflog_entry(&log, &(entry->oid_old), &(entry->oid_cur), entry->committer, entry->msg) < 0)
 			goto cleanup;
@@ -1308,7 +1326,7 @@ cleanup:
 
 success:
 	git_buf_free(&log);
-	git_buf_free(&log_path);
+
 	return error;
 }
 
diff --git a/src/refs.c b/src/refs.c
index d3d072cef..dbbdda045 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -396,7 +396,7 @@ static int reference__create(
 
 	GITERR_CHECK_ALLOC(ref);
 
-	if ((error = git_refdb_write(refdb, ref, force)) < 0) {
+	if ((error = git_refdb_write(refdb, ref, force, log_message)) < 0) {
 		git_reference_free(ref);
 		return error;
 	}
@@ -579,7 +579,7 @@ int git_reference_rename(
 
 	should_head_be_updated = (error > 0);
 
-	if ((error = git_refdb_rename(out, ref->db, ref->name, new_name, force)) < 0)
+	if ((error = git_refdb_rename(out, ref->db, ref->name, new_name, force, NULL)) < 0)
 		return error;
 
 	/* Update HEAD it was poiting to the reference being renamed. */
-- 
cgit v1.2.3


From a57dd3b7a46c9a2f87f203f1ab372fa28e10e571 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 13 Nov 2013 18:15:20 +0100
Subject: reflog: integrate into the ref writing

Whenever a reference is created or updated, we need to write to the
reflog regardless of whether the user gave us a message, so we shouldn't
leave that to the ref frontend, but integrate it into the backend.

This also eliminates the race between ref update and writing to the
reflog, as we protect the reflog with the ref lock.

As an additional benefit, this reflog append on the backend happens by
appending to the file instead of parsing and rewriting it.
---
 include/git2/sys/refdb_backend.h |   4 +-
 src/refdb.c                      |   7 ++-
 src/refdb.h                      |   3 +-
 src/refdb_fs.c                   | 104 ++++++++++++++++++++++++++++---
 src/refs.c                       | 128 +++++++++++++++++----------------------
 src/stash.c                      |  21 ++-----
 tests/refs/createwithlog.c       |  32 ----------
 tests/refs/reflog/reflog.c       |   9 ++-
 tests/refs/settargetwithlog.c    |  39 ------------
 9 files changed, 171 insertions(+), 176 deletions(-)

diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index d5611d01e..131e1b5d0 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -94,12 +94,12 @@ struct git_refdb_backend {
 	 */
 	int (*write)(git_refdb_backend *backend,
 		     const git_reference *ref, int force,
-		     const char *message);
+		     const git_signature *who, const char *message);
 
 	int (*rename)(
 		git_reference **out, git_refdb_backend *backend,
 		const char *old_name, const char *new_name, int force,
-		const char *message);
+		const git_signature *who, const char *message);
 
 	/**
 	 * Deletes the given reference from the refdb.  A refdb implementation
diff --git a/src/refdb.c b/src/refdb.c
index 8f002ebcc..bc8c2b366 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -167,14 +167,14 @@ void git_refdb_iterator_free(git_reference_iterator *iter)
 	iter->free(iter);
 }
 
-int git_refdb_write(git_refdb *db, git_reference *ref, int force, const char *message)
+int git_refdb_write(git_refdb *db, git_reference *ref, int force, const git_signature *who, const char *message)
 {
 	assert(db && db->backend);
 
 	GIT_REFCOUNT_INC(db);
 	ref->db = db;
 
-	return db->backend->write(db->backend, ref, force, message);
+	return db->backend->write(db->backend, ref, force, who, message);
 }
 
 int git_refdb_rename(
@@ -183,12 +183,13 @@ int git_refdb_rename(
 	const char *old_name,
 	const char *new_name,
 	int force,
+	const git_signature *who,
 	const char *message)
 {
 	int error;
 
 	assert(db && db->backend);
-	error = db->backend->rename(out, db->backend, old_name, new_name, force, message);
+	error = db->backend->rename(out, db->backend, old_name, new_name, force, who, message);
 	if (error < 0)
 		return error;
 
diff --git a/src/refdb.h b/src/refdb.h
index 4dea20bd9..215ae17c5 100644
--- a/src/refdb.h
+++ b/src/refdb.h
@@ -34,6 +34,7 @@ int git_refdb_rename(
 	const char *old_name,
 	const char *new_name,
 	int force,
+	const git_signature *who,
 	const char *message);
 
 int git_refdb_iterator(git_reference_iterator **out, git_refdb *db, const char *glob);
@@ -41,7 +42,7 @@ int git_refdb_iterator_next(git_reference **out, git_reference_iterator *iter);
 int git_refdb_iterator_next_name(const char **out, git_reference_iterator *iter);
 void git_refdb_iterator_free(git_reference_iterator *iter);
 
-int git_refdb_write(git_refdb *refdb, git_reference *ref, int force, const char *message);
+int git_refdb_write(git_refdb *refdb, git_reference *ref, int force, const git_signature *who, const char *message);
 int git_refdb_delete(git_refdb *refdb, const char *ref_name);
 
 int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name);
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 6eb6ec418..2f7b43401 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -688,9 +688,8 @@ static int reference_path_available(
 	return 0;
 }
 
-static int loose_write(refdb_fs_backend *backend, const git_reference *ref)
+static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const git_reference *ref)
 {
-	git_filebuf file = GIT_FILEBUF_INIT;
 	git_buf ref_path = GIT_BUF_INIT;
 
 	/* Remove a possibly existing empty directory hierarchy
@@ -702,25 +701,29 @@ static int loose_write(refdb_fs_backend *backend, const git_reference *ref)
 	if (git_buf_joinpath(&ref_path, backend->path, ref->name) < 0)
 		return -1;
 
-	if (git_filebuf_open(&file, ref_path.ptr, GIT_FILEBUF_FORCE, GIT_REFS_FILE_MODE) < 0) {
+	if (git_filebuf_open(file, ref_path.ptr, GIT_FILEBUF_FORCE, GIT_REFS_FILE_MODE) < 0) {
 		git_buf_free(&ref_path);
 		return -1;
 	}
 
 	git_buf_free(&ref_path);
+	return 0;
+}
 
+static int loose_commit(git_filebuf *file, const git_reference *ref)
+{
 	if (ref->type == GIT_REF_OID) {
 		char oid[GIT_OID_HEXSZ + 1];
 		git_oid_nfmt(oid, sizeof(oid), &ref->target.oid);
 
-		git_filebuf_printf(&file, "%s\n", oid);
+		git_filebuf_printf(file, "%s\n", oid);
 	} else if (ref->type == GIT_REF_SYMBOLIC) {
-		git_filebuf_printf(&file, GIT_SYMREF "%s\n", ref->target.symbolic);
+		git_filebuf_printf(file, GIT_SYMREF "%s\n", ref->target.symbolic);
 	} else {
 		assert(0); /* don't let this happen */
 	}
 
-	return git_filebuf_commit(&file);
+	return git_filebuf_commit(file);
 }
 
 /*
@@ -907,13 +910,17 @@ fail:
 	return -1;
 }
 
+static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_signature *author, const char *message);
+
 static int refdb_fs_backend__write(
 	git_refdb_backend *_backend,
 	const git_reference *ref,
 	int force,
+	const git_signature *who,
 	const char *message)
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
+	git_filebuf file = GIT_FILEBUF_INIT;
 	int error;
 
 	assert(backend);
@@ -922,7 +929,16 @@ static int refdb_fs_backend__write(
 	if (error < 0)
 		return error;
 
-	return loose_write(backend, ref);
+	/* We need to perform the reflog append under the ref's lock */
+	if ((error = loose_lock(&file, backend, ref)) < 0)
+		return error;
+
+	if ((error = reflog_append(backend, ref, who, message)) < 0) {
+		git_filebuf_cleanup(&file);
+		return error;
+	}
+
+	return loose_commit(&file, ref);
 }
 
 static int refdb_fs_backend__delete(
@@ -970,16 +986,20 @@ static int refdb_fs_backend__delete(
 	return packed_write(backend);
 }
 
+static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_name, const char *new_name);
+
 static int refdb_fs_backend__rename(
 	git_reference **out,
 	git_refdb_backend *_backend,
 	const char *old_name,
 	const char *new_name,
 	int force,
+	const git_signature *who,
 	const char *message)
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_reference *old, *new;
+	git_filebuf file = GIT_FILEBUF_INIT;
 	int error;
 
 	assert(backend);
@@ -1000,7 +1020,28 @@ static int refdb_fs_backend__rename(
 		return -1;
 	}
 
-	if ((error = loose_write(backend, new)) < 0 || out == NULL) {
+	if ((error = loose_lock(&file, backend, new)) < 0) {
+		git_reference_free(new);
+		return error;
+	}
+
+	/* Try to rename the refog; it's ok if the old doesn't exist */
+	error = refdb_reflog_fs__rename(_backend, old_name, new_name);
+	if (((error == 0) || (error == GIT_ENOTFOUND)) &&
+	    ((error = reflog_append(backend, new, who, message)) < 0)) {
+		git_reference_free(new);
+		git_filebuf_cleanup(&file);
+		return error;
+	}
+
+	if (error < 0) {
+		git_reference_free(new);
+		git_filebuf_cleanup(&file);
+		return error;
+	}
+
+
+	if ((error = loose_commit(&file, new)) < 0 || out == NULL) {
 		git_reference_free(new);
 		return error;
 	}
@@ -1330,6 +1371,48 @@ success:
 	return error;
 }
 
+/* Append to the reflog, must be called under reference lock */
+static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_signature *who, const char *message)
+{
+	int error;
+	git_oid old_id, new_id;
+	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
+	git_repository *repo = backend->repo;
+
+	/* Creation of symbolic references doesn't get a reflog entry */
+	if (ref->type == GIT_REF_SYMBOLIC)
+		return 0;
+
+	error = git_reference_name_to_id(&old_id, repo, ref->name);
+	if (error == GIT_ENOTFOUND) {
+		memset(&old_id, 0, sizeof(git_oid));
+		error = 0;
+	}
+	if (error < 0)
+		return error;
+
+	git_oid_cpy(&new_id, git_reference_target(ref));
+
+	if ((error = serialize_reflog_entry(&buf, &old_id, &new_id, who, message)) < 0)
+		goto cleanup;
+
+	if ((error = retrieve_reflog_path(&path, repo, ref->name)) < 0)
+		goto cleanup;
+
+	if (((error = git_futils_mkpath2file(git_buf_cstr(&path), 0777)) < 0) &&
+	    (error != GIT_EEXISTS)) {
+		goto cleanup;
+	}
+
+	error = git_futils_writebuffer(&buf, git_buf_cstr(&path), O_WRONLY|O_CREAT|O_APPEND, GIT_REFLOG_FILE_MODE);
+
+cleanup:
+	git_buf_free(&buf);
+	git_buf_free(&path);
+
+	return error;
+}
+
 static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_name, const char *new_name)
 {
 	int error = 0, fd;
@@ -1358,6 +1441,11 @@ static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_
 	if (git_buf_joinpath(&new_path, git_buf_cstr(&temp_path), git_buf_cstr(&normalized)) < 0)
 		return -1;
 
+	if (!git_path_exists(git_buf_cstr(&old_path))) {
+		error = GIT_ENOTFOUND;
+		goto cleanup;
+	}
+
 	/*
 	 * Move the reflog to a temporary place. This two-phase renaming is required
 	 * in order to cope with funny renaming use cases when one tries to move a reference
diff --git a/src/refs.c b/src/refs.c
index dbbdda045..598d6873c 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -21,6 +21,7 @@
 #include <git2/refs.h>
 #include <git2/refdb.h>
 #include <git2/sys/refs.h>
+#include <git2/signature.h>
 
 GIT__USE_STRMAP;
 
@@ -322,23 +323,6 @@ const char *git_reference_symbolic_target(const git_reference *ref)
 	return ref->target.symbolic;
 }
 
-static int feed_reflog(
-	const git_reference *ref,
-	const git_signature *signature,
-	const char *log_message)
-{
-
-	git_oid peeled_ref_oid;
-	int error;
-
-	if ((error = git_reference_name_to_id(&peeled_ref_oid,
-		git_reference_owner(ref), git_reference_name(ref))) < 0)
-		return error;
-
-	return git_reflog_append_to(git_reference_owner(ref), git_reference_name(ref),
-				    &peeled_ref_oid, signature, log_message);
-}
-
 static int reference__create(
 	git_reference **ref_out,
 	git_repository *repo,
@@ -355,7 +339,7 @@ static int reference__create(
 	int error = 0;
 
 	assert(repo && name);
-	assert(!((signature == NULL) ^ (log_message == NULL)));
+	assert(symbolic || signature);
 
 	if (ref_out)
 		*ref_out = NULL;
@@ -396,12 +380,7 @@ static int reference__create(
 
 	GITERR_CHECK_ALLOC(ref);
 
-	if ((error = git_refdb_write(refdb, ref, force, log_message)) < 0) {
-		git_reference_free(ref);
-		return error;
-	}
-
-	if (log_message && (error = feed_reflog(ref, signature, log_message)) < 0) {
+	if ((error = git_refdb_write(refdb, ref, force, signature, log_message)) < 0) {
 		git_reference_free(ref);
 		return error;
 	}
@@ -421,9 +400,22 @@ int git_reference_create(
 	const git_oid *oid,
 	int force)
 {
+	git_signature *who;
+	int error;
+
 	assert(oid);
 
-	return reference__create(ref_out, repo, name, oid, NULL, force, NULL, NULL);
+	/* Should we return an error if there is no default? */
+	if (((error = git_signature_default(&who, repo)) < 0) &&
+	    ((error = git_signature_now(&who, "unknown", "unknown")) < 0)) {
+		return error;
+	}
+
+	error = reference__create(ref_out, repo, name, oid, NULL, force, who, NULL);
+
+	git_signature_free(who);
+
+	return error;
 }
 
 int git_reference_create_with_log(
@@ -449,25 +441,9 @@ int git_reference_symbolic_create(
 	int force)
 {
 	assert(target);
-
 	return reference__create(ref_out, repo, name, NULL, target, force, NULL, NULL);
 }
 
-int git_reference_symbolic_create_with_log(
-	git_reference **ref_out,
-	git_repository *repo,
-	const char *name,
-	const char *target,
-	int force,
-	const git_signature *signature,
-	const char* log_message)
-{
-	assert(target && signature && log_message);
-
-	return reference__create(
-		ref_out, repo, name, NULL, target, force, signature, log_message);
-}
-
 static int ensure_is_an_updatable_direct_reference(git_reference *ref)
 {
 	if (ref->type == GIT_REF_OID)
@@ -535,36 +511,15 @@ int git_reference_symbolic_set_target(
 	return git_reference_symbolic_create(out, ref->db->repo, ref->name, target, 1);
 }
 
-int git_reference_symbolic_set_target_with_log(
-	git_reference **out,
-	git_reference *ref,
-	const char *target,
-	const git_signature *signature,
-	const char *log_message)
-{
-	int error;
-
-	assert(out && ref && target);
-	assert(signature && log_message);
-
-	if ((error = ensure_is_an_updatable_symbolic_reference(ref)) < 0)
-		return error;
-
-	return git_reference_symbolic_create_with_log(
-		out, ref->db->repo, ref->name, target, 1, signature, log_message);
-}
-
-int git_reference_rename(
-	git_reference **out,
-	git_reference *ref,
-	const char *new_name,
-	int force)
+static int reference__rename(git_reference **out, git_reference *ref, const char *new_name, int force,
+				 const git_signature *signature, const char *message)
 {
 	unsigned int normalization_flags;
 	char normalized[GIT_REFNAME_MAX];
 	bool should_head_be_updated = false;
 	int error = 0;
-	int reference_has_log;
+
+	assert(ref && new_name && signature);
 
 	normalization_flags = ref->type == GIT_REF_SYMBOLIC ?
 		GIT_REF_FORMAT_ALLOW_ONELEVEL : GIT_REF_FORMAT_NORMAL;
@@ -573,13 +528,14 @@ int git_reference_rename(
 			normalized, sizeof(normalized), new_name, normalization_flags)) < 0)
 		return error;
 
+
 	/* Check if we have to update HEAD. */
 	if ((error = git_branch_is_head(ref)) < 0)
 		return error;
 
 	should_head_be_updated = (error > 0);
 
-	if ((error = git_refdb_rename(out, ref->db, ref->name, new_name, force, NULL)) < 0)
+	if ((error = git_refdb_rename(out, ref->db, ref->name, new_name, force, signature, message)) < 0)
 		return error;
 
 	/* Update HEAD it was poiting to the reference being renamed. */
@@ -589,15 +545,41 @@ int git_reference_rename(
 		return error;
 	}
 
-	/* Rename the reflog file, if it exists. */
-	reference_has_log = git_reference_has_log(ref);
-	if (reference_has_log < 0)
-		return reference_has_log;
+	return 0;
+}
+
 
-	if (reference_has_log && (error = git_reflog_rename(git_reference_owner(ref), git_reference_name(ref), new_name)) < 0)
+int git_reference_rename(
+	git_reference **out,
+	git_reference *ref,
+	const char *new_name,
+	int force)
+{
+	git_signature *who;
+	int error;
+
+	/* Should we return an error if there is no default? */
+	if (((error = git_signature_default(&who, ref->db->repo)) < 0) &&
+	    ((error = git_signature_now(&who, "unknown", "unknown")) < 0)) {
 		return error;
+	}
 
-	return 0;
+	error = reference__rename(out, ref, new_name, force, who, NULL);
+
+	git_signature_free(who);
+
+	return error;
+}
+
+int git_reference_rename_with_log(
+	git_reference **out,
+	git_reference *ref,
+	const char *new_name,
+	int force,
+	const git_signature *who,
+	const char * message)
+{
+	return reference__rename(out, ref, new_name, force, who, message);
 }
 
 int git_reference_resolve(git_reference **ref_out, const git_reference *ref)
diff --git a/src/stash.c b/src/stash.c
index 083c2a4cd..66b1cd7c5 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -412,25 +412,12 @@ static int update_reflog(
 	const char *message)
 {
 	git_reference *stash;
-	git_reflog *reflog = NULL;
 	int error;
 
-	if ((error = git_reference_create(&stash, repo, GIT_REFS_STASH_FILE, w_commit_oid, 1)) < 0)
-		goto cleanup;
+	error = git_reference_create_with_log(&stash, repo, GIT_REFS_STASH_FILE, w_commit_oid, 1, stasher, message);
 
 	git_reference_free(stash);
 
-	if ((error = git_reflog_read(&reflog, repo, GIT_REFS_STASH_FILE) < 0))
-		goto cleanup;
-
-	if ((error = git_reflog_append(reflog, w_commit_oid, stasher, message)) < 0)
-		goto cleanup;
-
-	if ((error = git_reflog_write(reflog)) < 0)
-		goto cleanup;
-
-cleanup:
-	git_reflog_free(reflog);
 	return error;
 }
 
@@ -636,7 +623,11 @@ int git_stash_drop(
 		entry = git_reflog_entry_byindex(reflog, 0);
 
 		git_reference_free(stash);
-		error = git_reference_create(&stash, repo, GIT_REFS_STASH_FILE, &entry->oid_cur, 1);
+		if ((error = git_reference_create(&stash, repo, GIT_REFS_STASH_FILE, &entry->oid_cur, 1) < 0))
+			goto cleanup;
+
+		/* We need to undo the writing that we just did */
+		error = git_reflog_write(reflog);
 	}
 
 cleanup:
diff --git a/tests/refs/createwithlog.c b/tests/refs/createwithlog.c
index ff36ffdcd..0fe81df91 100644
--- a/tests/refs/createwithlog.c
+++ b/tests/refs/createwithlog.c
@@ -6,7 +6,6 @@
 #include "ref_helpers.h"
 
 static const char *current_master_tip = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
-static const char *current_head_target = "refs/heads/master";
 
 static git_repository *g_repo;
 
@@ -50,34 +49,3 @@ void test_refs_createwithlog__creating_a_direct_reference_adds_a_reflog_entry(vo
 	git_reference_free(reference);
 	git_signature_free(signature);
 }
-
-void test_refs_createwithlog__creating_a_symbolic_reference_adds_a_reflog_entry(void)
-{
-	git_reference *reference;
-	git_oid id;
-	git_signature *signature;
-	git_reflog *reflog;
-	const git_reflog_entry *entry;
-
-	const char *name = "ANOTHER_HEAD_TRACKER";
-	const char *message = "You've been logged, mate!";
-
-	git_oid_fromstr(&id, current_master_tip);
-
-	cl_git_pass(git_signature_now(&signature, "foo", "foo@bar"));
-
-	cl_git_pass(git_reference_symbolic_create_with_log(&reference, g_repo,
-		name, current_head_target, 0, signature, message));
-
-	cl_git_pass(git_reflog_read(&reflog, g_repo, name));
-	cl_assert_equal_sz(1, git_reflog_entrycount(reflog));
-
-	entry = git_reflog_entry_byindex(reflog, 0);
-	cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) == 0);
-	cl_assert(git_oid_cmp(&id, &entry->oid_cur) == 0);
-	cl_assert_equal_s(message, entry->msg);
-
-	git_reflog_free(reflog);
-	git_reference_free(reference);
-	git_signature_free(signature);
-}
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index bcd224270..60085791c 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -49,17 +49,20 @@ static void assert_appends(const git_signature *committer, const git_oid *oid)
 
 	/* Read and parse the reflog for this branch */
 	cl_git_pass(git_reflog_read(&reflog, repo2, new_ref));
-	cl_assert_equal_i(2, (int)git_reflog_entrycount(reflog));
+	cl_assert_equal_i(3, (int)git_reflog_entrycount(reflog));
+
+	/* The first one was the creation of the branch */
+	entry = git_reflog_entry_byindex(reflog, 2);
+	cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) == 0);
 
 	entry = git_reflog_entry_byindex(reflog, 1);
 	assert_signature(committer, entry->committer);
-	cl_assert(git_oid_streq(&entry->oid_old, GIT_OID_HEX_ZERO) == 0);
+	cl_assert(git_oid_cmp(oid, &entry->oid_old) == 0);
 	cl_assert(git_oid_cmp(oid, &entry->oid_cur) == 0);
 	cl_assert(entry->msg == NULL);
 
 	entry = git_reflog_entry_byindex(reflog, 0);
 	assert_signature(committer, entry->committer);
-	cl_assert(git_oid_cmp(oid, &entry->oid_old) == 0);
 	cl_assert(git_oid_cmp(oid, &entry->oid_cur) == 0);
 	cl_assert_equal_s(commit_msg, entry->msg);
 
diff --git a/tests/refs/settargetwithlog.c b/tests/refs/settargetwithlog.c
index 99377dad7..cfa1c99d5 100644
--- a/tests/refs/settargetwithlog.c
+++ b/tests/refs/settargetwithlog.c
@@ -53,42 +53,3 @@ void test_refs_settargetwithlog__updating_a_direct_reference_adds_a_reflog_entry
 	git_reference_free(reference);
 	git_signature_free(signature);
 }
-
-void test_refs_settargetwithlog__updating_a_symbolic_reference_adds_a_reflog_entry(void)
-{
-	git_reference *reference, *reference_out;
-	git_oid id;
-	git_signature *signature;
-	git_reflog *reflog;
-	const git_reflog_entry *entry;
-
-	const char *name = "HEAD";
-	const char *message = "You've been logged, mate!";
-
-	git_oid_fromstr(&id, br2_tip);
-
-	cl_git_pass(git_signature_now(&signature, "foo", "foo@bar"));
-	
-	cl_git_pass(git_reference_lookup(&reference, g_repo, name));
-
-	cl_assert_equal_s(
-		"refs/heads/master", git_reference_symbolic_target(reference));
-
-	cl_git_pass(git_reference_symbolic_set_target_with_log(&reference_out,
-		reference, br2_name, signature, message));
-
-	cl_assert_equal_s(
-		br2_name, git_reference_symbolic_target(reference_out));
-
-	cl_git_pass(git_reflog_read(&reflog, g_repo, name));
-
-	entry = git_reflog_entry_byindex(reflog, 0);
-	cl_assert(git_oid_streq(&entry->oid_old, master_tip) == 0);
-	cl_assert(git_oid_streq(&entry->oid_cur, br2_tip) == 0);
-	cl_assert_equal_s(message, entry->msg);
-
-	git_reflog_free(reflog);
-	git_reference_free(reference_out);
-	git_reference_free(reference);
-	git_signature_free(signature);
-}
-- 
cgit v1.2.3


From 13c9e44af9424e1fc478693f0d64fbf7082c9665 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 14 Nov 2013 19:41:09 +0100
Subject: reflog: remove git_reflog_append_to()

This was a convenience method for the refs front-end to do the reflog
writing. This is now done in the backend and it has no more reason for
being.
---
 include/git2/reflog.h      | 19 +------------------
 src/reflog.c               | 19 -------------------
 tests/refs/reflog/reflog.c | 23 -----------------------
 3 files changed, 1 insertion(+), 60 deletions(-)

diff --git a/include/git2/reflog.h b/include/git2/reflog.h
index 2d1b6eeaa..df06e1b8e 100644
--- a/include/git2/reflog.h
+++ b/include/git2/reflog.h
@@ -47,7 +47,7 @@ GIT_EXTERN(int) git_reflog_read(git_reflog **out, git_repository *repo,  const c
 GIT_EXTERN(int) git_reflog_write(git_reflog *reflog);
 
 /**
- * Add a new entry to the reflog.
+ * Add a new entry to the in-memory reflog.
  *
  * `msg` is optional and can be NULL.
  *
@@ -59,23 +59,6 @@ GIT_EXTERN(int) git_reflog_write(git_reflog *reflog);
  */
 GIT_EXTERN(int) git_reflog_append(git_reflog *reflog, const git_oid *id, const git_signature *committer, const char *msg);
 
-/**
- * Add a new entry to the named reflog.
- *
- * This utility function loads the named reflog, appends to it and
- * writes it back out to the backend.
- *
- * `msg` is optional and can be NULL.
- *
- * @param repo the repository to act on
- * @param name the reflog's name
- * @param id the OID the reference is now pointing to
- * @param committer the signature of the committer
- * @param msg the reflog message
- * @return 0 or an error code
- */
-GIT_EXTERN(int) git_reflog_append_to(git_repository *repo, const char *name, const git_oid *id, const git_signature *committer, const char *msg);
-
 /**
  * Rename a reflog
  *
diff --git a/src/reflog.c b/src/reflog.c
index cebb87d86..9b2b201bf 100644
--- a/src/reflog.c
+++ b/src/reflog.c
@@ -230,22 +230,3 @@ int git_reflog_drop(git_reflog *reflog, size_t idx, int rewrite_previous_entry)
 
 	return 0;
 }
-
-int git_reflog_append_to(git_repository *repo, const char *name, const git_oid *id,
-			 const git_signature *committer, const char *msg)
-{
-	int error;
-	git_reflog *reflog;
-
-	if ((error = git_reflog_read(&reflog, repo, name)) < 0)
-		return error;
-
-	if ((error = git_reflog_append(reflog, id, committer, msg)) < 0)
-		goto cleanup;
-
-	error = git_reflog_write(reflog);
-
-cleanup:
-	git_reflog_free(reflog);
-	return error;
-}
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index 60085791c..9ac15d556 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -100,29 +100,6 @@ void test_refs_reflog_reflog__append_then_read(void)
 	git_signature_free(committer);
 }
 
-void test_refs_reflog_reflog__append_to_then_read(void)
-{
-	/* write a reflog for a given reference and ensure it can be read back */
-	git_reference *ref;
-	git_oid oid;
-	git_signature *committer;
-
-	/* Create a new branch pointing at the HEAD */
-	git_oid_fromstr(&oid, current_master_tip);
-	cl_git_pass(git_reference_create(&ref, g_repo, new_ref, &oid, 0));
-	git_reference_free(ref);
-
-	cl_git_pass(git_signature_now(&committer, "foo", "foo@bar"));
-
-	cl_git_fail(git_reflog_append_to(g_repo, new_ref, &oid, committer, "no inner\nnewline"));
-	cl_git_pass(git_reflog_append_to(g_repo, new_ref, &oid, committer, NULL));
-	cl_git_pass(git_reflog_append_to(g_repo, new_ref, &oid, committer, commit_msg "\n"));
-
-	assert_appends(committer, &oid);
-
-	git_signature_free(committer);
-}
-
 void test_refs_reflog_reflog__renaming_the_reference_moves_the_reflog(void)
 {
 	git_reference *master, *new_master;
-- 
cgit v1.2.3


From 758f2f1022d09e1423f3cd8c5d52ca633e9fc317 Mon Sep 17 00:00:00 2001
From: Alessandro Ghedini <alessandro@ghedini.me>
Date: Wed, 27 Nov 2013 14:17:40 +0100
Subject: posix: Solaris doesn't have strnlen either

---
 src/posix.h              | 7 ++++++-
 src/win32/mingw-compat.h | 5 -----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/posix.h b/src/posix.h
index 14c92b93d..f529914fe 100644
--- a/src/posix.h
+++ b/src/posix.h
@@ -89,7 +89,12 @@ extern struct tm * p_gmtime_r (const time_t *timer, struct tm *result);
 #	include "unix/posix.h"
 #endif
 
-#ifndef __MINGW32__
+#if defined(__MINGW32__) || defined(__sun)
+GIT_INLINE(size_t) p_strnlen(const char *s, size_t maxlen) {
+	const char *end = memchr(s, 0, maxlen);
+	return end ? (size_t)(end - s) : maxlen;
+}
+#else
 # define p_strnlen strnlen
 #endif
 
diff --git a/src/win32/mingw-compat.h b/src/win32/mingw-compat.h
index fe0abfb54..7b97b48db 100644
--- a/src/win32/mingw-compat.h
+++ b/src/win32/mingw-compat.h
@@ -19,11 +19,6 @@
 # define S_IFLNK _S_IFLNK
 # define S_ISLNK(m) (((m) & _S_IFMT) == _S_IFLNK)
 
-GIT_INLINE(size_t) p_strnlen(const char *s, size_t maxlen) {
-	const char *end = memchr(s, 0, maxlen);
-	return end ? (size_t)(end - s) : maxlen;
-}
-
 #endif
 
 #endif /* INCLUDE_mingw_compat__ */
-- 
cgit v1.2.3


From 27f680a9981202ed47764232f67a8d043de9286c Mon Sep 17 00:00:00 2001
From: Nicolas Kaiser <nikai@nikai.net>
Date: Sun, 1 Dec 2013 10:35:56 +0100
Subject: fix typos in docs

---
 docs/diff-internals.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/diff-internals.md b/docs/diff-internals.md
index cf8ad5383..da4c5a17c 100644
--- a/docs/diff-internals.md
+++ b/docs/diff-internals.md
@@ -21,7 +21,7 @@ content, everything goes through diff drivers that are implemented in
 External Objects
 ----------------
 
-* `git_diff_options` repesents user choices about how a diff should be
+* `git_diff_options` represents user choices about how a diff should be
   performed and is passed to most diff generating functions.
 * `git_diff_file` represents an item on one side of a possible delta
 * `git_diff_delta` represents a pair of items that have changed in some
@@ -37,7 +37,7 @@ External Objects
   header that compactly represents that information, and it will have a
   number of lines of context surrounding added and deleted lines.
 * A `line` is simple a line of data along with a `git_diff_line_t` value
-  that tells how the data should be interpretted (e.g. context or added).
+  that tells how the data should be interpreted (e.g. context or added).
 
 Internal Objects
 ----------------
-- 
cgit v1.2.3


From 726b75d1b839649ee118e5521f52c669f4664d45 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 2 Dec 2013 11:32:37 -0800
Subject: Improve iconv finding for cmake

* add FindIconv helper for CMake iconv detection
* only default using iconv to ON for MacOS
* update pkg-config generation to include iconv dependency better
---
 CMakeLists.txt                | 23 ++++++++++++++++-------
 cmake/Modules/FindIconv.cmake | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 58 insertions(+), 7 deletions(-)
 create mode 100644 cmake/Modules/FindIconv.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ac1032acf..9c19a5a79 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -34,7 +34,7 @@ OPTION( ANDROID				"Build for android NDK"	 				OFF )
 OPTION( USE_ICONV			"Link with and use iconv library" 		OFF )
 OPTION( USE_SSH				"Link with libssh to enable SSH support" ON )
 
-IF(APPLE)
+IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	SET( USE_ICONV ON )
 ENDIF()
 
@@ -82,12 +82,6 @@ FUNCTION(TARGET_OS_LIBRARIES target)
 		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -lrt" PARENT_SCOPE)
 	ENDIF()
 
-	IF(USE_ICONV)
-		TARGET_LINK_LIBRARIES(${target} iconv)
-		ADD_DEFINITIONS(-DGIT_USE_ICONV)
-		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -liconv" PARENT_SCOPE)
-	ENDIF()
-
 	IF(THREADSAFE)
 		TARGET_LINK_LIBRARIES(${target} ${CMAKE_THREAD_LIBS_INIT})
 	ENDIF()
@@ -190,6 +184,7 @@ ELSE()
 	FILE(GLOB SRC_ZLIB deps/zlib/*.c deps/zlib/*.h)
 ENDIF()
 
+# Optional external dependency: libssh2
 IF (USE_SSH AND NOT MINGW)
 	FIND_PACKAGE(LIBSSH2 QUIET)
 ENDIF()
@@ -200,6 +195,18 @@ IF (LIBSSH2_FOUND)
 	SET(SSH_LIBRARIES ${LIBSSH2_LIBRARIES})
 ENDIF()
 
+# Optional external dependency: iconv
+IF (USE_ICONV)
+	FIND_PACKAGE(ICONV QUIET)
+ENDIF()
+IF (ICONV_FOUND)
+	ADD_DEFINITIONS(-DGIT_USE_ICONV)
+	IF(ICONV_LIBRARIES MATCHES "libiconv")
+		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -liconv")
+	ELSE()
+		SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} iconv")
+	ENDIF()
+ENDIF()
 
 # Platform specific compilation flags
 IF (MSVC)
@@ -353,6 +360,7 @@ ENDIF()
 ADD_LIBRARY(git2 ${SRC_H} ${SRC_GIT2} ${SRC_OS} ${SRC_ZLIB} ${SRC_HTTP} ${SRC_REGEX} ${SRC_SHA1} ${WIN_RC})
 TARGET_LINK_LIBRARIES(git2 ${SSL_LIBRARIES})
 TARGET_LINK_LIBRARIES(git2 ${SSH_LIBRARIES})
+TARGET_LINK_LIBRARIES(git2 ${ICONV_LIBRARIES})
 TARGET_OS_LIBRARIES(git2)
 
 # Workaround for Cmake bug #0011240 (see http://public.kitware.com/Bug/view.php?id=11240)
@@ -418,6 +426,7 @@ IF (BUILD_CLAR)
 
 	TARGET_LINK_LIBRARIES(libgit2_clar ${SSL_LIBRARIES})
 	TARGET_LINK_LIBRARIES(libgit2_clar ${SSH_LIBRARIES})
+	TARGET_LINK_LIBRARIES(libgit2_clar ${ICONV_LIBRARIES})
 	TARGET_OS_LIBRARIES(libgit2_clar)
 	MSVC_SPLIT_SOURCES(libgit2_clar)
 
diff --git a/cmake/Modules/FindIconv.cmake b/cmake/Modules/FindIconv.cmake
new file mode 100644
index 000000000..fb6d1e210
--- /dev/null
+++ b/cmake/Modules/FindIconv.cmake
@@ -0,0 +1,42 @@
+# - Try to find Iconv
+# Once done this will define
+#
+# ICONV_FOUND - system has Iconv
+# ICONV_INCLUDE_DIR - the Iconv include directory
+# ICONV_LIBRARIES - Link these to use Iconv
+# ICONV_SECOND_ARGUMENT_IS_CONST - the second argument for iconv() is const
+#
+
+IF (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
+	# Already in cache, be silent
+	SET(ICONV_FIND_QUIETLY TRUE)
+ENDIF (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
+
+FIND_PATH(ICONV_INCLUDE_DIR iconv.h)
+
+FIND_LIBRARY(ICONV_LIBRARIES NAMES iconv libiconv libiconv-2 c PATH)
+
+IF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
+	 SET(ICONV_FOUND TRUE)
+ENDIF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
+
+set(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR})
+set(CMAKE_REQUIRED_LIBRARIES ${ICONV_LIBRARIES})
+set(CMAKE_REQUIRED_INCLUDES)
+set(CMAKE_REQUIRED_LIBRARIES)
+
+IF(ICONV_FOUND)
+	IF(NOT ICONV_FIND_QUIETLY)
+		MESSAGE(STATUS "Found Iconv: ${ICONV_LIBRARIES}")
+	ENDIF(NOT ICONV_FIND_QUIETLY)
+ELSE(ICONV_FOUND)
+	IF(Iconv_FIND_REQUIRED)
+		MESSAGE(FATAL_ERROR "Could not find Iconv")
+	ENDIF(Iconv_FIND_REQUIRED)
+ENDIF(ICONV_FOUND)
+
+MARK_AS_ADVANCED(
+	ICONV_INCLUDE_DIR
+	ICONV_LIBRARIES
+	ICONV_SECOND_ARGUMENT_IS_CONST
+)
-- 
cgit v1.2.3


From 2123a17f83cc95adee4e7259d0686b07f074de4c Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 2 Dec 2013 13:27:06 -0800
Subject: Fix bug making split deltas a COPIED targets

When FIND_COPIES is used in combination with BREAK_REWRITES for
rename detection, there was a bug where the split MODIFIED delta
was only used as a target for RENAME records and not for COPIED
records.  This fixes that, converting the split into a pair of
DELETED and COPIED deltas when that circumstance arises.
---
 src/diff_tform.c    | 46 ++++++++++++++++++++++++++++++----------------
 tests/diff/rename.c | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+), 16 deletions(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index 28a9cc70d..3b5575d28 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -366,12 +366,28 @@ static int normalize_find_opts(
 	return 0;
 }
 
+static int insert_delete_side_of_split(
+	git_diff *diff, git_vector *onto, const git_diff_delta *delta)
+{
+	/* make new record for DELETED side of split */
+	git_diff_delta *deleted = diff_delta__dup(delta, &diff->pool);
+	GITERR_CHECK_ALLOC(deleted);
+
+	deleted->status = GIT_DELTA_DELETED;
+	deleted->nfiles = 1;
+	memset(&deleted->new_file, 0, sizeof(deleted->new_file));
+	deleted->new_file.path = deleted->old_file.path;
+	deleted->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+
+	return git_vector_insert(onto, deleted);
+}
+
 static int apply_splits_and_deletes(
 	git_diff *diff, size_t expected_size, bool actually_split)
 {
 	git_vector onto = GIT_VECTOR_INIT;
 	size_t i;
-	git_diff_delta *delta, *deleted;
+	git_diff_delta *delta;
 
 	if (git_vector_init(&onto, expected_size, git_diff_delta__cmp) < 0)
 		return -1;
@@ -384,17 +400,7 @@ static int apply_splits_and_deletes(
 		if ((delta->flags & GIT_DIFF_FLAG__TO_SPLIT) != 0 && actually_split) {
 			delta->similarity = 0;
 
-			/* make new record for DELETED side of split */
-			if (!(deleted = diff_delta__dup(delta, &diff->pool)))
-				goto on_error;
-
-			deleted->status = GIT_DELTA_DELETED;
-			deleted->nfiles = 1;
-			memset(&deleted->new_file, 0, sizeof(deleted->new_file));
-			deleted->new_file.path = deleted->old_file.path;
-			deleted->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
-
-			if (git_vector_insert(&onto, deleted) < 0)
+			if (insert_delete_side_of_split(diff, &onto, delta) < 0)
 				goto on_error;
 
 			if (diff->new_src == GIT_ITERATOR_TYPE_WORKDIR)
@@ -1058,10 +1064,7 @@ find_best_matches:
 			}
 		}
 
-		else if (delta_is_new_only(tgt)) {
-			if (!FLAG_SET(&opts, GIT_DIFF_FIND_COPIES))
-				continue;
-
+		else if (FLAG_SET(&opts, GIT_DIFF_FIND_COPIES)) {
 			if (tgt2src_copy[t].similarity < opts.copy_threshold)
 				continue;
 
@@ -1069,10 +1072,21 @@ find_best_matches:
 			best_match = &tgt2src_copy[t];
 			src = GIT_VECTOR_GET(&diff->deltas, best_match->idx);
 
+			if (delta_is_split(tgt)) {
+				error = insert_delete_side_of_split(diff, &diff->deltas, tgt);
+				if (error < 0)
+					goto cleanup;
+				num_rewrites--;
+			}
+
+			if (!delta_is_split(tgt) && !delta_is_new_only(tgt))
+				continue;
+
 			tgt->status     = GIT_DELTA_COPIED;
 			tgt->similarity = best_match->similarity;
 			tgt->nfiles     = 2;
 			memcpy(&tgt->old_file, &src->old_file, sizeof(tgt->old_file));
+			tgt->flags &= ~GIT_DIFF_FLAG__TO_SPLIT;
 
 			num_updates++;
 		}
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index 42bb65aa8..7f033936e 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -1284,3 +1284,52 @@ void test_diff_rename__rewrite_on_single_file(void)
 	git_diff_free(diff);
 	git_index_free(index);
 }
+
+void test_diff_rename__can_find_copy_to_split(void)
+{
+	git_buf c1 = GIT_BUF_INIT;
+	git_index *index;
+	git_tree *tree;
+	git_diff *diff;
+	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
+	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
+	diff_expects exp;
+
+	cl_git_pass(git_futils_readbuffer(&c1, "renames/songof7cities.txt"));
+	cl_git_pass(git_futils_writebuffer(&c1, "renames/untimely.txt", 0, 0));
+
+	cl_git_pass(
+		git_revparse_single((git_object **)&tree, g_repo, "HEAD^{tree}"));
+
+	cl_git_pass(git_repository_index(&index, g_repo));
+	cl_git_pass(git_index_read_tree(index, tree));
+	cl_git_pass(git_index_add_bypath(index, "untimely.txt"));
+
+	diffopts.flags = GIT_DIFF_INCLUDE_UNMODIFIED;
+
+	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, tree, index, &diffopts));
+
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_foreach(
+		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(4, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
+
+	opts.flags = GIT_DIFF_FIND_ALL;
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_foreach(
+		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(5, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
+	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
+
+	git_diff_free(diff);
+	git_tree_free(tree);
+	git_index_free(index);
+
+	git_buf_free(&c1);
+}
-- 
cgit v1.2.3


From 97ad85b88d7a2f6d1c31a07de3c3c0b4b504d4ee Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 2 Dec 2013 13:30:05 -0800
Subject: Add GIT_DIFF_FIND_DELETE_UNMODIFIED flag

When doing copy detection, it is often necessary to include
UNMODIFIED records in the git_diff so they are available as source
records for GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED.  Yet in the final
diff, often you will not want to have these UNMODIFIED records.
This adds a flag which marks these UNMODIFIED records for deletion
from the diff list so they will be removed after the rename detect
phase is over.
---
 include/git2/diff.h | 58 ++++++++++++++++++++++++++++++++++++++++-------------
 src/diff_tform.c    |  2 ++
 tests/diff/rename.c | 48 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 94 insertions(+), 14 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 61d288380..51ad349e3 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -468,41 +468,71 @@ typedef int (*git_diff_line_cb)(
  * Flags to control the behavior of diff rename/copy detection.
  */
 typedef enum {
-	/** look for renames? (`--find-renames`) */
+	/** Look for renames? (`--find-renames`) */
 	GIT_DIFF_FIND_RENAMES = (1u << 0),
-	/** consider old side of modified for renames? (`--break-rewrites=N`) */
+
+	/** Consider old side of MODIFIED for renames? (`--break-rewrites=N`) */
 	GIT_DIFF_FIND_RENAMES_FROM_REWRITES = (1u << 1),
 
-	/** look for copies? (a la `--find-copies`) */
+	/** Look for copies? (a la `--find-copies`). */
 	GIT_DIFF_FIND_COPIES = (1u << 2),
-	/** consider unmodified as copy sources? (`--find-copies-harder`) */
+
+	/** Consider UNMODIFIED as copy sources? (`--find-copies-harder`).
+	 *
+	 * For this to work correctly, use GIT_DIFF_INCLUDE_UNMODIFIED when
+	 * the initial `git_diff` is being generated.
+	 */
 	GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED = (1u << 3),
 
-	/** mark large rewrites for split (`--break-rewrites=/M`) */
+	/** Mark significant rewrites for split (`--break-rewrites=/M`) */
 	GIT_DIFF_FIND_REWRITES = (1u << 4),
-	/** actually split large rewrites into delete/add pairs */
+	/** Actually split large rewrites into delete/add pairs */
 	GIT_DIFF_BREAK_REWRITES = (1u << 5),
-	/** mark rewrites for split and break into delete/add pairs */
+	/** Mark rewrites for split and break into delete/add pairs */
 	GIT_DIFF_FIND_AND_BREAK_REWRITES =
 		(GIT_DIFF_FIND_REWRITES | GIT_DIFF_BREAK_REWRITES),
 
-	/** find renames/copies for untracked items in working directory */
+	/** Find renames/copies for UNTRACKED items in working directory.
+	 *
+	 * For this to work correctly, use GIT_DIFF_INCLUDE_UNTRACKED when the
+	 * initial `git_diff` is being generated (and obviously the diff must
+	 * be against the working directory for this to make sense).
+	 */
 	GIT_DIFF_FIND_FOR_UNTRACKED = (1u << 6),
 
-	/** turn on all finding features */
+	/** Turn on all finding features. */
 	GIT_DIFF_FIND_ALL = (0x0ff),
 
-	/** measure similarity ignoring leading whitespace (default) */
+	/** Measure similarity ignoring leading whitespace (default) */
 	GIT_DIFF_FIND_IGNORE_LEADING_WHITESPACE = 0,
-	/** measure similarity ignoring all whitespace */
+	/** Measure similarity ignoring all whitespace */
 	GIT_DIFF_FIND_IGNORE_WHITESPACE = (1u << 12),
-	/** measure similarity including all data */
+	/** Measure similarity including all data */
 	GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE = (1u << 13),
-	/** measure similarity only by comparing SHAs (fast and cheap) */
+	/** Measure similarity only by comparing SHAs (fast and cheap) */
 	GIT_DIFF_FIND_EXACT_MATCH_ONLY = (1u << 14),
 
-	/** do not break rewrites unless they contribute to a rename */
+	/** Do not break rewrites unless they contribute to a rename.
+	 *
+	 * Normally, GIT_DIFF_FIND_AND_BREAK_REWRITES will measure the self-
+	 * similarity of modified files and split the ones that have changed a
+	 * lot into a DELETE / ADD pair.  Then the sides of that pair will be
+	 * considered candidates for rename and copy detection.
+	 *
+	 * If you add this flag in and the split pair is *not* used for an
+	 * actual rename or copy, then the modified record will be restored to
+	 * a regular MODIFIED record instead of being split.
+	 */
 	GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY  = (1u << 15),
+
+	/** Delete any UNMODIFIED records after find_similar is done.
+	 *
+	 * Using GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED to emulate the
+	 * --find-copies-harder behavior requires building a diff with the
+	 * GIT_DIFF_INCLUDE_UNMODIFIED flag.  If you do not want UNMODIFIED
+	 * records in the final result, pass this flag to have them removed.
+	 */
+	GIT_DIFF_FIND_DELETE_UNMODIFIED = (1u << 16),
 } git_diff_find_t;
 
 /**
diff --git a/src/diff_tform.c b/src/diff_tform.c
index 3b5575d28..bff821dc3 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -746,6 +746,8 @@ static bool is_rename_source(
 	case GIT_DELTA_UNMODIFIED:
 		if (!FLAG_SET(opts, GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED))
 			return false;
+		if (FLAG_SET(opts, GIT_DIFF_FIND_DELETE_UNMODIFIED))
+			delta->flags |= GIT_DIFF_FLAG__TO_DELETE;
 		break;
 
 	default: /* MODIFIED, RENAMED, COPIED */
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index 7f033936e..e081d616f 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -1333,3 +1333,51 @@ void test_diff_rename__can_find_copy_to_split(void)
 
 	git_buf_free(&c1);
 }
+
+void test_diff_rename__can_delete_unmodified_deltas(void)
+{
+	git_buf c1 = GIT_BUF_INIT;
+	git_index *index;
+	git_tree *tree;
+	git_diff *diff;
+	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
+	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
+	diff_expects exp;
+
+	cl_git_pass(git_futils_readbuffer(&c1, "renames/songof7cities.txt"));
+	cl_git_pass(git_futils_writebuffer(&c1, "renames/untimely.txt", 0, 0));
+
+	cl_git_pass(
+		git_revparse_single((git_object **)&tree, g_repo, "HEAD^{tree}"));
+
+	cl_git_pass(git_repository_index(&index, g_repo));
+	cl_git_pass(git_index_read_tree(index, tree));
+	cl_git_pass(git_index_add_bypath(index, "untimely.txt"));
+
+	diffopts.flags = GIT_DIFF_INCLUDE_UNMODIFIED;
+
+	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, tree, index, &diffopts));
+
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_foreach(
+		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(4, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
+
+	opts.flags = GIT_DIFF_FIND_ALL | GIT_DIFF_FIND_DELETE_UNMODIFIED;
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_foreach(
+		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(2, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
+
+	git_diff_free(diff);
+	git_tree_free(tree);
+	git_index_free(index);
+
+	git_buf_free(&c1);
+}
-- 
cgit v1.2.3


From f62c174d0d88c3e491fe3f4e3490959edb7cae1b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 2 Dec 2013 13:49:58 -0800
Subject: GIT_DIFF_FIND_REMOVE_UNMODIFIED sounds better

---
 include/git2/diff.h | 4 ++--
 src/diff_tform.c    | 2 +-
 tests/diff/rename.c | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 51ad349e3..db6bce2eb 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -525,14 +525,14 @@ typedef enum {
 	 */
 	GIT_DIFF_BREAK_REWRITES_FOR_RENAMES_ONLY  = (1u << 15),
 
-	/** Delete any UNMODIFIED records after find_similar is done.
+	/** Remove any UNMODIFIED deltas after find_similar is done.
 	 *
 	 * Using GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED to emulate the
 	 * --find-copies-harder behavior requires building a diff with the
 	 * GIT_DIFF_INCLUDE_UNMODIFIED flag.  If you do not want UNMODIFIED
 	 * records in the final result, pass this flag to have them removed.
 	 */
-	GIT_DIFF_FIND_DELETE_UNMODIFIED = (1u << 16),
+	GIT_DIFF_FIND_REMOVE_UNMODIFIED = (1u << 16),
 } git_diff_find_t;
 
 /**
diff --git a/src/diff_tform.c b/src/diff_tform.c
index bff821dc3..0a28e58c7 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -746,7 +746,7 @@ static bool is_rename_source(
 	case GIT_DELTA_UNMODIFIED:
 		if (!FLAG_SET(opts, GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED))
 			return false;
-		if (FLAG_SET(opts, GIT_DIFF_FIND_DELETE_UNMODIFIED))
+		if (FLAG_SET(opts, GIT_DIFF_FIND_REMOVE_UNMODIFIED))
 			delta->flags |= GIT_DIFF_FLAG__TO_DELETE;
 		break;
 
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index e081d616f..919f5139a 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -1365,7 +1365,7 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
 	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_MODIFIED]);
 	cl_assert_equal_i(3, exp.file_status[GIT_DELTA_UNMODIFIED]);
 
-	opts.flags = GIT_DIFF_FIND_ALL | GIT_DIFF_FIND_DELETE_UNMODIFIED;
+	opts.flags = GIT_DIFF_FIND_ALL | GIT_DIFF_FIND_REMOVE_UNMODIFIED;
 	cl_git_pass(git_diff_find_similar(diff, &opts));
 
 	memset(&exp, 0, sizeof(exp));
-- 
cgit v1.2.3


From 300d192f7ed45112121f2a35d5ca80a4913c7aad Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 2 Dec 2013 11:15:27 -0500
Subject: Introduce git_revert to revert a single commit

---
 include/git2/commit.h                              |  11 +
 include/git2/errors.h                              |   1 +
 include/git2/revert.h                              |  52 +++
 src/commit.c                                       |  29 ++
 src/commit.h                                       |   2 +
 src/merge.c                                        |  18 +-
 src/merge.h                                        |   2 +
 src/revert.c                                       | 217 ++++++++++++
 src/revert.h                                       |  14 +
 tests/commit/commit.c                              |  29 ++
 tests/resources/revert/.gitted/HEAD                |   1 +
 tests/resources/revert/.gitted/config              |   8 +
 tests/resources/revert/.gitted/index               | Bin 0 -> 320 bytes
 tests/resources/revert/.gitted/info/exclude        |   6 +
 .../0a/a8c7e40d342fff78d60b29a4ba8e993ed79c51      |   2 +
 .../0a/b09ea6d4c3634bdf6c221626d8b6f7dd890767      | Bin 0 -> 28 bytes
 .../0c/db66192ee192f70f891f05a47636057420e871      | Bin 0 -> 35 bytes
 .../0f/5bfcf58c558d865da6be0281d7795993646cee      | Bin 0 -> 45 bytes
 .../13/ee9cd5d8e1023c218e0e1ea684ec0c582b5050      | Bin 0 -> 161 bytes
 .../15/6ef9bcb968dccec8472a0f2eff49f1a713bc6b      | Bin 0 -> 133 bytes
 .../18/1aab27ddb37b40d9a284fb4733497006d57091      | Bin 0 -> 133 bytes
 .../1f/a4e069a641f10f5fb7588138b2d147fcd22c36      | Bin 0 -> 133 bytes
 .../29/6a6d3be1dff05c5d1f631d2459389fa7b619eb      | Bin 0 -> 40 bytes
 .../2d/440f2b3147d3dc7ad1085813478d6d869d5a4d      |   2 +
 .../33/c6fd981c49a2abf2971482089350bfc5cda8ea      | Bin 0 -> 47 bytes
 .../39/467716290f6df775a91cdb9a4eb39295018145      | Bin 0 -> 162 bytes
 .../3a/3ef367eaf3fe79effbfb0a56b269c04c2b59fe      | Bin 0 -> 33 bytes
 .../4b/8fcff56437e60f58e9a6bc630dd242ebf6ea2c      | Bin 0 -> 43 bytes
 .../52/c95c4264245469a0617e289a7d737f156826b4      |   2 +
 .../55/568c8de5322ff9a95d72747a239cdb64a19965      |   1 +
 .../55/acf326a69f0aab7a974ec53ffa55a50bcac14e      | Bin 0 -> 30 bytes
 .../5a/cdc74af27172ec491d213ee36cea7eb9ef2579      |   3 +
 .../72/333f47d4e83616630ff3b0ffe4c0faebcc3c45      | Bin 0 -> 172 bytes
 .../73/ec36fa120f8066963a0bc9105bb273dbd903d7      | Bin 0 -> 31 bytes
 .../74/7726e021bc5f44b86de60e3032fd6f9f1b8383      | Bin 0 -> 28 bytes
 .../77/31926a337c4eaba1e2187d90ebfa0a93659382      | Bin 0 -> 37 bytes
 .../83/f65df4606c4f8dbf8da43de25de1b7e4c03238      | Bin 0 -> 113 bytes
 .../8f/d40e13fff575b63e86af87175e70fa7fb92f80      | Bin 0 -> 80 bytes
 .../97/f3574e92f1730d365fb9e00c10e3c507c1cfe9      | Bin 0 -> 115 bytes
 .../a6/9f74efcb51634b88e04ea81273158a85257f41      | Bin 0 -> 146 bytes
 .../b7/a55408832174c54708906a372a9be2ffe3649b      | Bin 0 -> 133 bytes
 .../be/ead165e017269e8dc0dd6f01195726a2e1e01b      | Bin 0 -> 133 bytes
 .../ce/f56612d71a6af8d8015691e4865f7fece905b5      | Bin 0 -> 174 bytes
 .../d1/d403d22cbe24592d725f442835cf46fe60c8ac      | Bin 0 -> 164 bytes
 .../dd/9a159c89509e73fd37d6af99619994cf7dfc06      | Bin 0 -> 133 bytes
 .../eb/b03002cee5d66c7732dd06241119fe72ab96a5      |   2 +
 .../f4/e107c230d08a60fb419d19869f1f282b272d9c      | Bin 0 -> 30 bytes
 tests/resources/revert/.gitted/refs/heads/master   |   1 +
 tests/resources/revert/.gitted/refs/heads/merges   |   1 +
 .../revert/.gitted/refs/heads/merges-branch        |   1 +
 .../revert/.gitted/refs/heads/reverted-branch      |   1 +
 tests/resources/revert/file1.txt                   |  14 +
 tests/resources/revert/file2.txt                   |  16 +
 tests/resources/revert/file3.txt                   |  16 +
 tests/resources/revert/file6.txt                   |  14 +
 tests/revert/revert.c                              | 364 +++++++++++++++++++++
 56 files changed, 822 insertions(+), 8 deletions(-)
 create mode 100644 include/git2/revert.h
 create mode 100644 src/revert.c
 create mode 100644 src/revert.h
 create mode 100644 tests/resources/revert/.gitted/HEAD
 create mode 100644 tests/resources/revert/.gitted/config
 create mode 100644 tests/resources/revert/.gitted/index
 create mode 100644 tests/resources/revert/.gitted/info/exclude
 create mode 100644 tests/resources/revert/.gitted/objects/0a/a8c7e40d342fff78d60b29a4ba8e993ed79c51
 create mode 100644 tests/resources/revert/.gitted/objects/0a/b09ea6d4c3634bdf6c221626d8b6f7dd890767
 create mode 100644 tests/resources/revert/.gitted/objects/0c/db66192ee192f70f891f05a47636057420e871
 create mode 100644 tests/resources/revert/.gitted/objects/0f/5bfcf58c558d865da6be0281d7795993646cee
 create mode 100644 tests/resources/revert/.gitted/objects/13/ee9cd5d8e1023c218e0e1ea684ec0c582b5050
 create mode 100644 tests/resources/revert/.gitted/objects/15/6ef9bcb968dccec8472a0f2eff49f1a713bc6b
 create mode 100644 tests/resources/revert/.gitted/objects/18/1aab27ddb37b40d9a284fb4733497006d57091
 create mode 100644 tests/resources/revert/.gitted/objects/1f/a4e069a641f10f5fb7588138b2d147fcd22c36
 create mode 100644 tests/resources/revert/.gitted/objects/29/6a6d3be1dff05c5d1f631d2459389fa7b619eb
 create mode 100644 tests/resources/revert/.gitted/objects/2d/440f2b3147d3dc7ad1085813478d6d869d5a4d
 create mode 100644 tests/resources/revert/.gitted/objects/33/c6fd981c49a2abf2971482089350bfc5cda8ea
 create mode 100644 tests/resources/revert/.gitted/objects/39/467716290f6df775a91cdb9a4eb39295018145
 create mode 100644 tests/resources/revert/.gitted/objects/3a/3ef367eaf3fe79effbfb0a56b269c04c2b59fe
 create mode 100644 tests/resources/revert/.gitted/objects/4b/8fcff56437e60f58e9a6bc630dd242ebf6ea2c
 create mode 100644 tests/resources/revert/.gitted/objects/52/c95c4264245469a0617e289a7d737f156826b4
 create mode 100644 tests/resources/revert/.gitted/objects/55/568c8de5322ff9a95d72747a239cdb64a19965
 create mode 100644 tests/resources/revert/.gitted/objects/55/acf326a69f0aab7a974ec53ffa55a50bcac14e
 create mode 100644 tests/resources/revert/.gitted/objects/5a/cdc74af27172ec491d213ee36cea7eb9ef2579
 create mode 100644 tests/resources/revert/.gitted/objects/72/333f47d4e83616630ff3b0ffe4c0faebcc3c45
 create mode 100644 tests/resources/revert/.gitted/objects/73/ec36fa120f8066963a0bc9105bb273dbd903d7
 create mode 100644 tests/resources/revert/.gitted/objects/74/7726e021bc5f44b86de60e3032fd6f9f1b8383
 create mode 100644 tests/resources/revert/.gitted/objects/77/31926a337c4eaba1e2187d90ebfa0a93659382
 create mode 100644 tests/resources/revert/.gitted/objects/83/f65df4606c4f8dbf8da43de25de1b7e4c03238
 create mode 100644 tests/resources/revert/.gitted/objects/8f/d40e13fff575b63e86af87175e70fa7fb92f80
 create mode 100644 tests/resources/revert/.gitted/objects/97/f3574e92f1730d365fb9e00c10e3c507c1cfe9
 create mode 100644 tests/resources/revert/.gitted/objects/a6/9f74efcb51634b88e04ea81273158a85257f41
 create mode 100644 tests/resources/revert/.gitted/objects/b7/a55408832174c54708906a372a9be2ffe3649b
 create mode 100644 tests/resources/revert/.gitted/objects/be/ead165e017269e8dc0dd6f01195726a2e1e01b
 create mode 100644 tests/resources/revert/.gitted/objects/ce/f56612d71a6af8d8015691e4865f7fece905b5
 create mode 100644 tests/resources/revert/.gitted/objects/d1/d403d22cbe24592d725f442835cf46fe60c8ac
 create mode 100644 tests/resources/revert/.gitted/objects/dd/9a159c89509e73fd37d6af99619994cf7dfc06
 create mode 100644 tests/resources/revert/.gitted/objects/eb/b03002cee5d66c7732dd06241119fe72ab96a5
 create mode 100644 tests/resources/revert/.gitted/objects/f4/e107c230d08a60fb419d19869f1f282b272d9c
 create mode 100644 tests/resources/revert/.gitted/refs/heads/master
 create mode 100644 tests/resources/revert/.gitted/refs/heads/merges
 create mode 100644 tests/resources/revert/.gitted/refs/heads/merges-branch
 create mode 100644 tests/resources/revert/.gitted/refs/heads/reverted-branch
 create mode 100644 tests/resources/revert/file1.txt
 create mode 100644 tests/resources/revert/file2.txt
 create mode 100644 tests/resources/revert/file3.txt
 create mode 100644 tests/resources/revert/file6.txt
 create mode 100644 tests/revert/revert.c

diff --git a/include/git2/commit.h b/include/git2/commit.h
index a08cf1c6c..8b03df0a9 100644
--- a/include/git2/commit.h
+++ b/include/git2/commit.h
@@ -116,6 +116,17 @@ GIT_EXTERN(const char *) git_commit_message(const git_commit *commit);
  */
 GIT_EXTERN(const char *) git_commit_message_raw(const git_commit *commit);
 
+/**
+ * Get the short "summary" of the git commit message.
+ *
+ * The returned message is the summary of the commit, comprising the
+ * first paragraph of the message with whitespace trimmed and squashed.
+ *
+ * @param commit a previously loaded commit.
+ * @return the summary of a commit or NULL on error
+ */
+GIT_EXTERN(const char *) git_commit_summary(git_commit *commit);
+
 /**
  * Get the commit time (i.e. committer time) of a commit.
  *
diff --git a/include/git2/errors.h b/include/git2/errors.h
index be7a31d8e..f1a8ea1ae 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -71,6 +71,7 @@ typedef enum {
 	GITERR_MERGE,
 	GITERR_SSH,
 	GITERR_FILTER,
+	GITERR_REVERT,
 } git_error_t;
 
 /**
diff --git a/include/git2/revert.h b/include/git2/revert.h
new file mode 100644
index 000000000..fe84238c5
--- /dev/null
+++ b/include/git2/revert.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_git_revert_h__
+#define INCLUDE_git_revert_h__
+
+#include "common.h"
+#include "types.h"
+#include "merge.h"
+
+/**
+ * @file git2/revert.h
+ * @brief Git revert routines
+ * @defgroup git_revert Git revert routines
+ * @ingroup Git
+ * @{
+ */
+GIT_BEGIN_DECL
+
+typedef struct {
+	unsigned int version;
+
+	/** For merge commits, the "mainline" is treated as the parent. */
+	unsigned int mainline;
+
+	git_merge_tree_opts merge_tree_opts;
+	git_checkout_opts checkout_opts;
+} git_revert_opts;
+
+#define GIT_REVERT_OPTS_VERSION 1
+#define GIT_REVERT_OPTS_INIT {GIT_REVERT_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
+
+/**
+* Reverts the given commits, producing changes in the working directory.
+*
+* @param repo the repository to revert
+* @param commits the commits to revert
+* @param commits_len the number of commits to revert
+* @param flags merge flags
+*/
+GIT_EXTERN(int) git_revert(
+	git_repository *repo,
+	git_commit *commit,
+	const git_revert_opts *given_opts);
+
+/** @} */
+GIT_END_DECL
+#endif
+
diff --git a/src/commit.c b/src/commit.c
index 91b60bbb2..bbb76f350 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -31,6 +31,7 @@ void git_commit__free(void *_commit)
 	git__free(commit->raw_header);
 	git__free(commit->raw_message);
 	git__free(commit->message_encoding);
+	git__free(commit->summary);
 
 	git__free(commit);
 }
@@ -286,6 +287,34 @@ const char *git_commit_message(const git_commit *commit)
 	return message;
 }
 
+const char *git_commit_summary(git_commit *commit)
+{
+	git_buf summary = GIT_BUF_INIT;
+	const char *msg, *space;
+
+	assert(commit);
+
+	if (!commit->summary) {
+		for (msg = git_commit_message(commit), space = NULL; *msg; ++msg) {
+			if (msg[0] == '\n' && (!msg[1] || msg[1] == '\n'))
+				break;
+			else if (msg[0] == '\n')
+				git_buf_putc(&summary, ' ');
+			else if (git__isspace(msg[0]))
+				space = space ? space : msg;
+			else if (space) {
+				git_buf_put(&summary, space, (msg - space) + 1);
+				space = NULL;
+			} else
+				git_buf_putc(&summary, *msg);
+		}
+
+		commit->summary = git_buf_detach(&summary);
+	}
+
+	return commit->summary;
+}
+
 int git_commit_tree(git_tree **tree_out, const git_commit *commit)
 {
 	assert(commit);
diff --git a/src/commit.h b/src/commit.h
index d452e2975..efb080b50 100644
--- a/src/commit.h
+++ b/src/commit.h
@@ -26,6 +26,8 @@ struct git_commit {
 	char *message_encoding;
 	char *raw_message;
 	char *raw_header;
+
+	char *summary;
 };
 
 void git_commit__free(void *commit);
diff --git a/src/merge.c b/src/merge.c
index 115867971..c31a935b0 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -1206,7 +1206,7 @@ static git_merge_diff *merge_diff_from_index_entries(
 
 /* Merge trees */
 
-static int merge_index_insert_conflict(
+static int merge_diff_list_insert_conflict(
 	git_merge_diff_list *diff_list,
 	struct merge_diff_df_data *merge_df_data,
 	const git_index_entry *tree_items[3])
@@ -1222,7 +1222,7 @@ static int merge_index_insert_conflict(
 	return 0;
 }
 
-static int merge_index_insert_unmodified(
+static int merge_diff_list_insert_unmodified(
 	git_merge_diff_list *diff_list,
 	const git_index_entry *tree_items[3])
 {
@@ -1252,7 +1252,7 @@ int git_merge_diff_list__find_differences(
 	size_t i, j;
 	int error = 0;
 
-	assert(diff_list && our_tree && their_tree);
+	assert(diff_list && (our_tree || their_tree));
 
 	if ((error = git_iterator_for_tree(&iterators[TREE_IDX_ANCESTOR], (git_tree *)ancestor_tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL)) < 0 ||
 		(error = git_iterator_for_tree(&iterators[TREE_IDX_OURS], (git_tree *)our_tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL)) < 0 ||
@@ -1262,6 +1262,7 @@ int git_merge_diff_list__find_differences(
 	/* Set up the iterators */
 	for (i = 0; i < 3; i++) {
 		error = git_iterator_current(&items[i], iterators[i]);
+
 		if (error < 0 && error != GIT_ITEROVER)
 			goto done;
 	}
@@ -1313,9 +1314,9 @@ int git_merge_diff_list__find_differences(
 			break;
 
 		if (cur_item_modified)
-			error = merge_index_insert_conflict(diff_list, &df_data, cur_items);
+			error = merge_diff_list_insert_conflict(diff_list, &df_data, cur_items);
 		else
-			error = merge_index_insert_unmodified(diff_list, cur_items);
+			error = merge_diff_list_insert_unmodified(diff_list, cur_items);
 		if (error < 0)
 			goto done;
 
@@ -1325,6 +1326,7 @@ int git_merge_diff_list__find_differences(
 				continue;
 
 			error = git_iterator_advance(&items[i], iterators[i]);
+
 			if (error < 0 && error != GIT_ITEROVER)
 				goto done;
 		}
@@ -1569,7 +1571,7 @@ int git_merge_trees(
 	size_t i;
 	int error = 0;
 
-	assert(out && repo && our_tree && their_tree);
+	assert(out && repo && (our_tree || their_tree));
 
 	*out = NULL;
 
@@ -2268,7 +2270,7 @@ done:
 	return error;
 }
 
-static int merge_indexes(git_repository *repo, git_index *index_new)
+int git_merge__indexes(git_repository *repo, git_index *index_new)
 {
 	git_index *index_repo;
 	unsigned int index_repo_caps;
@@ -2440,7 +2442,7 @@ int git_merge(
 	/* TODO: recursive, octopus, etc... */
 
 	if ((error = git_merge_trees(&index_new, repo, ancestor_tree, our_tree, their_trees[0], &opts.merge_tree_opts)) < 0 ||
-		(error = merge_indexes(repo, index_new)) < 0 ||
+		(error = git_merge__indexes(repo, index_new)) < 0 ||
 		(error = git_repository_index(&index_repo, repo)) < 0 ||
 		(error = git_checkout_index(repo, index_repo, &opts.checkout_opts)) < 0)
 		goto on_error;
diff --git a/src/merge.h b/src/merge.h
index d7d1c67b7..b240f6c44 100644
--- a/src/merge.h
+++ b/src/merge.h
@@ -158,4 +158,6 @@ int git_merge__setup(
 	size_t their_heads_len,
 	unsigned int flags);
 
+int git_merge__indexes(git_repository *repo, git_index *index_new);
+
 #endif
diff --git a/src/revert.c b/src/revert.c
new file mode 100644
index 000000000..34ba343b6
--- /dev/null
+++ b/src/revert.c
@@ -0,0 +1,217 @@
+/*
+* Copyright (C) the libgit2 contributors. All rights reserved.
+*
+* This file is part of libgit2, distributed under the GNU GPL v2 with
+* a Linking Exception. For full terms see the included COPYING file.
+*/
+
+#include "common.h"
+#include "repository.h"
+#include "filebuf.h"
+#include "merge.h"
+#include "revert.h"
+
+#include "git2/types.h"
+#include "git2/merge.h"
+#include "git2/revert.h"
+#include "git2/commit.h"
+#include "git2/sys/commit.h"
+
+#define GIT_REVERT_FILE_MODE		0666
+
+static int write_revert_head(
+	git_repository *repo,
+	const git_commit *commit,
+	const char *commit_oidstr)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	git_buf file_path = GIT_BUF_INIT;
+	int error = 0;
+
+	assert(repo && commit);
+
+	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_REVERT_HEAD_FILE)) >= 0 &&
+		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_REVERT_FILE_MODE)) >= 0 &&
+		(error = git_filebuf_printf(&file, "%s\n", commit_oidstr)) >= 0)
+		error = git_filebuf_commit(&file);
+
+	if (error < 0)
+		git_filebuf_cleanup(&file);
+
+	git_buf_free(&file_path);
+
+	return error;
+}
+
+static int write_merge_msg(
+	git_repository *repo,
+	const git_commit *commit,
+	const char *commit_oidstr,
+	const char *commit_msgline)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	git_buf file_path = GIT_BUF_INIT;
+	int error = 0;
+
+	assert(repo && commit);
+
+	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_MERGE_MSG_FILE)) < 0 ||
+		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_REVERT_FILE_MODE)) < 0 ||
+		(error = git_filebuf_printf(&file, "Revert \"%s\"\n\nThis reverts commit %s.\n",
+		commit_msgline, commit_oidstr)) < 0)
+		goto cleanup;
+
+	error = git_filebuf_commit(&file);
+
+cleanup:
+	if (error < 0)
+		git_filebuf_cleanup(&file);
+
+	git_buf_free(&file_path);
+
+	return error;
+}
+
+static int revert_normalize_opts(
+	git_repository *repo,
+	git_revert_opts *opts,
+	const git_revert_opts *given,
+	const char *their_label)
+{
+	int error = 0;
+	unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE_CREATE |
+		GIT_CHECKOUT_ALLOW_CONFLICTS;
+
+	GIT_UNUSED(repo);
+
+	if (given != NULL)
+		memcpy(opts, given, sizeof(git_revert_opts));
+	else {
+		git_revert_opts default_opts = GIT_REVERT_OPTS_INIT;
+		memcpy(opts, &default_opts, sizeof(git_revert_opts));
+	}
+
+	if (!opts->checkout_opts.checkout_strategy)
+		opts->checkout_opts.checkout_strategy = default_checkout_strategy;
+
+	if (!opts->checkout_opts.our_label)
+		opts->checkout_opts.our_label = "HEAD";
+
+	if (!opts->checkout_opts.their_label)
+		opts->checkout_opts.their_label = their_label;
+
+	return error;
+}
+
+int git_revert(
+	git_repository *repo,
+	git_commit *commit,
+	const git_revert_opts *given_opts)
+{
+	git_revert_opts opts;
+	git_commit *parent_commit = NULL;
+	git_tree *parent_tree = NULL, *our_tree = NULL, *revert_tree = NULL;
+	git_index *index_new = NULL, *index_repo = NULL;
+	char commit_oidstr[GIT_OID_HEXSZ + 1];
+	const char *commit_msg;
+	git_buf their_label = GIT_BUF_INIT;
+	int parent = 0;
+	int error = 0;
+
+	assert(repo && commit);
+
+	if ((error = git_repository__ensure_not_bare(repo, "revert")) < 0)
+		return error;
+
+	git_oid_fmt(commit_oidstr, git_commit_id(commit));
+	commit_oidstr[GIT_OID_HEXSZ] = '\0';
+
+	if ((commit_msg = git_commit_summary(commit)) == NULL) {
+		error = -1;
+		goto on_error;
+	}
+
+	if ((error = git_buf_printf(&their_label, "parent of %.7s... %s", commit_oidstr, commit_msg)) < 0 ||
+		(error = revert_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 ||
+		(error = write_revert_head(repo, commit, commit_oidstr)) < 0 ||
+		(error = write_merge_msg(repo, commit, commit_oidstr, commit_msg)) < 0 ||
+		(error = git_repository_head_tree(&our_tree, repo)) < 0 ||
+		(error = git_commit_tree(&revert_tree, commit)) < 0)
+		goto on_error;
+
+	if (git_commit_parentcount(commit) > 1) {
+		if (!opts.mainline) {
+			giterr_set(GITERR_REVERT,
+				"Mainline branch is not specified but %s is a merge commit",
+				commit_oidstr);
+			error = -1;
+			goto on_error;
+		}
+
+		parent = opts.mainline;
+	} else {
+		if (opts.mainline) {
+			giterr_set(GITERR_REVERT,
+				"Mainline branch was specified but %s is not a merge",
+				commit_oidstr);
+			error = -1;
+			goto on_error;
+		}
+
+		parent = git_commit_parentcount(commit);
+	}
+
+	if (parent &&
+		((error = git_commit_parent(&parent_commit, commit, (parent - 1))) < 0 ||
+		(error = git_commit_tree(&parent_tree, parent_commit)) < 0))
+		goto on_error;
+
+	if ((error = git_merge_trees(&index_new, repo, revert_tree, our_tree, parent_tree, &opts.merge_tree_opts)) < 0 ||
+		(error = git_merge__indexes(repo, index_new)) < 0 ||
+		(error = git_repository_index(&index_repo, repo)) < 0 ||
+		(error = git_checkout_index(repo, index_repo, &opts.checkout_opts)) < 0)
+		goto on_error;
+
+	goto done;
+
+on_error:
+	git_revert__cleanup(repo);
+
+done:
+	git_index_free(index_new);
+	git_index_free(index_repo);
+	git_tree_free(parent_tree);
+	git_tree_free(our_tree);
+	git_tree_free(revert_tree);
+	git_commit_free(parent_commit);
+	git_buf_free(&their_label);
+
+	return error;
+}
+
+int git_revert__cleanup(git_repository *repo)
+{
+	int error = 0;
+	git_buf revert_head_path = GIT_BUF_INIT,
+		merge_msg_path = GIT_BUF_INIT;
+
+	assert(repo);
+
+	if (git_buf_joinpath(&revert_head_path, repo->path_repository, GIT_REVERT_HEAD_FILE) < 0 ||
+		git_buf_joinpath(&merge_msg_path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
+		return -1;
+
+	if (git_path_isfile(revert_head_path.ptr)) {
+		if ((error = p_unlink(revert_head_path.ptr)) < 0)
+			goto cleanup;
+	}
+
+	if (git_path_isfile(merge_msg_path.ptr))
+		(void)p_unlink(merge_msg_path.ptr);
+
+cleanup:
+	git_buf_free(&merge_msg_path);
+	git_buf_free(&revert_head_path);
+
+	return error;
+}
diff --git a/src/revert.h b/src/revert.h
new file mode 100644
index 000000000..ed3912198
--- /dev/null
+++ b/src/revert.h
@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_revert_h__
+#define INCLUDE_revert_h__
+
+#include "git2/repository.h"
+
+int git_revert__cleanup(git_repository *repo);
+
+#endif
diff --git a/tests/commit/commit.c b/tests/commit/commit.c
index 8f071ff94..4af9190b5 100644
--- a/tests/commit/commit.c
+++ b/tests/commit/commit.c
@@ -1,4 +1,6 @@
 #include "clar_libgit2.h"
+#include "commit.h"
+#include "git2/commit.h"
 
 static git_repository *_repo;
 
@@ -44,3 +46,30 @@ void test_commit_commit__create_unexisting_update_ref(void)
 	git_signature_free(s);
 	git_reference_free(ref);
 }
+
+void assert_commit_summary(const char *expected, const char *given)
+{
+	git_commit *dummy;
+
+	cl_assert(dummy = git__calloc(1, sizeof(struct git_commit)));
+
+	dummy->raw_message = git__strdup(given);
+	cl_assert_equal_s(expected, git_commit_summary(dummy));
+
+	git_commit__free(dummy);
+}
+
+void test_commit_commit__summary(void)
+{
+	assert_commit_summary("One-liner with no trailing newline", "One-liner with no trailing newline");
+	assert_commit_summary("One-liner with trailing newline", "One-liner with trailing newline\n");
+	assert_commit_summary("Trimmed leading&trailing newlines", "\n\nTrimmed leading&trailing newlines\n\n");
+	assert_commit_summary("First paragraph only", "\nFirst paragraph only\n\n(There are more!)");
+	assert_commit_summary("First paragraph with  unwrapped trailing\tlines", "\nFirst paragraph\nwith  unwrapped\ntrailing\tlines\n\n(Yes, unwrapped!)");
+	assert_commit_summary("\tLeading \ttabs", "\tLeading\n\ttabs\n\nis preserved");
+	assert_commit_summary(" Leading  Spaces", " Leading\n Spaces\n\nare preserved");
+	assert_commit_summary("Trailing tabs\tare removed", "Trailing tabs\tare removed\t\t");
+	assert_commit_summary("Trailing spaces  are removed", "Trailing spaces  are removed  ");
+	assert_commit_summary("Trailing tabs", "Trailing tabs\t\n\nare removed");
+	assert_commit_summary("Trailing spaces", "Trailing spaces \n\nare removed");
+}
diff --git a/tests/resources/revert/.gitted/HEAD b/tests/resources/revert/.gitted/HEAD
new file mode 100644
index 000000000..cb4380516
--- /dev/null
+++ b/tests/resources/revert/.gitted/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/master
diff --git a/tests/resources/revert/.gitted/config b/tests/resources/revert/.gitted/config
new file mode 100644
index 000000000..454e576b9
--- /dev/null
+++ b/tests/resources/revert/.gitted/config
@@ -0,0 +1,8 @@
+[core]
+	repositoryformatversion = 0
+	filemode = false
+	bare = false
+	logallrefupdates = true
+	symlinks = false
+	ignorecase = true
+	hideDotFiles = dotGitOnly
diff --git a/tests/resources/revert/.gitted/index b/tests/resources/revert/.gitted/index
new file mode 100644
index 000000000..87419ff57
Binary files /dev/null and b/tests/resources/revert/.gitted/index differ
diff --git a/tests/resources/revert/.gitted/info/exclude b/tests/resources/revert/.gitted/info/exclude
new file mode 100644
index 000000000..f00680973
--- /dev/null
+++ b/tests/resources/revert/.gitted/info/exclude
@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
diff --git a/tests/resources/revert/.gitted/objects/0a/a8c7e40d342fff78d60b29a4ba8e993ed79c51 b/tests/resources/revert/.gitted/objects/0a/a8c7e40d342fff78d60b29a4ba8e993ed79c51
new file mode 100644
index 000000000..5c811ef89
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/0a/a8c7e40d342fff78d60b29a4ba8e993ed79c51
@@ -0,0 +1,2 @@
+x
¥�K
+Â0@]çs
%Ó4?qã
¼@2�Ѐé@ñúÖ3¸{¼Å{$­Õ
Üitf@ë¸ÄL9º°1…ÙOI—‰K™cÁäÑdrY¥÷X¥Ãcù¤¾Às•¶ËW>ì�î­R—]ʸ�´ 	�GଭÖê°Çxð	U·:jz©/¤’?
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/0a/b09ea6d4c3634bdf6c221626d8b6f7dd890767 b/tests/resources/revert/.gitted/objects/0a/b09ea6d4c3634bdf6c221626d8b6f7dd890767
new file mode 100644
index 000000000..c050e5a89
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/0a/b09ea6d4c3634bdf6c221626d8b6f7dd890767 differ
diff --git a/tests/resources/revert/.gitted/objects/0c/db66192ee192f70f891f05a47636057420e871 b/tests/resources/revert/.gitted/objects/0c/db66192ee192f70f891f05a47636057420e871
new file mode 100644
index 000000000..31c107fc4
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/0c/db66192ee192f70f891f05a47636057420e871 differ
diff --git a/tests/resources/revert/.gitted/objects/0f/5bfcf58c558d865da6be0281d7795993646cee b/tests/resources/revert/.gitted/objects/0f/5bfcf58c558d865da6be0281d7795993646cee
new file mode 100644
index 000000000..fb4fc763a
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/0f/5bfcf58c558d865da6be0281d7795993646cee differ
diff --git a/tests/resources/revert/.gitted/objects/13/ee9cd5d8e1023c218e0e1ea684ec0c582b5050 b/tests/resources/revert/.gitted/objects/13/ee9cd5d8e1023c218e0e1ea684ec0c582b5050
new file mode 100644
index 000000000..aed4647a6
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/13/ee9cd5d8e1023c218e0e1ea684ec0c582b5050 differ
diff --git a/tests/resources/revert/.gitted/objects/15/6ef9bcb968dccec8472a0f2eff49f1a713bc6b b/tests/resources/revert/.gitted/objects/15/6ef9bcb968dccec8472a0f2eff49f1a713bc6b
new file mode 100644
index 000000000..3ee2a189b
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/15/6ef9bcb968dccec8472a0f2eff49f1a713bc6b differ
diff --git a/tests/resources/revert/.gitted/objects/18/1aab27ddb37b40d9a284fb4733497006d57091 b/tests/resources/revert/.gitted/objects/18/1aab27ddb37b40d9a284fb4733497006d57091
new file mode 100644
index 000000000..6b422b808
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/18/1aab27ddb37b40d9a284fb4733497006d57091 differ
diff --git a/tests/resources/revert/.gitted/objects/1f/a4e069a641f10f5fb7588138b2d147fcd22c36 b/tests/resources/revert/.gitted/objects/1f/a4e069a641f10f5fb7588138b2d147fcd22c36
new file mode 100644
index 000000000..3df134a8d
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/1f/a4e069a641f10f5fb7588138b2d147fcd22c36 differ
diff --git a/tests/resources/revert/.gitted/objects/29/6a6d3be1dff05c5d1f631d2459389fa7b619eb b/tests/resources/revert/.gitted/objects/29/6a6d3be1dff05c5d1f631d2459389fa7b619eb
new file mode 100644
index 000000000..5555268fd
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/29/6a6d3be1dff05c5d1f631d2459389fa7b619eb differ
diff --git a/tests/resources/revert/.gitted/objects/2d/440f2b3147d3dc7ad1085813478d6d869d5a4d b/tests/resources/revert/.gitted/objects/2d/440f2b3147d3dc7ad1085813478d6d869d5a4d
new file mode 100644
index 000000000..c06cc9472
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/2d/440f2b3147d3dc7ad1085813478d6d869d5a4d
@@ -0,0 +1,2 @@
+x
¥ŽK
+1D]ç}
%Iç3"n¼�Èt:΀I$ñúÆ3¸)ŠWð(ª9o´q‡Þ˜aaQ9ËRyífž"É]’JÍv� Y�m¯Ð¸tð“ñÑð„N9‡2%\F°!™/DHÆŠðîkmp‹ŸÐ"Üך÷Zà̃þÚ5oÔê^S?QÍP8Y…~ÖŽÒJ)G;ÿ¡Ž’žõ­<€ÖP¼‹/ælPÞ
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/33/c6fd981c49a2abf2971482089350bfc5cda8ea b/tests/resources/revert/.gitted/objects/33/c6fd981c49a2abf2971482089350bfc5cda8ea
new file mode 100644
index 000000000..683f27f0e
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/33/c6fd981c49a2abf2971482089350bfc5cda8ea differ
diff --git a/tests/resources/revert/.gitted/objects/39/467716290f6df775a91cdb9a4eb39295018145 b/tests/resources/revert/.gitted/objects/39/467716290f6df775a91cdb9a4eb39295018145
new file mode 100644
index 000000000..7c1e01d67
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/39/467716290f6df775a91cdb9a4eb39295018145 differ
diff --git a/tests/resources/revert/.gitted/objects/3a/3ef367eaf3fe79effbfb0a56b269c04c2b59fe b/tests/resources/revert/.gitted/objects/3a/3ef367eaf3fe79effbfb0a56b269c04c2b59fe
new file mode 100644
index 000000000..b83806e68
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/3a/3ef367eaf3fe79effbfb0a56b269c04c2b59fe differ
diff --git a/tests/resources/revert/.gitted/objects/4b/8fcff56437e60f58e9a6bc630dd242ebf6ea2c b/tests/resources/revert/.gitted/objects/4b/8fcff56437e60f58e9a6bc630dd242ebf6ea2c
new file mode 100644
index 000000000..c0bd3dbf9
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/4b/8fcff56437e60f58e9a6bc630dd242ebf6ea2c differ
diff --git a/tests/resources/revert/.gitted/objects/52/c95c4264245469a0617e289a7d737f156826b4 b/tests/resources/revert/.gitted/objects/52/c95c4264245469a0617e289a7d737f156826b4
new file mode 100644
index 000000000..7cc9e9662
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/52/c95c4264245469a0617e289a7d737f156826b4
@@ -0,0 +1,2 @@
+x
¥�=N1…©s
+k›mØU~Ç	!J´È8ÎÎIP&ÀõÉ2@¢°ä÷¤Ïï™jÎk+ñ¡7fð˜ŒCË^'…FF3¹4{–’”dCN")JìÅGh\:¸@‘І¤Q¡f²^E­³™ˆò`“vèEøìKmð¿C‹p]jÞj�'î}{É+µºÕÔÏTó3(sqcŒ“p’NJ1ÜQ´ó?NˆwþâÖáðÆíÆ0·Ph�c¾«í´Ë#¬¥Wؽƒ×eÝ ýrìþüóãnk¹	ZB)�Cd
ÆÛ	QMÚË4Å„è‚Wg,ÏÆk鷺(ëÎâçÛ�ä
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/55/568c8de5322ff9a95d72747a239cdb64a19965 b/tests/resources/revert/.gitted/objects/55/568c8de5322ff9a95d72747a239cdb64a19965
new file mode 100644
index 000000000..4dae50b5d
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/55/568c8de5322ff9a95d72747a239cdb64a19965
@@ -0,0 +1 @@
+x
¥ŽK!]sŠ¾€¦ù
�ãÆx�莓ˆÄx}ñî^jñªr«u`œÝ�ÎZÈ1.‰§E£xYƒ�QÛ¸š¢]�\ŒÉvQOêü€D1vX¬3"bYp5‰ÜJ‘S²\BÊ^+z�[ëp)ê®·V_í
Gžô·Îu˽½šŒCnõSèµ
ìÑ#ªIgèà?.Ô,¦Ê°•Y¾eº«/»ZOH
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/55/acf326a69f0aab7a974ec53ffa55a50bcac14e b/tests/resources/revert/.gitted/objects/55/acf326a69f0aab7a974ec53ffa55a50bcac14e
new file mode 100644
index 000000000..e9cdfc5d5
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/55/acf326a69f0aab7a974ec53ffa55a50bcac14e differ
diff --git a/tests/resources/revert/.gitted/objects/5a/cdc74af27172ec491d213ee36cea7eb9ef2579 b/tests/resources/revert/.gitted/objects/5a/cdc74af27172ec491d213ee36cea7eb9ef2579
new file mode 100644
index 000000000..61055ea80
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/5a/cdc74af27172ec491d213ee36cea7eb9ef2579
@@ -0,0 +1,3 @@
+x
¥�=N1…©s
+w[-Š“8?B4”t\ ?3E&«L×'«' °ä÷é=?9÷Öö	éifˆ6Tg¸æDhµIÞ³4=*·<>zRäªAq‹ƒ�Æ:‡VYm©ÎQ˜K
+ÑpÒA’èÑП5sÈ…Šg”Jg…«€‘£õ†³ÌäU"IRÄï¹õ
ïå'ŽŸ[og?à…½oomÏ£Ÿ½ÎçÜÛ+ ö´fõÁuÅ¥Xt=6ù'Ä�/†4â‘7¸´»:¯y�ý˜Lü:øc’
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/72/333f47d4e83616630ff3b0ffe4c0faebcc3c45 b/tests/resources/revert/.gitted/objects/72/333f47d4e83616630ff3b0ffe4c0faebcc3c45
new file mode 100644
index 000000000..1f6978703
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/72/333f47d4e83616630ff3b0ffe4c0faebcc3c45 differ
diff --git a/tests/resources/revert/.gitted/objects/73/ec36fa120f8066963a0bc9105bb273dbd903d7 b/tests/resources/revert/.gitted/objects/73/ec36fa120f8066963a0bc9105bb273dbd903d7
new file mode 100644
index 000000000..3c8d2c20a
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/73/ec36fa120f8066963a0bc9105bb273dbd903d7 differ
diff --git a/tests/resources/revert/.gitted/objects/74/7726e021bc5f44b86de60e3032fd6f9f1b8383 b/tests/resources/revert/.gitted/objects/74/7726e021bc5f44b86de60e3032fd6f9f1b8383
new file mode 100644
index 000000000..e4d14776f
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/74/7726e021bc5f44b86de60e3032fd6f9f1b8383 differ
diff --git a/tests/resources/revert/.gitted/objects/77/31926a337c4eaba1e2187d90ebfa0a93659382 b/tests/resources/revert/.gitted/objects/77/31926a337c4eaba1e2187d90ebfa0a93659382
new file mode 100644
index 000000000..b87fa1543
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/77/31926a337c4eaba1e2187d90ebfa0a93659382 differ
diff --git a/tests/resources/revert/.gitted/objects/83/f65df4606c4f8dbf8da43de25de1b7e4c03238 b/tests/resources/revert/.gitted/objects/83/f65df4606c4f8dbf8da43de25de1b7e4c03238
new file mode 100644
index 000000000..152ed5f77
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/83/f65df4606c4f8dbf8da43de25de1b7e4c03238 differ
diff --git a/tests/resources/revert/.gitted/objects/8f/d40e13fff575b63e86af87175e70fa7fb92f80 b/tests/resources/revert/.gitted/objects/8f/d40e13fff575b63e86af87175e70fa7fb92f80
new file mode 100644
index 000000000..9ff861728
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/8f/d40e13fff575b63e86af87175e70fa7fb92f80 differ
diff --git a/tests/resources/revert/.gitted/objects/97/f3574e92f1730d365fb9e00c10e3c507c1cfe9 b/tests/resources/revert/.gitted/objects/97/f3574e92f1730d365fb9e00c10e3c507c1cfe9
new file mode 100644
index 000000000..12ebc58df
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/97/f3574e92f1730d365fb9e00c10e3c507c1cfe9 differ
diff --git a/tests/resources/revert/.gitted/objects/a6/9f74efcb51634b88e04ea81273158a85257f41 b/tests/resources/revert/.gitted/objects/a6/9f74efcb51634b88e04ea81273158a85257f41
new file mode 100644
index 000000000..b96831f10
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/a6/9f74efcb51634b88e04ea81273158a85257f41 differ
diff --git a/tests/resources/revert/.gitted/objects/b7/a55408832174c54708906a372a9be2ffe3649b b/tests/resources/revert/.gitted/objects/b7/a55408832174c54708906a372a9be2ffe3649b
new file mode 100644
index 000000000..77d4e20f9
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/b7/a55408832174c54708906a372a9be2ffe3649b differ
diff --git a/tests/resources/revert/.gitted/objects/be/ead165e017269e8dc0dd6f01195726a2e1e01b b/tests/resources/revert/.gitted/objects/be/ead165e017269e8dc0dd6f01195726a2e1e01b
new file mode 100644
index 000000000..57de3f278
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/be/ead165e017269e8dc0dd6f01195726a2e1e01b differ
diff --git a/tests/resources/revert/.gitted/objects/ce/f56612d71a6af8d8015691e4865f7fece905b5 b/tests/resources/revert/.gitted/objects/ce/f56612d71a6af8d8015691e4865f7fece905b5
new file mode 100644
index 000000000..564588539
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/ce/f56612d71a6af8d8015691e4865f7fece905b5 differ
diff --git a/tests/resources/revert/.gitted/objects/d1/d403d22cbe24592d725f442835cf46fe60c8ac b/tests/resources/revert/.gitted/objects/d1/d403d22cbe24592d725f442835cf46fe60c8ac
new file mode 100644
index 000000000..2190bb449
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/d1/d403d22cbe24592d725f442835cf46fe60c8ac differ
diff --git a/tests/resources/revert/.gitted/objects/dd/9a159c89509e73fd37d6af99619994cf7dfc06 b/tests/resources/revert/.gitted/objects/dd/9a159c89509e73fd37d6af99619994cf7dfc06
new file mode 100644
index 000000000..ed80d0aa5
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/dd/9a159c89509e73fd37d6af99619994cf7dfc06 differ
diff --git a/tests/resources/revert/.gitted/objects/eb/b03002cee5d66c7732dd06241119fe72ab96a5 b/tests/resources/revert/.gitted/objects/eb/b03002cee5d66c7732dd06241119fe72ab96a5
new file mode 100644
index 000000000..802125ebb
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/eb/b03002cee5d66c7732dd06241119fe72ab96a5
@@ -0,0 +1,2 @@
+x
¥�Á	1E=§Ši@I6&AÄ‹Ø@6;ÃÌdGlßXƒ‡Ÿwø¯HkUÁa<h'äålÉyf)ÌÑÆ̘\
+”,çÄóeb´&¿u•�å“ûÏUÚ.\iØߺ·ZºìÂz*Ònà<†Áä#m°Ö;ÂJ\˜ºU­ùe¾8[>`
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/f4/e107c230d08a60fb419d19869f1f282b272d9c b/tests/resources/revert/.gitted/objects/f4/e107c230d08a60fb419d19869f1f282b272d9c
new file mode 100644
index 000000000..029da1ba9
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/f4/e107c230d08a60fb419d19869f1f282b272d9c differ
diff --git a/tests/resources/revert/.gitted/refs/heads/master b/tests/resources/revert/.gitted/refs/heads/master
new file mode 100644
index 000000000..d3850daa6
--- /dev/null
+++ b/tests/resources/revert/.gitted/refs/heads/master
@@ -0,0 +1 @@
+2d440f2b3147d3dc7ad1085813478d6d869d5a4d
diff --git a/tests/resources/revert/.gitted/refs/heads/merges b/tests/resources/revert/.gitted/refs/heads/merges
new file mode 100644
index 000000000..6533a947b
--- /dev/null
+++ b/tests/resources/revert/.gitted/refs/heads/merges
@@ -0,0 +1 @@
+5acdc74af27172ec491d213ee36cea7eb9ef2579
diff --git a/tests/resources/revert/.gitted/refs/heads/merges-branch b/tests/resources/revert/.gitted/refs/heads/merges-branch
new file mode 100644
index 000000000..febb29c44
--- /dev/null
+++ b/tests/resources/revert/.gitted/refs/heads/merges-branch
@@ -0,0 +1 @@
+13ee9cd5d8e1023c218e0e1ea684ec0c582b5050
diff --git a/tests/resources/revert/.gitted/refs/heads/reverted-branch b/tests/resources/revert/.gitted/refs/heads/reverted-branch
new file mode 100644
index 000000000..16bb7a2d7
--- /dev/null
+++ b/tests/resources/revert/.gitted/refs/heads/reverted-branch
@@ -0,0 +1 @@
+52c95c4264245469a0617e289a7d737f156826b4
diff --git a/tests/resources/revert/file1.txt b/tests/resources/revert/file1.txt
new file mode 100644
index 000000000..84b225940
--- /dev/null
+++ b/tests/resources/revert/file1.txt
@@ -0,0 +1,14 @@
+!File one!
+!File one!
+File one!
+File one
+File one
+File one
+File one
+File one
+File one
+File one
+File one!
+!File one!
+!File one!
+!File one!
diff --git a/tests/resources/revert/file2.txt b/tests/resources/revert/file2.txt
new file mode 100644
index 000000000..acb5747b3
--- /dev/null
+++ b/tests/resources/revert/file2.txt
@@ -0,0 +1,16 @@
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
+File two
diff --git a/tests/resources/revert/file3.txt b/tests/resources/revert/file3.txt
new file mode 100644
index 000000000..b0330597f
--- /dev/null
+++ b/tests/resources/revert/file3.txt
@@ -0,0 +1,16 @@
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
+File three
diff --git a/tests/resources/revert/file6.txt b/tests/resources/revert/file6.txt
new file mode 100644
index 000000000..5c0cd5d56
--- /dev/null
+++ b/tests/resources/revert/file6.txt
@@ -0,0 +1,14 @@
+File six, actually!
+File four!
+File four!
+File four!
+File four!
+File four!
+File four!
+File four!
+File four!
+File four!
+File four!
+File four!
+File four!
+File four!
diff --git a/tests/revert/revert.c b/tests/revert/revert.c
new file mode 100644
index 000000000..4a45190b9
--- /dev/null
+++ b/tests/revert/revert.c
@@ -0,0 +1,364 @@
+#include "clar.h"
+#include "clar_libgit2.h"
+
+#include "buffer.h"
+#include "fileops.h"
+#include "git2/revert.h"
+
+#include "../merge/merge_helpers.h"
+
+#define TEST_REPO_PATH "revert"
+
+static git_repository *repo;
+static git_index *repo_index;
+
+// Fixture setup and teardown
+void test_revert_revert__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+	git_repository_index(&repo_index, repo);
+}
+
+void test_revert_revert__cleanup(void)
+{
+	git_index_free(repo_index);
+	cl_git_sandbox_cleanup();
+}
+
+/* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45
+ * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */
+void test_revert_revert__automerge(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git revert --no-commit 72333f47d4e83616630ff3b0ffe4c0faebcc3c45 */
+void test_revert_revert__conflicts(void)
+{
+	git_reference *head_ref;
+	git_commit *head, *commit;
+	git_oid revert_oid;
+	git_buf conflicting_buf = GIT_BUF_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 1, "file1.txt" },
+		{ 0100644, "4b8fcff56437e60f58e9a6bc630dd242ebf6ea2c", 2, "file1.txt" },
+		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 3, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+
+	cl_git_pass(git_repository_head(&head_ref, repo));
+	cl_git_pass(git_reference_peel((git_object **)&head, head_ref, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
+
+	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
+		TEST_REPO_PATH "/file1.txt"));
+	cl_assert(strcmp(conflicting_buf.ptr, "!File one!\n" \
+		"!File one!\n" \
+		"File one!\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"<<<<<<< HEAD\n" \
+		"File one!\n" \
+		"!File one!\n" \
+		"!File one!\n" \
+		"!File one!\n" \
+		"=======\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		">>>>>>> parent of 72333f4... automergeable changes\n") == 0);
+
+	git_commit_free(commit);
+	git_commit_free(head);
+	git_reference_free(head_ref);
+	git_buf_free(&conflicting_buf);
+}
+
+/* git reset --hard 39467716290f6df775a91cdb9a4eb39295018145
+ * git revert --no-commit ebb03002cee5d66c7732dd06241119fe72ab96a5
+*/
+void test_revert_revert__orphan(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 1));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45
+ * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */
+void test_revert_revert__conflict_use_ours(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.merge_tree_opts.automerge_flags = GIT_MERGE_AUTOMERGE_NONE;
+	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 1, "file1.txt" },
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 2, "file1.txt" },
+		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 3, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	struct merge_index_entry merge_filesystem_entries[] = {
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
+	cl_assert(merge_test_workdir(repo, merge_filesystem_entries, 4));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard cef56612d71a6af8d8015691e4865f7fece905b5
+ * git revert --no-commit 55568c8de5322ff9a95d72747a239cdb64a19965
+ */
+void test_revert_revert__rename_1_of_2(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_tree_opts.rename_threshold = 50;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 3, "file4.txt" },
+		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 1, "file5.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 2, "file6.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "cef56612d71a6af8d8015691e4865f7fece905b5");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard 55568c8de5322ff9a95d72747a239cdb64a19965
+ * git revert --no-commit HEAD~1 */
+void test_revert_revert__rename(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_tree_opts.rename_threshold = 50;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 1, "file4.txt" },
+		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 2, "file5.txt" },
+	};
+
+	struct merge_name_entry merge_name_entries[] = {
+		{ "file4.txt", "file5.txt", "" },
+	};
+
+	git_oid_fromstr(&head_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "0aa8c7e40d342fff78d60b29a4ba8e993ed79c51");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 2));
+	cl_assert(merge_test_names(repo_index, merge_name_entries, 1));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git revert --no-commit HEAD */
+void test_revert_revert__head(void)
+{
+	git_reference *head;
+	git_commit *commit;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	/* HEAD is 2d440f2b3147d3dc7ad1085813478d6d869d5a4d */
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+	cl_assert(merge_test_workdir(repo, merge_index_entries, 4));
+
+	git_reference_free(head);
+	git_commit_free(commit);
+}
+
+void test_revert_revert__nonmerge_fails_mainline_specified(void)
+{
+	git_reference *head;
+	git_commit *commit;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
+
+	opts.mainline = 1;
+	cl_must_fail(git_revert(repo, commit, &opts));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/REVERT_HEAD"));
+
+	git_reference_free(head);
+	git_commit_free(commit);
+}
+
+/* git reset --hard 5acdc74af27172ec491d213ee36cea7eb9ef2579
+ * git revert HEAD */
+void test_revert_revert__merge_fails_without_mainline_specified(void)
+{
+	git_commit *head;
+	git_oid head_oid;
+
+	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	cl_must_fail(git_revert(repo, head, NULL));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/REVERT_HEAD"));
+
+	git_commit_free(head);
+}
+
+/* git reset --hard 5acdc74af27172ec491d213ee36cea7eb9ef2579
+ * git revert HEAD -m1 --no-commit */
+void test_revert_revert__merge_first_parent(void)
+{
+	git_commit *head;
+	git_oid head_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.mainline = 1;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
+		{ 0100644, "0cdb66192ee192f70f891f05a47636057420e871", 0, "file1.txt" },
+		{ 0100644, "73ec36fa120f8066963a0bc9105bb273dbd903d7", 0, "file2.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	cl_git_pass(git_revert(repo, head, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
+
+	git_commit_free(head);
+}
+
+void test_revert_revert__merge_second_parent(void)
+{
+	git_commit *head;
+	git_oid head_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.mainline = 2;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "33c6fd981c49a2abf2971482089350bfc5cda8ea", 0, "file-branch.txt" },
+		{ 0100644, "0cdb66192ee192f70f891f05a47636057420e871", 0, "file1.txt" },
+		{ 0100644, "73ec36fa120f8066963a0bc9105bb273dbd903d7", 0, "file2.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	cl_git_pass(git_revert(repo, head, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
+
+	git_commit_free(head);
+}
-- 
cgit v1.2.3


From bab0b9f2d21d993c3f25ee00ce2d243a4dc0de93 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 22 Nov 2013 18:02:12 -0500
Subject: clean up state metadata more consistently

---
 include/git2/repository.h |  6 +++---
 src/merge.c               | 46 ++++++++++++----------------------------------
 src/repository.c          | 36 ++++++++++++++++++++++++++++++++++++
 src/repository.h          |  2 ++
 src/reset.c               |  2 +-
 src/revert.c              | 37 ++++++++-----------------------------
 src/revert.h              | 14 --------------
 7 files changed, 62 insertions(+), 81 deletions(-)
 delete mode 100644 src/revert.h

diff --git a/include/git2/repository.h b/include/git2/repository.h
index b4d561992..c6bd4dca4 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -488,13 +488,13 @@ GIT_EXTERN(int) git_repository_message(char *out, size_t len, git_repository *re
 GIT_EXTERN(int) git_repository_message_remove(git_repository *repo);
 
 /**
- * Remove all the metadata associated with an ongoing git merge, including
- * MERGE_HEAD, MERGE_MSG, etc.
+ * Remove all the metadata associated with an ongoing command like merge,
+ * revert, cherry-pick, etc.  For example: MERGE_HEAD, MERGE_MSG, etc.
  *
  * @param repo A repository object
  * @return 0 on success, or error
  */
-GIT_EXTERN(int) git_repository_merge_cleanup(git_repository *repo);
+GIT_EXTERN(int) git_repository_state_cleanup(git_repository *repo);
 
 typedef int (*git_repository_fetchhead_foreach_cb)(const char *ref_name,
 	const char *remote_url,
diff --git a/src/merge.c b/src/merge.c
index c31a935b0..05e656d1e 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2362,6 +2362,17 @@ done:
 	return error;
 }
 
+static int merge_state_cleanup(git_repository *repo)
+{
+	const char *state_files[] = {
+		GIT_MERGE_HEAD_FILE,
+		GIT_MERGE_MODE_FILE,
+		GIT_MERGE_MSG_FILE,
+	};
+
+	return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
+}
+
 int git_merge(
 	git_merge_result **out,
 	git_repository *repo,
@@ -2453,7 +2464,7 @@ int git_merge(
 	goto done;
 
 on_error:
-	git_repository_merge_cleanup(repo);
+	merge_state_cleanup(repo);
 
 	git_index_free(index_new);
 	git__free(result);
@@ -2497,39 +2508,6 @@ int git_merge__setup(
 	return error;
 }
 
-int git_repository_merge_cleanup(git_repository *repo)
-{
-	int error = 0;
-	git_buf merge_head_path = GIT_BUF_INIT,
-		merge_mode_path = GIT_BUF_INIT,
-		merge_msg_path = GIT_BUF_INIT;
-
-	assert(repo);
-
-	if (git_buf_joinpath(&merge_head_path, repo->path_repository, GIT_MERGE_HEAD_FILE) < 0 ||
-		git_buf_joinpath(&merge_mode_path, repo->path_repository, GIT_MERGE_MODE_FILE) < 0 ||
-		git_buf_joinpath(&merge_msg_path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
-		return -1;
-
-	if (git_path_isfile(merge_head_path.ptr)) {
-		if ((error = p_unlink(merge_head_path.ptr)) < 0)
-			goto cleanup;
-	}
-
-	if (git_path_isfile(merge_mode_path.ptr))
-		(void)p_unlink(merge_mode_path.ptr);
-
-	if (git_path_isfile(merge_msg_path.ptr))
-		(void)p_unlink(merge_msg_path.ptr);
-
-cleanup:
-	git_buf_free(&merge_msg_path);
-	git_buf_free(&merge_mode_path);
-	git_buf_free(&merge_head_path);
-
-	return error;
-}
-
 /* Merge result data */
 
 int git_merge_result_is_uptodate(git_merge_result *merge_result)
diff --git a/src/repository.c b/src/repository.c
index dcc02e4fb..278c0384e 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1965,6 +1965,42 @@ int git_repository_state(git_repository *repo)
 	return state;
 }
 
+int git_repository__cleanup_files(git_repository *repo, const char *files[], size_t files_len)
+{
+	git_buf path = GIT_BUF_INIT;
+	size_t i;
+	int error = 0;
+
+	for (i = 0; i < files_len; ++i) {
+		git_buf_clear(&path);
+
+		if ((error = git_buf_joinpath(&path, repo->path_repository, files[i])) < 0 ||
+			(git_path_isfile(git_buf_cstr(&path)) &&
+			(error = p_unlink(git_buf_cstr(&path))) < 0))
+			goto done;
+	}
+
+done:
+	git_buf_free(&path);
+
+	return error;
+}
+
+static const char *state_files[] = {
+	GIT_MERGE_HEAD_FILE,
+	GIT_MERGE_MODE_FILE,
+	GIT_MERGE_MSG_FILE,
+	GIT_REVERT_HEAD_FILE,
+	GIT_CHERRY_PICK_HEAD_FILE,
+};
+
+int git_repository_state_cleanup(git_repository *repo)
+{
+	assert(repo);
+
+	return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
+}
+
 int git_repository_is_shallow(git_repository *repo)
 {
 	git_buf path = GIT_BUF_INIT;
diff --git a/src/repository.h b/src/repository.h
index 832df3bd2..4e79714f1 100644
--- a/src/repository.h
+++ b/src/repository.h
@@ -169,4 +169,6 @@ GIT_INLINE(int) git_repository__ensure_not_bare(
 	return GIT_EBAREREPO;
 }
 
+int git_repository__cleanup_files(git_repository *repo, const char *files[], size_t files_len);
+
 #endif
diff --git a/src/reset.c b/src/reset.c
index a9780bfbc..261a36576 100644
--- a/src/reset.c
+++ b/src/reset.c
@@ -149,7 +149,7 @@ int git_reset(
 			(error = git_index_write(index)) < 0)
 			goto cleanup;
 
-		if ((error = git_repository_merge_cleanup(repo)) < 0) {
+		if ((error = git_repository_state_cleanup(repo)) < 0) {
 			giterr_set(GITERR_INDEX, "%s - failed to clean up merge data", ERROR_MSG);
 			goto cleanup;
 		}
diff --git a/src/revert.c b/src/revert.c
index 34ba343b6..5660c9919 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -9,7 +9,6 @@
 #include "repository.h"
 #include "filebuf.h"
 #include "merge.h"
-#include "revert.h"
 
 #include "git2/types.h"
 #include "git2/merge.h"
@@ -103,6 +102,13 @@ static int revert_normalize_opts(
 	return error;
 }
 
+static int revert_state_cleanup(git_repository *repo)
+{
+	const char *state_files[] = { GIT_REVERT_HEAD_FILE, GIT_MERGE_MSG_FILE };
+
+	return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
+}
+
 int git_revert(
 	git_repository *repo,
 	git_commit *commit,
@@ -175,7 +181,7 @@ int git_revert(
 	goto done;
 
 on_error:
-	git_revert__cleanup(repo);
+	revert_state_cleanup(repo);
 
 done:
 	git_index_free(index_new);
@@ -188,30 +194,3 @@ done:
 
 	return error;
 }
-
-int git_revert__cleanup(git_repository *repo)
-{
-	int error = 0;
-	git_buf revert_head_path = GIT_BUF_INIT,
-		merge_msg_path = GIT_BUF_INIT;
-
-	assert(repo);
-
-	if (git_buf_joinpath(&revert_head_path, repo->path_repository, GIT_REVERT_HEAD_FILE) < 0 ||
-		git_buf_joinpath(&merge_msg_path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
-		return -1;
-
-	if (git_path_isfile(revert_head_path.ptr)) {
-		if ((error = p_unlink(revert_head_path.ptr)) < 0)
-			goto cleanup;
-	}
-
-	if (git_path_isfile(merge_msg_path.ptr))
-		(void)p_unlink(merge_msg_path.ptr);
-
-cleanup:
-	git_buf_free(&merge_msg_path);
-	git_buf_free(&revert_head_path);
-
-	return error;
-}
diff --git a/src/revert.h b/src/revert.h
deleted file mode 100644
index ed3912198..000000000
--- a/src/revert.h
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_revert_h__
-#define INCLUDE_revert_h__
-
-#include "git2/repository.h"
-
-int git_revert__cleanup(git_repository *repo);
-
-#endif
-- 
cgit v1.2.3


From db4cbfe5041d2dca342b123c14259d1860ed4c8c Mon Sep 17 00:00:00 2001
From: Jameson Miller <jamill@microsoft.com>
Date: Mon, 2 Dec 2013 14:09:12 -0500
Subject: Updates to cancellation logic during download and indexing of
 packfile.

---
 src/indexer.c                   | 28 +++++++++++++++++-----------
 src/transports/smart_protocol.c | 30 ++++++++++++++++++++++--------
 2 files changed, 39 insertions(+), 19 deletions(-)

diff --git a/src/indexer.c b/src/indexer.c
index df1ce7cfb..852a04120 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -386,8 +386,13 @@ on_error:
 
 static int do_progress_callback(git_indexer *idx, git_transfer_progress *stats)
 {
-	if (!idx->progress_cb) return 0;
-	return idx->progress_cb(stats, idx->progress_payload);
+	if (idx->progress_cb &&
+		idx->progress_cb(stats, idx->progress_payload)) {
+			giterr_clear();
+			return GIT_EUSER;
+	}
+
+	return 0;
 }
 
 /* Hash everything but the last 20B of input */
@@ -491,7 +496,9 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 		stats->indexed_deltas = 0;
 		processed = stats->indexed_objects = 0;
 		stats->total_objects = total_objects;
-		do_progress_callback(idx, stats);
+
+		if ((error = do_progress_callback(idx, stats)) < 0)
+			return error;
 	}
 
 	/* Now that we have data in the pack, let's try to parse it */
@@ -573,11 +580,8 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 		}
 		stats->received_objects++;
 
-		if (do_progress_callback(idx, stats) != 0) {
-			giterr_clear();
-			error = GIT_EUSER;
+		if ((error = do_progress_callback(idx, stats)) < 0)
 			goto on_error;
-		}
 	}
 
 	return 0;
@@ -749,7 +753,7 @@ static int resolve_deltas(git_indexer *idx, git_transfer_progress *stats)
 {
 	unsigned int i;
 	struct delta_info *delta;
-	int progressed = 0;
+	int progressed = 0, progress_cb_result;
 
 	while (idx->deltas.length > 0) {
 		progressed = 0;
@@ -767,7 +771,8 @@ static int resolve_deltas(git_indexer *idx, git_transfer_progress *stats)
 			stats->indexed_objects++;
 			stats->indexed_deltas++;
 			progressed = 1;
-			do_progress_callback(idx, stats);
+			if ((progress_cb_result = do_progress_callback(idx, stats)) < 0)
+				return progress_cb_result;
 
 			/*
 			 * Remove this delta from the list and
@@ -841,6 +846,7 @@ int git_indexer_commit(git_indexer *idx, git_transfer_progress *stats)
 {
 	git_mwindow *w = NULL;
 	unsigned int i, long_offsets = 0, left;
+	int error;
 	struct git_pack_idx_header hdr;
 	git_buf filename = GIT_BUF_INIT;
 	struct entry *entry;
@@ -877,8 +883,8 @@ int git_indexer_commit(git_indexer *idx, git_transfer_progress *stats)
 	/* Freeze the number of deltas */
 	stats->total_deltas = stats->total_objects - stats->indexed_objects;
 
-	if (resolve_deltas(idx, stats) < 0)
-		return -1;
+	if ((error = resolve_deltas(idx, stats)) < 0)
+		return error;
 
 	if (stats->indexed_objects != stats->total_objects) {
 		giterr_set(GITERR_INDEXER, "early EOF");
diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index 3bf1f9329..a4046ee43 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -521,7 +521,7 @@ int git_smart__download_pack(
 
 		/* Check cancellation before network call */
 		if (t->cancelled.val) {
-			giterr_set(GITERR_NET, "The fetch was cancelled by the user");
+			giterr_clear();
 			error = GIT_EUSER;
 			goto done;
 		}
@@ -531,7 +531,7 @@ int git_smart__download_pack(
 
 		/* Check cancellation after network call */
 		if (t->cancelled.val) {
-			giterr_set(GITERR_NET, "The fetch was cancelled by the user");
+			giterr_clear();
 			error = GIT_EUSER;
 			goto done;
 		}
@@ -540,8 +540,9 @@ int git_smart__download_pack(
 			if (t->progress_cb) {
 				git_pkt_progress *p = (git_pkt_progress *) pkt;
 				if (t->progress_cb(p->data, p->len, t->message_cb_payload)) {
-					giterr_set(GITERR_NET, "The fetch was cancelled by the user");
-					return GIT_EUSER;
+					giterr_clear();
+					error = GIT_EUSER;
+					goto done;
 				}
 			}
 			git__free(pkt);
@@ -559,16 +560,29 @@ int git_smart__download_pack(
 		}
 	} while (1);
 
+	/*
+	 * Trailing execution of progress_cb, if necessary...
+	 * Only the callback through the npp datastructure currently
+	 * updates the last_fired_bytes value. It is possible that
+	 * progress has already been reported with the correct 
+	 * "received_bytes" value, but until (if?) this is unified
+	 * then we will report progress again to be sure that the
+	 * correct last received_bytes value is reported.
+	 */
+	if (npp.callback && npp.stats->received_bytes > npp.last_fired_bytes) {
+		if (npp.callback(npp.stats, npp.payload) < 0) {
+			giterr_clear();
+			error = GIT_EUSER;
+			goto done;
+		}
+	}
+
 	error = writepack->commit(writepack, stats);
 
 done:
 	if (writepack)
 		writepack->free(writepack);
 
-	/* Trailing execution of progress_cb, if necessary */
-	if (npp.callback && npp.stats->received_bytes > npp.last_fired_bytes)
-		npp.callback(npp.stats, npp.payload);
-
 	return error;
 }
 
-- 
cgit v1.2.3


From d706e843e1e2e1b5edca57fe691d9e72fd844ffd Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Tue, 3 Dec 2013 23:00:50 +0800
Subject: Include git2/revert.h in git2.h

---
 include/git2.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/git2.h b/include/git2.h
index d00a20a2e..704fb585a 100644
--- a/include/git2.h
+++ b/include/git2.h
@@ -43,6 +43,7 @@
 #include "git2/remote.h"
 #include "git2/repository.h"
 #include "git2/reset.h"
+#include "git2/revert.h"
 #include "git2/revparse.h"
 #include "git2/revwalk.h"
 #include "git2/signature.h"
-- 
cgit v1.2.3


From eac938d96eccb39c30ce94adf7f8cdc06df098fe Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 2 Dec 2013 14:10:04 -0500
Subject: Bare naked merge and rebase

---
 include/git2/merge.h        |  20 +++
 include/git2/revert.h       |  37 ++++-
 src/merge.c                 |  34 +++++
 src/revert.c                | 110 ++++++++-----
 tests/merge/merge_helpers.c |  28 ++++
 tests/merge/merge_helpers.h |   5 +
 tests/merge/trees/commits.c | 164 ++++++++++++++++++++
 tests/revert/bare.c         | 107 +++++++++++++
 tests/revert/revert.c       | 364 --------------------------------------------
 tests/revert/workdir.c      | 364 ++++++++++++++++++++++++++++++++++++++++++++
 10 files changed, 821 insertions(+), 412 deletions(-)
 create mode 100644 tests/merge/trees/commits.c
 create mode 100644 tests/revert/bare.c
 delete mode 100644 tests/revert/revert.c
 create mode 100644 tests/revert/workdir.c

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 3354fbeab..8a1dfec2e 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -191,6 +191,26 @@ GIT_EXTERN(int) git_merge_trees(
 	const git_tree *their_tree,
 	const git_merge_tree_opts *opts);
 
+/**
+ * Merge two commits, producing a `git_index` that reflects the result of
+ * the merge.
+ *
+ * The returned index must be freed explicitly with `git_index_free`.
+ *
+ * @param out pointer to store the index result in
+ * @param repo repository that contains the given trees
+ * @param our_commit the commit that reflects the destination tree
+ * @param their_commit the commit to merge in to `our_commit`
+ * @param opts the merge tree options (or null for defaults)
+ * @return zero on success, -1 on failure.
+ */
+GIT_EXTERN(int) git_merge_commits(
+	git_index **out,
+	git_repository *repo,
+	const git_commit *our_commit,
+	const git_commit *their_commit,
+	const git_merge_tree_opts *opts);
+
 /**
  * Merges the given commits into HEAD, producing a new commit.
  *
diff --git a/include/git2/revert.h b/include/git2/revert.h
index fe84238c5..86a6e26cb 100644
--- a/include/git2/revert.h
+++ b/include/git2/revert.h
@@ -34,13 +34,36 @@ typedef struct {
 #define GIT_REVERT_OPTS_INIT {GIT_REVERT_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
 
 /**
-* Reverts the given commits, producing changes in the working directory.
-*
-* @param repo the repository to revert
-* @param commits the commits to revert
-* @param commits_len the number of commits to revert
-* @param flags merge flags
-*/
+ * Reverts the given commit against the given "our" commit, producing an
+ * index that reflects the result of the revert.
+ *
+ * The returned index must be freed explicitly with `git_index_free`.
+ *
+ * @param out pointer to store the index result in
+ * @param repo the repository that contains the given commits
+ * @param revert_commit the commit to revert
+ * @param our_commit the commit to revert against (eg, HEAD)
+ * @param mainline the parent of the revert commit, if it is a merge
+ * @param merge_tree_opts the merge tree options (or null for defaults)
+ * @return zero on success, -1 on failure.
+ */
+int git_revert_commit(
+	git_index **out,
+	git_repository *repo,
+	git_commit *revert_commit,
+	git_commit *our_commit,
+	unsigned int mainline,
+	const git_merge_tree_opts *merge_tree_opts);
+
+/**
+ * Reverts the given commit, producing changes in the working directory.
+ *
+ * @param repo the repository to revert
+ * @param commits the commits to revert
+ * @param commits_len the number of commits to revert
+ * @param flags merge flags
+ * @return zero on success, -1 on failure.
+ */
 GIT_EXTERN(int) git_revert(
 	git_repository *repo,
 	git_commit *commit,
diff --git a/src/merge.c b/src/merge.c
index 05e656d1e..ef138c284 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -1609,6 +1609,40 @@ done:
 	return error;
 }
 
+int git_merge_commits(
+	git_index **out,
+	git_repository *repo,
+	const git_commit *our_commit,
+	const git_commit *their_commit,
+	const git_merge_tree_opts *opts)
+{
+	git_oid ancestor_oid;
+	git_commit *ancestor_commit = NULL;
+	git_tree *our_tree = NULL, *their_tree = NULL, *ancestor_tree = NULL;
+	int error = 0;
+
+	if ((error = git_merge_base(&ancestor_oid, repo, git_commit_id(our_commit), git_commit_id(their_commit))) < 0 &&
+		error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0 ||
+		(error = git_commit_lookup(&ancestor_commit, repo, &ancestor_oid)) < 0 ||
+		(error = git_commit_tree(&ancestor_tree, ancestor_commit)) < 0)
+		goto done;
+
+	if ((error = git_commit_tree(&our_tree, our_commit)) < 0 ||
+		(error = git_commit_tree(&their_tree, their_commit)) < 0 ||
+		(error = git_merge_trees(out, repo, ancestor_tree, our_tree, their_tree, opts)) < 0)
+		goto done;
+
+done:
+	git_commit_free(ancestor_commit);
+	git_tree_free(our_tree);
+	git_tree_free(their_tree);
+	git_tree_free(ancestor_tree);
+
+	return error;
+}
+
 /* Merge setup / cleanup */
 
 static int write_orig_head(
diff --git a/src/revert.c b/src/revert.c
index 5660c9919..7ed04fee3 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -109,20 +109,79 @@ static int revert_state_cleanup(git_repository *repo)
 	return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
 }
 
+static int revert_seterr(git_commit *commit, const char *fmt)
+{
+	char commit_oidstr[GIT_OID_HEXSZ + 1];
+
+	git_oid_fmt(commit_oidstr, git_commit_id(commit));
+	commit_oidstr[GIT_OID_HEXSZ] = '\0';
+
+	giterr_set(GITERR_REVERT, fmt, commit_oidstr);
+
+	return -1;
+}
+
+int git_revert_commit(
+	git_index **out,
+	git_repository *repo,
+	git_commit *revert_commit,
+	git_commit *our_commit,
+	unsigned int mainline,
+	const git_merge_tree_opts *merge_tree_opts)
+{
+	git_commit *parent_commit = NULL;
+	git_tree *parent_tree = NULL, *our_tree = NULL, *revert_tree = NULL;
+	int parent = 0, error = 0;
+
+	assert(out && repo && revert_commit && our_commit);
+
+	if (git_commit_parentcount(revert_commit) > 1) {
+		if (!mainline)
+			return revert_seterr(revert_commit,
+				"Mainline branch is not specified but %s is a merge commit");
+
+		parent = mainline;
+	} else {
+		if (mainline)
+			return revert_seterr(revert_commit,
+				"Mainline branch specified but %s is not a merge commit");
+
+		parent = git_commit_parentcount(revert_commit);
+	}
+
+	if (parent &&
+		((error = git_commit_parent(&parent_commit, revert_commit, (parent - 1))) < 0 ||
+		(error = git_commit_tree(&parent_tree, parent_commit)) < 0))
+		goto done;
+
+	if ((error = git_commit_tree(&revert_tree, revert_commit)) < 0 ||
+		(error = git_commit_tree(&our_tree, our_commit)) < 0)
+		goto done;
+
+	error = git_merge_trees(out, repo, revert_tree, our_tree, parent_tree, merge_tree_opts);
+
+done:
+	git_tree_free(parent_tree);
+	git_tree_free(our_tree);
+	git_tree_free(revert_tree);
+	git_commit_free(parent_commit);
+
+	return error;
+}
+
 int git_revert(
 	git_repository *repo,
 	git_commit *commit,
 	const git_revert_opts *given_opts)
 {
 	git_revert_opts opts;
-	git_commit *parent_commit = NULL;
-	git_tree *parent_tree = NULL, *our_tree = NULL, *revert_tree = NULL;
-	git_index *index_new = NULL, *index_repo = NULL;
+	git_reference *our_ref = NULL;
+	git_commit *our_commit = NULL;
 	char commit_oidstr[GIT_OID_HEXSZ + 1];
 	const char *commit_msg;
 	git_buf their_label = GIT_BUF_INIT;
-	int parent = 0;
-	int error = 0;
+	git_index *index_new = NULL, *index_repo = NULL;
+	int error;
 
 	assert(repo && commit);
 
@@ -141,38 +200,9 @@ int git_revert(
 		(error = revert_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 ||
 		(error = write_revert_head(repo, commit, commit_oidstr)) < 0 ||
 		(error = write_merge_msg(repo, commit, commit_oidstr, commit_msg)) < 0 ||
-		(error = git_repository_head_tree(&our_tree, repo)) < 0 ||
-		(error = git_commit_tree(&revert_tree, commit)) < 0)
-		goto on_error;
-
-	if (git_commit_parentcount(commit) > 1) {
-		if (!opts.mainline) {
-			giterr_set(GITERR_REVERT,
-				"Mainline branch is not specified but %s is a merge commit",
-				commit_oidstr);
-			error = -1;
-			goto on_error;
-		}
-
-		parent = opts.mainline;
-	} else {
-		if (opts.mainline) {
-			giterr_set(GITERR_REVERT,
-				"Mainline branch was specified but %s is not a merge",
-				commit_oidstr);
-			error = -1;
-			goto on_error;
-		}
-
-		parent = git_commit_parentcount(commit);
-	}
-
-	if (parent &&
-		((error = git_commit_parent(&parent_commit, commit, (parent - 1))) < 0 ||
-		(error = git_commit_tree(&parent_tree, parent_commit)) < 0))
-		goto on_error;
-
-	if ((error = git_merge_trees(&index_new, repo, revert_tree, our_tree, parent_tree, &opts.merge_tree_opts)) < 0 ||
+		(error = git_repository_head(&our_ref, repo)) < 0 ||
+		(error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJ_COMMIT)) < 0 ||
+		(error = git_revert_commit(&index_new, repo, commit, our_commit, opts.mainline, &opts.merge_tree_opts)) < 0 ||
 		(error = git_merge__indexes(repo, index_new)) < 0 ||
 		(error = git_repository_index(&index_repo, repo)) < 0 ||
 		(error = git_checkout_index(repo, index_repo, &opts.checkout_opts)) < 0)
@@ -186,10 +216,8 @@ on_error:
 done:
 	git_index_free(index_new);
 	git_index_free(index_repo);
-	git_tree_free(parent_tree);
-	git_tree_free(our_tree);
-	git_tree_free(revert_tree);
-	git_commit_free(parent_commit);
+	git_commit_free(our_commit);
+	git_reference_free(our_ref);
 	git_buf_free(&their_label);
 
 	return error;
diff --git a/tests/merge/merge_helpers.c b/tests/merge/merge_helpers.c
index 43619be0d..7ca1e6522 100644
--- a/tests/merge/merge_helpers.c
+++ b/tests/merge/merge_helpers.c
@@ -52,6 +52,34 @@ int merge_trees_from_branches(
 	return 0;
 }
 
+int merge_commits_from_branches(
+	git_index **index, git_repository *repo,
+	const char *ours_name, const char *theirs_name,
+	git_merge_tree_opts *opts)
+{
+	git_commit *our_commit, *their_commit;
+	git_oid our_oid, their_oid;
+	git_buf branch_buf = GIT_BUF_INIT;
+	int error;
+
+	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, ours_name);
+	cl_git_pass(git_reference_name_to_id(&our_oid, repo, branch_buf.ptr));
+	cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid));
+
+	git_buf_clear(&branch_buf);
+	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, theirs_name);
+	cl_git_pass(git_reference_name_to_id(&their_oid, repo, branch_buf.ptr));
+	cl_git_pass(git_commit_lookup(&their_commit, repo, &their_oid));
+
+	cl_git_pass(git_merge_commits(index, repo, our_commit, their_commit, opts));
+
+	git_buf_free(&branch_buf);
+	git_commit_free(our_commit);
+	git_commit_free(their_commit);
+
+	return 0;
+}
+
 int merge_branches(git_merge_result **result, git_repository *repo, const char *ours_branch, const char *theirs_branch, git_merge_opts *opts)
 {
 	git_reference *head_ref, *theirs_ref;
diff --git a/tests/merge/merge_helpers.h b/tests/merge/merge_helpers.h
index ae3274437..3f53abc7c 100644
--- a/tests/merge/merge_helpers.h
+++ b/tests/merge/merge_helpers.h
@@ -44,6 +44,11 @@ int merge_trees_from_branches(
 	const char *ours_name, const char *theirs_name,
 	git_merge_tree_opts *opts);
 
+int merge_commits_from_branches(
+	git_index **index, git_repository *repo,
+	const char *ours_name, const char *theirs_name,
+	git_merge_tree_opts *opts);
+
 int merge_branches(git_merge_result **result, git_repository *repo,
 	const char *ours_branch, const char *theirs_branch, git_merge_opts *opts);
 
diff --git a/tests/merge/trees/commits.c b/tests/merge/trees/commits.c
new file mode 100644
index 000000000..92680c3c7
--- /dev/null
+++ b/tests/merge/trees/commits.c
@@ -0,0 +1,164 @@
+#include "clar_libgit2.h"
+#include "git2/repository.h"
+#include "git2/merge.h"
+#include "merge.h"
+#include "../merge_helpers.h"
+
+static git_repository *repo;
+
+#define TEST_REPO_PATH "merge-resolve"
+
+#define AUTOMERGEABLE_MERGED_FILE \
+	"this file is changed in master\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is changed in branch\n"
+
+void test_merge_trees_commits__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+}
+
+void test_merge_trees_commits__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+static void merge_commits(
+	git_index **out,
+	git_repository *repo,
+	const char *our_oidstr,
+	const char *their_oidstr,
+	const git_merge_tree_opts *opts)
+{
+	git_oid our_oid, their_oid;
+	git_commit *our_commit, *their_commit;
+
+	cl_git_pass(git_oid_fromstr(&our_oid, our_oidstr));
+	cl_git_pass(git_oid_fromstr(&their_oid, their_oidstr));
+
+	cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid));
+	cl_git_pass(git_commit_lookup(&their_commit, repo, &their_oid));
+
+	cl_git_pass(git_merge_commits(out, repo, our_commit, their_commit, opts));
+
+	git_commit_free(our_commit);
+	git_commit_free(their_commit);
+}
+
+void test_merge_trees_commits__automerge(void)
+{
+	git_index *index;
+	const git_index_entry *entry;
+	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_blob *blob;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0,  "added-in-master.txt" },
+		{ 0100644, "f2e1550a0c9e53d5811175864a29536642ae3821", 0,  "automergeable.txt" },
+		{ 0100644, "4eb04c9e79e88f6640d01ff5b25ca2a60764f216", 0,  "changed-in-branch.txt" },
+		{ 0100644, "11deab00b2d3a6f5a3073988ac050c2d7b6655e2", 0,  "changed-in-master.txt" },
+
+		{ 0100644, "d427e0b2e138501a3d15cc376077a3631e15bd46", 1, "conflicting.txt" },
+		{ 0100644, "4e886e602529caa9ab11d71f86634bd1b6e0de10", 2, "conflicting.txt" },
+		{ 0100644, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", 3, "conflicting.txt" },
+
+		{ 0100644, "c8f06f2e3bb2964174677e91f0abead0e43c9e5d", 0,  "unchanged.txt" },
+	};
+
+	struct merge_reuc_entry merge_reuc_entries[] = {
+		{ "automergeable.txt", 0100644, 0100644, 0100644, \
+			"6212c31dab5e482247d7977e4f0dd3601decf13b", \
+			"ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", \
+			"058541fc37114bfc1dddf6bd6bffc7fae5c2e6fe" },
+		{ "removed-in-branch.txt", 0100644, 0100644, 0, \
+			"dfe3f22baa1f6fce5447901c3086bae368de6bdd", \
+			"dfe3f22baa1f6fce5447901c3086bae368de6bdd", \
+			"" },
+		{ "removed-in-master.txt", 0100644, 0, 0100644, \
+			"5c3b68a71fc4fa5d362fd3875e53137c6a5ab7a5", \
+			"", \
+			"5c3b68a71fc4fa5d362fd3875e53137c6a5ab7a5" },
+	};
+
+	cl_git_pass(merge_commits_from_branches(&index, repo, "master", "branch", &opts));
+
+	cl_assert(merge_test_index(index, merge_index_entries, 8));
+	cl_assert(merge_test_reuc(index, merge_reuc_entries, 3));
+
+	cl_assert((entry = git_index_get_bypath(index, "automergeable.txt", 0)) != NULL);
+	cl_assert(entry->file_size == strlen(AUTOMERGEABLE_MERGED_FILE));
+
+	cl_git_pass(git_object_lookup((git_object **)&blob, repo, &entry->oid, GIT_OBJ_BLOB));
+	cl_assert(memcmp(git_blob_rawcontent(blob), AUTOMERGEABLE_MERGED_FILE, (size_t)entry->file_size) == 0);
+
+	git_index_free(index);
+	git_blob_free(blob);
+}
+
+void test_merge_trees_commits__no_ancestor(void)
+{
+	git_index *index;
+	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0, "added-in-master.txt" },
+		{ 0100644, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", 2, "automergeable.txt" },
+		{ 0100644, "d07ec190c306ec690bac349e87d01c4358e49bb2", 3, "automergeable.txt" },
+		{ 0100644, "ab6c44a2e84492ad4b41bb6bac87353e9d02ac8b", 0, "changed-in-branch.txt" },
+		{ 0100644, "11deab00b2d3a6f5a3073988ac050c2d7b6655e2", 0, "changed-in-master.txt" },
+		{ 0100644, "4e886e602529caa9ab11d71f86634bd1b6e0de10", 2, "conflicting.txt" },
+		{ 0100644, "4b253da36a0ae8bfce63aeabd8c5b58429925594", 3, "conflicting.txt" },
+		{ 0100644, "ef58fdd8086c243bdc81f99e379acacfd21d32d6", 0, "new-in-unrelated1.txt" },
+		{ 0100644, "948ba6e701c1edab0c2d394fb7c5538334129793", 0, "new-in-unrelated2.txt" },
+		{ 0100644, "dfe3f22baa1f6fce5447901c3086bae368de6bdd", 0, "removed-in-branch.txt" },
+		{ 0100644, "c8f06f2e3bb2964174677e91f0abead0e43c9e5d", 0, "unchanged.txt" },
+	};
+
+	cl_git_pass(merge_commits_from_branches(&index, repo, "master", "unrelated", &opts));
+
+	cl_assert(merge_test_index(index, merge_index_entries, 11));
+
+	git_index_free(index);
+}
+
+
+void test_merge_trees_commits__df_conflict(void)
+{
+	git_index *index;
+	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "49130a28ef567af9a6a6104c38773fedfa5f9742", 2, "dir-10" },
+		{ 0100644, "6c06dcd163587c2cc18be44857e0b71116382aeb", 3, "dir-10" },
+		{ 0100644, "43aafd43bea779ec74317dc361f45ae3f532a505", 0, "dir-6" },
+		{ 0100644, "a031a28ae70e33a641ce4b8a8f6317f1ab79dee4", 3, "dir-7" },
+		{ 0100644, "5012fd565b1393bdfda1805d4ec38ce6619e1fd1", 1, "dir-7/file.txt" },
+		{ 0100644, "a5563304ddf6caba25cb50323a2ea6f7dbfcadca", 2, "dir-7/file.txt" },
+		{ 0100644, "e9ad6ec3e38364a3d07feda7c4197d4d845c53b5", 0, "dir-8" },
+		{ 0100644, "3ef4d30382ca33fdeba9fda895a99e0891ba37aa", 2, "dir-9" },
+		{ 0100644, "fc4c636d6515e9e261f9260dbcf3cc6eca97ea08", 1, "dir-9/file.txt" },
+		{ 0100644, "76ab0e2868197ec158ddd6c78d8a0d2fd73d38f9", 3, "dir-9/file.txt" },
+		{ 0100644, "5c2411f8075f48a6b2fdb85ebc0d371747c4df15", 0, "file-1/new" },
+		{ 0100644, "a39a620dae5bc8b4e771cd4d251b7d080401a21e", 1, "file-2" },
+		{ 0100644, "d963979c237d08b6ba39062ee7bf64c7d34a27f8", 2, "file-2" },
+		{ 0100644, "5c341ead2ba6f2af98ce5ec3fe84f6b6d2899c0d", 0, "file-2/new" },
+		{ 0100644, "9efe7723802d4305142eee177e018fee1572c4f4", 0, "file-3/new" },
+		{ 0100644, "bacac9b3493509aa15e1730e1545fc0919d1dae0", 1, "file-4" },
+		{ 0100644, "7663fce0130db092936b137cabd693ec234eb060", 3, "file-4" },
+		{ 0100644, "e49f917b448d1340b31d76e54ba388268fd4c922", 0, "file-4/new" },
+		{ 0100644, "cab2cf23998b40f1af2d9d9a756dc9e285a8df4b", 2, "file-5/new" },
+		{ 0100644, "f5504f36e6f4eb797a56fc5bac6c6c7f32969bf2", 3, "file-5/new" },
+	};
+
+	cl_git_pass(merge_trees_from_branches(&index, repo, "df_side1", "df_side2", &opts));
+
+	cl_assert(merge_test_index(index, merge_index_entries, 20));
+
+	git_index_free(index);
+}
diff --git a/tests/revert/bare.c b/tests/revert/bare.c
new file mode 100644
index 000000000..206c86d70
--- /dev/null
+++ b/tests/revert/bare.c
@@ -0,0 +1,107 @@
+#include "clar.h"
+#include "clar_libgit2.h"
+
+#include "buffer.h"
+#include "fileops.h"
+#include "git2/revert.h"
+
+#include "../merge/merge_helpers.h"
+
+#define TEST_REPO_PATH "revert"
+
+static git_repository *repo;
+
+// Fixture setup and teardown
+void test_revert_bare__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+}
+
+void test_revert_bare__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_revert_bare__automerge(void)
+{
+	git_commit *head_commit, *revert_commit;
+	git_oid head_oid, revert_oid;
+	git_index *index;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+	cl_git_pass(git_commit_lookup(&head_commit, repo, &head_oid));
+
+	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
+	cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_oid));
+
+	cl_git_pass(git_revert_commit(&index, repo, revert_commit, head_commit, 0, NULL));
+	cl_assert(merge_test_index(index, merge_index_entries, 4));
+
+	git_commit_free(revert_commit);
+	git_commit_free(head_commit);
+	git_index_free(index);
+}
+
+void test_revert_bare__conflicts(void)
+{
+	git_reference *head_ref;
+	git_commit *head_commit, *revert_commit;
+	git_oid revert_oid;
+	git_index *index;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 1, "file1.txt" },
+		{ 0100644, "4b8fcff56437e60f58e9a6bc630dd242ebf6ea2c", 2, "file1.txt" },
+		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 3, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+
+	cl_git_pass(git_repository_head(&head_ref, repo));
+	cl_git_pass(git_reference_peel((git_object **)&head_commit, head_ref, GIT_OBJ_COMMIT));
+
+	cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_oid));
+	cl_git_pass(git_revert_commit(&index, repo, revert_commit, head_commit, 0, NULL));
+
+	cl_assert(git_index_has_conflicts(index));
+	cl_assert(merge_test_index(index, merge_index_entries, 6));
+
+	git_commit_free(revert_commit);
+	git_commit_free(head_commit);
+	git_reference_free(head_ref);
+	git_index_free(index);
+}
+
+void test_revert_bare__orphan(void)
+{
+	git_commit *head_commit, *revert_commit;
+	git_oid head_oid, revert_oid;
+	git_index *index;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145");
+	cl_git_pass(git_commit_lookup(&head_commit, repo, &head_oid));
+
+	git_oid_fromstr(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5");
+	cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_oid));
+
+	cl_git_pass(git_revert_commit(&index, repo, revert_commit, head_commit, 0, NULL));
+	cl_assert(merge_test_index(index, merge_index_entries, 1));
+
+	git_commit_free(revert_commit);
+	git_commit_free(head_commit);
+	git_index_free(index);
+}
diff --git a/tests/revert/revert.c b/tests/revert/revert.c
deleted file mode 100644
index 4a45190b9..000000000
--- a/tests/revert/revert.c
+++ /dev/null
@@ -1,364 +0,0 @@
-#include "clar.h"
-#include "clar_libgit2.h"
-
-#include "buffer.h"
-#include "fileops.h"
-#include "git2/revert.h"
-
-#include "../merge/merge_helpers.h"
-
-#define TEST_REPO_PATH "revert"
-
-static git_repository *repo;
-static git_index *repo_index;
-
-// Fixture setup and teardown
-void test_revert_revert__initialize(void)
-{
-	repo = cl_git_sandbox_init(TEST_REPO_PATH);
-	git_repository_index(&repo_index, repo);
-}
-
-void test_revert_revert__cleanup(void)
-{
-	git_index_free(repo_index);
-	cl_git_sandbox_cleanup();
-}
-
-/* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45
- * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */
-void test_revert_revert__automerge(void)
-{
-	git_commit *head, *commit;
-	git_oid head_oid, revert_oid;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" },
-		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
-		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
-		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
-	};
-
-	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
-	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
-	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
-	cl_git_pass(git_revert(repo, commit, NULL));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
-
-	git_commit_free(commit);
-	git_commit_free(head);
-}
-
-/* git revert --no-commit 72333f47d4e83616630ff3b0ffe4c0faebcc3c45 */
-void test_revert_revert__conflicts(void)
-{
-	git_reference *head_ref;
-	git_commit *head, *commit;
-	git_oid revert_oid;
-	git_buf conflicting_buf = GIT_BUF_INIT;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 1, "file1.txt" },
-		{ 0100644, "4b8fcff56437e60f58e9a6bc630dd242ebf6ea2c", 2, "file1.txt" },
-		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 3, "file1.txt" },
-		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
-		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
-		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
-	};
-
-	git_oid_fromstr(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
-
-	cl_git_pass(git_repository_head(&head_ref, repo));
-	cl_git_pass(git_reference_peel((git_object **)&head, head_ref, GIT_OBJ_COMMIT));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
-	cl_git_pass(git_revert(repo, commit, NULL));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
-
-	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
-		TEST_REPO_PATH "/file1.txt"));
-	cl_assert(strcmp(conflicting_buf.ptr, "!File one!\n" \
-		"!File one!\n" \
-		"File one!\n" \
-		"File one\n" \
-		"File one\n" \
-		"File one\n" \
-		"File one\n" \
-		"File one\n" \
-		"File one\n" \
-		"File one\n" \
-		"<<<<<<< HEAD\n" \
-		"File one!\n" \
-		"!File one!\n" \
-		"!File one!\n" \
-		"!File one!\n" \
-		"=======\n" \
-		"File one\n" \
-		"File one\n" \
-		"File one\n" \
-		"File one\n" \
-		">>>>>>> parent of 72333f4... automergeable changes\n") == 0);
-
-	git_commit_free(commit);
-	git_commit_free(head);
-	git_reference_free(head_ref);
-	git_buf_free(&conflicting_buf);
-}
-
-/* git reset --hard 39467716290f6df775a91cdb9a4eb39295018145
- * git revert --no-commit ebb03002cee5d66c7732dd06241119fe72ab96a5
-*/
-void test_revert_revert__orphan(void)
-{
-	git_commit *head, *commit;
-	git_oid head_oid, revert_oid;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
-	};
-
-	git_oid_fromstr(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145");
-	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	git_oid_fromstr(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5");
-	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
-	cl_git_pass(git_revert(repo, commit, NULL));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 1));
-
-	git_commit_free(commit);
-	git_commit_free(head);
-}
-
-/* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45
- * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */
-void test_revert_revert__conflict_use_ours(void)
-{
-	git_commit *head, *commit;
-	git_oid head_oid, revert_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
-
-	opts.merge_tree_opts.automerge_flags = GIT_MERGE_AUTOMERGE_NONE;
-	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 1, "file1.txt" },
-		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 2, "file1.txt" },
-		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 3, "file1.txt" },
-		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
-		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
-		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
-	};
-
-	struct merge_index_entry merge_filesystem_entries[] = {
-		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 0, "file1.txt" },
-		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
-		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
-		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
-	};
-
-	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
-	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
-	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
-	cl_git_pass(git_revert(repo, commit, &opts));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
-	cl_assert(merge_test_workdir(repo, merge_filesystem_entries, 4));
-
-	git_commit_free(commit);
-	git_commit_free(head);
-}
-
-/* git reset --hard cef56612d71a6af8d8015691e4865f7fece905b5
- * git revert --no-commit 55568c8de5322ff9a95d72747a239cdb64a19965
- */
-void test_revert_revert__rename_1_of_2(void)
-{
-	git_commit *head, *commit;
-	git_oid head_oid, revert_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
-
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 0, "file1.txt" },
-		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
-		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
-		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 3, "file4.txt" },
-		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 1, "file5.txt" },
-		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 2, "file6.txt" },
-	};
-
-	git_oid_fromstr(&head_oid, "cef56612d71a6af8d8015691e4865f7fece905b5");
-	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	git_oid_fromstr(&revert_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
-	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
-	cl_git_pass(git_revert(repo, commit, &opts));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
-
-	git_commit_free(commit);
-	git_commit_free(head);
-}
-
-/* git reset --hard 55568c8de5322ff9a95d72747a239cdb64a19965
- * git revert --no-commit HEAD~1 */
-void test_revert_revert__rename(void)
-{
-	git_commit *head, *commit;
-	git_oid head_oid, revert_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
-
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 1, "file4.txt" },
-		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 2, "file5.txt" },
-	};
-
-	struct merge_name_entry merge_name_entries[] = {
-		{ "file4.txt", "file5.txt", "" },
-	};
-
-	git_oid_fromstr(&head_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
-	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	git_oid_fromstr(&revert_oid, "0aa8c7e40d342fff78d60b29a4ba8e993ed79c51");
-	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
-	cl_git_pass(git_revert(repo, commit, &opts));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 2));
-	cl_assert(merge_test_names(repo_index, merge_name_entries, 1));
-
-	git_commit_free(commit);
-	git_commit_free(head);
-}
-
-/* git revert --no-commit HEAD */
-void test_revert_revert__head(void)
-{
-	git_reference *head;
-	git_commit *commit;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 0, "file1.txt" },
-		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
-		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
-		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
-	};
-
-	/* HEAD is 2d440f2b3147d3dc7ad1085813478d6d869d5a4d */
-	cl_git_pass(git_repository_head(&head, repo));
-	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
-	cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD));
-	cl_git_pass(git_revert(repo, commit, NULL));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
-	cl_assert(merge_test_workdir(repo, merge_index_entries, 4));
-
-	git_reference_free(head);
-	git_commit_free(commit);
-}
-
-void test_revert_revert__nonmerge_fails_mainline_specified(void)
-{
-	git_reference *head;
-	git_commit *commit;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
-
-	cl_git_pass(git_repository_head(&head, repo));
-	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
-
-	opts.mainline = 1;
-	cl_must_fail(git_revert(repo, commit, &opts));
-	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
-	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/REVERT_HEAD"));
-
-	git_reference_free(head);
-	git_commit_free(commit);
-}
-
-/* git reset --hard 5acdc74af27172ec491d213ee36cea7eb9ef2579
- * git revert HEAD */
-void test_revert_revert__merge_fails_without_mainline_specified(void)
-{
-	git_commit *head;
-	git_oid head_oid;
-
-	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
-	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	cl_must_fail(git_revert(repo, head, NULL));
-	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
-	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/REVERT_HEAD"));
-
-	git_commit_free(head);
-}
-
-/* git reset --hard 5acdc74af27172ec491d213ee36cea7eb9ef2579
- * git revert HEAD -m1 --no-commit */
-void test_revert_revert__merge_first_parent(void)
-{
-	git_commit *head;
-	git_oid head_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
-
-	opts.mainline = 1;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
-		{ 0100644, "0cdb66192ee192f70f891f05a47636057420e871", 0, "file1.txt" },
-		{ 0100644, "73ec36fa120f8066963a0bc9105bb273dbd903d7", 0, "file2.txt" },
-	};
-
-	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
-	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	cl_git_pass(git_revert(repo, head, &opts));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
-
-	git_commit_free(head);
-}
-
-void test_revert_revert__merge_second_parent(void)
-{
-	git_commit *head;
-	git_oid head_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
-
-	opts.mainline = 2;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "33c6fd981c49a2abf2971482089350bfc5cda8ea", 0, "file-branch.txt" },
-		{ 0100644, "0cdb66192ee192f70f891f05a47636057420e871", 0, "file1.txt" },
-		{ 0100644, "73ec36fa120f8066963a0bc9105bb273dbd903d7", 0, "file2.txt" },
-	};
-
-	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
-	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-
-	cl_git_pass(git_revert(repo, head, &opts));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
-
-	git_commit_free(head);
-}
diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
new file mode 100644
index 000000000..7cdb24cf8
--- /dev/null
+++ b/tests/revert/workdir.c
@@ -0,0 +1,364 @@
+#include "clar.h"
+#include "clar_libgit2.h"
+
+#include "buffer.h"
+#include "fileops.h"
+#include "git2/revert.h"
+
+#include "../merge/merge_helpers.h"
+
+#define TEST_REPO_PATH "revert"
+
+static git_repository *repo;
+static git_index *repo_index;
+
+// Fixture setup and teardown
+void test_revert_workdir__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+	git_repository_index(&repo_index, repo);
+}
+
+void test_revert_workdir__cleanup(void)
+{
+	git_index_free(repo_index);
+	cl_git_sandbox_cleanup();
+}
+
+/* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45
+ * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */
+void test_revert_workdir__automerge(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git revert --no-commit 72333f47d4e83616630ff3b0ffe4c0faebcc3c45 */
+void test_revert_workdir__conflicts(void)
+{
+	git_reference *head_ref;
+	git_commit *head, *commit;
+	git_oid revert_oid;
+	git_buf conflicting_buf = GIT_BUF_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 1, "file1.txt" },
+		{ 0100644, "4b8fcff56437e60f58e9a6bc630dd242ebf6ea2c", 2, "file1.txt" },
+		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 3, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&revert_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+
+	cl_git_pass(git_repository_head(&head_ref, repo));
+	cl_git_pass(git_reference_peel((git_object **)&head, head_ref, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
+
+	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
+		TEST_REPO_PATH "/file1.txt"));
+	cl_assert(strcmp(conflicting_buf.ptr, "!File one!\n" \
+		"!File one!\n" \
+		"File one!\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"<<<<<<< HEAD\n" \
+		"File one!\n" \
+		"!File one!\n" \
+		"!File one!\n" \
+		"!File one!\n" \
+		"=======\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		"File one\n" \
+		">>>>>>> parent of 72333f4... automergeable changes\n") == 0);
+
+	git_commit_free(commit);
+	git_commit_free(head);
+	git_reference_free(head_ref);
+	git_buf_free(&conflicting_buf);
+}
+
+/* git reset --hard 39467716290f6df775a91cdb9a4eb39295018145
+ * git revert --no-commit ebb03002cee5d66c7732dd06241119fe72ab96a5
+*/
+void test_revert_workdir__orphan(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 1));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45
+ * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */
+void test_revert_workdir__conflict_use_ours(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.merge_tree_opts.automerge_flags = GIT_MERGE_AUTOMERGE_NONE;
+	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 1, "file1.txt" },
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 2, "file1.txt" },
+		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 3, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	struct merge_index_entry merge_filesystem_entries[] = {
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
+	cl_assert(merge_test_workdir(repo, merge_filesystem_entries, 4));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard cef56612d71a6af8d8015691e4865f7fece905b5
+ * git revert --no-commit 55568c8de5322ff9a95d72747a239cdb64a19965
+ */
+void test_revert_workdir__rename_1_of_2(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_tree_opts.rename_threshold = 50;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 3, "file4.txt" },
+		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 1, "file5.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 2, "file6.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "cef56612d71a6af8d8015691e4865f7fece905b5");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard 55568c8de5322ff9a95d72747a239cdb64a19965
+ * git revert --no-commit HEAD~1 */
+void test_revert_workdir__rename(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, revert_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_tree_opts.rename_threshold = 50;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 1, "file4.txt" },
+		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 2, "file5.txt" },
+	};
+
+	struct merge_name_entry merge_name_entries[] = {
+		{ "file4.txt", "file5.txt", "" },
+	};
+
+	git_oid_fromstr(&head_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "0aa8c7e40d342fff78d60b29a4ba8e993ed79c51");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 2));
+	cl_assert(merge_test_names(repo_index, merge_name_entries, 1));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git revert --no-commit HEAD */
+void test_revert_workdir__head(void)
+{
+	git_reference *head;
+	git_commit *commit;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	/* HEAD is 2d440f2b3147d3dc7ad1085813478d6d869d5a4d */
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+	cl_assert(merge_test_workdir(repo, merge_index_entries, 4));
+
+	git_reference_free(head);
+	git_commit_free(commit);
+}
+
+void test_revert_workdir__nonmerge_fails_mainline_specified(void)
+{
+	git_reference *head;
+	git_commit *commit;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
+
+	opts.mainline = 1;
+	cl_must_fail(git_revert(repo, commit, &opts));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/REVERT_HEAD"));
+
+	git_reference_free(head);
+	git_commit_free(commit);
+}
+
+/* git reset --hard 5acdc74af27172ec491d213ee36cea7eb9ef2579
+ * git revert HEAD */
+void test_revert_workdir__merge_fails_without_mainline_specified(void)
+{
+	git_commit *head;
+	git_oid head_oid;
+
+	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	cl_must_fail(git_revert(repo, head, NULL));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/REVERT_HEAD"));
+
+	git_commit_free(head);
+}
+
+/* git reset --hard 5acdc74af27172ec491d213ee36cea7eb9ef2579
+ * git revert HEAD -m1 --no-commit */
+void test_revert_workdir__merge_first_parent(void)
+{
+	git_commit *head;
+	git_oid head_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.mainline = 1;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
+		{ 0100644, "0cdb66192ee192f70f891f05a47636057420e871", 0, "file1.txt" },
+		{ 0100644, "73ec36fa120f8066963a0bc9105bb273dbd903d7", 0, "file2.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	cl_git_pass(git_revert(repo, head, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
+
+	git_commit_free(head);
+}
+
+void test_revert_workdir__merge_second_parent(void)
+{
+	git_commit *head;
+	git_oid head_oid;
+	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+
+	opts.mainline = 2;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "33c6fd981c49a2abf2971482089350bfc5cda8ea", 0, "file-branch.txt" },
+		{ 0100644, "0cdb66192ee192f70f891f05a47636057420e871", 0, "file1.txt" },
+		{ 0100644, "73ec36fa120f8066963a0bc9105bb273dbd903d7", 0, "file2.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	cl_git_pass(git_revert(repo, head, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
+
+	git_commit_free(head);
+}
-- 
cgit v1.2.3


From d192e60b7a808d4bd4daa457f23160c07b9991fe Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 3 Dec 2013 10:47:18 -0500
Subject: Reorder var decls in revert test

Oh, MSVC.
---
 tests/revert/workdir.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
index 7cdb24cf8..9dc72a9a8 100644
--- a/tests/revert/workdir.c
+++ b/tests/revert/workdir.c
@@ -145,9 +145,6 @@ void test_revert_workdir__conflict_use_ours(void)
 	git_oid head_oid, revert_oid;
 	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
 
-	opts.merge_tree_opts.automerge_flags = GIT_MERGE_AUTOMERGE_NONE;
-	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
-
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 1, "file1.txt" },
 		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 2, "file1.txt" },
@@ -164,6 +161,9 @@ void test_revert_workdir__conflict_use_ours(void)
 		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
 	};
 
+	opts.merge_tree_opts.automerge_flags = GIT_MERGE_AUTOMERGE_NONE;
+	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+
 	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
 	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
@@ -188,9 +188,6 @@ void test_revert_workdir__rename_1_of_2(void)
 	git_oid head_oid, revert_oid;
 	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
 
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
-
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 0, "file1.txt" },
 		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
@@ -200,6 +197,9 @@ void test_revert_workdir__rename_1_of_2(void)
 		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 2, "file6.txt" },
 	};
 
+	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_tree_opts.rename_threshold = 50;
+
 	git_oid_fromstr(&head_oid, "cef56612d71a6af8d8015691e4865f7fece905b5");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
 	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
@@ -222,9 +222,6 @@ void test_revert_workdir__rename(void)
 	git_oid head_oid, revert_oid;
 	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
 
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
-
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 1, "file4.txt" },
 		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 2, "file5.txt" },
@@ -234,6 +231,9 @@ void test_revert_workdir__rename(void)
 		{ "file4.txt", "file5.txt", "" },
 	};
 
+	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_tree_opts.rename_threshold = 50;
+
 	git_oid_fromstr(&head_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
 	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
@@ -319,14 +319,14 @@ void test_revert_workdir__merge_first_parent(void)
 	git_oid head_oid;
 	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
 
-	opts.mainline = 1;
-
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
 		{ 0100644, "0cdb66192ee192f70f891f05a47636057420e871", 0, "file1.txt" },
 		{ 0100644, "73ec36fa120f8066963a0bc9105bb273dbd903d7", 0, "file2.txt" },
 	};
 
+	opts.mainline = 1;
+
 	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
 	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
@@ -344,14 +344,14 @@ void test_revert_workdir__merge_second_parent(void)
 	git_oid head_oid;
 	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
 
-	opts.mainline = 2;
-
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "33c6fd981c49a2abf2971482089350bfc5cda8ea", 0, "file-branch.txt" },
 		{ 0100644, "0cdb66192ee192f70f891f05a47636057420e871", 0, "file1.txt" },
 		{ 0100644, "73ec36fa120f8066963a0bc9105bb273dbd903d7", 0, "file2.txt" },
 	};
 
+	opts.mainline = 2;
+
 	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
 	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
-- 
cgit v1.2.3


From a6ebc2bdb314543a1fdf25f523f8793f4f52b8b3 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 4 Dec 2013 15:17:39 -0800
Subject: Introduce GIT_DIFF_FIND_BY_CONFIG

---
 include/git2/diff.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index db6bce2eb..312702bc2 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -468,6 +468,9 @@ typedef int (*git_diff_line_cb)(
  * Flags to control the behavior of diff rename/copy detection.
  */
 typedef enum {
+	/** Obey `diff.renames`. This is overridden by any other GIT_DIFF_FIND_ALL flag. */
+	GIT_DIFF_FIND_BY_CONFIG = 0,
+
 	/** Look for renames? (`--find-renames`) */
 	GIT_DIFF_FIND_RENAMES = (1u << 0),
 
-- 
cgit v1.2.3


From ed5b77b0fdd6eebc35742e1f27c4a9de4849d8ce Mon Sep 17 00:00:00 2001
From: mgbowen <matthew@mgbowen.com>
Date: Thu, 5 Dec 2013 11:13:58 -0500
Subject: Fixed compilation on Windows when using libssh2.

---
 src/transport.c | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/transport.c b/src/transport.c
index ff926b1be..2b0c6a185 100644
--- a/src/transport.c
+++ b/src/transport.c
@@ -79,12 +79,8 @@ static int transport_find_fn(const char *url, git_transport_cb *callback, void *
 	/* Check to see if the path points to a file on the local file system */
 	if (!definition && git_path_exists(url) && git_path_isdir(url))
 		definition = &local_transport_definition;
+#endif
 
-	/* It could be a SSH remote path. Check to see if there's a :
-	 * SSH is an unsupported transport mechanism in this version of libgit2 */
-	if (!definition && strrchr(url, ':'))
-		definition = &dummy_transport_definition;
-#else
 	/* For other systems, perform the SSH check first, to avoid going to the
 	 * filesystem if it is not necessary */
 
@@ -97,6 +93,7 @@ static int transport_find_fn(const char *url, git_transport_cb *callback, void *
         definition = &dummy_transport_definition;
 #endif
 
+#ifndef GIT_WIN32
 	/* Check to see if the path points to a file on the local file system */
 	if (!definition && git_path_exists(url) && git_path_isdir(url))
 		definition = &local_transport_definition;
-- 
cgit v1.2.3


From c56c6d694563fdd28cd00ed246f35349522b836e Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Thu, 5 Dec 2013 14:13:46 -0800
Subject: Implement GIT_DIFF_FIND_BY_CONFIG

---
 src/diff_tform.c    |  28 ++++++-----
 tests/diff/rename.c | 138 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 155 insertions(+), 11 deletions(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index 0a28e58c7..6f29f25da 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -279,23 +279,29 @@ static int normalize_find_opts(
 		git_repository_config__weakptr(&cfg, diff->repo) < 0)
 		return -1;
 
-	if (given != NULL)
+	if (given) {
 		memcpy(opts, given, sizeof(*opts));
-	else {
-		const char *val = NULL;
-
+	} else {
 		GIT_INIT_STRUCTURE(opts, GIT_DIFF_FIND_OPTIONS_VERSION);
+	}
 
-		opts->flags = GIT_DIFF_FIND_RENAMES;
+	if (!given ||
+		 (given->flags & GIT_DIFF_FIND_ALL) == GIT_DIFF_FIND_BY_CONFIG)
+	{
+		const char *val = NULL;
 
 		if (git_config_get_string(&val, cfg, "diff.renames") < 0)
 			giterr_clear();
-		else if (val &&
-			(!strcasecmp(val, "copies") || !strcasecmp(val, "copy")))
-			opts->flags = GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES;
+		else if (val) {
+			if (!strcasecmp(val, "false"))
+				return GIT_PASSTHROUGH;
+			else if (!strcasecmp(val, "copies") || !strcasecmp(val, "copy"))
+				opts->flags = GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES;
+			else
+				opts->flags = GIT_DIFF_FIND_RENAMES;
+		}
 	}
-
-	GITERR_CHECK_VERSION(opts, GIT_DIFF_FIND_OPTIONS_VERSION, "git_diff_find_options");
+	GITERR_CHECK_VERSION(given, GIT_DIFF_FIND_OPTIONS_VERSION, "git_diff_find_options");
 
 	/* some flags imply others */
 
@@ -828,7 +834,7 @@ int git_diff_find_similar(
 	git_diff_file swap;
 
 	if ((error = normalize_find_opts(diff, &opts, given_opts)) < 0)
-		return error;
+		return (error == GIT_PASSTHROUGH) ? 0 : error;
 
 	num_deltas = diff->deltas.length;
 
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index 919f5139a..b304ec253 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -1381,3 +1381,141 @@ void test_diff_rename__can_delete_unmodified_deltas(void)
 
 	git_buf_free(&c1);
 }
+
+void test_diff_rename__matches_config_behavior(void)
+{
+	const char *sha0 = "31e47d8c1fa36d7f8d537b96158e3f024de0a9f2";
+	const char *sha1 = "2bc7f351d20b53f1c72c16c4b036e491c478c49a";
+	const char *sha2 = "1c068dee5790ef1580cfc4cd670915b48d790084";
+
+	git_tree *tree0, *tree1, *tree2;
+	git_config *cfg;
+	git_diff *diff;
+	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
+	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
+	diff_expects exp;
+
+	opts.flags = GIT_DIFF_FIND_BY_CONFIG;
+	tree0 = resolve_commit_oid_to_tree(g_repo, sha0);
+	tree1 = resolve_commit_oid_to_tree(g_repo, sha1);
+	tree2 = resolve_commit_oid_to_tree(g_repo, sha2);
+
+	diffopts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+
+	/* diff.renames = false; no rename detection should happen */
+	cl_git_pass(git_config_set_bool(cfg, "diff.renames", false));
+	cl_git_pass(git_diff_tree_to_tree(
+				&diff, g_repo, tree0, tree1, &diffopts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+	cl_git_pass(git_diff_foreach(diff,
+				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(4, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
+	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_ADDED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
+	git_diff_free(diff);
+
+	/* diff.renames = true; should act like -M */
+	cl_git_pass(git_config_set_bool(cfg, "diff.renames", true));
+	cl_git_pass(git_diff_tree_to_tree(
+				&diff, g_repo, tree0, tree1, &diffopts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+	cl_git_pass(git_diff_foreach(diff,
+				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(3, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
+	git_diff_free(diff);
+
+	/* diff.renames = copies; should act like -M -C */
+	cl_git_pass(git_config_set_string(cfg, "diff.renames", "copies"));
+	cl_git_pass(git_diff_tree_to_tree(
+				&diff, g_repo, tree1, tree2, &diffopts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+	cl_git_pass(git_diff_foreach(diff,
+				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(4, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
+	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
+	git_diff_free(diff);
+
+	/* NULL find options is the same as GIT_DIFF_FIND_BY_CONFIG */
+	cl_git_pass(git_diff_tree_to_tree(
+				&diff, g_repo, tree1, tree2, &diffopts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_find_similar(diff, NULL));
+	cl_git_pass(git_diff_foreach(diff,
+				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(4, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
+	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
+	git_diff_free(diff);
+
+	/* Cleanup */
+	git_tree_free(tree0);
+	git_tree_free(tree1);
+	git_tree_free(tree2);
+	git_config_free(cfg);
+}
+
+void test_diff_rename__can_override_thresholds_when_obeying_config(void)
+{
+	const char *sha1 = "2bc7f351d20b53f1c72c16c4b036e491c478c49a";
+	const char *sha2 = "1c068dee5790ef1580cfc4cd670915b48d790084";
+
+	git_tree *tree1, *tree2;
+	git_config *cfg;
+	git_diff *diff;
+	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
+	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
+	diff_expects exp;
+
+	tree1 = resolve_commit_oid_to_tree(g_repo, sha1);
+	tree2 = resolve_commit_oid_to_tree(g_repo, sha2);
+
+	diffopts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
+	opts.flags = GIT_DIFF_FIND_BY_CONFIG;
+
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(git_config_set_string(cfg, "diff.renames", "copies"));
+	git_config_free(cfg);
+
+	/* copy threshold = 96%, should see creation of ikeepsix.txt */
+	opts.copy_threshold = 96;
+	cl_git_pass(git_diff_tree_to_tree(
+				&diff, g_repo, tree1, tree2, &diffopts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+	cl_git_pass(git_diff_foreach(diff,
+				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(4, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
+	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
+	git_diff_free(diff);
+
+	/* copy threshold = 20%, should see sixserving.txt => ikeepsix.txt */
+	opts.copy_threshold = 20;
+	cl_git_pass(git_diff_tree_to_tree(
+				&diff, g_repo, tree1, tree2, &diffopts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+	cl_git_pass(git_diff_foreach(diff,
+				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(4, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
+	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
+	git_diff_free(diff);
+
+	/* Cleanup */
+	git_tree_free(tree1);
+	git_tree_free(tree2);
+}
-- 
cgit v1.2.3


From 628e92cdb31cb3561549671ea5346a347f2addcd Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Thu, 5 Dec 2013 14:47:04 -0800
Subject: Don't use weird return codes

---
 src/diff_tform.c    | 11 ++++++++---
 tests/diff/rename.c |  3 +++
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index 6f29f25da..0c9f961f2 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -293,8 +293,9 @@ static int normalize_find_opts(
 		if (git_config_get_string(&val, cfg, "diff.renames") < 0)
 			giterr_clear();
 		else if (val) {
-			if (!strcasecmp(val, "false"))
-				return GIT_PASSTHROUGH;
+			int boolval;
+			if (!git__parse_bool(&boolval, val) && !boolval)
+				opts->flags = 0;
 			else if (!strcasecmp(val, "copies") || !strcasecmp(val, "copy"))
 				opts->flags = GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES;
 			else
@@ -834,7 +835,11 @@ int git_diff_find_similar(
 	git_diff_file swap;
 
 	if ((error = normalize_find_opts(diff, &opts, given_opts)) < 0)
-		return (error == GIT_PASSTHROUGH) ? 0 : error;
+		return error;
+
+	/* No flags set; nothing to do */
+	if ((opts.flags & GIT_DIFF_FIND_ALL) == 0)
+		return 0;
 
 	num_deltas = diff->deltas.length;
 
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index b304ec253..c08c1a8b4 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -919,6 +919,7 @@ void test_diff_rename__rejected_match_can_match_others(void)
 	char *ptr;
 
 	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
+	findopts.flags = GIT_DIFF_FIND_RENAMES;
 
 	cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
 	cl_git_pass(git_reference_symbolic_set_target(
@@ -1003,6 +1004,7 @@ void test_diff_rename__rejected_match_can_match_others_two(void)
 	struct rename_expected expect = { 2, status, sources, targets };
 
 	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
+	findopts.flags = GIT_DIFF_FIND_RENAMES;
 
 	cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
 	cl_git_pass(git_reference_symbolic_set_target(
@@ -1060,6 +1062,7 @@ void test_diff_rename__rejected_match_can_match_others_three(void)
 	struct rename_expected expect = { 2, status, sources, targets };
 
 	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
+	findopts.flags = GIT_DIFF_FIND_RENAMES;
 
 	cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
 	cl_git_pass(git_reference_symbolic_set_target(
-- 
cgit v1.2.3


From 8f460f2c464bb5dd7bb65374cfa3d965badc8da1 Mon Sep 17 00:00:00 2001
From: Paul Holden <paulholden2@gmail.com>
Date: Thu, 5 Dec 2013 20:41:12 -0800
Subject: blame.c: Remove unnecessary error-check and goto

In private function 'load_blob'.
---
 src/blame.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/blame.c b/src/blame.c
index 219a6bfe4..ea9f77af5 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -282,8 +282,6 @@ static int load_blob(git_blame *blame)
 		goto cleanup;
 	error = git_object_lookup_bypath((git_object**)&blame->final_blob,
 			(git_object*)blame->final, blame->path, GIT_OBJ_BLOB);
-	if (error < 0)
-		goto cleanup;
 
 cleanup:
 	return error;
-- 
cgit v1.2.3


From 710f383868cef86ff837340c698b1672c7902486 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Fri, 6 Dec 2013 09:32:09 -0800
Subject: Clarify default value and behavior

---
 include/git2/diff.h | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 312702bc2..1654523c8 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -576,7 +576,11 @@ typedef struct {
 typedef struct {
 	unsigned int version;
 
-	/** Combination of git_diff_find_t values (default FIND_RENAMES) */
+	/**
+	 * Combination of git_diff_find_t values (default FIND_BY_CONFIG).  Note
+	 * that if the configuration value is falsy, this will result in
+	 * `git_diff_find_similar` doing nothing. 
+	 */
 	uint32_t flags;
 
 	/** Similarity to consider a file renamed (default 50) */
-- 
cgit v1.2.3


From 7fb4147f1f7e64d7544e574998d5cec04077dfc4 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Fri, 6 Dec 2013 13:38:59 -0800
Subject: Don't clobber whitespace settings

---
 src/diff_tform.c    | 10 +++++-----
 tests/diff/rename.c | 42 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 5 deletions(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index 0c9f961f2..3ff6108c8 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -294,12 +294,12 @@ static int normalize_find_opts(
 			giterr_clear();
 		else if (val) {
 			int boolval;
-			if (!git__parse_bool(&boolval, val) && !boolval)
-				opts->flags = 0;
-			else if (!strcasecmp(val, "copies") || !strcasecmp(val, "copy"))
-				opts->flags = GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES;
+			if (!git__parse_bool(&boolval, val) && !boolval) {
+				/* do nothing */
+			} else if (!strcasecmp(val, "copies") || !strcasecmp(val, "copy"))
+				opts->flags |= (GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES);
 			else
-				opts->flags = GIT_DIFF_FIND_RENAMES;
+				opts->flags |= GIT_DIFF_FIND_RENAMES;
 		}
 	}
 	GITERR_CHECK_VERSION(given, GIT_DIFF_FIND_OPTIONS_VERSION, "git_diff_find_options");
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index c08c1a8b4..ca6d076d6 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -1522,3 +1522,45 @@ void test_diff_rename__can_override_thresholds_when_obeying_config(void)
 	git_tree_free(tree1);
 	git_tree_free(tree2);
 }
+
+void test_diff_rename__by_config_doesnt_mess_with_whitespace_settings(void)
+{
+	const char *sha1 = "1c068dee5790ef1580cfc4cd670915b48d790084";
+	const char *sha2 = "19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13";
+
+	git_tree *tree1, *tree2;
+	git_config *cfg;
+	git_diff *diff;
+	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
+	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
+	diff_expects exp;
+
+	tree1 = resolve_commit_oid_to_tree(g_repo, sha1);
+	tree2 = resolve_commit_oid_to_tree(g_repo, sha2);
+
+	diffopts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
+	opts.flags = GIT_DIFF_FIND_BY_CONFIG;
+
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(git_config_set_string(cfg, "diff.renames", "copies"));
+	git_config_free(cfg);
+
+	/* Don't ignore whitespace; this should find a change in sixserving.txt */
+	opts.flags |= 0 | GIT_DIFF_FIND_DONT_IGNORE_WHITESPACE;
+	cl_git_pass(git_diff_tree_to_tree(
+				&diff, g_repo, tree1, tree2, &diffopts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+	cl_git_pass(git_diff_foreach(diff,
+				diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(5, exp.files);
+	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_DELETED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_ADDED]);
+	git_diff_free(diff);
+
+	/* Cleanup */
+	git_tree_free(tree1);
+	git_tree_free(tree2);
+}
-- 
cgit v1.2.3


From a7c83aec2149a4885bfac032859142e8a62bceab Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Fri, 6 Dec 2013 13:39:08 -0800
Subject: Clarify docs

---
 include/git2/diff.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 1654523c8..315cc1215 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -577,9 +577,9 @@ typedef struct {
 	unsigned int version;
 
 	/**
-	 * Combination of git_diff_find_t values (default FIND_BY_CONFIG).  Note
-	 * that if the configuration value is falsy, this will result in
-	 * `git_diff_find_similar` doing nothing. 
+	 * Combination of git_diff_find_t values (default FIND_BY_CONFIG).
+	 * Note that if you don't explicitly set this, `diff.renames` could be set
+	 * to false, resulting in `git_diff_find_similar` doing nothing. 
 	 */
 	uint32_t flags;
 
-- 
cgit v1.2.3


From 307a3d6762a2797ee28b43fceb1c941680ac97ec Mon Sep 17 00:00:00 2001
From: Jared Wong <jaredlwong@gmail.com>
Date: Sun, 8 Dec 2013 01:50:10 -0800
Subject: Fixed left shift size of int.

Simply switched the ordering of the checks in the for loop where this left
shift was being made.
---
 src/delta.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/delta.c b/src/delta.c
index b3435ba87..8375a2c4d 100644
--- a/src/delta.c
+++ b/src/delta.c
@@ -144,7 +144,7 @@ git_delta_create_index(const void *buf, unsigned long bufsize)
 		entries = 0xfffffffeU / RABIN_WINDOW;
 	}
 	hsize = entries / 4;
-	for (i = 4; (1u << i) < hsize && i < 31; i++);
+	for (i = 4; i < 31 && (1u << i) < hsize; i++);
 	hsize = 1 << i;
 	hmask = hsize - 1;
 
-- 
cgit v1.2.3


From be0a1a79588c24b0cf032809c83d0b9cd167e0a9 Mon Sep 17 00:00:00 2001
From: Paul Holden <paulholden2@gmail.com>
Date: Sun, 8 Dec 2013 02:03:05 -0800
Subject: commit: Fix potential segfault in git_commit_message

Dereferencing commit pointer before asserting
---
 src/commit.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/commit.c b/src/commit.c
index bbb76f350..4ddfafb41 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -276,10 +276,12 @@ GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id);
 
 const char *git_commit_message(const git_commit *commit)
 {
-	const char *message = commit->raw_message;
+	const char *message;
 
 	assert(commit);
 
+	message = commit->raw_message;
+
 	/* trim leading newlines from raw message */
 	while (*message && *message == '\n')
 		++message;
-- 
cgit v1.2.3


From 6f13a30565fc3891c0df161945097b316945fca7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 17 Nov 2013 23:26:49 +0100
Subject: reflog: write to the reflog following git's rules

git-core only writes to the reflogs of HEAD, refs/heads/ and,
refs/notes/ or if there is already a reflog in place. Adjust our code to
follow these semantics.
---
 src/refdb_fs.c             | 36 +++++++++++++++++++++++++++++++++---
 src/refs.h                 |  1 +
 tests/refs/reflog/reflog.c | 36 ++++++++++++++++++++++++++++++++++++
 3 files changed, 70 insertions(+), 3 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 2f7b43401..9f23de248 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -911,6 +911,22 @@ fail:
 }
 
 static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_signature *author, const char *message);
+static int has_reflog(git_repository *repo, const char *name);
+
+/* We only write if it's under heads/, remotes/ or notes/ or if it already has a log */
+static bool should_write_reflog(git_repository *repo, const char *name)
+{
+	if (has_reflog(repo, name))
+		return 1;
+
+	if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR) ||
+	    !git__strcmp(name, GIT_HEAD_FILE) ||
+	    !git__prefixcmp(name, GIT_REFS_REMOTES_DIR) ||
+	    !git__prefixcmp(name, GIT_REFS_NOTES_DIR))
+		return 1;
+
+	return 0;
+}
 
 static int refdb_fs_backend__write(
 	git_refdb_backend *_backend,
@@ -933,7 +949,8 @@ static int refdb_fs_backend__write(
 	if ((error = loose_lock(&file, backend, ref)) < 0)
 		return error;
 
-	if ((error = reflog_append(backend, ref, who, message)) < 0) {
+	if (should_write_reflog(backend->repo, ref->name) &&
+	    (error = reflog_append(backend, ref, who, message)) < 0) {
 		git_filebuf_cleanup(&file);
 		return error;
 	}
@@ -1228,6 +1245,21 @@ GIT_INLINE(int) retrieve_reflog_path(git_buf *path, git_repository *repo, const
 	return git_buf_join_n(path, '/', 3, repo->path_repository, GIT_REFLOG_DIR, name);
 }
 
+static int has_reflog(git_repository *repo, const char *name)
+{
+	int ret = 0;
+	git_buf path = GIT_BUF_INIT;
+
+	if (retrieve_reflog_path(&path, repo, name) < 0)
+		goto cleanup;
+
+	ret = git_path_isfile(git_buf_cstr(&path));
+
+cleanup:
+	git_buf_free(&path);
+	return ret;
+}
+
 static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, const char *name)
 {
 	int error = -1;
@@ -1338,7 +1370,6 @@ static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflo
 	int error = -1;
 	unsigned int i;
 	git_reflog_entry *entry;
-	git_repository *repo;
 	refdb_fs_backend *backend;
 	git_buf log = GIT_BUF_INIT;
 	git_filebuf fbuf = GIT_FILEBUF_INIT;
@@ -1346,7 +1377,6 @@ static int refdb_reflog_fs__write(git_refdb_backend *_backend, git_reflog *reflo
 	assert(_backend && reflog);
 
 	backend = (refdb_fs_backend *) _backend;
-	repo = backend->repo;
 
 	if ((error = lock_reflog(&fbuf, backend, reflog->ref_name)) < 0)
 		return -1;
diff --git a/src/refs.h b/src/refs.h
index 80c7703fc..4d5b6dacb 100644
--- a/src/refs.h
+++ b/src/refs.h
@@ -19,6 +19,7 @@
 #define GIT_REFS_HEADS_DIR GIT_REFS_DIR "heads/"
 #define GIT_REFS_TAGS_DIR GIT_REFS_DIR "tags/"
 #define GIT_REFS_REMOTES_DIR GIT_REFS_DIR "remotes/"
+#define GIT_REFS_NOTES_DIR GIT_REFS_DIR "notes/"
 #define GIT_REFS_DIR_MODE 0777
 #define GIT_REFS_FILE_MODE 0666
 
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index 9ac15d556..6c9375dc7 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -187,3 +187,39 @@ void test_refs_reflog_reflog__renaming_with_an_invalid_name_returns_EINVALIDSPEC
 	cl_assert_equal_i(GIT_EINVALIDSPEC,
 			  git_reflog_rename(g_repo, "refs/heads/master", "refs/heads/Inv@{id"));
 }
+
+void test_refs_reflog_reflog__write_only_std_locations(void)
+{
+	git_reference *ref;
+	git_oid id;
+
+	git_oid_fromstr(&id, current_master_tip);
+
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/foo", &id, 1));
+	git_reference_free(ref);
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1));
+	git_reference_free(ref);
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/notes/foo", &id, 1));
+	git_reference_free(ref);
+
+	assert_has_reflog(true, "refs/heads/foo");
+	assert_has_reflog(false, "refs/tags/foo");
+	assert_has_reflog(true, "refs/notes/foo");
+
+}
+
+void test_refs_reflog_reflog__write_when_explicitly_active(void)
+{
+	git_reference *ref;
+	git_oid id;
+	git_buf path = GIT_BUF_INIT;
+
+	git_oid_fromstr(&id, current_master_tip);
+	cl_git_pass(git_buf_join(&path, '/', git_repository_path(g_repo), "logs/refs/tags/foo"));
+	cl_git_pass(git_futils_mkpath2file(git_buf_cstr(&path), 0777));
+	cl_git_mkfile(git_buf_cstr(&path), "");
+
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1));
+	git_reference_free(ref);
+	assert_has_reflog(true, "refs/tags/foo");
+}
-- 
cgit v1.2.3


From 8d5ec9106afbca346a8def84ef20de0a7ba2240a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 23 Nov 2013 14:13:01 +0100
Subject: refs: expose a way to ensure a ref has a log

Sometimes (e.g. stash) we want to make sure that a log will be written,
even if it's not in one of the standard locations. Let's make that
easier.
---
 include/git2/refs.h              | 12 ++++++++++++
 include/git2/sys/refdb_backend.h |  6 ++++++
 src/refdb.c                      |  7 +++++++
 src/refdb.h                      |  3 +++
 src/refdb_fs.c                   | 21 ++++++++++++++++++++-
 src/refs.c                       | 13 +++++++++++++
 src/stash.c                      |  3 +++
 tests/refs/reflog/reflog.c       |  5 +----
 8 files changed, 65 insertions(+), 5 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 2dc137692..31bf997fe 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -555,6 +555,18 @@ GIT_EXTERN(int) git_reference_foreach_glob(
  */
 GIT_EXTERN(int) git_reference_has_log(git_reference *ref);
 
+/**
+ * Ensure there is a reflog for a particular reference.
+ *
+ * Make sure that successive updates to the reference will append to
+ * its log.
+ *
+ * @param repo the repository
+ * @param refname the reference's name
+ * @return 0 or an error code.
+ */
+GIT_EXTERN(int) git_reference_ensure_log(git_repository *repo, const char *refname);
+
 /**
  * Check if a reference is a local branch.
  *
diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index 131e1b5d0..1485ed73a 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -116,6 +116,12 @@ struct git_refdb_backend {
 	 */
 	int (*compress)(git_refdb_backend *backend);
 
+	/**
+	 * Make sure a particular reference will have a reflog which
+	 * will be appended to on writes.
+	 */
+	int (*ensure_log)(git_refdb_backend *backend, const char *refname);
+
 	/**
 	 * Frees any resources held by the refdb.  A refdb implementation may
 	 * provide this function; if it is not provided, nothing will be done.
diff --git a/src/refdb.c b/src/refdb.c
index bc8c2b366..4f3169f88 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -221,3 +221,10 @@ int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name)
 
 	return 0;
 }
+
+int git_refdb_ensure_log(git_refdb *db, const char *refname)
+{
+	assert(db && refname);
+
+	return db->backend->ensure_log(db->backend, refname);
+}
diff --git a/src/refdb.h b/src/refdb.h
index 215ae17c5..12c15cb9f 100644
--- a/src/refdb.h
+++ b/src/refdb.h
@@ -48,5 +48,8 @@ int git_refdb_delete(git_refdb *refdb, const char *ref_name);
 int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name);
 int git_refdb_reflog_write(git_reflog *reflog);
 
+int git_refdb_ensure_log(git_refdb *refdb, const char *refname);
+
+
 
 #endif
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 9f23de248..2cdea8274 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1233,7 +1233,7 @@ static int create_new_reflog_file(const char *filepath)
 		return error;
 
 	if ((fd = p_open(filepath,
-			O_WRONLY | O_CREAT | O_TRUNC,
+			O_WRONLY | O_CREAT,
 			GIT_REFLOG_FILE_MODE)) < 0)
 		return -1;
 
@@ -1245,6 +1245,24 @@ GIT_INLINE(int) retrieve_reflog_path(git_buf *path, git_repository *repo, const
 	return git_buf_join_n(path, '/', 3, repo->path_repository, GIT_REFLOG_DIR, name);
 }
 
+static int refdb_reflog_fs__ensure_log(git_refdb_backend *_backend, const char *name)
+{
+	refdb_fs_backend *backend;
+	git_repository *repo;
+	git_buf path = GIT_BUF_INIT;
+	int error;
+
+	assert(_backend && name);
+
+	backend = (refdb_fs_backend *) _backend;
+	repo = backend->repo;
+
+	if ((error = retrieve_reflog_path(&path, repo, name)) < 0)
+		return error;
+
+	return create_new_reflog_file(git_buf_cstr(&path));
+}
+
 static int has_reflog(git_repository *repo, const char *name)
 {
 	int ret = 0;
@@ -1590,6 +1608,7 @@ int git_refdb_backend_fs(
 	backend->parent.del = &refdb_fs_backend__delete;
 	backend->parent.rename = &refdb_fs_backend__rename;
 	backend->parent.compress = &refdb_fs_backend__compress;
+	backend->parent.ensure_log = &refdb_reflog_fs__ensure_log;
 	backend->parent.free = &refdb_fs_backend__free;
 	backend->parent.reflog_read = &refdb_reflog_fs__read;
 	backend->parent.reflog_write = &refdb_reflog_fs__write;
diff --git a/src/refs.c b/src/refs.c
index 598d6873c..902a17cfc 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -1068,6 +1068,19 @@ int git_reference_has_log(
 	return result;
 }
 
+int git_reference_ensure_log(git_repository *repo, const char *refname)
+{
+	int error;
+	git_refdb *refdb;
+
+	assert(repo && refname);
+
+	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
+		return error;
+
+	return git_refdb_ensure_log(refdb, refname);
+}
+
 int git_reference__is_branch(const char *ref_name)
 {
 	return git__prefixcmp(ref_name, GIT_REFS_HEADS_DIR) == 0;
diff --git a/src/stash.c b/src/stash.c
index 66b1cd7c5..7d7bf78c3 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -414,6 +414,9 @@ static int update_reflog(
 	git_reference *stash;
 	int error;
 
+	if ((error = git_reference_ensure_log(repo, GIT_REFS_STASH_FILE)) < 0)
+		return error;
+
 	error = git_reference_create_with_log(&stash, repo, GIT_REFS_STASH_FILE, w_commit_oid, 1, stasher, message);
 
 	git_reference_free(stash);
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index 6c9375dc7..9f414f21d 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -212,12 +212,9 @@ void test_refs_reflog_reflog__write_when_explicitly_active(void)
 {
 	git_reference *ref;
 	git_oid id;
-	git_buf path = GIT_BUF_INIT;
 
 	git_oid_fromstr(&id, current_master_tip);
-	cl_git_pass(git_buf_join(&path, '/', git_repository_path(g_repo), "logs/refs/tags/foo"));
-	cl_git_pass(git_futils_mkpath2file(git_buf_cstr(&path), 0777));
-	cl_git_mkfile(git_buf_cstr(&path), "");
+	git_reference_ensure_log(g_repo, "refs/tags/foo");
 
 	cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1));
 	git_reference_free(ref);
-- 
cgit v1.2.3


From f21051297cc698644ea0dc9c7122ec944dba2863 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 23 Nov 2013 14:39:53 +0100
Subject: refs: expose has_log() on the backend

The frontend used to look at the file directly, but that's obviously not
the right thing to do. Expose it on the backend and use that function
instead.
---
 include/git2/refs.h              |  6 +++---
 include/git2/sys/refdb_backend.h |  5 +++++
 src/refdb.c                      |  7 +++++++
 src/refdb.h                      |  1 +
 src/refdb_fs.c                   | 12 ++++++++++++
 src/refs.c                       | 19 +++++++------------
 tests/refs/reflog/reflog.c       |  8 +-------
 7 files changed, 36 insertions(+), 22 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 31bf997fe..f88f448f0 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -548,12 +548,12 @@ GIT_EXTERN(int) git_reference_foreach_glob(
 /**
  * Check if a reflog exists for the specified reference.
  *
- * @param ref A git reference
- *
+ * @param repo the repository
+ * @param refname the reference's name
  * @return 0 when no reflog can be found, 1 when it exists;
  * otherwise an error code.
  */
-GIT_EXTERN(int) git_reference_has_log(git_reference *ref);
+GIT_EXTERN(int) git_reference_has_log(git_repository *repo, const char *refname);
 
 /**
  * Ensure there is a reflog for a particular reference.
diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index 1485ed73a..5bbd4ba4c 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -116,6 +116,11 @@ struct git_refdb_backend {
 	 */
 	int (*compress)(git_refdb_backend *backend);
 
+	/**
+	 * Query whether a particular reference has a log (may be empty)
+	 */
+	int (*has_log)(git_refdb_backend *backend, const char *refname);
+
 	/**
 	 * Make sure a particular reference will have a reflog which
 	 * will be appended to on writes.
diff --git a/src/refdb.c b/src/refdb.c
index 4f3169f88..411423d57 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -222,6 +222,13 @@ int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name)
 	return 0;
 }
 
+int git_refdb_has_log(git_refdb *db, const char *refname)
+{
+	assert(db && refname);
+
+	return db->backend->has_log(db->backend, refname);
+}
+
 int git_refdb_ensure_log(git_refdb *db, const char *refname)
 {
 	assert(db && refname);
diff --git a/src/refdb.h b/src/refdb.h
index 12c15cb9f..91eecb782 100644
--- a/src/refdb.h
+++ b/src/refdb.h
@@ -48,6 +48,7 @@ int git_refdb_delete(git_refdb *refdb, const char *ref_name);
 int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name);
 int git_refdb_reflog_write(git_reflog *reflog);
 
+int git_refdb_has_log(git_refdb *db, const char *refname);
 int git_refdb_ensure_log(git_refdb *refdb, const char *refname);
 
 
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 2cdea8274..e9ce648e1 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1278,6 +1278,17 @@ cleanup:
 	return ret;
 }
 
+static int refdb_reflog_fs__has_log(git_refdb_backend *_backend, const char *name)
+{
+	refdb_fs_backend *backend;
+
+	assert(_backend && name);
+
+	backend = (refdb_fs_backend *) _backend;
+
+	return has_reflog(backend->repo, name);
+}
+
 static int refdb_reflog_fs__read(git_reflog **out, git_refdb_backend *_backend, const char *name)
 {
 	int error = -1;
@@ -1608,6 +1619,7 @@ int git_refdb_backend_fs(
 	backend->parent.del = &refdb_fs_backend__delete;
 	backend->parent.rename = &refdb_fs_backend__rename;
 	backend->parent.compress = &refdb_fs_backend__compress;
+	backend->parent.has_log = &refdb_reflog_fs__has_log;
 	backend->parent.ensure_log = &refdb_reflog_fs__ensure_log;
 	backend->parent.free = &refdb_fs_backend__free;
 	backend->parent.reflog_read = &refdb_reflog_fs__read;
diff --git a/src/refs.c b/src/refs.c
index 902a17cfc..519770d2d 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -1050,22 +1050,17 @@ int git_reference__update_terminal(
 	return reference__update_terminal(repo, ref_name, oid, 0);
 }
 
-int git_reference_has_log(
-	git_reference *ref)
+int git_reference_has_log(git_repository *repo, const char *refname)
 {
-	git_buf path = GIT_BUF_INIT;
-	int result;
-
-	assert(ref);
+	int error;
+	git_refdb *refdb;
 
-	if (git_buf_join_n(&path, '/', 3, ref->db->repo->path_repository,
-		GIT_REFLOG_DIR, ref->name) < 0)
-		return -1;
+	assert(repo && refname);
 
-	result = git_path_isfile(git_buf_cstr(&path));
-	git_buf_free(&path);
+	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
+		return error;
 
-	return result;
+	return git_refdb_has_log(refdb, refname);
 }
 
 int git_reference_ensure_log(git_repository *repo, const char *refname)
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index 9f414f21d..a1c5adaf4 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -127,13 +127,7 @@ void test_refs_reflog_reflog__renaming_the_reference_moves_the_reflog(void)
 
 static void assert_has_reflog(bool expected_result, const char *name)
 {
-	git_reference *ref;
-
-	cl_git_pass(git_reference_lookup(&ref, g_repo, name));
-
-	cl_assert_equal_i(expected_result, git_reference_has_log(ref));
-
-	git_reference_free(ref);
+	cl_assert_equal_i(expected_result, git_reference_has_log(g_repo, name));
 }
 
 void test_refs_reflog_reflog__reference_has_reflog(void)
-- 
cgit v1.2.3


From 0db932254741934afcdb04e644c31ff86db0d58c Mon Sep 17 00:00:00 2001
From: Matthew Bowen <matthew@mgbowen.com>
Date: Mon, 9 Dec 2013 10:43:05 -0500
Subject: Fix GIT_MERGE_OPTS_INIT on MSVC.

---
 include/git2/merge.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 8a1dfec2e..610b0d509 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -85,7 +85,7 @@ typedef struct {
 } git_merge_opts;
 
 #define GIT_MERGE_OPTS_VERSION 1
-#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
+#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, (git_merge_flags_t)0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
 
 
 /**
-- 
cgit v1.2.3


From 5588f0736089ab00e12cb7ea7c8143ec666738e6 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 9 Dec 2013 10:25:36 -0500
Subject: Clean up warnings

---
 deps/regex/regex.c           | 13 ++++++++++---
 src/buffer.h                 |  3 ++-
 src/common.h                 |  2 ++
 src/merge.c                  |  4 ++--
 src/revert.c                 | 10 ++--------
 src/win32/precompiled.h      |  7 ++++---
 tests/blame/harder.c         |  8 ++++++++
 tests/merge/merge_helpers.c  |  1 -
 tests/merge/trees/commits.c  | 22 ----------------------
 tests/refs/branches/create.c |  3 ++-
 10 files changed, 32 insertions(+), 41 deletions(-)

diff --git a/deps/regex/regex.c b/deps/regex/regex.c
index f9a8c9bf1..225a001ee 100644
--- a/deps/regex/regex.c
+++ b/deps/regex/regex.c
@@ -67,10 +67,17 @@
 #include "regex_internal.h"
 
 #include "regex_internal.c"
+
 #ifdef GAWK
-#define bool int
-#define true (1)
-#define false (0)
+# define bool int
+
+# ifndef true
+#  define true (1)
+# endif
+
+# ifndef false
+#  define false (0)
+# endif
 #endif
 #include "regcomp.c"
 #include "regexec.c"
diff --git a/src/buffer.h b/src/buffer.h
index 4ca9d4d94..c88af6fef 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -7,10 +7,11 @@
 #ifndef INCLUDE_buffer_h__
 #define INCLUDE_buffer_h__
 
+#include <stdarg.h>
+
 #include "common.h"
 #include "git2/strarray.h"
 #include "git2/buffer.h"
-#include <stdarg.h>
 
 /* typedef struct {
  *  	char   *ptr;
diff --git a/src/common.h b/src/common.h
index 159d31b2e..a1888785e 100644
--- a/src/common.h
+++ b/src/common.h
@@ -42,6 +42,8 @@
 # endif
 #define GIT_STDLIB_CALL
 
+# include <arpa/inet.h>
+
 #endif
 
 #include "git2/types.h"
diff --git a/src/merge.c b/src/merge.c
index ef138c284..45387d4ad 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2306,8 +2306,8 @@ done:
 
 int git_merge__indexes(git_repository *repo, git_index *index_new)
 {
-	git_index *index_repo;
-	unsigned int index_repo_caps;
+	git_index *index_repo = NULL;
+	unsigned int index_repo_caps = 0;
 	git_vector paths = GIT_VECTOR_INIT;
 	size_t index_conflicts = 0, wd_conflicts = 0, conflicts, i;
 	char *path;
diff --git a/src/revert.c b/src/revert.c
index 7ed04fee3..6cfd591b4 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -20,15 +20,12 @@
 
 static int write_revert_head(
 	git_repository *repo,
-	const git_commit *commit,
 	const char *commit_oidstr)
 {
 	git_filebuf file = GIT_FILEBUF_INIT;
 	git_buf file_path = GIT_BUF_INIT;
 	int error = 0;
 
-	assert(repo && commit);
-
 	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_REVERT_HEAD_FILE)) >= 0 &&
 		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_REVERT_FILE_MODE)) >= 0 &&
 		(error = git_filebuf_printf(&file, "%s\n", commit_oidstr)) >= 0)
@@ -44,7 +41,6 @@ static int write_revert_head(
 
 static int write_merge_msg(
 	git_repository *repo,
-	const git_commit *commit,
 	const char *commit_oidstr,
 	const char *commit_msgline)
 {
@@ -52,8 +48,6 @@ static int write_merge_msg(
 	git_buf file_path = GIT_BUF_INIT;
 	int error = 0;
 
-	assert(repo && commit);
-
 	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_MERGE_MSG_FILE)) < 0 ||
 		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_REVERT_FILE_MODE)) < 0 ||
 		(error = git_filebuf_printf(&file, "Revert \"%s\"\n\nThis reverts commit %s.\n",
@@ -198,8 +192,8 @@ int git_revert(
 
 	if ((error = git_buf_printf(&their_label, "parent of %.7s... %s", commit_oidstr, commit_msg)) < 0 ||
 		(error = revert_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 ||
-		(error = write_revert_head(repo, commit, commit_oidstr)) < 0 ||
-		(error = write_merge_msg(repo, commit, commit_oidstr, commit_msg)) < 0 ||
+		(error = write_revert_head(repo, commit_oidstr)) < 0 ||
+		(error = write_merge_msg(repo, commit_oidstr, commit_msg)) < 0 ||
 		(error = git_repository_head(&our_ref, repo)) < 0 ||
 		(error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJ_COMMIT)) < 0 ||
 		(error = git_revert_commit(&index_new, repo, commit, our_commit, opts.mainline, &opts.merge_tree_opts)) < 0 ||
diff --git a/src/win32/precompiled.h b/src/win32/precompiled.h
index cbfe98812..33ce106d3 100644
--- a/src/win32/precompiled.h
+++ b/src/win32/precompiled.h
@@ -1,6 +1,3 @@
-#include "git2.h"
-#include "common.h"
-
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
@@ -9,6 +6,7 @@
 #include <string.h>
 #include <fcntl.h>
 #include <time.h>
+#include <stdarg.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -20,3 +18,6 @@
 #ifdef GIT_THREADS
  #include "win32/pthread.h"
 #endif
+
+#include "git2.h"
+#include "common.h"
diff --git a/tests/blame/harder.c b/tests/blame/harder.c
index 7c4dd4f74..e77741720 100644
--- a/tests/blame/harder.c
+++ b/tests/blame/harder.c
@@ -36,6 +36,8 @@ void test_blame_harder__m(void)
 	/* TODO */
 	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
 
+	GIT_UNUSED(opts);
+
 	opts.flags = GIT_BLAME_TRACK_COPIES_SAME_FILE;
 }
 
@@ -44,6 +46,8 @@ void test_blame_harder__c(void)
 {
 	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
 
+	GIT_UNUSED(opts);
+
 	/* Attribute the first hunk in b.txt to (E), since it was cut/pasted from
 	 * a.txt in (D).
 	 */
@@ -54,6 +58,8 @@ void test_blame_harder__cc(void)
 {
 	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
 
+	GIT_UNUSED(opts);
+
 	/* Attribute the second hunk in b.txt to (E), since it was copy/pasted from
 	 * a.txt in (C).
 	 */
@@ -63,6 +69,8 @@ void test_blame_harder__cc(void)
 void test_blame_harder__ccc(void)
 {
 	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
+
+	GIT_UNUSED(opts);
 	
 	/* Attribute the third hunk in b.txt to (E).  This hunk was deleted from
 	 * a.txt in (D), but reintroduced in (B).
diff --git a/tests/merge/merge_helpers.c b/tests/merge/merge_helpers.c
index 7ca1e6522..5660179a7 100644
--- a/tests/merge/merge_helpers.c
+++ b/tests/merge/merge_helpers.c
@@ -60,7 +60,6 @@ int merge_commits_from_branches(
 	git_commit *our_commit, *their_commit;
 	git_oid our_oid, their_oid;
 	git_buf branch_buf = GIT_BUF_INIT;
-	int error;
 
 	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, ours_name);
 	cl_git_pass(git_reference_name_to_id(&our_oid, repo, branch_buf.ptr));
diff --git a/tests/merge/trees/commits.c b/tests/merge/trees/commits.c
index 92680c3c7..f8f4fbacb 100644
--- a/tests/merge/trees/commits.c
+++ b/tests/merge/trees/commits.c
@@ -29,28 +29,6 @@ void test_merge_trees_commits__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-static void merge_commits(
-	git_index **out,
-	git_repository *repo,
-	const char *our_oidstr,
-	const char *their_oidstr,
-	const git_merge_tree_opts *opts)
-{
-	git_oid our_oid, their_oid;
-	git_commit *our_commit, *their_commit;
-
-	cl_git_pass(git_oid_fromstr(&our_oid, our_oidstr));
-	cl_git_pass(git_oid_fromstr(&their_oid, their_oidstr));
-
-	cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid));
-	cl_git_pass(git_commit_lookup(&their_commit, repo, &their_oid));
-
-	cl_git_pass(git_merge_commits(out, repo, our_commit, their_commit, opts));
-
-	git_commit_free(our_commit);
-	git_commit_free(their_commit);
-}
-
 void test_merge_trees_commits__automerge(void)
 {
 	git_index *index;
diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 693a592a3..e4ad6683e 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -73,4 +73,5 @@ void test_refs_branches_create__creating_a_branch_with_an_invalid_name_returns_E
 
 	cl_assert_equal_i(GIT_EINVALIDSPEC,
 		git_branch_create(&branch, repo, "inv@{id", target, 0));
-}
\ No newline at end of file
+}
+
-- 
cgit v1.2.3


From 5a52d6be4c3a2635a3121b529e0ab2ab674f6be6 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 11 Dec 2013 06:43:17 -0800
Subject: Check version earlier

---
 src/diff_tform.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index 3ff6108c8..702e43bd3 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -275,6 +275,8 @@ static int normalize_find_opts(
 {
 	git_config *cfg = NULL;
 
+	GITERR_CHECK_VERSION(given, GIT_DIFF_FIND_OPTIONS_VERSION, "git_diff_find_options");
+
 	if (diff->repo != NULL &&
 		git_repository_config__weakptr(&cfg, diff->repo) < 0)
 		return -1;
@@ -302,7 +304,6 @@ static int normalize_find_opts(
 				opts->flags |= GIT_DIFF_FIND_RENAMES;
 		}
 	}
-	GITERR_CHECK_VERSION(given, GIT_DIFF_FIND_OPTIONS_VERSION, "git_diff_find_options");
 
 	/* some flags imply others */
 
-- 
cgit v1.2.3


From 9f77b3f6f5ce6944ec49dfc666ef6b8df0af0c6b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 25 Nov 2013 14:21:34 -0800
Subject: Add config read fns with controlled error behavior

This adds `git_config__lookup_entry` which will look up a key in
a config and return either the entry or NULL if the key was not
present.  Optionally, it can either suppress all errors or can
return them (although not finding the key is not an error for this
function).  Unlike other accessors, this does not normalize the
config key string, so it must only be used when the key is known
to be in normalized form (i.e. all lower-case before the first dot
and after the last dot, with no invalid characters).

This also adds three high-level helper functions to look up config
values with no errors and a fallback value.  The three functions
are for string, bool, and int values, and will resort to the
fallback value for any error that arises.  They are:

* `git_config__get_string_force`
* `git_config__get_bool_force`
* `git_config__get_int_force`

None of them normalize the config `key` either, so they can only
be used for internal cases where the key is known to be in normal
format.
---
 include/git2/diff.h    |   8 +--
 src/attr.c             |  16 ++---
 src/config.c           | 181 +++++++++++++++++++++++++++++++------------------
 src/config.h           |  21 ++++++
 src/config_cache.c     |  22 +++---
 src/config_file.c      |  13 +---
 src/diff.c             |  39 +++--------
 src/diff_driver.c      |  39 ++++++-----
 src/diff_tform.c       |  35 ++++------
 src/merge.c            |  17 ++---
 src/notes.c            |  15 +---
 src/remote.c           |  63 +++++++----------
 src/repository.c       |  40 ++++++-----
 src/submodule.c        |  14 ++--
 src/transports/local.c |   3 +-
 15 files changed, 267 insertions(+), 259 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 315cc1215..d6919393a 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -468,7 +468,7 @@ typedef int (*git_diff_line_cb)(
  * Flags to control the behavior of diff rename/copy detection.
  */
 typedef enum {
-	/** Obey `diff.renames`. This is overridden by any other GIT_DIFF_FIND_ALL flag. */
+	/** Obey `diff.renames`. Overridden by any other GIT_DIFF_FIND_... flag. */
 	GIT_DIFF_FIND_BY_CONFIG = 0,
 
 	/** Look for renames? (`--find-renames`) */
@@ -577,9 +577,9 @@ typedef struct {
 	unsigned int version;
 
 	/**
-	 * Combination of git_diff_find_t values (default FIND_BY_CONFIG).
-	 * Note that if you don't explicitly set this, `diff.renames` could be set
-	 * to false, resulting in `git_diff_find_similar` doing nothing. 
+	 * Combination of git_diff_find_t values (default GIT_DIFF_FIND_BY_CONFIG).
+	 * NOTE: if you don't explicitly set this, `diff.renames` could be set
+	 * to false, resulting in `git_diff_find_similar` doing nothing.
 	 */
 	uint32_t flags;
 
diff --git a/src/attr.c b/src/attr.c
index 98a328a55..51895b7ac 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -603,11 +603,15 @@ static int attr_cache__lookup_path(
 {
 	git_buf buf = GIT_BUF_INIT;
 	int error;
-	const char *cfgval = NULL;
+	const git_config_entry *entry = NULL;
 
 	*out = NULL;
 
-	if (!(error = git_config_get_string(&cfgval, cfg, key))) {
+	if ((error = git_config__lookup_entry(&entry, cfg, key, false)) < 0)
+		return error;
+
+	if (entry) {
+		const char *cfgval = entry->value;
 
 		/* expand leading ~/ as needed */
 		if (cfgval && cfgval[0] == '~' && cfgval[1] == '/' &&
@@ -616,13 +620,9 @@ static int attr_cache__lookup_path(
 		else if (cfgval)
 			*out = git__strdup(cfgval);
 
-	} else if (error == GIT_ENOTFOUND) {
-		giterr_clear();
-		error = 0;
-
-		if (!git_futils_find_xdg_file(&buf, fallback))
-			*out = git_buf_detach(&buf);
 	}
+	else if (!git_futils_find_xdg_file(&buf, fallback))
+		*out = git_buf_detach(&buf);
 
 	git_buf_free(&buf);
 
diff --git a/src/config.c b/src/config.c
index 0d9471383..227adbc9b 100644
--- a/src/config.c
+++ b/src/config.c
@@ -620,6 +620,78 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value)
 /***********
  * Getters
  ***********/
+
+static int config_error_notfound(const char *name)
+{
+	giterr_set(GITERR_CONFIG, "Config value '%s' was not found", name);
+	return GIT_ENOTFOUND;
+}
+
+enum {
+	GET_ALL_ERRORS = 0,
+	GET_NO_MISSING = 1,
+	GET_NO_ERRORS  = 2
+};
+
+static int get_entry(
+	const git_config_entry **out,
+	const git_config *cfg,
+	const char *name,
+	bool normalize_name,
+	int want_errors)
+{
+	int res = GIT_ENOTFOUND;
+	const char *key = name;
+	char *normalized = NULL;
+	size_t i;
+	file_internal *internal;
+
+	*out = NULL;
+
+	if (normalize_name) {
+		if ((res = git_config__normalize_name(name, &normalized)) < 0)
+			goto cleanup;
+		key = normalized;
+	}
+
+	git_vector_foreach(&cfg->files, i, internal) {
+		if (!internal || !internal->file)
+			continue;
+
+		res = internal->file->get(internal->file, key, out);
+		if (res != GIT_ENOTFOUND)
+			break;
+	}
+
+	git__free(normalized);
+
+cleanup:
+	if (res == GIT_ENOTFOUND)
+		res = (want_errors > GET_ALL_ERRORS) ? 0 : config_error_notfound(name);
+	else if (res && (want_errors == GET_NO_ERRORS)) {
+		giterr_clear();
+		res = 0;
+	}
+
+	return res;
+}
+
+int git_config_get_entry(
+	const git_config_entry **out, const git_config *cfg, const char *name)
+{
+	return get_entry(out, cfg, name, true, GET_ALL_ERRORS);
+}
+
+int git_config__lookup_entry(
+	const git_config_entry **out,
+	const git_config *cfg,
+	const char *key,
+	bool no_errors)
+{
+	return get_entry(
+		out, cfg, key, false, no_errors ? GET_NO_ERRORS : GET_NO_MISSING);
+}
+
 int git_config_get_mapped(
 	int *out,
 	const git_config *cfg,
@@ -627,116 +699,91 @@ int git_config_get_mapped(
 	const git_cvar_map *maps,
 	size_t map_n)
 {
-	const char *value;
+	const git_config_entry *entry;
 	int ret;
 
-	if ((ret = git_config_get_string(&value, cfg, name)) < 0)
+	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
 		return ret;
 
-	return git_config_lookup_map_value(out, maps, map_n, value);
+	return git_config_lookup_map_value(out, maps, map_n, entry->value);
 }
 
 int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name)
 {
-	const char *value;
+	const git_config_entry *entry;
 	int ret;
 
-	if ((ret = git_config_get_string(&value, cfg, name)) < 0)
+	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
 		return ret;
 
-	return git_config_parse_int64(out, value);
+	return git_config_parse_int64(out, entry->value);
 }
 
 int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name)
 {
-	const char *value;
+	const git_config_entry *entry;
 	int ret;
 
-	if ((ret = git_config_get_string(&value, cfg, name)) < 0)
+	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
 		return ret;
 
-	return git_config_parse_int32(out, value);
+	return git_config_parse_int32(out, entry->value);
 }
 
-static int get_string_at_file(const char **out, const git_config_backend *file, const char *name)
+int git_config_get_bool(int *out, const git_config *cfg, const char *name)
 {
 	const git_config_entry *entry;
-	int res;
+	int ret;
 
-	res = file->get(file, name, &entry);
-	if (!res)
-		*out = entry->value;
+	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
+		return ret;
 
-	return res;
+	return git_config_parse_bool(out, entry->value);
 }
 
-static int config_error_notfound(const char *name)
+int git_config_get_string(
+	const char **out, const git_config *cfg, const char *name)
 {
-	giterr_set(GITERR_CONFIG, "Config value '%s' was not found", name);
-	return GIT_ENOTFOUND;
+	const git_config_entry *entry;
+	int ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
+	*out = !ret ? (entry->value ? entry->value : "") : NULL;
+	return ret;
 }
 
-static int get_string(const char **out, const git_config *cfg, const char *name)
+const char *git_config__get_string_force(
+	const git_config *cfg, const char *key, const char *fallback_value)
 {
-	file_internal *internal;
-	unsigned int i;
-	int res;
-
-	git_vector_foreach(&cfg->files, i, internal) {
-		if (!internal || !internal->file)
-			continue;
-
-		res = get_string_at_file(out, internal->file, name);
-		if (res != GIT_ENOTFOUND)
-			return res;
-	}
-
-	return config_error_notfound(name);
+	const git_config_entry *entry;
+	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
+	return (entry && entry->value) ? entry->value : fallback_value;
 }
 
-int git_config_get_bool(int *out, const git_config *cfg, const char *name)
+int git_config__get_bool_force(
+	const git_config *cfg, const char *key, int fallback_value)
 {
-	const char *value = NULL;
-	int ret;
-
-	if ((ret = get_string(&value, cfg, name)) < 0)
-		return ret;
-
-	return git_config_parse_bool(out, value);
-}
+	int val = fallback_value;
+	const git_config_entry *entry;
 
-int git_config_get_string(const char **out, const git_config *cfg, const char *name)
-{
-	int ret;
-	const char *str = NULL;
+	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
 
-	if ((ret = get_string(&str, cfg, name)) < 0)
-		return ret;
+	if (entry && git_config_parse_bool(&val, entry->value) < 0)
+		giterr_clear();
 
-	*out = str == NULL ? "" : str;
-	return 0;
+	return val;
 }
 
-int git_config_get_entry(const git_config_entry **out, const git_config *cfg, const char *name)
+int git_config__get_int_force(
+	const git_config *cfg, const char *key, int fallback_value)
 {
-	file_internal *internal;
-	unsigned int i;
-	git_config_backend *file;
-	int ret;
-
-	*out = NULL;
+	int32_t val = (int32_t)fallback_value;
+	const git_config_entry *entry;
 
-	git_vector_foreach(&cfg->files, i, internal) {
-		if (!internal || !internal->file)
-			continue;
-		file = internal->file;
+	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
 
-		ret = file->get(file, name, out);
-		if (ret != GIT_ENOTFOUND)
-			return ret;
-	}
+	if (entry && git_config_parse_int32(&val, entry->value) < 0)
+		giterr_clear();
 
-	return config_error_notfound(name);
+	return (int)val;
 }
 
 int git_config_get_multivar_foreach(
@@ -1070,7 +1117,7 @@ int git_config_parse_int64(int64_t *out, const char *value)
 	const char *num_end;
 	int64_t num;
 
-	if (git__strtol64(&num, value, &num_end, 0) < 0)
+	if (!value || git__strtol64(&num, value, &num_end, 0) < 0)
 		goto fail_parse;
 
 	switch (*num_end) {
diff --git a/src/config.h b/src/config.h
index 01e8465cc..3cd888c88 100644
--- a/src/config.h
+++ b/src/config.h
@@ -51,5 +51,26 @@ extern int git_config_file__ondisk(git_config_backend **out, const char *path);
 
 extern int git_config__normalize_name(const char *in, char **out);
 
+/* internal only: does not normalize key and sets out to NULL if not found */
+extern int git_config__lookup_entry(
+	const git_config_entry **out,
+	const git_config *cfg,
+	const char *key,
+	bool no_errors);
+
+/*
+ * Lookup functions that cannot fail.  These functions look up a config
+ * value and return a fallback value if the value is missing or if any
+ * failures occur while trying to access the value.
+ */
+
+extern const char *git_config__get_string_force(
+	const git_config *cfg, const char *key, const char *fallback_value);
+
+extern int git_config__get_bool_force(
+	const git_config *cfg, const char *key, int fallback_value);
+
+extern int git_config__get_int_force(
+	const git_config *cfg, const char *key, int fallback_value);
 
 #endif
diff --git a/src/config_cache.c b/src/config_cache.c
index 6808521a3..ec75d1501 100644
--- a/src/config_cache.c
+++ b/src/config_cache.c
@@ -78,22 +78,22 @@ int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
 		struct map_data *data = &_cvar_maps[(int)cvar];
 		git_config *config;
 		int error;
+		const git_config_entry *entry;
 
-		error = git_repository_config__weakptr(&config, repo);
-		if (error < 0)
+		if ((error = git_repository_config__weakptr(&config, repo)) < 0)
 			return error;
 
-		if (data->maps)
-			error = git_config_get_mapped(
-				out, config, data->cvar_name, data->maps, data->map_count);
-		else
-			error = git_config_get_bool(out, config, data->cvar_name);
+		git_config__lookup_entry(&entry, config, data->cvar_name, false);
 
-		if (error == GIT_ENOTFOUND) {
-			giterr_clear();
+		if (!entry)
 			*out = data->default_value;
-		}
-		else if (error < 0)
+		else if (data->maps)
+			error = git_config_lookup_map_value(
+				out, data->maps, data->map_count, entry->value);
+		else
+			error = git_config_parse_bool(out, entry->value);
+
+		if (error < 0)
 			return error;
 
 		repo->cvar_cache[(int)cvar] = *out;
diff --git a/src/config_file.c b/src/config_file.c
index 15c8de49c..0971aa7b0 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -404,20 +404,12 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 /*
  * Internal function that actually gets the value in string form
  */
-static int config_get(const git_config_backend *cfg, const char *name, const git_config_entry **out)
+static int config_get(const git_config_backend *cfg, const char *key, const git_config_entry **out)
 {
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	char *key;
-	khiter_t pos;
-	int error;
+	khiter_t pos = git_strmap_lookup_index(b->values, key);
 	cvar_t *var;
 
-	if ((error = git_config__normalize_name(name, &key)) < 0)
-		return error;
-
-	pos = git_strmap_lookup_index(b->values, key);
-	git__free(key);
-
 	/* no error message; the config system will write one */
 	if (!git_strmap_valid_index(b->values, pos))
 		return GIT_ENOTFOUND;
@@ -427,7 +419,6 @@ static int config_get(const git_config_backend *cfg, const char *name, const git
 		var = var->next;
 
 	*out = var->entry;
-
 	return 0;
 }
 
diff --git a/src/diff.c b/src/diff.c
index 4c33a0213..53a8f4638 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -304,26 +304,6 @@ bool git_diff_delta__should_skip(
 }
 
 
-static int config_bool(git_config *cfg, const char *name, int defvalue)
-{
-	int val = defvalue;
-
-	if (git_config_get_bool(&val, cfg, name) < 0)
-		giterr_clear();
-
-	return val;
-}
-
-static int config_int(git_config *cfg, const char *name, int defvalue)
-{
-	int val = defvalue;
-
-	if (git_config_get_int32(&val, cfg, name) < 0)
-		giterr_clear();
-
-	return val;
-}
-
 static const char *diff_mnemonic_prefix(
 	git_iterator_type_t type, bool left_side)
 {
@@ -422,8 +402,8 @@ static int diff_list_apply_options(
 		diff->opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
 
 	/* load config values that affect diff behavior */
-	if (git_repository_config__weakptr(&cfg, repo) < 0)
-		return -1;
+	if ((val = git_repository_config__weakptr(&cfg, repo)) < 0)
+		return val;
 
 	if (!git_repository__cvar(&val, repo, GIT_CVAR_SYMLINKS) && val)
 		diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_HAS_SYMLINKS;
@@ -445,7 +425,7 @@ static int diff_list_apply_options(
 
 	/* If not given explicit `opts`, check `diff.xyz` configs */
 	if (!opts) {
-		int context = config_int(cfg, "diff.context", 3);
+		int context = git_config__get_int_force(cfg, "diff.context", 3);
 		diff->opts.context_lines = context >= 0 ? (uint16_t)context : 3;
 
 		/* add other defaults here */
@@ -460,12 +440,11 @@ static int diff_list_apply_options(
 
 	/* if ignore_submodules not explicitly set, check diff config */
 	if (diff->opts.ignore_submodules <= 0) {
-		const char *str;
+		const git_config_entry *entry;
+		git_config__lookup_entry(&entry, cfg, "diff.ignoresubmodules", true);
 
-		if (git_config_get_string(&str , cfg, "diff.ignoreSubmodules") < 0)
-			giterr_clear();
-		else if (str != NULL &&
-			git_submodule_parse_ignore(&diff->opts.ignore_submodules, str) < 0)
+		if (entry && git_submodule_parse_ignore(
+				&diff->opts.ignore_submodules, entry->value) < 0)
 			giterr_clear();
 	}
 
@@ -474,9 +453,9 @@ static int diff_list_apply_options(
 		const char *use_old = DIFF_OLD_PREFIX_DEFAULT;
 		const char *use_new = DIFF_NEW_PREFIX_DEFAULT;
 
-		if (config_bool(cfg, "diff.noprefix", 0)) {
+		if (git_config__get_bool_force(cfg, "diff.noprefix", 0))
 			use_old = use_new = "";
-		} else if (config_bool(cfg, "diff.mnemonicprefix", 0)) {
+		else if (git_config__get_bool_force(cfg, "diff.mnemonicprefix", 0)) {
 			use_old = diff_mnemonic_prefix(diff->old_src, true);
 			use_new = diff_mnemonic_prefix(diff->new_src, false);
 		}
diff --git a/src/diff_driver.c b/src/diff_driver.c
index bd5a8fbd9..167c0cc5a 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -14,6 +14,7 @@
 #include "strmap.h"
 #include "map.h"
 #include "buf_text.h"
+#include "config.h"
 #include "repository.h"
 
 GIT__USE_STRMAP;
@@ -130,14 +131,14 @@ static git_diff_driver_registry *git_repository_driver_registry(
 static int git_diff_driver_load(
 	git_diff_driver **out, git_repository *repo, const char *driver_name)
 {
-	int error = 0, bval;
+	int error = 0;
 	git_diff_driver_registry *reg;
 	git_diff_driver *drv;
 	size_t namelen = strlen(driver_name);
 	khiter_t pos;
 	git_config *cfg;
 	git_buf name = GIT_BUF_INIT;
-	const char *val;
+	const git_config_entry *ce;
 	bool found_driver = false;
 
 	reg = git_repository_driver_registry(repo);
@@ -164,23 +165,21 @@ static int git_diff_driver_load(
 
 	if ((error = git_buf_printf(&name, "diff.%s.binary", driver_name)) < 0)
 		goto done;
-	if ((error = git_config_get_string(&val, cfg, name.ptr)) < 0) {
-		if (error != GIT_ENOTFOUND)
-			goto done;
-		/* diff.<driver>.binary unspecified, so just continue */
-		giterr_clear();
-	} else if (git_config_parse_bool(&bval, val) < 0) {
-		/* TODO: warn that diff.<driver>.binary has invalid value */
-		giterr_clear();
-	} else if (bval) {
+
+	switch (git_config__get_bool_force(cfg, name.ptr, -1)) {
+	case true:
 		/* if diff.<driver>.binary is true, just return the binary driver */
 		*out = &global_drivers[DIFF_DRIVER_BINARY];
 		goto done;
-	} else {
+	case false:
 		/* if diff.<driver>.binary is false, force binary checks off */
 		/* but still may have custom function context patterns, etc. */
 		drv->binary_flags = GIT_DIFF_FORCE_TEXT;
 		found_driver = true;
+		break;
+	default:
+		/* diff.<driver>.binary unspecified, so just continue */
+		break;
 	}
 
 	/* TODO: warn if diff.<name>.command or diff.<name>.textconv are set */
@@ -211,16 +210,16 @@ static int git_diff_driver_load(
 
 	git_buf_truncate(&name, namelen + strlen("diff.."));
 	git_buf_put(&name, "wordregex", strlen("wordregex"));
-	if ((error = git_config_get_string(&val, cfg, name.ptr)) < 0) {
-		if (error != GIT_ENOTFOUND)
-			goto done;
-		giterr_clear(); /* no diff.<driver>.wordregex, so just continue */
-	} else if ((error = regcomp(&drv->word_pattern, val, REG_EXTENDED)) != 0) {
-		/* TODO: warning about bad regex instead of failure */
-		error = giterr_set_regex(&drv->word_pattern, error);
+	if ((error = git_config__lookup_entry(&ce, cfg, name.ptr, false)) < 0)
 		goto done;
-	} else {
+	if (!ce || !ce->value)
+		/* no diff.<driver>.wordregex, so just continue */;
+	else if (!(error = regcomp(&drv->word_pattern, ce->value, REG_EXTENDED)))
 		found_driver = true;
+	else {
+		/* TODO: warn about bad regex instead of failure */
+		error = giterr_set_regex(&drv->word_pattern, error);
+		goto done;
 	}
 
 	/* TODO: look up diff.<driver>.algorithm to turn on minimal / patience
diff --git a/src/diff_tform.c b/src/diff_tform.c
index 702e43bd3..2f94b2e77 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -13,6 +13,7 @@
 #include "hashsig.h"
 #include "path.h"
 #include "fileops.h"
+#include "config.h"
 
 static git_diff_delta *diff_delta__dup(
 	const git_diff_delta *d, git_pool *pool)
@@ -290,19 +291,16 @@ static int normalize_find_opts(
 	if (!given ||
 		 (given->flags & GIT_DIFF_FIND_ALL) == GIT_DIFF_FIND_BY_CONFIG)
 	{
-		const char *val = NULL;
-
-		if (git_config_get_string(&val, cfg, "diff.renames") < 0)
-			giterr_clear();
-		else if (val) {
-			int boolval;
-			if (!git__parse_bool(&boolval, val) && !boolval) {
-				/* do nothing */
-			} else if (!strcasecmp(val, "copies") || !strcasecmp(val, "copy"))
-				opts->flags |= (GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES);
-			else
-				opts->flags |= GIT_DIFF_FIND_RENAMES;
-		}
+		const char *rule =
+			git_config__get_string_force(cfg, "diff.renames", "true");
+		int boolval;
+
+		if (!git__parse_bool(&boolval, rule) && !boolval)
+			/* don't set FIND_RENAMES if bool value is false */;
+		else if (!strcasecmp(rule, "copies") || !strcasecmp(rule, "copy"))
+			opts->flags |= GIT_DIFF_FIND_RENAMES | GIT_DIFF_FIND_COPIES;
+		else
+			opts->flags |= GIT_DIFF_FIND_RENAMES;
 	}
 
 	/* some flags imply others */
@@ -343,14 +341,11 @@ static int normalize_find_opts(
 #undef USE_DEFAULT
 
 	if (!opts->rename_limit) {
-		int32_t limit = 0;
-
-		opts->rename_limit = DEFAULT_RENAME_LIMIT;
+		opts->rename_limit = git_config__get_int_force(
+			cfg, "diff.renamelimit", DEFAULT_RENAME_LIMIT);
 
-		if (git_config_get_int32(&limit, cfg, "diff.renameLimit") < 0)
-			giterr_clear();
-		else if (limit > 0)
-			opts->rename_limit = limit;
+		if (opts->rename_limit <= 0)
+			opts->rename_limit = DEFAULT_RENAME_LIMIT;
 	}
 
 	/* assign the internal metric with whitespace flag as payload */
diff --git a/src/merge.c b/src/merge.c
index 45387d4ad..e552b037b 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -26,6 +26,7 @@
 #include "oid.h"
 #include "index.h"
 #include "filebuf.h"
+#include "config.h"
 
 #include "git2/types.h"
 #include "git2/repository.h"
@@ -1396,19 +1397,13 @@ static int merge_tree_normalize_opts(
 	}
 
 	if (!opts->target_limit) {
-		int32_t limit = 0;
+		int limit = git_config__get_int_force(cfg, "merge.renamelimit", 0);
 
-		opts->target_limit = GIT_MERGE_TREE_TARGET_LIMIT;
+		if (!limit)
+			limit = git_config__get_int_force(cfg, "diff.renamelimit", 0);
 
-		if (git_config_get_int32(&limit, cfg, "merge.renameLimit") < 0) {
-			giterr_clear();
-
-			if (git_config_get_int32(&limit, cfg, "diff.renameLimit") < 0)
-				giterr_clear();
-		}
-
-		if (limit > 0)
-			opts->target_limit = limit;
+		opts->target_limit = (limit <= 0) ?
+			GIT_MERGE_TREE_TARGET_LIMIT : (unsigned int)limit;
 	}
 
 	/* assign the internal metric with whitespace flag as payload */
diff --git a/src/notes.c b/src/notes.c
index beace1b50..d8ed32f82 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -378,20 +378,11 @@ cleanup:
 
 static int note_get_default_ref(const char **out, git_repository *repo)
 {
-	int ret;
 	git_config *cfg;
+	int ret = git_repository_config__weakptr(&cfg, repo);
 
-	*out = NULL;
-
-	if (git_repository_config__weakptr(&cfg, repo) < 0)
-		return -1;
-
-	ret = git_config_get_string(out, cfg, "core.notesRef");
-	if (ret == GIT_ENOTFOUND) {
-		giterr_clear();
-		*out = GIT_NOTES_DEFAULT_REF;
-		return 0;
-	}
+	*out = (ret != 0) ? NULL : git_config__get_string_force(
+		cfg, "core.notesref", GIT_NOTES_DEFAULT_REF);
 
 	return ret;
 }
diff --git a/src/remote.c b/src/remote.c
index 3d890a5f1..6f86a4b57 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -45,7 +45,7 @@ static int add_refspec(git_remote *remote, const char *string, bool is_fetch)
 
 static int download_tags_value(git_remote *remote, git_config *cfg)
 {
-	const char *val;
+	const git_config_entry *ce;
 	git_buf buf = GIT_BUF_INIT;
 	int error;
 
@@ -53,16 +53,14 @@ static int download_tags_value(git_remote *remote, git_config *cfg)
 	if (git_buf_printf(&buf, "remote.%s.tagopt", remote->name) < 0)
 		return -1;
 
-	error = git_config_get_string(&val, cfg, git_buf_cstr(&buf));
+	error = git_config__lookup_entry(&ce, cfg, git_buf_cstr(&buf), false);
 	git_buf_free(&buf);
-	if (!error && !strcmp(val, "--no-tags"))
-		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_NONE;
-	else if (!error && !strcmp(val, "--tags"))
-		remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
 
-	if (error == GIT_ENOTFOUND) {
-		giterr_clear();
-		error = 0;
+	if (!error && ce && ce->value) {
+		if (!strcmp(ce->value, "--no-tags"))
+			remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_NONE;
+		else if (!strcmp(ce->value, "--tags"))
+			remote->download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
 	}
 
 	return error;
@@ -104,12 +102,7 @@ static int get_check_cert(int *out, git_repository *repo)
 	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
 		return error;
 
-	if ((error = git_config_get_bool(out, cfg, "http.sslVerify")) == 0)
-		return 0;
-	else if (error != GIT_ENOTFOUND)
-		return error;
-
-	giterr_clear();
+	*out = git_config__get_bool_force(cfg, "http.sslverify", 1);
 	return 0;
 }
 
@@ -493,7 +486,7 @@ int git_remote_save(const git_remote *remote)
 		}
 		if (error < 0) {
 			git_buf_free(&buf);
-			return -1;
+			return error;
 		}
 	}
 
@@ -667,7 +660,8 @@ int git_remote_ls(const git_remote_head ***out, size_t *size, git_remote *remote
 int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_url)
 {
 	git_config *cfg;
-	const char *val;
+	const git_config_entry *ce;
+	const char *val = NULL;
 	int error;
 
 	assert(remote);
@@ -684,44 +678,39 @@ int git_remote__get_http_proxy(git_remote *remote, bool use_ssl, char **proxy_ur
 	 * to least specific. */
 
 	/* remote.<name>.proxy config setting */
-	if (remote->name && 0 != *(remote->name)) {
+	if (remote->name && remote->name[0]) {
 		git_buf buf = GIT_BUF_INIT;
 
 		if ((error = git_buf_printf(&buf, "remote.%s.proxy", remote->name)) < 0)
 			return error;
 
-		if ((error = git_config_get_string(&val, cfg, git_buf_cstr(&buf))) == 0 &&
-			val && ('\0' != *val)) {
-			git_buf_free(&buf);
+		error = git_config__lookup_entry(&ce, cfg, git_buf_cstr(&buf), false);
+		git_buf_free(&buf);
 
-			*proxy_url = git__strdup(val);
-			GITERR_CHECK_ALLOC(*proxy_url);
-			return 0;
-		} else if (error != GIT_ENOTFOUND)
+		if (error < 0)
 			return error;
 
-		giterr_clear();
-		git_buf_free(&buf);
+		if (ce && ce->value) {
+			val = ce->value;
+			goto found;
+		}
 	}
 
 	/* http.proxy config setting */
-	if ((error = git_config_get_string(&val, cfg, "http.proxy")) == 0 &&
-		val && ('\0' != *val)) {
-		*proxy_url = git__strdup(val);
-		GITERR_CHECK_ALLOC(*proxy_url);
-		return 0;
-	} else if (error != GIT_ENOTFOUND)
+	if ((error = git_config__lookup_entry(&ce, cfg, "http.proxy", false)) < 0)
 		return error;
-
-	giterr_clear();
+	if (ce && ce->value) {
+		val = ce->value;
+		goto found;
+	}
 
 	/* HTTP_PROXY / HTTPS_PROXY environment variables */
 	val = use_ssl ? getenv("HTTPS_PROXY") : getenv("HTTP_PROXY");
 
-	if (val && ('\0' != *val)) {
+found:
+	if (val && val[0]) {
 		*proxy_url = git__strdup(val);
 		GITERR_CHECK_ALLOC(*proxy_url);
-		return 0;
 	}
 
 	return 0;
diff --git a/src/repository.c b/src/repository.c
index 278c0384e..443744504 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -186,39 +186,37 @@ static int load_workdir(git_repository *repo, git_buf *parent_path)
 {
 	int         error;
 	git_config *config;
-	const char *worktree;
-	git_buf     worktree_buf = GIT_BUF_INIT;
+	const git_config_entry *ce;
+	git_buf     worktree = GIT_BUF_INIT;
 
 	if (repo->is_bare)
 		return 0;
 
-	if (git_repository_config__weakptr(&config, repo) < 0)
-		return -1;
+	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
+		return error;
 
-	error = git_config_get_string(&worktree, config, "core.worktree");
-	if (!error && worktree != NULL) {
-		error = git_path_prettify_dir(
-			&worktree_buf, worktree, repo->path_repository);
-		if (error < 0)
+	if ((error = git_config__lookup_entry(
+			&ce, config, "core.worktree", false)) < 0)
+		return error;
+
+	if (ce && ce->value) {
+		if ((error = git_path_prettify_dir(
+				&worktree, ce->value, repo->path_repository)) < 0)
 			return error;
-		repo->workdir = git_buf_detach(&worktree_buf);
+
+		repo->workdir = git_buf_detach(&worktree);
 	}
-	else if (error != GIT_ENOTFOUND)
-		return error;
+	else if (parent_path && git_path_isdir(parent_path->ptr))
+		repo->workdir = git_buf_detach(parent_path);
 	else {
-		giterr_clear();
+		if (git_path_dirname_r(&worktree, repo->path_repository) < 0 ||
+			git_path_to_dir(&worktree) < 0)
+			return -1;
 
-		if (parent_path && git_path_isdir(parent_path->ptr))
-			repo->workdir = git_buf_detach(parent_path);
-		else {
-			git_path_dirname_r(&worktree_buf, repo->path_repository);
-			git_path_to_dir(&worktree_buf);
-			repo->workdir = git_buf_detach(&worktree_buf);
-		}
+		repo->workdir = git_buf_detach(&worktree);
 	}
 
 	GITERR_CHECK_ALLOC(repo->workdir);
-
 	return 0;
 }
 
diff --git a/src/submodule.c b/src/submodule.c
index 586494fed..1e3d07911 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -1468,7 +1468,7 @@ static int submodule_update_config(
 	int error;
 	git_config *config;
 	git_buf key = GIT_BUF_INIT;
-	const char *old = NULL;
+	const git_config_entry *ce = NULL;
 
 	assert(submodule);
 
@@ -1480,14 +1480,16 @@ static int submodule_update_config(
 	if (error < 0)
 		goto cleanup;
 
-	if (git_config_get_string(&old, config, key.ptr) < 0)
-		giterr_clear();
+	if ((error = git_config__lookup_entry(&ce, config, key.ptr, false)) < 0)
+		goto cleanup;
 
-	if (!old && only_existing)
+	if (!ce && only_existing)
+		goto cleanup;
+	if (ce && !overwrite)
 		goto cleanup;
-	if (old && !overwrite)
+	if (value && ce && ce->value && !strcmp(ce->value, value))
 		goto cleanup;
-	if ((!old && !value) || (old && value && strcmp(old, value) == 0))
+	if (!value && (!ce || !ce->value))
 		goto cleanup;
 
 	if (!value)
diff --git a/src/transports/local.c b/src/transports/local.c
index 4502f0202..f09e797ce 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -250,8 +250,9 @@ static int local_negotiate_fetch(
 			git_oid_cpy(&rhead->loid, git_object_id(obj));
 		else if (error != GIT_ENOTFOUND)
 			return error;
+		else
+			giterr_clear();
 		git_object_free(obj);
-		giterr_clear();
 	}
 
 	return 0;
-- 
cgit v1.2.3


From 96869a4edb2872934e0e167a726ab240f4270fea Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 3 Dec 2013 16:45:39 -0800
Subject: Improve GIT_EUSER handling

This adds giterr_user_cancel to return GIT_EUSER and clear any
error message that is sitting around.  As a result of using that
in places, we need to be more thorough with capturing errors that
happen inside a callback when used internally.  To help with that,
this also adds giterr_capture and giterr_restore so that when we
internally use a foreach-type function that clears errors and
converts them to GIT_EUSER, it is easier to restore not just the
return value, but the actual error message text.
---
 include/git2/errors.h       |   3 +-
 src/attr.c                  |   3 +-
 src/blame.c                 |  24 +++++----
 src/blame.h                 |   2 +-
 src/branch.c                |  41 ++++++++-------
 src/checkout.c              |  17 +++---
 src/common.h                |  42 ++++++++++-----
 src/config.c                |  29 +++++------
 src/diff.c                  |  23 ++++----
 src/diff_patch.c            |  68 ++++++++++++------------
 src/diff_print.c            |  46 +++++++++-------
 src/diff_xdiff.c            |  25 ++++-----
 src/errors.c                |  45 ++++++++++++++--
 src/fileops.c               |  75 +++++++++++++--------------
 src/iterator.c              |  12 ++---
 src/odb_loose.c             |  20 ++++---
 src/odb_pack.c              |  58 +++++++++++++--------
 src/path.c                  |  11 ++--
 src/pool.c                  |   9 +++-
 src/refdb_fs.c              |  27 +++++++---
 src/refs.c                  |   2 +-
 src/remote.c                | 124 +++++++++++++++++++++++---------------------
 src/status.c                |  32 +++++++++---
 src/submodule.c             | 122 ++++++++++++++++++++++++-------------------
 tests/config/rename.c       |  82 +++++++++++++++++++++++++++++
 tests/config/validkeyname.c |  20 -------
 tests/config/write.c        |   1 +
 tests/refs/branches/move.c  |  44 +++++++++++++++-
 28 files changed, 624 insertions(+), 383 deletions(-)
 create mode 100644 tests/config/rename.c

diff --git a/include/git2/errors.h b/include/git2/errors.h
index f1a8ea1ae..c6076f3ab 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -8,7 +8,6 @@
 #define INCLUDE_git_errors_h__
 
 #include "common.h"
-#include "buffer.h"
 
 /**
  * @file git2/errors.h
@@ -91,7 +90,7 @@ GIT_EXTERN(void) giterr_clear(void);
  * Get the last error data and clear it.
  *
  * This copies the last error into the given `git_error` struct
- * and returns 0 if the copy was successful, leaving the error 
+ * and returns 0 if the copy was successful, leaving the error
  * cleared as if `giterr_clear` had been called.
  *
  * If there was no existing error in the library, -1 will be returned
diff --git a/src/attr.c b/src/attr.c
index 51895b7ac..2fccf21f8 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -193,8 +193,7 @@ int git_attr_foreach(
 
 				error = callback(assign->name, assign->value, payload);
 				if (error) {
-					giterr_clear();
-					error = GIT_EUSER;
+					error = giterr_user_cancel();
 					goto cleanup;
 				}
 			}
diff --git a/src/blame.c b/src/blame.c
index ea9f77af5..f732338e6 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -108,17 +108,23 @@ git_blame* git_blame__alloc(
 	git_blame_options opts,
 	const char *path)
 {
-	git_blame *gbr = (git_blame*)git__calloc(1, sizeof(git_blame));
-	if (!gbr) {
-		giterr_set_oom();
+	git_blame *gbr = git__calloc(1, sizeof(git_blame));
+	if (!gbr)
 		return NULL;
-	}
-	git_vector_init(&gbr->hunks, 8, hunk_cmp);
-	git_vector_init(&gbr->paths, 8, paths_cmp);
+
 	gbr->repository = repo;
 	gbr->options = opts;
-	gbr->path = git__strdup(path);
-	git_vector_insert(&gbr->paths, git__strdup(path));
+
+	if (git_vector_init(&gbr->hunks, 8, hunk_cmp) < 0 ||
+		git_vector_init(&gbr->paths, 8, paths_cmp) < 0 ||
+		(gbr->path = git__strdup(path)) == NULL ||
+		git_vector_insert(&gbr->paths, git__strdup(path)) < 0)
+	{
+		git_blame_free(gbr);
+		git__free(gbr);
+		return NULL;
+	}
+
 	return gbr;
 }
 
@@ -140,7 +146,7 @@ void git_blame_free(git_blame *blame)
 
 	git_array_clear(blame->line_index);
 
-	git__free((void*)blame->path);
+	git__free(blame->path);
 	git_blob_free(blame->final_blob);
 	git__free(blame);
 }
diff --git a/src/blame.h b/src/blame.h
index 637e43985..7e23de808 100644
--- a/src/blame.h
+++ b/src/blame.h
@@ -64,7 +64,7 @@ typedef struct git_blame__entry {
 } git_blame__entry;
 
 struct git_blame {
-	const char *path;
+	char *path;
 	git_repository *repository;
 	git_blame_options options;
 
diff --git a/src/branch.c b/src/branch.c
index 95b3fd980..ef71c2cd1 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -90,29 +90,28 @@ int git_branch_delete(git_reference *branch)
 
 	assert(branch);
 
-	if (!git_reference_is_branch(branch) &&
-		!git_reference_is_remote(branch)) {
-		giterr_set(GITERR_INVALID, "Reference '%s' is not a valid branch.", git_reference_name(branch));
-		return -1;
+	if (!git_reference_is_branch(branch) && !git_reference_is_remote(branch)) {
+		giterr_set(GITERR_INVALID, "Reference '%s' is not a valid branch.",
+			git_reference_name(branch));
+		return GIT_ENOTFOUND;
 	}
 
 	if ((is_head = git_branch_is_head(branch)) < 0)
 		return is_head;
 
 	if (is_head) {
-		giterr_set(GITERR_REFERENCE,
-				"Cannot delete branch '%s' as it is the current HEAD of the repository.", git_reference_name(branch));
+		giterr_set(GITERR_REFERENCE, "Cannot delete branch '%s' as it is "
+			"the current HEAD of the repository.", git_reference_name(branch));
 		return -1;
 	}
 
-	if (git_buf_printf(&config_section, "branch.%s", git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)) < 0)
+	if (git_buf_join(&config_section, '.', "branch",
+			git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR)) < 0)
 		goto on_error;
 
 	if (git_config_rename_section(
-		git_reference_owner(branch), 
-		git_buf_cstr(&config_section),
-		NULL) < 0)
-			goto on_error;
+		git_reference_owner(branch), git_buf_cstr(&config_section), NULL) < 0)
+		goto on_error;
 
 	if (git_reference_delete(branch) < 0)
 		goto on_error;
@@ -206,17 +205,21 @@ int git_branch_move(
 	if (error < 0)
 		goto done;
 
-	git_buf_printf(&old_config_section,
-		"branch.%s", git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR));
-
-	git_buf_printf(&new_config_section, "branch.%s", new_branch_name);
+	/* first update ref then config so failure won't trash config */
 
-	if ((error = git_config_rename_section(git_reference_owner(branch),
-		git_buf_cstr(&old_config_section),
-		git_buf_cstr(&new_config_section))) < 0)
+	error = git_reference_rename(
+		out, branch, git_buf_cstr(&new_reference_name), force);
+	if (error < 0)
 		goto done;
 
-	error = git_reference_rename(out, branch, git_buf_cstr(&new_reference_name), force);
+	git_buf_join(&old_config_section, '.', "branch",
+		git_reference_name(branch) + strlen(GIT_REFS_HEADS_DIR));
+	git_buf_join(&new_config_section, '.', "branch", new_branch_name);
+
+	error = git_config_rename_section(
+		git_reference_owner(branch),
+		git_buf_cstr(&old_config_section),
+		git_buf_cstr(&new_config_section));
 
 done:
 	git_buf_free(&new_reference_name);
diff --git a/src/checkout.c b/src/checkout.c
index 6d7e3cfd4..4305d3e9a 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -216,7 +216,7 @@ static int checkout_action_common(
 
 	if (notify != GIT_CHECKOUT_NOTIFY_NONE &&
 		checkout_notify(data, notify, delta, wd) != 0)
-		return GIT_EUSER;
+		return giterr_user_cancel();
 
 	return action;
 }
@@ -230,7 +230,7 @@ static int checkout_action_no_wd(
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED: /* case 12 */
 		if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL))
-			return GIT_EUSER;
+			return giterr_user_cancel();
 		action = CHECKOUT_ACTION_IF(SAFE_CREATE, UPDATE_BLOB, NONE);
 		break;
 	case GIT_DELTA_ADDED:    /* case 2 or 28 (and 5 but not really) */
@@ -302,7 +302,7 @@ static int checkout_action_wd_only(
 	}
 
 	if (checkout_notify(data, notify, NULL, wd))
-		return GIT_EUSER;
+		return giterr_user_cancel();
 
 	if (remove) {
 		char *path = git_pool_strdup(&data->pool, wd->path);
@@ -342,7 +342,7 @@ static int checkout_action_with_wd(
 		if (checkout_is_workdir_modified(data, &delta->old_file, wd)) {
 			if (checkout_notify(
 					data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd))
-				return GIT_EUSER;
+				return giterr_user_cancel();
 			action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, NONE);
 		}
 		break;
@@ -406,7 +406,7 @@ static int checkout_action_with_wd_blocker(
 	case GIT_DELTA_UNMODIFIED:
 		/* should show delta as dirty / deleted */
 		if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd))
-			return GIT_EUSER;
+			return giterr_user_cancel();
 		action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, NONE);
 		break;
 	case GIT_DELTA_ADDED:
@@ -439,7 +439,7 @@ static int checkout_action_with_wd_dir(
 		if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL) ||
 			checkout_notify(
 				data, GIT_CHECKOUT_NOTIFY_UNTRACKED, NULL, wd))
-			return GIT_EUSER;
+			return giterr_user_cancel();
 		break;
 	case GIT_DELTA_ADDED:/* case 4 (and 7 for dir) */
 	case GIT_DELTA_MODIFIED: /* case 20 (or 37 but not really) */
@@ -452,7 +452,7 @@ static int checkout_action_with_wd_dir(
 		if (delta->old_file.mode != GIT_FILEMODE_TREE &&
 			checkout_notify(
 				data, GIT_CHECKOUT_NOTIFY_UNTRACKED, NULL, wd))
-			return GIT_EUSER;
+			return giterr_user_cancel();
 		break;
 	case GIT_DELTA_TYPECHANGE: /* case 24 or 31 */
 		if (delta->old_file.mode == GIT_FILEMODE_TREE) {
@@ -1998,9 +1998,6 @@ int git_checkout_iterator(
 	assert(data.completed_steps == data.total_steps);
 
 cleanup:
-	if (error == GIT_EUSER)
-		giterr_clear();
-
 	if (!error && data.index != NULL &&
 		(data.strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) == 0)
 		error = git_index_write(data.index);
diff --git a/src/common.h b/src/common.h
index a1888785e..0ad4130aa 100644
--- a/src/common.h
+++ b/src/common.h
@@ -78,27 +78,41 @@ int giterr_set_regex(const regex_t *regex, int error_code);
 /**
  * Gets the system error code for this thread.
  */
-GIT_INLINE(int) giterr_system_last(void)
-{
-#ifdef GIT_WIN32
-	return GetLastError();
-#else
-	return errno;
-#endif
-}
+int giterr_system_last(void);
 
 /**
  * Sets the system error code for this thread.
  */
-GIT_INLINE(void) giterr_system_set(int code)
+void giterr_system_set(int code);
+
+/**
+ * Note that a user cancelled an operation with GIT_EUSER
+ */
+GIT_INLINE(int) giterr_user_cancel(void)
 {
-#ifdef GIT_WIN32
-	SetLastError(code);
-#else
-	errno = code;
-#endif
+	giterr_clear();
+	return GIT_EUSER;
 }
 
+/**
+ * Structure to preserve libgit2 error state
+ */
+typedef struct {
+	int       error_code;
+	git_error error_msg;
+} git_error_state;
+
+/**
+ * Capture current error state to restore later, returning error code.
+ * If `error_code` is zero, this does nothing and returns zero.
+ */
+int giterr_capture(git_error_state *state, int error_code);
+
+/**
+ * Restore error state to a previous value, returning saved error code.
+ */
+int giterr_restore(git_error_state *state);
+
 /**
  * Check a versioned structure for validity
  */
diff --git a/src/config.c b/src/config.c
index 227adbc9b..3af9d58de 100644
--- a/src/config.c
+++ b/src/config.c
@@ -501,20 +501,18 @@ int git_config_backend_foreach_match(
 		return -1;
 	}
 
-	while(!(iter->next(&entry, iter) < 0)) {
+	while (!(iter->next(&entry, iter) < 0)) {
 		/* skip non-matching keys if regexp was provided */
 		if (regexp && regexec(&regex, entry->name, 0, NULL, 0) != 0)
 			continue;
 
 		/* abort iterator on non-zero return value */
 		if (fn(entry, data)) {
-			giterr_clear();
-			result = GIT_EUSER;
-			goto cleanup;
+			result = giterr_user_cancel();
+			break;
 		}
 	}
 
-cleanup:
 	if (regexp != NULL)
 		regfree(&regex);
 
@@ -537,9 +535,8 @@ int git_config_foreach_match(
 		return error;
 
 	while ((error = git_config_next(&entry, iter)) == 0) {
-		if(cb(entry, payload)) {
-			giterr_clear();
-			error = GIT_EUSER;
+		if (cb(entry, payload)) {
+			error = giterr_user_cancel();
 			break;
 		}
 	}
@@ -800,9 +797,10 @@ int git_config_get_multivar_foreach(
 	found = 0;
 	while ((err = iter->next(&entry, iter)) == 0) {
 		found = 1;
-		if(cb(entry, payload)) {
+
+		if (cb(entry, payload)) {
 			iter->free(iter);
-			return GIT_EUSER;
+			return giterr_user_cancel();
 		}
 	}
 
@@ -1214,7 +1212,7 @@ struct rename_data {
 	git_config *config;
 	git_buf *name;
 	size_t old_len;
-	int actual_error;
+	git_error_state error;
 };
 
 static int rename_config_entries_cb(
@@ -1237,9 +1235,8 @@ static int rename_config_entries_cb(
 	if (!error)
 		error = git_config_delete_entry(data->config, entry->name);
 
-	data->actual_error = error; /* preserve actual error code */
-
-	return error;
+	/* capture error message as needed, since it will become EUSER */
+	return giterr_capture(&data->error, error);
 }
 
 int git_config_rename_section(
@@ -1260,10 +1257,10 @@ int git_config_rename_section(
 	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
 		goto cleanup;
 
+	memset(&data, 0, sizeof(data));
 	data.config  = config;
 	data.name    = &replace;
 	data.old_len = strlen(old_section_name) + 1;
-	data.actual_error = 0;
 
 	if ((error = git_buf_join(&replace, '.', new_section_name, "")) < 0)
 		goto cleanup;
@@ -1281,7 +1278,7 @@ int git_config_rename_section(
 		config, git_buf_cstr(&pattern), rename_config_entries_cb, &data);
 
 	if (error == GIT_EUSER)
-		error = data.actual_error;
+		error = giterr_restore(&data.error);
 
 cleanup:
 	git_buf_free(&pattern);
diff --git a/src/diff.c b/src/diff.c
index 53a8f4638..ad058af61 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -120,7 +120,7 @@ static int diff_delta__from_one(
 		return -1;
 	}
 
-	return notify_res < 0 ? GIT_EUSER : 0;
+	return notify_res < 0 ? giterr_user_cancel() : 0;
 }
 
 static int diff_delta__from_two(
@@ -182,7 +182,7 @@ static int diff_delta__from_two(
 		return -1;
 	}
 
-	return notify_res < 0 ? GIT_EUSER : 0;
+	return notify_res < 0 ? giterr_user_cancel() : 0;
 }
 
 static git_diff_delta *diff_delta__last_for_item(
@@ -1343,7 +1343,7 @@ int git_diff__paired_foreach(
 	int (*cb)(git_diff_delta *h2i, git_diff_delta *i2w, void *payload),
 	void *payload)
 {
-	int cmp;
+	int cmp, error = 0;
 	git_diff_delta *h2i, *i2w;
 	size_t i, j, i_max, j_max;
 	int (*strcomp)(const char *, const char *) = git__strcmp;
@@ -1399,18 +1399,17 @@ int git_diff__paired_foreach(
 			strcomp(h2i->new_file.path, i2w->old_file.path);
 
 		if (cmp < 0) {
-			if (cb(h2i, NULL, payload))
-				return GIT_EUSER;
-			i++;
+			i++; i2w = NULL;
 		} else if (cmp > 0) {
-			if (cb(NULL, i2w, payload))
-				return GIT_EUSER;
-			j++;
+			j++; h2i = NULL;
 		} else {
-			if (cb(h2i, i2w, payload))
-				return GIT_EUSER;
 			i++; j++;
 		}
+
+		if (cb(h2i, i2w, payload)) {
+			error = giterr_user_cancel();
+			break;
+		}
 	}
 
 	/* restore case-insensitive delta sort */
@@ -1426,5 +1425,5 @@ int git_diff__paired_foreach(
 		git_vector_sort(&idx2wd->deltas);
 	}
 
-	return 0;
+	return error;
 }
diff --git a/src/diff_patch.c b/src/diff_patch.c
index cc49d68eb..c0910558e 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -32,6 +32,7 @@ struct git_patch {
 	git_array_t(git_diff_line)   lines;
 	size_t content_size, context_size, header_size;
 	git_pool flattened;
+	git_error_state error;
 };
 
 enum {
@@ -193,21 +194,17 @@ cleanup:
 	return error;
 }
 
-static int diff_patch_file_callback(
+static int diff_patch_invoke_file_callback(
 	git_patch *patch, git_diff_output *output)
 {
-	float progress;
-
-	if (!output->file_cb)
-		return 0;
-
-	progress = patch->diff ?
+	float progress = patch->diff ?
 		((float)patch->delta_index / patch->diff->deltas.length) : 1.0f;
 
-	if (output->file_cb(patch->delta, progress, output->payload) != 0)
-		output->error = GIT_EUSER;
+	if (output->file_cb &&
+		output->file_cb(patch->delta, progress, output->payload) != 0)
+		return giterr_user_cancel();
 
-	return output->error;
+	return 0;
 }
 
 static int diff_patch_generate(git_patch *patch, git_diff_output *output)
@@ -229,7 +226,7 @@ static int diff_patch_generate(git_patch *patch, git_diff_output *output)
 		return 0;
 
 	if (output->diff_cb != NULL &&
-		!(error = output->diff_cb(output, patch)))
+		(error = output->diff_cb(output, patch)) < 0)
 		patch->flags |= GIT_DIFF_PATCH_DIFFED;
 
 	return error;
@@ -272,9 +269,10 @@ int git_diff_foreach(
 	size_t idx;
 	git_patch patch;
 
-	if (diff_required(diff, "git_diff_foreach") < 0)
-		return -1;
+	if ((error = diff_required(diff, "git_diff_foreach")) < 0)
+		return error;
 
+	memset(&xo, 0, sizeof(xo));
 	diff_output_init(
 		&xo.output, &diff->opts, file_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, &diff->opts);
@@ -285,22 +283,18 @@ int git_diff_foreach(
 		if (git_diff_delta__should_skip(&diff->opts, patch.delta))
 			continue;
 
-		if (!(error = diff_patch_init_from_diff(&patch, diff, idx))) {
-
-			error = diff_patch_file_callback(&patch, &xo.output);
+		if ((error = diff_patch_init_from_diff(&patch, diff, idx)) < 0)
+			break;
 
-			if (!error)
-				error = diff_patch_generate(&patch, &xo.output);
+		if (!(error = diff_patch_invoke_file_callback(&patch, &xo.output)))
+			error = diff_patch_generate(&patch, &xo.output);
 
-			git_patch_free(&patch);
-		}
+		git_patch_free(&patch);
 
 		if (error < 0)
 			break;
 	}
 
-	if (error == GIT_EUSER)
-		giterr_clear(); /* don't leave error message set invalidly */
 	return error;
 }
 
@@ -332,7 +326,7 @@ static int diff_single_generate(diff_patch_with_delta *pd, git_xdiff_output *xo)
 		!(patch->ofile.opts_flags & GIT_DIFF_INCLUDE_UNMODIFIED))
 		return error;
 
-	error = diff_patch_file_callback(patch, (git_diff_output *)xo);
+	error = diff_patch_invoke_file_callback(patch, (git_diff_output *)xo);
 
 	if (!error)
 		error = diff_patch_generate(patch, (git_diff_output *)xo);
@@ -424,9 +418,7 @@ int git_diff_blobs(
 	diff_patch_with_delta pd;
 	git_xdiff_output xo;
 
-	memset(&pd, 0, sizeof(pd));
 	memset(&xo, 0, sizeof(xo));
-
 	diff_output_init(
 		&xo.output, opts, file_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, opts);
@@ -436,6 +428,7 @@ int git_diff_blobs(
 	else if (!new_path && old_path)
 		new_path = old_path;
 
+	memset(&pd, 0, sizeof(pd));
 	error = diff_patch_from_blobs(
 		&pd, &xo, old_blob, old_path, new_blob, new_path, opts);
 
@@ -463,13 +456,15 @@ int git_patch_from_blobs(
 		return -1;
 
 	memset(&xo, 0, sizeof(xo));
-
 	diff_output_to_patch(&xo.output, &pd->patch);
 	git_xdiff_init(&xo, opts);
 
 	error = diff_patch_from_blobs(
 		pd, &xo, old_blob, old_path, new_blob, new_path, opts);
 
+	if (error == GIT_EUSER)
+		error = giterr_restore(&pd->patch.error);
+
 	if (!error)
 		*out = (git_patch *)pd;
 	else
@@ -536,9 +531,7 @@ int git_diff_blob_to_buffer(
 	diff_patch_with_delta pd;
 	git_xdiff_output xo;
 
-	memset(&pd, 0, sizeof(pd));
 	memset(&xo, 0, sizeof(xo));
-
 	diff_output_init(
 		&xo.output, opts, file_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, opts);
@@ -548,6 +541,7 @@ int git_diff_blob_to_buffer(
 	else if (!buf_path && old_path)
 		buf_path = old_path;
 
+	memset(&pd, 0, sizeof(pd));
 	error = diff_patch_from_blob_and_buffer(
 		&pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
 
@@ -576,13 +570,15 @@ int git_patch_from_blob_and_buffer(
 		return -1;
 
 	memset(&xo, 0, sizeof(xo));
-
 	diff_output_to_patch(&xo.output, &pd->patch);
 	git_xdiff_init(&xo, opts);
 
 	error = diff_patch_from_blob_and_buffer(
 		pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
 
+	if (error == GIT_EUSER)
+		error = giterr_restore(&pd->patch.error);
+
 	if (!error)
 		*out = (git_patch *)pd;
 	else
@@ -622,14 +618,18 @@ int git_patch_from_diff(
 	if ((error = diff_patch_alloc_from_diff(&patch, diff, idx)) < 0)
 		return error;
 
+	memset(&xo, 0, sizeof(xo));
 	diff_output_to_patch(&xo.output, patch);
 	git_xdiff_init(&xo, &diff->opts);
 
-	error = diff_patch_file_callback(patch, &xo.output);
+	error = diff_patch_invoke_file_callback(patch, &xo.output);
 
 	if (!error)
 		error = diff_patch_generate(patch, &xo.output);
 
+	if (error == GIT_EUSER)
+		error = giterr_restore(&patch->error);
+
 	if (!error) {
 		/* if cumulative diff size is < 0.5 total size, flatten the patch */
 		/* unload the file content */
@@ -879,7 +879,8 @@ static int diff_patch_hunk_cb(
 	GIT_UNUSED(delta);
 
 	hunk = git_array_alloc(patch->hunks);
-	GITERR_CHECK_ALLOC(hunk);
+	if (!hunk)
+		return giterr_capture(&patch->error, -1);
 
 	memcpy(&hunk->hunk, hunk_, sizeof(hunk->hunk));
 
@@ -905,10 +906,11 @@ static int diff_patch_line_cb(
 	GIT_UNUSED(hunk_);
 
 	hunk = git_array_last(patch->hunks);
-	GITERR_CHECK_ALLOC(hunk);
+	assert(hunk); /* programmer error if no hunk is available */
 
 	line = git_array_alloc(patch->lines);
-	GITERR_CHECK_ALLOC(line);
+	if (!line)
+		return giterr_capture(&patch->error, -1);
 
 	memcpy(line, line_, sizeof(*line));
 
diff --git a/src/diff_print.c b/src/diff_print.c
index b04b11515..712402864 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -18,6 +18,7 @@ typedef struct {
 	uint32_t flags;
 	int oid_strlen;
 	git_diff_line line;
+	git_error_state error;
 } diff_print_info;
 
 static int diff_print_info_init(
@@ -33,6 +34,7 @@ static int diff_print_info_init(
 	pi->print_cb = cb;
 	pi->payload  = payload;
 	pi->buf      = out;
+	memset(&pi->error, 0, sizeof(pi->error));
 
 	if (diff)
 		pi->flags = diff->opts.flags;
@@ -89,12 +91,6 @@ char git_diff_status_char(git_delta_t status)
 	return code;
 }
 
-static int callback_error(void)
-{
-	giterr_clear();
-	return GIT_EUSER;
-}
-
 static int diff_print_one_name_only(
 	const git_diff_delta *delta, float progress, void *data)
 {
@@ -111,14 +107,14 @@ static int diff_print_one_name_only(
 
 	if (git_buf_puts(out, delta->new_file.path) < 0 ||
 		git_buf_putc(out, '\n'))
-		return -1;
+		return giterr_capture(&pi->error, -1);
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
 	pi->line.content     = git_buf_cstr(out);
 	pi->line.content_len = git_buf_len(out);
 
 	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return callback_error();
+		return giterr_user_cancel();
 
 	return 0;
 }
@@ -156,14 +152,14 @@ static int diff_print_one_name_status(
 		git_buf_printf(out, "%c\t%s\n", code, delta->old_file.path);
 
 	if (git_buf_oom(out))
-		return -1;
+		return giterr_capture(&pi->error, -1);
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
 	pi->line.content     = git_buf_cstr(out);
 	pi->line.content_len = git_buf_len(out);
 
 	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return callback_error();
+		return giterr_user_cancel();
 
 	return 0;
 }
@@ -202,14 +198,14 @@ static int diff_print_one_raw(
 			delta->old_file.path : delta->new_file.path);
 
 	if (git_buf_oom(out))
-		return -1;
+		return giterr_capture(&pi->error, -1);
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
 	pi->line.content     = git_buf_cstr(out);
 	pi->line.content_len = git_buf_len(out);
 
 	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return callback_error();
+		return giterr_user_cancel();
 
 	return 0;
 }
@@ -315,14 +311,14 @@ static int diff_print_patch_file(
 
 	if (git_diff_delta__format_file_header(
 			pi->buf, delta, oldpfx, newpfx, pi->oid_strlen) < 0)
-		return -1;
+		return giterr_capture(&pi->error, -1);
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
 	pi->line.content     = git_buf_cstr(pi->buf);
 	pi->line.content_len = git_buf_len(pi->buf);
 
 	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return callback_error();
+		return giterr_user_cancel();
 
 	if ((delta->flags & GIT_DIFF_FLAG_BINARY) == 0)
 		return 0;
@@ -332,7 +328,7 @@ static int diff_print_patch_file(
 	if (diff_delta_format_with_paths(
 			pi->buf, delta, oldpfx, newpfx,
 			"Binary files %s%s and %s%s differ\n") < 0)
-		return -1;
+		return giterr_capture(&pi->error, -1);
 
 	pi->line.origin      = GIT_DIFF_LINE_BINARY;
 	pi->line.content     = git_buf_cstr(pi->buf);
@@ -340,7 +336,7 @@ static int diff_print_patch_file(
 	pi->line.num_lines   = 1;
 
 	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return callback_error();
+		return giterr_user_cancel();
 
 	return 0;
 }
@@ -360,7 +356,7 @@ static int diff_print_patch_hunk(
 	pi->line.content_len = h->header_len;
 
 	if (pi->print_cb(d, h, &pi->line, pi->payload))
-		return callback_error();
+		return giterr_user_cancel();
 
 	return 0;
 }
@@ -377,7 +373,7 @@ static int diff_print_patch_line(
 		return 0;
 
 	if (pi->print_cb(delta, hunk, line, pi->payload))
-		return callback_error();
+		return giterr_user_cancel();
 
 	return 0;
 }
@@ -421,9 +417,14 @@ int git_diff_print(
 
 	if (!(error = diff_print_info_init(
 			&pi, &buf, diff, format, print_cb, payload)))
+	{
 		error = git_diff_foreach(
 			diff, print_file, print_hunk, print_line, &pi);
 
+		if (error == GIT_EUSER && pi.error.error_code)
+			error = giterr_restore(&pi.error);
+	}
+
 	git_buf_free(&buf);
 
 	return error;
@@ -444,10 +445,15 @@ int git_patch_print(
 	if (!(error = diff_print_info_init(
 			&pi, &temp, git_patch__diff(patch),
 			GIT_DIFF_FORMAT_PATCH, print_cb, payload)))
+	{
 		error = git_patch__invoke_callbacks(
 			patch, diff_print_patch_file, diff_print_patch_hunk,
 			diff_print_patch_line, &pi);
 
+		if (error && error != GIT_EUSER)
+			error = giterr_restore(&pi.error);
+	}
+
 	git_buf_free(&temp);
 
 	return error;
@@ -483,8 +489,10 @@ int git_patch_to_str(
 	/* GIT_EUSER means git_buf_put in print_to_buffer_cb returned -1,
 	 * meaning a memory allocation failure, so just map to -1...
 	 */
-	if (error == GIT_EUSER)
+	if (error == GIT_EUSER) {
+		giterr_set_oom();
 		error = -1;
+	}
 
 	*string = git_buf_detach(&output);
 
diff --git a/src/diff_xdiff.c b/src/diff_xdiff.c
index e0bc11f7f..c6ca48882 100644
--- a/src/diff_xdiff.c
+++ b/src/diff_xdiff.c
@@ -28,25 +28,29 @@ static int git_xdiff_parse_hunk(git_diff_hunk *hunk, const char *header)
 {
 	/* expect something of the form "@@ -%d[,%d] +%d[,%d] @@" */
 	if (*header != '@')
-		return -1;
+		goto fail;
 	if (git_xdiff_scan_int(&header, &hunk->old_start) < 0)
-		return -1;
+		goto fail;
 	if (*header == ',') {
 		if (git_xdiff_scan_int(&header, &hunk->old_lines) < 0)
-			return -1;
+			goto fail;
 	} else
 		hunk->old_lines = 1;
 	if (git_xdiff_scan_int(&header, &hunk->new_start) < 0)
-		return -1;
+		goto fail;
 	if (*header == ',') {
 		if (git_xdiff_scan_int(&header, &hunk->new_lines) < 0)
-			return -1;
+			goto fail;
 	} else
 		hunk->new_lines = 1;
 	if (hunk->old_start < 0 || hunk->new_start < 0)
-		return -1;
+		goto fail;
 
 	return 0;
+
+fail:
+	giterr_set(GITERR_INVALID, "Malformed hunk header from xdiff");
+	return -1;
 }
 
 typedef struct {
@@ -123,7 +127,7 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 
 		if (output->hunk_cb != NULL &&
 			output->hunk_cb(delta, &info->hunk, output->payload))
-			output->error = GIT_EUSER;
+			return (output->error = giterr_user_cancel());
 
 		info->old_lineno = info->hunk.old_start;
 		info->new_lineno = info->hunk.new_start;
@@ -149,7 +153,7 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 		if (!output->error &&
 			output->data_cb != NULL &&
 			output->data_cb(delta, &info->hunk, &line, output->payload))
-			output->error = GIT_EUSER;
+			output->error = giterr_user_cancel();
 	}
 
 	if (len == 3 && !output->error) {
@@ -171,7 +175,7 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 		if (!output->error &&
 			output->data_cb != NULL &&
 			output->data_cb(delta, &info->hunk, &line, output->payload))
-			output->error = GIT_EUSER;
+			output->error = giterr_user_cancel();
 	}
 
 	return output->error;
@@ -219,11 +223,9 @@ void git_xdiff_init(git_xdiff_output *xo, const git_diff_options *opts)
 
 	xo->output.diff_cb = git_xdiff;
 
-	memset(&xo->config, 0, sizeof(xo->config));
 	xo->config.ctxlen = opts ? opts->context_lines : 3;
 	xo->config.interhunkctxlen = opts ? opts->interhunk_lines : 0;
 
-	memset(&xo->params, 0, sizeof(xo->params));
 	if (flags & GIT_DIFF_IGNORE_WHITESPACE)
 		xo->params.flags |= XDF_WHITESPACE_FLAGS;
 	if (flags & GIT_DIFF_IGNORE_WHITESPACE_CHANGE)
@@ -236,6 +238,5 @@ void git_xdiff_init(git_xdiff_output *xo, const git_diff_options *opts)
 	if (flags & GIT_DIFF_MINIMAL)
 		xo->params.flags |= XDF_NEED_MINIMAL;
 
-	memset(&xo->callback, 0, sizeof(xo->callback));
 	xo->callback.outf = git_xdiff_cb;
 }
diff --git a/src/errors.c b/src/errors.c
index d04da4ca9..a0b085923 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -23,7 +23,8 @@ static void set_error(int error_class, char *string)
 {
 	git_error *error = &GIT_GLOBAL->error_t;
 
-	git__free(error->message);
+	if (error->message != string)
+		git__free(error->message);
 
 	error->message = string;
 	error->klass = error_class;
@@ -103,8 +104,10 @@ int giterr_set_regex(const regex_t *regex, int error_code)
 
 void giterr_clear(void)
 {
-	set_error(0, NULL);
-	GIT_GLOBAL->last_error = NULL;
+	if (GIT_GLOBAL->last_error != NULL) {
+		set_error(0, NULL);
+		GIT_GLOBAL->last_error = NULL;
+	}
 
 	errno = 0;
 #ifdef GIT_WIN32
@@ -134,3 +137,39 @@ const git_error *giterr_last(void)
 {
 	return GIT_GLOBAL->last_error;
 }
+
+int giterr_capture(git_error_state *state, int error_code)
+{
+	state->error_code = error_code;
+	if (error_code)
+		giterr_detach(&state->error_msg);
+	return error_code;
+}
+
+int giterr_restore(git_error_state *state)
+{
+	if (state && state->error_code && state->error_msg.message)
+		set_error(state->error_msg.klass, state->error_msg.message);
+	else
+		giterr_clear();
+
+	return state ? state->error_code : 0;
+}
+
+int giterr_system_last(void)
+{
+#ifdef GIT_WIN32
+	return GetLastError();
+#else
+	return errno;
+#endif
+}
+
+void giterr_system_set(int code)
+{
+#ifdef GIT_WIN32
+	SetLastError(code);
+#else
+	errno = code;
+#endif
+}
diff --git a/src/fileops.c b/src/fileops.c
index 5763b370b..0418e9e52 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -403,8 +403,8 @@ typedef struct {
 	const char *base;
 	size_t baselen;
 	uint32_t flags;
-	int error;
 	int depth;
+	git_error_state error;
 } futils__rmdir_data;
 
 #define FUTILS_MAX_DEPTH 100
@@ -447,8 +447,8 @@ static int futils__rm_first_parent(git_buf *path, const char *ceiling)
 
 static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path)
 {
+	int error = 0;
 	futils__rmdir_data *data = opaque;
-	int error = data->error;
 	struct stat st;
 
 	if (data->depth > FUTILS_MAX_DEPTH)
@@ -474,13 +474,16 @@ static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path)
 		data->depth++;
 
 		error = git_path_direach(path, 0, futils__rmdir_recurs_foreach, data);
-		if (error < 0)
-			return (error == GIT_EUSER) ? data->error : error;
+		if (error == GIT_EUSER)
+			return error;
 
 		data->depth--;
 
+		if (error < 0)
+			goto done;
+
 		if (data->depth == 0 && (data->flags & GIT_RMDIR_SKIP_ROOT) != 0)
-			return data->error;
+			goto done;
 
 		if ((error = p_rmdir(path->ptr)) < 0) {
 			if ((data->flags & GIT_RMDIR_SKIP_NONEMPTY) != 0 &&
@@ -499,35 +502,31 @@ static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path)
 	else if ((data->flags & GIT_RMDIR_SKIP_NONEMPTY) == 0)
 		error = futils__error_cannot_rmdir(path->ptr, "still present");
 
-	data->error = error;
-	return error;
+done:
+	return giterr_capture(&data->error, error);
 }
 
 static int futils__rmdir_empty_parent(void *opaque, git_buf *path)
 {
 	futils__rmdir_data *data = opaque;
-	int error;
+	int error = 0;
 
 	if (git_buf_len(path) <= data->baselen)
-		return GIT_ITEROVER;
-
-	error = p_rmdir(git_buf_cstr(path));
+		return giterr_capture(&data->error, GIT_ITEROVER);
 
-	if (error) {
+	if (p_rmdir(git_buf_cstr(path)) < 0) {
 		int en = errno;
 
 		if (en == ENOENT || en == ENOTDIR) {
-			giterr_clear();
-			error = 0;
+			/* do nothing */
 		} else if (en == ENOTEMPTY || en == EEXIST || en == EBUSY) {
-			giterr_clear();
 			error = GIT_ITEROVER;
 		} else {
 			error = git_path_set_error(errno, git_buf_cstr(path), "rmdir");
 		}
 	}
 
-	return error;
+	return giterr_capture(&data->error, error);
 }
 
 int git_futils_rmdir_r(
@@ -535,12 +534,13 @@ int git_futils_rmdir_r(
 {
 	int error;
 	git_buf fullpath = GIT_BUF_INIT;
-	futils__rmdir_data data = { 0 };
+	futils__rmdir_data data;
 
 	/* build path and find "root" where we should start calling mkdir */
 	if (git_path_join_unrooted(&fullpath, path, base, NULL) < 0)
 		return -1;
 
+	memset(&data, 0, sizeof(data));
 	data.base    = base ? base : "";
 	data.baselen = base ? strlen(base) : 0;
 	data.flags   = flags;
@@ -548,13 +548,14 @@ int git_futils_rmdir_r(
 	error = futils__rmdir_recurs_foreach(&data, &fullpath);
 
 	/* remove now-empty parents if requested */
-	if (!error && (flags & GIT_RMDIR_EMPTY_PARENTS) != 0) {
+	if (!error && (flags & GIT_RMDIR_EMPTY_PARENTS) != 0)
 		error = git_path_walk_up(
 			&fullpath, base, futils__rmdir_empty_parent, &data);
 
-		if (error == GIT_ITEROVER)
-			error = 0;
-	}
+	if (error == GIT_EUSER)
+		error = giterr_restore(&data.error);
+	if (error == GIT_ITEROVER)
+		error = 0;
 
 	git_buf_free(&fullpath);
 
@@ -858,7 +859,7 @@ typedef struct {
 	uint32_t flags;
 	uint32_t mkdir_flags;
 	mode_t dirmode;
-	int error;
+	git_error_state error;
 } cp_r_info;
 
 #define GIT_CPDIR__MKDIR_DONE_FOR_TO_ROOT (1u << 10)
@@ -896,23 +897,21 @@ static int _cp_r_callback(void *ref, git_buf *from)
 		from->ptr[git_path_basename_offset(from)] == '.')
 		return 0;
 
-	if (git_buf_joinpath(
-			&info->to, info->to_root, from->ptr + info->from_prefix) < 0) {
-		error = -1;
-		goto exit;
-	}
+	if ((error = git_buf_joinpath(
+			&info->to, info->to_root, from->ptr + info->from_prefix)) < 0)
+		goto done;
 
 	if (!(error = git_path_lstat(info->to.ptr, &to_st)))
 		exists = true;
 	else if (error != GIT_ENOTFOUND)
-		goto exit;
+		goto done;
 	else {
 		giterr_clear();
 		error = 0;
 	}
 
 	if ((error = git_path_lstat(from->ptr, &from_st)) < 0)
-		goto exit;
+		goto done;
 
 	if (S_ISDIR(from_st.st_mode)) {
 		mode_t oldmode = info->dirmode;
@@ -928,15 +927,14 @@ static int _cp_r_callback(void *ref, git_buf *from)
 		/* recurse onto target directory */
 		if (!error && (!exists || S_ISDIR(to_st.st_mode))) {
 			error = git_path_direach(from, 0, _cp_r_callback, info);
-
 			if (error == GIT_EUSER)
-				error = info->error;
+				return error;
 		}
 
 		if (oldmode != 0)
 			info->dirmode = oldmode;
 
-		goto exit;
+		goto done;
 	}
 
 	if (exists) {
@@ -947,7 +945,7 @@ static int _cp_r_callback(void *ref, git_buf *from)
 			giterr_set(GITERR_OS, "Cannot overwrite existing file '%s'",
 				info->to.ptr);
 			error = -1;
-			goto exit;
+			goto done;
 		}
 	}
 
@@ -960,7 +958,7 @@ static int _cp_r_callback(void *ref, git_buf *from)
 	/* Make container directory on demand if needed */
 	if ((info->flags & GIT_CPDIR_CREATE_EMPTY_DIRS) == 0 &&
 		(error = _cp_r_mkdir(info, from)) < 0)
-		goto exit;
+		goto done;
 
 	/* make symlink or regular file */
 	if (S_ISLNK(from_st.st_mode))
@@ -974,9 +972,8 @@ static int _cp_r_callback(void *ref, git_buf *from)
 		error = git_futils_cp(from->ptr, info->to.ptr, usemode);
 	}
 
-exit:
-	info->error = error;
-	return error;
+done:
+	return giterr_capture(&info->error, error);
 }
 
 int git_futils_cp_r(
@@ -992,11 +989,11 @@ int git_futils_cp_r(
 	if (git_buf_joinpath(&path, from, "") < 0) /* ensure trailing slash */
 		return -1;
 
+	memset(&info, 0, sizeof(info));
 	info.to_root = to;
 	info.flags   = flags;
 	info.dirmode = dirmode;
 	info.from_prefix = path.size;
-	info.error = 0;
 	git_buf_init(&info.to, 0);
 
 	/* precalculate mkdir flags */
@@ -1019,7 +1016,7 @@ int git_futils_cp_r(
 	git_buf_free(&info.to);
 
 	if (error == GIT_EUSER)
-		error = info.error;
+		error = giterr_restore(&info.error);
 
 	return error;
 }
diff --git a/src/iterator.c b/src/iterator.c
index 8646399ab..c1292227c 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -991,9 +991,8 @@ static int fs_iterator__expand_dir(fs_iterator *fi)
 		fi->base.start, fi->base.end, &ff->entries);
 
 	if (error < 0) {
-		git_error last_error = {0};
-
-		giterr_detach(&last_error);
+		git_error_state last_error = { 0 };
+		giterr_capture(&last_error, error);
 
 		/* these callbacks may clear the error message */
 		fs_iterator__free_frame(ff);
@@ -1001,12 +1000,7 @@ static int fs_iterator__expand_dir(fs_iterator *fi)
 		/* next time return value we skipped to */
 		fi->base.flags &= ~GIT_ITERATOR_FIRST_ACCESS;
 
-		if (last_error.message) {
-			giterr_set_str(last_error.klass, last_error.message);
-			free(last_error.message);
-		}
-
-		return error;
+		return giterr_restore(&last_error);
 	}
 
 	if (ff->entries.length == 0) {
diff --git a/src/odb_loose.c b/src/odb_loose.c
index ced272b33..ae772b425 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -696,7 +696,7 @@ struct foreach_state {
 	size_t dir_len;
 	git_odb_foreach_cb cb;
 	void *data;
-	int cb_error;
+	git_error_state cb_error;
 };
 
 GIT_INLINE(int) filename_to_oid(git_oid *oid, const char *ptr)
@@ -735,10 +735,8 @@ static int foreach_object_dir_cb(void *_state, git_buf *path)
 	if (filename_to_oid(&oid, path->ptr + state->dir_len) < 0)
 		return 0;
 
-	if (state->cb(&oid, state->data)) {
-		state->cb_error = GIT_EUSER;
-		return -1;
-	}
+	if (state->cb(&oid, state->data))
+		return giterr_user_cancel();
 
 	return 0;
 }
@@ -747,7 +745,9 @@ static int foreach_cb(void *_state, git_buf *path)
 {
 	struct foreach_state *state = (struct foreach_state *) _state;
 
-	return git_path_direach(path, 0, foreach_object_dir_cb, state);
+	return giterr_capture(
+		&state->cb_error,
+		git_path_direach(path, 0, foreach_object_dir_cb, state));
 }
 
 static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb cb, void *data)
@@ -762,7 +762,8 @@ static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb
 
 	objects_dir = backend->objects_dir;
 
-	git_buf_sets(&buf, objects_dir);
+	if (git_buf_sets(&buf, objects_dir) < 0)
+		return -1;
 	git_path_to_dir(&buf);
 
 	memset(&state, 0, sizeof(state));
@@ -772,9 +773,12 @@ static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb
 
 	error = git_path_direach(&buf, 0, foreach_cb, &state);
 
+	if (error == GIT_EUSER)
+		error = giterr_restore(&state.cb_error);
+
 	git_buf_free(&buf);
 
-	return state.cb_error ? state.cb_error : error;
+	return error;
 }
 
 static int loose_backend__stream_fwrite(git_odb_stream *_stream, const git_oid *oid)
diff --git a/src/odb_pack.c b/src/odb_pack.c
index fd2ca0fd8..2c0319fb6 100644
--- a/src/odb_pack.c
+++ b/src/odb_pack.c
@@ -190,31 +190,45 @@ static int packfile_sort__cb(const void *a_, const void *b_)
 }
 
 
+struct packfile_load_data {
+	struct pack_backend *backend;
+	git_error_state error;
+};
 
 static int packfile_load__cb(void *_data, git_buf *path)
 {
-	struct pack_backend *backend = (struct pack_backend *)_data;
+	struct packfile_load_data *data = _data;
+	struct pack_backend *backend = data->backend;
 	struct git_pack_file *pack;
+	const char *path_str = git_buf_cstr(path);
+	size_t i, cmp_len = git_buf_len(path);
 	int error;
-	size_t i;
 
-	if (git__suffixcmp(path->ptr, ".idx") != 0)
+	if (cmp_len <= strlen(".idx") || git__suffixcmp(path_str, ".idx") != 0)
 		return 0; /* not an index */
 
+	cmp_len -= strlen(".idx");
+
 	for (i = 0; i < backend->packs.length; ++i) {
 		struct git_pack_file *p = git_vector_get(&backend->packs, i);
-		if (memcmp(p->pack_name, git_buf_cstr(path), git_buf_len(path) - strlen(".idx")) == 0)
+
+		if (memcmp(p->pack_name, path_str, cmp_len) == 0)
 			return 0;
 	}
 
 	error = git_packfile_alloc(&pack, path->ptr);
-	if (error == GIT_ENOTFOUND)
-		/* ignore missing .pack file as git does */
+
+	/* ignore missing .pack file as git does */
+	if (error == GIT_ENOTFOUND) {
+		giterr_clear();
 		return 0;
-	else if (error < 0)
-		return error;
+	}
+
+	if (!error)
+		error = git_vector_insert(&backend->packs, pack);
+
+	return giterr_capture(&data->error, error);
 
-	return git_vector_insert(&backend->packs, pack);
 }
 
 static int pack_entry_find_inner(
@@ -314,32 +328,34 @@ static int pack_entry_find_prefix(
  * Implement the git_odb_backend API calls
  *
  ***********************************************************/
-static int pack_backend__refresh(git_odb_backend *_backend)
+static int pack_backend__refresh(git_odb_backend *backend)
 {
-	struct pack_backend *backend = (struct pack_backend *)_backend;
-
+	struct packfile_load_data data;
 	int error;
 	struct stat st;
 	git_buf path = GIT_BUF_INIT;
 
-	if (backend->pack_folder == NULL)
+	memset(&data, 0, sizeof(data));
+	data.backend = (struct pack_backend *)backend;
+
+	if (data.backend->pack_folder == NULL)
 		return 0;
 
-	if (p_stat(backend->pack_folder, &st) < 0 || !S_ISDIR(st.st_mode))
+	if (p_stat(data.backend->pack_folder, &st) < 0 || !S_ISDIR(st.st_mode))
 		return git_odb__error_notfound("failed to refresh packfiles", NULL);
 
-	git_buf_sets(&path, backend->pack_folder);
+	git_buf_sets(&path, data.backend->pack_folder);
 
 	/* reload all packs */
-	error = git_path_direach(&path, 0, packfile_load__cb, backend);
+	error = git_path_direach(&path, 0, packfile_load__cb, &data);
 
-	git_buf_free(&path);
+	if (error == GIT_EUSER)
+		error = giterr_restore(&data.error);
 
-	if (error < 0)
-		return -1;
+	git_buf_free(&path);
+	git_vector_sort(&data.backend->packs);
 
-	git_vector_sort(&backend->packs);
-	return 0;
+	return error;
 }
 
 static int pack_backend__read_header_internal(
diff --git a/src/path.c b/src/path.c
index 750dd3ef7..8be41c17e 100644
--- a/src/path.c
+++ b/src/path.c
@@ -434,7 +434,8 @@ int git_path_walk_up(
 	iter.asize = path->asize;
 
 	while (scan >= stop) {
-		error = cb(data, &iter);
+		if (cb(data, &iter))
+			error = giterr_user_cancel();
 		iter.ptr[scan] = oldc;
 		if (error < 0)
 			break;
@@ -528,7 +529,9 @@ bool git_path_is_empty_dir(const char *path)
 	if (!git_path_isdir(path))
 		return false;
 
-	if (!(error = git_buf_sets(&dir, path)))
+	if ((error = git_buf_sets(&dir, path)) != 0)
+		giterr_clear();
+	else
 		error = git_path_direach(&dir, 0, path_found_entry, NULL);
 
 	git_buf_free(&dir);
@@ -867,7 +870,7 @@ int git_path_direach(
 		if ((error = git_path_iconv(&ic, &de_path, &de_len)) < 0)
 			break;
 #endif
-				
+
 		if ((error = git_buf_put(path, de_path, de_len)) < 0)
 			break;
 
@@ -876,7 +879,7 @@ int git_path_direach(
 		git_buf_truncate(path, wd_len); /* restore path */
 
 		if (error) {
-			error = GIT_EUSER;
+			error = giterr_user_cancel();
 			break;
 		}
 	}
diff --git a/src/pool.c b/src/pool.c
index d484769e9..4796d0a81 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -217,7 +217,14 @@ char *git_pool_strdup(git_pool *pool, const char *str)
 
 char *git_pool_strdup_safe(git_pool *pool, const char *str)
 {
-	return str ? git_pool_strdup(pool, str) : NULL;
+	if (!str)
+		return NULL;
+	else {
+		char *result = git_pool_strdup(pool, str);
+		if (!result)
+			giterr_clear();
+		return result;
+	}
 }
 
 char *git_pool_strcat(git_pool *pool, const char *a, const char *b)
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 62d5c1047..938e02a78 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -264,9 +264,14 @@ done:
 	return error;
 }
 
-static int _dirent_loose_load(void *data, git_buf *full_path)
+struct packed_loadloose_data {
+	refdb_fs_backend *backend;
+	git_error_state error;
+};
+
+static int _dirent_loose_load(void *data_, git_buf *full_path)
 {
-	refdb_fs_backend *backend = (refdb_fs_backend *)data;
+	struct packed_loadloose_data *data = data_;
 	const char *file_path;
 
 	if (git__suffixcmp(full_path->ptr, ".lock") == 0)
@@ -274,11 +279,12 @@ static int _dirent_loose_load(void *data, git_buf *full_path)
 
 	if (git_path_isdir(full_path->ptr))
 		return git_path_direach(
-			full_path, backend->direach_flags, _dirent_loose_load, backend);
+			full_path, data->backend->direach_flags, _dirent_loose_load, data);
 
-	file_path = full_path->ptr + strlen(backend->path);
+	file_path = full_path->ptr + strlen(data->backend->path);
 
-	return loose_lookup_to_packfile(backend, file_path);
+	return giterr_capture(
+		&data->error, loose_lookup_to_packfile(data->backend, file_path));
 }
 
 /*
@@ -291,21 +297,28 @@ static int packed_loadloose(refdb_fs_backend *backend)
 {
 	int error;
 	git_buf refs_path = GIT_BUF_INIT;
+	struct packed_loadloose_data data;
 
 	if (git_buf_joinpath(&refs_path, backend->path, GIT_REFS_DIR) < 0)
 		return -1;
 
+	memset(&data, 0, sizeof(data));
+	data.backend = backend;
+
 	/*
 	 * Load all the loose files from disk into the Packfile table.
 	 * This will overwrite any old packed entries with their
 	 * updated loose versions
 	 */
 	error = git_path_direach(
-		&refs_path, backend->direach_flags, _dirent_loose_load, backend);
+		&refs_path, backend->direach_flags, _dirent_loose_load, &data);
 
 	git_buf_free(&refs_path);
 
-	return (error == GIT_EUSER) ? -1 : error;
+	if (error == GIT_EUSER)
+		error = giterr_restore(&data.error);
+
+	return error;
 }
 
 static int refdb_fs_backend__exists(
diff --git a/src/refs.c b/src/refs.c
index 472a79890..bae62158b 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -471,7 +471,7 @@ int git_reference_rename(
 	if ((error = git_refdb_rename(out, ref->db, ref->name, new_name, force)) < 0)
 		return error;
 
-	/* Update HEAD it was poiting to the reference being renamed. */
+	/* Update HEAD it was pointing to the reference being renamed */
 	if (should_head_be_updated &&
 		(error = git_repository_set_head(ref->db->repo, new_name)) < 0) {
 		giterr_set(GITERR_REFERENCE, "Failed to update HEAD after renaming reference");
diff --git a/src/remote.c b/src/remote.c
index 6f86a4b57..e4bebe1c6 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -251,13 +251,14 @@ int git_remote_create_inmemory(git_remote **out, git_repository *repo, const cha
 struct refspec_cb_data {
 	git_remote *remote;
 	int fetch;
+	git_error_state error;
 };
 
 static int refspec_cb(const git_config_entry *entry, void *payload)
 {
-	const struct refspec_cb_data *data = (struct refspec_cb_data *)payload;
-
-	return add_refspec(data->remote, entry->value, data->fetch);
+	struct refspec_cb_data *data = (struct refspec_cb_data *)payload;
+	return giterr_capture(
+		&data->error, add_refspec(data->remote, entry->value, data->fetch));
 }
 
 static int get_optional_config(
@@ -283,9 +284,6 @@ static int get_optional_config(
 		error = 0;
 	}
 
-	if (error < 0)
-		error = -1;
-
 	return error;
 }
 
@@ -296,7 +294,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	const char *val;
 	int error = 0;
 	git_config *config;
-	struct refspec_cb_data data;
+	struct refspec_cb_data data = { NULL };
 	bool optional_setting_found = false, found;
 
 	assert(out && repo && name);
@@ -363,6 +361,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 
 	data.remote = remote;
 	data.fetch = true;
+
 	git_buf_clear(&buf);
 	git_buf_printf(&buf, "remote.%s.fetch", name);
 
@@ -388,6 +387,9 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 cleanup:
 	git_buf_free(&buf);
 
+	if (error == GIT_EUSER)
+		error = giterr_restore(&data.error);
+
 	if (error < 0)
 		git_remote_free(remote);
 
@@ -1110,9 +1112,14 @@ void git_remote_free(git_remote *remote)
 	git__free(remote);
 }
 
+struct remote_list_data {
+	git_vector list;
+	git_error_state error;
+};
+
 static int remote_list_cb(const git_config_entry *entry, void *payload)
 {
-	git_vector *list = payload;
+	struct remote_list_data *data = payload;
 	const char *name = entry->name + strlen("remote.");
 	size_t namelen = strlen(name);
 	char *remote_name;
@@ -1123,47 +1130,50 @@ static int remote_list_cb(const git_config_entry *entry, void *payload)
 		remote_name = git__strndup(name, namelen - 4); /* strip ".url" */
 	else
 		remote_name = git__strndup(name, namelen - 8); /* strip ".pushurl" */
-	GITERR_CHECK_ALLOC(remote_name);
+	if (!remote_name)
+		return giterr_capture(&data->error, -1);
 
-	return git_vector_insert(list, remote_name);
+	return giterr_capture(
+		&data->error, git_vector_insert(&data->list, remote_name));
 }
 
 int git_remote_list(git_strarray *remotes_list, git_repository *repo)
 {
-	git_config *cfg;
-	git_vector list;
 	int error;
+	git_config *cfg;
+	struct remote_list_data data;
 
-	if (git_repository_config__weakptr(&cfg, repo) < 0)
-		return -1;
+	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
+		return error;
 
-	if (git_vector_init(&list, 4, git__strcmp_cb) < 0)
-		return -1;
+	memset(&data, 0, sizeof(data));
+	if ((error = git_vector_init(&data.list, 4, git__strcmp_cb)) < 0)
+		return error;
 
 	error = git_config_foreach_match(
-		cfg, "^remote\\..*\\.(push)?url$", remote_list_cb, &list);
+		cfg, "^remote\\..*\\.(push)?url$", remote_list_cb, &data);
+
+	/* cb error is converted to GIT_EUSER by git_config_foreach */
+	if (error == GIT_EUSER)
+		error = giterr_restore(&data.error);
 
 	if (error < 0) {
 		size_t i;
 		char *elem;
 
-		git_vector_foreach(&list, i, elem) {
+		git_vector_foreach(&data.list, i, elem) {
 			git__free(elem);
 		}
 
-		git_vector_free(&list);
-
-		/* cb error is converted to GIT_EUSER by git_config_foreach */
-		if (error == GIT_EUSER)
-			error = -1;
+		git_vector_free(&data.list);
 
 		return error;
 	}
 
-	git_vector_uniq(&list, git__free);
+	git_vector_uniq(&data.list, git__free);
 
-	remotes_list->strings = (char **)list.contents;
-	remotes_list->count = list.length;
+	remotes_list->strings = (char **)data.list.contents;
+	remotes_list->count = data.list.length;
 
 	return 0;
 }
@@ -1250,11 +1260,11 @@ cleanup:
 	return error;
 }
 
-struct update_data
-{
+struct update_data {
 	git_config *config;
 	const char *old_remote_name;
 	const char *new_remote_name;
+	git_error_state error;
 };
 
 static int update_config_entries_cb(
@@ -1266,10 +1276,9 @@ static int update_config_entries_cb(
 	if (strcmp(entry->value, data->old_remote_name))
 		return 0;
 
-	return git_config_set_string(
-		data->config,
-		entry->name,
-		data->new_remote_name);
+	return giterr_capture(
+		&data->error, git_config_set_string(
+			data->config, entry->name, data->new_remote_name));
 }
 
 static int update_branch_remote_config_entry(
@@ -1277,20 +1286,22 @@ static int update_branch_remote_config_entry(
 	const char *old_name,
 	const char *new_name)
 {
-	git_config *config;
-	struct update_data data;
+	int error;
+	struct update_data data = { NULL };
 
-	if (git_repository_config__weakptr(&config, repo) < 0)
-		return -1;
+	if ((error = git_repository_config__weakptr(&data.config, repo)) < 0)
+		return error;
 
-	data.config = config;
 	data.old_remote_name = old_name;
 	data.new_remote_name = new_name;
 
-	return git_config_foreach_match(
-		config,
-		"branch\\..+\\.remote",
-		update_config_entries_cb, &data);
+	error = git_config_foreach_match(
+		data.config, "branch\\..+\\.remote", update_config_entries_cb, &data);
+
+	if (error == GIT_EUSER)
+		error = giterr_restore(&data.error);
+
+	return error;
 }
 
 static int rename_one_remote_reference(
@@ -1298,18 +1309,20 @@ static int rename_one_remote_reference(
 	const char *old_remote_name,
 	const char *new_remote_name)
 {
-	int error = -1;
+	int error;
 	git_buf new_name = GIT_BUF_INIT;
 
-	if (git_buf_printf(
+	error = git_buf_printf(
 		&new_name,
 		GIT_REFS_REMOTES_DIR "%s%s",
 		new_remote_name,
-		reference->name + strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name)) < 0)
-			return -1;
+		reference->name + strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name));
 
-	error = git_reference_rename(NULL, reference, git_buf_cstr(&new_name), 0);
-	git_reference_free(reference);
+	if (!error) {
+		error = git_reference_rename(
+			NULL, reference, git_buf_cstr(&new_name), 0);
+		git_reference_free(reference);
+	}
 
 	git_buf_free(&new_name);
 	return error;
@@ -1320,12 +1333,12 @@ static int rename_remote_references(
 	const char *old_name,
 	const char *new_name)
 {
-	int error = -1;
+	int error;
 	git_reference *ref;
 	git_reference_iterator *iter;
 
-	if (git_reference_iterator_new(&iter, repo) < 0)
-		return -1;
+	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
+		return error;
 
 	while ((error = git_reference_next(&ref, iter)) == 0) {
 		if (git__prefixcmp(ref->name, GIT_REFS_REMOTES_DIR)) {
@@ -1333,18 +1346,13 @@ static int rename_remote_references(
 			continue;
 		}
 
-		if ((error = rename_one_remote_reference(ref, old_name, new_name)) < 0) {
-			git_reference_iterator_free(iter);
-			return error;
-		}
+		if ((error = rename_one_remote_reference(ref, old_name, new_name)) < 0)
+			break;
 	}
 
 	git_reference_iterator_free(iter);
 
-	if (error == GIT_ITEROVER)
-		return 0;
-
-	return error;
+	return (error == GIT_ITEROVER) ? 0 : error;
 }
 
 static int rename_fetch_refspecs(
diff --git a/src/status.c b/src/status.c
index 07fdcb5c3..fb99fb4e4 100644
--- a/src/status.c
+++ b/src/status.c
@@ -152,25 +152,32 @@ static git_status_t status_compute(
 	return st;
 }
 
+struct status_data {
+	git_status_list *status;
+	git_error_state err;
+};
+
 static int status_collect(
 	git_diff_delta *head2idx,
 	git_diff_delta *idx2wd,
 	void *payload)
 {
-	git_status_list *status = payload;
+	struct status_data *data = payload;
 	git_status_entry *status_entry;
 
-	if (!status_is_included(status, head2idx, idx2wd))
+	if (!status_is_included(data->status, head2idx, idx2wd))
 		return 0;
 
 	status_entry = git__malloc(sizeof(git_status_entry));
-	GITERR_CHECK_ALLOC(status_entry);
+	if (!status_entry)
+		return giterr_capture(&data->err, -1);
 
-	status_entry->status = status_compute(status, head2idx, idx2wd);
+	status_entry->status = status_compute(data->status, head2idx, idx2wd);
 	status_entry->head_to_index = head2idx;
 	status_entry->index_to_workdir = idx2wd;
 
-	return git_vector_insert(&status->paired, status_entry);
+	return giterr_capture(
+		&data->err, git_vector_insert(&data->status->paired, status_entry));
 }
 
 GIT_INLINE(int) status_entry_cmp_base(
@@ -314,9 +321,18 @@ int git_status_list_new(
 			goto done;
 	}
 
-	if ((error = git_diff__paired_foreach(
-			status->head2idx, status->idx2wd, status_collect, status)) < 0)
-		goto done;
+	{
+		struct status_data data = { 0 };
+		data.status = status;
+
+		error = git_diff__paired_foreach(
+			status->head2idx, status->idx2wd, status_collect, &data);
+
+		if (error == GIT_EUSER)
+			error = giterr_restore(&data.err);
+		if (error < 0)
+			goto done;
+	}
 
 	if (flags & GIT_STATUS_OPT_SORT_CASE_SENSITIVELY)
 		git_vector_set_cmp(&status->paired, status_entry_cmp);
diff --git a/src/submodule.c b/src/submodule.c
index 1e3d07911..15c87c0b4 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -71,6 +71,11 @@ __KHASH_IMPL(
 	str, static kh_inline, const char *, void *, 1,
 	str_hash_no_trailing_slash, str_equal_no_trailing_slash);
 
+struct submodule_callback_payload {
+	git_repository *repo;
+	git_error_state error;
+};
+
 static int load_submodule_config(git_repository *repo);
 static git_config_backend *open_gitmodules(git_repository *, bool, const git_oid *);
 static int lookup_head_remote(git_buf *url, git_repository *repo);
@@ -169,8 +174,7 @@ int git_submodule_foreach(
 		}
 
 		if (callback(sm, sm->name, payload)) {
-			giterr_clear();
-			error = GIT_EUSER;
+			error = giterr_user_cancel();
 			break;
 		}
 	});
@@ -821,20 +825,21 @@ int git_submodule_reload(git_submodule *submodule)
 {
 	int error = 0;
 	git_config_backend *mods;
+	struct submodule_callback_payload p;
 
 	assert(submodule);
 
 	/* refresh index data */
-
-	if (submodule_update_index(submodule) < 0)
-		return -1;
+	if ((error = submodule_update_index(submodule)) < 0)
+		return error;
 
 	/* refresh HEAD tree data */
-
-	if (submodule_update_head(submodule) < 0)
-		return -1;
+	if ((error = submodule_update_head(submodule)) < 0)
+		return error;
 
 	/* refresh config data */
+	memset(&p, 0, sizeof(p));
+	p.repo = submodule->repo;
 
 	mods = open_gitmodules(submodule->repo, false, NULL);
 	if (mods != NULL) {
@@ -846,23 +851,29 @@ int git_submodule_reload(git_submodule *submodule)
 
 		if (git_buf_oom(&path))
 			error = -1;
-		else
+		else {
 			error = git_config_file_foreach_match(
-				mods, path.ptr, submodule_load_from_config, submodule->repo);
+				mods, path.ptr, submodule_load_from_config, &p);
+
+			if (error == GIT_EUSER)
+				error = giterr_restore(&p.error);
+		}
 
 		git_buf_free(&path);
 		git_config_file_free(mods);
-	}
 
-	if (error < 0)
-		return error;
+		if (error < 0)
+			return error;
+	}
 
 	/* refresh wd data */
 
 	submodule->flags = submodule->flags &
 		~(GIT_SUBMODULE_STATUS_IN_WD | GIT_SUBMODULE_STATUS__WD_OID_VALID);
 
-	error = submodule_load_from_wd_lite(submodule, submodule->path, NULL);
+	error = submodule_load_from_wd_lite(submodule, submodule->path, &p);
+	if (error)
+		error = giterr_restore(&p.error);
 
 	return error;
 }
@@ -1087,15 +1098,14 @@ int git_submodule_parse_update(git_submodule_update_t *out, const char *value)
 }
 
 static int submodule_load_from_config(
-	const git_config_entry *entry, void *data)
+	const git_config_entry *entry, void *payload)
 {
-	git_repository *repo = data;
-	git_strmap *smcfg = repo->submodules;
+	struct submodule_callback_payload *p = payload;
+	git_strmap *smcfg = p->repo->submodules;
 	const char *namestart, *property, *alternate = NULL;
-	const char *key = entry->name, *value = entry->value;
+	const char *key = entry->name, *value = entry->value, *path;
 	git_buf name = GIT_BUF_INIT;
 	git_submodule *sm;
-	bool is_path;
 	int error = 0;
 
 	if (git__prefixcmp(key, "submodule.") != 0)
@@ -1108,15 +1118,11 @@ static int submodule_load_from_config(
 		return 0;
 
 	property++;
-	is_path = (strcasecmp(property, "path") == 0);
+	path = !strcasecmp(property, "path") ? value : NULL;
 
-	if (git_buf_set(&name, namestart, property - namestart - 1) < 0)
-		return -1;
-
-	if (submodule_get(&sm, repo, name.ptr, is_path ? value : NULL) < 0) {
-		git_buf_free(&name);
-		return -1;
-	}
+	if ((error = git_buf_set(&name, namestart, property - namestart - 1)) < 0 ||
+		(error = submodule_get(&sm, p->repo, name.ptr, path)) < 0)
+		goto done;
 
 	sm->flags |= GIT_SUBMODULE_STATUS_IN_CONFIG;
 
@@ -1130,15 +1136,20 @@ static int submodule_load_from_config(
 
 	if (strcmp(sm->name, name.ptr) != 0) {
 		alternate = sm->name = git_buf_detach(&name);
-	} else if (is_path && value && strcmp(sm->path, value) != 0) {
+	} else if (path && strcmp(path, sm->path) != 0) {
 		alternate = sm->path = git__strdup(value);
-		if (!sm->path)
+		if (!sm->path) {
 			error = -1;
+			goto done;
+		}
 	}
+
 	if (alternate) {
 		void *old_sm = NULL;
 		git_strmap_insert2(smcfg, alternate, sm, old_sm, error);
 
+		if (error < 0)
+			goto done;
 		if (error >= 0)
 			GIT_REFCOUNT_INC(sm); /* inserted under a new key */
 
@@ -1149,15 +1160,11 @@ static int submodule_load_from_config(
 		}
 	}
 
-	git_buf_free(&name);
-	if (error < 0)
-		return error;
-
 	/* TODO: Look up path in index and if it is present but not a GITLINK
 	 * then this should be deleted (at least to match git's behavior)
 	 */
 
-	if (is_path)
+	if (path)
 		return 0;
 
 	/* copy other properties into submodule entry */
@@ -1165,41 +1172,47 @@ static int submodule_load_from_config(
 		git__free(sm->url);
 		sm->url = NULL;
 
-		if (value != NULL && (sm->url = git__strdup(value)) == NULL)
-			return -1;
+		if (value != NULL && (sm->url = git__strdup(value)) == NULL) {
+			error = -1;
+			goto done;
+		}
 	}
 	else if (strcasecmp(property, "update") == 0) {
-		if (git_submodule_parse_update(&sm->update, value) < 0)
-			return -1;
+		if ((error = git_submodule_parse_update(&sm->update, value)) < 0)
+			goto done;
 		sm->update_default = sm->update;
 	}
 	else if (strcasecmp(property, "fetchRecurseSubmodules") == 0) {
-		if (git__parse_bool(&sm->fetch_recurse, value) < 0)
-			return submodule_config_error("fetchRecurseSubmodules", value);
+		if (git__parse_bool(&sm->fetch_recurse, value) < 0) {
+			error = submodule_config_error("fetchRecurseSubmodules", value);
+			goto done;
+		}
 	}
 	else if (strcasecmp(property, "ignore") == 0) {
-		if (git_submodule_parse_ignore(&sm->ignore, value) < 0)
-			return -1;
+		if ((error = git_submodule_parse_ignore(&sm->ignore, value)) < 0)
+			goto done;
 		sm->ignore_default = sm->ignore;
 	}
 	/* ignore other unknown submodule properties */
 
-	return 0;
+done:
+	git_buf_free(&name);
+	return giterr_capture(&p->error, error);
 }
 
 static int submodule_load_from_wd_lite(
 	git_submodule *sm, const char *name, void *payload)
 {
+	struct submodule_callback_payload *p = payload;
 	git_buf path = GIT_BUF_INIT;
 
 	GIT_UNUSED(name);
-	GIT_UNUSED(payload);
 
 	if (git_repository_is_bare(sm->repo))
 		return 0;
 
 	if (git_buf_joinpath(&path, git_repository_workdir(sm->repo), sm->path) < 0)
-		return -1;
+		return giterr_capture(&p->error, -1);
 
 	if (git_path_isdir(path.ptr))
 		sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED;
@@ -1208,7 +1221,6 @@ static int submodule_load_from_wd_lite(
 		sm->flags |= GIT_SUBMODULE_STATUS_IN_WD;
 
 	git_buf_free(&path);
-
 	return 0;
 }
 
@@ -1342,13 +1354,15 @@ static int load_submodule_config(git_repository *repo)
 {
 	int error;
 	git_oid gitmodules_oid;
-	git_buf path = GIT_BUF_INIT;
 	git_config_backend *mods = NULL;
+	struct submodule_callback_payload p;
 
 	if (repo->submodules)
 		return 0;
 
 	memset(&gitmodules_oid, 0, sizeof(gitmodules_oid));
+	memset(&p, 0, sizeof(p));
+	p.repo = repo;
 
 	/* Submodule data is kept in a hashtable keyed by both name and path.
 	 * These are usually the same, but that is not guaranteed.
@@ -1370,23 +1384,23 @@ static int load_submodule_config(git_repository *repo)
 
 	/* add submodule information from .gitmodules */
 
-	if ((mods = open_gitmodules(repo, false, &gitmodules_oid)) != NULL)
-		error = git_config_file_foreach(mods, submodule_load_from_config, repo);
-
-	if (error != 0)
+	if ((mods = open_gitmodules(repo, false, &gitmodules_oid)) != NULL &&
+		(error = git_config_file_foreach(
+			mods, submodule_load_from_config, &p)) < 0)
 		goto cleanup;
 
 	/* shallow scan submodules in work tree */
 
 	if (!git_repository_is_bare(repo))
-		error = git_submodule_foreach(repo, submodule_load_from_wd_lite, NULL);
+		error = git_submodule_foreach(repo, submodule_load_from_wd_lite, &p);
 
 cleanup:
-	git_buf_free(&path);
-
 	if (mods != NULL)
 		git_config_file_free(mods);
 
+	if (error == GIT_EUSER)
+		error = giterr_restore(&p.error);
+
 	if (error)
 		git_submodule_config_free(repo);
 
diff --git a/tests/config/rename.c b/tests/config/rename.c
new file mode 100644
index 000000000..29ade7b00
--- /dev/null
+++ b/tests/config/rename.c
@@ -0,0 +1,82 @@
+#include "clar_libgit2.h"
+#include "config.h"
+
+static git_repository *g_repo = NULL;
+static git_config *g_config = NULL;
+
+void test_config_rename__initialize(void)
+{
+    g_repo = cl_git_sandbox_init("testrepo.git");
+	cl_git_pass(git_repository_config(&g_config, g_repo));
+}
+
+void test_config_rename__cleanup(void)
+{
+	git_config_free(g_config);
+	g_config = NULL;
+
+	cl_git_sandbox_cleanup();
+	g_repo = NULL;
+}
+
+void test_config_rename__can_rename(void)
+{
+	const git_config_entry *ce;
+
+	cl_git_pass(git_config_get_entry(
+		&ce, g_config, "branch.track-local.remote"));
+	cl_assert_equal_s(".", ce->value);
+
+	cl_git_fail(git_config_get_entry(
+		&ce, g_config, "branch.local-track.remote"));
+
+	cl_git_pass(git_config_rename_section(
+		g_repo, "branch.track-local", "branch.local-track"));
+
+	cl_git_pass(git_config_get_entry(
+		&ce, g_config, "branch.local-track.remote"));
+	cl_assert_equal_s(".", ce->value);
+
+	cl_git_fail(git_config_get_entry(
+		&ce, g_config, "branch.track-local.remote"));
+}
+
+void test_config_rename__prevent_overwrite(void)
+{
+	const git_config_entry *ce;
+	const git_error *err;
+
+	cl_git_pass(git_config_set_string(
+		g_config, "branch.local-track.remote", "yellow"));
+
+	cl_git_pass(git_config_get_entry(
+		&ce, g_config, "branch.local-track.remote"));
+	cl_assert_equal_s("yellow", ce->value);
+
+	cl_git_pass(git_config_rename_section(
+		g_repo, "branch.track-local", "branch.local-track"));
+
+	cl_git_pass(git_config_get_entry(
+		&ce, g_config, "branch.local-track.remote"));
+	cl_assert_equal_s(".", ce->value);
+
+//	cl_assert((err = giterr_last()) != NULL);
+//	cl_assert(err->message != NULL);
+}
+
+static void assert_invalid_config_section_name(
+	git_repository *repo, const char *name)
+{
+	cl_git_fail_with(
+		git_config_rename_section(repo, "branch.remoteless", name),
+		GIT_EINVALIDSPEC);
+}
+
+void test_config_rename__require_a_valid_new_name(void)
+{
+	assert_invalid_config_section_name(g_repo, "");
+	assert_invalid_config_section_name(g_repo, "bra\nch");
+	assert_invalid_config_section_name(g_repo, "branc#");
+	assert_invalid_config_section_name(g_repo, "bra\nch.duh");
+	assert_invalid_config_section_name(g_repo, "branc#.duh");
+}
diff --git a/tests/config/validkeyname.c b/tests/config/validkeyname.c
index 33699737b..0ef4a9ae3 100644
--- a/tests/config/validkeyname.c
+++ b/tests/config/validkeyname.c
@@ -46,23 +46,3 @@ void test_config_validkeyname__accessing_requires_a_valid_name(void)
 	assert_invalid_config_key_name("dif.dir\nstat.lines");
 	assert_invalid_config_key_name("dif.dirstat.li\nes");
 }
-
-static void assert_invalid_config_section_name(git_repository *repo, const char *name)
-{
-	cl_git_fail_with(git_config_rename_section(repo, "branch.remoteless", name), GIT_EINVALIDSPEC);
-}
-
-void test_config_validkeyname__renaming_a_section_requires_a_valid_name(void)
-{
-	git_repository *repo;
-
-	cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
-
-	assert_invalid_config_section_name(repo, "");
-	assert_invalid_config_section_name(repo, "bra\nch");
-	assert_invalid_config_section_name(repo, "branc#");
-	assert_invalid_config_section_name(repo, "bra\nch.duh");
-	assert_invalid_config_section_name(repo, "branc#.duh");
-
-	git_repository_free(repo);
-}
diff --git a/tests/config/write.c b/tests/config/write.c
index 15f750dc0..922d75557 100644
--- a/tests/config/write.c
+++ b/tests/config/write.c
@@ -303,3 +303,4 @@ void test_config_write__updating_a_locked_config_file_returns_ELOCKED(void)
 
 	git_config_free(cfg);
 }
+
diff --git a/tests/refs/branches/move.c b/tests/refs/branches/move.c
index ecf14e006..9d233de1a 100644
--- a/tests/refs/branches/move.c
+++ b/tests/refs/branches/move.c
@@ -66,12 +66,54 @@ void test_refs_branches_move__can_move_a_local_branch_to_a_partially_colliding_n
 void test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_collide_with_an_existing_one(void)
 {
 	git_reference *original_ref, *new_ref;
+	git_config *config;
+	const git_config_entry *ce;
+	char *original_remote, *original_merge;
+
+	cl_git_pass(git_repository_config(&config, repo));
+
+	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.remote"));
+	original_remote = strdup(ce->value);
+	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.merge"));
+	original_merge  = strdup(ce->value);
+
 
 	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
 
-	cl_assert_equal_i(GIT_EEXISTS, git_branch_move(&new_ref, original_ref, "master", 0));
+	cl_assert_equal_i(GIT_EEXISTS,
+		git_branch_move(&new_ref, original_ref, "master", 0));
+
+	cl_assert(giterr_last()->message != NULL);
+	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.remote"));
+	cl_assert_equal_s(original_remote, ce->value);
+	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.merge"));
+	cl_assert_equal_s(original_merge,  ce->value);
+
+
+	cl_assert_equal_i(GIT_EEXISTS,
+		git_branch_move(&new_ref, original_ref, "cannot-fetch", 0));
+
+	cl_assert(giterr_last()->message != NULL);
+	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.remote"));
+	cl_assert_equal_s(original_remote, ce->value);
+	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.merge"));
+	cl_assert_equal_s(original_merge,  ce->value);
+
+	git_reference_free(original_ref);
+	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/track-local"));
+
+	cl_assert_equal_i(GIT_EEXISTS,
+		git_branch_move(&new_ref, original_ref, "master", 0));
+
+	cl_assert(giterr_last()->message != NULL);
+	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.remote"));
+	cl_assert_equal_s(original_remote, ce->value);
+	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.merge"));
+	cl_assert_equal_s(original_merge,  ce->value);
 
+	free(original_remote); free(original_merge);
 	git_reference_free(original_ref);
+	git_config_free(config);
 }
 
 void test_refs_branches_move__moving_a_branch_with_an_invalid_name_returns_EINVALIDSPEC(void)
-- 
cgit v1.2.3


From dab89f9b6821b67dd07c8bd4dbb53e25a3e687c7 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 4 Dec 2013 21:22:57 -0800
Subject: Further EUSER and error propagation fixes

This continues auditing all the places where GIT_EUSER is being
returned and making sure to clear any existing error using the
new giterr_user_cancel helper.  As a result, places that relied
on intercepting GIT_EUSER but having the old error preserved also
needed to be cleaned up to correctly stash and then retrieve the
actual error.

Additionally, as I encountered places where error codes were not
being propagated correctly, I tried to fix them up.  A number of
those fixes are included in the this commit as well.
---
 src/attr.c             |   7 ++-
 src/clone.c            | 120 +++++++++++++++++++++++--------------------------
 src/fetchhead.c        |   4 +-
 src/ignore.c           |  21 +++++++--
 src/index.c            |  12 +++--
 src/indexer.c          |   6 +--
 src/merge.c            |   5 ++-
 src/notes.c            |   2 +-
 src/pack-objects.c     |  47 ++++++++++---------
 src/pack.c             |   6 +--
 src/push.c             |   2 +-
 src/refs.c             |  27 +++++------
 src/remote.c           |  47 ++++++++++---------
 src/revwalk.c          |  21 +++++----
 src/stash.c            |   4 +-
 src/status.c           |   3 +-
 src/tag.c              |  42 +++++++++++++----
 src/transports/git.c   |  27 ++++++-----
 src/transports/smart.c |   3 +-
 src/tree.c             |  13 ++----
 tests/core/path.c      |  46 +++++++++++++++++++
 21 files changed, 273 insertions(+), 192 deletions(-)

diff --git a/src/attr.c b/src/attr.c
index 2fccf21f8..1a0f1f97f 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -480,6 +480,7 @@ typedef struct {
 	const char *workdir;
 	git_index *index;
 	git_vector *files;
+	git_error_state error;
 } attr_walk_up_info;
 
 int git_attr_cache__decide_sources(
@@ -523,7 +524,7 @@ static int push_one_attr(void *ref, git_buf *path)
 			info->repo, path->ptr, GIT_ATTR_FILE, src[i],
 			git_attr_file__parse_buffer, NULL, info->files);
 
-	return error;
+	return giterr_capture(&info->error, error);
 }
 
 static int collect_attr_files(
@@ -535,7 +536,7 @@ static int collect_attr_files(
 	int error;
 	git_buf dir = GIT_BUF_INIT;
 	const char *workdir = git_repository_workdir(repo);
-	attr_walk_up_info info;
+	attr_walk_up_info info = { NULL };
 
 	if (git_attr_cache__init(repo) < 0 ||
 		git_vector_init(files, 4, NULL) < 0)
@@ -569,6 +570,8 @@ static int collect_attr_files(
 	info.files = files;
 
 	error = git_path_walk_up(&dir, workdir, push_one_attr, &info);
+	if (error == GIT_EUSER)
+		error = giterr_restore(&info.error);
 	if (error < 0)
 		goto cleanup;
 
diff --git a/src/clone.c b/src/clone.c
index 23aacd478..415efabba 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -107,6 +107,7 @@ struct head_info {
 	git_buf branchname;
 	const git_refspec *refspec;
 	bool found;
+	git_error_state error;
 };
 
 static int reference_matches_remote_head(
@@ -115,43 +116,38 @@ static int reference_matches_remote_head(
 {
 	struct head_info *head_info = (struct head_info *)payload;
 	git_oid oid;
+	int error;
 
 	/* TODO: Should we guard against references
 	 * which name doesn't start with refs/heads/ ?
 	 */
 
-	/* Stop looking if we've already found a match */
-	if (head_info->found)
+	error = git_reference_name_to_id(&oid, head_info->repo, reference_name);
+	if (error == GIT_ENOTFOUND) {
+		/* If the reference doesn't exists, it obviously cannot match the
+		 * expected oid. */
+		giterr_clear();
 		return 0;
-
-	if (git_reference_name_to_id(
-		&oid,
-		head_info->repo,
-		reference_name) < 0) {
-			/* If the reference doesn't exists, it obviously cannot match the expected oid. */
-			giterr_clear();
-			return 0;
 	}
 
-	if (git_oid__cmp(&head_info->remote_head_oid, &oid) == 0) {
+	if (!error && !git_oid__cmp(&head_info->remote_head_oid, &oid)) {
 		/* Determine the local reference name from the remote tracking one */
-		if (git_refspec_transform_l(
-			&head_info->branchname,
-			head_info->refspec,
-			reference_name) < 0)
-				return -1;
-
-		if (git_buf_len(&head_info->branchname) > 0) {
-			if (git_buf_sets(
-				&head_info->branchname,
-				git_buf_cstr(&head_info->branchname) + strlen(GIT_REFS_HEADS_DIR)) < 0)
-					return -1;
+		error = git_refspec_transform_l(
+			&head_info->branchname, head_info->refspec, reference_name);
 
-			head_info->found = 1;
+		if (!error &&
+			git_buf_len(&head_info->branchname) > 0 &&
+			!(error = git_buf_sets(
+				&head_info->branchname,
+				git_buf_cstr(&head_info->branchname) +
+				strlen(GIT_REFS_HEADS_DIR))))
+		{
+			head_info->found = true;
+			error = GIT_ITEROVER;
 		}
 	}
 
-	return 0;
+	return giterr_capture(&head_info->error, error);
 }
 
 static int update_head_to_new_branch(
@@ -160,16 +156,11 @@ static int update_head_to_new_branch(
 	const char *name)
 {
 	git_reference *tracking_branch = NULL;
-	int error;
-
-	if ((error = create_tracking_branch(
-		&tracking_branch,
-		repo,
-		target,
-		name)) < 0)
-			return error;
+	int error = create_tracking_branch(&tracking_branch, repo, target, name);
 
-	error = git_repository_set_head(repo, git_reference_name(tracking_branch));
+	if (!error)
+		error = git_repository_set_head(
+			repo, git_reference_name(tracking_branch));
 
 	git_reference_free(tracking_branch);
 
@@ -178,34 +169,30 @@ static int update_head_to_new_branch(
 
 static int update_head_to_remote(git_repository *repo, git_remote *remote)
 {
-	int retcode = -1;
+	int error = 0;
 	size_t refs_len;
 	git_refspec dummy_spec;
 	const git_remote_head *remote_head, **refs;
 	struct head_info head_info;
 	git_buf remote_master_name = GIT_BUF_INIT;
 
-	if (git_remote_ls(&refs, &refs_len, remote) < 0)
-		return -1;
+	if ((error = git_remote_ls(&refs, &refs_len, remote)) < 0)
+		return error;
 
 	/* Did we just clone an empty repository? */
-	if (refs_len == 0) {
+	if (refs_len == 0)
 		return setup_tracking_config(
-			repo,
-			"master",
-			GIT_REMOTE_ORIGIN,
-			GIT_REFS_HEADS_MASTER_FILE);
-	}
+			repo, "master", GIT_REMOTE_ORIGIN, GIT_REFS_HEADS_MASTER_FILE);
 
 	/* Get the remote's HEAD. This is always the first ref in the list. */
 	remote_head = refs[0];
 	assert(remote_head);
 
+	memset(&head_info, 0, sizeof(head_info));
 	git_oid_cpy(&head_info.remote_head_oid, &remote_head->oid);
-	git_buf_init(&head_info.branchname, 16);
 	head_info.repo = repo;
-	head_info.refspec = git_remote__matching_refspec(remote, GIT_REFS_HEADS_MASTER_FILE);
-	head_info.found = 0;
+	head_info.refspec =
+		git_remote__matching_refspec(remote, GIT_REFS_HEADS_MASTER_FILE);
 
 	if (head_info.refspec == NULL) {
 		memset(&dummy_spec, 0, sizeof(git_refspec));
@@ -213,50 +200,53 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 	}
 
 	/* Determine the remote tracking reference name from the local master */
-	if (git_refspec_transform_r(
+	if ((error = git_refspec_transform_r(
 		&remote_master_name,
 		head_info.refspec,
-		GIT_REFS_HEADS_MASTER_FILE) < 0)
-			return -1;
+		GIT_REFS_HEADS_MASTER_FILE)) < 0)
+		return error;
 
 	/* Check to see if the remote HEAD points to the remote master */
-	if (reference_matches_remote_head(git_buf_cstr(&remote_master_name), &head_info) < 0)
-		goto cleanup;
+	error = reference_matches_remote_head(
+		git_buf_cstr(&remote_master_name), &head_info);
+
+	if (error < 0) {
+		error = giterr_restore(&head_info.error);
+		if (error < 0 && error != GIT_ITEROVER)
+			goto cleanup;
+	}
 
 	if (head_info.found) {
-		retcode = update_head_to_new_branch(
+		error = update_head_to_new_branch(
 			repo,
 			&head_info.remote_head_oid,
 			git_buf_cstr(&head_info.branchname));
-
 		goto cleanup;
 	}
 
 	/* Not master. Check all the other refs. */
-	if (git_reference_foreach_name(
-		repo,
-		reference_matches_remote_head,
-		&head_info) < 0)
-			goto cleanup;
+	error = git_reference_foreach_name(
+		repo, reference_matches_remote_head, &head_info);
+
+	if (error == GIT_EUSER)
+		error = giterr_restore(&head_info.error);
+	if (error < 0 && error != GIT_ITEROVER)
+		goto cleanup;
 
 	if (head_info.found) {
-		retcode = update_head_to_new_branch(
+		error = update_head_to_new_branch(
 			repo,
 			&head_info.remote_head_oid,
 			git_buf_cstr(&head_info.branchname));
-
-		goto cleanup;
 	} else {
-		retcode = git_repository_set_head_detached(
-			repo,
-			&head_info.remote_head_oid);
-		goto cleanup;
+		error = git_repository_set_head_detached(
+			repo, &head_info.remote_head_oid);
 	}
 
 cleanup:
 	git_buf_free(&remote_master_name);
 	git_buf_free(&head_info.branchname);
-	return retcode;
+	return error;
 }
 
 static int update_head_to_branch(
diff --git a/src/fetchhead.c b/src/fetchhead.c
index 67089d13d..ee1492211 100644
--- a/src/fetchhead.c
+++ b/src/fetchhead.c
@@ -269,8 +269,8 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 		else
 			ref_name = NULL;
 
-		if ((cb(ref_name, remote_url, &oid, is_merge, payload)) != 0) {
-			error = GIT_EUSER;
+		if (cb(ref_name, remote_url, &oid, is_merge, payload) != 0) {
+			error = giterr_user_cancel();
 			goto done;
 		}
 	}
diff --git a/src/ignore.c b/src/ignore.c
index 27d7c7ec4..aa53d409d 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -74,10 +74,20 @@ static int parse_ignore_file(
 #define push_ignore_file(R,IGN,S,B,F) \
 	git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,parse_ignore_file,(IGN),(S))
 
+struct ignores_walk_up_data {
+	git_ignores *ign;
+	git_error_state error;
+};
+
 static int push_one_ignore(void *ref, git_buf *path)
 {
-	git_ignores *ign = (git_ignores *)ref;
-	return push_ignore_file(ign->repo, ign, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
+	struct ignores_walk_up_data *data = ref;
+
+	return giterr_capture(
+		&data->error,
+		push_ignore_file(
+			data->ign->repo, data->ign, &data->ign->ign_path,
+			path->ptr, GIT_IGNORE_FILE) );
 }
 
 static int get_internal_ignores(git_attr_file **ign, git_repository *repo)
@@ -132,8 +142,13 @@ int git_ignore__for_path(
 
 	/* load .gitignore up the path */
 	if (workdir != NULL) {
+		struct ignores_walk_up_data data = { ignores };
+
 		error = git_path_walk_up(
-			&ignores->dir, workdir, push_one_ignore, ignores);
+			&ignores->dir, workdir, push_one_ignore, &data);
+
+		if (error == GIT_EUSER)
+			error = giterr_restore(&data.error);
 		if (error < 0)
 			goto cleanup;
 	}
diff --git a/src/index.c b/src/index.c
index 09e7b2346..d0d2cf187 100644
--- a/src/index.c
+++ b/src/index.c
@@ -2036,6 +2036,12 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
 
 	error = git_tree_walk(tree, GIT_TREEWALK_POST, read_tree_cb, &data);
 
+	if (error == GIT_EUSER) {
+		giterr_set_oom();
+		git_vector_free(&entries);
+		return -1;
+	}
+
 	git_vector_sort(&entries);
 
 	git_index_clear(index);
@@ -2116,8 +2122,7 @@ int git_index_add_all(
 			if (error > 0) /* return > 0 means skip this one */
 				continue;
 			if (error < 0) { /* return < 0 means abort */
-				giterr_clear();
-				error = GIT_EUSER;
+				error = giterr_user_cancel();
 				break;
 			}
 		}
@@ -2205,8 +2210,7 @@ static int index_apply_to_all(
 				continue;
 			}
 			if (error < 0) { /* return < 0 means abort */
-				giterr_clear();
-				error = GIT_EUSER;
+				error = giterr_user_cancel();
 				break;
 			}
 		}
diff --git a/src/indexer.c b/src/indexer.c
index 852a04120..7312809bf 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -387,10 +387,8 @@ on_error:
 static int do_progress_callback(git_indexer *idx, git_transfer_progress *stats)
 {
 	if (idx->progress_cb &&
-		idx->progress_cb(stats, idx->progress_payload)) {
-			giterr_clear();
-			return GIT_EUSER;
-	}
+		idx->progress_cb(stats, idx->progress_payload))
+		return giterr_user_cancel();
 
 	return 0;
 }
diff --git a/src/merge.c b/src/merge.c
index e552b037b..0d89da5a0 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -254,7 +254,8 @@ int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_l
 	return 0;
 }
 
-int git_repository_mergehead_foreach(git_repository *repo,
+int git_repository_mergehead_foreach(
+	git_repository *repo,
 	git_repository_mergehead_foreach_cb cb,
 	void *payload)
 {
@@ -287,7 +288,7 @@ int git_repository_mergehead_foreach(git_repository *repo,
 			goto cleanup;
 
 		if (cb(&oid, payload) != 0) {
-			error = GIT_EUSER;
+			error = giterr_user_cancel();
 			goto cleanup;
 		}
 
diff --git a/src/notes.c b/src/notes.c
index d8ed32f82..7e8aecbae 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -584,7 +584,7 @@ int git_note_foreach(
 
 	while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
 		if (note_cb(&note_id, &annotated_id, payload)) {
-			error = GIT_EUSER;
+			error = giterr_user_cancel();
 			break;
 		}
 	}
diff --git a/src/pack-objects.c b/src/pack-objects.c
index 2d62507f2..ac0615064 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -32,6 +32,7 @@ struct unpacked {
 struct tree_walk_context {
 	git_packbuilder *pb;
 	git_buf buf;
+	git_error_state error;
 };
 
 struct pack_write_context {
@@ -220,12 +221,15 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 
 	if (pb->progress_cb) {
 		double current_time = git__timer();
-		if ((current_time - pb->last_progress_report_time) >= MIN_PROGRESS_UPDATE_INTERVAL) {
+		double elapsed = current_time - pb->last_progress_report_time;
+
+		if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
-			if (pb->progress_cb(GIT_PACKBUILDER_ADDING_OBJECTS, pb->nr_objects, 0, pb->progress_cb_payload)) {
-				giterr_clear();
-				return GIT_EUSER;
-			}
+
+			if (pb->progress_cb(
+					GIT_PACKBUILDER_ADDING_OBJECTS,
+					pb->nr_objects, 0, pb->progress_cb_payload))
+				return giterr_user_cancel();
 		}
 	}
 
@@ -1284,21 +1288,22 @@ const git_oid *git_packbuilder_hash(git_packbuilder *pb)
 	return &pb->pack_oid;
 }
 
-static int cb_tree_walk(const char *root, const git_tree_entry *entry, void *payload)
+static int cb_tree_walk(
+	const char *root, const git_tree_entry *entry, void *payload)
 {
+	int error;
 	struct tree_walk_context *ctx = payload;
 
 	/* A commit inside a tree represents a submodule commit and should be skipped. */
 	if (git_tree_entry_type(entry) == GIT_OBJ_COMMIT)
 		return 0;
 
-	if (git_buf_sets(&ctx->buf, root) < 0 ||
-		git_buf_puts(&ctx->buf, git_tree_entry_name(entry)) < 0)
-		return -1;
+	if (!(error = git_buf_sets(&ctx->buf, root)) &&
+		!(error = git_buf_puts(&ctx->buf, git_tree_entry_name(entry))))
+		error = git_packbuilder_insert(
+			ctx->pb, git_tree_entry_id(entry), git_buf_cstr(&ctx->buf));
 
-	return git_packbuilder_insert(ctx->pb,
-		git_tree_entry_id(entry),
-		git_buf_cstr(&ctx->buf));
+	return giterr_capture(&ctx->error, error);
 }
 
 int git_packbuilder_insert_commit(git_packbuilder *pb, const git_oid *oid)
@@ -1318,22 +1323,20 @@ int git_packbuilder_insert_commit(git_packbuilder *pb, const git_oid *oid)
 
 int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid)
 {
-	git_tree *tree;
+	int error;
+	git_tree *tree = NULL;
 	struct tree_walk_context context = { pb, GIT_BUF_INIT };
 
-	if (git_tree_lookup(&tree, pb->repo, oid) < 0 ||
-	    git_packbuilder_insert(pb, oid, NULL) < 0)
-		return -1;
+	if (!(error = git_tree_lookup(&tree, pb->repo, oid)) &&
+	    !(error = git_packbuilder_insert(pb, oid, NULL)))
+		error = git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context);
 
-	if (git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context) < 0) {
-		git_tree_free(tree);
-		git_buf_free(&context.buf);
-		return -1;
-	}
+	if (error == GIT_EUSER)
+		error = giterr_restore(&context.error);
 
 	git_tree_free(tree);
 	git_buf_free(&context.buf);
-	return 0;
+	return error;
 }
 
 uint32_t git_packbuilder_object_count(git_packbuilder *pb)
diff --git a/src/pack.c b/src/pack.c
index 644b2d465..f69fe85e8 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -1042,10 +1042,9 @@ int git_pack_foreach_entry(
 {
 	const unsigned char *index = p->index_map.data, *current;
 	uint32_t i;
+	int error = 0;
 
 	if (index == NULL) {
-		int error;
-
 		if ((error = pack_index_open(p)) < 0)
 			return error;
 
@@ -1062,7 +1061,6 @@ int git_pack_foreach_entry(
 
 	if (p->oids == NULL) {
 		git_vector offsets, oids;
-		int error;
 
 		if ((error = git_vector_init(&oids, p->num_objects, NULL)))
 			return error;
@@ -1090,7 +1088,7 @@ int git_pack_foreach_entry(
 
 	for (i = 0; i < p->num_objects; i++)
 		if (cb(p->oids[i], data))
-			return GIT_EUSER;
+			return giterr_user_cancel();
 
 	return 0;
 }
diff --git a/src/push.c b/src/push.c
index 3c9d5bb35..e592249d9 100644
--- a/src/push.c
+++ b/src/push.c
@@ -663,7 +663,7 @@ int git_push_status_foreach(git_push *push,
 
 	git_vector_foreach(&push->status, i, status) {
 		if (cb(status->ref, status->msg, data) < 0)
-			return GIT_EUSER;
+			return giterr_user_cancel();
 	}
 
 	return 0;
diff --git a/src/refs.c b/src/refs.c
index bae62158b..60ed9ffb1 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -513,20 +513,19 @@ int git_reference_foreach(
 	git_reference *ref;
 	int error;
 
-	if (git_reference_iterator_new(&iter, repo) < 0)
-		return -1;
+	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
+		return error;
 
 	while ((error = git_reference_next(&ref, iter)) == 0) {
 		if (callback(ref, payload)) {
-			error = GIT_EUSER;
-			goto out;
+			error = giterr_user_cancel();
+			break;
 		}
 	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
 
-out:
 	git_reference_iterator_free(iter);
 	return error;
 }
@@ -540,20 +539,19 @@ int git_reference_foreach_name(
 	const char *refname;
 	int error;
 
-	if (git_reference_iterator_new(&iter, repo) < 0)
-		return -1;
+	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
+		return error;
 
 	while ((error = git_reference_next_name(&refname, iter)) == 0) {
 		if (callback(refname, payload)) {
-			error = GIT_EUSER;
-			goto out;
+			error = giterr_user_cancel();
+			break;
 		}
 	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
 
-out:
 	git_reference_iterator_free(iter);
 	return error;
 }
@@ -568,20 +566,19 @@ int git_reference_foreach_glob(
 	const char *refname;
 	int error;
 
-	if (git_reference_iterator_glob_new(&iter, repo, glob) < 0)
-		return -1;
+	if ((error = git_reference_iterator_glob_new(&iter, repo, glob)) < 0)
+		return error;
 
 	while ((error = git_reference_next_name(&refname, iter)) == 0) {
 		if (callback(refname, payload)) {
-			error = GIT_EUSER;
-			goto out;
+			error = giterr_user_cancel();
+			break;
 		}
 	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
 
-out:
 	git_reference_iterator_free(iter);
 	return error;
 }
diff --git a/src/remote.c b/src/remote.c
index e4bebe1c6..e9d079db5 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1370,46 +1370,43 @@ static int rename_fetch_refspecs(
 	if (git_buf_printf(&base, "+refs/heads/*:refs/remotes/%s/*", remote->name) < 0)
 		goto cleanup;
 
+	if ((error = git_repository_config__weakptr(&config, remote->repo)) < 0)
+		goto cleanup;
+
 	git_vector_foreach(&remote->refspecs, i, spec) {
 		if (spec->push)
 			continue;
 
-		/* Every refspec is a problem refspec for an in-memory remote */
-		if (!remote->name) {
-			if (callback(spec->string, payload) < 0) {
-				error = GIT_EUSER;
-				goto cleanup;
-			}
-
-			continue;
-		}
+		/* Every refspec is a problem refspec for an in-memory remote, OR */
+		/* Does the dst part of the refspec follow the expected format? */
+		if (!remote->name ||
+			strcmp(git_buf_cstr(&base), spec->string)) {
 
-		/* Does the dst part of the refspec follow the extected standard format? */
-		if (strcmp(git_buf_cstr(&base), spec->string)) {
 			if (callback(spec->string, payload) < 0) {
-				error = GIT_EUSER;
+				error = giterr_user_cancel();
 				goto cleanup;
 			}
-
 			continue;
 		}
 
 		/* If we do want to move it to the new section */
-		if (git_buf_printf(&val, "+refs/heads/*:refs/remotes/%s/*", new_name) < 0)
-			goto cleanup;
 
-		if (git_buf_printf(&var, "remote.%s.fetch", new_name) < 0)
-			goto cleanup;
+		git_buf_clear(&val);
+		git_buf_clear(&var);
 
-		if (git_repository_config__weakptr(&config, remote->repo) < 0)
+		if (git_buf_printf(
+				&val, "+refs/heads/*:refs/remotes/%s/*", new_name) < 0 ||
+			git_buf_printf(&var, "remote.%s.fetch", new_name) < 0)
+		{
+			error = -1;
 			goto cleanup;
+		}
 
-		if (git_config_set_string(config, git_buf_cstr(&var), git_buf_cstr(&val)) < 0)
+		if ((error = git_config_set_string(
+				config, git_buf_cstr(&var), git_buf_cstr(&val))) < 0)
 			goto cleanup;
 	}
 
-	error = 0;
-
 cleanup:
 	git_buf_free(&base);
 	git_buf_free(&var);
@@ -1445,11 +1442,11 @@ int git_remote_rename(
 				new_name,
 				callback,
 				payload)) < 0)
-				return error;
+					return error;
 
 			remote->name = git__strdup(new_name);
+			GITERR_CHECK_ALLOC(remote->name);
 
-			if (!remote->name) return 0;
 			return git_remote_save(remote);
 		}
 
@@ -1476,11 +1473,13 @@ int git_remote_rename(
 			new_name,
 			callback,
 			payload)) < 0)
-			return error;
+				return error;
 	}
 
 	git__free(remote->name);
+
 	remote->name = git__strdup(new_name);
+	GITERR_CHECK_ALLOC(remote->name);
 
 	return 0;
 }
diff --git a/src/revwalk.c b/src/revwalk.c
index 3dd14b419..e8c7f23ec 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -112,12 +112,13 @@ static int process_commit_parents(git_revwalk *walk, git_commit_list_node *commi
 
 static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting)
 {
+	int error;
 	git_object *obj;
 	git_otype type;
 	git_commit_list_node *commit;
 
-	if (git_object_lookup(&obj, walk->repo, oid, GIT_OBJ_ANY) < 0)
-		return -1;
+	if ((error = git_object_lookup(&obj, walk->repo, oid, GIT_OBJ_ANY)) < 0)
+		return error;
 
 	type = git_object_type(obj);
 	git_object_free(obj);
@@ -168,13 +169,15 @@ static int push_ref(git_revwalk *walk, const char *refname, int hide)
 struct push_cb_data {
 	git_revwalk *walk;
 	int hide;
+	git_error_state error;
 };
 
 static int push_glob_cb(const char *refname, void *data_)
 {
 	struct push_cb_data *data = (struct push_cb_data *)data_;
 
-	return push_ref(data->walk, refname, data->hide);
+	return giterr_capture(
+		&data->error, push_ref(data->walk, refname, data->hide) );
 }
 
 static int push_glob(git_revwalk *walk, const char *glob, int hide)
@@ -191,6 +194,8 @@ static int push_glob(git_revwalk *walk, const char *glob, int hide)
 		git_buf_joinpath(&buf, GIT_REFS_DIR, glob);
 	else
 		git_buf_puts(&buf, glob);
+	if (git_buf_oom(&buf))
+		return -1;
 
 	/* If no '?', '*' or '[' exist, we append '/ *' to the glob */
 	wildcard = strcspn(glob, "?*[");
@@ -199,12 +204,12 @@ static int push_glob(git_revwalk *walk, const char *glob, int hide)
 
 	data.walk = walk;
 	data.hide = hide;
+	memset(&data.error, 0, sizeof(data.error));
 
-	if (git_buf_oom(&buf))
-		error = -1;
-	else
-		error = git_reference_foreach_glob(
-			walk->repo, git_buf_cstr(&buf), push_glob_cb, &data);
+	error = git_reference_foreach_glob(
+		walk->repo, git_buf_cstr(&buf), push_glob_cb, &data);
+	if (error == GIT_EUSER)
+		error = giterr_restore(&data.error);
 
 	git_buf_free(&buf);
 	return error;
diff --git a/src/stash.c b/src/stash.c
index 083c2a4cd..06a7b9a33 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -586,8 +586,8 @@ int git_stash_foreach(
 			git_reflog_entry_message(entry),
 			git_reflog_entry_id_new(entry),
 			payload)) {
-				error = GIT_EUSER;
-				break;
+			error = giterr_user_cancel();
+			break;
 		}
 	}
 
diff --git a/src/status.c b/src/status.c
index fb99fb4e4..777b7964a 100644
--- a/src/status.c
+++ b/src/status.c
@@ -414,8 +414,7 @@ int git_status_foreach_ext(
 			status_entry->index_to_workdir->old_file.path;
 
 		if (cb(path, status_entry->status, payload) != 0) {
-			error = GIT_EUSER;
-			giterr_clear();
+			error = giterr_user_cancel();
 			break;
 		}
 	}
diff --git a/src/tag.c b/src/tag.c
index 31a3c8b80..5d4e45e5d 100644
--- a/src/tag.c
+++ b/src/tag.c
@@ -414,24 +414,29 @@ typedef struct {
 	git_repository *repo;
 	git_tag_foreach_cb cb;
 	void *cb_data;
+	git_error_state error;
 } tag_cb_data;
 
 static int tags_cb(const char *ref, void *data)
 {
+	int error;
 	git_oid oid;
 	tag_cb_data *d = (tag_cb_data *)data;
 
 	if (git__prefixcmp(ref, GIT_REFS_TAGS_DIR) != 0)
 		return 0; /* no tag */
 
-	if (git_reference_name_to_id(&oid, d->repo, ref) < 0)
-		return -1;
+	if (!(error = git_reference_name_to_id(&oid, d->repo, ref))) {
+		if (d->cb(ref, &oid, d->cb_data))
+			error = giterr_user_cancel();
+	}
 
-	return d->cb(ref, &oid, d->cb_data);
+	return giterr_capture(&d->error, error);
 }
 
 int git_tag_foreach(git_repository *repo, git_tag_foreach_cb cb, void *cb_data)
 {
+	int error;
 	tag_cb_data data;
 
 	assert(repo && cb);
@@ -439,8 +444,14 @@ int git_tag_foreach(git_repository *repo, git_tag_foreach_cb cb, void *cb_data)
 	data.cb = cb;
 	data.cb_data = cb_data;
 	data.repo = repo;
+	memset(&data.error, 0, sizeof(data.error));
 
-	return git_reference_foreach_name(repo, &tags_cb, &data);
+	error = git_reference_foreach_name(repo, &tags_cb, &data);
+
+	if (error == GIT_EUSER)
+		error = giterr_restore(&data.error);
+
+	return error;
 }
 
 typedef struct {
@@ -455,8 +466,14 @@ static int tag_list_cb(const char *tag_name, git_oid *oid, void *data)
 	tag_filter_data *filter = (tag_filter_data *)data;
 	GIT_UNUSED(oid);
 
-	if (!*filter->pattern || p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == 0)
-		return git_vector_insert(filter->taglist, git__strdup(tag_name + GIT_REFS_TAGS_DIR_LEN));
+	if (!*filter->pattern ||
+		p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == 0)
+	{
+		char *matched = git__strdup(tag_name + GIT_REFS_TAGS_DIR_LEN);
+		if (!matched)
+			return -1;
+		return git_vector_insert(filter->taglist, matched);
+	}
 
 	return 0;
 }
@@ -469,16 +486,23 @@ int git_tag_list_match(git_strarray *tag_names, const char *pattern, git_reposit
 
 	assert(tag_names && repo && pattern);
 
-	if (git_vector_init(&taglist, 8, NULL) < 0)
-		return -1;
+	if ((error = git_vector_init(&taglist, 8, NULL)) < 0)
+		return error;
 
 	filter.taglist = &taglist;
 	filter.pattern = pattern;
 
 	error = git_tag_foreach(repo, &tag_list_cb, (void *)&filter);
+
+	/* the only case where callback will return an error is oom */
+	if (error == GIT_EUSER) {
+		giterr_set_oom();
+		error = -1;
+	}
+
 	if (error < 0) {
 		git_vector_free(&taglist);
-		return -1;
+		return error;
 	}
 
 	tag_names->strings = (char **)taglist.contents;
diff --git a/src/transports/git.c b/src/transports/git.c
index 5dcd4eff7..21507c1c7 100644
--- a/src/transports/git.c
+++ b/src/transports/git.c
@@ -93,18 +93,19 @@ static int git_stream_read(
 	size_t buf_size,
 	size_t *bytes_read)
 {
+	int error;
 	git_stream *s = (git_stream *)stream;
 	gitno_buffer buf;
 
 	*bytes_read = 0;
 
-	if (!s->sent_command && send_command(s) < 0)
-		return -1;
+	if (!s->sent_command && (error = send_command(s)) < 0)
+		return error;
 
 	gitno_buffer_setup(&s->socket, &buf, buffer, buf_size);
 
-	if (gitno_recv(&buf) < 0)
-		return -1;
+	if ((error = gitno_recv(&buf)) < 0)
+		return error;
 
 	*bytes_read = buf.offset;
 
@@ -116,10 +117,11 @@ static int git_stream_write(
 	const char *buffer,
 	size_t len)
 {
+	int error;
 	git_stream *s = (git_stream *)stream;
 
-	if (!s->sent_command && send_command(s) < 0)
-		return -1;
+	if (!s->sent_command && (error = send_command(s)) < 0)
+		return error;
 
 	return gitno_send(&s->socket, buffer, len, 0);
 }
@@ -140,7 +142,7 @@ static void git_stream_free(git_smart_subtransport_stream *stream)
 	}
 
 	git__free(s->url);
-	git__free(s);	
+	git__free(s);
 }
 
 static int git_stream_alloc(
@@ -182,18 +184,21 @@ static int _git_uploadpack_ls(
 	char *host=NULL, *port=NULL, *path=NULL, *user=NULL, *pass=NULL;
 	const char *stream_url = url;
 	git_stream *s;
-	int error = -1;
+	int error;
 
 	*stream = NULL;
+
 	if (!git__prefixcmp(url, prefix_git))
 		stream_url += strlen(prefix_git);
 
-	if (git_stream_alloc(t, stream_url, cmd_uploadpack, stream) < 0)
-		return -1;
+	if ((error = git_stream_alloc(t, stream_url, cmd_uploadpack, stream)) < 0)
+		return error;
 
 	s = (git_stream *)*stream;
 
-	if (!(error = gitno_extract_url_parts(&host, &port, &path, &user, &pass, url, GIT_DEFAULT_PORT))) {
+	if (!(error = gitno_extract_url_parts(
+			&host, &port, &path, &user, &pass, url, GIT_DEFAULT_PORT))) {
+
 		if (!(error = gitno_connect(&s->socket, host, port, 0)))
 			t->current_stream = s;
 
diff --git a/src/transports/smart.c b/src/transports/smart.c
index 5242beb65..e298f3510 100644
--- a/src/transports/smart.c
+++ b/src/transports/smart.c
@@ -27,8 +27,7 @@ static int git_smart__recv_cb(gitno_buffer *buf)
 		if (t->packetsize_cb(bytes_read, t->packetsize_payload)) {
 			git_atomic_set(&t->cancelled, 1);
 
-			giterr_clear();
-			return GIT_EUSER;
+			return giterr_user_cancel();
 		}
 
 	return (int)(buf->offset - old_len);
diff --git a/src/tree.c b/src/tree.c
index bb59ff82b..8ded007eb 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -884,14 +884,12 @@ static int tree_walk(
 	git_vector_foreach(&tree->entries, i, entry) {
 		if (preorder) {
 			error = callback(path->ptr, entry, payload);
+			if (error < 0)
+				return giterr_user_cancel();
 			if (error > 0) {
 				error = 0;
 				continue;
 			}
-			if (error < 0) {
-				giterr_clear();
-				return GIT_EUSER;
-			}
 		}
 
 		if (git_tree_entry__is_tree(entry)) {
@@ -918,11 +916,8 @@ static int tree_walk(
 			git_buf_truncate(path, path_len);
 		}
 
-		if (!preorder && callback(path->ptr, entry, payload) < 0) {
-			giterr_clear();
-			error = GIT_EUSER;
-			break;
-		}
+		if (!preorder && callback(path->ptr, entry, payload) < 0)
+			return giterr_user_cancel();
 	}
 
 	return error;
diff --git a/tests/core/path.c b/tests/core/path.c
index cf2d5e944..3858e30dd 100644
--- a/tests/core/path.c
+++ b/tests/core/path.c
@@ -350,15 +350,24 @@ void test_core_path__10_fromurl(void)
 
 typedef struct {
 	int expect_idx;
+	int cancel_after;
 	char **expect;
 } check_walkup_info;
 
 static int check_one_walkup_step(void *ref, git_buf *path)
 {
 	check_walkup_info *info = (check_walkup_info *)ref;
+
+	if (!info->cancel_after) {
+		cl_assert_equal_s(info->expect[info->expect_idx], "[CANCEL]");
+		return -1;
+	}
+	info->cancel_after--;
+
 	cl_assert(info->expect[info->expect_idx] != NULL);
 	cl_assert_equal_s(info->expect[info->expect_idx], path->ptr);
 	info->expect_idx++;
+
 	return 0;
 }
 
@@ -381,6 +390,7 @@ void test_core_path__11_walkup(void)
 	check_walkup_info info;
 
 	info.expect = expect;
+	info.cancel_after = -1;
 
 	for (i = 0, j = 0; expect[i] != NULL; i++, j++) {
 
@@ -400,6 +410,42 @@ void test_core_path__11_walkup(void)
 	git_buf_free(&p);
 }
 
+void test_core_path__11a_walkup_cancel(void)
+{
+	git_buf p = GIT_BUF_INIT;
+	int cancel[] = { 3, 2, 1, 0 };
+	char *expect[] = {
+		"/a/b/c/d/e/", "/a/b/c/d/", "/a/b/c/", "[CANCEL]", NULL,
+		"/a/b/c/d/e", "/a/b/c/d/", "[CANCEL]", NULL,
+		"/a/b/c/d/e", "[CANCEL]", NULL,
+		"[CANCEL]", NULL,
+		NULL
+	};
+	char *root[] = { NULL, NULL, "/", "", NULL };
+	int i, j;
+	check_walkup_info info;
+
+	info.expect = expect;
+
+	for (i = 0, j = 0; expect[i] != NULL; i++, j++) {
+
+		git_buf_sets(&p, expect[i]);
+
+		info.cancel_after = cancel[j];
+		info.expect_idx = i;
+
+		cl_assert_equal_i(
+			GIT_EUSER,
+			git_path_walk_up(&p, root[j], check_one_walkup_step, &info)
+		);
+
+		/* skip to next run of expectations */
+		while (expect[i] != NULL) i++;
+	}
+
+	git_buf_free(&p);
+}
+
 void test_core_path__12_offset_to_path_root(void)
 {
 	cl_assert(git_path_root("non/rooted/path") == -1);
-- 
cgit v1.2.3


From fcd324c625d8be3f368c924d787e945e5812d8dd Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 6 Dec 2013 15:04:31 -0800
Subject: Add git_vector_free_all

There are a lot of places that we call git__free on each item in
a vector and then call git_vector_free on the vector itself.  This
just wraps that up into one convenient helper function.
---
 src/blame.c      |  5 +----
 src/checkout.c   | 10 ++--------
 src/diff.c       |  9 +--------
 src/diff_tform.c |  8 ++------
 src/indexer.c    | 20 +++++---------------
 src/iterator.c   |  7 +------
 src/merge.c      |  6 +-----
 src/pathspec.c   | 10 +---------
 src/push.c       |  5 +----
 src/remote.c     | 14 ++------------
 src/status.c     |  8 +-------
 src/vector.c     | 14 ++++++++++++++
 src/vector.h     |  1 +
 13 files changed, 33 insertions(+), 84 deletions(-)

diff --git a/src/blame.c b/src/blame.c
index f732338e6..f10ed409a 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -132,7 +132,6 @@ void git_blame_free(git_blame *blame)
 {
 	size_t i;
 	git_blame_hunk *hunk;
-	char *path;
 
 	if (!blame) return;
 
@@ -140,9 +139,7 @@ void git_blame_free(git_blame *blame)
 		free_hunk(hunk);
 	git_vector_free(&blame->hunks);
 
-	git_vector_foreach(&blame->paths, i, path)
-		git__free(path);
-	git_vector_free(&blame->paths);
+	git_vector_free_all(&blame->paths);
 
 	git_array_clear(blame->line_index);
 
diff --git a/src/checkout.c b/src/checkout.c
index 4305d3e9a..e33ac2ed6 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -846,7 +846,7 @@ static int checkout_conflicts_coalesce_renames(
 
 	/* Juggle entries based on renames */
 	names = git_index_name_entrycount(data->index);
-	
+
 	for (i = 0; i < names; i++) {
 		name_entry = git_index_name_get_byindex(data->index, i);
 
@@ -1760,9 +1760,6 @@ static int checkout_create_conflicts(checkout_data *data)
 
 static void checkout_data_clear(checkout_data *data)
 {
-	checkout_conflictdata *conflict;
-	size_t i;
-
 	if (data->opts_free_baseline) {
 		git_tree_free(data->opts.baseline);
 		data->opts.baseline = NULL;
@@ -1771,10 +1768,7 @@ static void checkout_data_clear(checkout_data *data)
 	git_vector_free(&data->removes);
 	git_pool_clear(&data->pool);
 
-	git_vector_foreach(&data->conflicts, i, conflict)
-		git__free(conflict);
-
-	git_vector_free(&data->conflicts);
+	git_vector_free_all(&data->conflicts);
 
 	git__free(data->pfx);
 	data->pfx = NULL;
diff --git a/src/diff.c b/src/diff.c
index ad058af61..af47e86aa 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -483,14 +483,7 @@ static int diff_list_apply_options(
 
 static void diff_list_free(git_diff *diff)
 {
-	git_diff_delta *delta;
-	unsigned int i;
-
-	git_vector_foreach(&diff->deltas, i, delta) {
-		git__free(delta);
-		diff->deltas.contents[i] = NULL;
-	}
-	git_vector_free(&diff->deltas);
+	git_vector_free_all(&diff->deltas);
 
 	git_pathspec__vfree(&diff->pathspec);
 	git_pool_clear(&diff->pool);
diff --git a/src/diff_tform.c b/src/diff_tform.c
index 2f94b2e77..16184910a 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -209,9 +209,7 @@ int git_diff_merge(git_diff *onto, const git_diff *from)
 			git_pool_strdup_safe(&onto->pool, onto->opts.new_prefix);
 	}
 
-	git_vector_foreach(&onto_new, i, delta)
-		git__free(delta);
-	git_vector_free(&onto_new);
+	git_vector_free_all(&onto_new);
 	git_pool_clear(&onto_pool);
 
 	return error;
@@ -445,9 +443,7 @@ static int apply_splits_and_deletes(
 	return 0;
 
 on_error:
-	git_vector_foreach(&onto, i, delta)
-		git__free(delta);
-	git_vector_free(&onto);
+	git_vector_free_all(&onto);
 
 	return -1;
 }
diff --git a/src/indexer.c b/src/indexer.c
index 7312809bf..d3253cb57 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -1005,30 +1005,20 @@ on_error:
 
 void git_indexer_free(git_indexer *idx)
 {
-	khiter_t k;
-	unsigned int i;
-	struct entry *e;
-	struct delta_info *delta;
-
 	if (idx == NULL)
 		return;
 
-	git_vector_foreach(&idx->objects, i, e)
-		git__free(e);
-	git_vector_free(&idx->objects);
+	git_vector_free_all(&idx->objects);
 
 	if (idx->pack) {
-		for (k = kh_begin(idx->pack->idx_cache); k != kh_end(idx->pack->idx_cache); k++) {
-			if (kh_exist(idx->pack->idx_cache, k))
-				git__free(kh_value(idx->pack->idx_cache, k));
-		}
+		struct git_pack_entry *pentry;
+		kh_foreach_value(
+			idx->pack->idx_cache, pentry, { git__free(pentry); });
 
 		git_oidmap_free(idx->pack->idx_cache);
 	}
 
-	git_vector_foreach(&idx->deltas, i, delta)
-		git__free(delta);
-	git_vector_free(&idx->deltas);
+	git_vector_free_all(&idx->deltas);
 	git_packfile_free(idx->pack);
 	git_filebuf_cleanup(&idx->pack_file);
 	git__free(idx);
diff --git a/src/iterator.c b/src/iterator.c
index c1292227c..118bbb880 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -920,12 +920,7 @@ static fs_iterator_frame *fs_iterator__alloc_frame(fs_iterator *fi)
 
 static void fs_iterator__free_frame(fs_iterator_frame *ff)
 {
-	size_t i;
-	git_path_with_stat *path;
-
-	git_vector_foreach(&ff->entries, i, path)
-		git__free(path);
-	git_vector_free(&ff->entries);
+	git_vector_free_all(&ff->entries);
 	git__free(ff);
 }
 
diff --git a/src/merge.c b/src/merge.c
index 0d89da5a0..d5bc6a39c 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2383,11 +2383,7 @@ done:
         git_index_set_caps(index_repo, index_repo_caps);
 
 	git_index_free(index_repo);
-
-	git_vector_foreach(&paths, i, path)
-		git__free(path);
-
-	git_vector_free(&paths);
+	git_vector_free_all(&paths);
 
 	return error;
 }
diff --git a/src/pathspec.c b/src/pathspec.c
index 1e7e65e90..f16e19f47 100644
--- a/src/pathspec.c
+++ b/src/pathspec.c
@@ -102,15 +102,7 @@ int git_pathspec__vinit(
 /* free data from the pathspec vector */
 void git_pathspec__vfree(git_vector *vspec)
 {
-	git_attr_fnmatch *match;
-	unsigned int i;
-
-	git_vector_foreach(vspec, i, match) {
-		git__free(match);
-		vspec->contents[i] = NULL;
-	}
-
-	git_vector_free(vspec);
+	git_vector_free_all(vspec);
 }
 
 struct pathspec_match_context {
diff --git a/src/push.c b/src/push.c
index e592249d9..a314922c1 100644
--- a/src/push.c
+++ b/src/push.c
@@ -541,10 +541,7 @@ static int queue_objects(git_push *push)
 	error = 0;
 
 on_error:
-	git_vector_foreach(&commits, i, oid)
-		git__free(oid);
-
-	git_vector_free(&commits);
+	git_vector_free_all(&commits);
 	return error;
 }
 
diff --git a/src/remote.c b/src/remote.c
index e9d079db5..93d243001 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1158,15 +1158,7 @@ int git_remote_list(git_strarray *remotes_list, git_repository *repo)
 		error = giterr_restore(&data.error);
 
 	if (error < 0) {
-		size_t i;
-		char *elem;
-
-		git_vector_foreach(&data.list, i, elem) {
-			git__free(elem);
-		}
-
-		git_vector_free(&data.list);
-
+		git_vector_free_all(&data.list);
 		return error;
 	}
 
@@ -1651,9 +1643,7 @@ static int copy_refspecs(git_strarray *array, git_remote *remote, unsigned int p
 	return 0;
 
 on_error:
-	git_vector_foreach(&refspecs, i, dup)
-		git__free(dup);
-	git_vector_free(&refspecs);
+	git_vector_free_all(&refspecs);
 
 	return -1;
 }
diff --git a/src/status.c b/src/status.c
index 777b7964a..ce571a2d8 100644
--- a/src/status.c
+++ b/src/status.c
@@ -376,19 +376,13 @@ const git_status_entry *git_status_byindex(git_status_list *status, size_t i)
 
 void git_status_list_free(git_status_list *status)
 {
-	git_status_entry *status_entry;
-	size_t i;
-
 	if (status == NULL)
 		return;
 
 	git_diff_free(status->head2idx);
 	git_diff_free(status->idx2wd);
 
-	git_vector_foreach(&status->paired, i, status_entry)
-		git__free(status_entry);
-
-	git_vector_free(&status->paired);
+	git_vector_free_all(&status->paired);
 
 	git__memzero(status, sizeof(*status));
 	git__free(status);
diff --git a/src/vector.c b/src/vector.c
index 362e7b0c0..9e217b831 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -77,6 +77,20 @@ void git_vector_free(git_vector *v)
 	v->_alloc_size = 0;
 }
 
+void git_vector_free_all(git_vector *v)
+{
+	size_t i;
+
+	assert(v);
+
+	for (i = 0; i < v->length; ++i) {
+		git__free(v->contents[i]);
+		v->contents[i] = NULL;
+	}
+
+	git_vector_free(v);
+}
+
 int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp)
 {
 	assert(v);
diff --git a/src/vector.h b/src/vector.h
index 279f5c6ee..c6d3e9d55 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -23,6 +23,7 @@ typedef struct git_vector {
 
 int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp);
 void git_vector_free(git_vector *v);
+void git_vector_free_all(git_vector *v); /* free each entry and self */
 void git_vector_clear(git_vector *v);
 int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp);
 void git_vector_swap(git_vector *a, git_vector *b);
-- 
cgit v1.2.3


From 25e0b1576d5f9e5248603f81d3198a65bfccf0ed Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 6 Dec 2013 15:07:57 -0800
Subject: Remove converting user error to GIT_EUSER

This changes the behavior of callbacks so that the callback error
code is not converted into GIT_EUSER and instead we propagate the
return value through to the caller.  Instead of using the
giterr_capture and giterr_restore functions, we now rely on all
functions to pass back the return value from a callback.

To avoid having a return value with no error message, the user
can call the public giterr_set_str or some such function to set
an error message.  There is a new helper 'giterr_set_callback'
that functions can invoke after making a callback which ensures
that some error message was set in case the callback did not set
one.

In places where the sign of the callback return value is
meaningful (e.g. positive to skip, negative to abort), only the
negative values are returned back to the caller, obviously, since
the other values allow for continuing the loop.

The hardest parts of this were in the checkout code where positive
return values were overloaded as meaningful values for checkout.
I fixed this by adding an output parameter to many of the internal
checkout functions and removing the overload.  This added some
code, but it is probably a better implementation.

There is some funkiness in the network code where user provided
callbacks could be returning a positive or a negative value and
we want to rely on that to cancel the loop.  There are still a
couple places where an user error might get turned into GIT_EUSER
there, I think, though none exercised by the tests.
---
 include/git2/config.h           |   4 +-
 include/git2/errors.h           |   1 +
 src/attr.c                      |  12 +-
 src/checkout.c                  | 244 ++++++++++++++++++++--------------------
 src/clone.c                     |  24 ++--
 src/common.h                    |  32 ++++--
 src/config.c                    |  42 +++----
 src/diff.c                      |  79 ++++++-------
 src/diff_patch.c                |  36 ++----
 src/diff_print.c                |  93 ++++++---------
 src/diff_xdiff.c                |  19 ++--
 src/fetch.c                     |   6 +-
 src/fetchhead.c                 |   6 +-
 src/fileops.c                   |  47 +++-----
 src/ignore.c                    |  23 +---
 src/index.c                     |  17 +--
 src/indexer.c                   |  16 +--
 src/merge.c                     |   4 +-
 src/notes.c                     |  10 +-
 src/odb_loose.c                 |  22 ++--
 src/odb_pack.c                  |  32 ++----
 src/pack-objects.c              |  21 ++--
 src/pack.c                      |   9 +-
 src/path.c                      |  12 +-
 src/path.h                      |   7 +-
 src/push.c                      |   4 +-
 src/refdb_fs.c                  |  25 +---
 src/refs.c                      |  35 +++---
 src/remote.c                    |  94 ++++++----------
 src/repository.c                |   5 +-
 src/revwalk.c                   |   8 +-
 src/stash.c                     |  16 +--
 src/status.c                    |  38 ++-----
 src/submodule.c                 |  52 +++------
 src/tag.c                       |  35 ++----
 src/transports/http.c           |   8 +-
 src/transports/local.c          |  61 +++++-----
 src/transports/smart.c          |  13 ++-
 src/transports/smart_protocol.c |  35 +++---
 src/transports/winhttp.c        |   8 +-
 src/tree.c                      |  22 ++--
 src/vector.c                    |  16 +++
 src/vector.h                    |   2 +
 tests/attr/repo.c               |   6 +-
 tests/config/read.c             |   2 +-
 tests/config/rename.c           |   9 +-
 tests/core/path.c               |   6 +-
 tests/diff/index.c              |   4 +-
 tests/diff/notify.c             |   2 +-
 tests/diff/rename.c             |  22 ++++
 tests/notes/notes.c             |   2 +-
 tests/object/tree/walk.c        |  14 +--
 tests/odb/foreach.c             |  28 ++---
 tests/online/clone.c            |   5 +-
 tests/online/fetch.c            |   4 +-
 tests/refs/foreachglob.c        |   4 +-
 tests/status/worktree.c         |   4 +-
 57 files changed, 603 insertions(+), 804 deletions(-)

diff --git a/include/git2/config.h b/include/git2/config.h
index 95da4bc03..3ab58f1a7 100644
--- a/include/git2/config.h
+++ b/include/git2/config.h
@@ -612,8 +612,8 @@ GIT_EXTERN(int) git_config_parse_int64(int64_t *out, const char *value);
 GIT_EXTERN(int) git_config_backend_foreach_match(
 	git_config_backend *backend,
 	const char *regexp,
-	int (*fn)(const git_config_entry *, void *),
-	void *data);
+	git_config_foreach_cb callback,
+	void *payload);
 
 
 /** @} */
diff --git a/include/git2/errors.h b/include/git2/errors.h
index c6076f3ab..26f9a747c 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -71,6 +71,7 @@ typedef enum {
 	GITERR_SSH,
 	GITERR_FILTER,
 	GITERR_REVERT,
+	GITERR_CALLBACK,
 } git_error_t;
 
 /**
diff --git a/src/attr.c b/src/attr.c
index 1a0f1f97f..08d7ee99d 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -191,11 +191,10 @@ int git_attr_foreach(
 				if (error < 0)
 					goto cleanup;
 
-				error = callback(assign->name, assign->value, payload);
-				if (error) {
-					error = giterr_user_cancel();
+				error = GITERR_CALLBACK(
+					callback(assign->name, assign->value, payload) );
+				if (error)
 					goto cleanup;
-				}
 			}
 		}
 	}
@@ -480,7 +479,6 @@ typedef struct {
 	const char *workdir;
 	git_index *index;
 	git_vector *files;
-	git_error_state error;
 } attr_walk_up_info;
 
 int git_attr_cache__decide_sources(
@@ -524,7 +522,7 @@ static int push_one_attr(void *ref, git_buf *path)
 			info->repo, path->ptr, GIT_ATTR_FILE, src[i],
 			git_attr_file__parse_buffer, NULL, info->files);
 
-	return giterr_capture(&info->error, error);
+	return error;
 }
 
 static int collect_attr_files(
@@ -570,8 +568,6 @@ static int collect_attr_files(
 	info.files = files;
 
 	error = git_path_walk_up(&dir, workdir, push_one_attr, &info);
-	if (error == GIT_EUSER)
-		error = giterr_restore(&info.error);
 	if (error < 0)
 		goto cleanup;
 
diff --git a/src/checkout.c b/src/checkout.c
index e33ac2ed6..4c64252e4 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -83,10 +83,8 @@ static int checkout_notify(
 	const git_diff_file *baseline = NULL, *target = NULL, *workdir = NULL;
 	const char *path = NULL;
 
-	if (!data->opts.notify_cb)
-		return 0;
-
-	if ((why & data->opts.notify_flags) == 0)
+	if (!data->opts.notify_cb ||
+		(why & data->opts.notify_flags) == 0)
 		return 0;
 
 	if (wditem) {
@@ -125,8 +123,10 @@ static int checkout_notify(
 		path = delta->old_file.path;
 	}
 
-	return data->opts.notify_cb(
-		why, path, baseline, target, workdir, data->opts.notify_payload);
+	return giterr_set_callback(
+		data->opts.notify_cb(
+			why, path, baseline, target, workdir, data->opts.notify_payload),
+		"git_checkout notification");
 }
 
 static bool checkout_is_workdir_modified(
@@ -186,69 +186,66 @@ static bool checkout_is_workdir_modified(
 	((data->strategy & GIT_CHECKOUT_##FLAG) ? CHECKOUT_ACTION__##YES : CHECKOUT_ACTION__##NO)
 
 static int checkout_action_common(
+	int *action,
 	checkout_data *data,
-	int action,
 	const git_diff_delta *delta,
 	const git_index_entry *wd)
 {
 	git_checkout_notify_t notify = GIT_CHECKOUT_NOTIFY_NONE;
 
-	if (action <= 0)
-		return action;
-
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0)
-		action = (action & ~CHECKOUT_ACTION__REMOVE);
+		*action = (*action & ~CHECKOUT_ACTION__REMOVE);
 
-	if ((action & CHECKOUT_ACTION__UPDATE_BLOB) != 0) {
+	if ((*action & CHECKOUT_ACTION__UPDATE_BLOB) != 0) {
 		if (S_ISGITLINK(delta->new_file.mode))
-			action = (action & ~CHECKOUT_ACTION__UPDATE_BLOB) |
+			*action = (*action & ~CHECKOUT_ACTION__UPDATE_BLOB) |
 				CHECKOUT_ACTION__UPDATE_SUBMODULE;
 
 		/* to "update" a symlink, we must remove the old one first */
 		if (delta->new_file.mode == GIT_FILEMODE_LINK && wd != NULL)
-			action |= CHECKOUT_ACTION__REMOVE;
+			*action |= CHECKOUT_ACTION__REMOVE;
 
 		notify = GIT_CHECKOUT_NOTIFY_UPDATED;
 	}
 
-	if ((action & CHECKOUT_ACTION__CONFLICT) != 0)
+	if ((*action & CHECKOUT_ACTION__CONFLICT) != 0)
 		notify = GIT_CHECKOUT_NOTIFY_CONFLICT;
 
-	if (notify != GIT_CHECKOUT_NOTIFY_NONE &&
-		checkout_notify(data, notify, delta, wd) != 0)
-		return giterr_user_cancel();
-
-	return action;
+	return checkout_notify(data, notify, delta, wd);
 }
 
 static int checkout_action_no_wd(
+	int *action,
 	checkout_data *data,
 	const git_diff_delta *delta)
 {
-	int action = CHECKOUT_ACTION__NONE;
+	int error = 0;
+
+	*action = CHECKOUT_ACTION__NONE;
 
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED: /* case 12 */
-		if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL))
-			return giterr_user_cancel();
-		action = CHECKOUT_ACTION_IF(SAFE_CREATE, UPDATE_BLOB, NONE);
+		error = checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL);
+		if (error)
+			return error;
+		*action = CHECKOUT_ACTION_IF(SAFE_CREATE, UPDATE_BLOB, NONE);
 		break;
 	case GIT_DELTA_ADDED:    /* case 2 or 28 (and 5 but not really) */
-		action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+		*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
 		break;
 	case GIT_DELTA_MODIFIED: /* case 13 (and 35 but not really) */
-		action = CHECKOUT_ACTION_IF(SAFE_CREATE, UPDATE_BLOB, CONFLICT);
+		*action = CHECKOUT_ACTION_IF(SAFE_CREATE, UPDATE_BLOB, CONFLICT);
 		break;
 	case GIT_DELTA_TYPECHANGE: /* case 21 (B->T) and 28 (T->B)*/
 		if (delta->new_file.mode == GIT_FILEMODE_TREE)
-			action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
 		break;
 	case GIT_DELTA_DELETED: /* case 8 or 25 */
 	default: /* impossible */
 		break;
 	}
 
-	return checkout_action_common(data, action, delta, NULL);
+	return checkout_action_common(action, data, delta, NULL);
 }
 
 static int checkout_action_wd_only(
@@ -257,6 +254,7 @@ static int checkout_action_wd_only(
 	const git_index_entry *wd,
 	git_vector *pathspec)
 {
+	int error = 0;
 	bool remove = false;
 	git_checkout_notify_t notify = GIT_CHECKOUT_NOTIFY_NONE;
 
@@ -269,13 +267,13 @@ static int checkout_action_wd_only(
 	/* check if item is tracked in the index but not in the checkout diff */
 	if (data->index != NULL) {
 		if (wd->mode != GIT_FILEMODE_TREE) {
-			int error;
-
-			if ((error = git_index_find(NULL, data->index, wd->path)) == 0) {
+			if (!(error = git_index_find(NULL, data->index, wd->path))) {
 				notify = GIT_CHECKOUT_NOTIFY_DIRTY;
 				remove = ((data->strategy & GIT_CHECKOUT_FORCE) != 0);
 			} else if (error != GIT_ENOTFOUND)
 				return error;
+			else
+				giterr_clear();
 		} else {
 			/* for tree entries, we have to see if there are any index
 			 * entries that are contained inside that tree
@@ -301,18 +299,16 @@ static int checkout_action_wd_only(
 		remove = ((data->strategy & GIT_CHECKOUT_REMOVE_UNTRACKED) != 0);
 	}
 
-	if (checkout_notify(data, notify, NULL, wd))
-		return giterr_user_cancel();
+	error = checkout_notify(data, notify, NULL, wd);
 
-	if (remove) {
+	if (!error && remove) {
 		char *path = git_pool_strdup(&data->pool, wd->path);
 		GITERR_CHECK_ALLOC(path);
 
-		if (git_vector_insert(&data->removes, path) < 0)
-			return -1;
+		error = git_vector_insert(&data->removes, path);
 	}
 
-	return 0;
+	return error;
 }
 
 static bool submodule_is_config_only(
@@ -331,35 +327,35 @@ static bool submodule_is_config_only(
 }
 
 static int checkout_action_with_wd(
+	int *action,
 	checkout_data *data,
 	const git_diff_delta *delta,
 	const git_index_entry *wd)
 {
-	int action = CHECKOUT_ACTION__NONE;
+	*action = CHECKOUT_ACTION__NONE;
 
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED: /* case 14/15 or 33 */
 		if (checkout_is_workdir_modified(data, &delta->old_file, wd)) {
-			if (checkout_notify(
-					data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd))
-				return giterr_user_cancel();
-			action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, NONE);
+			GITERR_CHECK_ERROR(
+				checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd) );
+			*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, NONE);
 		}
 		break;
 	case GIT_DELTA_ADDED: /* case 3, 4 or 6 */
-		action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
+		*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
 		break;
 	case GIT_DELTA_DELETED: /* case 9 or 10 (or 26 but not really) */
 		if (checkout_is_workdir_modified(data, &delta->old_file, wd))
-			action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
+			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
 		else
-			action = CHECKOUT_ACTION_IF(SAFE, REMOVE, NONE);
+			*action = CHECKOUT_ACTION_IF(SAFE, REMOVE, NONE);
 		break;
 	case GIT_DELTA_MODIFIED: /* case 16, 17, 18 (or 36 but not really) */
 		if (checkout_is_workdir_modified(data, &delta->old_file, wd))
-			action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
+			*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
 		else
-			action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
 		break;
 	case GIT_DELTA_TYPECHANGE: /* case 22, 23, 29, 30 */
 		if (delta->old_file.mode == GIT_FILEMODE_TREE) {
@@ -367,92 +363,93 @@ static int checkout_action_with_wd(
 				/* either deleting items in old tree will delete the wd dir,
 				 * or we'll get a conflict when we attempt blob update...
 				 */
-				action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+				*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
 			else if (wd->mode == GIT_FILEMODE_COMMIT) {
 				/* workdir is possibly a "phantom" submodule - treat as a
 				 * tree if the only submodule info came from the config
 				 */
 				if (submodule_is_config_only(data, wd->path))
-					action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+					*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
 				else
-					action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
+					*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 			} else
-				action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
+				*action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
 		}
 		else if (checkout_is_workdir_modified(data, &delta->old_file, wd))
-			action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
+			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 		else
-			action = CHECKOUT_ACTION_IF(SAFE, REMOVE_AND_UPDATE, NONE);
+			*action = CHECKOUT_ACTION_IF(SAFE, REMOVE_AND_UPDATE, NONE);
 
 		/* don't update if the typechange is to a tree */
 		if (delta->new_file.mode == GIT_FILEMODE_TREE)
-			action = (action & ~CHECKOUT_ACTION__UPDATE_BLOB);
+			*action = (*action & ~CHECKOUT_ACTION__UPDATE_BLOB);
 		break;
 	default: /* impossible */
 		break;
 	}
 
-	return checkout_action_common(data, action, delta, wd);
+	return checkout_action_common(action, data, delta, wd);
 }
 
 static int checkout_action_with_wd_blocker(
+	int *action,
 	checkout_data *data,
 	const git_diff_delta *delta,
 	const git_index_entry *wd)
 {
-	int action = CHECKOUT_ACTION__NONE;
+	*action = CHECKOUT_ACTION__NONE;
 
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED:
 		/* should show delta as dirty / deleted */
-		if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd))
-			return giterr_user_cancel();
-		action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, NONE);
+		GITERR_CHECK_ERROR(
+			checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd) );
+		*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, NONE);
 		break;
 	case GIT_DELTA_ADDED:
 	case GIT_DELTA_MODIFIED:
-		action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
+		*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 		break;
 	case GIT_DELTA_DELETED:
-		action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
+		*action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
 		break;
 	case GIT_DELTA_TYPECHANGE:
 		/* not 100% certain about this... */
-		action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
+		*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 		break;
 	default: /* impossible */
 		break;
 	}
 
-	return checkout_action_common(data, action, delta, wd);
+	return checkout_action_common(action, data, delta, wd);
 }
 
 static int checkout_action_with_wd_dir(
+	int *action,
 	checkout_data *data,
 	const git_diff_delta *delta,
 	const git_index_entry *wd)
 {
-	int action = CHECKOUT_ACTION__NONE;
+	*action = CHECKOUT_ACTION__NONE;
 
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED: /* case 19 or 24 (or 34 but not really) */
-		if (checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL) ||
-			checkout_notify(
-				data, GIT_CHECKOUT_NOTIFY_UNTRACKED, NULL, wd))
-			return giterr_user_cancel();
+		GITERR_CHECK_ERROR(
+			checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, NULL));
+		GITERR_CHECK_ERROR(
+			checkout_notify(data, GIT_CHECKOUT_NOTIFY_UNTRACKED, NULL, wd));
 		break;
 	case GIT_DELTA_ADDED:/* case 4 (and 7 for dir) */
 	case GIT_DELTA_MODIFIED: /* case 20 (or 37 but not really) */
 		if (delta->old_file.mode == GIT_FILEMODE_COMMIT)
 			/* expected submodule (and maybe found one) */;
 		else if (delta->new_file.mode != GIT_FILEMODE_TREE)
-			action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
+			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 		break;
 	case GIT_DELTA_DELETED: /* case 11 (and 27 for dir) */
-		if (delta->old_file.mode != GIT_FILEMODE_TREE &&
-			checkout_notify(
-				data, GIT_CHECKOUT_NOTIFY_UNTRACKED, NULL, wd))
-			return giterr_user_cancel();
+		if (delta->old_file.mode != GIT_FILEMODE_TREE)
+			GITERR_CHECK_ERROR(
+				checkout_notify(data, GIT_CHECKOUT_NOTIFY_UNTRACKED, NULL, wd));
 		break;
 	case GIT_DELTA_TYPECHANGE: /* case 24 or 31 */
 		if (delta->old_file.mode == GIT_FILEMODE_TREE) {
@@ -462,39 +459,41 @@ static int checkout_action_with_wd_dir(
 			 * directory if is it left empty, so we can defer removing the
 			 * dir and it will succeed if no children are left.
 			 */
-			action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
-			if (action != CHECKOUT_ACTION__NONE)
-				action |= CHECKOUT_ACTION__DEFER_REMOVE;
+			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
+			if (*action != CHECKOUT_ACTION__NONE)
+				*action |= CHECKOUT_ACTION__DEFER_REMOVE;
 		}
 		else if (delta->new_file.mode != GIT_FILEMODE_TREE)
 			/* For typechange to dir, dir is already created so no action */
-			action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
+			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 		break;
 	default: /* impossible */
 		break;
 	}
 
-	return checkout_action_common(data, action, delta, wd);
+	return checkout_action_common(action, data, delta, wd);
 }
 
 static int checkout_action(
+	int *action,
 	checkout_data *data,
 	git_diff_delta *delta,
 	git_iterator *workdir,
-	const git_index_entry **wditem_ptr,
+	const git_index_entry **wditem,
 	git_vector *pathspec)
 {
-	const git_index_entry *wd = *wditem_ptr;
-	int cmp = -1, act;
+	int cmp = -1, error;
 	int (*strcomp)(const char *, const char *) = data->diff->strcomp;
 	int (*pfxcomp)(const char *str, const char *pfx) = data->diff->pfxcomp;
-	int error;
+	int (*advance)(const git_index_entry **, git_iterator *) = NULL;
 
 	/* move workdir iterator to follow along with deltas */
 
 	while (1) {
+		const git_index_entry *wd = *wditem;
+
 		if (!wd)
-			return checkout_action_no_wd(data, delta);
+			return checkout_action_no_wd(action, data, delta);
 
 		cmp = strcomp(wd->path, delta->old_file.path);
 
@@ -512,79 +511,77 @@ static int checkout_action(
 			if (cmp == 0) {
 				if (wd->mode == GIT_FILEMODE_TREE) {
 					/* case 2 - entry prefixed by workdir tree */
-					error = git_iterator_advance_into_or_over(&wd, workdir);
-					if (error && error != GIT_ITEROVER)
-						goto fail;
-					*wditem_ptr = wd;
+					error = git_iterator_advance_into_or_over(wditem, workdir);
+					if (error < 0 && error != GIT_ITEROVER)
+						goto done;
 					continue;
 				}
 
 				/* case 3 maybe - wd contains non-dir where dir expected */
 				if (delta->old_file.path[strlen(wd->path)] == '/') {
-					act = checkout_action_with_wd_blocker(data, delta, wd);
-					*wditem_ptr =
-						git_iterator_advance(&wd, workdir) ? NULL : wd;
-					return act;
+					error = checkout_action_with_wd_blocker(
+						action, data, delta, wd);
+					advance = git_iterator_advance;
+					goto done;
 				}
 			}
 
 			/* case 1 - handle wd item (if it matches pathspec) */
-			if (checkout_action_wd_only(data, workdir, wd, pathspec) < 0)
-				goto fail;
-			if ((error = git_iterator_advance(&wd, workdir)) < 0 &&
+			error = checkout_action_wd_only(data, workdir, wd, pathspec);
+			if (error)
+				goto done;
+			if ((error = git_iterator_advance(wditem, workdir)) < 0 &&
 				error != GIT_ITEROVER)
-				goto fail;
-
-			*wditem_ptr = wd;
+				goto done;
 			continue;
 		}
 
 		if (cmp == 0) {
 			/* case 4 */
-			act = checkout_action_with_wd(data, delta, wd);
-			*wditem_ptr = git_iterator_advance(&wd, workdir) ? NULL : wd;
-			return act;
+			error = checkout_action_with_wd(action, data, delta, wd);
+			advance = git_iterator_advance;
+			goto done;
 		}
 
 		cmp = pfxcomp(wd->path, delta->old_file.path);
 
 		if (cmp == 0) { /* case 5 */
 			if (wd->path[strlen(delta->old_file.path)] != '/')
-				return checkout_action_no_wd(data, delta);
+				return checkout_action_no_wd(action, data, delta);
 
 			if (delta->status == GIT_DELTA_TYPECHANGE) {
 				if (delta->old_file.mode == GIT_FILEMODE_TREE) {
-					act = checkout_action_with_wd(data, delta, wd);
-					if ((error = git_iterator_advance_into(&wd, workdir)) < 0 &&
-						error != GIT_ENOTFOUND)
-						goto fail;
-					*wditem_ptr = wd;
-					return act;
+					error = checkout_action_with_wd(action, data, delta, wd);
+					advance = git_iterator_advance_into;
+					goto done;
 				}
 
 				if (delta->new_file.mode == GIT_FILEMODE_TREE ||
 					delta->new_file.mode == GIT_FILEMODE_COMMIT ||
 					delta->old_file.mode == GIT_FILEMODE_COMMIT)
 				{
-					act = checkout_action_with_wd(data, delta, wd);
-					if ((error = git_iterator_advance(&wd, workdir)) < 0 &&
-						error != GIT_ITEROVER)
-						goto fail;
-					*wditem_ptr = wd;
-					return act;
+					error = checkout_action_with_wd(action, data, delta, wd);
+					advance = git_iterator_advance;
+					goto done;
 				}
 			}
 
-			return checkout_action_with_wd_dir(data, delta, wd);
+			return checkout_action_with_wd_dir(action, data, delta, wd);
 		}
 
 		/* case 6 - wd is after delta */
-		return checkout_action_no_wd(data, delta);
+		return checkout_action_no_wd(action, data, delta);
 	}
 
-fail:
-	*wditem_ptr = NULL;
-	return -1;
+done:
+	if (!error && advance != NULL &&
+		(error = advance(wditem, workdir)) < 0) {
+		*wditem = NULL;
+		if (error == GIT_ITEROVER)
+			error = 0;
+	}
+
+	return error;
 }
 
 static int checkout_remaining_wd_items(
@@ -965,7 +962,7 @@ static int checkout_get_actions(
 	checkout_data *data,
 	git_iterator *workdir)
 {
-	int error = 0;
+	int error = 0, act;
 	const git_index_entry *wditem;
 	git_vector pathspec = GIT_VECTOR_INIT, *deltas;
 	git_pool pathpool = GIT_POOL_INIT_STRINGPOOL;
@@ -992,12 +989,9 @@ static int checkout_get_actions(
 	}
 
 	git_vector_foreach(deltas, i, delta) {
-		int act = checkout_action(data, delta, workdir, &wditem, &pathspec);
-
-		if (act < 0) {
-			error = act;
+		error = checkout_action(&act, data, delta, workdir, &wditem, &pathspec);
+		if (error)
 			goto fail;
-		}
 
 		actions[i] = act;
 
@@ -1012,7 +1006,7 @@ static int checkout_get_actions(
 	}
 
 	error = checkout_remaining_wd_items(data, workdir, wditem, &pathspec);
-	if (error < 0)
+	if (error)
 		goto fail;
 
 	counts[CHECKOUT_ACTION__REMOVE] += data->removes.length;
diff --git a/src/clone.c b/src/clone.c
index 415efabba..ffbe8f8af 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -107,7 +107,6 @@ struct head_info {
 	git_buf branchname;
 	const git_refspec *refspec;
 	bool found;
-	git_error_state error;
 };
 
 static int reference_matches_remote_head(
@@ -147,7 +146,7 @@ static int reference_matches_remote_head(
 		}
 	}
 
-	return giterr_capture(&head_info->error, error);
+	return error;
 }
 
 static int update_head_to_new_branch(
@@ -209,12 +208,8 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 	/* Check to see if the remote HEAD points to the remote master */
 	error = reference_matches_remote_head(
 		git_buf_cstr(&remote_master_name), &head_info);
-
-	if (error < 0) {
-		error = giterr_restore(&head_info.error);
-		if (error < 0 && error != GIT_ITEROVER)
-			goto cleanup;
-	}
+	if (error < 0 && error != GIT_ITEROVER)
+		goto cleanup;
 
 	if (head_info.found) {
 		error = update_head_to_new_branch(
@@ -227,9 +222,6 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 	/* Not master. Check all the other refs. */
 	error = git_reference_foreach_name(
 		repo, reference_matches_remote_head, &head_info);
-
-	if (error == GIT_EUSER)
-		error = giterr_restore(&head_info.error);
 	if (error < 0 && error != GIT_ITEROVER)
 		goto cleanup;
 
@@ -349,7 +341,7 @@ int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_
 	old_fetchhead = git_remote_update_fetchhead(remote);
 	git_remote_set_update_fetchhead(remote, 0);
 
-	if ((error = git_remote_fetch(remote)) < 0)
+	if ((error = git_remote_fetch(remote)) != 0)
 		goto cleanup;
 
 	if (branch)
@@ -363,10 +355,12 @@ int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_
 
 cleanup:
 	git_remote_set_update_fetchhead(remote, old_fetchhead);
+
 	/* Go back to the original refspecs */
-	if (git_remote_set_fetch_refspecs(remote, &refspecs) < 0) {
-		git_strarray_free(&refspecs);
-		return -1;
+	{
+		int error_alt = git_remote_set_fetch_refspecs(remote, &refspecs);
+		if (!error)
+			error = error_alt;
 	}
 
 	git_strarray_free(&refspecs);
diff --git a/src/common.h b/src/common.h
index 0ad4130aa..a0e47df9a 100644
--- a/src/common.h
+++ b/src/common.h
@@ -62,7 +62,7 @@
  * Check a return value and propogate result if non-zero.
  */
 #define GITERR_CHECK_ERROR(code) \
-	do { int _err = (code); if (_err < 0) return _err; } while (0)
+	do { int _err = (code); if (_err) return _err; } while (0)
 
 /**
  * Set the error message for this thread, formatting as needed.
@@ -75,6 +75,27 @@ void giterr_set(int error_class, const char *string, ...);
  */
 int giterr_set_regex(const regex_t *regex, int error_code);
 
+/**
+ * Set error message for user callback if needed.
+ *
+ * If the error code in non-zero and no error message is set, this
+ * sets a generic error message.
+ *
+ * @return This always returns the `error_code` parameter.
+ */
+GIT_INLINE(int) giterr_set_callback(int error_code, const char *action)
+{
+	if (error_code) {
+		const git_error *e = giterr_last();
+		if (!e || !e->message)
+			giterr_set(e ? e->klass : GITERR_CALLBACK,
+				"%s callback returned %d", action, error_code);
+	}
+	return error_code;
+}
+
+#define GITERR_CALLBACK(code) giterr_set_callback((code), __func__)
+
 /**
  * Gets the system error code for this thread.
  */
@@ -85,15 +106,6 @@ int giterr_system_last(void);
  */
 void giterr_system_set(int code);
 
-/**
- * Note that a user cancelled an operation with GIT_EUSER
- */
-GIT_INLINE(int) giterr_user_cancel(void)
-{
-	giterr_clear();
-	return GIT_EUSER;
-}
-
 /**
  * Structure to preserve libgit2 error state
  */
diff --git a/src/config.c b/src/config.c
index 3af9d58de..8b3a426ed 100644
--- a/src/config.c
+++ b/src/config.c
@@ -480,23 +480,23 @@ int git_config_foreach(
 int git_config_backend_foreach_match(
 	git_config_backend *backend,
 	const char *regexp,
-	int (*fn)(const git_config_entry *, void *),
-	void *data)
+	git_config_foreach_cb cb,
+	void *payload)
 {
 	git_config_entry *entry;
 	git_config_iterator* iter;
 	regex_t regex;
-	int result = 0;
+	int error = 0;
 
 	if (regexp != NULL) {
-		if ((result = regcomp(&regex, regexp, REG_EXTENDED)) < 0) {
-			giterr_set_regex(&regex, result);
+		if ((error = regcomp(&regex, regexp, REG_EXTENDED)) < 0) {
+			giterr_set_regex(&regex, error);
 			regfree(&regex);
 			return -1;
 		}
 	}
 
-	if ((result = backend->iterator(&iter, backend)) < 0) {
+	if ((error = backend->iterator(&iter, backend)) < 0) {
 		iter = NULL;
 		return -1;
 	}
@@ -507,10 +507,9 @@ int git_config_backend_foreach_match(
 			continue;
 
 		/* abort iterator on non-zero return value */
-		if (fn(entry, data)) {
-			result = giterr_user_cancel();
+		error = GITERR_CALLBACK( cb(entry, payload) );
+		if (error)
 			break;
-		}
 	}
 
 	if (regexp != NULL)
@@ -518,7 +517,7 @@ int git_config_backend_foreach_match(
 
 	iter->free(iter);
 
-	return result;
+	return error;
 }
 
 int git_config_foreach_match(
@@ -534,12 +533,9 @@ int git_config_foreach_match(
 	if ((error = git_config_iterator_glob_new(&iter, cfg, regexp)) < 0)
 		return error;
 
-	while ((error = git_config_next(&entry, iter)) == 0) {
-		if (cb(entry, payload)) {
-			error = giterr_user_cancel();
-			break;
-		}
-	}
+	while (!(error = git_config_next(&entry, iter)) &&
+		   !(error = GITERR_CALLBACK( cb(entry, payload) )))
+		/* make callback on each config */;
 
 	git_config_iterator_free(iter);
 
@@ -798,10 +794,8 @@ int git_config_get_multivar_foreach(
 	while ((err = iter->next(&entry, iter)) == 0) {
 		found = 1;
 
-		if (cb(entry, payload)) {
-			iter->free(iter);
-			return giterr_user_cancel();
-		}
+		if ((err = GITERR_CALLBACK( cb(entry, payload) )) != 0)
+			break;
 	}
 
 	iter->free(iter);
@@ -1212,7 +1206,6 @@ struct rename_data {
 	git_config *config;
 	git_buf *name;
 	size_t old_len;
-	git_error_state error;
 };
 
 static int rename_config_entries_cb(
@@ -1235,8 +1228,7 @@ static int rename_config_entries_cb(
 	if (!error)
 		error = git_config_delete_entry(data->config, entry->name);
 
-	/* capture error message as needed, since it will become EUSER */
-	return giterr_capture(&data->error, error);
+	return error;
 }
 
 int git_config_rename_section(
@@ -1257,7 +1249,6 @@ int git_config_rename_section(
 	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
 		goto cleanup;
 
-	memset(&data, 0, sizeof(data));
 	data.config  = config;
 	data.name    = &replace;
 	data.old_len = strlen(old_section_name) + 1;
@@ -1277,9 +1268,6 @@ int git_config_rename_section(
 	error = git_config_foreach_match(
 		config, git_buf_cstr(&pattern), rename_config_entries_cb, &data);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
-
 cleanup:
 	git_buf_free(&pattern);
 	git_buf_free(&replace);
diff --git a/src/diff.c b/src/diff.c
index af47e86aa..101426f6e 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -49,16 +49,25 @@ static git_diff_delta *diff_delta__alloc(
 	return delta;
 }
 
-static int diff_notify(
-	const git_diff *diff,
-	const git_diff_delta *delta,
-	const char *matched_pathspec)
+static int diff_insert_delta(
+	git_diff *diff, git_diff_delta *delta, const char *matched_pathspec)
 {
-	if (!diff->opts.notify_cb)
-		return 0;
+	int error = 0;
+
+	if (diff->opts.notify_cb) {
+		error = diff->opts.notify_cb(
+			diff, delta, matched_pathspec, diff->opts.notify_payload);
+
+		if (error) {
+			git__free(delta);
+			return (error > 0) ? 0 : giterr_set_callback(error, "git_diff");
+		}
+	}
+
+	if ((error = git_vector_insert(&diff->deltas, delta)) < 0)
+		git__free(delta);
 
-	return diff->opts.notify_cb(
-		diff, delta, matched_pathspec, diff->opts.notify_payload);
+	return error;
 }
 
 static int diff_delta__from_one(
@@ -68,7 +77,6 @@ static int diff_delta__from_one(
 {
 	git_diff_delta *delta;
 	const char *matched_pathspec;
-	int notify_res;
 
 	if ((entry->flags & GIT_IDXENTRY_VALID) != 0)
 		return 0;
@@ -111,21 +119,12 @@ static int diff_delta__from_one(
 		!git_oid_iszero(&delta->new_file.oid))
 		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
 
-	notify_res = diff_notify(diff, delta, matched_pathspec);
-
-	if (notify_res)
-		git__free(delta);
-	else if (git_vector_insert(&diff->deltas, delta) < 0) {
-		git__free(delta);
-		return -1;
-	}
-
-	return notify_res < 0 ? giterr_user_cancel() : 0;
+	return diff_insert_delta(diff, delta, matched_pathspec);
 }
 
 static int diff_delta__from_two(
 	git_diff *diff,
-	git_delta_t   status,
+	git_delta_t status,
 	const git_index_entry *old_entry,
 	uint32_t old_mode,
 	const git_index_entry *new_entry,
@@ -134,7 +133,6 @@ static int diff_delta__from_two(
 	const char *matched_pathspec)
 {
 	git_diff_delta *delta;
-	int notify_res;
 	const char *canonical_path = old_entry->path;
 
 	if (status == GIT_DELTA_UNMODIFIED &&
@@ -173,16 +171,7 @@ static int diff_delta__from_two(
 	if (new_oid || !git_oid_iszero(&new_entry->oid))
 		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
 
-	notify_res = diff_notify(diff, delta, matched_pathspec);
-
-	if (notify_res)
-		git__free(delta);
-	else if (git_vector_insert(&diff->deltas, delta) < 0) {
-		git__free(delta);
-		return -1;
-	}
-
-	return notify_res < 0 ? giterr_user_cancel() : 0;
+	return diff_insert_delta(diff, delta, matched_pathspec);
 }
 
 static git_diff_delta *diff_delta__last_for_item(
@@ -654,6 +643,7 @@ static int maybe_modified(
 	unsigned int nmode = nitem->mode;
 	bool new_is_workdir = (info->new_iter->type == GIT_ITERATOR_TYPE_WORKDIR);
 	const char *matched_pathspec;
+	int error = 0;
 
 	if (!git_pathspec__match(
 			&diff->pathspec, oitem->path,
@@ -688,10 +678,9 @@ static int maybe_modified(
 		if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_INCLUDE_TYPECHANGE))
 			status = GIT_DELTA_TYPECHANGE;
 		else {
-			if (diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem) < 0 ||
-				diff_delta__from_one(diff, GIT_DELTA_ADDED, nitem) < 0)
-				return -1;
-			return 0;
+			if (!(error = diff_delta__from_one(diff, GIT_DELTA_DELETED, oitem)))
+				error = diff_delta__from_one(diff, GIT_DELTA_ADDED, nitem);
+			return error;
 		}
 	}
 
@@ -713,8 +702,8 @@ static int maybe_modified(
 		/* TODO: add check against index file st_mtime to avoid racy-git */
 
 		if (S_ISGITLINK(nmode)) {
-			if (maybe_modified_submodule(&status, &noid, diff, info) < 0)
-				return -1;
+			if ((error = maybe_modified_submodule(&status, &noid, diff, info)) < 0)
+				return error;
 		}
 
 		/* if the stat data looks different, then mark modified - this just
@@ -741,9 +730,9 @@ static int maybe_modified(
 	 */
 	if (status == GIT_DELTA_MODIFIED && git_oid_iszero(&nitem->oid)) {
 		if (git_oid_iszero(&noid)) {
-			if (git_diff__oid_for_file(diff->repo,
-					nitem->path, nitem->mode, nitem->file_size, &noid) < 0)
-				return -1;
+			if ((error = git_diff__oid_for_file(diff->repo,
+					nitem->path, nitem->mode, nitem->file_size, &noid)) < 0)
+				return error;
 		}
 
 		/* if oid matches, then mark unmodified (except submodules, where
@@ -898,7 +887,7 @@ static int handle_unmatched_new_item(
 			git_diff_delta *last;
 
 			/* attempt to insert record for this directory */
-			if ((error = diff_delta__from_one(diff, delta_type, nitem)) < 0)
+			if ((error = diff_delta__from_one(diff, delta_type, nitem)) != 0)
 				return error;
 
 			/* if delta wasn't created (because of rules), just skip ahead */
@@ -977,7 +966,7 @@ static int handle_unmatched_new_item(
 	}
 
 	/* Actually create the record for this item if necessary */
-	if ((error = diff_delta__from_one(diff, delta_type, nitem)) < 0)
+	if ((error = diff_delta__from_one(diff, delta_type, nitem)) != 0)
 		return error;
 
 	/* If user requested TYPECHANGE records, then check for that instead of
@@ -1002,7 +991,7 @@ static int handle_unmatched_old_item(
 	git_diff *diff, diff_in_progress *info)
 {
 	int error = diff_delta__from_one(diff, GIT_DELTA_DELETED, info->oitem);
-	if (error < 0)
+	if (error != 0)
 		return error;
 
 	/* if we are generating TYPECHANGE records then check for that
@@ -1399,10 +1388,8 @@ int git_diff__paired_foreach(
 			i++; j++;
 		}
 
-		if (cb(h2i, i2w, payload)) {
-			error = giterr_user_cancel();
+		if ((error = GITERR_CALLBACK( cb(h2i, i2w, payload) )) != 0)
 			break;
-		}
 	}
 
 	/* restore case-insensitive delta sort */
diff --git a/src/diff_patch.c b/src/diff_patch.c
index c0910558e..11f02478d 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -32,7 +32,6 @@ struct git_patch {
 	git_array_t(git_diff_line)   lines;
 	size_t content_size, context_size, header_size;
 	git_pool flattened;
-	git_error_state error;
 };
 
 enum {
@@ -200,11 +199,12 @@ static int diff_patch_invoke_file_callback(
 	float progress = patch->diff ?
 		((float)patch->delta_index / patch->diff->deltas.length) : 1.0f;
 
-	if (output->file_cb &&
-		output->file_cb(patch->delta, progress, output->payload) != 0)
-		return giterr_user_cancel();
+	if (!output->file_cb)
+		return 0;
 
-	return 0;
+	return giterr_set_callback(
+		output->file_cb(patch->delta, progress, output->payload),
+		"git_patch");
 }
 
 static int diff_patch_generate(git_patch *patch, git_diff_output *output)
@@ -291,7 +291,7 @@ int git_diff_foreach(
 
 		git_patch_free(&patch);
 
-		if (error < 0)
+		if (error)
 			break;
 	}
 
@@ -331,9 +331,6 @@ static int diff_single_generate(diff_patch_with_delta *pd, git_xdiff_output *xo)
 	if (!error)
 		error = diff_patch_generate(patch, (git_diff_output *)xo);
 
-	if (error == GIT_EUSER)
-		giterr_clear(); /* don't leave error message set invalidly */
-
 	return error;
 }
 
@@ -462,9 +459,6 @@ int git_patch_from_blobs(
 	error = diff_patch_from_blobs(
 		pd, &xo, old_blob, old_path, new_blob, new_path, opts);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&pd->patch.error);
-
 	if (!error)
 		*out = (git_patch *)pd;
 	else
@@ -576,9 +570,6 @@ int git_patch_from_blob_and_buffer(
 	error = diff_patch_from_blob_and_buffer(
 		pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&pd->patch.error);
-
 	if (!error)
 		*out = (git_patch *)pd;
 	else
@@ -627,12 +618,9 @@ int git_patch_from_diff(
 	if (!error)
 		error = diff_patch_generate(patch, &xo.output);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&patch->error);
-
 	if (!error) {
-		/* if cumulative diff size is < 0.5 total size, flatten the patch */
-		/* unload the file content */
+		/* TODO: if cumulative diff size is < 0.5 total size, flatten patch */
+		/* TODO: and unload the file content */
 	}
 
 	if (error || !patch_ptr)
@@ -640,8 +628,6 @@ int git_patch_from_diff(
 	else
 		*patch_ptr = patch;
 
-	if (error == GIT_EUSER)
-		giterr_clear(); /* don't leave error message set invalidly */
 	return error;
 }
 
@@ -879,8 +865,7 @@ static int diff_patch_hunk_cb(
 	GIT_UNUSED(delta);
 
 	hunk = git_array_alloc(patch->hunks);
-	if (!hunk)
-		return giterr_capture(&patch->error, -1);
+	GITERR_CHECK_ALLOC(hunk);
 
 	memcpy(&hunk->hunk, hunk_, sizeof(hunk->hunk));
 
@@ -909,8 +894,7 @@ static int diff_patch_line_cb(
 	assert(hunk); /* programmer error if no hunk is available */
 
 	line = git_array_alloc(patch->lines);
-	if (!line)
-		return giterr_capture(&patch->error, -1);
+	GITERR_CHECK_ALLOC(line);
 
 	memcpy(line, line_, sizeof(*line));
 
diff --git a/src/diff_print.c b/src/diff_print.c
index 712402864..ff477e4c8 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -18,7 +18,6 @@ typedef struct {
 	uint32_t flags;
 	int oid_strlen;
 	git_diff_line line;
-	git_error_state error;
 } diff_print_info;
 
 static int diff_print_info_init(
@@ -34,7 +33,6 @@ static int diff_print_info_init(
 	pi->print_cb = cb;
 	pi->payload  = payload;
 	pi->buf      = out;
-	memset(&pi->error, 0, sizeof(pi->error));
 
 	if (diff)
 		pi->flags = diff->opts.flags;
@@ -104,19 +102,16 @@ static int diff_print_one_name_only(
 		return 0;
 
 	git_buf_clear(out);
-
-	if (git_buf_puts(out, delta->new_file.path) < 0 ||
-		git_buf_putc(out, '\n'))
-		return giterr_capture(&pi->error, -1);
+	git_buf_puts(out, delta->new_file.path);
+	git_buf_putc(out, '\n');
+	if (git_buf_oom(out))
+		return -1;
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
 	pi->line.content     = git_buf_cstr(out);
 	pi->line.content_len = git_buf_len(out);
 
-	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return giterr_user_cancel();
-
-	return 0;
+	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
 }
 
 static int diff_print_one_name_status(
@@ -150,18 +145,14 @@ static int diff_print_one_name_status(
 		git_buf_printf(out, "%c\t%s%c\n", code, delta->old_file.path, old_suffix);
 	else
 		git_buf_printf(out, "%c\t%s\n", code, delta->old_file.path);
-
 	if (git_buf_oom(out))
-		return giterr_capture(&pi->error, -1);
+		return -1;
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
 	pi->line.content     = git_buf_cstr(out);
 	pi->line.content_len = git_buf_len(out);
 
-	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return giterr_user_cancel();
-
-	return 0;
+	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
 }
 
 static int diff_print_one_raw(
@@ -198,16 +189,13 @@ static int diff_print_one_raw(
 			delta->old_file.path : delta->new_file.path);
 
 	if (git_buf_oom(out))
-		return giterr_capture(&pi->error, -1);
+		return -1;
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
 	pi->line.content     = git_buf_cstr(out);
 	pi->line.content_len = git_buf_len(out);
 
-	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return giterr_user_cancel();
-
-	return 0;
+	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
 }
 
 static int diff_print_oid_range(
@@ -234,10 +222,7 @@ static int diff_print_oid_range(
 		git_buf_printf(out, "index %s..%s\n", start_oid, end_oid);
 	}
 
-	if (git_buf_oom(out))
-		return -1;
-
-	return 0;
+	return git_buf_oom(out) ? -1 : 0;
 }
 
 static int diff_delta_format_with_paths(
@@ -281,8 +266,7 @@ int git_diff_delta__format_file_header(
 	git_buf_printf(out, "diff --git %s%s %s%s\n",
 		oldpfx, delta->old_file.path, newpfx, delta->new_file.path);
 
-	if (diff_print_oid_range(out, delta, oid_strlen) < 0)
-		return -1;
+	GITERR_CHECK_ERROR(diff_print_oid_range(out, delta, oid_strlen));
 
 	if ((delta->flags & GIT_DIFF_FLAG_BINARY) == 0)
 		diff_delta_format_with_paths(
@@ -294,6 +278,7 @@ int git_diff_delta__format_file_header(
 static int diff_print_patch_file(
 	const git_diff_delta *delta, float progress, void *data)
 {
+	int error;
 	diff_print_info *pi = data;
 	const char *oldpfx =
 		pi->diff ? pi->diff->opts.old_prefix : DIFF_OLD_PREFIX_DEFAULT;
@@ -309,36 +294,33 @@ static int diff_print_patch_file(
 		 (pi->flags & GIT_DIFF_SHOW_UNTRACKED_CONTENT) == 0))
 		return 0;
 
-	if (git_diff_delta__format_file_header(
-			pi->buf, delta, oldpfx, newpfx, pi->oid_strlen) < 0)
-		return giterr_capture(&pi->error, -1);
+	if ((error = git_diff_delta__format_file_header(
+			pi->buf, delta, oldpfx, newpfx, pi->oid_strlen)) < 0)
+		return error;
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
 	pi->line.content     = git_buf_cstr(pi->buf);
 	pi->line.content_len = git_buf_len(pi->buf);
 
-	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return giterr_user_cancel();
+	if ((error = pi->print_cb(delta, NULL, &pi->line, pi->payload)) != 0)
+		return error;
 
 	if ((delta->flags & GIT_DIFF_FLAG_BINARY) == 0)
 		return 0;
 
 	git_buf_clear(pi->buf);
 
-	if (diff_delta_format_with_paths(
+	if ((error = diff_delta_format_with_paths(
 			pi->buf, delta, oldpfx, newpfx,
-			"Binary files %s%s and %s%s differ\n") < 0)
-		return giterr_capture(&pi->error, -1);
+			"Binary files %s%s and %s%s differ\n")) < 0)
+		return error;
 
 	pi->line.origin      = GIT_DIFF_LINE_BINARY;
 	pi->line.content     = git_buf_cstr(pi->buf);
 	pi->line.content_len = git_buf_len(pi->buf);
 	pi->line.num_lines   = 1;
 
-	if (pi->print_cb(delta, NULL, &pi->line, pi->payload))
-		return giterr_user_cancel();
-
-	return 0;
+	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
 }
 
 static int diff_print_patch_hunk(
@@ -355,10 +337,7 @@ static int diff_print_patch_hunk(
 	pi->line.content     = h->header;
 	pi->line.content_len = h->header_len;
 
-	if (pi->print_cb(d, h, &pi->line, pi->payload))
-		return giterr_user_cancel();
-
-	return 0;
+	return pi->print_cb(d, h, &pi->line, pi->payload);
 }
 
 static int diff_print_patch_line(
@@ -372,10 +351,7 @@ static int diff_print_patch_line(
 	if (S_ISDIR(delta->new_file.mode))
 		return 0;
 
-	if (pi->print_cb(delta, hunk, line, pi->payload))
-		return giterr_user_cancel();
-
-	return 0;
+	return pi->print_cb(delta, hunk, line, pi->payload);
 }
 
 /* print a git_diff to an output callback */
@@ -421,8 +397,8 @@ int git_diff_print(
 		error = git_diff_foreach(
 			diff, print_file, print_hunk, print_line, &pi);
 
-		if (error == GIT_EUSER && pi.error.error_code)
-			error = giterr_restore(&pi.error);
+		if (error) /* make sure error message is set */
+			giterr_set_callback(error, "git_diff_print");
 	}
 
 	git_buf_free(&buf);
@@ -450,8 +426,8 @@ int git_patch_print(
 			patch, diff_print_patch_file, diff_print_patch_hunk,
 			diff_print_patch_line, &pi);
 
-		if (error && error != GIT_EUSER)
-			error = giterr_restore(&pi.error);
+		if (error) /* make sure error message is set */
+			giterr_set_callback(error, "git_patch_print");
 	}
 
 	git_buf_free(&temp);
@@ -484,17 +460,12 @@ int git_patch_to_str(
 	int error;
 	git_buf output = GIT_BUF_INIT;
 
-	error = git_patch_print(patch, diff_print_to_buffer_cb, &output);
-
-	/* GIT_EUSER means git_buf_put in print_to_buffer_cb returned -1,
-	 * meaning a memory allocation failure, so just map to -1...
-	 */
-	if (error == GIT_EUSER) {
-		giterr_set_oom();
-		error = -1;
+	if (!(error = git_patch_print(patch, diff_print_to_buffer_cb, &output)))
+		*string = git_buf_detach(&output);
+	else {
+		git_buf_free(&output);
+		*string = NULL;
 	}
 
-	*string = git_buf_detach(&output);
-
 	return error;
 }
diff --git a/src/diff_xdiff.c b/src/diff_xdiff.c
index c6ca48882..e5984f1c9 100644
--- a/src/diff_xdiff.c
+++ b/src/diff_xdiff.c
@@ -126,8 +126,9 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 		info->hunk.header[info->hunk.header_len] = '\0';
 
 		if (output->hunk_cb != NULL &&
-			output->hunk_cb(delta, &info->hunk, output->payload))
-			return (output->error = giterr_user_cancel());
+			(output->error = output->hunk_cb(
+				delta, &info->hunk, output->payload)))
+			return output->error;
 
 		info->old_lineno = info->hunk.old_start;
 		info->new_lineno = info->hunk.new_start;
@@ -150,10 +151,9 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 		output->error = diff_update_lines(
 			info, &line, bufs[1].ptr, bufs[1].size);
 
-		if (!output->error &&
-			output->data_cb != NULL &&
-			output->data_cb(delta, &info->hunk, &line, output->payload))
-			output->error = giterr_user_cancel();
+		if (!output->error && output->data_cb != NULL)
+			output->error = output->data_cb(
+				delta, &info->hunk, &line, output->payload);
 	}
 
 	if (len == 3 && !output->error) {
@@ -172,10 +172,9 @@ static int git_xdiff_cb(void *priv, mmbuffer_t *bufs, int len)
 		output->error = diff_update_lines(
 			info, &line, bufs[2].ptr, bufs[2].size);
 
-		if (!output->error &&
-			output->data_cb != NULL &&
-			output->data_cb(delta, &info->hunk, &line, output->payload))
-			output->error = giterr_user_cancel();
+		if (!output->error && output->data_cb != NULL)
+			output->error = output->data_cb(
+				delta, &info->hunk, &line, output->payload);
 	}
 
 	return output->error;
diff --git a/src/fetch.c b/src/fetch.c
index 276591821..5bf2b93c1 100644
--- a/src/fetch.c
+++ b/src/fetch.c
@@ -104,7 +104,7 @@ cleanup:
 int git_fetch_negotiate(git_remote *remote)
 {
 	git_transport *t = remote->transport;
-	
+
 	if (filter_wants(remote) < 0) {
 		giterr_set(GITERR_NET, "Failed to filter the reference list for wants");
 		return -1;
@@ -128,9 +128,9 @@ int git_fetch_download_pack(git_remote *remote)
 {
 	git_transport *t = remote->transport;
 
-	if(!remote->need_pack)
+	if (!remote->need_pack)
 		return 0;
 
 	return t->download_pack(t, remote->repo, &remote->stats,
-				remote->callbacks.transfer_progress, remote->callbacks.payload);
+			remote->callbacks.transfer_progress, remote->callbacks.payload);
 }
diff --git a/src/fetchhead.c b/src/fetchhead.c
index ee1492211..7c37be4c6 100644
--- a/src/fetchhead.c
+++ b/src/fetchhead.c
@@ -269,10 +269,10 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 		else
 			ref_name = NULL;
 
-		if (cb(ref_name, remote_url, &oid, is_merge, payload) != 0) {
-			error = giterr_user_cancel();
+		error = GITERR_CALLBACK(
+			cb(ref_name, remote_url, &oid, is_merge, payload) );
+		if (error)
 			goto done;
-		}
 	}
 
 	if (*buffer) {
diff --git a/src/fileops.c b/src/fileops.c
index 0418e9e52..98dcd3269 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -404,7 +404,6 @@ typedef struct {
 	size_t baselen;
 	uint32_t flags;
 	int depth;
-	git_error_state error;
 } futils__rmdir_data;
 
 #define FUTILS_MAX_DEPTH 100
@@ -474,16 +473,14 @@ static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path)
 		data->depth++;
 
 		error = git_path_direach(path, 0, futils__rmdir_recurs_foreach, data);
-		if (error == GIT_EUSER)
-			return error;
 
 		data->depth--;
 
 		if (error < 0)
-			goto done;
+			return error;
 
 		if (data->depth == 0 && (data->flags & GIT_RMDIR_SKIP_ROOT) != 0)
-			goto done;
+			return error;
 
 		if ((error = p_rmdir(path->ptr)) < 0) {
 			if ((data->flags & GIT_RMDIR_SKIP_NONEMPTY) != 0 &&
@@ -502,8 +499,7 @@ static int futils__rmdir_recurs_foreach(void *opaque, git_buf *path)
 	else if ((data->flags & GIT_RMDIR_SKIP_NONEMPTY) == 0)
 		error = futils__error_cannot_rmdir(path->ptr, "still present");
 
-done:
-	return giterr_capture(&data->error, error);
+	return error;
 }
 
 static int futils__rmdir_empty_parent(void *opaque, git_buf *path)
@@ -512,9 +508,9 @@ static int futils__rmdir_empty_parent(void *opaque, git_buf *path)
 	int error = 0;
 
 	if (git_buf_len(path) <= data->baselen)
-		return giterr_capture(&data->error, GIT_ITEROVER);
+		error = GIT_ITEROVER;
 
-	if (p_rmdir(git_buf_cstr(path)) < 0) {
+	else if (p_rmdir(git_buf_cstr(path)) < 0) {
 		int en = errno;
 
 		if (en == ENOENT || en == ENOTDIR) {
@@ -526,7 +522,7 @@ static int futils__rmdir_empty_parent(void *opaque, git_buf *path)
 		}
 	}
 
-	return giterr_capture(&data->error, error);
+	return error;
 }
 
 int git_futils_rmdir_r(
@@ -552,10 +548,10 @@ int git_futils_rmdir_r(
 		error = git_path_walk_up(
 			&fullpath, base, futils__rmdir_empty_parent, &data);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
-	if (error == GIT_ITEROVER)
+	if (error == GIT_ITEROVER) {
+		giterr_clear();
 		error = 0;
+	}
 
 	git_buf_free(&fullpath);
 
@@ -859,7 +855,6 @@ typedef struct {
 	uint32_t flags;
 	uint32_t mkdir_flags;
 	mode_t dirmode;
-	git_error_state error;
 } cp_r_info;
 
 #define GIT_CPDIR__MKDIR_DONE_FOR_TO_ROOT (1u << 10)
@@ -899,19 +894,19 @@ static int _cp_r_callback(void *ref, git_buf *from)
 
 	if ((error = git_buf_joinpath(
 			&info->to, info->to_root, from->ptr + info->from_prefix)) < 0)
-		goto done;
+		return error;
 
 	if (!(error = git_path_lstat(info->to.ptr, &to_st)))
 		exists = true;
 	else if (error != GIT_ENOTFOUND)
-		goto done;
+		return error;
 	else {
 		giterr_clear();
 		error = 0;
 	}
 
 	if ((error = git_path_lstat(from->ptr, &from_st)) < 0)
-		goto done;
+		return error;
 
 	if (S_ISDIR(from_st.st_mode)) {
 		mode_t oldmode = info->dirmode;
@@ -925,16 +920,13 @@ static int _cp_r_callback(void *ref, git_buf *from)
 			error = _cp_r_mkdir(info, from);
 
 		/* recurse onto target directory */
-		if (!error && (!exists || S_ISDIR(to_st.st_mode))) {
+		if (!error && (!exists || S_ISDIR(to_st.st_mode)))
 			error = git_path_direach(from, 0, _cp_r_callback, info);
-			if (error == GIT_EUSER)
-				return error;
-		}
 
 		if (oldmode != 0)
 			info->dirmode = oldmode;
 
-		goto done;
+		return error;
 	}
 
 	if (exists) {
@@ -944,8 +936,7 @@ static int _cp_r_callback(void *ref, git_buf *from)
 		if (p_unlink(info->to.ptr) < 0) {
 			giterr_set(GITERR_OS, "Cannot overwrite existing file '%s'",
 				info->to.ptr);
-			error = -1;
-			goto done;
+			return GIT_EEXISTS;
 		}
 	}
 
@@ -958,7 +949,7 @@ static int _cp_r_callback(void *ref, git_buf *from)
 	/* Make container directory on demand if needed */
 	if ((info->flags & GIT_CPDIR_CREATE_EMPTY_DIRS) == 0 &&
 		(error = _cp_r_mkdir(info, from)) < 0)
-		goto done;
+		return error;
 
 	/* make symlink or regular file */
 	if (S_ISLNK(from_st.st_mode))
@@ -972,8 +963,7 @@ static int _cp_r_callback(void *ref, git_buf *from)
 		error = git_futils_cp(from->ptr, info->to.ptr, usemode);
 	}
 
-done:
-	return giterr_capture(&info->error, error);
+	return error;
 }
 
 int git_futils_cp_r(
@@ -1015,9 +1005,6 @@ int git_futils_cp_r(
 	git_buf_free(&path);
 	git_buf_free(&info.to);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&info.error);
-
 	return error;
 }
 
diff --git a/src/ignore.c b/src/ignore.c
index aa53d409d..c79fe4871 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -74,20 +74,12 @@ static int parse_ignore_file(
 #define push_ignore_file(R,IGN,S,B,F) \
 	git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,parse_ignore_file,(IGN),(S))
 
-struct ignores_walk_up_data {
-	git_ignores *ign;
-	git_error_state error;
-};
-
-static int push_one_ignore(void *ref, git_buf *path)
+static int push_one_ignore(void *payload, git_buf *path)
 {
-	struct ignores_walk_up_data *data = ref;
+	git_ignores *ign = payload;
 
-	return giterr_capture(
-		&data->error,
-		push_ignore_file(
-			data->ign->repo, data->ign, &data->ign->ign_path,
-			path->ptr, GIT_IGNORE_FILE) );
+	return push_ignore_file(
+		ign->repo, ign, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
 }
 
 static int get_internal_ignores(git_attr_file **ign, git_repository *repo)
@@ -142,13 +134,8 @@ int git_ignore__for_path(
 
 	/* load .gitignore up the path */
 	if (workdir != NULL) {
-		struct ignores_walk_up_data data = { ignores };
-
 		error = git_path_walk_up(
-			&ignores->dir, workdir, push_one_ignore, &data);
-
-		if (error == GIT_EUSER)
-			error = giterr_restore(&data.error);
+			&ignores->dir, workdir, push_one_ignore, ignores);
 		if (error < 0)
 			goto cleanup;
 	}
diff --git a/src/index.c b/src/index.c
index d0d2cf187..671bdfa79 100644
--- a/src/index.c
+++ b/src/index.c
@@ -2036,17 +2036,12 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
 
 	error = git_tree_walk(tree, GIT_TREEWALK_POST, read_tree_cb, &data);
 
-	if (error == GIT_EUSER) {
-		giterr_set_oom();
-		git_vector_free(&entries);
-		return -1;
+	if (!error) {
+		git_vector_sort(&entries);
+		git_index_clear(index);
+		git_vector_swap(&entries, &index->entries);
 	}
 
-	git_vector_sort(&entries);
-
-	git_index_clear(index);
-
-	git_vector_swap(&entries, &index->entries);
 	git_vector_free(&entries);
 
 	return error;
@@ -2122,7 +2117,7 @@ int git_index_add_all(
 			if (error > 0) /* return > 0 means skip this one */
 				continue;
 			if (error < 0) { /* return < 0 means abort */
-				error = giterr_user_cancel();
+				GITERR_CALLBACK(error);
 				break;
 			}
 		}
@@ -2210,7 +2205,7 @@ static int index_apply_to_all(
 				continue;
 			}
 			if (error < 0) { /* return < 0 means abort */
-				error = giterr_user_cancel();
+				giterr_set_callback(error, "git_index_matched_path");
 				break;
 			}
 		}
diff --git a/src/indexer.c b/src/indexer.c
index d3253cb57..320845bd9 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -386,10 +386,10 @@ on_error:
 
 static int do_progress_callback(git_indexer *idx, git_transfer_progress *stats)
 {
-	if (idx->progress_cb &&
-		idx->progress_cb(stats, idx->progress_payload))
-		return giterr_user_cancel();
-
+	if (idx->progress_cb)
+		return giterr_set_callback(
+			idx->progress_cb(stats, idx->progress_payload),
+			"indexer progress");
 	return 0;
 }
 
@@ -495,7 +495,7 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 		processed = stats->indexed_objects = 0;
 		stats->total_objects = total_objects;
 
-		if ((error = do_progress_callback(idx, stats)) < 0)
+		if ((error = do_progress_callback(idx, stats)) != 0)
 			return error;
 	}
 
@@ -520,7 +520,7 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 				return 0;
 			}
 			if (error < 0)
-				return -1;
+				return error;
 
 			git_mwindow_close(&w);
 			idx->entry_start = entry_start;
@@ -533,7 +533,7 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 					return 0;
 				}
 				if (error < 0)
-					return -1;
+					return error;
 
 				idx->have_delta = 1;
 			} else {
@@ -578,7 +578,7 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 		}
 		stats->received_objects++;
 
-		if ((error = do_progress_callback(idx, stats)) < 0)
+		if ((error = do_progress_callback(idx, stats)) != 0)
 			goto on_error;
 	}
 
diff --git a/src/merge.c b/src/merge.c
index d5bc6a39c..6f73fc14a 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -287,10 +287,8 @@ int git_repository_mergehead_foreach(
 		if ((error = git_oid_fromstr(&oid, line)) < 0)
 			goto cleanup;
 
-		if (cb(&oid, payload) != 0) {
-			error = giterr_user_cancel();
+		if ((error = GITERR_CALLBACK( cb(&oid, payload) )) != 0)
 			goto cleanup;
-		}
 
 		++line_num;
 	}
diff --git a/src/notes.c b/src/notes.c
index 7e8aecbae..e3a3fccf8 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -582,12 +582,10 @@ int git_note_foreach(
 	if ((error = git_note_iterator_new(&iter, repo, notes_ref)) < 0)
 		return error;
 
-	while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
-		if (note_cb(&note_id, &annotated_id, payload)) {
-			error = giterr_user_cancel();
-			break;
-		}
-	}
+	while (!(error = git_note_next(&note_id, &annotated_id, iter)) &&
+		   !(error = GITERR_CALLBACK(
+				note_cb(&note_id, &annotated_id, payload))))
+		/* callback for each note */;
 
 	if (error == GIT_ITEROVER)
 		error = 0;
diff --git a/src/odb_loose.c b/src/odb_loose.c
index ae772b425..78cd792bd 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -547,8 +547,7 @@ static int locate_object_short_oid(
 	/* Explore directory to find a unique object matching short_oid */
 	error = git_path_direach(
 		object_location, 0, fn_locate_object_short_oid, &state);
-
-	if (error && error != GIT_EUSER)
+	if (error < 0 && error != GIT_EAMBIGUOUS)
 		return error;
 
 	if (!state.found)
@@ -696,7 +695,6 @@ struct foreach_state {
 	size_t dir_len;
 	git_odb_foreach_cb cb;
 	void *data;
-	git_error_state cb_error;
 };
 
 GIT_INLINE(int) filename_to_oid(git_oid *oid, const char *ptr)
@@ -735,19 +733,15 @@ static int foreach_object_dir_cb(void *_state, git_buf *path)
 	if (filename_to_oid(&oid, path->ptr + state->dir_len) < 0)
 		return 0;
 
-	if (state->cb(&oid, state->data))
-		return giterr_user_cancel();
-
-	return 0;
+	return giterr_set_callback(
+		state->cb(&oid, state->data), "git_odb_foreach");
 }
 
 static int foreach_cb(void *_state, git_buf *path)
 {
 	struct foreach_state *state = (struct foreach_state *) _state;
 
-	return giterr_capture(
-		&state->cb_error,
-		git_path_direach(path, 0, foreach_object_dir_cb, state));
+	return git_path_direach(path, 0, foreach_object_dir_cb, state);
 }
 
 static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb cb, void *data)
@@ -762,9 +756,10 @@ static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb
 
 	objects_dir = backend->objects_dir;
 
-	if (git_buf_sets(&buf, objects_dir) < 0)
-		return -1;
+	git_buf_sets(&buf, objects_dir);
 	git_path_to_dir(&buf);
+	if (git_buf_oom(&buf))
+		return -1;
 
 	memset(&state, 0, sizeof(state));
 	state.cb = cb;
@@ -773,9 +768,6 @@ static int loose_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb
 
 	error = git_path_direach(&buf, 0, foreach_cb, &state);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&state.cb_error);
-
 	git_buf_free(&buf);
 
 	return error;
diff --git a/src/odb_pack.c b/src/odb_pack.c
index 2c0319fb6..903b00d26 100644
--- a/src/odb_pack.c
+++ b/src/odb_pack.c
@@ -190,15 +190,9 @@ static int packfile_sort__cb(const void *a_, const void *b_)
 }
 
 
-struct packfile_load_data {
-	struct pack_backend *backend;
-	git_error_state error;
-};
-
-static int packfile_load__cb(void *_data, git_buf *path)
+static int packfile_load__cb(void *data, git_buf *path)
 {
-	struct packfile_load_data *data = _data;
-	struct pack_backend *backend = data->backend;
+	struct pack_backend *backend = data;
 	struct git_pack_file *pack;
 	const char *path_str = git_buf_cstr(path);
 	size_t i, cmp_len = git_buf_len(path);
@@ -227,7 +221,7 @@ static int packfile_load__cb(void *_data, git_buf *path)
 	if (!error)
 		error = git_vector_insert(&backend->packs, pack);
 
-	return giterr_capture(&data->error, error);
+	return error;
 
 }
 
@@ -328,32 +322,26 @@ static int pack_entry_find_prefix(
  * Implement the git_odb_backend API calls
  *
  ***********************************************************/
-static int pack_backend__refresh(git_odb_backend *backend)
+static int pack_backend__refresh(git_odb_backend *backend_)
 {
-	struct packfile_load_data data;
 	int error;
 	struct stat st;
 	git_buf path = GIT_BUF_INIT;
+	struct pack_backend *backend = (struct pack_backend *)backend_;
 
-	memset(&data, 0, sizeof(data));
-	data.backend = (struct pack_backend *)backend;
-
-	if (data.backend->pack_folder == NULL)
+	if (backend->pack_folder == NULL)
 		return 0;
 
-	if (p_stat(data.backend->pack_folder, &st) < 0 || !S_ISDIR(st.st_mode))
+	if (p_stat(backend->pack_folder, &st) < 0 || !S_ISDIR(st.st_mode))
 		return git_odb__error_notfound("failed to refresh packfiles", NULL);
 
-	git_buf_sets(&path, data.backend->pack_folder);
+	git_buf_sets(&path, backend->pack_folder);
 
 	/* reload all packs */
-	error = git_path_direach(&path, 0, packfile_load__cb, &data);
-
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
+	error = git_path_direach(&path, 0, packfile_load__cb, backend);
 
 	git_buf_free(&path);
-	git_vector_sort(&data.backend->packs);
+	git_vector_sort(&backend->packs);
 
 	return error;
 }
diff --git a/src/pack-objects.c b/src/pack-objects.c
index ac0615064..2f0007f4f 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -32,7 +32,6 @@ struct unpacked {
 struct tree_walk_context {
 	git_packbuilder *pb;
 	git_buf buf;
-	git_error_state error;
 };
 
 struct pack_write_context {
@@ -206,14 +205,18 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 	po = pb->object_list + pb->nr_objects;
 	memset(po, 0x0, sizeof(*po));
 
-	if (git_odb_read_header(&po->size, &po->type, pb->odb, oid) < 0)
-		return -1;
+	if ((ret = git_odb_read_header(&po->size, &po->type, pb->odb, oid)) < 0)
+		return ret;
 
 	pb->nr_objects++;
 	git_oid_cpy(&po->id, oid);
 	po->hash = name_hash(name);
 
 	pos = kh_put(oid, pb->object_ix, &po->id, &ret);
+	if (ret < 0) {
+		giterr_set_oom();
+		return ret;
+	}
 	assert(ret != 0);
 	kh_value(pb->object_ix, pos) = po;
 
@@ -226,10 +229,9 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 		if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
 
-			if (pb->progress_cb(
-					GIT_PACKBUILDER_ADDING_OBJECTS,
-					pb->nr_objects, 0, pb->progress_cb_payload))
-				return giterr_user_cancel();
+			return GITERR_CALLBACK( pb->progress_cb(
+				GIT_PACKBUILDER_ADDING_OBJECTS,
+				pb->nr_objects, 0, pb->progress_cb_payload) );
 		}
 	}
 
@@ -1303,7 +1305,7 @@ static int cb_tree_walk(
 		error = git_packbuilder_insert(
 			ctx->pb, git_tree_entry_id(entry), git_buf_cstr(&ctx->buf));
 
-	return giterr_capture(&ctx->error, error);
+	return error;
 }
 
 int git_packbuilder_insert_commit(git_packbuilder *pb, const git_oid *oid)
@@ -1331,9 +1333,6 @@ int git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *oid)
 	    !(error = git_packbuilder_insert(pb, oid, NULL)))
 		error = git_tree_walk(tree, GIT_TREEWALK_PRE, cb_tree_walk, &context);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&context.error);
-
 	git_tree_free(tree);
 	git_buf_free(&context.buf);
 	return error;
diff --git a/src/pack.c b/src/pack.c
index f69fe85e8..3f2adb2f3 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -1082,15 +1082,16 @@ int git_pack_foreach_entry(
 			git_vector_foreach(&offsets, i, current)
 				git_vector_insert(&oids, (void*)&current[4]);
 		}
+
 		git_vector_free(&offsets);
-		p->oids = (git_oid **)oids.contents;
+		p->oids = (git_oid **)git_vector_detach(NULL, NULL, &oids);
 	}
 
 	for (i = 0; i < p->num_objects; i++)
-		if (cb(p->oids[i], data))
-			return giterr_user_cancel();
+		if ((error = GITERR_CALLBACK( cb(p->oids[i], data) )) != 0)
+			break;
 
-	return 0;
+	return error;
 }
 
 static int pack_entry_find_offset(
diff --git a/src/path.c b/src/path.c
index 8be41c17e..857a2e61c 100644
--- a/src/path.c
+++ b/src/path.c
@@ -434,11 +434,11 @@ int git_path_walk_up(
 	iter.asize = path->asize;
 
 	while (scan >= stop) {
-		if (cb(data, &iter))
-			error = giterr_user_cancel();
+		error = GITERR_CALLBACK( cb(data, &iter) );
 		iter.ptr[scan] = oldc;
-		if (error < 0)
+		if (error)
 			break;
+
 		scan = git_buf_rfind_next(&iter, '/');
 		if (scan >= 0) {
 			scan++;
@@ -874,14 +874,12 @@ int git_path_direach(
 		if ((error = git_buf_put(path, de_path, de_len)) < 0)
 			break;
 
-		error = fn(arg, path);
+		error = GITERR_CALLBACK( fn(arg, path) );
 
 		git_buf_truncate(path, wd_len); /* restore path */
 
-		if (error) {
-			error = giterr_user_cancel();
+		if (error)
 			break;
-		}
 	}
 
 	closedir(dir);
diff --git a/src/path.h b/src/path.h
index 3daafd265..f26175d15 100644
--- a/src/path.h
+++ b/src/path.h
@@ -255,9 +255,10 @@ enum {
  * @param flags Combination of GIT_PATH_DIR flags.
  * @param callback Callback for each entry. Passed the `payload` and each
  *		successive path inside the directory as a full path.  This may
- *		safely append text to the pathbuf if needed.
+ *		safely append text to the pathbuf if needed.  Return non-zero to
+ *		cancel iteration (and return value will be propagated back).
  * @param payload Passed to callback as first argument.
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success or error code from OS error or from callback
  */
 extern int git_path_direach(
 	git_buf *pathbuf,
@@ -288,7 +289,7 @@ extern int git_path_cmp(
  *		original input path.
  * @param callback Function to invoke on each path.  Passed the `payload`
  *		and the buffer containing the current path.  The path should not
- *		be modified in any way.
+ *		be modified in any way. Return non-zero to stop iteration.
  * @param state Passed to fn as the first ath.
  */
 extern int git_path_walk_up(
diff --git a/src/push.c b/src/push.c
index a314922c1..428173397 100644
--- a/src/push.c
+++ b/src/push.c
@@ -659,8 +659,8 @@ int git_push_status_foreach(git_push *push,
 	unsigned int i;
 
 	git_vector_foreach(&push->status, i, status) {
-		if (cb(status->ref, status->msg, data) < 0)
-			return giterr_user_cancel();
+		GITERR_CHECK_ERROR(
+			GITERR_CALLBACK( cb(status->ref, status->msg, data) ) );
 	}
 
 	return 0;
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 938e02a78..df7cb9d4d 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -264,14 +264,9 @@ done:
 	return error;
 }
 
-struct packed_loadloose_data {
-	refdb_fs_backend *backend;
-	git_error_state error;
-};
-
-static int _dirent_loose_load(void *data_, git_buf *full_path)
+static int _dirent_loose_load(void *payload, git_buf *full_path)
 {
-	struct packed_loadloose_data *data = data_;
+	refdb_fs_backend *backend = payload;
 	const char *file_path;
 
 	if (git__suffixcmp(full_path->ptr, ".lock") == 0)
@@ -279,12 +274,11 @@ static int _dirent_loose_load(void *data_, git_buf *full_path)
 
 	if (git_path_isdir(full_path->ptr))
 		return git_path_direach(
-			full_path, data->backend->direach_flags, _dirent_loose_load, data);
+			full_path, backend->direach_flags, _dirent_loose_load, backend);
 
-	file_path = full_path->ptr + strlen(data->backend->path);
+	file_path = full_path->ptr + strlen(backend->path);
 
-	return giterr_capture(
-		&data->error, loose_lookup_to_packfile(data->backend, file_path));
+	return loose_lookup_to_packfile(backend, file_path);
 }
 
 /*
@@ -297,27 +291,20 @@ static int packed_loadloose(refdb_fs_backend *backend)
 {
 	int error;
 	git_buf refs_path = GIT_BUF_INIT;
-	struct packed_loadloose_data data;
 
 	if (git_buf_joinpath(&refs_path, backend->path, GIT_REFS_DIR) < 0)
 		return -1;
 
-	memset(&data, 0, sizeof(data));
-	data.backend = backend;
-
 	/*
 	 * Load all the loose files from disk into the Packfile table.
 	 * This will overwrite any old packed entries with their
 	 * updated loose versions
 	 */
 	error = git_path_direach(
-		&refs_path, backend->direach_flags, _dirent_loose_load, &data);
+		&refs_path, backend->direach_flags, _dirent_loose_load, backend);
 
 	git_buf_free(&refs_path);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
-
 	return error;
 }
 
diff --git a/src/refs.c b/src/refs.c
index 60ed9ffb1..afb067986 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -516,12 +516,9 @@ int git_reference_foreach(
 	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
 		return error;
 
-	while ((error = git_reference_next(&ref, iter)) == 0) {
-		if (callback(ref, payload)) {
-			error = giterr_user_cancel();
-			break;
-		}
-	}
+	while (!(error = git_reference_next(&ref, iter)) &&
+		   !(error = GITERR_CALLBACK( callback(ref, payload) )))
+		/* callback on each reference */;
 
 	if (error == GIT_ITEROVER)
 		error = 0;
@@ -542,12 +539,9 @@ int git_reference_foreach_name(
 	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
 		return error;
 
-	while ((error = git_reference_next_name(&refname, iter)) == 0) {
-		if (callback(refname, payload)) {
-			error = giterr_user_cancel();
-			break;
-		}
-	}
+	while (!(error = git_reference_next_name(&refname, iter)) &&
+		   !(error = GITERR_CALLBACK( callback(refname, payload) )))
+		/* callback on each reference name */;
 
 	if (error == GIT_ITEROVER)
 		error = 0;
@@ -569,12 +563,9 @@ int git_reference_foreach_glob(
 	if ((error = git_reference_iterator_glob_new(&iter, repo, glob)) < 0)
 		return error;
 
-	while ((error = git_reference_next_name(&refname, iter)) == 0) {
-		if (callback(refname, payload)) {
-			error = giterr_user_cancel();
-			break;
-		}
-	}
+	while (!(error = git_reference_next_name(&refname, iter)) &&
+		   !(error = GITERR_CALLBACK( callback(refname, payload) )))
+		/* callback on each matching reference name */;
 
 	if (error == GIT_ITEROVER)
 		error = 0;
@@ -621,7 +612,9 @@ void git_reference_iterator_free(git_reference_iterator *iter)
 
 static int cb__reflist_add(const char *ref, void *data)
 {
-	return git_vector_insert((git_vector *)data, git__strdup(ref));
+	char *name = git__strdup(ref);
+	GITERR_CHECK_ALLOC(name);
+	return git_vector_insert((git_vector *)data, name);
 }
 
 int git_reference_list(
@@ -644,8 +637,8 @@ int git_reference_list(
 		return -1;
 	}
 
-	array->strings = (char **)ref_list.contents;
-	array->count = ref_list.length;
+	array->strings = (char **)git_vector_detach(&array->count, NULL, &ref_list);
+
 	return 0;
 }
 
diff --git a/src/remote.c b/src/remote.c
index 93d243001..307306d1a 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -251,14 +251,12 @@ int git_remote_create_inmemory(git_remote **out, git_repository *repo, const cha
 struct refspec_cb_data {
 	git_remote *remote;
 	int fetch;
-	git_error_state error;
 };
 
 static int refspec_cb(const git_config_entry *entry, void *payload)
 {
 	struct refspec_cb_data *data = (struct refspec_cb_data *)payload;
-	return giterr_capture(
-		&data->error, add_refspec(data->remote, entry->value, data->fetch));
+	return add_refspec(data->remote, entry->value, data->fetch);
 }
 
 static int get_optional_config(
@@ -316,17 +314,15 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	if ((error = get_check_cert(&remote->check_cert, repo)) < 0)
 		goto cleanup;
 
-	if ((git_vector_init(&remote->refs, 32, NULL) < 0) ||
-	    (git_vector_init(&remote->refspecs, 2, NULL) < 0) ||
-	    (git_vector_init(&remote->active_refspecs, 2, NULL) < 0)) {
+	if (git_vector_init(&remote->refs, 32, NULL) < 0 ||
+	    git_vector_init(&remote->refspecs, 2, NULL) < 0 ||
+	    git_vector_init(&remote->active_refspecs, 2, NULL) < 0) {
 		error = -1;
 		goto cleanup;
 	}
 
-	if (git_buf_printf(&buf, "remote.%s.url", name) < 0) {
-		error = -1;
+	if ((error = git_buf_printf(&buf, "remote.%s.url", name)) < 0)
 		goto cleanup;
-	}
 
 	if ((error = get_optional_config(&found, config, &buf, NULL, (void *)&val)) < 0)
 		goto cleanup;
@@ -387,9 +383,6 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 cleanup:
 	git_buf_free(&buf);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
-
 	if (error < 0)
 		git_remote_free(remote);
 
@@ -636,7 +629,7 @@ int git_remote_connect(git_remote *remote, git_direction direction)
 	if (!remote->check_cert)
 		flags |= GIT_TRANSPORTFLAGS_NO_CHECK_CERT;
 
-	if ((error = t->connect(t, url, remote->callbacks.credentials, remote->callbacks.payload, direction, flags)) < 0)
+	if ((error = t->connect(t, url, remote->callbacks.credentials, remote->callbacks.payload, direction, flags)) != 0)
 		goto on_error;
 
 	remote->transport = t;
@@ -788,7 +781,7 @@ int git_remote_download(git_remote *remote)
 	git_vector_free(&refs);
 
 	if (error < 0)
-		return -1;
+		return error;
 
 	if ((error = git_fetch_negotiate(remote)) < 0)
 		return error;
@@ -801,10 +794,10 @@ int git_remote_fetch(git_remote *remote)
 	int error;
 
 	/* Connect and download everything */
-	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH)) < 0)
+	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH)) != 0)
 		return error;
 
-	if ((error = git_remote_download(remote)) < 0)
+	if ((error = git_remote_download(remote)) != 0)
 		return error;
 
 	/* We don't need to be connected anymore */
@@ -1032,7 +1025,6 @@ int git_remote_update_tips(git_remote *remote)
 	int error;
 	size_t i;
 
-
 	if (git_refspec__parse(&tagspec, GIT_REFSPEC_TAGS, true) < 0)
 		return -1;
 
@@ -1112,14 +1104,9 @@ void git_remote_free(git_remote *remote)
 	git__free(remote);
 }
 
-struct remote_list_data {
-	git_vector list;
-	git_error_state error;
-};
-
 static int remote_list_cb(const git_config_entry *entry, void *payload)
 {
-	struct remote_list_data *data = payload;
+	git_vector *list = payload;
 	const char *name = entry->name + strlen("remote.");
 	size_t namelen = strlen(name);
 	char *remote_name;
@@ -1130,42 +1117,35 @@ static int remote_list_cb(const git_config_entry *entry, void *payload)
 		remote_name = git__strndup(name, namelen - 4); /* strip ".url" */
 	else
 		remote_name = git__strndup(name, namelen - 8); /* strip ".pushurl" */
-	if (!remote_name)
-		return giterr_capture(&data->error, -1);
+	GITERR_CHECK_ALLOC(remote_name);
 
-	return giterr_capture(
-		&data->error, git_vector_insert(&data->list, remote_name));
+	return git_vector_insert(list, remote_name);
 }
 
 int git_remote_list(git_strarray *remotes_list, git_repository *repo)
 {
 	int error;
 	git_config *cfg;
-	struct remote_list_data data;
+	git_vector list = GIT_VECTOR_INIT;
 
 	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
 		return error;
 
-	memset(&data, 0, sizeof(data));
-	if ((error = git_vector_init(&data.list, 4, git__strcmp_cb)) < 0)
+	if ((error = git_vector_init(&list, 4, git__strcmp_cb)) < 0)
 		return error;
 
 	error = git_config_foreach_match(
-		cfg, "^remote\\..*\\.(push)?url$", remote_list_cb, &data);
-
-	/* cb error is converted to GIT_EUSER by git_config_foreach */
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
+		cfg, "^remote\\..*\\.(push)?url$", remote_list_cb, &list);
 
 	if (error < 0) {
-		git_vector_free_all(&data.list);
+		git_vector_free_all(&list);
 		return error;
 	}
 
-	git_vector_uniq(&data.list, git__free);
+	git_vector_uniq(&list, git__free);
 
-	remotes_list->strings = (char **)data.list.contents;
-	remotes_list->count = data.list.length;
+	remotes_list->strings =
+		(char **)git_vector_detach(&remotes_list->count, NULL, &list);
 
 	return 0;
 }
@@ -1256,7 +1236,6 @@ struct update_data {
 	git_config *config;
 	const char *old_remote_name;
 	const char *new_remote_name;
-	git_error_state error;
 };
 
 static int update_config_entries_cb(
@@ -1268,9 +1247,8 @@ static int update_config_entries_cb(
 	if (strcmp(entry->value, data->old_remote_name))
 		return 0;
 
-	return giterr_capture(
-		&data->error, git_config_set_string(
-			data->config, entry->name, data->new_remote_name));
+	return git_config_set_string(
+		data->config, entry->name, data->new_remote_name);
 }
 
 static int update_branch_remote_config_entry(
@@ -1287,13 +1265,8 @@ static int update_branch_remote_config_entry(
 	data.old_remote_name = old_name;
 	data.new_remote_name = new_name;
 
-	error = git_config_foreach_match(
+	return git_config_foreach_match(
 		data.config, "branch\\..+\\.remote", update_config_entries_cb, &data);
-
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
-
-	return error;
 }
 
 static int rename_one_remote_reference(
@@ -1357,13 +1330,14 @@ static int rename_fetch_refspecs(
 	git_buf base = GIT_BUF_INIT, var = GIT_BUF_INIT, val = GIT_BUF_INIT;
 	const git_refspec *spec;
 	size_t i;
-	int error = -1;
-
-	if (git_buf_printf(&base, "+refs/heads/*:refs/remotes/%s/*", remote->name) < 0)
-		goto cleanup;
+	int error = 0;
 
 	if ((error = git_repository_config__weakptr(&config, remote->repo)) < 0)
-		goto cleanup;
+		return error;
+
+	if ((error = git_buf_printf(
+			&base, "+refs/heads/*:refs/remotes/%s/*", remote->name)) < 0)
+		return error;
 
 	git_vector_foreach(&remote->refspecs, i, spec) {
 		if (spec->push)
@@ -1374,10 +1348,9 @@ static int rename_fetch_refspecs(
 		if (!remote->name ||
 			strcmp(git_buf_cstr(&base), spec->string)) {
 
-			if (callback(spec->string, payload) < 0) {
-				error = giterr_user_cancel();
-				goto cleanup;
-			}
+			error = GITERR_CALLBACK( callback(spec->string, payload) );
+			if (error)
+				break;
 			continue;
 		}
 
@@ -1391,15 +1364,14 @@ static int rename_fetch_refspecs(
 			git_buf_printf(&var, "remote.%s.fetch", new_name) < 0)
 		{
 			error = -1;
-			goto cleanup;
+			break;
 		}
 
 		if ((error = git_config_set_string(
 				config, git_buf_cstr(&var), git_buf_cstr(&val))) < 0)
-			goto cleanup;
+			break;
 	}
 
-cleanup:
 	git_buf_free(&base);
 	git_buf_free(&var);
 	git_buf_free(&val);
diff --git a/src/repository.c b/src/repository.c
index 443744504..94f6603aa 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1608,15 +1608,14 @@ static int at_least_one_cb(const char *refname, void *payload)
 {
 	GIT_UNUSED(refname);
 	GIT_UNUSED(payload);
-
-	return GIT_EUSER;
+	return GIT_PASSTHROUGH;
 }
 
 static int repo_contains_no_reference(git_repository *repo)
 {
 	int error = git_reference_foreach_name(repo, &at_least_one_cb, NULL);
 
-	if (error == GIT_EUSER)
+	if (error == GIT_PASSTHROUGH)
 		return 0;
 
 	if (!error)
diff --git a/src/revwalk.c b/src/revwalk.c
index e8c7f23ec..c0a053211 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -169,15 +169,12 @@ static int push_ref(git_revwalk *walk, const char *refname, int hide)
 struct push_cb_data {
 	git_revwalk *walk;
 	int hide;
-	git_error_state error;
 };
 
 static int push_glob_cb(const char *refname, void *data_)
 {
 	struct push_cb_data *data = (struct push_cb_data *)data_;
-
-	return giterr_capture(
-		&data->error, push_ref(data->walk, refname, data->hide) );
+	return push_ref(data->walk, refname, data->hide);
 }
 
 static int push_glob(git_revwalk *walk, const char *glob, int hide)
@@ -204,12 +201,9 @@ static int push_glob(git_revwalk *walk, const char *glob, int hide)
 
 	data.walk = walk;
 	data.hide = hide;
-	memset(&data.error, 0, sizeof(data.error));
 
 	error = git_reference_foreach_glob(
 		walk->repo, git_buf_cstr(&buf), push_glob_cb, &data);
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
 
 	git_buf_free(&buf);
 	return error;
diff --git a/src/stash.c b/src/stash.c
index 06a7b9a33..458a1e175 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -440,7 +440,7 @@ static int is_dirty_cb(const char *path, unsigned int status, void *payload)
 	GIT_UNUSED(status);
 	GIT_UNUSED(payload);
 
-	return 1;
+	return GIT_PASSTHROUGH;
 }
 
 static int ensure_there_are_changes_to_stash(
@@ -463,7 +463,7 @@ static int ensure_there_are_changes_to_stash(
 
 	error = git_status_foreach_ext(repo, &opts, is_dirty_cb, NULL);
 
-	if (error == GIT_EUSER)
+	if (error == GIT_PASSTHROUGH)
 		return 0;
 
 	if (!error)
@@ -582,13 +582,13 @@ int git_stash_foreach(
 	for (i = 0; i < max; i++) {
 		entry = git_reflog_entry_byindex(reflog, i);
 
-		if (callback(i,
-			git_reflog_entry_message(entry),
-			git_reflog_entry_id_new(entry),
-			payload)) {
-			error = giterr_user_cancel();
+		error = GITERR_CALLBACK(
+			callback(i,
+				git_reflog_entry_message(entry),
+				git_reflog_entry_id_new(entry),
+				payload) );
+		if (error)
 			break;
-		}
 	}
 
 cleanup:
diff --git a/src/status.c b/src/status.c
index ce571a2d8..d76617a72 100644
--- a/src/status.c
+++ b/src/status.c
@@ -152,32 +152,25 @@ static git_status_t status_compute(
 	return st;
 }
 
-struct status_data {
-	git_status_list *status;
-	git_error_state err;
-};
-
 static int status_collect(
 	git_diff_delta *head2idx,
 	git_diff_delta *idx2wd,
 	void *payload)
 {
-	struct status_data *data = payload;
+	git_status_list *status = payload;
 	git_status_entry *status_entry;
 
-	if (!status_is_included(data->status, head2idx, idx2wd))
+	if (!status_is_included(status, head2idx, idx2wd))
 		return 0;
 
 	status_entry = git__malloc(sizeof(git_status_entry));
-	if (!status_entry)
-		return giterr_capture(&data->err, -1);
+	GITERR_CHECK_ALLOC(status_entry);
 
-	status_entry->status = status_compute(data->status, head2idx, idx2wd);
+	status_entry->status = status_compute(status, head2idx, idx2wd);
 	status_entry->head_to_index = head2idx;
 	status_entry->index_to_workdir = idx2wd;
 
-	return giterr_capture(
-		&data->err, git_vector_insert(&data->status->paired, status_entry));
+	return git_vector_insert(&status->paired, status_entry);
 }
 
 GIT_INLINE(int) status_entry_cmp_base(
@@ -321,18 +314,10 @@ int git_status_list_new(
 			goto done;
 	}
 
-	{
-		struct status_data data = { 0 };
-		data.status = status;
-
-		error = git_diff__paired_foreach(
-			status->head2idx, status->idx2wd, status_collect, &data);
-
-		if (error == GIT_EUSER)
-			error = giterr_restore(&data.err);
-		if (error < 0)
-			goto done;
-	}
+	error = git_diff__paired_foreach(
+		status->head2idx, status->idx2wd, status_collect, status);
+	if (error < 0)
+		goto done;
 
 	if (flags & GIT_STATUS_OPT_SORT_CASE_SENSITIVELY)
 		git_vector_set_cmp(&status->paired, status_entry_cmp);
@@ -407,10 +392,9 @@ int git_status_foreach_ext(
 			status_entry->head_to_index->old_file.path :
 			status_entry->index_to_workdir->old_file.path;
 
-		if (cb(path, status_entry->status, payload) != 0) {
-			error = giterr_user_cancel();
+		error = GITERR_CALLBACK( cb(path, status_entry->status, payload) );
+		if (error)
 			break;
-		}
 	}
 
 	git_status_list_free(status);
diff --git a/src/submodule.c b/src/submodule.c
index 15c87c0b4..e9d534ae8 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -71,11 +71,6 @@ __KHASH_IMPL(
 	str, static kh_inline, const char *, void *, 1,
 	str_hash_no_trailing_slash, str_equal_no_trailing_slash);
 
-struct submodule_callback_payload {
-	git_repository *repo;
-	git_error_state error;
-};
-
 static int load_submodule_config(git_repository *repo);
 static git_config_backend *open_gitmodules(git_repository *, bool, const git_oid *);
 static int lookup_head_remote(git_buf *url, git_repository *repo);
@@ -173,10 +168,8 @@ int git_submodule_foreach(
 				break;
 		}
 
-		if (callback(sm, sm->name, payload)) {
-			error = giterr_user_cancel();
+		if ((error = GITERR_CALLBACK(callback(sm, sm->name, payload))) != 0)
 			break;
-		}
 	});
 
 	git_vector_free(&seen);
@@ -825,7 +818,6 @@ int git_submodule_reload(git_submodule *submodule)
 {
 	int error = 0;
 	git_config_backend *mods;
-	struct submodule_callback_payload p;
 
 	assert(submodule);
 
@@ -838,9 +830,6 @@ int git_submodule_reload(git_submodule *submodule)
 		return error;
 
 	/* refresh config data */
-	memset(&p, 0, sizeof(p));
-	p.repo = submodule->repo;
-
 	mods = open_gitmodules(submodule->repo, false, NULL);
 	if (mods != NULL) {
 		git_buf path = GIT_BUF_INIT;
@@ -851,13 +840,9 @@ int git_submodule_reload(git_submodule *submodule)
 
 		if (git_buf_oom(&path))
 			error = -1;
-		else {
+		else
 			error = git_config_file_foreach_match(
-				mods, path.ptr, submodule_load_from_config, &p);
-
-			if (error == GIT_EUSER)
-				error = giterr_restore(&p.error);
-		}
+				mods, path.ptr, submodule_load_from_config, submodule->repo);
 
 		git_buf_free(&path);
 		git_config_file_free(mods);
@@ -867,15 +852,11 @@ int git_submodule_reload(git_submodule *submodule)
 	}
 
 	/* refresh wd data */
-
 	submodule->flags = submodule->flags &
 		~(GIT_SUBMODULE_STATUS_IN_WD | GIT_SUBMODULE_STATUS__WD_OID_VALID);
 
-	error = submodule_load_from_wd_lite(submodule, submodule->path, &p);
-	if (error)
-		error = giterr_restore(&p.error);
-
-	return error;
+	return submodule_load_from_wd_lite(
+		submodule, submodule->path, submodule->repo);
 }
 
 static void submodule_copy_oid_maybe(
@@ -1100,8 +1081,8 @@ int git_submodule_parse_update(git_submodule_update_t *out, const char *value)
 static int submodule_load_from_config(
 	const git_config_entry *entry, void *payload)
 {
-	struct submodule_callback_payload *p = payload;
-	git_strmap *smcfg = p->repo->submodules;
+	git_repository *repo = payload;
+	git_strmap *smcfg = repo->submodules;
 	const char *namestart, *property, *alternate = NULL;
 	const char *key = entry->name, *value = entry->value, *path;
 	git_buf name = GIT_BUF_INIT;
@@ -1121,7 +1102,7 @@ static int submodule_load_from_config(
 	path = !strcasecmp(property, "path") ? value : NULL;
 
 	if ((error = git_buf_set(&name, namestart, property - namestart - 1)) < 0 ||
-		(error = submodule_get(&sm, p->repo, name.ptr, path)) < 0)
+		(error = submodule_get(&sm, repo, name.ptr, path)) < 0)
 		goto done;
 
 	sm->flags |= GIT_SUBMODULE_STATUS_IN_CONFIG;
@@ -1197,22 +1178,21 @@ static int submodule_load_from_config(
 
 done:
 	git_buf_free(&name);
-	return giterr_capture(&p->error, error);
+	return error;
 }
 
 static int submodule_load_from_wd_lite(
 	git_submodule *sm, const char *name, void *payload)
 {
-	struct submodule_callback_payload *p = payload;
 	git_buf path = GIT_BUF_INIT;
 
-	GIT_UNUSED(name);
+	GIT_UNUSED(name); GIT_UNUSED(payload);
 
 	if (git_repository_is_bare(sm->repo))
 		return 0;
 
 	if (git_buf_joinpath(&path, git_repository_workdir(sm->repo), sm->path) < 0)
-		return giterr_capture(&p->error, -1);
+		return -1;
 
 	if (git_path_isdir(path.ptr))
 		sm->flags |= GIT_SUBMODULE_STATUS__WD_SCANNED;
@@ -1355,14 +1335,11 @@ static int load_submodule_config(git_repository *repo)
 	int error;
 	git_oid gitmodules_oid;
 	git_config_backend *mods = NULL;
-	struct submodule_callback_payload p;
 
 	if (repo->submodules)
 		return 0;
 
 	memset(&gitmodules_oid, 0, sizeof(gitmodules_oid));
-	memset(&p, 0, sizeof(p));
-	p.repo = repo;
 
 	/* Submodule data is kept in a hashtable keyed by both name and path.
 	 * These are usually the same, but that is not guaranteed.
@@ -1386,21 +1363,18 @@ static int load_submodule_config(git_repository *repo)
 
 	if ((mods = open_gitmodules(repo, false, &gitmodules_oid)) != NULL &&
 		(error = git_config_file_foreach(
-			mods, submodule_load_from_config, &p)) < 0)
+			mods, submodule_load_from_config, repo)) < 0)
 		goto cleanup;
 
 	/* shallow scan submodules in work tree */
 
 	if (!git_repository_is_bare(repo))
-		error = git_submodule_foreach(repo, submodule_load_from_wd_lite, &p);
+		error = git_submodule_foreach(repo, submodule_load_from_wd_lite, NULL);
 
 cleanup:
 	if (mods != NULL)
 		git_config_file_free(mods);
 
-	if (error == GIT_EUSER)
-		error = giterr_restore(&p.error);
-
 	if (error)
 		git_submodule_config_free(repo);
 
diff --git a/src/tag.c b/src/tag.c
index 5d4e45e5d..adf2819d7 100644
--- a/src/tag.c
+++ b/src/tag.c
@@ -414,7 +414,6 @@ typedef struct {
 	git_repository *repo;
 	git_tag_foreach_cb cb;
 	void *cb_data;
-	git_error_state error;
 } tag_cb_data;
 
 static int tags_cb(const char *ref, void *data)
@@ -427,16 +426,15 @@ static int tags_cb(const char *ref, void *data)
 		return 0; /* no tag */
 
 	if (!(error = git_reference_name_to_id(&oid, d->repo, ref))) {
-		if (d->cb(ref, &oid, d->cb_data))
-			error = giterr_user_cancel();
+		error = d->cb(ref, &oid, d->cb_data);
+		giterr_set_callback(error, "git_tag_foreach");
 	}
 
-	return giterr_capture(&d->error, error);
+	return error;
 }
 
 int git_tag_foreach(git_repository *repo, git_tag_foreach_cb cb, void *cb_data)
 {
-	int error;
 	tag_cb_data data;
 
 	assert(repo && cb);
@@ -444,14 +442,8 @@ int git_tag_foreach(git_repository *repo, git_tag_foreach_cb cb, void *cb_data)
 	data.cb = cb;
 	data.cb_data = cb_data;
 	data.repo = repo;
-	memset(&data.error, 0, sizeof(data.error));
-
-	error = git_reference_foreach_name(repo, &tags_cb, &data);
-
-	if (error == GIT_EUSER)
-		error = giterr_restore(&data.error);
 
-	return error;
+	return git_reference_foreach_name(repo, &tags_cb, &data);
 }
 
 typedef struct {
@@ -470,8 +462,8 @@ static int tag_list_cb(const char *tag_name, git_oid *oid, void *data)
 		p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == 0)
 	{
 		char *matched = git__strdup(tag_name + GIT_REFS_TAGS_DIR_LEN);
-		if (!matched)
-			return -1;
+		GITERR_CHECK_ALLOC(matched);
+
 		return git_vector_insert(filter->taglist, matched);
 	}
 
@@ -494,19 +486,12 @@ int git_tag_list_match(git_strarray *tag_names, const char *pattern, git_reposit
 
 	error = git_tag_foreach(repo, &tag_list_cb, (void *)&filter);
 
-	/* the only case where callback will return an error is oom */
-	if (error == GIT_EUSER) {
-		giterr_set_oom();
-		error = -1;
-	}
-
-	if (error < 0) {
+	if (error < 0)
 		git_vector_free(&taglist);
-		return error;
-	}
 
-	tag_names->strings = (char **)taglist.contents;
-	tag_names->count = taglist.length;
+	tag_names->strings =
+		(char **)git_vector_detach(&tag_names->count, NULL, &taglist);
+
 	return 0;
 }
 
diff --git a/src/transports/http.c b/src/transports/http.c
index ace0d97d0..0e1bbf60d 100644
--- a/src/transports/http.c
+++ b/src/transports/http.c
@@ -382,9 +382,6 @@ static int on_body_fill_buffer(http_parser *parser, const char *str, size_t len)
 
 static void clear_parser_state(http_subtransport *t)
 {
-	unsigned i;
-	char *entry;
-
 	http_parser_init(&t->parser, HTTP_RESPONSE);
 	gitno_buffer_setup(&t->socket,
 		&t->parse_buffer,
@@ -407,10 +404,7 @@ static void clear_parser_state(http_subtransport *t)
 	git__free(t->location);
 	t->location = NULL;
 
-	git_vector_foreach(&t->www_authenticate, i, entry)
-		git__free(entry);
-
-	git_vector_free(&t->www_authenticate);
+	git_vector_free_all(&t->www_authenticate);
 }
 
 static int write_chunk(gitno_socket *socket, const char *buffer, size_t len)
diff --git a/src/transports/local.c b/src/transports/local.c
index f09e797ce..4635d5dd3 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -43,43 +43,43 @@ typedef struct {
 static int add_ref(transport_local *t, const char *name)
 {
 	const char peeled[] = "^{}";
+	git_oid head_oid;
 	git_remote_head *head;
 	git_object *obj = NULL, *target = NULL;
 	git_buf buf = GIT_BUF_INIT;
 	int error;
 
-	head = git__calloc(1, sizeof(git_remote_head));
-	GITERR_CHECK_ALLOC(head);
-
-	head->name = git__strdup(name);
-	GITERR_CHECK_ALLOC(head->name);
-
-	error = git_reference_name_to_id(&head->oid, t->repo, name);
+	error = git_reference_name_to_id(&head_oid, t->repo, name);
 	if (error < 0) {
-		git__free(head->name);
-		git__free(head);
 		if (!strcmp(name, GIT_HEAD_FILE) && error == GIT_ENOTFOUND) {
-			/* This is actually okay.  Empty repos often have a HEAD that points to
-			 * a nonexistent "refs/heads/master". */
+			/* This is actually okay.  Empty repos often have a HEAD that
+			 * points to a nonexistent "refs/heads/master". */
 			giterr_clear();
 			return 0;
 		}
 		return error;
 	}
 
-	if (git_vector_insert(&t->refs, head) < 0)
-	{
+	head = git__calloc(1, sizeof(git_remote_head));
+	GITERR_CHECK_ALLOC(head);
+
+	head->name = git__strdup(name);
+	GITERR_CHECK_ALLOC(head->name);
+
+	git_oid_cpy(&head->oid, &head_oid);
+
+	if ((error = git_vector_insert(&t->refs, head)) < 0) {
 		git__free(head->name);
 		git__free(head);
-		return -1;
+		return error;
 	}
 
 	/* If it's not a tag, we don't need to try to peel it */
 	if (git__prefixcmp(name, GIT_REFS_TAGS_DIR))
 		return 0;
 
-	if (git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY) < 0)
-		return -1;
+	if ((error = git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY)) < 0)
+		return error;
 
 	head = NULL;
 
@@ -94,27 +94,24 @@ static int add_ref(transport_local *t, const char *name)
 	/* And if it's a tag, peel it, and add it to the list */
 	head = git__calloc(1, sizeof(git_remote_head));
 	GITERR_CHECK_ALLOC(head);
+
 	if (git_buf_join(&buf, 0, name, peeled) < 0)
 		return -1;
-
 	head->name = git_buf_detach(&buf);
 
-	if (git_tag_peel(&target, (git_tag *) obj) < 0)
-		goto on_error;
+	if (!(error = git_tag_peel(&target, (git_tag *)obj))) {
+		git_oid_cpy(&head->oid, git_object_id(target));
 
-	git_oid_cpy(&head->oid, git_object_id(target));
-	git_object_free(obj);
-	git_object_free(target);
-
-	if (git_vector_insert(&t->refs, head) < 0)
-		return -1;
-
-	return 0;
+		if ((error = git_vector_insert(&t->refs, head)) < 0) {
+			git__free(head->name);
+			git__free(head);
+		}
+	}
 
-on_error:
 	git_object_free(obj);
 	git_object_free(target);
-	return -1;
+
+	return error;
 }
 
 static int store_refs(transport_local *t)
@@ -222,7 +219,7 @@ static int local_ls(const git_remote_head ***out, size_t *size, git_transport *t
 		return -1;
 	}
 
-	*out = (const git_remote_head **) t->refs.contents;
+	*out = (const git_remote_head **)t->refs.contents;
 	*size = t->refs.length;
 
 	return 0;
@@ -529,7 +526,7 @@ static int local_download_pack(
 		}
 	}
 
-	if ((error = git_odb_write_pack(&writepack, odb, progress_cb, progress_payload)) < 0)
+	if ((error = git_odb_write_pack(&writepack, odb, progress_cb, progress_payload)) != 0)
 		goto cleanup;
 
 	/* Write the data to the ODB */
@@ -540,7 +537,7 @@ static int local_download_pack(
 		data.progress_payload = progress_payload;
 		data.writepack = writepack;
 
-		if ((error = git_packbuilder_foreach(pack, foreach_cb, &data)) < 0)
+		if ((error = git_packbuilder_foreach(pack, foreach_cb, &data)) != 0)
 			goto cleanup;
 	}
 	error = writepack->commit(writepack, stats);
diff --git a/src/transports/smart.c b/src/transports/smart.c
index e298f3510..69eaf9b78 100644
--- a/src/transports/smart.c
+++ b/src/transports/smart.c
@@ -23,12 +23,13 @@ static int git_smart__recv_cb(gitno_buffer *buf)
 
 	buf->offset += bytes_read;
 
-	if (t->packetsize_cb && !t->cancelled.val)
-		if (t->packetsize_cb(bytes_read, t->packetsize_payload)) {
+	if (t->packetsize_cb && !t->cancelled.val) {
+		error = t->packetsize_cb(bytes_read, t->packetsize_payload);
+		if (error) {
 			git_atomic_set(&t->cancelled, 1);
-
-			return giterr_user_cancel();
+			return GIT_EUSER;
 		}
+	}
 
 	return (int)(buf->offset - old_len);
 }
@@ -341,7 +342,7 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param)
 	t->parent.is_connected = git_smart__is_connected;
 	t->parent.read_flags = git_smart__read_flags;
 	t->parent.cancel = git_smart__cancel;
-	
+
 	t->owner = owner;
 	t->rpc = definition->rpc;
 
@@ -358,7 +359,7 @@ int git_transport_smart(git_transport **out, git_remote *owner, void *param)
 	if (definition->callback(&t->wrapped, &t->parent) < 0) {
 		git__free(t);
 		return -1;
-	}	
+	}
 
 	*out = (git_transport *) t;
 	return 0;
diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index a4046ee43..dd9b5e0ed 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -45,7 +45,7 @@ int git_smart__store_refs(transport_smart *t, int flushes)
 			error = GIT_EBUFS;
 
 		if (error < 0 && error != GIT_EBUFS)
-			return -1;
+			return error;
 
 		if (error == GIT_EBUFS) {
 			if ((recvd = gitno_recv(buf)) < 0)
@@ -209,12 +209,13 @@ static int fetch_setup_walk(git_revwalk **out, git_repository *repo)
 	git_strarray refs;
 	unsigned int i;
 	git_reference *ref;
+	int error;
 
-	if (git_reference_list(&refs, repo) < 0)
-		return -1;
+	if ((error = git_reference_list(&refs, repo)) < 0)
+		return error;
 
-	if (git_revwalk_new(&walk, repo) < 0)
-		return -1;
+	if ((error = git_revwalk_new(&walk, repo)) < 0)
+		return error;
 
 	git_revwalk_sorting(walk, GIT_SORT_TIME);
 
@@ -223,13 +224,13 @@ static int fetch_setup_walk(git_revwalk **out, git_repository *repo)
 		if (!git__prefixcmp(refs.strings[i], GIT_REFS_TAGS_DIR))
 			continue;
 
-		if (git_reference_lookup(&ref, repo, refs.strings[i]) < 0)
+		if ((error = git_reference_lookup(&ref, repo, refs.strings[i])) < 0)
 			goto on_error;
 
 		if (git_reference_type(ref) == GIT_REF_SYMBOLIC)
 			continue;
 
-		if (git_revwalk_push(walk, git_reference_target(ref)) < 0)
+		if ((error = git_revwalk_push(walk, git_reference_target(ref))) < 0)
 			goto on_error;
 
 		git_reference_free(ref);
@@ -242,7 +243,7 @@ static int fetch_setup_walk(git_revwalk **out, git_repository *repo)
 on_error:
 	git_reference_free(ref);
 	git_strarray_free(&refs);
-	return -1;
+	return error;
 }
 
 static int wait_while_ack(gitno_buffer *buf)
@@ -503,7 +504,7 @@ int git_smart__download_pack(
 	}
 
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
-		((error = git_odb_write_pack(&writepack, odb, progress_cb, progress_payload)) < 0))
+		((error = git_odb_write_pack(&writepack, odb, progress_cb, progress_payload)) != 0))
 		goto done;
 
 	/*
@@ -539,11 +540,9 @@ int git_smart__download_pack(
 		if (pkt->type == GIT_PKT_PROGRESS) {
 			if (t->progress_cb) {
 				git_pkt_progress *p = (git_pkt_progress *) pkt;
-				if (t->progress_cb(p->data, p->len, t->message_cb_payload)) {
-					giterr_clear();
-					error = GIT_EUSER;
+				error = t->progress_cb(p->data, p->len, t->message_cb_payload);
+				if (error)
 					goto done;
-				}
 			}
 			git__free(pkt);
 		} else if (pkt->type == GIT_PKT_DATA) {
@@ -551,7 +550,7 @@ int git_smart__download_pack(
 			error = writepack->append(writepack, p->data, p->len, stats);
 
 			git__free(pkt);
-			if (error < 0)
+			if (error != 0)
 				goto done;
 		} else if (pkt->type == GIT_PKT_FLUSH) {
 			/* A flush indicates the end of the packfile */
@@ -564,17 +563,15 @@ int git_smart__download_pack(
 	 * Trailing execution of progress_cb, if necessary...
 	 * Only the callback through the npp datastructure currently
 	 * updates the last_fired_bytes value. It is possible that
-	 * progress has already been reported with the correct 
+	 * progress has already been reported with the correct
 	 * "received_bytes" value, but until (if?) this is unified
 	 * then we will report progress again to be sure that the
 	 * correct last received_bytes value is reported.
 	 */
 	if (npp.callback && npp.stats->received_bytes > npp.last_fired_bytes) {
-		if (npp.callback(npp.stats, npp.payload) < 0) {
-			giterr_clear();
-			error = GIT_EUSER;
+		error = npp.callback(npp.stats, npp.payload);
+		if (error != 0)
 			goto done;
-		}
 	}
 
 	error = writepack->commit(writepack, stats);
diff --git a/src/transports/winhttp.c b/src/transports/winhttp.c
index 673cd0faf..e47e19cca 100644
--- a/src/transports/winhttp.c
+++ b/src/transports/winhttp.c
@@ -667,9 +667,11 @@ replay:
 			if (allowed_types &&
 				(!t->cred || 0 == (t->cred->credtype & allowed_types))) {
 
-				if (t->owner->cred_acquire_cb(&t->cred, t->owner->url, t->connection_data.user, allowed_types, 
-					t->owner->cred_acquire_payload) < 0)
-					return GIT_EUSER;
+				int error = t->owner->cred_acquire_cb(
+					&t->cred, t->owner->url, t->connection_data.user,
+					allowed_types, t->owner->cred_acquire_payload);
+				if (error < 0)
+					return error;
 
 				assert(t->cred);
 
diff --git a/src/tree.c b/src/tree.c
index 8ded007eb..5f35ac3a8 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -883,9 +883,8 @@ static int tree_walk(
 
 	git_vector_foreach(&tree->entries, i, entry) {
 		if (preorder) {
-			error = callback(path->ptr, entry, payload);
-			if (error < 0)
-				return giterr_user_cancel();
+			if ((error = callback(path->ptr, entry, payload)) < 0)
+				return giterr_set_callback(error, "git_tree_walk");
 			if (error > 0) {
 				error = 0;
 				continue;
@@ -896,8 +895,8 @@ static int tree_walk(
 			git_tree *subtree;
 			size_t path_len = git_buf_len(path);
 
-			if ((error = git_tree_lookup(
-				&subtree, tree->object.repo, &entry->oid)) < 0)
+			error = git_tree_lookup(&subtree, tree->object.repo, &entry->oid);
+			if (error < 0)
 				break;
 
 			/* append the next entry to the path */
@@ -905,19 +904,22 @@ static int tree_walk(
 			git_buf_putc(path, '/');
 
 			if (git_buf_oom(path))
-				return -1;
+				error = -1;
+			else
+				error = tree_walk(subtree, callback, path, payload, preorder);
 
-			error = tree_walk(subtree, callback, path, payload, preorder);
 			git_tree_free(subtree);
-
 			if (error != 0)
 				break;
 
 			git_buf_truncate(path, path_len);
 		}
 
-		if (!preorder && callback(path->ptr, entry, payload) < 0)
-			return giterr_user_cancel();
+		if (!preorder) {
+			if ((error = callback(path->ptr, entry, payload)) < 0)
+				return giterr_set_callback(error, "git_tree_walk");
+			error = 0;
+		}
 	}
 
 	return error;
diff --git a/src/vector.c b/src/vector.c
index 9e217b831..b1ea89606 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -104,6 +104,22 @@ int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp)
 	return resize_vector(v, max(initial_size, MIN_ALLOCSIZE));
 }
 
+void **git_vector_detach(size_t *size, size_t *asize, git_vector *v)
+{
+	void **data = v->contents;
+
+	if (size)
+		*size = v->length;
+	if (asize)
+		*asize = v->_alloc_size;
+
+	v->_alloc_size = 0;
+	v->length   = 0;
+	v->contents = NULL;
+
+	return data;
+}
+
 int git_vector_insert(git_vector *v, void *element)
 {
 	assert(v);
diff --git a/src/vector.h b/src/vector.h
index c6d3e9d55..defe22466 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -28,6 +28,8 @@ void git_vector_clear(git_vector *v);
 int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp);
 void git_vector_swap(git_vector *a, git_vector *b);
 
+void **git_vector_detach(size_t *size, size_t *asize, git_vector *v);
+
 void git_vector_sort(git_vector *v);
 
 /** Linear search for matching entry using internal comparison function */
diff --git a/tests/attr/repo.c b/tests/attr/repo.c
index ef2ad5ce9..f9ba585fb 100644
--- a/tests/attr/repo.c
+++ b/tests/attr/repo.c
@@ -129,6 +129,8 @@ static int count_attrs(
 	return 0;
 }
 
+#define CANCEL_VALUE 12345
+
 static int cancel_iteration(
 	const char *name,
 	const char *value,
@@ -140,7 +142,7 @@ static int cancel_iteration(
 	*((int *)payload) -= 1;
 
 	if (*((int *)payload) < 0)
-		return -1;
+		return CANCEL_VALUE;
 
 	return 0;
 }
@@ -166,7 +168,7 @@ void test_attr_repo__foreach(void)
 
 	count = 2;
 	cl_assert_equal_i(
-		GIT_EUSER, git_attr_foreach(
+		CANCEL_VALUE, git_attr_foreach(
 			g_repo, 0, "sub/subdir_test1", &cancel_iteration, &count)
 	);
 }
diff --git a/tests/config/read.c b/tests/config/read.c
index abc088d59..25672729f 100644
--- a/tests/config/read.c
+++ b/tests/config/read.c
@@ -247,7 +247,7 @@ void test_config_read__foreach(void)
 
 	count = 3;
 	cl_git_fail(ret = git_config_foreach(cfg, cfg_callback_countdown, &count));
-	cl_assert_equal_i(GIT_EUSER, ret);
+	cl_assert_equal_i(-100, ret);
 
 	git_config_free(cfg);
 }
diff --git a/tests/config/rename.c b/tests/config/rename.c
index 29ade7b00..db07c798f 100644
--- a/tests/config/rename.c
+++ b/tests/config/rename.c
@@ -44,7 +44,6 @@ void test_config_rename__can_rename(void)
 void test_config_rename__prevent_overwrite(void)
 {
 	const git_config_entry *ce;
-	const git_error *err;
 
 	cl_git_pass(git_config_set_string(
 		g_config, "branch.local-track.remote", "yellow"));
@@ -60,8 +59,12 @@ void test_config_rename__prevent_overwrite(void)
 		&ce, g_config, "branch.local-track.remote"));
 	cl_assert_equal_s(".", ce->value);
 
-//	cl_assert((err = giterr_last()) != NULL);
-//	cl_assert(err->message != NULL);
+	/* so, we don't currently prevent overwrite... */
+	/* {
+		const git_error *err;
+		cl_assert((err = giterr_last()) != NULL);
+		cl_assert(err->message != NULL);
+	} */
 }
 
 static void assert_invalid_config_section_name(
diff --git a/tests/core/path.c b/tests/core/path.c
index 3858e30dd..471491b87 100644
--- a/tests/core/path.c
+++ b/tests/core/path.c
@@ -354,13 +354,15 @@ typedef struct {
 	char **expect;
 } check_walkup_info;
 
+#define CANCEL_VALUE 1234
+
 static int check_one_walkup_step(void *ref, git_buf *path)
 {
 	check_walkup_info *info = (check_walkup_info *)ref;
 
 	if (!info->cancel_after) {
 		cl_assert_equal_s(info->expect[info->expect_idx], "[CANCEL]");
-		return -1;
+		return CANCEL_VALUE;
 	}
 	info->cancel_after--;
 
@@ -435,7 +437,7 @@ void test_core_path__11a_walkup_cancel(void)
 		info.expect_idx = i;
 
 		cl_assert_equal_i(
-			GIT_EUSER,
+			CANCEL_VALUE,
 			git_path_walk_up(&p, root[j], check_one_walkup_step, &info)
 		);
 
diff --git a/tests/diff/index.c b/tests/diff/index.c
index 8f4567137..21afe8da2 100644
--- a/tests/diff/index.c
+++ b/tests/diff/index.c
@@ -128,9 +128,7 @@ void test_diff_index__1(void)
 	cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
 
 	cl_assert_equal_i(
-		GIT_EUSER,
-		git_diff_foreach(diff, diff_stop_after_2_files, NULL, NULL, &exp)
-	);
+		1, git_diff_foreach(diff, diff_stop_after_2_files, NULL, NULL, &exp) );
 
 	cl_assert_equal_i(2, exp.files);
 
diff --git a/tests/diff/notify.c b/tests/diff/notify.c
index cc33cb71c..f6accd004 100644
--- a/tests/diff/notify.c
+++ b/tests/diff/notify.c
@@ -20,7 +20,7 @@ static int assert_called_notifications(
 {
 	bool found = false;
 	notify_expected *exp = (notify_expected*)payload;
-	notify_expected *e;;
+	notify_expected *e;
 
 	GIT_UNUSED(diff_so_far);
 
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index ca6d076d6..93e69f479 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -111,6 +111,28 @@ void test_diff_rename__match_oid(void)
 
 	git_diff_free(diff);
 
+	cl_git_pass(git_diff_tree_to_tree(
+		&diff, g_repo, old_tree, new_tree, &diffopts));
+
+	/* git diff --find-copies-harder -M100 -B100 \
+	 *          31e47d8c1fa36d7f8d537b96158e3f024de0a9f2 \
+	 *          2bc7f351d20b53f1c72c16c4b036e491c478c49a
+	 */
+	opts.flags = GIT_DIFF_FIND_COPIES_FROM_UNMODIFIED |
+		GIT_DIFF_FIND_EXACT_MATCH_ONLY;
+	cl_git_pass(git_diff_find_similar(diff, &opts));
+
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_foreach(
+		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+
+	cl_assert_equal_i(3, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNMODIFIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_COPIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_RENAMED]);
+
+	git_diff_free(diff);
+
 	git_tree_free(old_tree);
 	git_tree_free(new_tree);
 }
diff --git a/tests/notes/notes.c b/tests/notes/notes.c
index 82dcaf8ca..c2579a2c4 100644
--- a/tests/notes/notes.c
+++ b/tests/notes/notes.c
@@ -129,7 +129,7 @@ void test_notes_notes__can_cancel_foreach(void)
 	create_note(&note_oid4, "refs/notes/i-can-see-dead-notes", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "I decorate 9fd7 and 4a20\n");
 
 	cl_assert_equal_i(
-		GIT_EUSER,
+		1,
 		git_note_foreach(_repo, "refs/notes/i-can-see-dead-notes",
 			note_cancel_cb, &retrieved_notes));
 }
diff --git a/tests/object/tree/walk.c b/tests/object/tree/walk.c
index 1207e864c..f8005e579 100644
--- a/tests/object/tree/walk.c
+++ b/tests/object/tree/walk.c
@@ -59,7 +59,7 @@ static int treewalk_stop_cb(
 
 	(*count) += 1;
 
-	return (*count == 2) ? -1 : 0;
+	return (*count == 2) ? -123 : 0;
 }
 
 static int treewalk_stop_immediately_cb(
@@ -83,20 +83,20 @@ void test_object_tree_walk__1(void)
 
 	ct = 0;
 	cl_assert_equal_i(
-		GIT_EUSER, git_tree_walk(tree, GIT_TREEWALK_PRE, treewalk_stop_cb, &ct));
+		-123, git_tree_walk(tree, GIT_TREEWALK_PRE, treewalk_stop_cb, &ct));
 	cl_assert_equal_i(2, ct);
 
 	ct = 0;
 	cl_assert_equal_i(
-		GIT_EUSER, git_tree_walk(tree, GIT_TREEWALK_POST, treewalk_stop_cb, &ct));
+		-123, git_tree_walk(tree, GIT_TREEWALK_POST, treewalk_stop_cb, &ct));
 	cl_assert_equal_i(2, ct);
 
 	cl_assert_equal_i(
-		GIT_EUSER, git_tree_walk(
+		-100, git_tree_walk(
 			tree, GIT_TREEWALK_PRE, treewalk_stop_immediately_cb, NULL));
 
 	cl_assert_equal_i(
-		GIT_EUSER, git_tree_walk(
+		-100, git_tree_walk(
 			tree, GIT_TREEWALK_POST, treewalk_stop_immediately_cb, NULL));
 
 	git_tree_free(tree);
@@ -152,7 +152,7 @@ void test_object_tree_walk__2(void)
 	memset(&data, 0, sizeof(data));
 	data.stop = "3.txt";
 
-	cl_assert_equal_i(GIT_EUSER, git_tree_walk(
+	cl_assert_equal_i(-1, git_tree_walk(
 		tree, GIT_TREEWALK_PRE, treewalk_skip_de_cb, &data));
 	cl_assert_equal_i(3, data.files);
 	cl_assert_equal_i(2, data.dirs);
@@ -168,7 +168,7 @@ void test_object_tree_walk__2(void)
 	memset(&data, 0, sizeof(data));
 	data.stop = "new.txt";
 
-	cl_assert_equal_i(GIT_EUSER, git_tree_walk(
+	cl_assert_equal_i(-1, git_tree_walk(
 		tree, GIT_TREEWALK_PRE, treewalk_skip_de_cb, &data));
 	cl_assert_equal_i(7, data.files);
 	cl_assert_equal_i(4, data.dirs);
diff --git a/tests/odb/foreach.c b/tests/odb/foreach.c
index ebb8866f7..256ae9cd7 100644
--- a/tests/odb/foreach.c
+++ b/tests/odb/foreach.c
@@ -5,7 +5,6 @@
 
 static git_odb *_odb;
 static git_repository *_repo;
-static int nobj;
 
 void test_odb_foreach__cleanup(void)
 {
@@ -18,10 +17,10 @@ void test_odb_foreach__cleanup(void)
 
 static int foreach_cb(const git_oid *oid, void *data)
 {
-	GIT_UNUSED(data);
-	GIT_UNUSED(oid);
+	int *nobj = data;
+	(*nobj)++;
 
-	nobj++;
+	GIT_UNUSED(oid);
 
 	return 0;
 }
@@ -38,43 +37,46 @@ static int foreach_cb(const git_oid *oid, void *data)
  */
 void test_odb_foreach__foreach(void)
 {
+	int nobj = 0;
+
 	cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
 	git_repository_odb(&_odb, _repo);
 
-	cl_git_pass(git_odb_foreach(_odb, foreach_cb, NULL));
+	cl_git_pass(git_odb_foreach(_odb, foreach_cb, &nobj));
 	cl_assert_equal_i(47 + 1640, nobj); /* count + in-pack */
 }
 
 void test_odb_foreach__one_pack(void)
 {
 	git_odb_backend *backend = NULL;
+	int nobj = 0;
 
 	cl_git_pass(git_odb_new(&_odb));
 	cl_git_pass(git_odb_backend_one_pack(&backend, cl_fixture("testrepo.git/objects/pack/pack-a81e489679b7d3418f9ab594bda8ceb37dd4c695.idx")));
 	cl_git_pass(git_odb_add_backend(_odb, backend, 1));
 	_repo = NULL;
 
-	nobj = 0;
-	cl_git_pass(git_odb_foreach(_odb, foreach_cb, NULL));
+	cl_git_pass(git_odb_foreach(_odb, foreach_cb, &nobj));
 	cl_assert(nobj == 1628);
 }
 
 static int foreach_stop_cb(const git_oid *oid, void *data)
 {
-	GIT_UNUSED(data);
-	GIT_UNUSED(oid);
+	int *nobj = data;
+	(*nobj)++;
 
-	nobj++;
+	GIT_UNUSED(oid);
 
-	return (nobj == 1000);
+	return (*nobj == 1000) ? -321 : 0;
 }
 
 void test_odb_foreach__interrupt_foreach(void)
 {
-	nobj = 0;
+	int nobj = 0;
+
 	cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
 	git_repository_odb(&_odb, _repo);
 
-	cl_assert_equal_i(GIT_EUSER, git_odb_foreach(_odb, foreach_stop_cb, NULL));
+	cl_assert_equal_i(-321, git_odb_foreach(_odb, foreach_stop_cb, &nobj));
 	cl_assert(nobj == 1000);
 }
diff --git a/tests/online/clone.c b/tests/online/clone.c
index efc76d958..be4421ae5 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -273,7 +273,7 @@ static int cancel_at_half(const git_transfer_progress *stats, void *payload)
 	GIT_UNUSED(payload);
 
 	if (stats->received_objects > (stats->total_objects/2))
-		return 1;
+		return 4321;
 	return 0;
 }
 
@@ -281,7 +281,8 @@ void test_online_clone__can_cancel(void)
 {
 	g_options.remote_callbacks.transfer_progress = cancel_at_half;
 
-	cl_git_fail_with(git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options), GIT_EUSER);
+	cl_git_fail_with(
+		git_clone(&g_repo, LIVE_REPO_URL, "./foo", &g_options), 4321);
 }
 
 
diff --git a/tests/online/fetch.c b/tests/online/fetch.c
index 5153a7ae0..7e9dfdbbe 100644
--- a/tests/online/fetch.c
+++ b/tests/online/fetch.c
@@ -129,7 +129,7 @@ static int cancel_at_half(const git_transfer_progress *stats, void *payload)
 	GIT_UNUSED(payload);
 
 	if (stats->received_objects > (stats->total_objects/2))
-		return -1;
+		return -4321;
 	return 0;
 }
 
@@ -147,7 +147,7 @@ void test_online_fetch__can_cancel(void)
 	git_remote_set_callbacks(remote, &callbacks);
 
 	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
-	cl_git_fail_with(git_remote_download(remote), GIT_EUSER);
+	cl_git_fail_with(git_remote_download(remote), -4321);
 	git_remote_disconnect(remote);
 	git_remote_free(remote);
 }
diff --git a/tests/refs/foreachglob.c b/tests/refs/foreachglob.c
index 2c458082f..c0f6ce763 100644
--- a/tests/refs/foreachglob.c
+++ b/tests/refs/foreachglob.c
@@ -81,14 +81,14 @@ static int interrupt_cb(const char *reference_name, void *payload)
 
 	(*count)++;
 
-	return (*count == 11);
+	return (*count == 11) ? -1000 : 0;
 }
 
 void test_refs_foreachglob__can_cancel(void)
 {
 	int count = 0;
 
-	cl_assert_equal_i(GIT_EUSER, git_reference_foreach_glob(
+	cl_assert_equal_i(-1000, git_reference_foreach_glob(
 		repo, "*", interrupt_cb, &count) );
 
 	cl_assert_equal_i(11, count);
diff --git a/tests/status/worktree.c b/tests/status/worktree.c
index 34be6d34c..fd57fcc1e 100644
--- a/tests/status/worktree.c
+++ b/tests/status/worktree.c
@@ -552,7 +552,7 @@ static int cb_status__interrupt(const char *p, unsigned int s, void *payload)
 
 	(*count)++;
 
-	return (*count == 8);
+	return (*count == 8) ? -111 : 0;
 }
 
 void test_status_worktree__interruptable_foreach(void)
@@ -561,7 +561,7 @@ void test_status_worktree__interruptable_foreach(void)
 	git_repository *repo = cl_git_sandbox_init("status");
 
 	cl_assert_equal_i(
-		GIT_EUSER, git_status_foreach(repo, cb_status__interrupt, &count)
+		-111, git_status_foreach(repo, cb_status__interrupt, &count)
 	);
 
 	cl_assert_equal_i(8, count);
-- 
cgit v1.2.3


From 60058018dcadbaa1f70281c9d29faf1e46d3a87c Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 6 Dec 2013 15:20:41 -0800
Subject: Fix C99 __func__ for MSVC

---
 src/common.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/common.h b/src/common.h
index a0e47df9a..71182bbb9 100644
--- a/src/common.h
+++ b/src/common.h
@@ -94,7 +94,11 @@ GIT_INLINE(int) giterr_set_callback(int error_code, const char *action)
 	return error_code;
 }
 
+#ifdef GIT_WIN32
+#define GITERR_CALLBACK(code) giterr_set_callback((code), __FUNCTION__)
+#else
 #define GITERR_CALLBACK(code) giterr_set_callback((code), __func__)
+#endif
 
 /**
  * Gets the system error code for this thread.
-- 
cgit v1.2.3


From c7b3e1b32040d05f3cb996d754a28af3b4d06d0b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 6 Dec 2013 15:42:20 -0800
Subject: Some callback error check style cleanups

I find this easier to read...
---
 src/attr.c         |  7 ++++---
 src/diff.c         |  4 +++-
 src/fetchhead.c    | 11 ++++++-----
 src/merge.c        |  4 +++-
 src/pack-objects.c |  7 +++++--
 src/pack.c         |  4 +++-
 src/path.c         | 13 +++++++++----
 src/push.c         |  5 +++--
 src/remote.c       |  6 ++++--
 src/stash.c        | 14 ++++++++------
 src/status.c       |  5 +++--
 src/submodule.c    |  4 +++-
 12 files changed, 54 insertions(+), 30 deletions(-)

diff --git a/src/attr.c b/src/attr.c
index 08d7ee99d..553c071be 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -191,10 +191,11 @@ int git_attr_foreach(
 				if (error < 0)
 					goto cleanup;
 
-				error = GITERR_CALLBACK(
-					callback(assign->name, assign->value, payload) );
-				if (error)
+				error = callback(assign->name, assign->value, payload);
+				if (error) {
+					GITERR_CALLBACK(error);
 					goto cleanup;
+				}
 			}
 		}
 	}
diff --git a/src/diff.c b/src/diff.c
index 101426f6e..b7657e432 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -1388,8 +1388,10 @@ int git_diff__paired_foreach(
 			i++; j++;
 		}
 
-		if ((error = GITERR_CALLBACK( cb(h2i, i2w, payload) )) != 0)
+		if ((error = cb(h2i, i2w, payload)) != 0) {
+			GITERR_CALLBACK(error);
 			break;
+		}
 	}
 
 	/* restore case-insensitive delta sort */
diff --git a/src/fetchhead.c b/src/fetchhead.c
index 7c37be4c6..2f217fad1 100644
--- a/src/fetchhead.c
+++ b/src/fetchhead.c
@@ -260,8 +260,8 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 	while ((line = git__strsep(&buffer, "\n")) != NULL) {
 		++line_num;
 
-		if ((error = fetchhead_ref_parse(&oid, &is_merge, &name, &remote_url,
-			line, line_num)) < 0)
+		if ((error = fetchhead_ref_parse(
+				&oid, &is_merge, &name, &remote_url, line, line_num)) < 0)
 			goto done;
 
 		if (git_buf_len(&name) > 0)
@@ -269,10 +269,11 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 		else
 			ref_name = NULL;
 
-		error = GITERR_CALLBACK(
-			cb(ref_name, remote_url, &oid, is_merge, payload) );
-		if (error)
+		error = cb(ref_name, remote_url, &oid, is_merge, payload);
+		if (error) {
+			GITERR_CALLBACK(error);
 			goto done;
+		}
 	}
 
 	if (*buffer) {
diff --git a/src/merge.c b/src/merge.c
index 6f73fc14a..f1778c950 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -287,8 +287,10 @@ int git_repository_mergehead_foreach(
 		if ((error = git_oid_fromstr(&oid, line)) < 0)
 			goto cleanup;
 
-		if ((error = GITERR_CALLBACK( cb(&oid, payload) )) != 0)
+		if ((error = cb(&oid, payload)) != 0) {
+			GITERR_CALLBACK(error);
 			goto cleanup;
+		}
 
 		++line_num;
 	}
diff --git a/src/pack-objects.c b/src/pack-objects.c
index 2f0007f4f..09b7248af 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -229,9 +229,12 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 		if (elapsed >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			pb->last_progress_report_time = current_time;
 
-			return GITERR_CALLBACK( pb->progress_cb(
+			ret = pb->progress_cb(
 				GIT_PACKBUILDER_ADDING_OBJECTS,
-				pb->nr_objects, 0, pb->progress_cb_payload) );
+				pb->nr_objects, 0, pb->progress_cb_payload);
+
+			if (ret)
+				return GITERR_CALLBACK(ret);
 		}
 	}
 
diff --git a/src/pack.c b/src/pack.c
index 3f2adb2f3..fd53ef49a 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -1088,8 +1088,10 @@ int git_pack_foreach_entry(
 	}
 
 	for (i = 0; i < p->num_objects; i++)
-		if ((error = GITERR_CALLBACK( cb(p->oids[i], data) )) != 0)
+		if ((error = cb(p->oids[i], data)) != 0) {
+			GITERR_CALLBACK(error);
 			break;
+		}
 
 	return error;
 }
diff --git a/src/path.c b/src/path.c
index 857a2e61c..8c19e004e 100644
--- a/src/path.c
+++ b/src/path.c
@@ -434,10 +434,13 @@ int git_path_walk_up(
 	iter.asize = path->asize;
 
 	while (scan >= stop) {
-		error = GITERR_CALLBACK( cb(data, &iter) );
+		error = cb(data, &iter);
 		iter.ptr[scan] = oldc;
-		if (error)
+
+		if (error) {
+			GITERR_CALLBACK(error);
 			break;
+		}
 
 		scan = git_buf_rfind_next(&iter, '/');
 		if (scan >= 0) {
@@ -874,12 +877,14 @@ int git_path_direach(
 		if ((error = git_buf_put(path, de_path, de_len)) < 0)
 			break;
 
-		error = GITERR_CALLBACK( fn(arg, path) );
+		error = fn(arg, path);
 
 		git_buf_truncate(path, wd_len); /* restore path */
 
-		if (error)
+		if (error != 0) {
+			GITERR_CALLBACK(error);
 			break;
+		}
 	}
 
 	closedir(dir);
diff --git a/src/push.c b/src/push.c
index 428173397..8ebba15eb 100644
--- a/src/push.c
+++ b/src/push.c
@@ -659,8 +659,9 @@ int git_push_status_foreach(git_push *push,
 	unsigned int i;
 
 	git_vector_foreach(&push->status, i, status) {
-		GITERR_CHECK_ERROR(
-			GITERR_CALLBACK( cb(status->ref, status->msg, data) ) );
+		int error = cb(status->ref, status->msg, data);
+		if (error)
+			return GITERR_CALLBACK(error);
 	}
 
 	return 0;
diff --git a/src/remote.c b/src/remote.c
index 307306d1a..d46364a81 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1348,9 +1348,11 @@ static int rename_fetch_refspecs(
 		if (!remote->name ||
 			strcmp(git_buf_cstr(&base), spec->string)) {
 
-			error = GITERR_CALLBACK( callback(spec->string, payload) );
-			if (error)
+			if ((error = callback(spec->string, payload)) != 0) {
+				GITERR_CALLBACK(error);
 				break;
+			}
+
 			continue;
 		}
 
diff --git a/src/stash.c b/src/stash.c
index 458a1e175..fb5bb2e55 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -582,13 +582,15 @@ int git_stash_foreach(
 	for (i = 0; i < max; i++) {
 		entry = git_reflog_entry_byindex(reflog, i);
 
-		error = GITERR_CALLBACK(
-			callback(i,
-				git_reflog_entry_message(entry),
-				git_reflog_entry_id_new(entry),
-				payload) );
-		if (error)
+		error = callback(i,
+			git_reflog_entry_message(entry),
+			git_reflog_entry_id_new(entry),
+			payload);
+
+		if (error) {
+			GITERR_CALLBACK(error);
 			break;
+		}
 	}
 
 cleanup:
diff --git a/src/status.c b/src/status.c
index d76617a72..d4a436283 100644
--- a/src/status.c
+++ b/src/status.c
@@ -392,9 +392,10 @@ int git_status_foreach_ext(
 			status_entry->head_to_index->old_file.path :
 			status_entry->index_to_workdir->old_file.path;
 
-		error = GITERR_CALLBACK( cb(path, status_entry->status, payload) );
-		if (error)
+		if ((error = cb(path, status_entry->status, payload)) != 0) {
+			GITERR_CALLBACK(error);
 			break;
+		}
 	}
 
 	git_status_list_free(status);
diff --git a/src/submodule.c b/src/submodule.c
index e9d534ae8..5298302c7 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -168,8 +168,10 @@ int git_submodule_foreach(
 				break;
 		}
 
-		if ((error = GITERR_CALLBACK(callback(sm, sm->name, payload))) != 0)
+		if ((error = callback(sm, sm->name, payload)) != 0) {
+			GITERR_CALLBACK(error);
 			break;
+		}
 	});
 
 	git_vector_free(&seen);
-- 
cgit v1.2.3


From f10d7a368fa4af28b1e6f082349ffa4f62b3c00e Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 6 Dec 2013 15:53:26 -0800
Subject: Further callback error check style fixes

Okay, I've decided I like the readability of this style much
better so I used it everywhere.
---
 src/config.c | 18 ++++++++++++------
 src/notes.c  | 10 ++++++----
 src/refs.c   | 27 ++++++++++++++++++---------
 3 files changed, 36 insertions(+), 19 deletions(-)

diff --git a/src/config.c b/src/config.c
index 8b3a426ed..5477b04c8 100644
--- a/src/config.c
+++ b/src/config.c
@@ -507,9 +507,10 @@ int git_config_backend_foreach_match(
 			continue;
 
 		/* abort iterator on non-zero return value */
-		error = GITERR_CALLBACK( cb(entry, payload) );
-		if (error)
+		if ((error = cb(entry, payload)) != 0) {
+			GITERR_CALLBACK(error);
 			break;
+		}
 	}
 
 	if (regexp != NULL)
@@ -533,9 +534,12 @@ int git_config_foreach_match(
 	if ((error = git_config_iterator_glob_new(&iter, cfg, regexp)) < 0)
 		return error;
 
-	while (!(error = git_config_next(&entry, iter)) &&
-		   !(error = GITERR_CALLBACK( cb(entry, payload) )))
-		/* make callback on each config */;
+	while (!(error = git_config_next(&entry, iter))) {
+		if ((error = cb(entry, payload)) != 0) {
+			GITERR_CALLBACK(error);
+			break;
+		}
+	}
 
 	git_config_iterator_free(iter);
 
@@ -794,8 +798,10 @@ int git_config_get_multivar_foreach(
 	while ((err = iter->next(&entry, iter)) == 0) {
 		found = 1;
 
-		if ((err = GITERR_CALLBACK( cb(entry, payload) )) != 0)
+		if ((err = cb(entry, payload)) != 0) {
+			GITERR_CALLBACK(err);
 			break;
+		}
 	}
 
 	iter->free(iter);
diff --git a/src/notes.c b/src/notes.c
index e3a3fccf8..e0d5ad19e 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -582,10 +582,12 @@ int git_note_foreach(
 	if ((error = git_note_iterator_new(&iter, repo, notes_ref)) < 0)
 		return error;
 
-	while (!(error = git_note_next(&note_id, &annotated_id, iter)) &&
-		   !(error = GITERR_CALLBACK(
-				note_cb(&note_id, &annotated_id, payload))))
-		/* callback for each note */;
+	while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
+		if ((error = note_cb(&note_id, &annotated_id, payload)) != 0) {
+			GITERR_CALLBACK(error);
+			break;
+		}
+	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
diff --git a/src/refs.c b/src/refs.c
index afb067986..25037cc4f 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -516,9 +516,12 @@ int git_reference_foreach(
 	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
 		return error;
 
-	while (!(error = git_reference_next(&ref, iter)) &&
-		   !(error = GITERR_CALLBACK( callback(ref, payload) )))
-		/* callback on each reference */;
+	while (!(error = git_reference_next(&ref, iter))) {
+		if ((error = callback(ref, payload)) != 0) {
+			GITERR_CALLBACK(error);
+			break;
+		}
+	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
@@ -539,9 +542,12 @@ int git_reference_foreach_name(
 	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
 		return error;
 
-	while (!(error = git_reference_next_name(&refname, iter)) &&
-		   !(error = GITERR_CALLBACK( callback(refname, payload) )))
-		/* callback on each reference name */;
+	while (!(error = git_reference_next_name(&refname, iter))) {
+		if ((error = callback(refname, payload)) != 0) {
+			GITERR_CALLBACK(error);
+			break;
+		}
+	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
@@ -563,9 +569,12 @@ int git_reference_foreach_glob(
 	if ((error = git_reference_iterator_glob_new(&iter, repo, glob)) < 0)
 		return error;
 
-	while (!(error = git_reference_next_name(&refname, iter)) &&
-		   !(error = GITERR_CALLBACK( callback(refname, payload) )))
-		/* callback on each matching reference name */;
+	while (!(error = git_reference_next_name(&refname, iter))) {
+		if ((error = callback(refname, payload)) != 0) {
+			GITERR_CALLBACK(error);
+			break;
+		}
+	}
 
 	if (error == GIT_ITEROVER)
 		error = 0;
-- 
cgit v1.2.3


From 26c1cb91beccb44425864bd233ed0e35f5801868 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 9 Dec 2013 09:44:03 -0800
Subject: One more rename/cleanup for callback err functions

---
 src/attr.c         |  2 +-
 src/checkout.c     | 11 +++++++----
 src/common.h       |  9 ++++++---
 src/config.c       |  6 +++---
 src/diff.c         |  8 ++++++--
 src/diff_patch.c   |  2 +-
 src/diff_print.c   |  4 ++--
 src/fetchhead.c    |  2 +-
 src/index.c        | 20 ++++++++++++++------
 src/indexer.c      |  2 +-
 src/merge.c        |  2 +-
 src/notes.c        |  2 +-
 src/odb_loose.c    |  2 +-
 src/pack-objects.c |  2 +-
 src/pack.c         |  6 ++----
 src/path.c         |  4 ++--
 src/push.c         |  2 +-
 src/refs.c         |  6 +++---
 src/remote.c       |  2 +-
 src/stash.c        |  2 +-
 src/status.c       |  2 +-
 src/submodule.c    |  2 +-
 src/tag.c          |  4 ++--
 src/tree.c         | 16 +++++++++++-----
 24 files changed, 71 insertions(+), 49 deletions(-)

diff --git a/src/attr.c b/src/attr.c
index 553c071be..e6e274e42 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -193,7 +193,7 @@ int git_attr_foreach(
 
 				error = callback(assign->name, assign->value, payload);
 				if (error) {
-					GITERR_CALLBACK(error);
+					giterr_set_after_callback(error);
 					goto cleanup;
 				}
 			}
diff --git a/src/checkout.c b/src/checkout.c
index 4c64252e4..a292e3d4c 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -123,10 +123,13 @@ static int checkout_notify(
 		path = delta->old_file.path;
 	}
 
-	return giterr_set_callback(
-		data->opts.notify_cb(
-			why, path, baseline, target, workdir, data->opts.notify_payload),
-		"git_checkout notification");
+	{
+		int error = data->opts.notify_cb(
+			why, path, baseline, target, workdir, data->opts.notify_payload);
+
+		return giterr_set_after_callback_function(
+			error, "git_checkout notification");
+	}
 }
 
 static bool checkout_is_workdir_modified(
diff --git a/src/common.h b/src/common.h
index 71182bbb9..e315b5979 100644
--- a/src/common.h
+++ b/src/common.h
@@ -83,7 +83,8 @@ int giterr_set_regex(const regex_t *regex, int error_code);
  *
  * @return This always returns the `error_code` parameter.
  */
-GIT_INLINE(int) giterr_set_callback(int error_code, const char *action)
+GIT_INLINE(int) giterr_set_after_callback_function(
+	int error_code, const char *action)
 {
 	if (error_code) {
 		const git_error *e = giterr_last();
@@ -95,9 +96,11 @@ GIT_INLINE(int) giterr_set_callback(int error_code, const char *action)
 }
 
 #ifdef GIT_WIN32
-#define GITERR_CALLBACK(code) giterr_set_callback((code), __FUNCTION__)
+#define giterr_set_after_callback(code) \
+	giterr_set_after_callback_function((code), __FUNCTION__)
 #else
-#define GITERR_CALLBACK(code) giterr_set_callback((code), __func__)
+#define giterr_set_after_callback(code) \
+	giterr_set_after_callback_function((code), __func__)
 #endif
 
 /**
diff --git a/src/config.c b/src/config.c
index 5477b04c8..056a6ae13 100644
--- a/src/config.c
+++ b/src/config.c
@@ -508,7 +508,7 @@ int git_config_backend_foreach_match(
 
 		/* abort iterator on non-zero return value */
 		if ((error = cb(entry, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
@@ -536,7 +536,7 @@ int git_config_foreach_match(
 
 	while (!(error = git_config_next(&entry, iter))) {
 		if ((error = cb(entry, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
@@ -799,7 +799,7 @@ int git_config_get_multivar_foreach(
 		found = 1;
 
 		if ((err = cb(entry, payload)) != 0) {
-			GITERR_CALLBACK(err);
+			giterr_set_after_callback(err);
 			break;
 		}
 	}
diff --git a/src/diff.c b/src/diff.c
index b7657e432..83adc2a8c 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -60,7 +60,11 @@ static int diff_insert_delta(
 
 		if (error) {
 			git__free(delta);
-			return (error > 0) ? 0 : giterr_set_callback(error, "git_diff");
+
+			if (error > 0)	/* positive value means to skip this delta */
+				return 0;
+			else			/* negative value means to cancel diff */
+				return giterr_set_after_callback_function(error, "git_diff");
 		}
 	}
 
@@ -1389,7 +1393,7 @@ int git_diff__paired_foreach(
 		}
 
 		if ((error = cb(h2i, i2w, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
diff --git a/src/diff_patch.c b/src/diff_patch.c
index 11f02478d..9c2eb885f 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -202,7 +202,7 @@ static int diff_patch_invoke_file_callback(
 	if (!output->file_cb)
 		return 0;
 
-	return giterr_set_callback(
+	return giterr_set_after_callback_function(
 		output->file_cb(patch->delta, progress, output->payload),
 		"git_patch");
 }
diff --git a/src/diff_print.c b/src/diff_print.c
index ff477e4c8..7a70e2b18 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -398,7 +398,7 @@ int git_diff_print(
 			diff, print_file, print_hunk, print_line, &pi);
 
 		if (error) /* make sure error message is set */
-			giterr_set_callback(error, "git_diff_print");
+			giterr_set_after_callback_function(error, "git_diff_print");
 	}
 
 	git_buf_free(&buf);
@@ -427,7 +427,7 @@ int git_patch_print(
 			diff_print_patch_line, &pi);
 
 		if (error) /* make sure error message is set */
-			giterr_set_callback(error, "git_patch_print");
+			giterr_set_after_callback_function(error, "git_patch_print");
 	}
 
 	git_buf_free(&temp);
diff --git a/src/fetchhead.c b/src/fetchhead.c
index 2f217fad1..4435454ef 100644
--- a/src/fetchhead.c
+++ b/src/fetchhead.c
@@ -271,7 +271,7 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 
 		error = cb(ref_name, remote_url, &oid, is_merge, payload);
 		if (error) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			goto done;
 		}
 	}
diff --git a/src/index.c b/src/index.c
index 671bdfa79..bb81f666e 100644
--- a/src/index.c
+++ b/src/index.c
@@ -2117,7 +2117,7 @@ int git_index_add_all(
 			if (error > 0) /* return > 0 means skip this one */
 				continue;
 			if (error < 0) { /* return < 0 means abort */
-				GITERR_CALLBACK(error);
+				giterr_set_after_callback(error);
 				break;
 			}
 		}
@@ -2204,10 +2204,8 @@ static int index_apply_to_all(
 				error = 0;
 				continue;
 			}
-			if (error < 0) { /* return < 0 means abort */
-				giterr_set_callback(error, "git_index_matched_path");
+			if (error < 0)   /* return < 0 means abort */
 				break;
-			}
 		}
 
 		/* index manipulation may alter entry, so don't depend on it */
@@ -2252,8 +2250,13 @@ int git_index_remove_all(
 	git_index_matched_path_cb cb,
 	void *payload)
 {
-	return index_apply_to_all(
+	int error = index_apply_to_all(
 		index, INDEX_ACTION_REMOVE, pathspec, cb, payload);
+
+	if (error) /* make sure error is set if callback stopped iteration */
+		giterr_set_after_callback(error);
+
+	return error;
 }
 
 int git_index_update_all(
@@ -2262,6 +2265,11 @@ int git_index_update_all(
 	git_index_matched_path_cb cb,
 	void *payload)
 {
-	return index_apply_to_all(
+	int error = index_apply_to_all(
 		index, INDEX_ACTION_UPDATE, pathspec, cb, payload);
+
+	if (error) /* make sure error is set if callback stopped iteration */
+		giterr_set_after_callback(error);
+
+	return error;
 }
diff --git a/src/indexer.c b/src/indexer.c
index 320845bd9..88897d07d 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -387,7 +387,7 @@ on_error:
 static int do_progress_callback(git_indexer *idx, git_transfer_progress *stats)
 {
 	if (idx->progress_cb)
-		return giterr_set_callback(
+		return giterr_set_after_callback_function(
 			idx->progress_cb(stats, idx->progress_payload),
 			"indexer progress");
 	return 0;
diff --git a/src/merge.c b/src/merge.c
index f1778c950..5640be56b 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -288,7 +288,7 @@ int git_repository_mergehead_foreach(
 			goto cleanup;
 
 		if ((error = cb(&oid, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			goto cleanup;
 		}
 
diff --git a/src/notes.c b/src/notes.c
index e0d5ad19e..795904917 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -584,7 +584,7 @@ int git_note_foreach(
 
 	while (!(error = git_note_next(&note_id, &annotated_id, iter))) {
 		if ((error = note_cb(&note_id, &annotated_id, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
diff --git a/src/odb_loose.c b/src/odb_loose.c
index 78cd792bd..fd4ffff1e 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -733,7 +733,7 @@ static int foreach_object_dir_cb(void *_state, git_buf *path)
 	if (filename_to_oid(&oid, path->ptr + state->dir_len) < 0)
 		return 0;
 
-	return giterr_set_callback(
+	return giterr_set_after_callback_function(
 		state->cb(&oid, state->data), "git_odb_foreach");
 }
 
diff --git a/src/pack-objects.c b/src/pack-objects.c
index 09b7248af..7ce1b6cb3 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -234,7 +234,7 @@ int git_packbuilder_insert(git_packbuilder *pb, const git_oid *oid,
 				pb->nr_objects, 0, pb->progress_cb_payload);
 
 			if (ret)
-				return GITERR_CALLBACK(ret);
+				return giterr_set_after_callback(ret);
 		}
 	}
 
diff --git a/src/pack.c b/src/pack.c
index fd53ef49a..23fcf3530 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -1088,10 +1088,8 @@ int git_pack_foreach_entry(
 	}
 
 	for (i = 0; i < p->num_objects; i++)
-		if ((error = cb(p->oids[i], data)) != 0) {
-			GITERR_CALLBACK(error);
-			break;
-		}
+		if ((error = cb(p->oids[i], data)) != 0)
+			return giterr_set_after_callback(error);
 
 	return error;
 }
diff --git a/src/path.c b/src/path.c
index 8c19e004e..365bd6c00 100644
--- a/src/path.c
+++ b/src/path.c
@@ -438,7 +438,7 @@ int git_path_walk_up(
 		iter.ptr[scan] = oldc;
 
 		if (error) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 
@@ -882,7 +882,7 @@ int git_path_direach(
 		git_buf_truncate(path, wd_len); /* restore path */
 
 		if (error != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
diff --git a/src/push.c b/src/push.c
index 8ebba15eb..adba880df 100644
--- a/src/push.c
+++ b/src/push.c
@@ -661,7 +661,7 @@ int git_push_status_foreach(git_push *push,
 	git_vector_foreach(&push->status, i, status) {
 		int error = cb(status->ref, status->msg, data);
 		if (error)
-			return GITERR_CALLBACK(error);
+			return giterr_set_after_callback(error);
 	}
 
 	return 0;
diff --git a/src/refs.c b/src/refs.c
index 25037cc4f..4f3a557c6 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -518,7 +518,7 @@ int git_reference_foreach(
 
 	while (!(error = git_reference_next(&ref, iter))) {
 		if ((error = callback(ref, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
@@ -544,7 +544,7 @@ int git_reference_foreach_name(
 
 	while (!(error = git_reference_next_name(&refname, iter))) {
 		if ((error = callback(refname, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
@@ -571,7 +571,7 @@ int git_reference_foreach_glob(
 
 	while (!(error = git_reference_next_name(&refname, iter))) {
 		if ((error = callback(refname, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
diff --git a/src/remote.c b/src/remote.c
index d46364a81..689de230a 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1349,7 +1349,7 @@ static int rename_fetch_refspecs(
 			strcmp(git_buf_cstr(&base), spec->string)) {
 
 			if ((error = callback(spec->string, payload)) != 0) {
-				GITERR_CALLBACK(error);
+				giterr_set_after_callback(error);
 				break;
 			}
 
diff --git a/src/stash.c b/src/stash.c
index fb5bb2e55..eae56966c 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -588,7 +588,7 @@ int git_stash_foreach(
 			payload);
 
 		if (error) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
diff --git a/src/status.c b/src/status.c
index d4a436283..9bde8fb57 100644
--- a/src/status.c
+++ b/src/status.c
@@ -393,7 +393,7 @@ int git_status_foreach_ext(
 			status_entry->index_to_workdir->old_file.path;
 
 		if ((error = cb(path, status_entry->status, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	}
diff --git a/src/submodule.c b/src/submodule.c
index 5298302c7..1c36d3656 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -169,7 +169,7 @@ int git_submodule_foreach(
 		}
 
 		if ((error = callback(sm, sm->name, payload)) != 0) {
-			GITERR_CALLBACK(error);
+			giterr_set_after_callback(error);
 			break;
 		}
 	});
diff --git a/src/tag.c b/src/tag.c
index adf2819d7..be56b05ce 100644
--- a/src/tag.c
+++ b/src/tag.c
@@ -426,8 +426,8 @@ static int tags_cb(const char *ref, void *data)
 		return 0; /* no tag */
 
 	if (!(error = git_reference_name_to_id(&oid, d->repo, ref))) {
-		error = d->cb(ref, &oid, d->cb_data);
-		giterr_set_callback(error, "git_tag_foreach");
+		if ((error = d->cb(ref, &oid, d->cb_data)) != 0)
+			giterr_set_after_callback_function(error, "git_tag_foreach");
 	}
 
 	return error;
diff --git a/src/tree.c b/src/tree.c
index 5f35ac3a8..4d77ff778 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -883,9 +883,12 @@ static int tree_walk(
 
 	git_vector_foreach(&tree->entries, i, entry) {
 		if (preorder) {
-			if ((error = callback(path->ptr, entry, payload)) < 0)
-				return giterr_set_callback(error, "git_tree_walk");
-			if (error > 0) {
+			error = callback(path->ptr, entry, payload);
+			if (error < 0) { /* negative value stops iteration */
+				giterr_set_after_callback_function(error, "git_tree_walk");
+				break;
+			}
+			if (error > 0) { /* positive value skips this entry */
 				error = 0;
 				continue;
 			}
@@ -916,8 +919,11 @@ static int tree_walk(
 		}
 
 		if (!preorder) {
-			if ((error = callback(path->ptr, entry, payload)) < 0)
-				return giterr_set_callback(error, "git_tree_walk");
+			error = callback(path->ptr, entry, payload);
+			if (error < 0) { /* negative value stops iteration */
+				giterr_set_after_callback_function(error, "git_tree_walk");
+				break;
+			}
 			error = 0;
 		}
 	}
-- 
cgit v1.2.3


From 373cf6a932a64d1cbe5f5cd8333546dcc2ca0b92 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 9 Dec 2013 10:17:47 -0800
Subject: Update docs for new callback return value behavior

---
 include/git2/attr.h       |  3 ++-
 include/git2/config.h     |  6 +++---
 include/git2/diff.h       | 12 ++++++------
 include/git2/errors.h     | 45 +++++++++++++++++++++++++++++----------------
 include/git2/index.h      |  8 ++++----
 include/git2/notes.h      |  2 +-
 include/git2/odb.h        |  2 +-
 include/git2/patch.h      |  4 ++--
 include/git2/push.h       |  6 ++++--
 include/git2/refs.h       | 17 +++++++++++++++--
 include/git2/repository.h | 20 ++++++++++++++------
 include/git2/stash.h      | 18 +++++++-----------
 include/git2/status.h     |  6 +++---
 13 files changed, 91 insertions(+), 58 deletions(-)

diff --git a/include/git2/attr.h b/include/git2/attr.h
index f256ff861..3adbb2c24 100644
--- a/include/git2/attr.h
+++ b/include/git2/attr.h
@@ -199,8 +199,9 @@ typedef int (*git_attr_foreach_cb)(const char *name, const char *value, void *pa
  *             only once per attribute name, even if there are multiple
  *             rules for a given file.  The highest priority rule will be
  *             used.  Return a non-zero value from this to stop looping.
+ *             The value will be returned from `git_attr_foreach`.
  * @param payload Passed on as extra parameter to callback function.
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_attr_foreach(
 	git_repository *repo,
diff --git a/include/git2/config.h b/include/git2/config.h
index 3ab58f1a7..f650f1b41 100644
--- a/include/git2/config.h
+++ b/include/git2/config.h
@@ -450,13 +450,13 @@ GIT_EXTERN(int) git_config_delete_multivar(git_config *cfg, const char *name, co
  *
  * The callback receives the normalized name and value of each variable
  * in the config backend, and the data pointer passed to this function.
- * As soon as one of the callback functions returns something other than 0,
- * this function stops iterating and returns `GIT_EUSER`.
+ * If the callback returns a non-zero value, the function stops iterating
+ * and returns that value to the caller.
  *
  * @param cfg where to get the variables from
  * @param callback the function to call on each variable
  * @param payload the data to pass to the callback
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_config_foreach(
 	const git_config *cfg,
diff --git a/include/git2/diff.h b/include/git2/diff.h
index d6919393a..76fb23654 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -870,7 +870,7 @@ GIT_EXTERN(int) git_diff_is_sorted_icase(const git_diff *diff);
  * files whose only changed is a file mode change.
  *
  * Returning a non-zero value from any of the callbacks will terminate
- * the iteration and cause this return `GIT_EUSER`.
+ * the iteration and return the value to the user.
  *
  * @param diff A git_diff generated by one of the above functions.
  * @param file_cb Callback function to make per file in the diff.
@@ -881,7 +881,7 @@ GIT_EXTERN(int) git_diff_is_sorted_icase(const git_diff *diff);
  *                same callback will be made for context lines, added, and
  *                removed lines, and even for a deleted trailing newline.
  * @param payload Reference pointer that will be passed to your callbacks.
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_diff_foreach(
 	git_diff *diff,
@@ -918,13 +918,13 @@ typedef enum {
  * Iterate over a diff generating formatted text output.
  *
  * Returning a non-zero value from the callbacks will terminate the
- * iteration and cause this return `GIT_EUSER`.
+ * iteration and return the non-zero value to the caller.
  *
  * @param diff A git_diff generated by one of the above functions.
  * @param format A git_diff_format_t value to pick the text format.
  * @param print_cb Callback to make per line of diff text.
  * @param payload Reference pointer that will be passed to your callback.
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_diff_print(
 	git_diff *diff,
@@ -964,7 +964,7 @@ GIT_EXTERN(int) git_diff_print(
  * @param hunk_cb Callback for each hunk in diff; can be NULL
  * @param line_cb Callback for each line in diff; can be NULL
  * @param payload Payload passed to each callback function
- * @return 0 on success, GIT_EUSER on non-zero callback return, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_diff_blobs(
 	const git_blob *old_blob,
@@ -999,7 +999,7 @@ GIT_EXTERN(int) git_diff_blobs(
  * @param hunk_cb Callback for each hunk in diff; can be NULL
  * @param line_cb Callback for each line in diff; can be NULL
  * @param payload Payload passed to each callback function
- * @return 0 on success, GIT_EUSER on non-zero callback return, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_diff_blob_to_buffer(
 	const git_blob *old_blob,
diff --git a/include/git2/errors.h b/include/git2/errors.h
index 26f9a747c..973d56003 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -19,25 +19,38 @@ GIT_BEGIN_DECL
 
 /** Generic return codes */
 typedef enum {
-	GIT_OK = 0,
-	GIT_ERROR = -1,
-	GIT_ENOTFOUND = -3,
-	GIT_EEXISTS = -4,
-	GIT_EAMBIGUOUS = -5,
-	GIT_EBUFS = -6,
-	GIT_EUSER = -7,
-	GIT_EBAREREPO = -8,
-	GIT_EUNBORNBRANCH = -9,
-	GIT_EUNMERGED = -10,
-	GIT_ENONFASTFORWARD = -11,
-	GIT_EINVALIDSPEC = -12,
-	GIT_EMERGECONFLICT = -13,
-	GIT_ELOCKED = -14,
+	GIT_OK         =  0,		/*< No error */
 
-	GIT_PASSTHROUGH = -30,
-	GIT_ITEROVER = -31,
+	GIT_ERROR      = -1,		/*< Generic error */
+	GIT_ENOTFOUND  = -3,		/*< Requested object could not be found */
+	GIT_EEXISTS    = -4,		/*< Object exists preventing operation */
+	GIT_EAMBIGUOUS = -5,		/*< More than one object matches */
+	GIT_EBUFS      = -6,		/*< Output buffer too short to hold data */
+
+	/* GIT_EUSER is a special error that is never generated by libgit2
+	 * code.  You can return it from a callback (e.g to stop an iteration)
+	 * to know that it was generated by the callback and not by libgit2.
+	 */
+	GIT_EUSER      = -7,
+
+	GIT_EBAREREPO       =  -8,	/*< Operation not allowed on bare repository */
+	GIT_EUNBORNBRANCH   =  -9,	/*< HEAD refers to branch with no commits */
+	GIT_EUNMERGED       = -10,	/*< Merge in progress prevented operation */
+	GIT_ENONFASTFORWARD = -11,	/*< Reference was not fast-forwardable */
+	GIT_EINVALIDSPEC    = -12,	/*< Name/ref spec was not in a valid format */
+	GIT_EMERGECONFLICT  = -13,	/*< Merge conflicts prevented operation */
+	GIT_ELOCKED         = -14,	/*< Lock file prevented operation */
+
+	GIT_PASSTHROUGH     = -30,	/*< Internal only */
+	GIT_ITEROVER        = -31,	/*< Signals end of iteration with iterator */
 } git_error_code;
 
+/**
+ * Structure to store extra details of the last error that occurred.
+ *
+ * This is kept on a per-thread basis if GIT_THREADS was defined when the
+ * library was build, otherwise one is kept globally for the library
+ */
 typedef struct {
 	char *message;
 	int klass;
diff --git a/include/git2/index.h b/include/git2/index.h
index a60db370a..ffefad15d 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -493,7 +493,7 @@ GIT_EXTERN(int) git_index_remove_bypath(git_index *index, const char *path);
  * item in the working directory immediately *before* it is added to /
  * updated in the index.  Returning zero will add the item to the index,
  * greater than zero will skip the item, and less than zero will abort the
- * scan and cause GIT_EUSER to be returned.
+ * scan and return that value to the caller.
  *
  * @param index an existing index object
  * @param pathspec array of path patterns
@@ -502,7 +502,7 @@ GIT_EXTERN(int) git_index_remove_bypath(git_index *index, const char *path);
  *                 gets index of matching pathspec entry); can be NULL;
  *                 return 0 to add, >0 to skip, <0 to abort scan.
  * @param payload payload passed through to callback function
- * @return 0 or an error code
+ * @return 0 on success, negative callback return value, or error code
  */
 GIT_EXTERN(int) git_index_add_all(
 	git_index *index,
@@ -524,7 +524,7 @@ GIT_EXTERN(int) git_index_add_all(
  *                 gets index of matching pathspec entry); can be NULL;
  *                 return 0 to add, >0 to skip, <0 to abort scan.
  * @param payload payload passed through to callback function
- * @return 0 or an error code
+ * @return 0 on success, negative callback return value, or error code
  */
 GIT_EXTERN(int) git_index_remove_all(
 	git_index *index,
@@ -553,7 +553,7 @@ GIT_EXTERN(int) git_index_remove_all(
  *                 gets index of matching pathspec entry); can be NULL;
  *                 return 0 to add, >0 to skip, <0 to abort scan.
  * @param payload payload passed through to callback function
- * @return 0 or an error code
+ * @return 0 on success, negative callback return value, or error code
  */
 GIT_EXTERN(int) git_index_update_all(
 	git_index *index,
diff --git a/include/git2/notes.h b/include/git2/notes.h
index 76361633b..0cb6ce5f1 100644
--- a/include/git2/notes.h
+++ b/include/git2/notes.h
@@ -189,7 +189,7 @@ GIT_EXTERN(int) git_note_default_ref(const char **out, git_repository *repo);
  *
  * @param payload Extra parameter to callback function.
  *
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_note_foreach(
 	git_repository *repo,
diff --git a/include/git2/odb.h b/include/git2/odb.h
index ad56384f0..82df4d300 100644
--- a/include/git2/odb.h
+++ b/include/git2/odb.h
@@ -189,7 +189,7 @@ GIT_EXTERN(int) git_odb_refresh(struct git_odb *db);
  * @param db database to use
  * @param cb the callback to call for each object
  * @param payload data to pass to the callback
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_odb_foreach(git_odb *db, git_odb_foreach_cb cb, void *payload);
 
diff --git a/include/git2/patch.h b/include/git2/patch.h
index 6a6ad92d7..e09f625c0 100644
--- a/include/git2/patch.h
+++ b/include/git2/patch.h
@@ -218,13 +218,13 @@ GIT_EXTERN(size_t) git_patch_size(
  * Serialize the patch to text via callback.
  *
  * Returning a non-zero value from the callback will terminate the iteration
- * and cause this return `GIT_EUSER`.
+ * and return that value to the caller.
  *
  * @param patch A git_patch representing changes to one file
  * @param print_cb Callback function to output lines of the patch.  Will be
  *                 called for file headers, hunk headers, and diff lines.
  * @param payload Reference pointer that will be passed to your callbacks.
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_patch_print(
 	git_patch *patch,
diff --git a/include/git2/push.h b/include/git2/push.h
index 77ef74039..12f0e7f2c 100644
--- a/include/git2/push.h
+++ b/include/git2/push.h
@@ -132,17 +132,19 @@ GIT_EXTERN(int) git_push_finish(git_push *push);
 GIT_EXTERN(int) git_push_unpack_ok(git_push *push);
 
 /**
- * Call callback `cb' on each status
+ * Invoke callback `cb' on each status entry
  *
  * For each of the updated references, we receive a status report in the
  * form of `ok refs/heads/master` or `ng refs/heads/master <msg>`.
  * `msg != NULL` means the reference has not been updated for the given
  * reason.
  *
+ * Return a non-zero value from the callback to stop the loop.
+ *
  * @param push The push object
  * @param cb The callback to call on each object
  *
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_push_status_foreach(git_push *push,
 			int (*cb)(const char *ref, const char *msg, void *data),
diff --git a/include/git2/refs.h b/include/git2/refs.h
index 4041947f6..e2bfa9615 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -310,20 +310,33 @@ typedef int (*git_reference_foreach_name_cb)(const char *name, void *payload);
  * Perform a callback on each reference in the repository.
  *
  * The `callback` function will be called for each reference in the
- * repository, receiving the name of the reference and the `payload` value
+ * repository, receiving the reference object and the `payload` value
  * passed to this method.  Returning a non-zero value from the callback
  * will terminate the iteration.
  *
  * @param repo Repository where to find the refs
  * @param callback Function which will be called for every listed ref
  * @param payload Additional data to pass to the callback
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_reference_foreach(
 	git_repository *repo,
 	git_reference_foreach_cb callback,
 	void *payload);
 
+/**
+ * Perform a callback on the fully-qualified name of each reference.
+ *
+ * The `callback` function will be called for each reference in the
+ * repository, receiving the name of the reference and the `payload` value
+ * passed to this method.  Returning a non-zero value from the callback
+ * will terminate the iteration.
+ *
+ * @param repo Repository where to find the refs
+ * @param callback Function which will be called for every listed ref name
+ * @param payload Additional data to pass to the callback
+ * @return 0 on success, non-zero callback return value, or error code
+ */
 GIT_EXTERN(int) git_reference_foreach_name(
 	git_repository *repo,
 	git_reference_foreach_name_cb callback,
diff --git a/include/git2/repository.h b/include/git2/repository.h
index c6bd4dca4..9f71d2959 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -503,14 +503,18 @@ typedef int (*git_repository_fetchhead_foreach_cb)(const char *ref_name,
 	void *payload);
 
 /**
- * Call callback 'callback' for each entry in the given FETCH_HEAD file.
+ * Invoke 'callback' for each entry in the given FETCH_HEAD file.
+ *
+ * Return a non-zero value from the callback to stop the loop.
  *
  * @param repo A repository object
  * @param callback Callback function
  * @param payload Pointer to callback data (optional)
- * @return 0 on success, GIT_ENOTFOUND, GIT_EUSER or error
+ * @return 0 on success, non-zero callback return value, GIT_ENOTFOUND if
+ *         there is no FETCH_HEAD file, or other error code.
  */
-GIT_EXTERN(int) git_repository_fetchhead_foreach(git_repository *repo,
+GIT_EXTERN(int) git_repository_fetchhead_foreach(
+	git_repository *repo,
 	git_repository_fetchhead_foreach_cb callback,
 	void *payload);
 
@@ -518,15 +522,19 @@ typedef int (*git_repository_mergehead_foreach_cb)(const git_oid *oid,
 	void *payload);
 
 /**
- * If a merge is in progress, call callback 'cb' for each commit ID in the
+ * If a merge is in progress, invoke 'callback' for each commit ID in the
  * MERGE_HEAD file.
  *
+ * Return a non-zero value from the callback to stop the loop.
+ *
  * @param repo A repository object
  * @param callback Callback function
  * @param payload Pointer to callback data (optional)
- * @return 0 on success, GIT_ENOTFOUND, GIT_EUSER or error
+ * @return 0 on success, non-zero callback return value, GIT_ENOTFOUND if
+ *         there is no MERGE_HEAD file, or other error code.
  */
-GIT_EXTERN(int) git_repository_mergehead_foreach(git_repository *repo,
+GIT_EXTERN(int) git_repository_mergehead_foreach(
+	git_repository *repo,
 	git_repository_mergehead_foreach_cb callback,
 	void *payload);
 
diff --git a/include/git2/stash.h b/include/git2/stash.h
index b48d33f5d..e2fe2cf0b 100644
--- a/include/git2/stash.h
+++ b/include/git2/stash.h
@@ -62,19 +62,15 @@ GIT_EXTERN(int) git_stash_save(
 	unsigned int flags);
 
 /**
- * When iterating over all the stashed states, callback that will be
- * issued per entry.
+ * This is a callback function you can provide to iterate over all the
+ * stashed states that will be invoked per entry.
  *
  * @param index The position within the stash list. 0 points to the
- * most recent stashed state.
- *
+ *              most recent stashed state.
  * @param message The stash message.
- *
  * @param stash_id The commit oid of the stashed state.
- *
  * @param payload Extra parameter to callback function.
- *
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 to continue iterating or non-zero to stop
  */
 typedef int (*git_stash_cb)(
 	size_t index,
@@ -89,12 +85,12 @@ typedef int (*git_stash_cb)(
  *
  * @param repo Repository where to find the stash.
  *
- * @param callback Callback to invoke per found stashed state. The most recent
- * stash state will be enumerated first.
+ * @param callback Callback to invoke per found stashed state. The most
+ *                 recent stash state will be enumerated first.
  *
  * @param payload Extra parameter to callback function.
  *
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_stash_foreach(
 	git_repository *repo,
diff --git a/include/git2/status.h b/include/git2/status.h
index 4ec3432df..aa68c0da0 100644
--- a/include/git2/status.h
+++ b/include/git2/status.h
@@ -203,12 +203,12 @@ typedef struct {
  * into this function.
  *
  * If the callback returns a non-zero value, this function will stop looping
- * and return GIT_EUSER.
+ * and return that value to caller.
  *
  * @param repo A repository object
  * @param callback The function to call on each file
  * @param payload Pointer to pass through to callback function
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_status_foreach(
 	git_repository *repo,
@@ -227,7 +227,7 @@ GIT_EXTERN(int) git_status_foreach(
  * @param opts Status options structure
  * @param callback The function to call on each file
  * @param payload Pointer to pass through to callback function
- * @return 0 on success, GIT_EUSER on non-zero callback, or error code
+ * @return 0 on success, non-zero callback return value, or error code
  */
 GIT_EXTERN(int) git_status_foreach_ext(
 	git_repository *repo,
-- 
cgit v1.2.3


From 19853bdd97e006b6e4519bc352c3e8fd7586e9c3 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 10 Dec 2013 13:01:34 -0800
Subject: Update git_blob_create_fromchunks callback behavr

The callback to supply data chunks could return a negative value
to stop creation of the blob, but we were neither using GIT_EUSER
nor propagating the return value.  This makes things use the new
behavior of returning the negative value back to the user.
---
 include/git2/blob.h            | 43 +++++++++++++++++++-----------------------
 src/blob.c                     | 34 ++++++++++++++++++++-------------
 tests/object/blob/fromchunks.c | 39 +++++++++++++++++++++++++++++++++++++-
 3 files changed, 78 insertions(+), 38 deletions(-)

diff --git a/include/git2/blob.h b/include/git2/blob.h
index dcab4fbe0..19ad4d949 100644
--- a/include/git2/blob.h
+++ b/include/git2/blob.h
@@ -159,37 +159,32 @@ typedef int (*git_blob_chunk_cb)(char *content, size_t max_length, void *payload
  * Write a loose blob to the Object Database from a
  * provider of chunks of data.
  *
- * Provided the `hintpath` parameter is filled, its value
- * will help to determine what git filters should be applied
- * to the object before it can be placed to the object database.
+ * If the `hintpath` parameter is filled, it will be used to determine
+ * what git filters should be applied to the object before it is written
+ * to the object database.
  *
+ * The implementation of the callback MUST respect the following rules:
  *
- * The implementation of the callback has to respect the
- * following rules:
+ *  - `content` must be filled by the callback. The maximum number of
+ *    bytes that the buffer can accept per call is defined by the
+ *    `max_length` parameter. Allocation and freeing of the buffer will
+ *    be taken care of by libgit2.
  *
- *  - `content` will have to be filled by the consumer. The maximum number
- * of bytes that the buffer can accept per call is defined by the
- * `max_length` parameter. Allocation and freeing of the buffer will be taken
- * care of by the function.
+ *  - The `callback` must return the number of bytes that have been
+ *    written to the `content` buffer.
  *
- *  - The callback is expected to return the number of bytes
- * that `content` have been filled with.
- *
- *  - When there is no more data to stream, the callback should
- * return 0. This will prevent it from being invoked anymore.
- *
- *  - When an error occurs, the callback should return -1.
+ *  - When there is no more data to stream, `callback` should return
+ *    0. This will prevent it from being invoked anymore.
  *
+ *  - If an error occurs, the callback should return a negative value.
+ *    This value will be returned to the caller.
  *
  * @param id Return the id of the written blob
- *
- * @param repo repository where the blob will be written.
- * This repository can be bare or not.
- *
- * @param hintpath if not NULL, will help selecting the filters
- * to apply onto the content of the blob to be created.
- *
- * @return 0 or an error code
+ * @param repo Repository where the blob will be written.
+ *        This repository can be bare or not.
+ * @param hintpath If not NULL, will be used to select data filters
+ *        to apply onto the content of the blob to be created.
+ * @return 0 or error code (from either libgit2 or callback function)
  */
 GIT_EXTERN(int) git_blob_create_fromchunks(
 	git_oid *id,
diff --git a/src/blob.c b/src/blob.c
index 2c6d52800..ab344ae98 100644
--- a/src/blob.c
+++ b/src/blob.c
@@ -272,37 +272,44 @@ int git_blob_create_fromchunks(
 	int (*source_cb)(char *content, size_t max_length, void *payload),
 	void *payload)
 {
-	int error = -1, read_bytes;
+	int error;
 	char *content = NULL;
 	git_filebuf file = GIT_FILEBUF_INIT;
 	git_buf path = GIT_BUF_INIT;
 
-	if (git_buf_joinpath(
-			&path, git_repository_path(repo), GIT_OBJECTS_DIR "streamed") < 0)
+	assert(oid && repo && source_cb);
+
+	if ((error = git_buf_joinpath(
+			&path, git_repository_path(repo), GIT_OBJECTS_DIR "streamed")) < 0)
 		goto cleanup;
 
 	content = git__malloc(BUFFER_SIZE);
 	GITERR_CHECK_ALLOC(content);
 
-	if (git_filebuf_open(&file, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY, 0666) < 0)
+	if ((error = git_filebuf_open(
+			&file, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY, 0666)) < 0)
 		goto cleanup;
 
 	while (1) {
-		read_bytes = source_cb(content, BUFFER_SIZE, payload);
-
-		assert(read_bytes <= BUFFER_SIZE);
+		int read_bytes = source_cb(content, BUFFER_SIZE, payload);
 
-		if (read_bytes <= 0)
+		if (!read_bytes)
 			break;
 
-		if (git_filebuf_write(&file, content, read_bytes) < 0)
+		if (read_bytes > BUFFER_SIZE) {
+			giterr_set(GITERR_OBJECT, "Invalid chunk size while creating blob");
+			error = GIT_EBUFS;
+		} else if (read_bytes < 0) {
+			error = giterr_set_after_callback(read_bytes);
+		} else {
+			error = git_filebuf_write(&file, content, read_bytes);
+		}
+
+		if (error < 0)
 			goto cleanup;
 	}
 
-	if (read_bytes < 0)
-		goto cleanup;
-
-	if (git_filebuf_flush(&file) < 0)
+	if ((error = git_filebuf_flush(&file)) < 0)
 		goto cleanup;
 
 	error = git_blob__create_from_paths(
@@ -312,6 +319,7 @@ cleanup:
 	git_buf_free(&path);
 	git_filebuf_cleanup(&file);
 	git__free(content);
+
 	return error;
 }
 
diff --git a/tests/object/blob/fromchunks.c b/tests/object/blob/fromchunks.c
index 03ed4efb4..b61cabfe1 100644
--- a/tests/object/blob/fromchunks.c
+++ b/tests/object/blob/fromchunks.c
@@ -59,7 +59,7 @@ void test_object_blob_fromchunks__doesnot_overwrite_an_already_existing_object(v
 	git_buf content = GIT_BUF_INIT;
 	git_oid expected_oid, oid;
 	int howmany = 7;
-	
+
 	cl_git_pass(git_oid_fromstr(&expected_oid, "321cbdf08803c744082332332838df6bd160f8f9"));
 
 	cl_git_pass(git_blob_create_fromchunks(&oid, repo, NULL, text_chunked_source_cb, &howmany));
@@ -117,3 +117,40 @@ void test_object_blob_fromchunks__creating_a_blob_from_chunks_honors_the_attribu
 	assert_named_chunked_blob("e9671e138a780833cb689753570fd10a55be84fb", "dummy.txt");
 	assert_named_chunked_blob("e9671e138a780833cb689753570fd10a55be84fb", "dummy.dunno");
 }
+
+static int failing_chunked_source_cb(
+	char *content, size_t max_length, void *payload)
+{
+	int *count = (int *)payload;
+
+	GIT_UNUSED(max_length);
+
+	(*count)--;
+	if (*count == 0)
+		return -1234;
+
+	strcpy(content, textual_content);
+	return (int)strlen(textual_content);
+}
+
+void test_object_blob_fromchunks__can_stop_with_error(void)
+{
+	git_oid expected_oid, oid;
+	git_object *blob;
+	int howmany = 7;
+
+	cl_git_pass(git_oid_fromstr(
+		&expected_oid, "321cbdf08803c744082332332838df6bd160f8f9"));
+
+	cl_git_fail_with(
+		git_object_lookup(&blob, repo, &expected_oid, GIT_OBJ_ANY),
+		GIT_ENOTFOUND);
+
+	cl_git_fail_with(git_blob_create_fromchunks(
+		&oid, repo, NULL, failing_chunked_source_cb, &howmany), -1234);
+
+	cl_git_fail_with(
+		git_object_lookup(&blob, repo, &expected_oid, GIT_OBJ_ANY),
+		GIT_ENOTFOUND);
+}
+
-- 
cgit v1.2.3


From cbd048969e2d53790472118bf2d337cd1d90ca94 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 10 Dec 2013 14:38:35 -0800
Subject: Fix checkout notify callback docs and tests

The checkout notify callback behavior on non-zero return values
was not being tested.  This adds tests, fixes a bug with positive
values, and clarifies the documentation to make it clear that the
checkout can be canceled via this mechanism.
---
 include/git2/checkout.h | 21 ++++++++-----
 src/checkout.c          |  4 +--
 tests/checkout/tree.c   | 78 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 93 insertions(+), 10 deletions(-)

diff --git a/include/git2/checkout.h b/include/git2/checkout.h
index efafdc3e4..0e9d338c6 100644
--- a/include/git2/checkout.h
+++ b/include/git2/checkout.h
@@ -174,7 +174,12 @@ typedef enum {
  * - GIT_CHECKOUT_NOTIFY_IGNORED notifies about ignored files.
  *
  * Returning a non-zero value from this callback will cancel the checkout.
- * Notification callbacks are made prior to modifying any files on disk.
+ * The non-zero return value will be propagated back and returned by the
+ * git_checkout_... call.
+ *
+ * Notification callbacks are made prior to modifying any files on disk,
+ * so canceling on any notification will still happen prior to any files
+ * being modified.
  */
 typedef enum {
 	GIT_CHECKOUT_NOTIFY_NONE      = 0,
@@ -252,9 +257,9 @@ typedef struct git_checkout_opts {
  *
  * @param repo repository to check out (must be non-bare)
  * @param opts specifies checkout options (may be NULL)
- * @return 0 on success, GIT_EUNBORNBRANCH when HEAD points to a non existing
- * branch, GIT_ERROR otherwise (use giterr_last for information
- * about the error)
+ * @return 0 on success, GIT_EUNBORNBRANCH if HEAD points to a non
+ *         existing branch, non-zero value returned by `notify_cb`, or
+ *         other error code < 0 (use giterr_last for error details)
  */
 GIT_EXTERN(int) git_checkout_head(
 	git_repository *repo,
@@ -266,8 +271,8 @@ GIT_EXTERN(int) git_checkout_head(
  * @param repo repository into which to check out (must be non-bare)
  * @param index index to be checked out (or NULL to use repository index)
  * @param opts specifies checkout options (may be NULL)
- * @return 0 on success, GIT_ERROR otherwise (use giterr_last for information
- * about the error)
+ * @return 0 on success, non-zero return value from `notify_cb`, or error
+ *         code < 0 (use giterr_last for error details)
  */
 GIT_EXTERN(int) git_checkout_index(
 	git_repository *repo,
@@ -282,8 +287,8 @@ GIT_EXTERN(int) git_checkout_index(
  * @param treeish a commit, tag or tree which content will be used to update
  * the working directory (or NULL to use HEAD)
  * @param opts specifies checkout options (may be NULL)
- * @return 0 on success, GIT_ERROR otherwise (use giterr_last for information
- * about the error)
+ * @return 0 on success, non-zero return value from `notify_cb`, or error
+ *         code < 0 (use giterr_last for error details)
  */
 GIT_EXTERN(int) git_checkout_tree(
 	git_repository *repo,
diff --git a/src/checkout.c b/src/checkout.c
index a292e3d4c..f7dd052c7 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -993,7 +993,7 @@ static int checkout_get_actions(
 
 	git_vector_foreach(deltas, i, delta) {
 		error = checkout_action(&act, data, delta, workdir, &wditem, &pathspec);
-		if (error)
+		if (error != 0)
 			goto fail;
 
 		actions[i] = act;
@@ -1957,7 +1957,7 @@ int git_checkout_iterator(
 	 * actions to be taken, plus look for conflicts and send notifications,
 	 * then loop through conflicts.
 	 */
-	if ((error = checkout_get_actions(&actions, &counts, &data, workdir)) < 0)
+	if ((error = checkout_get_actions(&actions, &counts, &data, workdir)) != 0)
 		goto cleanup;
 
 	data.total_steps = counts[CHECKOUT_ACTION__REMOVE] +
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index 66b01bc7f..ac48bfcdd 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -486,6 +486,84 @@ void test_checkout_tree__donot_update_deleted_file_by_default(void)
 	git_index_free(index);
 }
 
+struct checkout_cancel_at {
+	const char *filename;
+	int error;
+	int count;
+};
+
+static int checkout_cancel_cb(
+	git_checkout_notify_t why,
+	const char *path,
+	const git_diff_file *b,
+	const git_diff_file *t,
+	const git_diff_file *w,
+	void *payload)
+{
+	struct checkout_cancel_at *ca = payload;
+
+	GIT_UNUSED(why); GIT_UNUSED(b); GIT_UNUSED(t); GIT_UNUSED(w);
+
+	ca->count++;
+
+	if (!strcmp(path, ca->filename))
+		return ca->error;
+
+	return 0;
+}
+
+void test_checkout_tree__can_cancel_checkout_from_notify(void)
+{
+	struct checkout_cancel_at ca;
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_oid oid;
+	git_object *obj = NULL;
+
+	assert_on_branch(g_repo, "master");
+
+	cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/dir"));
+	cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY));
+
+	ca.filename = "new.txt";
+	ca.error = -5555;
+	ca.count = 0;
+
+	opts.notify_flags = GIT_CHECKOUT_NOTIFY_UPDATED;
+	opts.notify_cb = checkout_cancel_cb;
+	opts.notify_payload = &ca;
+	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
+
+	cl_assert(!git_path_exists("testrepo/new.txt"));
+
+	cl_git_fail_with(git_checkout_tree(g_repo, obj, &opts), -5555);
+
+	cl_assert(!git_path_exists("testrepo/new.txt"));
+
+	/* on case-insensitive FS = a/b.txt, branch_file.txt, new.txt */
+	/* on case-sensitive FS   = README, then above */
+
+	if (cl_repo_get_bool(g_repo, "core.ignorecase"))
+		cl_assert_equal_i(3, ca.count);
+	else
+		cl_assert_equal_i(4, ca.count);
+
+	/* and again with a different stopping point and return code */
+	ca.filename = "README";
+	ca.error = 123;
+	ca.count = 0;
+
+	cl_git_fail_with(git_checkout_tree(g_repo, obj, &opts), 123);
+
+	cl_assert(!git_path_exists("testrepo/new.txt"));
+
+	if (cl_repo_get_bool(g_repo, "core.ignorecase"))
+		cl_assert_equal_i(4, ca.count);
+	else
+		cl_assert_equal_i(1, ca.count);
+
+	git_object_free(obj);
+}
+
 void test_checkout_tree__can_checkout_with_last_workdir_item_missing(void)
 {
 	git_index *index = NULL;
-- 
cgit v1.2.3


From 8f1066a05f15ce0e3f91614cf9915162ce6447ee Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 10 Dec 2013 16:02:24 -0800
Subject: Update clone doc and tests for callback return val

Clone callbacks can return non-zero values to cancel the clone.
This adds some tests to verify that this actually works and updates
the documentation to be clearer that this can happen and that the
return value will be propagated back by the clone function.
---
 include/git2/clone.h    | 57 ++++++++++++++++++++++++++++---------------------
 src/clone.c             |  3 ++-
 tests/clone/nonetwork.c | 57 ++++++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 91 insertions(+), 26 deletions(-)

diff --git a/include/git2/clone.h b/include/git2/clone.h
index 331cf92e7..59a73aa15 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -26,23 +26,25 @@ GIT_BEGIN_DECL
 /**
  * Clone options structure
  *
- * Use zeros to indicate default settings.  It's easiest to use the
- * `GIT_CLONE_OPTIONS_INIT` macro:
+ * Use the GIT_CLONE_OPTIONS_INIT to get the default settings, like this:
  *
  *		git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
  *
- * - `checkout_opts` is options for the checkout step.  To disable checkout,
- *   set the `checkout_strategy` to GIT_CHECKOUT_DEFAULT.
- * - `bare` should be set to zero to create a standard repo, non-zero for
- *   a bare repo
- * - `ignore_cert_errors` should be set to 1 if errors validating the remote host's
- *   certificate should be ignored.
+ * - `checkout_opts` are option passed to the checkout step.  To disable
+ *   checkout, set the `checkout_strategy` to GIT_CHECKOUT_NONE.
+ *   Generally you will want the use GIT_CHECKOUT_SAFE_CREATE to create
+ *   all files in the working directory for the newly cloned repository.
+ * - `bare` should be set to zero (false) to create a standard repo,
+ *   or non-zero for a bare repo
+ * - `ignore_cert_errors` should be set to 1 if errors validating the
+ *   remote host's certificate should be ignored.
  *
  *   ** "origin" remote options: **
- * - `remote_name` is the name given to the "origin" remote.  The default is
- *   "origin".
- * - `checkout_branch` gives the name of the branch to checkout. NULL means
- *   use the remote's HEAD.
+ *
+ * - `remote_name` is the name to be given to the "origin" remote.  The
+ *   default is "origin".
+ * - `checkout_branch` gives the name of the branch to checkout.  NULL
+ *   means use the remote's HEAD.
  */
 
 typedef struct git_clone_options {
@@ -70,16 +72,17 @@ typedef struct git_clone_options {
  * @param out pointer that will receive the resulting repository object
  * @param url the remote repository to clone
  * @param local_path local directory to clone to
- * @param options configuration options for the clone.  If NULL, the function
- * works as though GIT_OPTIONS_INIT were passed.
- * @return 0 on success, GIT_ERROR otherwise (use giterr_last for information
- * about the error)
+ * @param options configuration options for the clone.  If NULL, the
+ *        function works as though GIT_OPTIONS_INIT were passed.
+ * @return 0 on success, any non-zero return value from a callback
+ *         function, or a negative value to indicate an error (use
+ *         `giterr_last` for a detailed error message)
  */
 GIT_EXTERN(int) git_clone(
-		git_repository **out,
-		const char *url,
-		const char *local_path,
-		const git_clone_options *options);
+	git_repository **out,
+	const char *url,
+	const char *local_path,
+	const git_clone_options *options);
 
 /**
  * Clone into a repository
@@ -91,11 +94,17 @@ GIT_EXTERN(int) git_clone(
  * @param repo the repository to use
  * @param remote the remote repository to clone from
  * @param co_opts options to use during checkout
- * @param branch the branch to checkout after the clone, pass NULL for the remote's
- * default branch
- * @return 0 on success or an error code
+ * @param branch the branch to checkout after the clone, pass NULL for the
+ *        remote's default branch
+ * @return 0 on success, any non-zero return value from a callback
+ *         function, or a negative value to indicate an error (use
+ *         `giterr_last` for a detailed error message)
  */
-GIT_EXTERN(int) git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_opts *co_opts, const char *branch);
+GIT_EXTERN(int) git_clone_into(
+	git_repository *repo,
+	git_remote *remote,
+	const git_checkout_opts *co_opts,
+	const char *branch);
 
 /** @} */
 GIT_END_DECL
diff --git a/src/clone.c b/src/clone.c
index ffbe8f8af..828c47ffb 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -408,9 +408,10 @@ int git_clone(
 		git_remote_free(origin);
 	}
 
-	if (error < 0) {
+	if (error != 0) {
 		git_repository_free(repo);
 		repo = NULL;
+
 		(void)git_futils_rmdir_r(local_path, NULL, rmdir_flags);
 	}
 
diff --git a/tests/clone/nonetwork.c b/tests/clone/nonetwork.c
index a286e2a8f..3cd5fb7f6 100644
--- a/tests/clone/nonetwork.c
+++ b/tests/clone/nonetwork.c
@@ -22,7 +22,7 @@ void test_clone_nonetwork__initialize(void)
 	memset(&g_options, 0, sizeof(git_clone_options));
 	g_options.version = GIT_CLONE_OPTIONS_VERSION;
 	g_options.checkout_opts = dummy_opts;
-	g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE;
+	g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 	g_options.remote_callbacks = dummy_callbacks;
 }
 
@@ -151,6 +151,61 @@ void test_clone_nonetwork__can_checkout_given_branch(void)
 
 	cl_git_pass(git_repository_head(&g_ref, g_repo));
 	cl_assert_equal_s(git_reference_name(g_ref), "refs/heads/test");
+
+	cl_assert(git_path_exists("foo/readme.txt"));
+}
+
+static int clone_cancel_fetch_transfer_progress_cb(
+	const git_transfer_progress *stats, void *data)
+{
+	GIT_UNUSED(stats); GIT_UNUSED(data);
+	return -54321;
+}
+
+void test_clone_nonetwork__can_cancel_clone_in_fetch(void)
+{
+	g_options.checkout_branch = "test";
+
+	g_options.remote_callbacks.transfer_progress =
+		clone_cancel_fetch_transfer_progress_cb;
+
+	cl_git_fail_with(git_clone(
+		&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options),
+		-54321);
+
+	cl_assert(!g_repo);
+	cl_assert(!git_path_exists("foo/readme.txt"));
+}
+
+static int clone_cancel_checkout_cb(
+	git_checkout_notify_t why,
+	const char *path,
+	const git_diff_file *b,
+	const git_diff_file *t,
+	const git_diff_file *w,
+	void *payload)
+{
+	const char *at_file = payload;
+	GIT_UNUSED(why); GIT_UNUSED(b); GIT_UNUSED(t); GIT_UNUSED(w);
+	if (!strcmp(path, at_file))
+		return -12345;
+	return 0;
+}
+
+void test_clone_nonetwork__can_cancel_clone_in_checkout(void)
+{
+	g_options.checkout_branch = "test";
+
+	g_options.checkout_opts.notify_flags = GIT_CHECKOUT_NOTIFY_UPDATED;
+	g_options.checkout_opts.notify_cb = clone_cancel_checkout_cb;
+	g_options.checkout_opts.notify_payload = "readme.txt";
+
+	cl_git_fail_with(git_clone(
+		&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options),
+		-12345);
+
+	cl_assert(!g_repo);
+	cl_assert(!git_path_exists("foo/readme.txt"));
 }
 
 void test_clone_nonetwork__can_detached_head(void)
-- 
cgit v1.2.3


From 8046b26cb1e06ef7699d16395598754a8ec5564b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 10 Dec 2013 16:16:36 -0800
Subject: Try a test that won't assert on Linux

---
 tests/checkout/tree.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index ac48bfcdd..d2e92f8e8 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -542,7 +542,7 @@ void test_checkout_tree__can_cancel_checkout_from_notify(void)
 	/* on case-insensitive FS = a/b.txt, branch_file.txt, new.txt */
 	/* on case-sensitive FS   = README, then above */
 
-	if (cl_repo_get_bool(g_repo, "core.ignorecase"))
+	if (git_path_exists("testrepo/.git/CoNfIg")) /* case insensitive */
 		cl_assert_equal_i(3, ca.count);
 	else
 		cl_assert_equal_i(4, ca.count);
@@ -556,7 +556,7 @@ void test_checkout_tree__can_cancel_checkout_from_notify(void)
 
 	cl_assert(!git_path_exists("testrepo/new.txt"));
 
-	if (cl_repo_get_bool(g_repo, "core.ignorecase"))
+	if (git_path_exists("testrepo/.git/CoNfIg")) /* case insensitive */
 		cl_assert_equal_i(4, ca.count);
 	else
 		cl_assert_equal_i(1, ca.count);
-- 
cgit v1.2.3


From 8b22d862fb4419b219210027f18c1e97dd36fa8b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 11 Dec 2013 11:55:00 -0800
Subject: More improvements to callback return value tests

This time actually checking return values in diff notify tests and
actually testing callbacks for the index all-all/update-all/etc
functions.
---
 tests/diff/notify.c  |   6 +-
 tests/index/addall.c | 158 +++++++++++++++++++++++++++++++++++++++++----------
 2 files changed, 132 insertions(+), 32 deletions(-)

diff --git a/tests/diff/notify.c b/tests/diff/notify.c
index f6accd004..da7390d3f 100644
--- a/tests/diff/notify.c
+++ b/tests/diff/notify.c
@@ -182,10 +182,12 @@ void test_diff_notify__notify_cb_can_abort_diff(void)
 	opts.pathspec.count   = 1;
 
 	pathspec = "file_deleted";
-	cl_git_fail(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+	cl_git_fail_with(
+		git_diff_index_to_workdir(&diff, g_repo, NULL, &opts), -42);
 
 	pathspec = "staged_changes_modified_file";
-	cl_git_fail(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+	cl_git_fail_with(
+		git_diff_index_to_workdir(&diff, g_repo, NULL, &opts), -42);
 }
 
 static int filter_all(
diff --git a/tests/index/addall.c b/tests/index/addall.c
index 44c51279d..452733710 100644
--- a/tests/index/addall.c
+++ b/tests/index/addall.c
@@ -4,6 +4,7 @@
 #include "fileops.h"
 
 git_repository *g_repo = NULL;
+#define TEST_DIR "addall"
 
 void test_index_addall__initialize(void)
 {
@@ -13,6 +14,8 @@ void test_index_addall__cleanup(void)
 {
 	git_repository_free(g_repo);
 	g_repo = NULL;
+
+	cl_fixture_cleanup(TEST_DIR);
 }
 
 #define STATUS_INDEX_FLAGS \
@@ -132,6 +135,25 @@ static void check_stat_data(git_index *index, const char *path, bool match)
 	}
 }
 
+static void addall_create_test_repo(bool check_every_step)
+{
+	cl_git_pass(git_repository_init(&g_repo, TEST_DIR, false));
+	if (check_every_step)
+		check_status(g_repo, 0, 0, 0, 0, 0, 0, 0);
+
+	cl_git_mkfile(TEST_DIR "/file.foo", "a file");
+	if (check_every_step)
+		check_status(g_repo, 0, 0, 0, 1, 0, 0, 0);
+
+	cl_git_mkfile(TEST_DIR "/.gitignore", "*.foo\n");
+	if (check_every_step)
+		check_status(g_repo, 0, 0, 0, 1, 0, 0, 1);
+
+	cl_git_mkfile(TEST_DIR "/file.bar", "another file");
+	if (check_every_step)
+		check_status(g_repo, 0, 0, 0, 2, 0, 0, 1);
+}
+
 void test_index_addall__repo_lifecycle(void)
 {
 	int error;
@@ -139,43 +161,33 @@ void test_index_addall__repo_lifecycle(void)
 	git_strarray paths = { NULL, 0 };
 	char *strs[1];
 
-	cl_git_pass(git_repository_init(&g_repo, "addall", false));
-	check_status(g_repo, 0, 0, 0, 0, 0, 0, 0);
+	addall_create_test_repo(true);
 
 	cl_git_pass(git_repository_index(&index, g_repo));
 
-	cl_git_mkfile("addall/file.foo", "a file");
-	check_status(g_repo, 0, 0, 0, 1, 0, 0, 0);
-
-	cl_git_mkfile("addall/.gitignore", "*.foo\n");
-	check_status(g_repo, 0, 0, 0, 1, 0, 0, 1);
-
-	cl_git_mkfile("addall/file.bar", "another file");
-	check_status(g_repo, 0, 0, 0, 2, 0, 0, 1);
-
 	strs[0] = "file.*";
 	paths.strings = strs;
 	paths.count   = 1;
 
 	cl_git_pass(git_index_add_all(index, &paths, 0, NULL, NULL));
-	check_stat_data(index, "addall/file.bar", true);
+	check_stat_data(index, TEST_DIR "/file.bar", true);
 	check_status(g_repo, 1, 0, 0, 1, 0, 0, 1);
 
-	cl_git_rewritefile("addall/file.bar", "new content for file");
-	check_stat_data(index, "addall/file.bar", false);
+	cl_git_rewritefile(TEST_DIR "/file.bar", "new content for file");
+	check_stat_data(index, TEST_DIR "/file.bar", false);
 	check_status(g_repo, 1, 0, 0, 1, 0, 1, 1);
 
-	cl_git_mkfile("addall/file.zzz", "yet another one");
-	cl_git_mkfile("addall/other.zzz", "yet another one");
-	cl_git_mkfile("addall/more.zzz", "yet another one");
+	cl_git_mkfile(TEST_DIR "/file.zzz", "yet another one");
+	cl_git_mkfile(TEST_DIR "/other.zzz", "yet another one");
+	cl_git_mkfile(TEST_DIR "/more.zzz", "yet another one");
 	check_status(g_repo, 1, 0, 0, 4, 0, 1, 1);
 
 	cl_git_pass(git_index_update_all(index, NULL, NULL, NULL));
-	check_stat_data(index, "addall/file.bar", true);
+	check_stat_data(index, TEST_DIR "/file.bar", true);
 	check_status(g_repo, 1, 0, 0, 4, 0, 0, 1);
 
 	cl_git_pass(git_index_add_all(index, &paths, 0, NULL, NULL));
-	check_stat_data(index, "addall/file.zzz", true);
+	check_stat_data(index, TEST_DIR "/file.zzz", true);
 	check_status(g_repo, 2, 0, 0, 3, 0, 0, 1);
 
 	cl_repo_commit_from_index(NULL, g_repo, NULL, 0, "first commit");
@@ -195,27 +207,27 @@ void test_index_addall__repo_lifecycle(void)
 	/* add with force - should allow */
 	cl_git_pass(git_index_add_all(
 		index, &paths, GIT_INDEX_ADD_FORCE, NULL, NULL));
-	check_stat_data(index, "addall/file.foo", true);
+	check_stat_data(index, TEST_DIR "/file.foo", true);
 	check_status(g_repo, 1, 0, 0, 3, 0, 0, 0);
 
 	/* now it's in the index, so regular add should work */
-	cl_git_rewritefile("addall/file.foo", "new content for file");
-	check_stat_data(index, "addall/file.foo", false);
+	cl_git_rewritefile(TEST_DIR "/file.foo", "new content for file");
+	check_stat_data(index, TEST_DIR "/file.foo", false);
 	check_status(g_repo, 1, 0, 0, 3, 0, 1, 0);
 
 	cl_git_pass(git_index_add_all(index, &paths, 0, NULL, NULL));
-	check_stat_data(index, "addall/file.foo", true);
+	check_stat_data(index, TEST_DIR "/file.foo", true);
 	check_status(g_repo, 1, 0, 0, 3, 0, 0, 0);
 
 	cl_git_pass(git_index_add_bypath(index, "more.zzz"));
-	check_stat_data(index, "addall/more.zzz", true);
+	check_stat_data(index, TEST_DIR "/more.zzz", true);
 	check_status(g_repo, 2, 0, 0, 2, 0, 0, 0);
 
-	cl_git_rewritefile("addall/file.zzz", "new content for file");
+	cl_git_rewritefile(TEST_DIR "/file.zzz", "new content for file");
 	check_status(g_repo, 2, 0, 0, 2, 0, 1, 0);
 
 	cl_git_pass(git_index_add_bypath(index, "file.zzz"));
-	check_stat_data(index, "addall/file.zzz", true);
+	check_stat_data(index, TEST_DIR "/file.zzz", true);
 	check_status(g_repo, 2, 0, 1, 2, 0, 0, 0);
 
 	strs[0] = "*.zzz";
@@ -228,7 +240,7 @@ void test_index_addall__repo_lifecycle(void)
 	cl_repo_commit_from_index(NULL, g_repo, NULL, 0, "second commit");
 	check_status(g_repo, 0, 0, 0, 3, 0, 0, 0);
 
-	cl_must_pass(p_unlink("addall/file.zzz"));
+	cl_must_pass(p_unlink(TEST_DIR "/file.zzz"));
 	check_status(g_repo, 0, 0, 0, 3, 1, 0, 0);
 
 	/* update_all should be able to remove entries */
@@ -240,9 +252,9 @@ void test_index_addall__repo_lifecycle(void)
 	check_status(g_repo, 3, 1, 0, 0, 0, 0, 0);
 
 	/* must be able to remove at any position while still updating other files */
-	cl_must_pass(p_unlink("addall/.gitignore"));
-	cl_git_rewritefile("addall/file.zzz", "reconstructed file");
-	cl_git_rewritefile("addall/more.zzz", "altered file reality");
+	cl_must_pass(p_unlink(TEST_DIR "/.gitignore"));
+	cl_git_rewritefile(TEST_DIR "/file.zzz", "reconstructed file");
+	cl_git_rewritefile(TEST_DIR "/more.zzz", "altered file reality");
 	check_status(g_repo, 3, 1, 0, 1, 1, 1, 0);
 
 	cl_git_pass(git_index_update_all(index, NULL, NULL, NULL));
@@ -256,3 +268,89 @@ void test_index_addall__repo_lifecycle(void)
 
 	git_index_free(index);
 }
+
+static int addall_match_prefix(
+	const char *path, const char *matched_pathspec, void *payload)
+{
+	GIT_UNUSED(matched_pathspec);
+	return !git__prefixcmp(path, payload) ? 0 : 1;
+}
+
+static int addall_match_suffix(
+	const char *path, const char *matched_pathspec, void *payload)
+{
+	GIT_UNUSED(matched_pathspec);
+	return !git__suffixcmp(path, payload) ? 0 : 1;
+}
+
+static int addall_cancel_at(
+	const char *path, const char *matched_pathspec, void *payload)
+{
+	GIT_UNUSED(matched_pathspec);
+	return !strcmp(path, payload) ? -123 : 0;
+}
+
+void test_index_addall__callback_filtering(void)
+{
+	git_index *index;
+
+	addall_create_test_repo(false);
+
+	cl_git_pass(git_repository_index(&index, g_repo));
+
+	cl_git_pass(
+		git_index_add_all(index, NULL, 0, addall_match_prefix, "file."));
+	check_stat_data(index, TEST_DIR "/file.bar", true);
+	check_status(g_repo, 1, 0, 0, 1, 0, 0, 1);
+
+	cl_git_mkfile(TEST_DIR "/file.zzz", "yet another one");
+	cl_git_mkfile(TEST_DIR "/more.zzz", "yet another one");
+	cl_git_mkfile(TEST_DIR "/other.zzz", "yet another one");
+
+	cl_git_pass(git_index_update_all(index, NULL, NULL, NULL));
+	check_stat_data(index, TEST_DIR "/file.bar", true);
+	check_status(g_repo, 1, 0, 0, 4, 0, 0, 1);
+
+	cl_git_pass(
+		git_index_add_all(index, NULL, 0, addall_match_prefix, "other"));
+	check_stat_data(index, TEST_DIR "/other.zzz", true);
+	check_status(g_repo, 2, 0, 0, 3, 0, 0, 1);
+
+	cl_git_pass(
+		git_index_add_all(index, NULL, 0, addall_match_suffix, ".zzz"));
+	check_status(g_repo, 4, 0, 0, 1, 0, 0, 1);
+
+	cl_git_pass(
+		git_index_remove_all(index, NULL, addall_match_suffix, ".zzz"));
+	check_status(g_repo, 1, 0, 0, 4, 0, 0, 1);
+
+	cl_git_fail_with(
+		git_index_add_all(index, NULL, 0, addall_cancel_at, "more.zzz"), -123);
+	check_status(g_repo, 3, 0, 0, 2, 0, 0, 1);
+
+	cl_git_fail_with(
+		git_index_add_all(index, NULL, 0, addall_cancel_at, "other.zzz"), -123);
+	check_status(g_repo, 4, 0, 0, 1, 0, 0, 1);
+
+	cl_git_pass(
+		git_index_add_all(index, NULL, 0, addall_match_suffix, ".zzz"));
+	check_status(g_repo, 5, 0, 0, 0, 0, 0, 1);
+
+	cl_must_pass(p_unlink(TEST_DIR "/file.zzz"));
+	cl_must_pass(p_unlink(TEST_DIR "/more.zzz"));
+	cl_must_pass(p_unlink(TEST_DIR "/other.zzz"));
+
+	cl_git_fail_with(
+		git_index_update_all(index, NULL, addall_cancel_at, "more.zzz"), -123);
+	/* file.zzz removed from index (so Index Adds 5 -> 4) and
+	 * more.zzz + other.zzz removed (so Worktree Dels 0 -> 2) */
+	check_status(g_repo, 4, 0, 0, 0, 2, 0, 1);
+
+	cl_git_fail_with(
+		git_index_update_all(index, NULL, addall_cancel_at, "other.zzz"), -123);
+	/* more.zzz removed from index (so Index Adds 4 -> 3) and
+	 * Just other.zzz removed (so Worktree Dels 2 -> 1) */
+	check_status(g_repo, 3, 0, 0, 0, 1, 0, 1);
+
+	git_index_free(index);
+}
-- 
cgit v1.2.3


From 7697e54176ccab22ed6d4597d7256e9a1e6ff202 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 11 Dec 2013 15:02:20 -0800
Subject: Test cancel from indexer progress callback

This adds tests that try canceling an indexer operation from
within the progress callback.

After writing the tests, I wanted to run this under valgrind and
had a number of errors in that situation because mmap wasn't
working.  I added a CMake option to force emulation of mmap and
consolidated the Amiga-specific code into that new place (so we
don't actually need separate Amiga code now, just have to turn on
-DNO_MMAP).

Additionally, I made the indexer code propagate error codes more
reliably than it used to.
---
 CMakeLists.txt              |  7 +++++--
 include/git2/pack.h         |  3 ++-
 src/amiga/map.c             | 48 ---------------------------------------------
 src/indexer.c               | 28 ++++++++++++++------------
 src/posix.c                 | 36 ++++++++++++++++++++++++++++++++++
 src/unix/map.c              |  2 +-
 src/win32/map.c             |  3 ++-
 tests/pack/indexer.c        | 23 +++++++++++-----------
 tests/pack/packbuilder.c    | 25 ++++++++++++++++++++---
 tests/valgrind-supp-mac.txt |  8 --------
 10 files changed, 95 insertions(+), 88 deletions(-)
 delete mode 100644 src/amiga/map.c

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9c19a5a79..48cbccb4e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,6 +33,7 @@ OPTION( ANDROID				"Build for android NDK"	 				OFF )
 
 OPTION( USE_ICONV			"Link with and use iconv library" 		OFF )
 OPTION( USE_SSH				"Link with libssh to enable SSH support" ON )
+OPTION( VALGRIND			"Configure build for valgrind"			OFF )
 
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	SET( USE_ICONV ON )
@@ -340,9 +341,11 @@ IF (WIN32 AND NOT CYGWIN)
 	ADD_DEFINITIONS(-DWIN32 -D_WIN32_WINNT=0x0501)
 	FILE(GLOB SRC_OS src/win32/*.c src/win32/*.h)
 ELSEIF (AMIGA)
-	ADD_DEFINITIONS(-DNO_ADDRINFO -DNO_READDIR_R)
-	FILE(GLOB SRC_OS src/amiga/*.c src/amiga/*.h)
+	ADD_DEFINITIONS(-DNO_ADDRINFO -DNO_READDIR_R -DNO_MMAP)
 ELSE()
+	IF (VALGRIND)
+		ADD_DEFINITIONS(-DNO_MMAP)
+	ENDIF()
 	FILE(GLOB SRC_OS src/unix/*.c src/unix/*.h)
 ENDIF()
 FILE(GLOB SRC_GIT2 src/*.c src/*.h src/transports/*.c src/transports/*.h src/xdiff/*.c src/xdiff/*.h)
diff --git a/include/git2/pack.h b/include/git2/pack.h
index 88a2716bb..11bb559d8 100644
--- a/include/git2/pack.h
+++ b/include/git2/pack.h
@@ -52,7 +52,7 @@ typedef enum {
 	GIT_PACKBUILDER_ADDING_OBJECTS = 0,
 	GIT_PACKBUILDER_DELTAFICATION = 1,
 } git_packbuilder_stage_t;
-	
+
 /**
  * Initialize a new packbuilder
  *
@@ -143,6 +143,7 @@ GIT_EXTERN(int) git_packbuilder_write(
 GIT_EXTERN(const git_oid *) git_packbuilder_hash(git_packbuilder *pb);
 
 typedef int (*git_packbuilder_foreach_cb)(void *buf, size_t size, void *payload);
+
 /**
  * Create the new pack and pass each object to the callback
  *
diff --git a/src/amiga/map.c b/src/amiga/map.c
deleted file mode 100644
index 0ba7995c6..000000000
--- a/src/amiga/map.c
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#include <git2/common.h>
-
-#ifndef GIT_WIN32
-
-#include "posix.h"
-#include "map.h"
-#include <errno.h>
-
-int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
-{
-	GIT_MMAP_VALIDATE(out, len, prot, flags);
-
-	out->data = NULL;
-	out->len = 0;
-
-	if ((prot & GIT_PROT_WRITE) && ((flags & GIT_MAP_TYPE) == GIT_MAP_SHARED)) {
-		giterr_set(GITERR_OS, "Trying to map shared-writeable");
-		return -1;
-	}
-
-	out->data = malloc(len);
-	GITERR_CHECK_ALLOC(out->data);
-
-	if ((p_lseek(fd, offset, SEEK_SET) < 0) || ((size_t)p_read(fd, out->data, len) != len)) {
-		giterr_set(GITERR_OS, "mmap emulation failed");
-		return -1;
-	}
-
-	out->len = len;
-	return 0;
-}
-
-int p_munmap(git_map *map)
-{
-	assert(map != NULL);
-	free(map->data);
-
-	return 0;
-}
-
-#endif
-
diff --git a/src/indexer.c b/src/indexer.c
index 88897d07d..718c69814 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -441,8 +441,8 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 
 	processed = stats->indexed_objects;
 
-	if (git_filebuf_write(&idx->pack_file, data, size) < 0)
-		return -1;
+	if ((error = git_filebuf_write(&idx->pack_file, data, size)) < 0)
+		return error;
 
 	hash_partially(idx, data, (int)size);
 
@@ -450,12 +450,12 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 	if (idx->opened_pack) {
 		idx->pack->mwf.size += size;
 	} else {
-		if (open_pack(&idx->pack, idx->pack_file.path_lock) < 0)
-			return -1;
+		if ((error = open_pack(&idx->pack, idx->pack_file.path_lock)) < 0)
+			return error;
 		idx->opened_pack = 1;
 		mwf = &idx->pack->mwf;
-		if (git_mwindow_file_register(&idx->pack->mwf) < 0)
-			return -1;
+		if ((error = git_mwindow_file_register(&idx->pack->mwf)) < 0)
+			return error;
 	}
 
 	if (!idx->parsed_header) {
@@ -464,8 +464,8 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 		if ((unsigned)idx->pack->mwf.size < sizeof(struct git_pack_header))
 			return 0;
 
-		if (parse_header(&idx->hdr, idx->pack) < 0)
-			return -1;
+		if ((error = parse_header(&idx->hdr, idx->pack)) < 0)
+			return error;
 
 		idx->parsed_header = 1;
 		idx->nr_objects = ntohl(hdr->hdr_entries);
@@ -503,6 +503,7 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 
 	/* As the file grows any windows we try to use will be out of date */
 	git_mwindow_free_all(mwf);
+
 	while (processed < idx->nr_objects) {
 		git_packfile_stream *stream = &idx->stream;
 		git_off_t entry_start = idx->off;
@@ -520,7 +521,7 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 				return 0;
 			}
 			if (error < 0)
-				return error;
+				goto on_error;
 
 			git_mwindow_close(&w);
 			idx->entry_start = entry_start;
@@ -533,7 +534,7 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 					return 0;
 				}
 				if (error < 0)
-					return error;
+					goto on_error;
 
 				idx->have_delta = 1;
 			} else {
@@ -542,9 +543,10 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 			}
 
 			idx->have_stream = 1;
-			if (git_packfile_stream_open(stream, idx->pack, idx->off) < 0)
-				goto on_error;
 
+			error = git_packfile_stream_open(stream, idx->pack, idx->off);
+			if (error < 0)
+				goto on_error;
 		}
 
 		if (idx->have_delta) {
@@ -858,7 +860,7 @@ int git_indexer_commit(git_indexer *idx, git_transfer_progress *stats)
 
 	/* Test for this before resolve_deltas(), as it plays with idx->off */
 	if (idx->off < idx->pack->mwf.size - 20) {
-		giterr_set(GITERR_INDEXER, "unexpected data at the end of the pack");
+		giterr_set(GITERR_INDEXER, "Unexpected data at the end of the pack");
 		return -1;
 	}
 
diff --git a/src/posix.c b/src/posix.c
index b75109b83..525785f35 100644
--- a/src/posix.c
+++ b/src/posix.c
@@ -203,4 +203,40 @@ int p_write(git_file fd, const void *buf, size_t cnt)
 	return 0;
 }
 
+#ifdef NO_MMAP
 
+#include "map.h"
+
+int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
+{
+	GIT_MMAP_VALIDATE(out, len, prot, flags);
+
+	out->data = NULL;
+	out->len = 0;
+
+	if ((prot & GIT_PROT_WRITE) && ((flags & GIT_MAP_TYPE) == GIT_MAP_SHARED)) {
+		giterr_set(GITERR_OS, "Trying to map shared-writeable");
+		return -1;
+	}
+
+	out->data = malloc(len);
+	GITERR_CHECK_ALLOC(out->data);
+
+	if ((p_lseek(fd, offset, SEEK_SET) < 0) || ((size_t)p_read(fd, out->data, len) != len)) {
+		giterr_set(GITERR_OS, "mmap emulation failed");
+		return -1;
+	}
+
+	out->len = len;
+	return 0;
+}
+
+int p_munmap(git_map *map)
+{
+	assert(map != NULL);
+	free(map->data);
+
+	return 0;
+}
+
+#endif
diff --git a/src/unix/map.c b/src/unix/map.c
index 7de99c99d..e62ab3e76 100644
--- a/src/unix/map.c
+++ b/src/unix/map.c
@@ -6,7 +6,7 @@
  */
 #include <git2/common.h>
 
-#ifndef GIT_WIN32
+#if !defined(GIT_WIN32) && !defined(NO_MMAP)
 
 #include "map.h"
 #include <sys/mman.h>
diff --git a/src/win32/map.c b/src/win32/map.c
index 44c6c4e2e..902ea3994 100644
--- a/src/win32/map.c
+++ b/src/win32/map.c
@@ -8,6 +8,7 @@
 #include "map.h"
 #include <errno.h>
 
+#ifndef NO_MMAP
 
 static DWORD get_page_size(void)
 {
@@ -112,4 +113,4 @@ int p_munmap(git_map *map)
 	return error;
 }
 
-
+#endif
diff --git a/tests/pack/indexer.c b/tests/pack/indexer.c
index 07963a9e7..084f8e666 100644
--- a/tests/pack/indexer.c
+++ b/tests/pack/indexer.c
@@ -11,7 +11,7 @@
  * This is a packfile with three objects. The second is a delta which
  * depends on the third, which is also a delta.
  */
-unsigned char out_of_order_pack[] = {
+static const unsigned char out_of_order_pack[] = {
   0x50, 0x41, 0x43, 0x4b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x03,
   0x32, 0x78, 0x9c, 0x63, 0x67, 0x00, 0x00, 0x00, 0x10, 0x00, 0x08, 0x76,
   0xe6, 0x8f, 0xe8, 0x12, 0x9b, 0x54, 0x6b, 0x10, 0x1a, 0xee, 0x95, 0x10,
@@ -23,13 +23,13 @@ unsigned char out_of_order_pack[] = {
   0x19, 0x87, 0x58, 0x80, 0x61, 0x09, 0x9a, 0x33, 0xca, 0x7a, 0x31, 0x92,
   0x6f, 0xae, 0x66, 0x75
 };
-unsigned int out_of_order_pack_len = 112;
+static const unsigned int out_of_order_pack_len = 112;
 
 /*
  * Packfile with two objects. The second is a delta against an object
  * which is not in the packfile
  */
-unsigned char thin_pack[] = {
+static const unsigned char thin_pack[] = {
   0x50, 0x41, 0x43, 0x4b, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
   0x32, 0x78, 0x9c, 0x63, 0x67, 0x00, 0x00, 0x00, 0x10, 0x00, 0x08, 0x76,
   0xe6, 0x8f, 0xe8, 0x12, 0x9b, 0x54, 0x6b, 0x10, 0x1a, 0xee, 0x95, 0x10,
@@ -38,18 +38,19 @@ unsigned char thin_pack[] = {
   0x3a, 0x6f, 0x39, 0xd1, 0xfe, 0x66, 0x68, 0x6b, 0xa5, 0xe5, 0xe2, 0x97,
   0xac, 0x94, 0x6c, 0x76, 0x0b, 0x04
 };
-unsigned int thin_pack_len = 78;
+static const unsigned int thin_pack_len = 78;
 
-unsigned char base_obj[] = { 07, 076 };
-unsigned int base_obj_len = 2;
+static const unsigned char base_obj[] = { 07, 076 };
+static const unsigned int base_obj_len = 2;
 
 void test_pack_indexer__out_of_order(void)
 {
-	git_indexer *idx;
-	git_transfer_progress stats;
+	git_indexer *idx = 0;
+	git_transfer_progress stats = { 0 };
 
 	cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL, NULL));
-	cl_git_pass(git_indexer_append(idx, out_of_order_pack, out_of_order_pack_len, &stats));
+	cl_git_pass(git_indexer_append(
+		idx, out_of_order_pack, out_of_order_pack_len, &stats));
 	cl_git_pass(git_indexer_commit(idx, &stats));
 
 	cl_assert_equal_i(stats.total_objects, 3);
@@ -61,8 +62,8 @@ void test_pack_indexer__out_of_order(void)
 
 void test_pack_indexer__fix_thin(void)
 {
-	git_indexer *idx;
-	git_transfer_progress stats;
+	git_indexer *idx = NULL;
+	git_transfer_progress stats = { 0 };
 	git_repository *repo;
 	git_odb *odb;
 	git_oid id, should_id;
diff --git a/tests/pack/packbuilder.c b/tests/pack/packbuilder.c
index 1ae2322a5..53db81828 100644
--- a/tests/pack/packbuilder.c
+++ b/tests/pack/packbuilder.c
@@ -12,6 +12,7 @@ static git_packbuilder *_packbuilder;
 static git_indexer *_indexer;
 static git_vector _commits;
 static int _commits_is_initialized;
+static git_transfer_progress _stats;
 
 void test_pack_packbuilder__initialize(void)
 {
@@ -20,6 +21,7 @@ void test_pack_packbuilder__initialize(void)
 	cl_git_pass(git_packbuilder_new(&_packbuilder, _repo));
 	cl_git_pass(git_vector_init(&_commits, 0, NULL));
 	_commits_is_initialized = 1;
+	memset(&_stats, 0, sizeof(_stats));
 }
 
 void test_pack_packbuilder__cleanup(void)
@@ -184,11 +186,10 @@ void test_pack_packbuilder__permissions_readwrite(void)
 	test_write_pack_permission(0666, 0666);
 }
 
-static git_transfer_progress stats;
 static int foreach_cb(void *buf, size_t len, void *payload)
 {
 	git_indexer *idx = (git_indexer *) payload;
-	cl_git_pass(git_indexer_append(idx, buf, len, &stats));
+	cl_git_pass(git_indexer_append(idx, buf, len, &_stats));
 	return 0;
 }
 
@@ -199,6 +200,24 @@ void test_pack_packbuilder__foreach(void)
 	seed_packbuilder();
 	cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL, NULL));
 	cl_git_pass(git_packbuilder_foreach(_packbuilder, foreach_cb, idx));
-	cl_git_pass(git_indexer_commit(idx, &stats));
+	cl_git_pass(git_indexer_commit(idx, &_stats));
+	git_indexer_free(idx);
+}
+
+static int foreach_cancel_cb(void *buf, size_t len, void *payload)
+{
+	git_indexer *idx = (git_indexer *)payload;
+	cl_git_pass(git_indexer_append(idx, buf, len, &_stats));
+	return (_stats.total_objects > 2) ? -1111 : 0;
+}
+
+void test_pack_packbuilder__foreach_with_cancel(void)
+{
+	git_indexer *idx;
+
+	seed_packbuilder();
+	cl_git_pass(git_indexer_new(&idx, ".", 0, NULL, NULL, NULL));
+	cl_git_fail_with(
+		git_packbuilder_foreach(_packbuilder, foreach_cancel_cb, idx), -1111);
 	git_indexer_free(idx);
 }
diff --git a/tests/valgrind-supp-mac.txt b/tests/valgrind-supp-mac.txt
index 99833d091..0cdc975fa 100644
--- a/tests/valgrind-supp-mac.txt
+++ b/tests/valgrind-supp-mac.txt
@@ -102,14 +102,6 @@
 	...
 	fun:ssl23_connect
 }
-{
-	mac-ssl-uninitialized-4
-	Memcheck:Param
-	...
-	obj:/usr/lib/libcrypto.0.9.8.dylib
-	...
-	fun:ssl23_connect
-}
 {
 	mac-ssl-leak-1
 	Memcheck:Leak
-- 
cgit v1.2.3


From 7e3ed419593a2dc9fae3bd69fdf172de015d79d9 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 11 Dec 2013 16:56:17 -0800
Subject: Fix up some valgrind leaks and warnings

---
 src/diff_tform.c   | 29 ++++++++++++++---------------
 src/pack-objects.c | 13 ++++++++++++-
 src/path.c         |  2 +-
 src/submodule.c    |  2 +-
 4 files changed, 28 insertions(+), 18 deletions(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index 16184910a..da4bdb3f5 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -280,11 +280,8 @@ static int normalize_find_opts(
 		git_repository_config__weakptr(&cfg, diff->repo) < 0)
 		return -1;
 
-	if (given) {
+	if (given)
 		memcpy(opts, given, sizeof(*opts));
-	} else {
-		GIT_INIT_STRUCTURE(opts, GIT_DIFF_FIND_OPTIONS_VERSION);
-	}
 
 	if (!given ||
 		 (given->flags & GIT_DIFF_FIND_ALL) == GIT_DIFF_FIND_BY_CONFIG)
@@ -815,11 +812,11 @@ int git_diff_find_similar(
 	int error = 0, result;
 	uint16_t similarity;
 	git_diff_delta *src, *tgt;
-	git_diff_find_options opts;
+	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
 	size_t num_deltas, num_srcs = 0, num_tgts = 0;
 	size_t tried_srcs = 0, tried_tgts = 0;
 	size_t num_rewrites = 0, num_updates = 0, num_bumped = 0;
-	void **sigcache; /* cache of similarity metric file signatures */
+	void **sigcache = NULL; /* cache of similarity metric file signatures */
 	diff_find_match *tgt2src = NULL;
 	diff_find_match *src2tgt = NULL;
 	diff_find_match *tgt2src_copy = NULL;
@@ -829,15 +826,15 @@ int git_diff_find_similar(
 	if ((error = normalize_find_opts(diff, &opts, given_opts)) < 0)
 		return error;
 
-	/* No flags set; nothing to do */
-	if ((opts.flags & GIT_DIFF_FIND_ALL) == 0)
-		return 0;
-
 	num_deltas = diff->deltas.length;
 
 	/* TODO: maybe abort if deltas.length > rename_limit ??? */
 	if (!git__is_uint32(num_deltas))
-		return 0;
+		goto cleanup;
+
+	/* No flags set; nothing to do */
+	if ((opts.flags & GIT_DIFF_FIND_ALL) == 0)
+		goto cleanup;
 
 	sigcache = git__calloc(num_deltas * 2, sizeof(void *));
 	GITERR_CHECK_ALLOC(sigcache);
@@ -1112,11 +1109,13 @@ cleanup:
 	git__free(src2tgt);
 	git__free(tgt2src_copy);
 
-	for (t = 0; t < num_deltas * 2; ++t) {
-		if (sigcache[t] != NULL)
-			opts.metric->free_signature(sigcache[t], opts.metric->payload);
+	if (sigcache) {
+		for (t = 0; t < num_deltas * 2; ++t) {
+			if (sigcache[t] != NULL)
+				opts.metric->free_signature(sigcache[t], opts.metric->payload);
+		}
+		git__free(sigcache);
 	}
-	git__free(sigcache);
 
 	if (!given_opts || !given_opts->metric)
 		git__free(opts.metric);
diff --git a/src/pack-objects.c b/src/pack-objects.c
index 7ce1b6cb3..335944c0c 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -332,8 +332,10 @@ static int write_object(git_buf *buf, git_packbuilder *pb, git_pobject *po)
 		git_hash_update(&pb->ctx, data, size) < 0)
 		goto on_error;
 
-	if (po->delta_data)
+	if (po->delta_data) {
 		git__free(po->delta_data);
+		po->delta_data = NULL;
+	}
 
 	git_odb_object_free(obj);
 	git_buf_free(&zbuf);
@@ -612,6 +614,15 @@ static int write_pack(git_packbuilder *pb,
 	error = cb(entry_oid.id, GIT_OID_RAWSZ, data);
 
 done:
+	/* if callback cancelled writing, we must still free delta_data */
+	for ( ; i < pb->nr_objects; ++i) {
+		po = write_order[i];
+		if (po->delta_data) {
+			git__free(po->delta_data);
+			po->delta_data = NULL;
+		}
+	}
+
 	git__free(write_order);
 	git_buf_free(&buf);
 	return error;
diff --git a/src/path.c b/src/path.c
index 365bd6c00..feb273915 100644
--- a/src/path.c
+++ b/src/path.c
@@ -784,7 +784,7 @@ int git_path_iconv(git_path_iconv_t *ic, char **in, size_t *inlen)
 		return 0;
 
 	while (1) {
-		if (git_buf_grow(&ic->buf, wantlen) < 0)
+		if (git_buf_grow(&ic->buf, wantlen + 1) < 0)
 			return -1;
 
 		nfc    = ic->buf.ptr   + ic->buf.size;
diff --git a/src/submodule.c b/src/submodule.c
index 1c36d3656..f6660a87e 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -1148,7 +1148,7 @@ static int submodule_load_from_config(
 	 */
 
 	if (path)
-		return 0;
+		goto done;
 
 	/* copy other properties into submodule entry */
 	if (strcasecmp(property, "url") == 0) {
-- 
cgit v1.2.3


From 11bd7a034ba9046a7ba601c446e937377d507065 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 12 Dec 2013 11:14:51 -0800
Subject: More tests of canceling from callbacks

This covers diff print, push, and ref foreach.  This also has a
fix for a small memory leak in the push tests.
---
 tests/diff/patch.c    |  39 ++++++++++++++--
 tests/online/push.c   |  63 ++++++++++++++++---------
 tests/refs/iterator.c | 127 +++++++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 186 insertions(+), 43 deletions(-)

diff --git a/tests/diff/patch.c b/tests/diff/patch.c
index bd1598b21..0cef3bd3a 100644
--- a/tests/diff/patch.c
+++ b/tests/diff/patch.c
@@ -30,8 +30,6 @@ static int check_removal_cb(
 	const git_diff_line *line,
 	void *payload)
 {
-	GIT_UNUSED(payload);
-
 	switch (line->origin) {
 	case GIT_DIFF_LINE_FILE_HDR:
 		cl_assert_equal_s(EXPECTED_HEADER, line->content);
@@ -40,10 +38,12 @@ static int check_removal_cb(
 
 	case GIT_DIFF_LINE_HUNK_HDR:
 		cl_assert_equal_s(EXPECTED_HUNK, line->content);
-		/* Fall through */
+		goto check_hunk;
 
 	case GIT_DIFF_LINE_CONTEXT:
 	case GIT_DIFF_LINE_DELETION:
+		if (payload != NULL)
+			return *(int *)payload;
 		goto check_hunk;
 
 	default:
@@ -101,6 +101,39 @@ void test_diff_patch__can_properly_display_the_removal_of_a_file(void)
 	git_tree_free(one);
 }
 
+void test_diff_patch__can_cancel_diff_print(void)
+{
+	const char *one_sha = "26a125e";
+	const char *another_sha = "735b6a2";
+	git_tree *one, *another;
+	git_diff *diff;
+	int fail_with;
+
+	g_repo = cl_git_sandbox_init("status");
+
+	one = resolve_commit_oid_to_tree(g_repo, one_sha);
+	another = resolve_commit_oid_to_tree(g_repo, another_sha);
+
+	cl_git_pass(git_diff_tree_to_tree(&diff, g_repo, one, another, NULL));
+
+	fail_with = -2323;
+
+	cl_git_fail_with(git_diff_print(
+		diff, GIT_DIFF_FORMAT_PATCH, check_removal_cb, &fail_with),
+		fail_with);
+
+	fail_with = 45;
+
+	cl_git_fail_with(git_diff_print(
+		diff, GIT_DIFF_FORMAT_PATCH, check_removal_cb, &fail_with),
+		fail_with);
+
+	git_diff_free(diff);
+
+	git_tree_free(another);
+	git_tree_free(one);
+}
+
 void test_diff_patch__to_string(void)
 {
 	const char *one_sha = "26a125e";
diff --git a/tests/online/push.c b/tests/online/push.c
index be505c3a1..33f174654 100644
--- a/tests/online/push.c
+++ b/tests/online/push.c
@@ -207,6 +207,7 @@ static void verify_tracking_branches(git_remote *remote, expected_ref expected_r
 	}
 
 	cl_assert_equal_i(error, GIT_ITEROVER);
+	git_branch_iterator_free(iter);
 
 	/* Loop through expected refs, make sure they exist */
 	for (i = 0; i < expected_refs_len; i++) {
@@ -371,19 +372,25 @@ void test_online_push__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-static int push_pack_progress_cb(int stage, unsigned int current, unsigned int total, void* payload)
+static int push_pack_progress_cb(
+	int stage, unsigned int current, unsigned int total, void* payload)
 {
-	int *was_called = (int *) payload;
+	int *calls = (int *)payload;
 	GIT_UNUSED(stage); GIT_UNUSED(current); GIT_UNUSED(total);
-	*was_called = 1;
+	if (*calls < 0)
+		return *calls;
+	(*calls)++;
 	return 0;
 }
 
-static int push_transfer_progress_cb(unsigned int current, unsigned int total, size_t bytes, void* payload)
+static int push_transfer_progress_cb(
+	unsigned int current, unsigned int total, size_t bytes, void* payload)
 {
-	int *was_called = (int *) payload;
+	int *calls = (int *)payload;
 	GIT_UNUSED(current); GIT_UNUSED(total); GIT_UNUSED(bytes);
-	*was_called = 1;
+	if (*calls < 0)
+		return *calls;
+	(*calls)++;
 	return 0;
 }
 
@@ -397,15 +404,16 @@ static int push_transfer_progress_cb(unsigned int current, unsigned int total, s
  * @param expected_ret expected return value from git_push_finish()
  * @param check_progress_cb Check that the push progress callbacks are called
  */
-static void do_push(const char *refspecs[], size_t refspecs_len,
+static void do_push(
+	const char *refspecs[], size_t refspecs_len,
 	push_status expected_statuses[], size_t expected_statuses_len,
-	expected_ref expected_refs[], size_t expected_refs_len, int expected_ret, int check_progress_cb)
+	expected_ref expected_refs[], size_t expected_refs_len,
+	int expected_ret, int check_progress_cb)
 {
 	git_push *push;
 	git_push_options opts = GIT_PUSH_OPTIONS_INIT;
 	size_t i;
-	int ret;
-	int pack_progress_called = 0, transfer_progress_called = 0;
+	int pack_progress_calls = 0, transfer_progress_calls = 0;
 
 	if (_remote) {
 		/* Auto-detect the number of threads to use */
@@ -416,30 +424,35 @@ static void do_push(const char *refspecs[], size_t refspecs_len,
 		cl_git_pass(git_push_new(&push, _remote));
 		cl_git_pass(git_push_set_options(push, &opts));
 
-		if (check_progress_cb)
-			cl_git_pass(git_push_set_callbacks(push, push_pack_progress_cb, &pack_progress_called, push_transfer_progress_cb, &transfer_progress_called));
+		if (check_progress_cb) {
+			/* if EUSER, then abort in transfer */
+			if (expected_ret == GIT_EUSER)
+				transfer_progress_calls = GIT_EUSER;
+
+			cl_git_pass(
+				git_push_set_callbacks(
+					push, push_pack_progress_cb, &pack_progress_calls,
+					push_transfer_progress_cb, &transfer_progress_calls));
+		}
 
 		for (i = 0; i < refspecs_len; i++)
 			cl_git_pass(git_push_add_refspec(push, refspecs[i]));
 
 		if (expected_ret < 0) {
-			cl_git_fail(ret = git_push_finish(push));
+			cl_git_fail_with(git_push_finish(push), expected_ret);
 			cl_assert_equal_i(0, git_push_unpack_ok(push));
-		}
-		else {
-			cl_git_pass(ret = git_push_finish(push));
+		} else {
+			cl_git_pass(git_push_finish(push));
 			cl_assert_equal_i(1, git_push_unpack_ok(push));
 		}
 
-		if (check_progress_cb) {
-			cl_assert_equal_i(1, pack_progress_called);
-			cl_assert_equal_i(1, transfer_progress_called);
+		if (check_progress_cb && !expected_ret) {
+			cl_assert(pack_progress_calls > 0);
+			cl_assert(transfer_progress_calls > 0);
 		}
 
 		do_verify_push_status(push, expected_statuses, expected_statuses_len);
 
-		cl_assert_equal_i(expected_ret, ret);
-
 		verify_refs(_remote, expected_refs, expected_refs_len);
 
 		cl_git_pass(git_push_update_tips(push));
@@ -507,6 +520,12 @@ void test_online_push__b5(void)
 		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
 }
 
+void test_online_push__b5_cancel(void)
+{
+	const char *specs[] = { "refs/heads/b5:refs/heads/b5" };
+	do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1);
+}
+
 void test_online_push__multi(void)
 {
 	const char *specs[] = {
@@ -731,7 +750,7 @@ void test_online_push__bad_refspecs(void)
 	git_push *push;
 
 	if (_remote) {
-//		cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_PUSH));
+/*		cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_PUSH)); */
 		cl_git_pass(git_push_new(&push, _remote));
 
 		/* Unexpanded branch names not supported */
diff --git a/tests/refs/iterator.c b/tests/refs/iterator.c
index 266410fdf..a29b0cf8b 100644
--- a/tests/refs/iterator.c
+++ b/tests/refs/iterator.c
@@ -46,36 +46,43 @@ static int refcmp_cb(const void *a, const void *b)
 	return strcmp(refa->name, refb->name);
 }
 
+static void assert_all_refnames_match(git_vector *output)
+{
+	size_t i;
+	git_reference *ref;
+
+	cl_assert_equal_sz(output->length, ARRAY_SIZE(refnames));
+
+	git_vector_sort(output);
+
+	git_vector_foreach(output, i, ref) {
+		cl_assert_equal_s(ref->name, refnames[i]);
+		git_reference_free(ref);
+	}
+
+	git_vector_free(output);
+}
+
 void test_refs_iterator__list(void)
 {
 	git_reference_iterator *iter;
 	git_vector output;
 	git_reference *ref;
-	int error;
-	size_t i;
 
 	cl_git_pass(git_vector_init(&output, 32, &refcmp_cb));
 	cl_git_pass(git_reference_iterator_new(&iter, repo));
 
-	do {
-		error = git_reference_next(&ref, iter);
-		cl_assert(error == 0 || error == GIT_ITEROVER);
-		if (error != GIT_ITEROVER) {
-			cl_git_pass(git_vector_insert(&output, ref));
-		}
-	} while (!error);
+	while (1) {
+		int error = git_reference_next(&ref, iter);
+		if (error == GIT_ITEROVER)
+			break;
+		cl_git_pass(error);
+		cl_git_pass(git_vector_insert(&output, ref));
+	}
 
 	git_reference_iterator_free(iter);
-	cl_assert_equal_sz(output.length, ARRAY_SIZE(refnames));
 
-	git_vector_sort(&output);
-
-	git_vector_foreach(&output, i, ref) {
-		cl_assert_equal_s(ref->name, refnames[i]);
-		git_reference_free(ref);
-	}
-
-	git_vector_free(&output);
+	assert_all_refnames_match(&output);
 }
 
 void test_refs_iterator__empty(void)
@@ -95,3 +102,87 @@ void test_refs_iterator__empty(void)
 	git_odb_free(odb);
 	git_repository_free(empty);
 }
+
+static int refs_foreach_cb(git_reference *reference, void *payload)
+{
+	git_vector *output = payload;
+	cl_git_pass(git_vector_insert(output, reference));
+	return 0;
+}
+
+void test_refs_iterator__foreach(void)
+{
+	git_vector output;
+	cl_git_pass(git_vector_init(&output, 32, &refcmp_cb));
+	cl_git_pass(git_reference_foreach(repo, refs_foreach_cb, &output));
+	assert_all_refnames_match(&output);
+}
+
+static int refs_foreach_cancel_cb(git_reference *reference, void *payload)
+{
+	int *cancel_after = payload;
+
+	git_reference_free(reference);
+
+	if (!*cancel_after)
+		return -333;
+	(*cancel_after)--;
+	return 0;
+}
+
+void test_refs_iterator__foreach_can_cancel(void)
+{
+	int cancel_after = 3;
+	cl_git_fail_with(
+		git_reference_foreach(repo, refs_foreach_cancel_cb, &cancel_after),
+		-333);
+	cl_assert_equal_i(0, cancel_after);
+}
+
+static int refs_foreach_name_cb(const char *name, void *payload)
+{
+	git_vector *output = payload;
+	cl_git_pass(git_vector_insert(output, git__strdup(name)));
+	return 0;
+}
+
+void test_refs_iterator__foreach_name(void)
+{
+	git_vector output;
+	size_t i;
+	char *name;
+
+	cl_git_pass(git_vector_init(&output, 32, &git__strcmp_cb));
+	cl_git_pass(
+		git_reference_foreach_name(repo, refs_foreach_name_cb, &output));
+
+	cl_assert_equal_sz(output.length, ARRAY_SIZE(refnames));
+	git_vector_sort(&output);
+
+	git_vector_foreach(&output, i, name) {
+		cl_assert_equal_s(name, refnames[i]);
+		git__free(name);
+	}
+
+	git_vector_free(&output);
+}
+
+static int refs_foreach_name_cancel_cb(const char *name, void *payload)
+{
+	int *cancel_after = payload;
+	if (!*cancel_after)
+		return -333;
+	GIT_UNUSED(name);
+	(*cancel_after)--;
+	return 0;
+}
+
+void test_refs_iterator__foreach_name_can_cancel(void)
+{
+	int cancel_after = 5;
+	cl_git_fail_with(
+		git_reference_foreach_name(
+			repo, refs_foreach_name_cancel_cb, &cancel_after),
+		-333);
+	cl_assert_equal_i(0, cancel_after);
+}
-- 
cgit v1.2.3


From 9cfce2735d77f4d8b6005e62349dd97c0c6de5ab Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 12 Dec 2013 12:11:38 -0800
Subject: Cleanups, renames, and leak fixes

This renames git_vector_free_all to the better git_vector_free_deep
and also contains a couple of memory leak fixes based on valgrind
checks.  The fixes are specifically: failure to free global dir
path variables when not compiled with threading on and failure to
free filters from the filter registry that had not be initialized
fully.
---
 include/git2/sys/filter.h |  1 +
 src/blame.c               |  2 +-
 src/checkout.c            |  2 +-
 src/diff.c                |  2 +-
 src/diff_tform.c          |  4 ++--
 src/fileops.c             | 13 ++++++++++---
 src/filter.c              |  2 +-
 src/indexer.c             |  4 ++--
 src/iterator.c            |  2 +-
 src/merge.c               |  2 +-
 src/pathspec.c            |  2 +-
 src/push.c                |  2 +-
 src/remote.c              |  4 ++--
 src/status.c              |  2 +-
 src/transports/http.c     |  2 +-
 src/vector.c              |  2 +-
 src/vector.h              |  2 +-
 17 files changed, 29 insertions(+), 21 deletions(-)

diff --git a/include/git2/sys/filter.h b/include/git2/sys/filter.h
index 94ad3aed4..8fe21c9c0 100644
--- a/include/git2/sys/filter.h
+++ b/include/git2/sys/filter.h
@@ -149,6 +149,7 @@ typedef int (*git_filter_init_fn)(git_filter *self);
  * Specified as `filter.shutdown`, this is an optional callback invoked
  * when the filter is unregistered or when libgit2 is shutting down.  It
  * will be called once at most and should release resources as needed.
+ * This may be called even if the `initialize` callback was not made.
  *
  * Typically this function will free the `git_filter` object itself.
  */
diff --git a/src/blame.c b/src/blame.c
index f10ed409a..a1357415a 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -139,7 +139,7 @@ void git_blame_free(git_blame *blame)
 		free_hunk(hunk);
 	git_vector_free(&blame->hunks);
 
-	git_vector_free_all(&blame->paths);
+	git_vector_free_deep(&blame->paths);
 
 	git_array_clear(blame->line_index);
 
diff --git a/src/checkout.c b/src/checkout.c
index f7dd052c7..0f30d16f3 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -1765,7 +1765,7 @@ static void checkout_data_clear(checkout_data *data)
 	git_vector_free(&data->removes);
 	git_pool_clear(&data->pool);
 
-	git_vector_free_all(&data->conflicts);
+	git_vector_free_deep(&data->conflicts);
 
 	git__free(data->pfx);
 	data->pfx = NULL;
diff --git a/src/diff.c b/src/diff.c
index 83adc2a8c..7f2e58c0c 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -476,7 +476,7 @@ static int diff_list_apply_options(
 
 static void diff_list_free(git_diff *diff)
 {
-	git_vector_free_all(&diff->deltas);
+	git_vector_free_deep(&diff->deltas);
 
 	git_pathspec__vfree(&diff->pathspec);
 	git_pool_clear(&diff->pool);
diff --git a/src/diff_tform.c b/src/diff_tform.c
index da4bdb3f5..263a64d12 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -209,7 +209,7 @@ int git_diff_merge(git_diff *onto, const git_diff *from)
 			git_pool_strdup_safe(&onto->pool, onto->opts.new_prefix);
 	}
 
-	git_vector_free_all(&onto_new);
+	git_vector_free_deep(&onto_new);
 	git_pool_clear(&onto_pool);
 
 	return error;
@@ -440,7 +440,7 @@ static int apply_splits_and_deletes(
 	return 0;
 
 on_error:
-	git_vector_free_all(&onto);
+	git_vector_free_deep(&onto);
 
 	return -1;
 }
diff --git a/src/fileops.c b/src/fileops.c
index 98dcd3269..a60689f3f 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -615,6 +615,8 @@ static git_futils_dirs_guess_cb git_futils__dir_guess[GIT_FUTILS_DIR__MAX] = {
 	git_futils_guess_template_dirs,
 };
 
+static int git_futils__dirs_shutdown_set = 0;
+
 void git_futils_dirs_global_shutdown(void)
 {
 	int i;
@@ -631,8 +633,6 @@ int git_futils_dirs_global_init(void)
 	for (i = 0; !error && i < GIT_FUTILS_DIR__MAX; i++)
 		error = git_futils_dirs_get(&path, i);
 
-	git__on_shutdown(git_futils_dirs_global_shutdown);
-
 	return error;
 }
 
@@ -652,9 +652,16 @@ int git_futils_dirs_get(const git_buf **out, git_futils_dir_t which)
 
 	GITERR_CHECK_ERROR(git_futils_check_selector(which));
 
-	if (!git_buf_len(&git_futils__dirs[which]))
+	if (!git_buf_len(&git_futils__dirs[which])) {
+		/* prepare shutdown if we're going to need it */
+		if (!git_futils__dirs_shutdown_set) {
+			git__on_shutdown(git_futils_dirs_global_shutdown);
+			git_futils__dirs_shutdown_set = 1;
+		}
+
 		GITERR_CHECK_ERROR(
 			git_futils__dir_guess[which](&git_futils__dirs[which]));
+	}
 
 	*out = &git_futils__dirs[which];
 	return 0;
diff --git a/src/filter.c b/src/filter.c
index 9f866fe88..ff81eb14e 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -69,7 +69,7 @@ static void filter_registry_shutdown(void)
 		return;
 
 	git_vector_foreach(&reg->filters, pos, fdef) {
-		if (fdef->initialized && fdef->filter && fdef->filter->shutdown) {
+		if (fdef->filter && fdef->filter->shutdown) {
 			fdef->filter->shutdown(fdef->filter);
 			fdef->initialized = false;
 		}
diff --git a/src/indexer.c b/src/indexer.c
index 718c69814..6132571cc 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -1010,7 +1010,7 @@ void git_indexer_free(git_indexer *idx)
 	if (idx == NULL)
 		return;
 
-	git_vector_free_all(&idx->objects);
+	git_vector_free_deep(&idx->objects);
 
 	if (idx->pack) {
 		struct git_pack_entry *pentry;
@@ -1020,7 +1020,7 @@ void git_indexer_free(git_indexer *idx)
 		git_oidmap_free(idx->pack->idx_cache);
 	}
 
-	git_vector_free_all(&idx->deltas);
+	git_vector_free_deep(&idx->deltas);
 	git_packfile_free(idx->pack);
 	git_filebuf_cleanup(&idx->pack_file);
 	git__free(idx);
diff --git a/src/iterator.c b/src/iterator.c
index 118bbb880..0e7d0db85 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -920,7 +920,7 @@ static fs_iterator_frame *fs_iterator__alloc_frame(fs_iterator *fi)
 
 static void fs_iterator__free_frame(fs_iterator_frame *ff)
 {
-	git_vector_free_all(&ff->entries);
+	git_vector_free_deep(&ff->entries);
 	git__free(ff);
 }
 
diff --git a/src/merge.c b/src/merge.c
index 5640be56b..d6db19243 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2383,7 +2383,7 @@ done:
         git_index_set_caps(index_repo, index_repo_caps);
 
 	git_index_free(index_repo);
-	git_vector_free_all(&paths);
+	git_vector_free_deep(&paths);
 
 	return error;
 }
diff --git a/src/pathspec.c b/src/pathspec.c
index f16e19f47..bad8dacdb 100644
--- a/src/pathspec.c
+++ b/src/pathspec.c
@@ -102,7 +102,7 @@ int git_pathspec__vinit(
 /* free data from the pathspec vector */
 void git_pathspec__vfree(git_vector *vspec)
 {
-	git_vector_free_all(vspec);
+	git_vector_free_deep(vspec);
 }
 
 struct pathspec_match_context {
diff --git a/src/push.c b/src/push.c
index adba880df..dd77864a5 100644
--- a/src/push.c
+++ b/src/push.c
@@ -541,7 +541,7 @@ static int queue_objects(git_push *push)
 	error = 0;
 
 on_error:
-	git_vector_free_all(&commits);
+	git_vector_free_deep(&commits);
 	return error;
 }
 
diff --git a/src/remote.c b/src/remote.c
index 689de230a..294a8709d 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1138,7 +1138,7 @@ int git_remote_list(git_strarray *remotes_list, git_repository *repo)
 		cfg, "^remote\\..*\\.(push)?url$", remote_list_cb, &list);
 
 	if (error < 0) {
-		git_vector_free_all(&list);
+		git_vector_free_deep(&list);
 		return error;
 	}
 
@@ -1617,7 +1617,7 @@ static int copy_refspecs(git_strarray *array, git_remote *remote, unsigned int p
 	return 0;
 
 on_error:
-	git_vector_free_all(&refspecs);
+	git_vector_free_deep(&refspecs);
 
 	return -1;
 }
diff --git a/src/status.c b/src/status.c
index 9bde8fb57..7a1472d8d 100644
--- a/src/status.c
+++ b/src/status.c
@@ -367,7 +367,7 @@ void git_status_list_free(git_status_list *status)
 	git_diff_free(status->head2idx);
 	git_diff_free(status->idx2wd);
 
-	git_vector_free_all(&status->paired);
+	git_vector_free_deep(&status->paired);
 
 	git__memzero(status, sizeof(*status));
 	git__free(status);
diff --git a/src/transports/http.c b/src/transports/http.c
index 0e1bbf60d..c6aaeb9cf 100644
--- a/src/transports/http.c
+++ b/src/transports/http.c
@@ -404,7 +404,7 @@ static void clear_parser_state(http_subtransport *t)
 	git__free(t->location);
 	t->location = NULL;
 
-	git_vector_free_all(&t->www_authenticate);
+	git_vector_free_deep(&t->www_authenticate);
 }
 
 static int write_chunk(gitno_socket *socket, const char *buffer, size_t len)
diff --git a/src/vector.c b/src/vector.c
index b1ea89606..050e032a0 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -77,7 +77,7 @@ void git_vector_free(git_vector *v)
 	v->_alloc_size = 0;
 }
 
-void git_vector_free_all(git_vector *v)
+void git_vector_free_deep(git_vector *v)
 {
 	size_t i;
 
diff --git a/src/vector.h b/src/vector.h
index defe22466..d318463c6 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -23,7 +23,7 @@ typedef struct git_vector {
 
 int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp);
 void git_vector_free(git_vector *v);
-void git_vector_free_all(git_vector *v); /* free each entry and self */
+void git_vector_free_deep(git_vector *v); /* free each entry and self */
 void git_vector_clear(git_vector *v);
 int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp);
 void git_vector_swap(git_vector *a, git_vector *b);
-- 
cgit v1.2.3


From 452c7de668568f75a97b0438daab9f33b68d605a Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 12 Dec 2013 14:16:40 -0800
Subject: Add git_treebuilder_insert test and clarify doc

This wasn't being tested and since it has a callback, I fixed it
even though the return value of this callback is not treated like
any of the other callbacks in the API.
---
 include/git2/tree.h       | 11 +++++--
 tests/object/tree/write.c | 84 ++++++++++++++++++++++++++++++++++++++---------
 2 files changed, 78 insertions(+), 17 deletions(-)

diff --git a/include/git2/tree.h b/include/git2/tree.h
index d94b446c2..422365674 100644
--- a/include/git2/tree.h
+++ b/include/git2/tree.h
@@ -332,11 +332,18 @@ GIT_EXTERN(int) git_treebuilder_insert(
 GIT_EXTERN(int) git_treebuilder_remove(
 	git_treebuilder *bld, const char *filename);
 
+/**
+ * Callback for git_treebuilder_filter
+ *
+ * The return value is treated as a boolean, with zero indicating that the
+ * entry should be left alone and any non-zero value meaning that the
+ * entry should be removed from the treebuilder list (i.e. filtered out).
+ */
 typedef int (*git_treebuilder_filter_cb)(
 	const git_tree_entry *entry, void *payload);
 
 /**
- * Filter the entries in the tree
+ * Selectively remove entries in the tree
  *
  * The `filter` callback will be called for each entry in the tree with a
  * pointer to the entry and the provided `payload`; if the callback returns
@@ -344,7 +351,7 @@ typedef int (*git_treebuilder_filter_cb)(
  *
  * @param bld Tree builder
  * @param filter Callback to filter entries
- * @param payload Extra data to pass to filter
+ * @param payload Extra data to pass to filter callback
  */
 GIT_EXTERN(void) git_treebuilder_filter(
 	git_treebuilder *bld,
diff --git a/tests/object/tree/write.c b/tests/object/tree/write.c
index 468c0ccd1..3bea0ed4d 100644
--- a/tests/object/tree/write.c
+++ b/tests/object/tree/write.c
@@ -164,24 +164,25 @@ void test_object_tree_write__sorted_subtrees(void)
 	git_treebuilder_free(builder);
 }
 
+static struct {
+	unsigned int attr;
+	const char *filename;
+} _entries[] = {
+	{ GIT_FILEMODE_BLOB, "aardvark" },
+	{ GIT_FILEMODE_BLOB, ".first" },
+	{ GIT_FILEMODE_BLOB, "apple" },
+	{ GIT_FILEMODE_BLOB, "last"},
+	{ GIT_FILEMODE_BLOB, "apple_after"},
+	{ GIT_FILEMODE_BLOB, "after_aardvark"},
+	{ 0, NULL },
+};
+
 void test_object_tree_write__removing_and_re_adding_in_treebuilder(void)
 {
 	git_treebuilder *builder;
-	int i,  aardvark_i, apple_i, apple_after_i, apple_extra_i, last_i;
+	int i, aardvark_i, apple_i, apple_after_i, apple_extra_i, last_i;
 	git_oid blank_oid, tree_oid;
 	git_tree *tree;
-	struct {
-		unsigned int attr;
-		const char *filename;
-	} entries[] = {
-		{ GIT_FILEMODE_BLOB, "aardvark" },
-		{ GIT_FILEMODE_BLOB, ".first" },
-		{ GIT_FILEMODE_BLOB, "apple" },
-		{ GIT_FILEMODE_BLOB, "last"},
-		{ GIT_FILEMODE_BLOB, "apple_after"},
-		{ GIT_FILEMODE_BLOB, "after_aardvark"},
-		{ 0, NULL },
-	};
 
 	memset(&blank_oid, 0x0, sizeof(blank_oid));
 
@@ -189,9 +190,9 @@ void test_object_tree_write__removing_and_re_adding_in_treebuilder(void)
 
 	cl_assert_equal_i(0, (int)git_treebuilder_entrycount(builder));
 
-	for (i = 0; entries[i].filename; ++i)
+	for (i = 0; _entries[i].filename; ++i)
 		cl_git_pass(git_treebuilder_insert(NULL,
-			builder, entries[i].filename, &blank_oid, entries[i].attr));
+			builder, _entries[i].filename, &blank_oid, _entries[i].attr));
 
 	cl_assert_equal_i(6, (int)git_treebuilder_entrycount(builder));
 
@@ -260,3 +261,56 @@ void test_object_tree_write__removing_and_re_adding_in_treebuilder(void)
 
 	git_tree_free(tree);
 }
+
+static int treebuilder_filter_prefixed(
+	const git_tree_entry *entry, void *payload)
+{
+	return !git__prefixcmp(git_tree_entry_name(entry), payload);
+}
+
+void test_object_tree_write__filtering(void)
+{
+	git_treebuilder *builder;
+	int i;
+	git_oid blank_oid, tree_oid;
+	git_tree *tree;
+
+	memset(&blank_oid, 0x0, sizeof(blank_oid));
+
+	cl_git_pass(git_treebuilder_create(&builder, NULL));
+
+	for (i = 0; _entries[i].filename; ++i)
+		cl_git_pass(git_treebuilder_insert(NULL,
+			builder, _entries[i].filename, &blank_oid, _entries[i].attr));
+
+	cl_assert_equal_i(6, (int)git_treebuilder_entrycount(builder));
+
+	cl_assert(git_treebuilder_get(builder, "apple") != NULL);
+	cl_assert(git_treebuilder_get(builder, "aardvark") != NULL);
+	cl_assert(git_treebuilder_get(builder, "last") != NULL);
+
+	git_treebuilder_filter(builder, treebuilder_filter_prefixed, "apple");
+
+	cl_assert_equal_i(4, (int)git_treebuilder_entrycount(builder));
+
+	cl_assert(git_treebuilder_get(builder, "apple") == NULL);
+	cl_assert(git_treebuilder_get(builder, "aardvark") != NULL);
+	cl_assert(git_treebuilder_get(builder, "last") != NULL);
+
+	git_treebuilder_filter(builder, treebuilder_filter_prefixed, "a");
+
+	cl_assert_equal_i(2, (int)git_treebuilder_entrycount(builder));
+
+	cl_assert(git_treebuilder_get(builder, "aardvark") == NULL);
+	cl_assert(git_treebuilder_get(builder, "last") != NULL);
+
+	cl_git_pass(git_treebuilder_write(&tree_oid, g_repo, builder));
+
+	git_treebuilder_free(builder);
+
+	cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_oid));
+
+	cl_assert_equal_i(2, (int)git_tree_entrycount(tree));
+
+	git_tree_free(tree);
+}
-- 
cgit v1.2.3


From 86a05ef382438b22d2ffaaa1a77814781243bc80 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Thu, 12 Dec 2013 17:40:40 -0500
Subject: Validate struct versions in merge, revert

---
 src/merge.c  | 4 ++++
 src/revert.c | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/src/merge.c b/src/merge.c
index 45387d4ad..00415cbc0 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -1575,6 +1575,8 @@ int git_merge_trees(
 
 	*out = NULL;
 
+	GITERR_CHECK_VERSION(given_opts, GIT_MERGE_TREE_OPTS_VERSION, "git_merge_tree_opts");
+
 	if ((error = merge_tree_normalize_opts(repo, &opts, given_opts)) < 0)
 		return error;
 
@@ -2427,6 +2429,8 @@ int git_merge(
 
 	*out = NULL;
 
+	GITERR_CHECK_VERSION(given_opts, GIT_MERGE_OPTS_VERSION, "git_merge_opts");
+
 	if (their_heads_len != 1) {
 		giterr_set(GITERR_MERGE, "Can only merge a single branch");
 		return -1;
diff --git a/src/revert.c b/src/revert.c
index 6cfd591b4..4ba329907 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -179,6 +179,8 @@ int git_revert(
 
 	assert(repo && commit);
 
+	GITERR_CHECK_VERSION(given_opts, GIT_REVERT_OPTS_VERSION, "git_revert_opts");
+
 	if ((error = git_repository__ensure_not_bare(repo, "revert")) < 0)
 		return error;
 
-- 
cgit v1.2.3


From ce33645ff32d68dfd89867468f58fd9c245c26ff Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Fri, 13 Dec 2013 12:25:48 +0100
Subject: pool: Cleanup error handling in pool_strdup

Note that `git_pool_strdup` cannot really return any error codes,
 because the pool doesn't set errors on OOM.

 The only place where `giterr_set_oom` is called is in
 `git_pool_strndup`, in a conditional check that is always optimized
 away. `n + 1` cannot be zero if `n` is unsigned because the compiler
 doesn't take wraparound into account.

 This check has been removed altogether because `size_t` is not
 particularly going to overflow.
---
 src/pool.c | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

diff --git a/src/pool.c b/src/pool.c
index 4796d0a81..a23641145 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -190,19 +190,15 @@ void *git_pool_malloc(git_pool *pool, uint32_t items)
 
 char *git_pool_strndup(git_pool *pool, const char *str, size_t n)
 {
-	void *ptr = NULL;
+	char *ptr = NULL;
 
 	assert(pool && str && pool->item_size == sizeof(char));
 
-	if (n + 1 == 0) {
-		giterr_set_oom();
-		return NULL;
-	}
-
 	if ((ptr = git_pool_malloc(pool, (uint32_t)(n + 1))) != NULL) {
 		memcpy(ptr, str, n);
-		*(((char *)ptr) + n) = '\0';
+		ptr[n] = '\0';
 	}
+
 	pool->has_string_alloc = 1;
 
 	return ptr;
@@ -217,14 +213,7 @@ char *git_pool_strdup(git_pool *pool, const char *str)
 
 char *git_pool_strdup_safe(git_pool *pool, const char *str)
 {
-	if (!str)
-		return NULL;
-	else {
-		char *result = git_pool_strdup(pool, str);
-		if (!result)
-			giterr_clear();
-		return result;
-	}
+	return str ? git_pool_strdup(pool, str) : NULL;
 }
 
 char *git_pool_strcat(git_pool *pool, const char *a, const char *b)
-- 
cgit v1.2.3


From 437f7d69b22324d20fe833aa53119885733029c2 Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Fri, 13 Dec 2013 12:41:22 +0100
Subject: pool: Correct overflow checks

Ok, scrap the previous commit. This is the right overflow check that
takes care of 64 bit overflow **and** 32-bit overflow, which needs to be
considered because the pool malloc can only allocate 32-bit elements in
one go.
---
 src/pool.c        | 3 +++
 tests/core/pool.c | 6 +++++-
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/pool.c b/src/pool.c
index a23641145..146f118b4 100644
--- a/src/pool.c
+++ b/src/pool.c
@@ -194,6 +194,9 @@ char *git_pool_strndup(git_pool *pool, const char *str, size_t n)
 
 	assert(pool && str && pool->item_size == sizeof(char));
 
+	if ((uint32_t)(n + 1) < n)
+		return NULL;
+
 	if ((ptr = git_pool_malloc(pool, (uint32_t)(n + 1))) != NULL) {
 		memcpy(ptr, str, n);
 		ptr[n] = '\0';
diff --git a/tests/core/pool.c b/tests/core/pool.c
index 3073c4a45..7a8b2dea6 100644
--- a/tests/core/pool.c
+++ b/tests/core/pool.c
@@ -139,7 +139,11 @@ void test_core_pool__strndup_limit(void)
 	git_pool p;
 
 	cl_git_pass(git_pool_init(&p, 1, 100));
-	cl_assert(git_pool_strndup(&p, "foo", -1) == NULL);
+	/* ensure 64 bit doesn't overflow */
+	cl_assert(git_pool_strndup(&p, "foo", (size_t)-1) == NULL);
+
+	/* ensure 32 bit doesn't overflow */
+	cl_assert(git_pool_strndup(&p, "bar", 0xfffffffful + 32) == NULL);
 	git_pool_clear(&p);
 }
 
-- 
cgit v1.2.3


From 7a16d54b5457aa9f60c25a204277ae0ce609ad2e Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Fri, 13 Dec 2013 12:47:51 +0100
Subject: pool: Agh, this test doesn't really apply in 32-bit machines

The size_t is 32-bit already, so it overflows before going into the
function. The `-1` test should handle this gracefully in both cases
anyway.
---
 tests/core/pool.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/core/pool.c b/tests/core/pool.c
index 7a8b2dea6..351d0c20f 100644
--- a/tests/core/pool.c
+++ b/tests/core/pool.c
@@ -141,9 +141,6 @@ void test_core_pool__strndup_limit(void)
 	cl_git_pass(git_pool_init(&p, 1, 100));
 	/* ensure 64 bit doesn't overflow */
 	cl_assert(git_pool_strndup(&p, "foo", (size_t)-1) == NULL);
-
-	/* ensure 32 bit doesn't overflow */
-	cl_assert(git_pool_strndup(&p, "bar", 0xfffffffful + 32) == NULL);
 	git_pool_clear(&p);
 }
 
-- 
cgit v1.2.3


From 81a2012d991212fbbbf98bf7eefca3dc5d0fd7bb Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Thu, 12 Dec 2013 11:30:50 -0500
Subject: Overwrite ignored files on checkout

---
 include/git2/checkout.h |  8 ++++++
 src/checkout.c          | 18 ++++++++----
 tests/checkout/tree.c   | 74 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 94 insertions(+), 6 deletions(-)

diff --git a/include/git2/checkout.h b/include/git2/checkout.h
index 0e9d338c6..b94a5e2ff 100644
--- a/include/git2/checkout.h
+++ b/include/git2/checkout.h
@@ -99,6 +99,11 @@ GIT_BEGIN_DECL
  *   files with unmerged index entries instead.  GIT_CHECKOUT_USE_OURS and
  *   GIT_CHECKOUT_USE_THEIRS to proceed with the checkout using either the
  *   stage 2 ("ours") or stage 3 ("theirs") version of files in the index.
+ *
+ * - GIT_CHECKOUT_DONT_OVERWRITE_IGNORED prevents ignored files from being
+ *   overwritten.  Normally, files that are ignored in the working directory
+ *   are not considered "precious" and may be overwritten if the checkout
+ *   target contains that file.
  */
 typedef enum {
 	GIT_CHECKOUT_NONE = 0, /** default is a dry run, no actual updates */
@@ -144,6 +149,9 @@ typedef enum {
 	/** Ignore directories in use, they will be left empty */
 	GIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES = (1u << 18),
 
+	/** Don't overwrite ignored files that exist in the checkout target */
+	GIT_CHECKOUT_DONT_OVERWRITE_IGNORED = (1u << 19),
+
 	/**
 	 * THE FOLLOWING OPTIONS ARE NOT YET IMPLEMENTED
 	 */
diff --git a/src/checkout.c b/src/checkout.c
index 0f30d16f3..50da83a4a 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -333,6 +333,7 @@ static int checkout_action_with_wd(
 	int *action,
 	checkout_data *data,
 	const git_diff_delta *delta,
+	git_iterator *workdir,
 	const git_index_entry *wd)
 {
 	*action = CHECKOUT_ACTION__NONE;
@@ -346,7 +347,10 @@ static int checkout_action_with_wd(
 		}
 		break;
 	case GIT_DELTA_ADDED: /* case 3, 4 or 6 */
-		*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
+		if (git_iterator_current_is_ignored(workdir))
+			*action = CHECKOUT_ACTION_IF(DONT_OVERWRITE_IGNORED, CONFLICT, UPDATE_BLOB);
+		else
+			*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
 		break;
 	case GIT_DELTA_DELETED: /* case 9 or 10 (or 26 but not really) */
 		if (checkout_is_workdir_modified(data, &delta->old_file, wd))
@@ -541,7 +545,7 @@ static int checkout_action(
 
 		if (cmp == 0) {
 			/* case 4 */
-			error = checkout_action_with_wd(action, data, delta, wd);
+			error = checkout_action_with_wd(action, data, delta, workdir, wd);
 			advance = git_iterator_advance;
 			goto done;
 		}
@@ -554,7 +558,7 @@ static int checkout_action(
 
 			if (delta->status == GIT_DELTA_TYPECHANGE) {
 				if (delta->old_file.mode == GIT_FILEMODE_TREE) {
-					error = checkout_action_with_wd(action, data, delta, wd);
+					error = checkout_action_with_wd(action, data, delta, workdir, wd);
 					advance = git_iterator_advance_into;
 					goto done;
 				}
@@ -563,7 +567,7 @@ static int checkout_action(
 					delta->new_file.mode == GIT_FILEMODE_COMMIT ||
 					delta->old_file.mode == GIT_FILEMODE_COMMIT)
 				{
-					error = checkout_action_with_wd(action, data, delta, wd);
+					error = checkout_action_with_wd(action, data, delta, workdir, wd);
 					advance = git_iterator_advance;
 					goto done;
 				}
@@ -1017,8 +1021,10 @@ static int checkout_get_actions(
 	if (counts[CHECKOUT_ACTION__CONFLICT] > 0 &&
 		(data->strategy & GIT_CHECKOUT_ALLOW_CONFLICTS) == 0)
 	{
-		giterr_set(GITERR_CHECKOUT, "%d conflicts prevent checkout",
-			(int)counts[CHECKOUT_ACTION__CONFLICT]);
+		giterr_set(GITERR_CHECKOUT, "%d %s checkout",
+			(int)counts[CHECKOUT_ACTION__CONFLICT],
+			counts[CHECKOUT_ACTION__CONFLICT] == 1 ?
+			"conflict prevents" : "conflicts prevent");
 		error = GIT_EMERGECONFLICT;
 		goto fail;
 	}
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index d2e92f8e8..10a44b6b9 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -235,6 +235,80 @@ void test_checkout_tree__can_remove_ignored(void)
 	cl_assert(!git_path_isfile("testrepo/ignored_file"));
 }
 
+static int checkout_tree_with_blob_ignored_in_workdir(int strategy)
+{
+	git_oid oid;
+	git_object *obj = NULL;
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	int ignored = 0, error;
+
+	assert_on_branch(g_repo, "master");
+
+	/* do first checkout with FORCE because we don't know if testrepo
+	 * base data is clean for a checkout or not
+	 */
+	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
+
+	cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/dir"));
+	cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY));
+
+	cl_git_pass(git_checkout_tree(g_repo, obj, &opts));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/dir"));
+
+	cl_assert(git_path_isfile("testrepo/README"));
+	cl_assert(git_path_isfile("testrepo/branch_file.txt"));
+	cl_assert(git_path_isfile("testrepo/new.txt"));
+	cl_assert(git_path_isfile("testrepo/a/b.txt"));
+
+	cl_assert(!git_path_isdir("testrepo/ab"));
+
+	assert_on_branch(g_repo, "dir");
+
+	git_object_free(obj);
+
+	opts.checkout_strategy = strategy;
+
+	cl_must_pass(p_mkdir("testrepo/ab", 0777));
+	cl_git_mkfile("testrepo/ab/4.txt", "as you wish");
+
+	cl_git_pass(git_ignore_add_rule(g_repo, "ab/4.txt\n"));
+
+	cl_git_pass(git_ignore_path_is_ignored(&ignored, g_repo, "ab/4.txt"));
+	cl_assert_equal_i(1, ignored);
+
+	cl_assert(git_path_isfile("testrepo/ab/4.txt"));
+
+	cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/subtrees"));
+	cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY));
+
+	error = git_checkout_tree(g_repo, obj, &opts);
+
+	git_object_free(obj);
+
+	return error;
+}
+
+void test_checkout_tree__conflict_on_ignored_when_not_overwriting(void)
+{
+	int error;
+
+	cl_git_fail(error = checkout_tree_with_blob_ignored_in_workdir(
+		GIT_CHECKOUT_SAFE | GIT_CHECKOUT_DONT_OVERWRITE_IGNORED));
+
+	cl_assert_equal_i(GIT_EMERGECONFLICT, error);
+}
+
+void test_checkout_tree__can_overwrite_ignored_by_default(void)
+{
+	cl_git_pass(checkout_tree_with_blob_ignored_in_workdir(GIT_CHECKOUT_SAFE));
+
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees"));
+
+	cl_assert(git_path_isfile("testrepo/ab/4.txt"));
+
+	assert_on_branch(g_repo, "subtrees");
+}
+
 void test_checkout_tree__can_update_only(void)
 {
 	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
-- 
cgit v1.2.3


From bf4a577c6989f67fc7821eebd61a117726afc9d5 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 13 Dec 2013 10:10:32 -0500
Subject: Overwrite ignored directories on checkout

---
 src/checkout.c        |  7 +++++--
 tests/checkout/tree.c | 47 ++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/src/checkout.c b/src/checkout.c
index 50da83a4a..e642c975e 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -435,6 +435,7 @@ static int checkout_action_with_wd_dir(
 	int *action,
 	checkout_data *data,
 	const git_diff_delta *delta,
+	git_iterator *workdir,
 	const git_index_entry *wd)
 {
 	*action = CHECKOUT_ACTION__NONE;
@@ -451,7 +452,9 @@ static int checkout_action_with_wd_dir(
 		if (delta->old_file.mode == GIT_FILEMODE_COMMIT)
 			/* expected submodule (and maybe found one) */;
 		else if (delta->new_file.mode != GIT_FILEMODE_TREE)
-			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
+			*action = git_iterator_current_is_ignored(workdir) ?
+				CHECKOUT_ACTION_IF(DONT_OVERWRITE_IGNORED, CONFLICT, REMOVE_AND_UPDATE) :
+				CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 		break;
 	case GIT_DELTA_DELETED: /* case 11 (and 27 for dir) */
 		if (delta->old_file.mode != GIT_FILEMODE_TREE)
@@ -573,7 +576,7 @@ static int checkout_action(
 				}
 			}
 
-			return checkout_action_with_wd_dir(action, data, delta, wd);
+			return checkout_action_with_wd_dir(action, data, delta, workdir, wd);
 		}
 
 		/* case 6 - wd is after delta */
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index 10a44b6b9..06aa6a594 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -235,7 +235,7 @@ void test_checkout_tree__can_remove_ignored(void)
 	cl_assert(!git_path_isfile("testrepo/ignored_file"));
 }
 
-static int checkout_tree_with_blob_ignored_in_workdir(int strategy)
+static int checkout_tree_with_blob_ignored_in_workdir(int strategy, bool isdir)
 {
 	git_oid oid;
 	git_object *obj = NULL;
@@ -268,16 +268,27 @@ static int checkout_tree_with_blob_ignored_in_workdir(int strategy)
 
 	opts.checkout_strategy = strategy;
 
-	cl_must_pass(p_mkdir("testrepo/ab", 0777));
-	cl_git_mkfile("testrepo/ab/4.txt", "as you wish");
+	if (isdir) {
+		cl_must_pass(p_mkdir("testrepo/ab", 0777));
+		cl_must_pass(p_mkdir("testrepo/ab/4.txt", 0777));
+
+		cl_git_mkfile("testrepo/ab/4.txt/file1.txt", "as you wish");
+		cl_git_mkfile("testrepo/ab/4.txt/file2.txt", "foo bar foo");
+		cl_git_mkfile("testrepo/ab/4.txt/file3.txt", "inky blinky pinky clyde");
+
+		cl_assert(git_path_isdir("testrepo/ab/4.txt"));
+	} else {
+		cl_must_pass(p_mkdir("testrepo/ab", 0777));
+		cl_git_mkfile("testrepo/ab/4.txt", "as you wish");
+
+		cl_assert(git_path_isfile("testrepo/ab/4.txt"));
+	}
 
 	cl_git_pass(git_ignore_add_rule(g_repo, "ab/4.txt\n"));
 
 	cl_git_pass(git_ignore_path_is_ignored(&ignored, g_repo, "ab/4.txt"));
 	cl_assert_equal_i(1, ignored);
 
-	cl_assert(git_path_isfile("testrepo/ab/4.txt"));
-
 	cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/subtrees"));
 	cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY));
 
@@ -293,14 +304,14 @@ void test_checkout_tree__conflict_on_ignored_when_not_overwriting(void)
 	int error;
 
 	cl_git_fail(error = checkout_tree_with_blob_ignored_in_workdir(
-		GIT_CHECKOUT_SAFE | GIT_CHECKOUT_DONT_OVERWRITE_IGNORED));
+		GIT_CHECKOUT_SAFE | GIT_CHECKOUT_DONT_OVERWRITE_IGNORED, false));
 
 	cl_assert_equal_i(GIT_EMERGECONFLICT, error);
 }
 
 void test_checkout_tree__can_overwrite_ignored_by_default(void)
 {
-	cl_git_pass(checkout_tree_with_blob_ignored_in_workdir(GIT_CHECKOUT_SAFE));
+	cl_git_pass(checkout_tree_with_blob_ignored_in_workdir(GIT_CHECKOUT_SAFE, false));
 
 	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees"));
 
@@ -309,6 +320,28 @@ void test_checkout_tree__can_overwrite_ignored_by_default(void)
 	assert_on_branch(g_repo, "subtrees");
 }
 
+void test_checkout_tree__conflict_on_ignored_folder_when_not_overwriting(void)
+{
+	int error;
+
+	cl_git_fail(error = checkout_tree_with_blob_ignored_in_workdir(
+		GIT_CHECKOUT_SAFE | GIT_CHECKOUT_DONT_OVERWRITE_IGNORED, true));
+
+	cl_assert_equal_i(GIT_EMERGECONFLICT, error);
+}
+
+void test_checkout_tree__can_overwrite_ignored_folder_by_default(void)
+{
+	cl_git_pass(checkout_tree_with_blob_ignored_in_workdir(GIT_CHECKOUT_SAFE, true));
+
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees"));
+
+	cl_assert(git_path_isfile("testrepo/ab/4.txt"));
+
+	assert_on_branch(g_repo, "subtrees");
+
+}
+
 void test_checkout_tree__can_update_only(void)
 {
 	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
-- 
cgit v1.2.3


From 7b50c7845bbc801ae2bb2d54e06996b7ecf424dc Mon Sep 17 00:00:00 2001
From: Andrius Bentkus <toxedvirus@gmail.com>
Date: Fri, 27 Dec 2013 15:15:48 +0200
Subject: docs: Remove non existing wrapper from the readme

libgit2net stopped to exist, all hail libgit2sharp
---
 README.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/README.md b/README.md
index 8ce60af62..434cc1937 100644
--- a/README.md
+++ b/README.md
@@ -168,7 +168,6 @@ Here are the bindings to libgit2 that are currently available:
     * luagit2 <https://github.com/libgit2/luagit2>
 * .NET
     * libgit2sharp <https://github.com/libgit2/libgit2sharp>
-    * libgit2net, low level bindings superseded by libgit2sharp <https://github.com/txdv/libgit2net>
 * Node.js
     * node-gitteh <https://github.com/libgit2/node-gitteh>
     * nodegit <https://github.com/tbranyen/nodegit>
-- 
cgit v1.2.3


From fccadba25268ab6df6637265cb4912079e5ed10b Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Sun, 29 Dec 2013 10:26:21 +0800
Subject: Accept 'submodule.*.fetchRecurseSubmodules' config 'on-demand' value

---
 include/git2/submodule.h | 17 +++++++++++++++--
 src/submodule.c          | 49 +++++++++++++++++++++++++++++++++++++-----------
 src/submodule.h          |  2 +-
 3 files changed, 54 insertions(+), 14 deletions(-)

diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index 186f263f5..a1507593c 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -104,6 +104,19 @@ typedef enum {
 	GIT_SUBMODULE_STATUS_WD_WD_MODIFIED | \
 	GIT_SUBMODULE_STATUS_WD_UNTRACKED)) != 0)
 
+/**
+ * Options for submodule recurse.
+ *
+ * * GIT_SUBMODULE_RECURSE_NO   - do no recurse into submodules
+ * * GIT_SUBMODULE_RECURSE_YES  - recurse into submodules
+ * * GIT_SUBMODULE_RECURSE_ONDEMAND - recurse into submodules only when commit not already in local clone
+ */
+typedef enum {
+	GIT_SUBMODULE_RECURSE_NO = 0,
+	GIT_SUBMODULE_RECURSE_YES = 1,
+	GIT_SUBMODULE_RECURSE_ONDEMAND = 2,
+} git_submodule_recurse_t;
+
 /**
  * Lookup submodule information by name or path.
  *
@@ -410,7 +423,7 @@ GIT_EXTERN(git_submodule_update_t) git_submodule_set_update(
  *
  * @return 0 if fetchRecurseSubmodules is false, 1 if true
  */
-GIT_EXTERN(int) git_submodule_fetch_recurse_submodules(
+GIT_EXTERN(git_submodule_recurse_t) git_submodule_fetch_recurse_submodules(
 	git_submodule *submodule);
 
 /**
@@ -426,7 +439,7 @@ GIT_EXTERN(int) git_submodule_fetch_recurse_submodules(
  */
 GIT_EXTERN(int) git_submodule_set_fetch_recurse_submodules(
 	git_submodule *submodule,
-	int fetch_recurse_submodules);
+	git_submodule_recurse_t fetch_recurse_submodules);
 
 /**
  * Copy submodule info into ".git/config" file.
diff --git a/src/submodule.c b/src/submodule.c
index f6660a87e..f771a4d66 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -43,6 +43,12 @@ static git_cvar_map _sm_ignore_map[] = {
 	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_IGNORE_ALL},
 };
 
+static git_cvar_map _sm_recurse_map[] = {
+	{GIT_CVAR_STRING, "on-demand", GIT_SUBMODULE_RECURSE_ONDEMAND},
+	{GIT_CVAR_FALSE, NULL, GIT_SUBMODULE_RECURSE_NO},
+	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_RECURSE_YES},
+};
+
 static kh_inline khint_t str_hash_no_trailing_slash(const char *s)
 {
 	khint_t h;
@@ -428,6 +434,15 @@ const char *git_submodule_update_to_str(git_submodule_update_t update)
 	return NULL;
 }
 
+const char *git_submodule_recurse_to_str(git_submodule_recurse_t recurse)
+{
+	int i;
+	for (i = 0; i < (int)ARRAY_SIZE(_sm_recurse_map); ++i)
+		if (_sm_recurse_map[i].map_value == recurse)
+			return _sm_recurse_map[i].str_match;
+	return NULL;
+}
+
 int git_submodule_save(git_submodule *submodule)
 {
 	int error = 0;
@@ -469,10 +484,10 @@ int git_submodule_save(git_submodule *submodule)
 	if (error < 0)
 		goto cleanup;
 
-	if ((error = submodule_config_key_trunc_puts(
-			&key, "fetchRecurseSubmodules")) < 0 ||
-		(error = git_config_file_set_string(
-			mods, key.ptr, submodule->fetch_recurse ? "true" : "false")) < 0)
+	if (!(error = submodule_config_key_trunc_puts(&key, "fetchRecurseSubmodules")) &&
+		(val = git_submodule_recurse_to_str(submodule->fetch_recurse)) != NULL)
+		error = git_config_file_set_string(mods, key.ptr, val);
+	if (error < 0)
 		goto cleanup;
 
 	/* update internal defaults */
@@ -610,7 +625,7 @@ git_submodule_update_t git_submodule_set_update(
 	return old;
 }
 
-int git_submodule_fetch_recurse_submodules(
+git_submodule_recurse_t git_submodule_fetch_recurse_submodules(
 	git_submodule *submodule)
 {
 	assert(submodule);
@@ -619,14 +634,14 @@ int git_submodule_fetch_recurse_submodules(
 
 int git_submodule_set_fetch_recurse_submodules(
 	git_submodule *submodule,
-	int fetch_recurse_submodules)
+	git_submodule_recurse_t fetch_recurse_submodules)
 {
 	int old;
 
 	assert(submodule);
 
 	old = submodule->fetch_recurse;
-	submodule->fetch_recurse = (fetch_recurse_submodules != 0);
+	submodule->fetch_recurse = fetch_recurse_submodules;
 	return old;
 }
 
@@ -1080,6 +1095,20 @@ int git_submodule_parse_update(git_submodule_update_t *out, const char *value)
 	return 0;
 }
 
+int git_submodule_parse_recurse(git_submodule_recurse_t *out, const char *value)
+{
+	int val;
+
+	if (git_config_lookup_map_value(
+			&val, _sm_recurse_map, ARRAY_SIZE(_sm_recurse_map), value) < 0) {
+		*out = GIT_SUBMODULE_RECURSE_YES;
+		return submodule_config_error("recurse", value);
+	}
+
+	*out = (git_submodule_recurse_t)val;
+	return 0;
+}
+
 static int submodule_load_from_config(
 	const git_config_entry *entry, void *payload)
 {
@@ -1166,10 +1195,8 @@ static int submodule_load_from_config(
 		sm->update_default = sm->update;
 	}
 	else if (strcasecmp(property, "fetchRecurseSubmodules") == 0) {
-		if (git__parse_bool(&sm->fetch_recurse, value) < 0) {
-			error = submodule_config_error("fetchRecurseSubmodules", value);
-			goto done;
-		}
+		if (git_submodule_parse_recurse(&sm->fetch_recurse, value) < 0)
+			return -1;
 	}
 	else if (strcasecmp(property, "ignore") == 0) {
 		if ((error = git_submodule_parse_ignore(&sm->ignore, value)) < 0)
diff --git a/src/submodule.h b/src/submodule.h
index b05937503..2a610e112 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -85,7 +85,7 @@ struct git_submodule {
 	git_submodule_update_t update_default;
 	git_submodule_ignore_t ignore;
 	git_submodule_ignore_t ignore_default;
-	int fetch_recurse;
+	git_submodule_recurse_t fetch_recurse;
 
 	/* internal information */
 	git_repository *repo;
-- 
cgit v1.2.3


From 217fee9ae67ecd338d6c153585f7e968adc7878d Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Sun, 29 Dec 2013 11:30:38 +0800
Subject: Default value for fetchRecurseSubmodules should be yes

---
 src/submodule.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/submodule.c b/src/submodule.c
index f771a4d66..5548e4553 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -990,6 +990,7 @@ static git_submodule *submodule_alloc(git_repository *repo, const char *name)
 	GIT_REFCOUNT_INC(sm);
 	sm->ignore = sm->ignore_default = GIT_SUBMODULE_IGNORE_NONE;
 	sm->update = sm->update_default = GIT_SUBMODULE_UPDATE_CHECKOUT;
+	sm->fetch_recurse = sm->update_default = GIT_SUBMODULE_RECURSE_YES;
 	sm->repo   = repo;
 
 	return sm;
-- 
cgit v1.2.3


From 41ceab2522655d92c6da5fa1ead197af54ee9862 Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Sun, 29 Dec 2013 11:21:13 +0800
Subject: Update test related to fetchRecurseSubmodules

---
 tests/submodule/modify.c | 25 +++++++++++++++++--------
 1 file changed, 17 insertions(+), 8 deletions(-)

diff --git a/tests/submodule/modify.c b/tests/submodule/modify.c
index e326287a6..8ec9fceb0 100644
--- a/tests/submodule/modify.c
+++ b/tests/submodule/modify.c
@@ -168,7 +168,7 @@ void test_submodule_modify__edit_and_save(void)
 	git_submodule_ignore_t old_ignore;
 	git_submodule_update_t old_update;
 	git_repository *r2;
-	int old_fetchrecurse;
+	git_submodule_recurse_t old_fetchrecurse;
 
 	cl_git_pass(git_submodule_lookup(&sm1, g_repo, "sm_changed_head"));
 
@@ -178,14 +178,14 @@ void test_submodule_modify__edit_and_save(void)
 	cl_git_pass(git_submodule_set_url(sm1, SM_LIBGIT2_URL));
 	old_ignore = git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_UNTRACKED);
 	old_update = git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_REBASE);
-	old_fetchrecurse = git_submodule_set_fetch_recurse_submodules(sm1, 1);
+	old_fetchrecurse = git_submodule_set_fetch_recurse_submodules(sm1, GIT_SUBMODULE_RECURSE_YES);
 
 	cl_assert_equal_s(SM_LIBGIT2_URL, git_submodule_url(sm1));
 	cl_assert_equal_i(
 		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm1));
 	cl_assert_equal_i(
 		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm1));
-	cl_assert_equal_i(1, git_submodule_fetch_recurse_submodules(sm1));
+	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_YES, git_submodule_fetch_recurse_submodules(sm1));
 
 	/* revert without saving (and confirm setters return old value) */
 	cl_git_pass(git_submodule_set_url(sm1, old_url));
@@ -196,7 +196,7 @@ void test_submodule_modify__edit_and_save(void)
 		(int)GIT_SUBMODULE_UPDATE_REBASE,
 		(int)git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_RESET));
 	cl_assert_equal_i(
-		1, git_submodule_set_fetch_recurse_submodules(sm1, old_fetchrecurse));
+		GIT_SUBMODULE_RECURSE_YES, git_submodule_set_fetch_recurse_submodules(sm1, old_fetchrecurse));
 
 	/* check that revert was successful */
 	cl_assert_equal_s(old_url, git_submodule_url(sm1));
@@ -209,7 +209,7 @@ void test_submodule_modify__edit_and_save(void)
 	cl_git_pass(git_submodule_set_url(sm1, SM_LIBGIT2_URL));
 	git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_UNTRACKED);
 	git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_REBASE);
-	git_submodule_set_fetch_recurse_submodules(sm1, 1);
+	git_submodule_set_fetch_recurse_submodules(sm1, GIT_SUBMODULE_RECURSE_YES);
 
 	/* call save */
 	cl_git_pass(git_submodule_save(sm1));
@@ -225,7 +225,7 @@ void test_submodule_modify__edit_and_save(void)
 		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm1));
 	cl_assert_equal_i(
 		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm1));
-	cl_assert_equal_i(1, git_submodule_fetch_recurse_submodules(sm1));
+	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_YES, git_submodule_fetch_recurse_submodules(sm1));
 
 	/* call reload and check that the new values are loaded */
 	cl_git_pass(git_submodule_reload(sm1));
@@ -235,7 +235,7 @@ void test_submodule_modify__edit_and_save(void)
 		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm1));
 	cl_assert_equal_i(
 		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm1));
-	cl_assert_equal_i(1, git_submodule_fetch_recurse_submodules(sm1));
+	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_YES, git_submodule_fetch_recurse_submodules(sm1));
 
 	/* open a second copy of the repo and compare submodule */
 	cl_git_pass(git_repository_open(&r2, "submod2"));
@@ -246,7 +246,16 @@ void test_submodule_modify__edit_and_save(void)
 		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm2));
 	cl_assert_equal_i(
 		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm2));
-	cl_assert_equal_i(1, git_submodule_fetch_recurse_submodules(sm2));
+	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_YES, git_submodule_fetch_recurse_submodules(sm2));
+
+	/* set fetchRecurseSubmodules on-demand */
+	cl_git_pass(git_submodule_reload(sm1));
+	git_submodule_set_fetch_recurse_submodules(sm1, GIT_SUBMODULE_RECURSE_ONDEMAND);
+	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_ONDEMAND, git_submodule_fetch_recurse_submodules(sm1));
+	/* call save */
+	cl_git_pass(git_submodule_save(sm1));
+	cl_git_pass(git_submodule_reload(sm1));
+	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_ONDEMAND, git_submodule_fetch_recurse_submodules(sm1));
 
 	git_repository_free(r2);
 	git__free(old_url);
-- 
cgit v1.2.3


From f38cb9815fde36843a945bfac115122c43b610a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Marek=20=C5=A0uppa?= <mr@shu.io>
Date: Tue, 31 Dec 2013 11:27:32 +0100
Subject: Updated fetch.c test to pass.

I am not sure why there was 6 in the first place.
---
 tests/online/fetch.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/online/fetch.c b/tests/online/fetch.c
index 7e9dfdbbe..8f71cf3f5 100644
--- a/tests/online/fetch.c
+++ b/tests/online/fetch.c
@@ -58,17 +58,17 @@ static void do_fetch(const char *url, git_remote_autotag_option_t flag, int n)
 
 void test_online_fetch__default_git(void)
 {
-	do_fetch("git://github.com/libgit2/TestGitRepository.git", GIT_REMOTE_DOWNLOAD_TAGS_AUTO, 6);
+	do_fetch("git://github.com/libgit2/TestGitRepository.git", GIT_REMOTE_DOWNLOAD_TAGS_AUTO, 5);
 }
 
 void test_online_fetch__default_http(void)
 {
-	do_fetch("http://github.com/libgit2/TestGitRepository.git", GIT_REMOTE_DOWNLOAD_TAGS_AUTO, 6);
+	do_fetch("http://github.com/libgit2/TestGitRepository.git", GIT_REMOTE_DOWNLOAD_TAGS_AUTO, 5);
 }
 
 void test_online_fetch__default_https(void)
 {
-	do_fetch("https://github.com/libgit2/TestGitRepository.git", GIT_REMOTE_DOWNLOAD_TAGS_AUTO, 6);
+	do_fetch("https://github.com/libgit2/TestGitRepository.git", GIT_REMOTE_DOWNLOAD_TAGS_AUTO, 5);
 }
 
 void test_online_fetch__no_tags_git(void)
-- 
cgit v1.2.3


From 6014b7b59ce3320311d61b929e9567c0503b630b Mon Sep 17 00:00:00 2001
From: Robert Konrad <robert@ktx-software.com>
Date: Mon, 30 Dec 2013 18:08:04 +0100
Subject: Fixed a compile error in VS2013.

---
 src/config_file.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/config_file.c b/src/config_file.c
index 0971aa7b0..2e78f7c8b 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -213,7 +213,7 @@ static int config_refresh(git_config_backend *cfg)
 	int res = 0, updated = 0, any_updated = 0;
 	diskfile_backend *b = (diskfile_backend *)cfg;
 	git_strmap *old_values;
-	struct reader *reader;
+	struct reader *reader = NULL;
 	uint32_t i;
 
 	for (i = 0; i < git_array_size(b->readers); i++) {
-- 
cgit v1.2.3


From 10311979492a4b91b24ebab178588e9af801bc42 Mon Sep 17 00:00:00 2001
From: Robert Konrad <robert@ktx-software.com>
Date: Thu, 2 Jan 2014 03:14:03 +0100
Subject: Read the submodule branch option from Git 1.8.2.

---
 include/git2/submodule.h |  8 ++++++++
 src/submodule.c          | 20 ++++++++++++++++++++
 src/submodule.h          |  1 +
 3 files changed, 29 insertions(+)

diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index a1507593c..36bc7f8ed 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -283,6 +283,14 @@ GIT_EXTERN(const char *) git_submodule_path(git_submodule *submodule);
  */
 GIT_EXTERN(const char *) git_submodule_url(git_submodule *submodule);
 
+/**
+* Get the branch for the submodule.
+*
+* @param submodule Pointer to submodule object
+* @return Pointer to the submodule branch
+*/
+GIT_EXTERN(const char *) git_submodule_branch(git_submodule *submodule);
+
 /**
  * Set the URL for the submodule.
  *
diff --git a/src/submodule.c b/src/submodule.c
index 5548e4553..365fea3c1 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -472,6 +472,10 @@ int git_submodule_save(git_submodule *submodule)
 		(error = git_config_file_set_string(mods, key.ptr, submodule->url)) < 0)
 		goto cleanup;
 
+	if ((error = submodule_config_key_trunc_puts(&key, "branch")) < 0 ||
+		(error = git_config_file_set_string(mods, key.ptr, submodule->branch)) < 0)
+		goto cleanup;
+
 	if (!(error = submodule_config_key_trunc_puts(&key, "update")) &&
 		(val = git_submodule_update_to_str(submodule->update)) != NULL)
 		error = git_config_file_set_string(mods, key.ptr, val);
@@ -528,6 +532,12 @@ const char *git_submodule_url(git_submodule *submodule)
 	return submodule->url;
 }
 
+const char *git_submodule_branch(git_submodule *submodule)
+{
+	assert(submodule);
+	return submodule->branch;
+}
+
 int git_submodule_set_url(git_submodule *submodule, const char *url)
 {
 	assert(submodule && url);
@@ -992,6 +1002,7 @@ static git_submodule *submodule_alloc(git_repository *repo, const char *name)
 	sm->update = sm->update_default = GIT_SUBMODULE_UPDATE_CHECKOUT;
 	sm->fetch_recurse = sm->update_default = GIT_SUBMODULE_RECURSE_YES;
 	sm->repo   = repo;
+	sm->branch = NULL;
 
 	return sm;
 }
@@ -1190,6 +1201,15 @@ static int submodule_load_from_config(
 			goto done;
 		}
 	}
+	else if (strcasecmp(property, "branch") == 0) {
+		git__free(sm->branch);
+		sm->branch = NULL;
+
+		if (value != NULL && (sm->branch = git__strdup(value)) == NULL) {
+			error = -1;
+			goto done;
+		}
+	}
 	else if (strcasecmp(property, "update") == 0) {
 		if ((error = git_submodule_parse_update(&sm->update, value)) < 0)
 			goto done;
diff --git a/src/submodule.h b/src/submodule.h
index 2a610e112..94748aca0 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -81,6 +81,7 @@ struct git_submodule {
 	char *name;
 	char *path; /* important: may just point to "name" string */
 	char *url;
+	char *branch;
 	git_submodule_update_t update;
 	git_submodule_update_t update_default;
 	git_submodule_ignore_t ignore;
-- 
cgit v1.2.3


From e5994eb02d1f43dd5f9104854fb6fb7448264167 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Thu, 2 Jan 2014 16:56:09 +0100
Subject: Add missing `git_reference_symbolic_create_with_log`.

It's exported in the headers, but the implementation was missing.
---
 src/refs.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/refs.c b/src/refs.c
index 83343f41b..f60ac3122 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -444,6 +444,21 @@ int git_reference_symbolic_create(
 	return reference__create(ref_out, repo, name, NULL, target, force, NULL, NULL);
 }
 
+int git_reference_symbolic_create_with_log(
+	git_reference **ref_out,
+	git_repository *repo,
+	const char *name,
+	const char *target,
+	int force,
+	const git_signature *signature,
+	const char *log_message)
+{
+	assert(target && signature && log_message);
+
+	return reference__create(
+		ref_out, repo, name, NULL, target, force, signature, log_message);
+}
+
 static int ensure_is_an_updatable_direct_reference(git_reference *ref)
 {
 	if (ref->type == GIT_REF_OID)
-- 
cgit v1.2.3


From 0b7951788cb793cea45594b168e3936527a3277a Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Thu, 2 Jan 2014 16:58:13 +0100
Subject: Allow the log message to be NULL.

---
 src/refs.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/refs.c b/src/refs.c
index f60ac3122..c8a833b6b 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -427,7 +427,7 @@ int git_reference_create_with_log(
 	const git_signature *signature,
 	const char *log_message)
 {
-	assert(oid && signature && log_message);
+	assert(oid && signature);
 
 	return reference__create(
 		ref_out, repo, name, oid, NULL, force, signature, log_message);
@@ -453,7 +453,7 @@ int git_reference_symbolic_create_with_log(
 	const git_signature *signature,
 	const char *log_message)
 {
-	assert(target && signature && log_message);
+	assert(target && signature);
 
 	return reference__create(
 		ref_out, repo, name, NULL, target, force, signature, log_message);
-- 
cgit v1.2.3


From 9152417290e7e375552638c2b340e9163c80dd8d Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 2 Jan 2014 14:30:24 -0800
Subject: Fix warnings with submodule changes

---
 include/git2/submodule.h | 2 +-
 src/submodule.c          | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index a1507593c..4b4ba6eef 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -437,7 +437,7 @@ GIT_EXTERN(git_submodule_recurse_t) git_submodule_fetch_recurse_submodules(
  * @param fetch_recurse_submodules Boolean value
  * @return old value for fetchRecurseSubmodules
  */
-GIT_EXTERN(int) git_submodule_set_fetch_recurse_submodules(
+GIT_EXTERN(git_submodule_recurse_t) git_submodule_set_fetch_recurse_submodules(
 	git_submodule *submodule,
 	git_submodule_recurse_t fetch_recurse_submodules);
 
diff --git a/src/submodule.c b/src/submodule.c
index 5548e4553..26dfe2c6b 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -632,11 +632,11 @@ git_submodule_recurse_t git_submodule_fetch_recurse_submodules(
 	return submodule->fetch_recurse;
 }
 
-int git_submodule_set_fetch_recurse_submodules(
+git_submodule_recurse_t git_submodule_set_fetch_recurse_submodules(
 	git_submodule *submodule,
 	git_submodule_recurse_t fetch_recurse_submodules)
 {
-	int old;
+	git_submodule_recurse_t old;
 
 	assert(submodule);
 
@@ -990,7 +990,7 @@ static git_submodule *submodule_alloc(git_repository *repo, const char *name)
 	GIT_REFCOUNT_INC(sm);
 	sm->ignore = sm->ignore_default = GIT_SUBMODULE_IGNORE_NONE;
 	sm->update = sm->update_default = GIT_SUBMODULE_UPDATE_CHECKOUT;
-	sm->fetch_recurse = sm->update_default = GIT_SUBMODULE_RECURSE_YES;
+	sm->fetch_recurse = GIT_SUBMODULE_RECURSE_YES;
 	sm->repo   = repo;
 
 	return sm;
-- 
cgit v1.2.3


From b49985212a395b54dbaa50c7d39faaaf6f4c4f4b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 3 Jan 2014 11:37:23 -0800
Subject: Use our strnlen on MacOS for backward compat

Apparently MacOS didn't have strnlen on 10.6 and earlier.  To
avoid having linking problems on older versions, we'll just use
our internal version.
---
 src/posix.h | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/posix.h b/src/posix.h
index f529914fe..0d9be49a9 100644
--- a/src/posix.h
+++ b/src/posix.h
@@ -89,13 +89,17 @@ extern struct tm * p_gmtime_r (const time_t *timer, struct tm *result);
 #	include "unix/posix.h"
 #endif
 
-#if defined(__MINGW32__) || defined(__sun)
+#if defined(__MINGW32__) || defined(__sun) || defined(__APPLE__)
+#   define NO_STRNLEN
+#endif
+
+#ifdef NO_STRNLEN
 GIT_INLINE(size_t) p_strnlen(const char *s, size_t maxlen) {
 	const char *end = memchr(s, 0, maxlen);
 	return end ? (size_t)(end - s) : maxlen;
 }
 #else
-# define p_strnlen strnlen
+#   define p_strnlen strnlen
 #endif
 
 #ifdef NO_READDIR_R
-- 
cgit v1.2.3


From 97bbf61e901ac9e0080394a9321dfc632b77fe99 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 3 Jan 2014 12:14:22 -0800
Subject: Tree accessor tests with hard path names

---
 tests/object/tree/write.c | 66 ++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 57 insertions(+), 9 deletions(-)

diff --git a/tests/object/tree/write.c b/tests/object/tree/write.c
index 3bea0ed4d..599859727 100644
--- a/tests/object/tree/write.c
+++ b/tests/object/tree/write.c
@@ -9,7 +9,7 @@ static const char *third_tree = "eb86d8b81d6adbd5290a935d6c9976882de98488";
 
 static git_repository *g_repo;
 
-// Fixture setup and teardown
+/* Fixture setup and teardown */
 void test_object_tree_write__initialize(void)
 {
    g_repo = cl_git_sandbox_init("testrepo");
@@ -22,7 +22,7 @@ void test_object_tree_write__cleanup(void)
 
 void test_object_tree_write__from_memory(void)
 {
-   // write a tree from a memory
+	/* write a tree from a memory */
 	git_treebuilder *builder;
 	git_tree *tree;
 	git_oid id, bid, rid, id2;
@@ -31,7 +31,9 @@ void test_object_tree_write__from_memory(void)
 	git_oid_fromstr(&id2, second_tree);
 	git_oid_fromstr(&bid, blob_oid);
 
-	//create a second tree from first tree using `git_treebuilder_insert` on REPOSITORY_FOLDER.
+	/* create a second tree from first tree using `git_treebuilder_insert`
+	 * on REPOSITORY_FOLDER.
+	 */
 	cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
 	cl_git_pass(git_treebuilder_create(&builder, tree));
 
@@ -61,7 +63,7 @@ void test_object_tree_write__from_memory(void)
 
 void test_object_tree_write__subtree(void)
 {
-   // write a hierarchical tree from a memory
+	/* write a hierarchical tree from a memory */
 	git_treebuilder *builder;
 	git_tree *tree;
 	git_oid id, bid, subtree_id, id2, id3;
@@ -72,25 +74,25 @@ void test_object_tree_write__subtree(void)
 	git_oid_fromstr(&id3, third_tree);
 	git_oid_fromstr(&bid, blob_oid);
 
-	//create subtree
+	/* create subtree */
 	cl_git_pass(git_treebuilder_create(&builder, NULL));
 	cl_git_pass(git_treebuilder_insert(
-		NULL, builder, "new.txt", &bid, GIT_FILEMODE_BLOB)); //-V536
+		NULL, builder, "new.txt", &bid, GIT_FILEMODE_BLOB)); /* -V536 */
 	cl_git_pass(git_treebuilder_write(&subtree_id, g_repo, builder));
 	git_treebuilder_free(builder);
 
-	// create parent tree
+	/* create parent tree */
 	cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
 	cl_git_pass(git_treebuilder_create(&builder, tree));
 	cl_git_pass(git_treebuilder_insert(
-		NULL, builder, "new", &subtree_id, GIT_FILEMODE_TREE)); //-V536
+		NULL, builder, "new", &subtree_id, GIT_FILEMODE_TREE)); /* -V536 */
 	cl_git_pass(git_treebuilder_write(&id_hiearar, g_repo, builder));
 	git_treebuilder_free(builder);
 	git_tree_free(tree);
 
 	cl_assert(git_oid_cmp(&id_hiearar, &id3) == 0);
 
-	// check data is correct
+	/* check data is correct */
 	cl_git_pass(git_tree_lookup(&tree, g_repo, &id_hiearar));
 	cl_assert(2 == git_tree_entrycount(tree));
 	git_tree_free(tree);
@@ -314,3 +316,49 @@ void test_object_tree_write__filtering(void)
 
 	git_tree_free(tree);
 }
+
+void test_object_tree_write__cruel_paths(void)
+{
+	static const char *the_paths[] = {
+		"C:\\",
+		" : * ? \" \n < > |",
+		"a\\b",
+		"\\\\b\a",
+		REP1024("1234"), /* 4096 char string */
+		REP1024("12345678"), /* 8192 char string */
+		NULL
+	};
+	git_treebuilder *builder;
+	git_tree *tree;
+	git_oid id, bid;
+	const char **scan;
+	int count = 0;
+
+	git_oid_fromstr(&bid, blob_oid);
+
+	/* create tree */
+	cl_git_pass(git_treebuilder_create(&builder, NULL));
+	for (scan = the_paths; *scan; ++scan) {
+		cl_git_pass(git_treebuilder_insert(
+			NULL, builder, *scan, &bid, GIT_FILEMODE_BLOB));
+		count++;
+	}
+	cl_git_pass(git_treebuilder_write(&id, g_repo, builder));
+	git_treebuilder_free(builder);
+
+	/* check data is correct */
+	cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
+	cl_assert_equal_i(count, git_tree_entrycount(tree));
+	for (scan = the_paths; *scan; ++scan) {
+		const git_tree_entry *te = git_tree_entry_byname(tree, *scan);
+		cl_assert(te != NULL);
+		cl_assert_equal_s(*scan, git_tree_entry_name(te));
+	}
+	for (scan = the_paths; *scan; ++scan) {
+		git_tree_entry *te;
+		cl_git_pass(git_tree_entry_bypath(&te, tree, *scan));
+		cl_assert_equal_s(*scan, git_tree_entry_name(te));
+		git_tree_entry_free(te);
+	}
+	git_tree_free(tree);
+}
-- 
cgit v1.2.3


From 79ccb921781dc61c4ed06e5c8c19c2ea1ba0a33a Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 3 Jan 2014 14:26:02 -0800
Subject: Further tree building tests with hard paths

---
 tests/object/tree/write.c | 46 ++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 40 insertions(+), 6 deletions(-)

diff --git a/tests/object/tree/write.c b/tests/object/tree/write.c
index 599859727..45356e807 100644
--- a/tests/object/tree/write.c
+++ b/tests/object/tree/write.c
@@ -324,15 +324,20 @@ void test_object_tree_write__cruel_paths(void)
 		" : * ? \" \n < > |",
 		"a\\b",
 		"\\\\b\a",
+		":\\",
+		"COM1",
+		"foo.aux",
 		REP1024("1234"), /* 4096 char string */
 		REP1024("12345678"), /* 8192 char string */
+		"\xC5\xAA\x6E\xC4\xAD\x63\xC5\x8D\x64\x65\xCC\xBD", /* Ūnĭc�de̽ */
 		NULL
 	};
 	git_treebuilder *builder;
 	git_tree *tree;
-	git_oid id, bid;
+	git_oid id, bid, subid;
 	const char **scan;
-	int count = 0;
+	int count = 0, i, j;
+	git_tree_entry *te;
 
 	git_oid_fromstr(&bid, blob_oid);
 
@@ -348,17 +353,46 @@ void test_object_tree_write__cruel_paths(void)
 
 	/* check data is correct */
 	cl_git_pass(git_tree_lookup(&tree, g_repo, &id));
+
 	cl_assert_equal_i(count, git_tree_entrycount(tree));
+
 	for (scan = the_paths; *scan; ++scan) {
-		const git_tree_entry *te = git_tree_entry_byname(tree, *scan);
-		cl_assert(te != NULL);
-		cl_assert_equal_s(*scan, git_tree_entry_name(te));
+		const git_tree_entry *cte = git_tree_entry_byname(tree, *scan);
+		cl_assert(cte != NULL);
+		cl_assert_equal_s(*scan, git_tree_entry_name(cte));
 	}
 	for (scan = the_paths; *scan; ++scan) {
-		git_tree_entry *te;
 		cl_git_pass(git_tree_entry_bypath(&te, tree, *scan));
 		cl_assert_equal_s(*scan, git_tree_entry_name(te));
 		git_tree_entry_free(te);
 	}
+
+	git_tree_free(tree);
+
+	/* let's try longer paths */
+	cl_git_pass(git_treebuilder_create(&builder, NULL));
+	for (scan = the_paths; *scan; ++scan) {
+		cl_git_pass(git_treebuilder_insert(
+			NULL, builder, *scan, &id, GIT_FILEMODE_TREE));
+	}
+	cl_git_pass(git_treebuilder_write(&subid, g_repo, builder));
+	git_treebuilder_free(builder);
+
+	/* check data is correct */
+	cl_git_pass(git_tree_lookup(&tree, g_repo, &subid));
+
+	cl_assert_equal_i(count, git_tree_entrycount(tree));
+
+	for (i = 0; i < count; ++i) {
+		for (j = 0; j < count; ++j) {
+			git_buf b = GIT_BUF_INIT;
+			cl_git_pass(git_buf_joinpath(&b, the_paths[i], the_paths[j]));
+			cl_git_pass(git_tree_entry_bypath(&te, tree, b.ptr));
+			cl_assert_equal_s(the_paths[j], git_tree_entry_name(te));
+			git_tree_entry_free(te);
+			git_buf_free(&b);
+		}
+	}
+
 	git_tree_free(tree);
 }
-- 
cgit v1.2.3


From e7f89b46c35727af5efc92ae46199285d8426d57 Mon Sep 17 00:00:00 2001
From: John Crepezzi <john.crepezzi@gmail.com>
Date: Sat, 4 Jan 2014 18:18:59 -0500
Subject: Fix spelling mistake

Closes #2029
---
 include/git2/types.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/types.h b/include/git2/types.h
index 55505b110..d88815d80 100644
--- a/include/git2/types.h
+++ b/include/git2/types.h
@@ -131,7 +131,7 @@ typedef struct git_treebuilder git_treebuilder;
 /** Memory representation of an index file. */
 typedef struct git_index git_index;
 
-/** An interator for conflicts in the index. */
+/** An iterator for conflicts in the index. */
 typedef struct git_index_conflict_iterator git_index_conflict_iterator;
 
 /** Memory representation of a set of config files */
-- 
cgit v1.2.3


From a06474f81dacabd5357be358a73340ee19306956 Mon Sep 17 00:00:00 2001
From: XTao <xutao881001@gmail.com>
Date: Wed, 8 Jan 2014 11:19:12 +0800
Subject: Add orig_commit.

---
 src/blame.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/blame.c b/src/blame.c
index a1357415a..45f55ed14 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -242,7 +242,7 @@ static int index_blob_lines(git_blame *blame)
     git_off_t len = blame->final_buf_size;
     int num = 0, incomplete = 0, bol = 1;
     size_t *i;
- 
+
     if (len && buf[len-1] != '\n')
         incomplete++; /* incomplete line at the end */
     while (len--) {
@@ -263,13 +263,15 @@ static int index_blob_lines(git_blame *blame)
     blame->num_lines = num + incomplete;
     return blame->num_lines;
 }
- 
+
 static git_blame_hunk* hunk_from_entry(git_blame__entry *e)
 {
 	git_blame_hunk *h = new_hunk(
 			e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path);
 	git_oid_cpy(&h->final_commit_id, git_commit_id(e->suspect->commit));
+	git_oid_cpy(&h->orig_commit_id, git_commit_id(e->suspect->commit));
 	h->final_signature = git_signature_dup(git_commit_author(e->suspect->commit));
+	h->orig_signature = git_signature_dup(git_commit_author(e->suspect->commit));
 	h->boundary = e->is_boundary ? 1 : 0;
 	return h;
 }
-- 
cgit v1.2.3


From 551f5cefb41877be03e6d7a03f16fd424fc9de37 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Wed, 8 Jan 2014 13:47:47 +0200
Subject: Solaris does not have qsort_r

---
 src/util.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/util.c b/src/util.c
index 47516a8f7..81a64c702 100644
--- a/src/util.c
+++ b/src/util.c
@@ -729,6 +729,7 @@ void git__qsort_r(
 #if defined(__MINGW32__) || defined(AMIGA) || \
 	defined(__OpenBSD__) || defined(__NetBSD__) || \
 	defined(__gnu_hurd__) || defined(__ANDROID_API__) || \
+	defined(__sun) || \
 	(__GLIBC__ == 2 && __GLIBC_MINOR__ < 8)
 	git__insertsort_r(els, nel, elsize, NULL, cmp, payload);
 #elif defined(GIT_WIN32)
-- 
cgit v1.2.3


From 6adcaab70cdd6ced307a71945a1f80833ec9670f Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 8 Jan 2014 10:07:30 -0800
Subject: Handle git_buf's from users more liberally

---
 include/git2/blob.h                                |   2 +-
 src/blob.c                                         |   2 ++
 src/buffer.c                                       |   8 ++++++
 src/buffer.h                                       |   9 ++++++
 tests/filter/blob.c                                |  32 +++++++++++++++++++++
 .../2c/9a868cfdf8e270d0ec68164433376c68fb1789      | Bin 0 -> 169 bytes
 .../e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391      | Bin 0 -> 15 bytes
 .../ef/0dcd356d77221e9c27f4f3928ad28e80b87ceb      | Bin 0 -> 168 bytes
 tests/resources/crlf/.gitted/refs/heads/master     |   2 +-
 9 files changed, 53 insertions(+), 2 deletions(-)
 create mode 100644 tests/resources/crlf/.gitted/objects/2c/9a868cfdf8e270d0ec68164433376c68fb1789
 create mode 100644 tests/resources/crlf/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
 create mode 100644 tests/resources/crlf/.gitted/objects/ef/0dcd356d77221e9c27f4f3928ad28e80b87ceb

diff --git a/include/git2/blob.h b/include/git2/blob.h
index 19ad4d949..6ba5e9f9c 100644
--- a/include/git2/blob.h
+++ b/include/git2/blob.h
@@ -84,7 +84,7 @@ GIT_EXTERN(git_repository *) git_blob_owner(const git_blob *blob);
  * time.
  *
  * @param blob pointer to the blob
- * @return the pointer; NULL if the blob has no contents
+ * @return the pointer
  */
 GIT_EXTERN(const void *) git_blob_rawcontent(const git_blob *blob);
 
diff --git a/src/blob.c b/src/blob.c
index ab344ae98..2e924f37f 100644
--- a/src/blob.c
+++ b/src/blob.c
@@ -347,6 +347,8 @@ int git_blob_filtered_content(
 
 	assert(blob && path && out);
 
+	git_buf_sanitize(out);
+
 	if (check_for_binary_data && git_blob_is_binary(blob))
 		return 0;
 
diff --git a/src/buffer.c b/src/buffer.c
index 20682322e..3283c2d4f 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -100,6 +100,14 @@ void git_buf_free(git_buf *buf)
 	git_buf_init(buf, 0);
 }
 
+void git_buf_sanitize(git_buf *buf)
+{
+	if (buf->ptr == NULL) {
+		assert (buf->size == 0 && buf->asize == 0);
+		buf->ptr = git_buf__initbuf;
+	}
+}
+
 void git_buf_clear(git_buf *buf)
 {
 	buf->size = 0;
diff --git a/src/buffer.h b/src/buffer.h
index c88af6fef..564a4f561 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -51,6 +51,15 @@ extern void git_buf_init(git_buf *buf, size_t initial_size);
 extern int git_buf_try_grow(
 	git_buf *buf, size_t target_size, bool mark_oom, bool preserve_external);
 
+/**
+ * Sanitizes git_buf structures provided from user input.  Users of the
+ * library, when providing git_buf's, may wish to provide a NULL ptr for
+ * ease of handling.  The buffer routines, however, expect a non-NULL ptr
+ * always.  This helper method simply handles NULL input, converting to a
+ * git_buf__initbuf.
+ */
+extern void git_buf_sanitize(git_buf *buf);
+
 extern void git_buf_swap(git_buf *buf_a, git_buf *buf_b);
 extern char *git_buf_detach(git_buf *buf);
 extern void git_buf_attach(git_buf *buf, char *ptr, size_t asize);
diff --git a/tests/filter/blob.c b/tests/filter/blob.c
index 9600a9779..8dce6470a 100644
--- a/tests/filter/blob.c
+++ b/tests/filter/blob.c
@@ -47,6 +47,38 @@ void test_filter_blob__all_crlf(void)
 	git_blob_free(blob);
 }
 
+void test_filter_blob__sanitizes(void)
+{
+	git_blob *blob;
+	git_buf buf;
+
+	cl_git_pass(git_revparse_single(
+		(git_object **)&blob, g_repo, "e69de29")); /* zero-byte */
+
+	cl_assert_equal_i(0, git_blob_rawsize(blob));
+	cl_assert_equal_s("", git_blob_rawcontent(blob));
+
+	memset(&buf, 0, sizeof(git_buf));
+	cl_git_pass(git_blob_filtered_content(&buf, blob, "file.bin", 1));
+	cl_assert_equal_sz(0, buf.size);
+	cl_assert_equal_s("", buf.ptr);
+	git_buf_free(&buf);
+
+	memset(&buf, 0, sizeof(git_buf));
+	cl_git_pass(git_blob_filtered_content(&buf, blob, "file.crlf", 1));
+	cl_assert_equal_sz(0, buf.size);
+	cl_assert_equal_s("", buf.ptr);
+	git_buf_free(&buf);
+
+	memset(&buf, 0, sizeof(git_buf));
+	cl_git_pass(git_blob_filtered_content(&buf, blob, "file.lf", 1));
+	cl_assert_equal_sz(0, buf.size);
+	cl_assert_equal_s("", buf.ptr);
+	git_buf_free(&buf);
+
+	git_blob_free(blob);
+}
+
 void test_filter_blob__ident(void)
 {
 	git_oid id;
diff --git a/tests/resources/crlf/.gitted/objects/2c/9a868cfdf8e270d0ec68164433376c68fb1789 b/tests/resources/crlf/.gitted/objects/2c/9a868cfdf8e270d0ec68164433376c68fb1789
new file mode 100644
index 000000000..218e9d192
Binary files /dev/null and b/tests/resources/crlf/.gitted/objects/2c/9a868cfdf8e270d0ec68164433376c68fb1789 differ
diff --git a/tests/resources/crlf/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests/resources/crlf/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
new file mode 100644
index 000000000..711223894
Binary files /dev/null and b/tests/resources/crlf/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ
diff --git a/tests/resources/crlf/.gitted/objects/ef/0dcd356d77221e9c27f4f3928ad28e80b87ceb b/tests/resources/crlf/.gitted/objects/ef/0dcd356d77221e9c27f4f3928ad28e80b87ceb
new file mode 100644
index 000000000..33aceda12
Binary files /dev/null and b/tests/resources/crlf/.gitted/objects/ef/0dcd356d77221e9c27f4f3928ad28e80b87ceb differ
diff --git a/tests/resources/crlf/.gitted/refs/heads/master b/tests/resources/crlf/.gitted/refs/heads/master
index a2dbe0c2d..cfdaaf37b 100644
--- a/tests/resources/crlf/.gitted/refs/heads/master
+++ b/tests/resources/crlf/.gitted/refs/heads/master
@@ -1 +1 @@
-12faf3c1ea55f572473cec9052fca468c3584ccb
+2c9a868cfdf8e270d0ec68164433376c68fb1789
-- 
cgit v1.2.3


From b92b434f5a240a8c149bcf86bbcd1743cd873bcf Mon Sep 17 00:00:00 2001
From: XTao <xutao881001@gmail.com>
Date: Thu, 9 Jan 2014 11:18:38 +0800
Subject: Add orig & final commit test.

---
 tests/blame/blame_helpers.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/blame/blame_helpers.c b/tests/blame/blame_helpers.c
index d64bb5c4c..56240dbde 100644
--- a/tests/blame/blame_helpers.c
+++ b/tests/blame/blame_helpers.c
@@ -48,6 +48,9 @@ void check_blame_hunk_index(git_repository *repo, git_blame *blame, int idx,
 				actual, expected);
 	}
 	cl_assert_equal_s(actual, expected);
+	cl_assert_equal_i(git_oid_cmp(&hunk->final_commit_id, &hunk->orig_commit_id), 0);
+
+
 	if (strcmp(hunk->orig_path, orig_path)) {
 		hunk_message(idx, hunk, "has mismatched original path (got '%s', expected '%s')\n",
 				hunk->orig_path, orig_path);
-- 
cgit v1.2.3


From 9eb45fc51a55fb8b058a28b5ee1e297991fedca5 Mon Sep 17 00:00:00 2001
From: Brodie Rao <brodie@sf.io>
Date: Sun, 12 Jan 2014 23:29:44 -0800
Subject: branch: handle NULL pointers passed to git_branch_iterator_free()

Signed-off-by: Brodie Rao <brodie@sf.io>
---
 src/branch.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/branch.c b/src/branch.c
index ef71c2cd1..9ed0addb5 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -181,6 +181,9 @@ void git_branch_iterator_free(git_branch_iterator *_iter)
 {
 	branch_iter *iter = (branch_iter *) _iter;
 
+	if (iter == NULL)
+		return;
+
 	git_reference_iterator_free(iter->iter);
 	git__free(iter);
 }
-- 
cgit v1.2.3


From e3c6a1bf02227cf996a5c0da784124ddea5c1ba6 Mon Sep 17 00:00:00 2001
From: Brodie Rao <brodie@sf.io>
Date: Sun, 12 Jan 2014 23:30:06 -0800
Subject: config: handle NULL pointers passed to git_config_iterator_free()

Signed-off-by: Brodie Rao <brodie@sf.io>
---
 src/config.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/config.c b/src/config.c
index 056a6ae13..b8d78c23b 100644
--- a/src/config.c
+++ b/src/config.c
@@ -927,6 +927,9 @@ int git_config_next(git_config_entry **entry, git_config_iterator *iter)
 
 void git_config_iterator_free(git_config_iterator *iter)
 {
+	if (iter == NULL)
+		return;
+
 	iter->free(iter);
 }
 
-- 
cgit v1.2.3


From ae3b6d612db6305a20e1139503b3c9e99cf4632a Mon Sep 17 00:00:00 2001
From: Brodie Rao <brodie@sf.io>
Date: Sun, 12 Jan 2014 23:31:13 -0800
Subject: odb: handle NULL pointers passed to git_odb_stream_free

Signed-off-by: Brodie Rao <brodie@sf.io>
---
 src/odb.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/odb.c b/src/odb.c
index b208b279e..b413f83b4 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -949,6 +949,9 @@ int git_odb_stream_read(git_odb_stream *stream, char *buffer, size_t len)
 
 void git_odb_stream_free(git_odb_stream *stream)
 {
+	if (stream == NULL)
+		return;
+
 	git__free(stream->hash_ctx);
 	stream->free(stream);
 }
-- 
cgit v1.2.3


From 32b7e84ec09170761bf9422cc4139be0b14975a9 Mon Sep 17 00:00:00 2001
From: Brodie Rao <brodie@sf.io>
Date: Sun, 12 Jan 2014 23:31:35 -0800
Subject: oid: handle NULL pointers passed to git_oid_shorten_free()

Signed-off-by: Brodie Rao <brodie@sf.io>
---
 src/oid.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/oid.c b/src/oid.c
index d56b6af24..567b6cf06 100644
--- a/src/oid.c
+++ b/src/oid.c
@@ -314,6 +314,9 @@ git_oid_shorten *git_oid_shorten_new(size_t min_length)
 
 void git_oid_shorten_free(git_oid_shorten *os)
 {
+	if (os == NULL)
+		return;
+
 	git__free(os->nodes);
 	git__free(os);
 }
-- 
cgit v1.2.3


From 2ad45213a84a5e3948557edcb3a76bc439f8b61e Mon Sep 17 00:00:00 2001
From: Brodie Rao <brodie@sf.io>
Date: Sun, 12 Jan 2014 23:31:57 -0800
Subject: refs: handle NULL pointers passed to git_reference_iterator_free()

Signed-off-by: Brodie Rao <brodie@sf.io>
---
 src/refs.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/refs.c b/src/refs.c
index c8a833b6b..ce172aa27 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -724,6 +724,9 @@ int git_reference_next_name(const char **out, git_reference_iterator *iter)
 
 void git_reference_iterator_free(git_reference_iterator *iter)
 {
+	if (iter == NULL)
+		return;
+
 	git_refdb_iterator_free(iter);
 }
 
-- 
cgit v1.2.3


From 2fcc0d07d050a6d70d85c510cef7aea4845e340f Mon Sep 17 00:00:00 2001
From: Brodie Rao <brodie@sf.io>
Date: Sun, 12 Jan 2014 23:32:10 -0800
Subject: util: handle NULL pointers passed to git_strarray_free()

Signed-off-by: Brodie Rao <brodie@sf.io>
---
 src/util.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/util.c b/src/util.c
index 81a64c702..f977a9bb1 100644
--- a/src/util.c
+++ b/src/util.c
@@ -140,6 +140,10 @@ int git_libgit2_opts(int key, ...)
 void git_strarray_free(git_strarray *array)
 {
 	size_t i;
+
+	if (array == NULL)
+		return;
+
 	for (i = 0; i < array->count; ++i)
 		git__free(array->strings[i]);
 
-- 
cgit v1.2.3


From 86f92b7431b15ccde4ba63a60afad87db83a215e Mon Sep 17 00:00:00 2001
From: Sascha Cunz <sascha.cunz@gmail.com>
Date: Mon, 13 Jan 2014 12:49:54 +0000
Subject: Show informational messages during cmake run as informational

---
 CMakeLists.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 48cbccb4e..f1c81eb6f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -136,7 +136,7 @@ ELSE ()
 		LINK_LIBRARIES(${HTTP_PARSER_LIBRARIES})
 		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -lhttp_parser")
 	ELSE()
-		MESSAGE("http-parser was not found or is too old; using bundled 3rd-party sources.")
+		MESSAGE(STATUS "http-parser was not found or is too old; using bundled 3rd-party sources.")
 		INCLUDE_DIRECTORIES(deps/http-parser)
 		FILE(GLOB SRC_HTTP deps/http-parser/*.c deps/http-parser/*.h)
 	ENDIF()
@@ -177,9 +177,9 @@ IF (ZLIB_FOUND)
 		SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} zlib")
 	ENDIF()
 	# Fake the message CMake would have shown
-	MESSAGE("-- Found zlib: ${ZLIB_LIBRARY}")
+	MESSAGE(STATUS "Found zlib: ${ZLIB_LIBRARY}")
 ELSE()
-	MESSAGE( "zlib was not found; using bundled 3rd-party sources." )
+	MESSAGE(STATUS "zlib was not found; using bundled 3rd-party sources." )
 	INCLUDE_DIRECTORIES(deps/zlib)
 	ADD_DEFINITIONS(-DNO_VIZ -DSTDC -DNO_GZIP)
 	FILE(GLOB SRC_ZLIB deps/zlib/*.c deps/zlib/*.h)
-- 
cgit v1.2.3


From 63170bcae91e5ddf6c0a2589d7212e0e62c8b269 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Mon, 13 Jan 2014 17:51:08 +0100
Subject: Fix a memory leak in `git_pathspec__vinit`.

---
 src/pathspec.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/pathspec.c b/src/pathspec.c
index bad8dacdb..d6ce09c02 100644
--- a/src/pathspec.c
+++ b/src/pathspec.c
@@ -89,8 +89,10 @@ int git_pathspec__vinit(
 		if (ret == GIT_ENOTFOUND) {
 			git__free(match);
 			continue;
-		} else if (ret < 0)
+		} else if (ret < 0) {
+			git__free(match);
 			return ret;
+		}
 
 		if (git_vector_insert(vspec, match) < 0)
 			return -1;
-- 
cgit v1.2.3


From 1234738e06c806ebafaf0ec04523adc823999c2d Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Mon, 13 Jan 2014 22:12:02 +0100
Subject: Fix a memory leak in `git_config_iterator_glob_new`.

---
 src/config.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/config.c b/src/config.c
index b8d78c23b..8447608cd 100644
--- a/src/config.c
+++ b/src/config.c
@@ -458,6 +458,7 @@ int git_config_iterator_glob_new(git_config_iterator **out, const git_config *cf
 	if ((result = regcomp(&iter->regex, regexp, REG_EXTENDED)) < 0) {
 		giterr_set_regex(&iter->regex, result);
 		regfree(&iter->regex);
+		git__free(iter);
 		return -1;
 	}
 
-- 
cgit v1.2.3


From a8e4cb11fd77d52529e1e464df52a6db1aae33e7 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Mon, 13 Jan 2014 22:12:17 +0100
Subject: Fix a memory leak in `config_parse`.

---
 src/config_file.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/config_file.c b/src/config_file.c
index 2e78f7c8b..c7727c029 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -1072,8 +1072,10 @@ static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_c
 			git_buf_printf(&buf, "%s.%s", current_section, var_name);
 			git__free(var_name);
 
-			if (git_buf_oom(&buf))
+			if (git_buf_oom(&buf)) {
+				git__free(var_value);
 				return -1;
+			}
 
 			var->entry->name = git_buf_detach(&buf);
 			var->entry->value = var_value;
-- 
cgit v1.2.3


From ddf1b1ffa5e6cea27562aa56df3955b5a916828a Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Mon, 13 Jan 2014 22:33:10 +0100
Subject: Fix a memory leak in `hash_and_save` and `inject_object`.

---
 src/indexer.c | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/indexer.c b/src/indexer.c
index 6132571cc..4af503546 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -373,8 +373,10 @@ static int hash_and_save(git_indexer *idx, git_rawobj *obj, git_off_t entry_star
 	entry->crc = crc32(0L, Z_NULL, 0);
 
 	entry_size = (size_t)(idx->off - entry_start);
-	if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0)
+	if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0) {
+		git__free(pentry);
 		goto on_error;
+	}
 
 	return save_entry(idx, entry, pentry, entry_start);
 
@@ -648,8 +650,10 @@ static int inject_object(git_indexer *idx, git_oid *id)
 
 	entry_start = seek_back_trailer(idx);
 
-	if (git_odb_read(&obj, idx->odb, id) < 0)
+	if (git_odb_read(&obj, idx->odb, id) < 0) {
+		git__free(entry);
 		return -1;
+	}
 
 	data = git_odb_object_data(obj);
 	len = git_odb_object_size(obj);
@@ -662,8 +666,10 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	idx->pack->mwf.size += hdr_len;
 	entry->crc = crc32(entry->crc, hdr, hdr_len);
 
-	if ((error = git__compress(&buf, data, len)) < 0)
+	if ((error = git__compress(&buf, data, len)) < 0) {
+		git__free(entry);
 		goto cleanup;
+	}
 
 	/* And then the compressed object */
 	git_filebuf_write(&idx->pack_file, buf.ptr, buf.size);
@@ -672,8 +678,10 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	git_buf_free(&buf);
 
 	/* Write a fake trailer so the pack functions play ball */
-	if ((error = git_filebuf_write(&idx->pack_file, &foo, GIT_OID_RAWSZ)) < 0)
+	if ((error = git_filebuf_write(&idx->pack_file, &foo, GIT_OID_RAWSZ)) < 0) {
+		git__free(entry);
 		goto cleanup;
+	}
 
 	idx->pack->mwf.size += GIT_OID_RAWSZ;
 
-- 
cgit v1.2.3


From b0b32b432111adf33fa3c3cb3beee7a81087704b Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Mon, 13 Jan 2014 22:51:10 +0100
Subject: Fix a double free issue in `git_blame__alloc`.

`git_blame_free` already calls `git__free` on `gbr`.
---
 src/blame.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/blame.c b/src/blame.c
index 45f55ed14..b885de214 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -121,7 +121,6 @@ git_blame* git_blame__alloc(
 		git_vector_insert(&gbr->paths, git__strdup(path)) < 0)
 	{
 		git_blame_free(gbr);
-		git__free(gbr);
 		return NULL;
 	}
 
-- 
cgit v1.2.3


From 9bf17d2cf59127573c0be812883170785f0dc340 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 13 Jan 2014 14:11:14 -0800
Subject: Add coverity-scan script

---
 .travis.yml        |  6 ++++++
 script/cibuild.sh  |  6 ++++++
 script/coverity.sh | 49 +++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 61 insertions(+)
 create mode 100755 script/coverity.sh

diff --git a/.travis.yml b/.travis.yml
index 151060fb4..648c432db 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,9 +13,15 @@ env:
   - OPTIONS="-DBUILD_CLAR=ON -DBUILD_EXAMPLES=ON"
 
 matrix:
+ fast_finish: true
  include:
    - compiler: i586-mingw32msvc-gcc
      env: OPTIONS="-DBUILD_CLAR=OFF -DWIN32=ON -DMINGW=ON"
+   - compiler: gcc
+     env: COVERITY=1
+     secure: "YnhS+8n6B+uoyaYfaJ3Lei7cSJqHDPiKJCKFIF2c87YDfmCvAJke8QtE7IzjYDs7UFkTCM4ox+ph2bERUrxZbSCyEkHdjIZpKuMJfYWja/jgMqTMxdyOH9y8JLFbZsSXDIXDwqBlC6vVyl1fP90M35wuWcNTs6tctfVWVofEFbs="
+ allow_failures:
+   - env: COVERITY=1
 
 install:
  - sudo apt-get -qq update
diff --git a/script/cibuild.sh b/script/cibuild.sh
index aa4fa47aa..5c0584a80 100755
--- a/script/cibuild.sh
+++ b/script/cibuild.sh
@@ -1,5 +1,11 @@
 #!/bin/sh
 
+if [ "$COVERITY" -eq 1 ];
+then
+	./script/coverity.sh;
+	exit $?;
+fi
+
 # Create a test repo which we can use for the online::push tests
 mkdir $HOME/_temp
 git init --bare $HOME/_temp/test.git
diff --git a/script/coverity.sh b/script/coverity.sh
new file mode 100755
index 000000000..e75395948
--- /dev/null
+++ b/script/coverity.sh
@@ -0,0 +1,49 @@
+#!/bin/bash
+set -e
+
+# Environment check
+[ -z "$COVERITY_TOKEN" ] && echo "Need to set a coverity token" && exit 1
+
+COV_VERSION=6.6.1
+case `uname -m` in
+	i?86)				BITS=32 ;;
+	amd64|x86_64)	BITS=64 ;;
+esac
+SCAN_TOOL=https://scan.coverity.com/download/linux-${BITS}
+TOOL_BASE=`pwd`/_coverity-scan
+
+# Install coverity tools
+if [ ! -d $TOOL_BASE ]; then
+	echo "Downloading coverity..."
+	mkdir -p $TOOL_BASE
+	cd $TOOL_BASE
+	wget -O coverity_tool.tgz $SCAN_TOOL \
+		--post-data "project=libgit2&token=$COVERITY_TOKEN"
+	tar xzf coverity_tool.tgz
+	cd ..
+	TOOL_DIR=`find $TOOL_BASE -type d -name 'cov-analysis*'`
+	ln -s $TOOL_DIR $TOOL_BASE/cov-analysis
+fi
+
+COV_BUILD="$TOOL_BASE/cov-analysis/bin/cov-build"
+
+# Configure and build
+rm -rf _build
+mkdir _build
+cd _build
+cmake .. -DTHREADSAFE=ON
+COVERITY_UNSUPPORTED=1 \
+	$COV_BUILD --dir cov-int \
+	cmake --build .
+
+# Upload results
+tar czf libgit2.tgz cov-int
+SHA=`git rev-parse --short HEAD`
+curl \
+	--form project=libgit2 \
+	--form token=$COVERITY_TOKEN \
+	--form email=bs@github.com \
+	--form file=@libgit2.tgz \
+	--form version=$SHA \
+	--form description="Travis build" \
+	http://scan5.coverity.com/cgi-bin/upload.py
-- 
cgit v1.2.3


From ac44b3d2447f06f4022bb4b58a160244e24c039c Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Mon, 13 Jan 2014 23:28:03 +0100
Subject: Incorporate @ethomson's suggestions.

---
 src/indexer.c | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/src/indexer.c b/src/indexer.c
index 4af503546..6290ea6cc 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -355,7 +355,7 @@ static int hash_and_save(git_indexer *idx, git_rawobj *obj, git_off_t entry_star
 	git_oid oid;
 	size_t entry_size;
 	struct entry *entry;
-	struct git_pack_entry *pentry;
+	struct git_pack_entry *pentry = NULL;
 
 	entry = git__calloc(1, sizeof(*entry));
 	GITERR_CHECK_ALLOC(entry);
@@ -373,14 +373,13 @@ static int hash_and_save(git_indexer *idx, git_rawobj *obj, git_off_t entry_star
 	entry->crc = crc32(0L, Z_NULL, 0);
 
 	entry_size = (size_t)(idx->off - entry_start);
-	if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0) {
-		git__free(pentry);
+	if (crc_object(&entry->crc, &idx->pack->mwf, entry_start, entry_size) < 0)
 		goto on_error;
-	}
 
 	return save_entry(idx, entry, pentry, entry_start);
 
 on_error:
+	git__free(pentry);
 	git__free(entry);
 	git__free(obj->data);
 	return -1;
@@ -636,7 +635,7 @@ static int inject_object(git_indexer *idx, git_oid *id)
 {
 	git_odb_object *obj;
 	struct entry *entry;
-	struct git_pack_entry *pentry;
+	struct git_pack_entry *pentry = NULL;
 	git_oid foo = {{0}};
 	unsigned char hdr[64];
 	git_buf buf = GIT_BUF_INIT;
@@ -666,10 +665,8 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	idx->pack->mwf.size += hdr_len;
 	entry->crc = crc32(entry->crc, hdr, hdr_len);
 
-	if ((error = git__compress(&buf, data, len)) < 0) {
-		git__free(entry);
-		goto cleanup;
-	}
+	if ((error = git__compress(&buf, data, len)) < 0)
+		goto error;
 
 	/* And then the compressed object */
 	git_filebuf_write(&idx->pack_file, buf.ptr, buf.size);
@@ -678,10 +675,8 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	git_buf_free(&buf);
 
 	/* Write a fake trailer so the pack functions play ball */
-	if ((error = git_filebuf_write(&idx->pack_file, &foo, GIT_OID_RAWSZ)) < 0) {
-		git__free(entry);
-		goto cleanup;
-	}
+	if ((error = git_filebuf_write(&idx->pack_file, &foo, GIT_OID_RAWSZ)) < 0)
+		goto error;
 
 	idx->pack->mwf.size += GIT_OID_RAWSZ;
 
@@ -692,10 +687,14 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	git_oid_cpy(&entry->oid, id);
 	idx->off = entry_start + hdr_len + len;
 
-	if ((error = save_entry(idx, entry, pentry, entry_start)) < 0)
-		git__free(pentry);
+	if (!(error = save_entry(idx, entry, pentry, entry_start)))
+		goto done;
 
-cleanup:
+error:
+	git__free(entry);
+	git__free(pentry);
+
+done:
 	git_odb_object_free(obj);
 	return error;
 }
-- 
cgit v1.2.3


From f1c16d0eb3caa18d98cae095aa536e6b6a8b8ea7 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 13 Jan 2014 15:18:13 -0800
Subject: Tweak travis secure config

---
 .travis.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 648c432db..f25ff7681 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -9,6 +9,9 @@ compiler:
 
 # Settings to try
 env:
+ global:
+  - secure: "YnhS+8n6B+uoyaYfaJ3Lei7cSJqHDPiKJCKFIF2c87YDfmCvAJke8QtE7IzjYDs7UFkTCM4ox+ph2bERUrxZbSCyEkHdjIZpKuMJfYWja/jgMqTMxdyOH9y8JLFbZsSXDIXDwqBlC6vVyl1fP90M35wuWcNTs6tctfVWVofEFbs="
+ matrix:
   - OPTIONS="-DTHREADSAFE=ON -DCMAKE_BUILD_TYPE=Release"
   - OPTIONS="-DBUILD_CLAR=ON -DBUILD_EXAMPLES=ON"
 
@@ -19,7 +22,6 @@ matrix:
      env: OPTIONS="-DBUILD_CLAR=OFF -DWIN32=ON -DMINGW=ON"
    - compiler: gcc
      env: COVERITY=1
-     secure: "YnhS+8n6B+uoyaYfaJ3Lei7cSJqHDPiKJCKFIF2c87YDfmCvAJke8QtE7IzjYDs7UFkTCM4ox+ph2bERUrxZbSCyEkHdjIZpKuMJfYWja/jgMqTMxdyOH9y8JLFbZsSXDIXDwqBlC6vVyl1fP90M35wuWcNTs6tctfVWVofEFbs="
  allow_failures:
    - env: COVERITY=1
 
-- 
cgit v1.2.3


From 4caf0df018a918b38446895ea870e8db65e8dcae Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 13 Jan 2014 15:43:29 -0800
Subject: Add coverity scan badge to readme

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 434cc1937..debf16eb6 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,7 @@ libgit2 - the Git linkable library
 ==================================
 
 [![Build Status](https://secure.travis-ci.org/libgit2/libgit2.png?branch=development)](http://travis-ci.org/libgit2/libgit2)
+[![Coverity Scan Build Status](https://scan.coverity.com/projects/639/badge.svg)](https://scan.coverity.com/projects/639)
 
 `libgit2` is a portable, pure C implementation of the Git core methods provided as a
 re-entrant linkable library with a solid API, allowing you to write native
-- 
cgit v1.2.3


From c6f26b48e47f6c0cd67769418c33efe66e5b5fe8 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 13 Dec 2013 18:26:46 -0500
Subject: Refactor zlib for easier deflate streaming

---
 src/compress.c     | 53 --------------------------------
 src/compress.h     | 16 ----------
 src/indexer.c      |  6 ++--
 src/pack-objects.c |  6 ++--
 src/zstream.c      | 90 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/zstream.h      | 25 +++++++++++++++
 6 files changed, 120 insertions(+), 76 deletions(-)
 delete mode 100644 src/compress.c
 delete mode 100644 src/compress.h
 create mode 100644 src/zstream.c
 create mode 100644 src/zstream.h

diff --git a/src/compress.c b/src/compress.c
deleted file mode 100644
index 14b79404c..000000000
--- a/src/compress.c
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-
-#include "compress.h"
-
-#include <zlib.h>
-
-#define BUFFER_SIZE (1024 * 1024)
-
-int git__compress(git_buf *buf, const void *buff, size_t len)
-{
-	z_stream zs;
-	char *zb;
-	size_t have;
-
-	memset(&zs, 0, sizeof(zs));
-	if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK)
-		return -1;
-
-	zb = git__malloc(BUFFER_SIZE);
-	GITERR_CHECK_ALLOC(zb);
-
-	zs.next_in = (void *)buff;
-	zs.avail_in = (uInt)len;
-
-	do {
-		zs.next_out = (unsigned char *)zb;
-		zs.avail_out = BUFFER_SIZE;
-
-		if (deflate(&zs, Z_FINISH) == Z_STREAM_ERROR) {
-			git__free(zb);
-			return -1;
-		}
-
-		have = BUFFER_SIZE - (size_t)zs.avail_out;
-
-		if (git_buf_put(buf, zb, have) < 0) {
-			git__free(zb);
-			return -1;
-		}
-
-	} while (zs.avail_out == 0);
-
-	assert(zs.avail_in == 0);
-
-	deflateEnd(&zs);
-	git__free(zb);
-	return 0;
-}
diff --git a/src/compress.h b/src/compress.h
deleted file mode 100644
index 49e6f4749..000000000
--- a/src/compress.h
+++ /dev/null
@@ -1,16 +0,0 @@
-/*
- * Copyright (C) the libgit2 contributors. All rights reserved.
- *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
- */
-#ifndef INCLUDE_compress_h__
-#define INCLUDE_compress_h__
-
-#include "common.h"
-
-#include "buffer.h"
-
-int git__compress(git_buf *buf, const void *buff, size_t len);
-
-#endif /* INCLUDE_compress_h__ */
diff --git a/src/indexer.c b/src/indexer.c
index 6132571cc..ccab8fcf0 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -5,8 +5,6 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include <zlib.h>
-
 #include "git2/indexer.h"
 #include "git2/object.h"
 
@@ -18,7 +16,7 @@
 #include "filebuf.h"
 #include "oid.h"
 #include "oidmap.h"
-#include "compress.h"
+#include "zstream.h"
 
 #define UINT31_MAX (0x7FFFFFFF)
 
@@ -662,7 +660,7 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	idx->pack->mwf.size += hdr_len;
 	entry->crc = crc32(entry->crc, hdr, hdr_len);
 
-	if ((error = git__compress(&buf, data, len)) < 0)
+	if ((error = git_zstream_deflatebuf(&buf, data, len)) < 0)
 		goto cleanup;
 
 	/* And then the compressed object */
diff --git a/src/pack-objects.c b/src/pack-objects.c
index 335944c0c..0d31d50ff 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -7,7 +7,7 @@
 
 #include "pack-objects.h"
 
-#include "compress.h"
+#include "zstream.h"
 #include "delta.h"
 #include "iterator.h"
 #include "netops.h"
@@ -319,7 +319,7 @@ static int write_object(git_buf *buf, git_packbuilder *pb, git_pobject *po)
 	/* Write data */
 	if (po->z_delta_size)
 		size = po->z_delta_size;
-	else if (git__compress(&zbuf, data, size) < 0)
+	else if (git_zstream_deflatebuf(&zbuf, data, size) < 0)
 		goto on_error;
 	else {
 		if (po->delta)
@@ -931,7 +931,7 @@ static int find_deltas(git_packbuilder *pb, git_pobject **list,
 		 * between writes at that moment.
 		 */
 		if (po->delta_data) {
-			if (git__compress(&zbuf, po->delta_data, po->delta_size) < 0)
+			if (git_zstream_deflatebuf(&zbuf, po->delta_data, po->delta_size) < 0)
 				goto on_error;
 
 			git__free(po->delta_data);
diff --git a/src/zstream.c b/src/zstream.c
new file mode 100644
index 000000000..e043dd3a9
--- /dev/null
+++ b/src/zstream.c
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include <zlib.h>
+
+#include "zstream.h"
+#include "buffer.h"
+
+#define BUFFER_SIZE (1024 * 1024)
+
+static int zstream_seterr(int zerr, git_zstream *zstream)
+{
+	if (zerr == Z_MEM_ERROR)
+		giterr_set_oom();
+	else if (zstream->msg)
+		giterr_set(GITERR_ZLIB, zstream->msg);
+	else
+		giterr_set(GITERR_ZLIB, "Unknown compression error");
+
+	return -1;
+}
+
+int git_zstream_init(git_zstream *zstream)
+{
+	int zerr;
+
+	if ((zerr = deflateInit(zstream, Z_DEFAULT_COMPRESSION)) != Z_OK)
+		return zstream_seterr(zerr, zstream);
+
+	return 0;
+}
+
+ssize_t git_zstream_deflate(void *out, size_t out_len, git_zstream *zstream, const void *in, size_t in_len)
+{
+	int zerr;
+
+	if ((ssize_t)out_len < 0)
+		out_len = INT_MAX;
+
+	zstream->next_in = (Bytef *)in;
+	zstream->avail_in = in_len;
+	zstream->next_out = out;
+	zstream->avail_out = out_len;
+
+	if ((zerr = deflate(zstream, Z_FINISH)) == Z_STREAM_ERROR)
+		return zstream_seterr(zerr, zstream);
+
+	return (out_len - zstream->avail_out);
+}
+
+void git_zstream_free(git_zstream *zstream)
+{
+	deflateEnd(zstream);
+}
+
+int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len)
+{
+	git_zstream zstream = GIT_ZSTREAM_INIT;
+	size_t out_len;
+	ssize_t written;
+	int error = 0;
+
+	if ((error = git_zstream_init(&zstream)) < 0)
+		goto done;
+
+	do {
+		if (out->asize - out->size < BUFFER_SIZE)
+			git_buf_grow(out, out->asize + BUFFER_SIZE);
+
+		out_len = out->asize - out->size;
+
+		if ((written = git_zstream_deflate(out->ptr + out->size, out_len, &zstream, in, in_len)) <= 0)
+			break;
+
+		in = (char *)in + written;
+		in_len -= written;
+		out->size += written;
+	} while (written > 0);
+
+	if (written < 0)
+		error = written;
+
+done:
+	git_zstream_free(&zstream);
+	return error;
+}
diff --git a/src/zstream.h b/src/zstream.h
new file mode 100644
index 000000000..e6c841120
--- /dev/null
+++ b/src/zstream.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_zstream_h__
+#define INCLUDE_zstream_h__
+
+#include <zlib.h>
+
+#include "common.h"
+#include "buffer.h"
+
+#define git_zstream z_stream
+
+#define GIT_ZSTREAM_INIT {0}
+
+int git_zstream_init(git_zstream *zstream);
+ssize_t git_zstream_deflate(void *out, size_t out_len, git_zstream *zstream, const void *in, size_t in_len);
+void git_zstream_free(git_zstream *zstream);
+
+int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len);
+
+#endif /* INCLUDE_zstream_h__ */
-- 
cgit v1.2.3


From 0ade2f7a5919d1953f679661a752c31328ccb90a Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sat, 14 Dec 2013 10:37:57 -0500
Subject: Packbuilder stream deflate instead of one-shot

---
 src/pack-objects.c | 145 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 81 insertions(+), 64 deletions(-)

diff --git a/src/pack-objects.c b/src/pack-objects.c
index 0d31d50ff..9df9a015e 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -61,6 +61,9 @@ struct pack_write_context {
 /* The minimal interval between progress updates (in seconds). */
 #define MIN_PROGRESS_UPDATE_INTERVAL 0.5
 
+/* Size of the buffer to feed to zlib */
+#define COMPRESS_BUFLEN (1024 * 1024)
+
 static unsigned name_hash(const char *name)
 {
 	unsigned c, hash = 0;
@@ -275,78 +278,95 @@ on_error:
 	return -1;
 }
 
-static int write_object(git_buf *buf, git_packbuilder *pb, git_pobject *po)
+static int write_object(
+	git_packbuilder *pb,
+	git_pobject *po,
+	int (*write_cb)(void *buf, size_t size, void *cb_data),
+	void *cb_data)
 {
+	git_zstream zstream = GIT_ZSTREAM_INIT;
 	git_odb_object *obj = NULL;
-	git_buf zbuf = GIT_BUF_INIT;
 	git_otype type;
-	unsigned char hdr[10];
-	size_t hdr_len;
-	unsigned long size;
+	unsigned char hdr[10], *zbuf = NULL;
 	void *data;
+	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
+	ssize_t written;
+	int error;
 
 	if (po->delta) {
 		if (po->delta_data)
 			data = po->delta_data;
-		else if (get_delta(&data, pb->odb, po) < 0)
-				goto on_error;
-		size = po->delta_size;
+		else if ((error = get_delta(&data, pb->odb, po)) < 0)
+				goto done;
+
+		data_len = po->delta_size;
 		type = GIT_OBJ_REF_DELTA;
 	} else {
-		if (git_odb_read(&obj, pb->odb, &po->id))
-			goto on_error;
+		if ((error = git_odb_read(&obj, pb->odb, &po->id)) < 0)
+			goto done;
 
 		data = (void *)git_odb_object_data(obj);
-		size = (unsigned long)git_odb_object_size(obj);
+		data_len = git_odb_object_size(obj);
 		type = git_odb_object_type(obj);
 	}
 
 	/* Write header */
-	hdr_len = git_packfile__object_header(hdr, size, type);
-
-	if (git_buf_put(buf, (char *)hdr, hdr_len) < 0)
-		goto on_error;
+	hdr_len = git_packfile__object_header(hdr, data_len, type);
 
-	if (git_hash_update(&pb->ctx, hdr, hdr_len) < 0)
-		goto on_error;
+	if ((error = write_cb(hdr, hdr_len, cb_data)) < 0 ||
+		(error = git_hash_update(&pb->ctx, hdr, hdr_len)) < 0)
+		goto done;
 
 	if (type == GIT_OBJ_REF_DELTA) {
-		if (git_buf_put(buf, (char *)po->delta->id.id, GIT_OID_RAWSZ) < 0 ||
-			git_hash_update(&pb->ctx, po->delta->id.id, GIT_OID_RAWSZ) < 0)
-			goto on_error;
+		if ((error = write_cb(po->delta->id.id, GIT_OID_RAWSZ, cb_data)) < 0 ||
+			(error = git_hash_update(&pb->ctx, po->delta->id.id, GIT_OID_RAWSZ)) < 0)
+			goto done;
 	}
 
 	/* Write data */
-	if (po->z_delta_size)
-		size = po->z_delta_size;
-	else if (git_zstream_deflatebuf(&zbuf, data, size) < 0)
-		goto on_error;
-	else {
+	if (po->z_delta_size) {
+		data_len = po->z_delta_size;
+
+		if ((error = write_cb(data, data_len, cb_data)) < 0 ||
+			(error = git_hash_update(&pb->ctx, data, data_len)) < 0)
+			goto done;
+	} else {
+		zbuf = git__malloc(zbuf_len);
+		GITERR_CHECK_ALLOC(zbuf);
+
+		if ((error = git_zstream_init(&zstream)) < 0)
+			goto done;
+
+		while ((written = git_zstream_deflate(zbuf, zbuf_len, &zstream, data, data_len)) > 0) {
+			if ((error = write_cb(zbuf, written, cb_data)) < 0 ||
+				(error = git_hash_update(&pb->ctx, zbuf, written)) < 0)
+				goto done;
+
+			data = (char *)data + written;
+			data_len -= written;
+		}
+
+		if (written < 0) {
+			error = written;
+			goto done;
+		}
+
 		if (po->delta)
 			git__free(data);
-		data = zbuf.ptr;
-		size = (unsigned long)zbuf.size;
 	}
 
-	if (git_buf_put(buf, data, size) < 0 ||
-		git_hash_update(&pb->ctx, data, size) < 0)
-		goto on_error;
-
 	if (po->delta_data) {
 		git__free(po->delta_data);
 		po->delta_data = NULL;
 	}
 
-	git_odb_object_free(obj);
-	git_buf_free(&zbuf);
-
 	pb->nr_written++;
-	return 0;
 
-on_error:
+done:
+	git__free(zbuf);
+	git_zstream_free(&zstream);
 	git_odb_object_free(obj);
-	git_buf_free(&zbuf);
-	return -1;
+	return error;
 }
 
 enum write_one_status {
@@ -356,9 +376,15 @@ enum write_one_status {
 	WRITE_ONE_RECURSIVE = 2 /* already scheduled to be written */
 };
 
-static int write_one(git_buf *buf, git_packbuilder *pb, git_pobject *po,
-		     enum write_one_status *status)
+static int write_one(
+	enum write_one_status *status,
+	git_packbuilder *pb,
+	git_pobject *po,
+	int (*write_cb)(void *buf, size_t size, void *cb_data),
+	void *cb_data)
 {
+	int error;
+
 	if (po->recursing) {
 		*status = WRITE_ONE_RECURSIVE;
 		return 0;
@@ -369,21 +395,19 @@ static int write_one(git_buf *buf, git_packbuilder *pb, git_pobject *po,
 
 	if (po->delta) {
 		po->recursing = 1;
-		if (write_one(buf, pb, po->delta, status) < 0)
-			return -1;
-		switch (*status) {
-		case WRITE_ONE_RECURSIVE:
-			/* we cannot depend on this one */
+
+		if ((error = write_one(status, pb, po->delta, write_cb, cb_data)) < 0)
+			return error;
+
+		/* we cannot depend on this one */
+		if (*status == WRITE_ONE_RECURSIVE)
 			po->delta = NULL;
-			break;
-		default:
-			break;
-		}
 	}
 
 	po->written = 1;
 	po->recursing = 0;
-	return write_object(buf, pb, po);
+
+	return write_object(pb, po, write_cb, cb_data);
 }
 
 GIT_INLINE(void) add_to_write_order(git_pobject **wo, unsigned int *endp,
@@ -563,12 +587,11 @@ static git_pobject **compute_write_order(git_packbuilder *pb)
 }
 
 static int write_pack(git_packbuilder *pb,
-		      int (*cb)(void *buf, size_t size, void *data),
-		      void *data)
+	int (*write_cb)(void *buf, size_t size, void *cb_data),
+	void *cb_data)
 {
 	git_pobject **write_order;
 	git_pobject *po;
-	git_buf buf = GIT_BUF_INIT;
 	enum write_one_status status;
 	struct git_pack_header ph;
 	git_oid entry_oid;
@@ -586,10 +609,8 @@ static int write_pack(git_packbuilder *pb,
 	ph.hdr_version = htonl(PACK_VERSION);
 	ph.hdr_entries = htonl(pb->nr_objects);
 
-	if ((error = cb(&ph, sizeof(ph), data)) < 0)
-		goto done;
-
-	if ((error = git_hash_update(&pb->ctx, &ph, sizeof(ph))) < 0)
+	if ((error = write_cb(&ph, sizeof(ph), cb_data)) < 0 ||
+		(error = git_hash_update(&pb->ctx, &ph, sizeof(ph))) < 0)
 		goto done;
 
 	pb->nr_remaining = pb->nr_objects;
@@ -597,21 +618,18 @@ static int write_pack(git_packbuilder *pb,
 		pb->nr_written = 0;
 		for ( ; i < pb->nr_objects; ++i) {
 			po = write_order[i];
-			if ((error = write_one(&buf, pb, po, &status)) < 0)
-				goto done;
-			if ((error = cb(buf.ptr, buf.size, data)) < 0)
+
+			if ((error = write_one(&status, pb, po, write_cb, cb_data)) < 0)
 				goto done;
-			git_buf_clear(&buf);
 		}
 
 		pb->nr_remaining -= pb->nr_written;
 	} while (pb->nr_remaining && i < pb->nr_objects);
 
-
 	if ((error = git_hash_final(&entry_oid, &pb->ctx)) < 0)
 		goto done;
 
-	error = cb(entry_oid.id, GIT_OID_RAWSZ, data);
+	error = write_cb(entry_oid.id, GIT_OID_RAWSZ, cb_data);
 
 done:
 	/* if callback cancelled writing, we must still free delta_data */
@@ -624,7 +642,6 @@ done:
 	}
 
 	git__free(write_order);
-	git_buf_free(&buf);
 	return error;
 }
 
-- 
cgit v1.2.3


From 52a8a130728e29d8ac9d6e4f9e3a7017afe461fb Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 6 Jan 2014 16:41:12 -0800
Subject: Packbuilder contains its own zstream

---
 src/pack-objects.c | 9 ++++-----
 src/pack-objects.h | 2 ++
 src/zstream.c      | 5 +++++
 src/zstream.h      | 1 +
 4 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/src/pack-objects.c b/src/pack-objects.c
index 9df9a015e..c4ed4dce3 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -130,6 +130,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	pb->nr_threads = 1; /* do not spawn any thread by default */
 
 	if (git_hash_ctx_init(&pb->ctx) < 0 ||
+		git_zstream_init(&pb->zstream) < 0 ||
 		git_repository_odb(&pb->odb, repo) < 0 ||
 		packbuilder_config(pb) < 0)
 		goto on_error;
@@ -284,7 +285,6 @@ static int write_object(
 	int (*write_cb)(void *buf, size_t size, void *cb_data),
 	void *cb_data)
 {
-	git_zstream zstream = GIT_ZSTREAM_INIT;
 	git_odb_object *obj = NULL;
 	git_otype type;
 	unsigned char hdr[10], *zbuf = NULL;
@@ -334,10 +334,9 @@ static int write_object(
 		zbuf = git__malloc(zbuf_len);
 		GITERR_CHECK_ALLOC(zbuf);
 
-		if ((error = git_zstream_init(&zstream)) < 0)
-			goto done;
+		git_zstream_reset(&pb->zstream);
 
-		while ((written = git_zstream_deflate(zbuf, zbuf_len, &zstream, data, data_len)) > 0) {
+		while ((written = git_zstream_deflate(zbuf, zbuf_len, &pb->zstream, data, data_len)) > 0) {
 			if ((error = write_cb(zbuf, written, cb_data)) < 0 ||
 				(error = git_hash_update(&pb->ctx, zbuf, written)) < 0)
 				goto done;
@@ -364,7 +363,6 @@ static int write_object(
 
 done:
 	git__free(zbuf);
-	git_zstream_free(&zstream);
 	git_odb_object_free(obj);
 	return error;
 }
@@ -1413,6 +1411,7 @@ void git_packbuilder_free(git_packbuilder *pb)
 		git__free(pb->object_list);
 
 	git_hash_ctx_cleanup(&pb->ctx);
+	git_zstream_free(&pb->zstream);
 
 	git__free(pb);
 }
diff --git a/src/pack-objects.h b/src/pack-objects.h
index 0c94a5a7a..4647df75a 100644
--- a/src/pack-objects.h
+++ b/src/pack-objects.h
@@ -14,6 +14,7 @@
 #include "hash.h"
 #include "oidmap.h"
 #include "netops.h"
+#include "zstream.h"
 
 #include "git2/oid.h"
 #include "git2/pack.h"
@@ -54,6 +55,7 @@ struct git_packbuilder {
 	git_odb *odb; /* associated object database */
 
 	git_hash_ctx ctx;
+	git_zstream zstream;
 
 	uint32_t nr_objects,
 		 nr_alloc,
diff --git a/src/zstream.c b/src/zstream.c
index e043dd3a9..7def0440b 100644
--- a/src/zstream.c
+++ b/src/zstream.c
@@ -52,6 +52,11 @@ ssize_t git_zstream_deflate(void *out, size_t out_len, git_zstream *zstream, con
 	return (out_len - zstream->avail_out);
 }
 
+void git_zstream_reset(git_zstream *zstream)
+{
+	deflateReset(zstream);
+}
+
 void git_zstream_free(git_zstream *zstream)
 {
 	deflateEnd(zstream);
diff --git a/src/zstream.h b/src/zstream.h
index e6c841120..9672903c0 100644
--- a/src/zstream.h
+++ b/src/zstream.h
@@ -18,6 +18,7 @@
 
 int git_zstream_init(git_zstream *zstream);
 ssize_t git_zstream_deflate(void *out, size_t out_len, git_zstream *zstream, const void *in, size_t in_len);
+void git_zstream_reset(git_zstream *zstream);
 void git_zstream_free(git_zstream *zstream);
 
 int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len);
-- 
cgit v1.2.3


From 249537573b8509fc8ed0ae8e51835d084af7c3d2 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Tue, 14 Jan 2014 19:08:58 +0100
Subject: Incorporate @arrbee's suggestions.

---
 src/indexer.c | 26 ++++++++++++--------------
 1 file changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/indexer.c b/src/indexer.c
index 6290ea6cc..bcca2eb6c 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -644,19 +644,17 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	size_t len, hdr_len;
 	int error;
 
-	entry = git__calloc(1, sizeof(*entry));
-	GITERR_CHECK_ALLOC(entry);
-
 	entry_start = seek_back_trailer(idx);
 
-	if (git_odb_read(&obj, idx->odb, id) < 0) {
-		git__free(entry);
+	if (git_odb_read(&obj, idx->odb, id) < 0)
 		return -1;
-	}
 
 	data = git_odb_object_data(obj);
 	len = git_odb_object_size(obj);
 
+	entry = git__calloc(1, sizeof(*entry));
+	GITERR_CHECK_ALLOC(entry);
+
 	entry->crc = crc32(0L, Z_NULL, 0);
 
 	/* Write out the object header */
@@ -666,7 +664,7 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	entry->crc = crc32(entry->crc, hdr, hdr_len);
 
 	if ((error = git__compress(&buf, data, len)) < 0)
-		goto error;
+		goto cleanup;
 
 	/* And then the compressed object */
 	git_filebuf_write(&idx->pack_file, buf.ptr, buf.size);
@@ -676,7 +674,7 @@ static int inject_object(git_indexer *idx, git_oid *id)
 
 	/* Write a fake trailer so the pack functions play ball */
 	if ((error = git_filebuf_write(&idx->pack_file, &foo, GIT_OID_RAWSZ)) < 0)
-		goto error;
+		goto cleanup;
 
 	idx->pack->mwf.size += GIT_OID_RAWSZ;
 
@@ -687,14 +685,14 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	git_oid_cpy(&entry->oid, id);
 	idx->off = entry_start + hdr_len + len;
 
-	if (!(error = save_entry(idx, entry, pentry, entry_start)))
-		goto done;
+	error = save_entry(idx, entry, pentry, entry_start);
 
-error:
-	git__free(entry);
-	git__free(pentry);
+cleanup:
+	if (error) {
+		git__free(entry);
+		git__free(pentry);
+	}
 
-done:
 	git_odb_object_free(obj);
 	return error;
 }
-- 
cgit v1.2.3


From 40ef47dd46fdd361b49ccc97605a93e0993e96db Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Tue, 14 Jan 2014 21:03:01 +0100
Subject: Add `git_remote_dup`.

---
 include/git2/remote.h          | 12 ++++++++++++
 src/remote.c                   | 41 +++++++++++++++++++++++++++++++++++++++++
 tests/network/remote/remotes.c | 21 +++++++++++++++++++++
 3 files changed, 74 insertions(+)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index 7410909dc..d3e6caa48 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -107,6 +107,18 @@ GIT_EXTERN(int) git_remote_load(git_remote **out, git_repository *repo, const ch
  */
 GIT_EXTERN(int) git_remote_save(const git_remote *remote);
 
+/**
+ * Create a copy of an existing remote.  All internal strings are also
+ * duplicated. Callbacks are not duplicated.
+ *
+ * Call `git_remote_free` to free the data.
+ *
+ * @param dest pointer where to store the copy
+ * @param source object to copy
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_remote_dup(git_remote **dest, const git_remote *source);
+
 /**
  * Get the remote's repository
  *
diff --git a/src/remote.c b/src/remote.c
index 294a8709d..6a4a707a4 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -248,6 +248,47 @@ int git_remote_create_inmemory(git_remote **out, git_repository *repo, const cha
 	return 0;
 }
 
+int git_remote_dup(git_remote **dest, const git_remote *source)
+{
+	int error;
+	git_remote *remote = git__calloc(1, sizeof(git_remote));
+	GITERR_CHECK_ALLOC(remote);
+
+	memset(remote, 0x0, sizeof(git_remote));
+
+	if (source->name != NULL) {
+		remote->name = git__strdup(source->name);
+		GITERR_CHECK_ALLOC(remote->name);
+	}
+
+	if (source->url != NULL) {
+		remote->url = git__strdup(source->url);
+		GITERR_CHECK_ALLOC(remote->url);		
+	}
+
+	if (source->pushurl != NULL) {
+		remote->pushurl = git__strdup(source->pushurl);
+		GITERR_CHECK_ALLOC(remote->pushurl);		
+	}
+
+	remote->repo = source->repo;
+	remote->need_pack = source->need_pack;
+	remote->download_tags = source->download_tags;
+	remote->check_cert = source->check_cert;
+	remote->update_fetchhead = source->update_fetchhead;
+
+	if ((error = git_vector_dup(&remote->refs, &source->refs, NULL)) < 0 ||
+		(error = git_vector_dup(&remote->refspecs, &source->refspecs, NULL)) < 0 ||
+		(error = git_vector_dup(&remote->active_refspecs, &source->active_refspecs, NULL))) {
+		git__free(remote);
+		return error;
+	}
+
+	*dest = remote;
+
+	return 0;
+}
+
 struct refspec_cb_data {
 	git_remote *remote;
 	int fetch;
diff --git a/tests/network/remote/remotes.c b/tests/network/remote/remotes.c
index 954ded82c..235a1022d 100644
--- a/tests/network/remote/remotes.c
+++ b/tests/network/remote/remotes.c
@@ -129,6 +129,27 @@ void test_network_remote_remotes__add_fetchspec(void)
 	cl_assert_equal_b(_refspec->push, false);
 }
 
+void test_network_remote_remotes__dup(void)
+{
+	git_strarray array;
+	git_remote *dup;
+
+	cl_git_pass(git_remote_dup(&dup, _remote));
+
+	cl_assert_equal_s(git_remote_name(dup), git_remote_name(_remote));
+	cl_assert_equal_s(git_remote_url(dup), git_remote_url(_remote));
+	cl_assert_equal_s(git_remote_pushurl(dup), git_remote_pushurl(_remote));
+
+	cl_git_pass(git_remote_get_fetch_refspecs(&array, _remote));
+	cl_assert_equal_i(1, (int)array.count);
+	cl_assert_equal_s("+refs/heads/*:refs/remotes/test/*", array.strings[0]);
+	git_strarray_free(&array);
+
+	cl_git_pass(git_remote_get_push_refspecs(&array, _remote));
+	cl_assert_equal_i(0, (int)array.count);
+	git_strarray_free(&array);
+}
+
 void test_network_remote_remotes__add_pushspec(void)
 {
 	size_t size;
-- 
cgit v1.2.3


From 616cd13757ece5becbba7b9ff556cf7ed5502431 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Tue, 14 Jan 2014 21:08:09 +0100
Subject: Don't duplicate state that's only used when fetching.

---
 src/remote.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/remote.c b/src/remote.c
index 6a4a707a4..089252668 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -272,7 +272,6 @@ int git_remote_dup(git_remote **dest, const git_remote *source)
 	}
 
 	remote->repo = source->repo;
-	remote->need_pack = source->need_pack;
 	remote->download_tags = source->download_tags;
 	remote->check_cert = source->check_cert;
 	remote->update_fetchhead = source->update_fetchhead;
-- 
cgit v1.2.3


From 99dcb2184a46140024de438a4a19ea5aada64be8 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Tue, 14 Jan 2014 21:08:20 +0100
Subject: We don't need memset here.

---
 src/remote.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index 089252668..622abbc8c 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -254,8 +254,6 @@ int git_remote_dup(git_remote **dest, const git_remote *source)
 	git_remote *remote = git__calloc(1, sizeof(git_remote));
 	GITERR_CHECK_ALLOC(remote);
 
-	memset(remote, 0x0, sizeof(git_remote));
-
 	if (source->name != NULL) {
 		remote->name = git__strdup(source->name);
 		GITERR_CHECK_ALLOC(remote->name);
-- 
cgit v1.2.3


From 29be3a6d9eee68b3964f34c498e64ce32452a57f Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Tue, 14 Jan 2014 21:33:35 +0100
Subject: Align git_signature_dup.

This changes git_signature_dup to actually honor oom conditions raised by
the call to git__strdup. It also aligns it with the error code return
pattern used everywhere else.
---
 include/git2/signature.h |  7 ++++---
 src/blame.c              |  8 ++++----
 src/reflog.c             |  2 +-
 src/signature.c          | 29 +++++++++++++++++------------
 4 files changed, 26 insertions(+), 20 deletions(-)

diff --git a/include/git2/signature.h b/include/git2/signature.h
index 2fa46d032..a1dd1ec7a 100644
--- a/include/git2/signature.h
+++ b/include/git2/signature.h
@@ -68,10 +68,11 @@ GIT_EXTERN(int) git_signature_default(git_signature **out, git_repository *repo)
  *
  * Call `git_signature_free()` to free the data.
  *
- * @param sig signature to duplicated
- * @return a copy of sig, NULL on out of memory
+ * @param dest pointer where to store the copy
+ * @param entry signature to duplicate
+ * @return 0 or an error code
  */
-GIT_EXTERN(git_signature *) git_signature_dup(const git_signature *sig);
+GIT_EXTERN(int) git_signature_dup(git_signature **dest, const git_signature *sig);
 
 /**
  * Free an existing signature.
diff --git a/src/blame.c b/src/blame.c
index b885de214..0f2d906d2 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -76,8 +76,8 @@ static git_blame_hunk* dup_hunk(git_blame_hunk *hunk)
 	git_oid_cpy(&newhunk->orig_commit_id, &hunk->orig_commit_id);
 	git_oid_cpy(&newhunk->final_commit_id, &hunk->final_commit_id);
 	newhunk->boundary = hunk->boundary;
-	newhunk->final_signature = git_signature_dup(hunk->final_signature);
-	newhunk->orig_signature = git_signature_dup(hunk->orig_signature);
+	git_signature_dup(&newhunk->final_signature, hunk->final_signature);
+	git_signature_dup(&newhunk->orig_signature, hunk->orig_signature);
 	return newhunk;
 }
 
@@ -269,8 +269,8 @@ static git_blame_hunk* hunk_from_entry(git_blame__entry *e)
 			e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path);
 	git_oid_cpy(&h->final_commit_id, git_commit_id(e->suspect->commit));
 	git_oid_cpy(&h->orig_commit_id, git_commit_id(e->suspect->commit));
-	h->final_signature = git_signature_dup(git_commit_author(e->suspect->commit));
-	h->orig_signature = git_signature_dup(git_commit_author(e->suspect->commit));
+	git_signature_dup(&h->final_signature, git_commit_author(e->suspect->commit));
+	git_signature_dup(&h->orig_signature, git_commit_author(e->suspect->commit));
 	h->boundary = e->is_boundary ? 1 : 0;
 	return h;
 }
diff --git a/src/reflog.c b/src/reflog.c
index 9b2b201bf..8e41621ea 100644
--- a/src/reflog.c
+++ b/src/reflog.c
@@ -82,7 +82,7 @@ int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_sign
 	entry = git__calloc(1, sizeof(git_reflog_entry));
 	GITERR_CHECK_ALLOC(entry);
 
-	if ((entry->committer = git_signature_dup(committer)) == NULL)
+	if ((git_signature_dup(&entry->committer, committer)) < 0)
 		goto cleanup;
 
 	if (msg != NULL) {
diff --git a/src/signature.c b/src/signature.c
index ec51a42e9..f658d6035 100644
--- a/src/signature.c
+++ b/src/signature.c
@@ -82,23 +82,28 @@ int git_signature_new(git_signature **sig_out, const char *name, const char *ema
 	return 0;
 }
 
-git_signature *git_signature_dup(const git_signature *sig)
+int git_signature_dup(git_signature **dest, const git_signature *source)
 {
-	git_signature *new;
+	git_signature *signature;
 
-	if (sig == NULL)
-		return NULL;
+	if (source == NULL)
+		return 0;
+
+	signature = git__calloc(1, sizeof(git_signature));
+	GITERR_CHECK_ALLOC(signature);
+
+	signature->name = git__strdup(source->name);
+	GITERR_CHECK_ALLOC(signature->name);
 
-	new = git__calloc(1, sizeof(git_signature));
-	if (new == NULL)
-		return NULL;
+	signature->email = git__strdup(source->email);
+	GITERR_CHECK_ALLOC(signature->email);
 
-	new->name = git__strdup(sig->name);
-	new->email = git__strdup(sig->email);
-	new->when.time = sig->when.time;
-	new->when.offset = sig->when.offset;
+	signature->when.time = source->when.time;
+	signature->when.offset = source->when.offset;
 
-	return new;
+	*dest = signature;
+
+	return 0;
 }
 
 int git_signature_now(git_signature **sig_out, const char *name, const char *email)
-- 
cgit v1.2.3


From 529f342aba858e81f370aca9570fa149ebba674b Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Tue, 14 Jan 2014 21:33:59 +0100
Subject: Align git_tree_entry_dup.

---
 include/git2/tree.h |  7 ++++---
 src/tree.c          | 17 ++++++++---------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/include/git2/tree.h b/include/git2/tree.h
index 422365674..6350ada9b 100644
--- a/include/git2/tree.h
+++ b/include/git2/tree.h
@@ -150,10 +150,11 @@ GIT_EXTERN(int) git_tree_entry_bypath(
  * Create a copy of a tree entry. The returned copy is owned by the user,
  * and must be freed explicitly with `git_tree_entry_free()`.
  *
- * @param entry A tree entry to duplicate
- * @return a copy of the original entry or NULL on error (alloc failure)
+ * @param dest pointer where to store the copy
+ * @param entry tree entry to duplicate
+ * @return 0 or an error code
  */
-GIT_EXTERN(git_tree_entry *) git_tree_entry_dup(const git_tree_entry *entry);
+GIT_EXTERN(int) git_tree_entry_dup(git_tree_entry **dest, const git_tree_entry *source);
 
 /**
  * Free a user-owned tree entry
diff --git a/src/tree.c b/src/tree.c
index 4d77ff778..fc105ed5e 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -204,22 +204,22 @@ void git_tree_entry_free(git_tree_entry *entry)
 	git__free(entry);
 }
 
-git_tree_entry *git_tree_entry_dup(const git_tree_entry *entry)
+int git_tree_entry_dup(git_tree_entry **dest, const git_tree_entry *source)
 {
 	size_t total_size;
 	git_tree_entry *copy;
 
-	assert(entry);
+	assert(source);
 
-	total_size = sizeof(git_tree_entry) + entry->filename_len + 1;
+	total_size = sizeof(git_tree_entry) + source->filename_len + 1;
 
 	copy = git__malloc(total_size);
-	if (!copy)
-		return NULL;
+	GITERR_CHECK_ALLOC(copy);
 
-	memcpy(copy, entry, total_size);
+	memcpy(copy, source, total_size);
 
-	return copy;
+	*dest = copy;
+	return 0;
 }
 
 void git_tree__free(void *_tree)
@@ -853,8 +853,7 @@ int git_tree_entry_bypath(
 	case '\0':
 		/* If there are no more components in the path, return
 		 * this entry */
-		*entry_out = git_tree_entry_dup(entry);
-		return 0;
+		return git_tree_entry_dup(entry_out, entry);
 	}
 
 	if (git_tree_lookup(&subtree, root->object.repo, &entry->oid) < 0)
-- 
cgit v1.2.3


From 39c2302a954e06d11fa39223d8e5afa2ad3a0b36 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 14 Jan 2014 11:19:57 -0800
Subject: unnecessary include

---
 src/vector.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/vector.c b/src/vector.c
index 050e032a0..f0c2f06c2 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -6,7 +6,6 @@
  */
 
 #include "common.h"
-#include "repository.h"
 #include "vector.h"
 
 /* In elements, not bytes */
-- 
cgit v1.2.3


From e85bbd5250d324980234ece9e8c2880f0e94c931 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 14 Jan 2014 14:41:49 -0800
Subject: Move libgit2 settings out of util

---
 src/settings.c | 134 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/util.c     | 123 ----------------------------------------------------
 2 files changed, 134 insertions(+), 123 deletions(-)
 create mode 100644 src/settings.c

diff --git a/src/settings.c b/src/settings.c
new file mode 100644
index 000000000..748f76560
--- /dev/null
+++ b/src/settings.c
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include <stdarg.h>
+
+#include <git2.h>
+#include "common.h"
+#include "fileops.h"
+#include "cache.h"
+
+void git_libgit2_version(int *major, int *minor, int *rev)
+{
+	*major = LIBGIT2_VER_MAJOR;
+	*minor = LIBGIT2_VER_MINOR;
+	*rev = LIBGIT2_VER_REVISION;
+}
+
+int git_libgit2_capabilities()
+{
+	return 0
+#ifdef GIT_THREADS
+		| GIT_CAP_THREADS
+#endif
+#if defined(GIT_SSL) || defined(GIT_WINHTTP)
+		| GIT_CAP_HTTPS
+#endif
+#if defined(GIT_SSH)
+		| GIT_CAP_SSH
+#endif
+	;
+}
+
+/* Declarations for tuneable settings */
+extern size_t git_mwindow__window_size;
+extern size_t git_mwindow__mapped_limit;
+
+static int config_level_to_futils_dir(int config_level)
+{
+	int val = -1;
+
+	switch (config_level) {
+	case GIT_CONFIG_LEVEL_SYSTEM: val = GIT_FUTILS_DIR_SYSTEM; break;
+	case GIT_CONFIG_LEVEL_XDG:    val = GIT_FUTILS_DIR_XDG; break;
+	case GIT_CONFIG_LEVEL_GLOBAL: val = GIT_FUTILS_DIR_GLOBAL; break;
+	default:
+		giterr_set(
+			GITERR_INVALID, "Invalid config path selector %d", config_level);
+	}
+
+	return val;
+}
+
+int git_libgit2_opts(int key, ...)
+{
+	int error = 0;
+	va_list ap;
+
+	va_start(ap, key);
+
+	switch (key) {
+	case GIT_OPT_SET_MWINDOW_SIZE:
+		git_mwindow__window_size = va_arg(ap, size_t);
+		break;
+
+	case GIT_OPT_GET_MWINDOW_SIZE:
+		*(va_arg(ap, size_t *)) = git_mwindow__window_size;
+		break;
+
+	case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT:
+		git_mwindow__mapped_limit = va_arg(ap, size_t);
+		break;
+
+	case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT:
+		*(va_arg(ap, size_t *)) = git_mwindow__mapped_limit;
+		break;
+
+	case GIT_OPT_GET_SEARCH_PATH:
+		if ((error = config_level_to_futils_dir(va_arg(ap, int))) >= 0) {
+			char *out = va_arg(ap, char *);
+			size_t outlen = va_arg(ap, size_t);
+
+			error = git_futils_dirs_get_str(out, outlen, error);
+		}
+		break;
+
+	case GIT_OPT_SET_SEARCH_PATH:
+		if ((error = config_level_to_futils_dir(va_arg(ap, int))) >= 0)
+			error = git_futils_dirs_set(error, va_arg(ap, const char *));
+		break;
+
+	case GIT_OPT_SET_CACHE_OBJECT_LIMIT:
+		{
+			git_otype type = (git_otype)va_arg(ap, int);
+			size_t size = va_arg(ap, size_t);
+			error = git_cache_set_max_object_size(type, size);
+			break;
+		}
+
+	case GIT_OPT_SET_CACHE_MAX_SIZE:
+		git_cache__max_storage = va_arg(ap, ssize_t);
+		break;
+
+	case GIT_OPT_ENABLE_CACHING:
+		git_cache__enabled = (va_arg(ap, int) != 0);
+		break;
+
+	case GIT_OPT_GET_CACHED_MEMORY:
+		*(va_arg(ap, ssize_t *)) = git_cache__current_storage.val;
+		*(va_arg(ap, ssize_t *)) = git_cache__max_storage;
+		break;
+
+	case GIT_OPT_GET_TEMPLATE_PATH:
+		{
+			char *out = va_arg(ap, char *);
+			size_t outlen = va_arg(ap, size_t);
+
+			error = git_futils_dirs_get_str(out, outlen, GIT_FUTILS_DIR_TEMPLATE);
+		}
+		break;
+
+	case GIT_OPT_SET_TEMPLATE_PATH:
+		error = git_futils_dirs_set(GIT_FUTILS_DIR_TEMPLATE, va_arg(ap, const char *));
+		break;
+	}
+
+	va_end(ap);
+
+	return error;
+}
+
diff --git a/src/util.c b/src/util.c
index f977a9bb1..3767b890c 100644
--- a/src/util.c
+++ b/src/util.c
@@ -6,137 +6,14 @@
  */
 #include <git2.h>
 #include "common.h"
-#include <stdarg.h>
 #include <stdio.h>
 #include <ctype.h>
 #include "posix.h"
-#include "fileops.h"
-#include "cache.h"
 
 #ifdef _MSC_VER
 # include <Shlwapi.h>
 #endif
 
-void git_libgit2_version(int *major, int *minor, int *rev)
-{
-	*major = LIBGIT2_VER_MAJOR;
-	*minor = LIBGIT2_VER_MINOR;
-	*rev = LIBGIT2_VER_REVISION;
-}
-
-int git_libgit2_capabilities()
-{
-	return 0
-#ifdef GIT_THREADS
-		| GIT_CAP_THREADS
-#endif
-#if defined(GIT_SSL) || defined(GIT_WINHTTP)
-		| GIT_CAP_HTTPS
-#endif
-#if defined(GIT_SSH)
-		| GIT_CAP_SSH
-#endif
-	;
-}
-
-/* Declarations for tuneable settings */
-extern size_t git_mwindow__window_size;
-extern size_t git_mwindow__mapped_limit;
-
-static int config_level_to_futils_dir(int config_level)
-{
-	int val = -1;
-
-	switch (config_level) {
-	case GIT_CONFIG_LEVEL_SYSTEM: val = GIT_FUTILS_DIR_SYSTEM; break;
-	case GIT_CONFIG_LEVEL_XDG:    val = GIT_FUTILS_DIR_XDG; break;
-	case GIT_CONFIG_LEVEL_GLOBAL: val = GIT_FUTILS_DIR_GLOBAL; break;
-	default:
-		giterr_set(
-			GITERR_INVALID, "Invalid config path selector %d", config_level);
-	}
-
-	return val;
-}
-
-int git_libgit2_opts(int key, ...)
-{
-	int error = 0;
-	va_list ap;
-
-	va_start(ap, key);
-
-	switch (key) {
-	case GIT_OPT_SET_MWINDOW_SIZE:
-		git_mwindow__window_size = va_arg(ap, size_t);
-		break;
-
-	case GIT_OPT_GET_MWINDOW_SIZE:
-		*(va_arg(ap, size_t *)) = git_mwindow__window_size;
-		break;
-
-	case GIT_OPT_SET_MWINDOW_MAPPED_LIMIT:
-		git_mwindow__mapped_limit = va_arg(ap, size_t);
-		break;
-
-	case GIT_OPT_GET_MWINDOW_MAPPED_LIMIT:
-		*(va_arg(ap, size_t *)) = git_mwindow__mapped_limit;
-		break;
-
-	case GIT_OPT_GET_SEARCH_PATH:
-		if ((error = config_level_to_futils_dir(va_arg(ap, int))) >= 0) {
-			char *out = va_arg(ap, char *);
-			size_t outlen = va_arg(ap, size_t);
-
-			error = git_futils_dirs_get_str(out, outlen, error);
-		}
-		break;
-
-	case GIT_OPT_SET_SEARCH_PATH:
-		if ((error = config_level_to_futils_dir(va_arg(ap, int))) >= 0)
-			error = git_futils_dirs_set(error, va_arg(ap, const char *));
-		break;
-
-	case GIT_OPT_SET_CACHE_OBJECT_LIMIT:
-		{
-			git_otype type = (git_otype)va_arg(ap, int);
-			size_t size = va_arg(ap, size_t);
-			error = git_cache_set_max_object_size(type, size);
-			break;
-		}
-
-	case GIT_OPT_SET_CACHE_MAX_SIZE:
-		git_cache__max_storage = va_arg(ap, ssize_t);
-		break;
-
-	case GIT_OPT_ENABLE_CACHING:
-		git_cache__enabled = (va_arg(ap, int) != 0);
-		break;
-
-	case GIT_OPT_GET_CACHED_MEMORY:
-		*(va_arg(ap, ssize_t *)) = git_cache__current_storage.val;
-		*(va_arg(ap, ssize_t *)) = git_cache__max_storage;
-		break;
-
-	case GIT_OPT_GET_TEMPLATE_PATH:
-		{
-			char *out = va_arg(ap, char *);
-			size_t outlen = va_arg(ap, size_t);
-
-			error = git_futils_dirs_get_str(out, outlen, GIT_FUTILS_DIR_TEMPLATE);
-		}
-		break;
-
-	case GIT_OPT_SET_TEMPLATE_PATH:
-		error = git_futils_dirs_set(GIT_FUTILS_DIR_TEMPLATE, va_arg(ap, const char *));
-		break;
-	}
-
-	va_end(ap);
-
-	return error;
-}
-
 void git_strarray_free(git_strarray *array)
 {
 	size_t i;
-- 
cgit v1.2.3


From 0b28217bdae4fd64f5b6b8f4cb8a6139518d037e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 15 Jan 2014 12:51:31 +0100
Subject: refs: remove the _with_log differentiation

Any well-behaved program should write a descriptive message to the
reflog whenever it updates a reference. Let's make this more prominent
by removing the version without the reflog parameters.
---
 include/git2/refs.h            | 152 +++++++----------------------------------
 src/branch.c                   |   2 +-
 src/commit.c                   |   2 +-
 src/push.c                     |   2 +-
 src/refs.c                     | 112 ++++++++++++++----------------
 src/refs.h                     |   2 +-
 src/remote.c                   |   2 +-
 src/repository.c               |   8 +--
 src/reset.c                    |   2 +-
 src/stash.c                    |   4 +-
 src/tag.c                      |   4 +-
 src/transports/local.c         |   2 +-
 tests/checkout/tree.c          |   2 +-
 tests/commit/write.c           |   2 +-
 tests/diff/rename.c            |   6 +-
 tests/merge/merge_helpers.c    |   2 +-
 tests/merge/workdir/simple.c   |   2 +-
 tests/merge/workdir/trivial.c  |   2 +-
 tests/refs/branches/delete.c   |   2 +-
 tests/refs/branches/ishead.c   |   6 +-
 tests/refs/branches/iterator.c |   4 +-
 tests/refs/crashes.c           |   2 +-
 tests/refs/create.c            |  16 ++---
 tests/refs/createwithlog.c     |   2 +-
 tests/refs/delete.c            |   2 +-
 tests/refs/foreachglob.c       |   2 +-
 tests/refs/overwrite.c         |  26 +++----
 tests/refs/pack.c              |   4 +-
 tests/refs/reflog/reflog.c     |  10 +--
 tests/refs/rename.c            |  10 +--
 tests/refs/revparse.c          |   3 +-
 tests/refs/settargetwithlog.c  |   2 +-
 tests/refs/setter.c            |  10 +--
 tests/refs/unicode.c           |   2 +-
 tests/refs/update.c            |   2 +-
 tests/repo/head.c              |   6 +-
 tests/repo/repo_helpers.c      |   2 +-
 tests/stash/save.c             |   2 +-
 tests/submodule/lookup.c       |   2 +-
 tests/threads/refdb.c          |   6 +-
 40 files changed, 162 insertions(+), 271 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 1df42fead..e4c6f1b16 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -89,37 +89,9 @@ GIT_EXTERN(int) git_reference_dwim(git_reference **out, git_repository *repo, co
  * This function will return an error if a reference already exists with the
  * given name unless `force` is true, in which case it will be overwritten.
  *
- * @param out Pointer to the newly created reference
- * @param repo Repository where that reference will live
- * @param name The name of the reference
- * @param target The target of the reference
- * @param force Overwrite existing references
- * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
- */
-GIT_EXTERN(int) git_reference_symbolic_create(git_reference **out, git_repository *repo, const char *name, const char *target, int force);
-
-/**
- * Create a new symbolic reference and update the reflog with a given
- * message.
- *
- * A symbolic reference is a reference name that refers to another
- * reference name.  If the other name moves, the symbolic name will move,
- * too.  As a simple example, the "HEAD" reference might refer to
- * "refs/heads/master" while on the "master" branch of a repository.
- *
- * The symbolic reference will be created in the repository and written to
- * the disk.  The generated reference object must be freed by the user.
- *
- * Valid reference names must follow one of two patterns:
- *
- * 1. Top-level names must contain only capital letters and underscores,
- *    and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
- * 2. Names prefixed with "refs/" can be almost anything.  You must avoid
- *    the characters '~', '^', ':', '\\', '?', '[', and '*', and the
- *    sequences ".." and "@{" which have special meaning to revparse.
- *
- * This function will return an error if a reference already exists with the
- * given name unless `force` is true, in which case it will be overwritten.
+ * The signature and message for the reflog will be ignored if the
+ * reference does not belong in the standard set (HEAD, branches and
+ * remote-tracking branches) and and it does not have a reflog.
  *
  * @param out Pointer to the newly created reference
  * @param repo Repository where that reference will live
@@ -127,18 +99,10 @@ GIT_EXTERN(int) git_reference_symbolic_create(git_reference **out, git_repositor
  * @param target The target of the reference
  * @param force Overwrite existing references
  * @param signature The identity that will used to populate the reflog entry
- * @param log_message The one line long message that has to be appended
- * to the reflog
- * @return 0 on success, EEXISTS, EINVALIDSPEC or an error code
+ * @param log_message The one line long message to be appended to the reflog
+ * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
  */
-GIT_EXTERN(int) git_reference_symbolic_create_with_log(
-	git_reference **out,
-	git_repository *repo,
-	const char *name,
-	const char *target,
-	int force,
-	const git_signature *signature,
-	const char *log_message);
+GIT_EXTERN(int) git_reference_symbolic_create(git_reference **out, git_repository *repo, const char *name, const char *target, int force, const git_signature *signature, const char *log_message);
 
 /**
  * Create a new direct reference.
@@ -163,57 +127,21 @@ GIT_EXTERN(int) git_reference_symbolic_create_with_log(
  * This function will return an error if a reference already exists with the
  * given name unless `force` is true, in which case it will be overwritten.
  *
- * @param out Pointer to the newly created reference
- * @param repo Repository where that reference will live
- * @param name The name of the reference
- * @param id The object id pointed to by the reference.
- * @param force Overwrite existing references
- * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
- */
-GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force);
-
-/**
- * Create a new direct reference and update the reflog with a given
- * message.
- *
- * A direct reference (also called an object id reference) refers directly
- * to a specific object id (a.k.a. OID or SHA) in the repository.  The id
- * permanently refers to the object (although the reference itself can be
- * moved).  For example, in libgit2 the direct ref "refs/tags/v0.17.0"
- * refers to OID 5b9fac39d8a76b9139667c26a63e6b3f204b3977.
- *
- * The direct reference will be created in the repository and written to
- * the disk.  The generated reference object must be freed by the user.
- *
- * Valid reference names must follow one of two patterns:
- *
- * 1. Top-level names must contain only capital letters and underscores,
- *    and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
- * 2. Names prefixed with "refs/" can be almost anything.  You must avoid
- *    the characters '~', '^', ':', '\\', '?', '[', and '*', and the
- *    sequences ".." and "@{" which have special meaning to revparse.
- *
- * This function will return an error if a reference already exists with the
- * given name unless `force` is true, in which case it will be overwritten.
+ * The signature and message for the reflog will be ignored if the
+ * reference does not belong in the standard set (HEAD, branches and
+ * remote-tracking branches) and and it does not have a reflog.
  *
  * @param out Pointer to the newly created reference
  * @param repo Repository where that reference will live
  * @param name The name of the reference
  * @param id The object id pointed to by the reference.
  * @param force Overwrite existing references
+ * @param force Overwrite existing references
  * @param signature The identity that will used to populate the reflog entry
- * @param log_message The one line long message that has to be appended
- * to the reflog
- * @return 0 on success, EEXISTS, EINVALIDSPEC or an error code
+ * @param log_message The one line long message to be appended to the reflog
+ * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
  */
-GIT_EXTERN(int) git_reference_create_with_log(
-	git_reference **out,
-	git_repository *repo,
-	const char *name,
-	const git_oid *id,
-	int force,
-	const git_signature *signature,
-	const char *log_message);
+GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message);
 
 /**
  * Get the OID pointed to by a direct reference.
@@ -307,35 +235,18 @@ GIT_EXTERN(git_repository *) git_reference_owner(const git_reference *ref);
  * The target name will be checked for validity.
  * See `git_reference_create_symbolic()` for rules about valid names.
  *
- * @param out Pointer to the newly created reference
- * @param ref The reference
- * @param target The new target for the reference
- * @return 0 on success, GIT_EINVALIDSPEC or an error code
- */
-GIT_EXTERN(int) git_reference_symbolic_set_target(
-	git_reference **out,
-	git_reference *ref,
-	const char *target);
-
-/**
- * Create a new reference with the same name as the given reference but a
- * different symbolic target  and update the reflog with a given message.
- *
- * The reference must be a symbolic reference, otherwise this will fail.
- *
- * The new reference will be written to disk, overwriting the given reference.
- *
- * The target name will be checked for validity.
- * See `git_reference_create_symbolic()` for rules about valid names.
+ * The signature and message for the reflog will be ignored if the
+ * reference does not belong in the standard set (HEAD, branches and
+ * remote-tracking branches) and and it does not have a reflog.
  *
  * @param out Pointer to the newly created reference
  * @param ref The reference
  * @param target The new target for the reference
  * @param signature The identity that will used to populate the reflog entry
- * @param log_message The one line long message that has to be appended
- * @return 0 on success, EINVALIDSPEC or an error code
+ * @param log_message The one line long message to be appended to the reflog
+ * @return 0 on success, GIT_EINVALIDSPEC or an error code
  */
-GIT_EXTERN(int) git_reference_symbolic_set_target_with_log(
+GIT_EXTERN(int) git_reference_symbolic_set_target(
 	git_reference **out,
 	git_reference *ref,
 	const char *target,
@@ -349,33 +260,18 @@ GIT_EXTERN(int) git_reference_symbolic_set_target_with_log(
  *
  * The new reference will be written to disk, overwriting the given reference.
  *
- * @param out Pointer to the newly created reference
- * @param ref The reference
- * @param id The new target OID for the reference
- * @return 0 or an error code
- */
-GIT_EXTERN(int) git_reference_set_target(
-	git_reference **out,
-	git_reference *ref,
-	const git_oid *id);
-
-/**
- * Create a new reference with the same name as the given reference but a
- * different OID target and update the reflog with a given message.
- *
- * The reference must be a direct reference, otherwise this will fail.
- *
- * The new reference will be written to disk, overwriting the given reference.
+ * The signature and message for the reflog will be ignored if the
+ * reference does not belong in the standard set (HEAD, branches and
+ * remote-tracking branches) and and it does not have a reflog.
  *
  * @param out Pointer to the newly created reference
  * @param ref The reference
  * @param id The new target OID for the reference
  * @param signature The identity that will used to populate the reflog entry
- * @param log_message The one line long message that has to be appended
- * to the reflog
+ * @param log_message The one line long message to be appended to the reflog
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_reference_set_target_with_log(
+GIT_EXTERN(int) git_reference_set_target(
 	git_reference **out,
 	git_reference *ref,
 	const git_oid *id,
diff --git a/src/branch.c b/src/branch.c
index 9ed0addb5..3b9aa0d20 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -72,7 +72,7 @@ int git_branch_create(
 		goto cleanup;
 
 	error = git_reference_create(&branch, repository,
-		git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force);
+		git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force, NULL, NULL);
 
 	if (!error)
 		*ref_out = branch;
diff --git a/src/commit.c b/src/commit.c
index 4ddfafb41..f0e304a84 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -112,7 +112,7 @@ int git_commit_create_from_oids(
 	git_buf_free(&commit);
 
 	if (update_ref != NULL)
-		return git_reference__update_terminal(repo, update_ref, oid);
+		return git_reference__update_terminal(repo, update_ref, oid, NULL, NULL);
 
 	return 0;
 
diff --git a/src/push.c b/src/push.c
index dd77864a5..0be82f3b2 100644
--- a/src/push.c
+++ b/src/push.c
@@ -241,7 +241,7 @@ int git_push_update_tips(git_push *push)
 				giterr_clear();
 			else
 				goto on_error;
-		} else if ((error = git_reference_create(NULL, push->remote->repo, git_buf_cstr(&remote_ref_name), &push_spec->loid, 1)) < 0)
+		} else if ((error = git_reference_create(NULL, push->remote->repo, git_buf_cstr(&remote_ref_name), &push_spec->loid, 1, NULL, NULL)) < 0)
 			goto on_error;
 	}
 
diff --git a/src/refs.c b/src/refs.c
index ce172aa27..0f0a380ea 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -393,32 +393,20 @@ static int reference__create(
 	return 0;
 }
 
-int git_reference_create(
-	git_reference **ref_out,
-	git_repository *repo,
-	const char *name,
-	const git_oid *oid,
-	int force)
+static int log_signature(git_signature **out, git_repository *repo)
 {
-	git_signature *who;
 	int error;
+	git_signature *who;
 
-	assert(oid);
-
-	/* Should we return an error if there is no default? */
-	if (((error = git_signature_default(&who, repo)) < 0) &&
-	    ((error = git_signature_now(&who, "unknown", "unknown")) < 0)) {
+	if(((error = git_signature_default(&who, repo)) < 0) &&
+	   ((error = git_signature_now(&who, "unknown", "unknown")) < 0))
 		return error;
-	}
 
-	error = reference__create(ref_out, repo, name, oid, NULL, force, who, NULL);
-
-	git_signature_free(who);
-
-	return error;
+	*out = who;
+	return 0;
 }
 
-int git_reference_create_with_log(
+int git_reference_create(
 	git_reference **ref_out,
 	git_repository *repo,
 	const char *name,
@@ -427,24 +415,26 @@ int git_reference_create_with_log(
 	const git_signature *signature,
 	const char *log_message)
 {
-	assert(oid && signature);
+	int error;
+	git_signature *who = NULL;
+	
+	assert(oid);
 
-	return reference__create(
+	if (!signature) {
+		if ((error = log_signature(&who, repo)) < 0)
+			return error;
+		else
+			signature = who;
+	}
+
+	error = reference__create(
 		ref_out, repo, name, oid, NULL, force, signature, log_message);
-}
 
-int git_reference_symbolic_create(
-	git_reference **ref_out,
-	git_repository *repo,
-	const char *name,
-	const char *target,
-	int force)
-{
-	assert(target);
-	return reference__create(ref_out, repo, name, NULL, target, force, NULL, NULL);
+	git_signature_free(who);
+	return error;
 }
 
-int git_reference_symbolic_create_with_log(
+int git_reference_symbolic_create(
 	git_reference **ref_out,
 	git_repository *repo,
 	const char *name,
@@ -453,10 +443,23 @@ int git_reference_symbolic_create_with_log(
 	const git_signature *signature,
 	const char *log_message)
 {
-	assert(target && signature);
+	int error;
+	git_signature *who = NULL;
+
+	assert(target);
+
+	if (!signature) {
+		if ((error = log_signature(&who, repo)) < 0)
+			return error;
+		else
+			signature = who;
+	}
 
-	return reference__create(
+	error = reference__create(
 		ref_out, repo, name, NULL, target, force, signature, log_message);
+
+	git_signature_free(who);
+	return error;
 }
 
 static int ensure_is_an_updatable_direct_reference(git_reference *ref)
@@ -469,21 +472,6 @@ static int ensure_is_an_updatable_direct_reference(git_reference *ref)
 }
 
 int git_reference_set_target(
-	git_reference **out,
-	git_reference *ref,
-	const git_oid *id)
-{
-	int error;
-
-	assert(out && ref && id);
-
-	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
-		return error;
-
-	return git_reference_create(out, ref->db->repo, ref->name, id, 1);
-}
-
-int git_reference_set_target_with_log(
 	git_reference **out,
 	git_reference *ref,
 	const git_oid *id,
@@ -493,12 +481,11 @@ int git_reference_set_target_with_log(
 	int error;
 
 	assert(out && ref && id);
-	assert(signature && log_message);
 
 	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
 		return error;
 
-	return git_reference_create_with_log(
+	return git_reference_create(
 		out, ref->db->repo, ref->name, id, 1, signature, log_message);
 }
 
@@ -514,7 +501,9 @@ static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
 int git_reference_symbolic_set_target(
 	git_reference **out,
 	git_reference *ref,
-	const char *target)
+	const char *target,
+	const git_signature *signature,
+	const char *log_message)
 {
 	int error;
 
@@ -523,7 +512,8 @@ int git_reference_symbolic_set_target(
 	if ((error = ensure_is_an_updatable_symbolic_reference(ref)) < 0)
 		return error;
 
-	return git_reference_symbolic_create(out, ref->db->repo, ref->name, target, 1);
+	return git_reference_symbolic_create(
+		out, ref->db->repo, ref->name, target, 1, signature, log_message);
 }
 
 static int reference__rename(git_reference **out, git_reference *ref, const char *new_name, int force,
@@ -1020,7 +1010,9 @@ static int reference__update_terminal(
 	git_repository *repo,
 	const char *ref_name,
 	const git_oid *oid,
-	int nesting)
+	int nesting,
+	const git_signature *signature,
+	const char *log_message)
 {
 	git_reference *ref;
 	int error = 0;
@@ -1035,7 +1027,7 @@ static int reference__update_terminal(
 	/* If we haven't found the reference at all, create a new reference. */
 	if (error == GIT_ENOTFOUND) {
 		giterr_clear();
-		return git_reference_create(NULL, repo, ref_name, oid, 0);
+		return git_reference_create(NULL, repo, ref_name, oid, 0, signature, log_message);
 	}
 
 	if (error < 0)
@@ -1044,11 +1036,11 @@ static int reference__update_terminal(
 	/* If the ref is a symbolic reference, follow its target. */
 	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
 		error = reference__update_terminal(repo, git_reference_symbolic_target(ref), oid,
-			nesting+1);
+			nesting+1, signature, log_message);
 		git_reference_free(ref);
 	} else {
 		git_reference_free(ref);
-		error = git_reference_create(NULL, repo, ref_name, oid, 1);
+		error = git_reference_create(NULL, repo, ref_name, oid, 1, signature, log_message);
 	}
 
 	return error;
@@ -1062,9 +1054,11 @@ static int reference__update_terminal(
 int git_reference__update_terminal(
 	git_repository *repo,
 	const char *ref_name,
-	const git_oid *oid)
+	const git_oid *oid,
+	const git_signature *signature,
+	const char *log_message)
 {
-	return reference__update_terminal(repo, ref_name, oid, 0);
+	return reference__update_terminal(repo, ref_name, oid, 0, signature, log_message);
 }
 
 int git_reference_has_log(git_repository *repo, const char *refname)
diff --git a/src/refs.h b/src/refs.h
index 4d5b6dacb..d57d67026 100644
--- a/src/refs.h
+++ b/src/refs.h
@@ -68,7 +68,7 @@ git_reference *git_reference__set_name(git_reference *ref, const char *name);
 
 int git_reference__normalize_name_lax(char *buffer_out, size_t out_size, const char *name);
 int git_reference__normalize_name(git_buf *buf, const char *name, unsigned int flags);
-int git_reference__update_terminal(git_repository *repo, const char *ref_name, const git_oid *oid);
+int git_reference__update_terminal(git_repository *repo, const char *ref_name, const git_oid *oid, const git_signature *signature, const char *log_message);
 int git_reference__is_valid_name(const char *refname, unsigned int flags);
 int git_reference__is_branch(const char *ref_name);
 int git_reference__is_remote(const char *ref_name);
diff --git a/src/remote.c b/src/remote.c
index 622abbc8c..306cb0b9a 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1027,7 +1027,7 @@ static int update_tips_for_spec(git_remote *remote, git_refspec *spec, git_vecto
 			continue;
 
 		/* In autotag mode, don't overwrite any locally-existing tags */
-		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag);
+		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag, NULL, NULL);
 		if (error < 0 && error != GIT_EEXISTS)
 			goto on_error;
 
diff --git a/src/repository.c b/src/repository.c
index 94f6603aa..c584d30c8 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1863,11 +1863,11 @@ int git_repository_set_head(
 
 	if (!error) {
 		if (git_reference_is_branch(ref))
-			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, git_reference_name(ref), 1);
+			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, git_reference_name(ref), 1, NULL, NULL);
 		else
 			error = git_repository_set_head_detached(repo, git_reference_target(ref));
 	} else if (looks_like_a_branch(refname))
-		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname, 1);
+		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname, 1, NULL, NULL);
 
 	git_reference_free(ref);
 	git_reference_free(new_head);
@@ -1891,7 +1891,7 @@ int git_repository_set_head_detached(
 	if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
-	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), 1);
+	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), 1, NULL, NULL);
 
 cleanup:
 	git_object_free(object);
@@ -1916,7 +1916,7 @@ int git_repository_detach_head(
 	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
-	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head), 1);
+	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head), 1, NULL, NULL);
 
 cleanup:
 	git_object_free(object);
diff --git a/src/reset.c b/src/reset.c
index 261a36576..32e101357 100644
--- a/src/reset.c
+++ b/src/reset.c
@@ -131,7 +131,7 @@ int git_reset(
 
 	/* move HEAD to the new target */
 	if ((error = git_reference__update_terminal(repo, GIT_HEAD_FILE,
-		git_object_id(commit))) < 0)
+		git_object_id(commit), NULL, NULL)) < 0)
 		goto cleanup;
 
 	if (reset_type == GIT_RESET_HARD) {
diff --git a/src/stash.c b/src/stash.c
index 3019816ff..b1dd87b22 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -417,7 +417,7 @@ static int update_reflog(
 	if ((error = git_reference_ensure_log(repo, GIT_REFS_STASH_FILE)) < 0)
 		return error;
 
-	error = git_reference_create_with_log(&stash, repo, GIT_REFS_STASH_FILE, w_commit_oid, 1, stasher, message);
+	error = git_reference_create(&stash, repo, GIT_REFS_STASH_FILE, w_commit_oid, 1, stasher, message);
 
 	git_reference_free(stash);
 
@@ -628,7 +628,7 @@ int git_stash_drop(
 		entry = git_reflog_entry_byindex(reflog, 0);
 
 		git_reference_free(stash);
-		if ((error = git_reference_create(&stash, repo, GIT_REFS_STASH_FILE, &entry->oid_cur, 1) < 0))
+		if ((error = git_reference_create(&stash, repo, GIT_REFS_STASH_FILE, &entry->oid_cur, 1, NULL, NULL) < 0))
 			goto cleanup;
 
 		/* We need to undo the writing that we just did */
diff --git a/src/tag.c b/src/tag.c
index be56b05ce..1a4ee1e1c 100644
--- a/src/tag.c
+++ b/src/tag.c
@@ -271,7 +271,7 @@ static int git_tag_create__internal(
 	} else
 		git_oid_cpy(oid, git_object_id(target));
 
-	error = git_reference_create(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite);
+	error = git_reference_create(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite, NULL, NULL);
 
 cleanup:
 	git_reference_free(new_ref);
@@ -376,7 +376,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 		return -1;
 	}
 
-	error = git_reference_create(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite);
+	error = git_reference_create(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite, NULL, NULL);
 
 	git_reference_free(new_ref);
 	git_buf_free(&ref_name);
diff --git a/src/transports/local.c b/src/transports/local.c
index 4635d5dd3..253aca30a 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -315,7 +315,7 @@ static int local_push_update_remote_ref(
 	if (lref) {
 		/* Create or update a ref */
 		if ((error = git_reference_create(NULL, remote_repo, rref, loid,
-				!git_oid_iszero(roid))) < 0)
+				!git_oid_iszero(roid), NULL, NULL)) < 0)
 			return error;
 	} else {
 		/* Delete a ref */
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index 06aa6a594..f0699fdb7 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -484,7 +484,7 @@ void assert_conflict(
 
 	/* Make HEAD point to this branch */
 	cl_git_pass(git_reference_symbolic_create(
-		&head, g_repo, "HEAD", git_reference_name(branch), 1));
+		&head, g_repo, "HEAD", git_reference_name(branch), 1, NULL, NULL));
 	git_reference_free(head);
 	git_reference_free(branch);
 
diff --git a/tests/commit/write.c b/tests/commit/write.c
index 73436b74b..8e5b67f2f 100644
--- a/tests/commit/write.c
+++ b/tests/commit/write.c
@@ -116,7 +116,7 @@ void test_commit_write__root(void)
 	cl_assert(head_old != NULL);
 	git_reference_free(head);
 
-	cl_git_pass(git_reference_symbolic_create(&head, g_repo, "HEAD", branch_name, 1));
+	cl_git_pass(git_reference_symbolic_create(&head, g_repo, "HEAD", branch_name, 1, NULL, NULL));
 
 	cl_git_pass(git_commit_create_v(
 		&commit_id, /* out id */
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index 93e69f479..4d1f7646e 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -945,7 +945,7 @@ void test_diff_rename__rejected_match_can_match_others(void)
 
 	cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
 	cl_git_pass(git_reference_symbolic_set_target(
-		&selfsimilar, head, "refs/heads/renames_similar"));
+		&selfsimilar, head, "refs/heads/renames_similar", NULL, NULL));
 	cl_git_pass(git_checkout_head(g_repo, &opts));
 	cl_git_pass(git_repository_index(&index, g_repo));
 
@@ -1030,7 +1030,7 @@ void test_diff_rename__rejected_match_can_match_others_two(void)
 
 	cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
 	cl_git_pass(git_reference_symbolic_set_target(
-		&selfsimilar, head, "refs/heads/renames_similar_two"));
+		&selfsimilar, head, "refs/heads/renames_similar_two", NULL, NULL));
 	cl_git_pass(git_checkout_head(g_repo, &opts));
 	cl_git_pass(git_repository_index(&index, g_repo));
 
@@ -1088,7 +1088,7 @@ void test_diff_rename__rejected_match_can_match_others_three(void)
 
 	cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
 	cl_git_pass(git_reference_symbolic_set_target(
-		&selfsimilar, head, "refs/heads/renames_similar_two"));
+		&selfsimilar, head, "refs/heads/renames_similar_two", NULL, NULL));
 	cl_git_pass(git_checkout_head(g_repo, &opts));
 	cl_git_pass(git_repository_index(&index, g_repo));
 
diff --git a/tests/merge/merge_helpers.c b/tests/merge/merge_helpers.c
index 5660179a7..7ce5e28ff 100644
--- a/tests/merge/merge_helpers.c
+++ b/tests/merge/merge_helpers.c
@@ -87,7 +87,7 @@ int merge_branches(git_merge_result **result, git_repository *repo, const char *
 
 	head_checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
-	cl_git_pass(git_reference_symbolic_create(&head_ref, repo, "HEAD", ours_branch, 1));
+	cl_git_pass(git_reference_symbolic_create(&head_ref, repo, "HEAD", ours_branch, 1, NULL, NULL));
 	cl_git_pass(git_checkout_head(repo, &head_checkout_opts));
 
 	cl_git_pass(git_reference_lookup(&theirs_ref, repo, theirs_branch));
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 4a3b86ee4..98dca53ef 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -406,7 +406,7 @@ void test_merge_workdir_simple__directory_file(void)
 		{ 0100644, "f5504f36e6f4eb797a56fc5bac6c6c7f32969bf2", 3, "file-5/new" },
 	};
 
-	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, GIT_REFS_HEADS_DIR OURS_DIRECTORY_FILE, 1));
+	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, GIT_REFS_HEADS_DIR OURS_DIRECTORY_FILE, 1, NULL, NULL));
 	cl_git_pass(git_reference_name_to_id(&head_commit_id, repo, GIT_HEAD_FILE));
 	cl_git_pass(git_commit_lookup(&head_commit, repo, &head_commit_id));
 	cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD));
diff --git a/tests/merge/workdir/trivial.c b/tests/merge/workdir/trivial.c
index 9f9566243..df18b0e0b 100644
--- a/tests/merge/workdir/trivial.c
+++ b/tests/merge/workdir/trivial.c
@@ -42,7 +42,7 @@ static int merge_trivial(const char *ours, const char *theirs, bool automerge)
 	opts.merge_tree_opts.automerge_flags |= automerge ? 0 : GIT_MERGE_AUTOMERGE_NONE;
 
 	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, ours);
-	cl_git_pass(git_reference_symbolic_create(&our_ref, repo, "HEAD", branch_buf.ptr, 1));
+	cl_git_pass(git_reference_symbolic_create(&our_ref, repo, "HEAD", branch_buf.ptr, 1, NULL, NULL));
 
 	cl_git_pass(git_checkout_head(repo, &checkout_opts));
 
diff --git a/tests/refs/branches/delete.c b/tests/refs/branches/delete.c
index de90cb734..a642f8704 100644
--- a/tests/refs/branches/delete.c
+++ b/tests/refs/branches/delete.c
@@ -14,7 +14,7 @@ void test_refs_branches_delete__initialize(void)
 	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
 
 	cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"));
-	cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0));
+	cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0, NULL, NULL));
 }
 
 void test_refs_branches_delete__cleanup(void)
diff --git a/tests/refs/branches/ishead.c b/tests/refs/branches/ishead.c
index b1ad09c3e..12a8c4449 100644
--- a/tests/refs/branches/ishead.c
+++ b/tests/refs/branches/ishead.c
@@ -98,9 +98,9 @@ void test_refs_branches_ishead__only_direct_references_are_considered(void)
 	git_repository_free(repo);
 	repo = cl_git_sandbox_init("testrepo.git");
 
-	cl_git_pass(git_reference_symbolic_create(&linked, repo, "refs/heads/linked", "refs/heads/master", 0));
-	cl_git_pass(git_reference_symbolic_create(&super, repo, "refs/heads/super", "refs/heads/linked", 0));
-	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, "refs/heads/super", 1));
+	cl_git_pass(git_reference_symbolic_create(&linked, repo, "refs/heads/linked", "refs/heads/master", 0, NULL, NULL));
+	cl_git_pass(git_reference_symbolic_create(&super, repo, "refs/heads/super", "refs/heads/linked", 0, NULL, NULL));
+	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, "refs/heads/super", 1, NULL, NULL));
 
 	cl_assert_equal_i(false, git_branch_is_head(linked));
 	cl_assert_equal_i(false, git_branch_is_head(super));
diff --git a/tests/refs/branches/iterator.c b/tests/refs/branches/iterator.c
index 904c6a146..29ca59aca 100644
--- a/tests/refs/branches/iterator.c
+++ b/tests/refs/branches/iterator.c
@@ -12,7 +12,7 @@ void test_refs_branches_iterator__initialize(void)
 	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
 
 	cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"));
-	cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0));
+	cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0, NULL, NULL));
 }
 
 void test_refs_branches_iterator__cleanup(void)
@@ -113,7 +113,7 @@ void test_refs_branches_iterator__retrieve_remote_symbolic_HEAD_when_present(voi
 	};
 
 	git_reference_free(fake_remote);
-	cl_git_pass(git_reference_symbolic_create(&fake_remote, repo, "refs/remotes/nulltoken/HEAD", "refs/remotes/nulltoken/master", 0));
+	cl_git_pass(git_reference_symbolic_create(&fake_remote, repo, "refs/remotes/nulltoken/HEAD", "refs/remotes/nulltoken/master", 0, NULL, NULL));
 
 	assert_retrieval(GIT_BRANCH_REMOTE, 3);
 
diff --git a/tests/refs/crashes.c b/tests/refs/crashes.c
index 5a1885a7a..03082d71e 100644
--- a/tests/refs/crashes.c
+++ b/tests/refs/crashes.c
@@ -7,7 +7,7 @@ void test_refs_crashes__double_free(void)
 	const char *REFNAME = "refs/heads/xxx";
 
 	cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
-	cl_git_pass(git_reference_symbolic_create(&ref, repo, REFNAME, "refs/heads/master", 0));
+	cl_git_pass(git_reference_symbolic_create(&ref, repo, REFNAME, "refs/heads/master", 0, NULL, NULL));
 	cl_git_pass(git_reference_lookup(&ref2, repo, REFNAME));
 	cl_git_pass(git_reference_delete(ref));
 	git_reference_free(ref);
diff --git a/tests/refs/create.c b/tests/refs/create.c
index 85ff05aa9..50b8e84f8 100644
--- a/tests/refs/create.c
+++ b/tests/refs/create.c
@@ -32,7 +32,7 @@ void test_refs_create__symbolic(void)
 	git_oid_fromstr(&id, current_master_tip);
 
 	/* Create and write the new symbolic reference */
-	cl_git_pass(git_reference_symbolic_create(&new_reference, g_repo, new_head_tracker, current_head_target, 0));
+	cl_git_pass(git_reference_symbolic_create(&new_reference, g_repo, new_head_tracker, current_head_target, 0, NULL, NULL));
 
 	/* Ensure the reference can be looked-up... */
 	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head_tracker));
@@ -73,7 +73,7 @@ void test_refs_create__deep_symbolic(void)
 
 	git_oid_fromstr(&id, current_master_tip);
 
-	cl_git_pass(git_reference_symbolic_create(&new_reference, g_repo, new_head_tracker, current_head_target, 0));
+	cl_git_pass(git_reference_symbolic_create(&new_reference, g_repo, new_head_tracker, current_head_target, 0, NULL, NULL));
 	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head_tracker));
 	cl_git_pass(git_reference_resolve(&resolved_ref, looked_up_ref));
 	cl_assert(git_oid_cmp(&id, git_reference_target(resolved_ref)) == 0);
@@ -95,7 +95,7 @@ void test_refs_create__oid(void)
 	git_oid_fromstr(&id, current_master_tip);
 
 	/* Create and write the new object id reference */
-	cl_git_pass(git_reference_create(&new_reference, g_repo, new_head, &id, 0));
+	cl_git_pass(git_reference_create(&new_reference, g_repo, new_head, &id, 0, NULL, NULL));
 
 	/* Ensure the reference can be looked-up... */
 	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, new_head));
@@ -130,7 +130,7 @@ void test_refs_create__oid_unknown(void)
 	git_oid_fromstr(&id, "deadbeef3f795b2b4353bcce3a527ad0a4f7f644");
 
 	/* Create and write the new object id reference */
-	cl_git_fail(git_reference_create(&new_reference, g_repo, new_head, &id, 0));
+	cl_git_fail(git_reference_create(&new_reference, g_repo, new_head, &id, 0, NULL, NULL));
 
 	/* Ensure the reference can't be looked-up... */
 	cl_git_fail(git_reference_lookup(&looked_up_ref, g_repo, new_head));
@@ -144,10 +144,10 @@ void test_refs_create__propagate_eexists(void)
 
 	/* Make sure it works for oid and for symbolic both */
 	git_oid_fromstr(&oid, current_master_tip);
-	error = git_reference_create(&ref, g_repo, current_head_target, &oid, false);
+	error = git_reference_create(&ref, g_repo, current_head_target, &oid, false, NULL, NULL);
 	cl_assert(error == GIT_EEXISTS);
 
-	error = git_reference_symbolic_create(&ref, g_repo, "HEAD", current_head_target, false);
+	error = git_reference_symbolic_create(&ref, g_repo, "HEAD", current_head_target, false, NULL, NULL);
 	cl_assert(error == GIT_EEXISTS);
 }
 
@@ -161,8 +161,8 @@ void test_refs_create__creating_a_reference_with_an_invalid_name_returns_EINVALI
 	git_oid_fromstr(&id, current_master_tip);
 
 	cl_assert_equal_i(GIT_EINVALIDSPEC, git_reference_create(
-		&new_reference, g_repo, name, &id, 0));
+		&new_reference, g_repo, name, &id, 0, NULL, NULL));
 
 	cl_assert_equal_i(GIT_EINVALIDSPEC, git_reference_symbolic_create(
-		&new_reference, g_repo, name, current_head_target, 0));
+		&new_reference, g_repo, name, current_head_target, 0, NULL, NULL));
 }
diff --git a/tests/refs/createwithlog.c b/tests/refs/createwithlog.c
index 0fe81df91..026ff6d6a 100644
--- a/tests/refs/createwithlog.c
+++ b/tests/refs/createwithlog.c
@@ -35,7 +35,7 @@ void test_refs_createwithlog__creating_a_direct_reference_adds_a_reflog_entry(vo
 	cl_git_pass(git_signature_now(&signature, "foo", "foo@bar"));
 
 	cl_git_pass(
-		git_reference_create_with_log(&reference, g_repo, name, &id, 0, signature, message));
+		git_reference_create(&reference, g_repo, name, &id, 0, signature, message));
 
 	cl_git_pass(git_reflog_read(&reflog, g_repo, name));
 	cl_assert_equal_sz(1, git_reflog_entrycount(reflog));
diff --git a/tests/refs/delete.c b/tests/refs/delete.c
index 973768aeb..5e4afb138 100644
--- a/tests/refs/delete.c
+++ b/tests/refs/delete.c
@@ -66,7 +66,7 @@ void test_refs_delete__packed_only(void)
 	git_oid_fromstr(&id, current_master_tip);
 
 	/* Create and write the new object id reference */
-	cl_git_pass(git_reference_create(&ref, g_repo, new_ref, &id, 0));
+	cl_git_pass(git_reference_create(&ref, g_repo, new_ref, &id, 0, NULL, NULL));
 	git_reference_free(ref);
 
 	/* Lookup the reference */
diff --git a/tests/refs/foreachglob.c b/tests/refs/foreachglob.c
index c0f6ce763..b992b07b8 100644
--- a/tests/refs/foreachglob.c
+++ b/tests/refs/foreachglob.c
@@ -12,7 +12,7 @@ void test_refs_foreachglob__initialize(void)
 	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
 
 	cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"));
-	cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0));
+	cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0, NULL, NULL));
 }
 
 void test_refs_foreachglob__cleanup(void)
diff --git a/tests/refs/overwrite.c b/tests/refs/overwrite.c
index ebe72069c..78ce4ace7 100644
--- a/tests/refs/overwrite.c
+++ b/tests/refs/overwrite.c
@@ -27,8 +27,8 @@ void test_refs_overwrite__symbolic(void)
 	git_reference *ref, *branch_ref;
 
 	/* The target needds to exist and we need to check the name has changed */
-	cl_git_pass(git_reference_symbolic_create(&branch_ref, g_repo, ref_branch_name, ref_master_name, 0));
-	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_branch_name, 0));
+	cl_git_pass(git_reference_symbolic_create(&branch_ref, g_repo, ref_branch_name, ref_master_name, 0, NULL, NULL));
+	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_branch_name, 0, NULL, NULL));
 	git_reference_free(ref);
 
 	/* Ensure it points to the right place*/
@@ -38,8 +38,8 @@ void test_refs_overwrite__symbolic(void)
 	git_reference_free(ref);
 
 	/* Ensure we can't create it unless we force it to */
-	cl_git_fail(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0));
-	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 1));
+	cl_git_fail(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0, NULL, NULL));
+	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 1, NULL, NULL));
 	git_reference_free(ref);
 
 	/* Ensure it points to the right place */
@@ -63,7 +63,7 @@ void test_refs_overwrite__object_id(void)
 	git_reference_free(ref);
 
 	/* Create it */
-	cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 0));
+	cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 0, NULL, NULL));
 	git_reference_free(ref);
 
 	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_test_name));
@@ -72,8 +72,8 @@ void test_refs_overwrite__object_id(void)
 	git_reference_free(ref);
 
 	/* Ensure we can't overwrite unless we force it */
-	cl_git_fail(git_reference_create(&ref, g_repo, ref_name, &id, 0));
-	cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 1));
+	cl_git_fail(git_reference_create(&ref, g_repo, ref_name, &id, 0, NULL, NULL));
+	cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 1, NULL, NULL));
 	git_reference_free(ref);
 
 	/* Ensure it has been overwritten */
@@ -94,10 +94,10 @@ void test_refs_overwrite__object_id_with_symbolic(void)
 	git_oid_cpy(&id, git_reference_target(ref));
 	git_reference_free(ref);
 
-	cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 0));
+	cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 0, NULL, NULL));
 	git_reference_free(ref);
-	cl_git_fail(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0));
-	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 1));
+	cl_git_fail(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0, NULL, NULL));
+	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 1, NULL, NULL));
 	git_reference_free(ref);
 
 	/* Ensure it points to the right place */
@@ -120,11 +120,11 @@ void test_refs_overwrite__symbolic_with_object_id(void)
 	git_reference_free(ref);
 
 	/* Create the symbolic ref */
-	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0));
+	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0, NULL, NULL));
 	git_reference_free(ref);
 	/* It shouldn't overwrite unless we tell it to */
-	cl_git_fail(git_reference_create(&ref, g_repo, ref_name, &id, 0));
-	cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 1));
+	cl_git_fail(git_reference_create(&ref, g_repo, ref_name, &id, 0, NULL, NULL));
+	cl_git_pass(git_reference_create(&ref, g_repo, ref_name, &id, 1, NULL, NULL));
 	git_reference_free(ref);
 
 	/* Ensure it points to the right place */
diff --git a/tests/refs/pack.c b/tests/refs/pack.c
index 849a052aa..7f5c611a7 100644
--- a/tests/refs/pack.c
+++ b/tests/refs/pack.c
@@ -93,11 +93,11 @@ void test_refs_pack__symbolic(void)
 	for (i = 0; i < 100; ++i) {
 		snprintf(name, sizeof(name), "refs/heads/symbolic-%03d", i);
 		cl_git_pass(git_reference_symbolic_create(
-			&ref, g_repo, name, "refs/heads/master", 0));
+			&ref, g_repo, name, "refs/heads/master", 0, NULL, NULL));
 		git_reference_free(ref);
 
 		snprintf(name, sizeof(name), "refs/heads/direct-%03d", i);
-		cl_git_pass(git_reference_create(&ref, g_repo, name, &head, 0));
+		cl_git_pass(git_reference_create(&ref, g_repo, name, &head, 0, NULL, NULL));
 		git_reference_free(ref);
 	}
 
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index a1c5adaf4..82b28de15 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -82,7 +82,7 @@ void test_refs_reflog_reflog__append_then_read(void)
 
 	/* Create a new branch pointing at the HEAD */
 	git_oid_fromstr(&oid, current_master_tip);
-	cl_git_pass(git_reference_create(&ref, g_repo, new_ref, &oid, 0));
+	cl_git_pass(git_reference_create(&ref, g_repo, new_ref, &oid, 0, NULL, NULL));
 	git_reference_free(ref);
 
 	cl_git_pass(git_signature_now(&committer, "foo", "foo@bar"));
@@ -189,11 +189,11 @@ void test_refs_reflog_reflog__write_only_std_locations(void)
 
 	git_oid_fromstr(&id, current_master_tip);
 
-	cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/foo", &id, 1));
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/foo", &id, 1, NULL, NULL));
 	git_reference_free(ref);
-	cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1));
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1, NULL, NULL));
 	git_reference_free(ref);
-	cl_git_pass(git_reference_create(&ref, g_repo, "refs/notes/foo", &id, 1));
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/notes/foo", &id, 1, NULL, NULL));
 	git_reference_free(ref);
 
 	assert_has_reflog(true, "refs/heads/foo");
@@ -210,7 +210,7 @@ void test_refs_reflog_reflog__write_when_explicitly_active(void)
 	git_oid_fromstr(&id, current_master_tip);
 	git_reference_ensure_log(g_repo, "refs/tags/foo");
 
-	cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1));
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/tags/foo", &id, 1, NULL, NULL));
 	git_reference_free(ref);
 	assert_has_reflog(true, "refs/tags/foo");
 }
diff --git a/tests/refs/rename.c b/tests/refs/rename.c
index 543bc4d62..120967892 100644
--- a/tests/refs/rename.c
+++ b/tests/refs/rename.c
@@ -268,15 +268,15 @@ void test_refs_rename__overwrite(void)
 	git_oid_cpy(&id, git_reference_target(ref));
 
 	/* Create loose references */
-	cl_git_pass(git_reference_create(&ref_one, g_repo, ref_one_name, &id, 0));
-	cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name, &id, 0));
+	cl_git_pass(git_reference_create(&ref_one, g_repo, ref_one_name, &id, 0, NULL, NULL));
+	cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name, &id, 0, NULL, NULL));
 
 	/* Pack everything */
 	cl_git_pass(git_repository_refdb(&refdb, g_repo));
 	cl_git_pass(git_refdb_compress(refdb));
 
 	/* Attempt to create illegal reference */
-	cl_git_fail(git_reference_create(&ref_one_new, g_repo, ref_one_name_new, &id, 0));
+	cl_git_fail(git_reference_create(&ref_one_new, g_repo, ref_one_name_new, &id, 0, NULL, NULL));
 
 	/* Illegal reference couldn't be created so this is supposed to fail */
 	cl_git_fail(git_reference_lookup(&ref_one_new, g_repo, ref_one_name_new));
@@ -301,7 +301,7 @@ void test_refs_rename__prefix(void)
 	git_oid_cpy(&id, git_reference_target(ref));
 
 	/* Create loose references */
-	cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name, &id, 0));
+	cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name, &id, 0, NULL, NULL));
 
 	/* An existing reference... */
 	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name));
@@ -334,7 +334,7 @@ void test_refs_rename__move_up(void)
 	git_oid_cpy(&id, git_reference_target(ref));
 
 	/* Create loose references */
-	cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name_new, &id, 0));
+	cl_git_pass(git_reference_create(&ref_two, g_repo, ref_two_name_new, &id, 0, NULL, NULL));
 	git_reference_free(ref_two);
 
 	/* An existing reference... */
diff --git a/tests/refs/revparse.c b/tests/refs/revparse.c
index 37d3981bb..522a44c82 100644
--- a/tests/refs/revparse.c
+++ b/tests/refs/revparse.c
@@ -596,7 +596,8 @@ void test_refs_revparse__issue_994(void)
 		repo,
 		"refs/remotes/origin/bim_with_3d@11296",
 		git_reference_target(head),
-		0));
+		0,
+		NULL, NULL));
 
 	cl_git_pass(git_revparse_single(&target, repo, "origin/bim_with_3d@11296"));
 	git_object_free(target);
diff --git a/tests/refs/settargetwithlog.c b/tests/refs/settargetwithlog.c
index cfa1c99d5..524ce771c 100644
--- a/tests/refs/settargetwithlog.c
+++ b/tests/refs/settargetwithlog.c
@@ -38,7 +38,7 @@ void test_refs_settargetwithlog__updating_a_direct_reference_adds_a_reflog_entry
 
 	cl_git_pass(git_signature_now(&signature, "foo", "foo@bar"));
 
-	cl_git_pass(git_reference_set_target_with_log(
+	cl_git_pass(git_reference_set_target(
 		&reference_out, reference, &target_id, signature, message));
 
 	cl_git_pass(git_reflog_read(&reflog, g_repo, br2_name));
diff --git a/tests/refs/setter.c b/tests/refs/setter.c
index 6d875f9b6..9a945db00 100644
--- a/tests/refs/setter.c
+++ b/tests/refs/setter.c
@@ -34,7 +34,7 @@ void test_refs_setter__update_direct(void)
 	cl_git_pass(git_reference_lookup(&test_ref, g_repo, ref_test_name));
 	cl_assert(git_reference_type(test_ref) == GIT_REF_OID);
 
-	cl_git_pass(git_reference_set_target(&new_ref, test_ref, &id));
+	cl_git_pass(git_reference_set_target(&new_ref, test_ref, &id, NULL, NULL));
 
 	git_reference_free(test_ref);
 	git_reference_free(new_ref);
@@ -53,7 +53,7 @@ void test_refs_setter__update_symbolic(void)
 	cl_assert(git_reference_type(head) == GIT_REF_SYMBOLIC);
 	cl_assert(strcmp(git_reference_symbolic_target(head), ref_master_name) == 0);
 
-	cl_git_pass(git_reference_symbolic_set_target(&new_head, head, ref_test_name));
+	cl_git_pass(git_reference_symbolic_set_target(&new_head, head, ref_test_name, NULL, NULL));
 	git_reference_free(new_head);
 	git_reference_free(head);
 
@@ -73,7 +73,7 @@ void test_refs_setter__cant_update_direct_with_symbolic(void)
 	cl_assert(git_reference_type(ref) == GIT_REF_OID);
 	git_oid_cpy(&id, git_reference_target(ref));
 
-	cl_git_fail(git_reference_symbolic_set_target(&new, ref, ref_name));
+	cl_git_fail(git_reference_symbolic_set_target(&new, ref, ref_name, NULL, NULL));
 
 	git_reference_free(ref);
 }
@@ -90,10 +90,10 @@ void test_refs_setter__cant_update_symbolic_with_direct(void)
 	git_reference_free(ref);
 
 	/* Create the symbolic ref */
-	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0));
+	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, ref_name, ref_master_name, 0, NULL, NULL));
 
 	/* Can't set an OID on a direct ref */
-	cl_git_fail(git_reference_set_target(&new, ref, &id));
+	cl_git_fail(git_reference_set_target(&new, ref, &id, NULL, NULL));
 
 	git_reference_free(ref);
 }
diff --git a/tests/refs/unicode.c b/tests/refs/unicode.c
index b56012869..471b0b8d3 100644
--- a/tests/refs/unicode.c
+++ b/tests/refs/unicode.c
@@ -24,7 +24,7 @@ void test_refs_unicode__create_and_lookup(void)
 	/* Create the reference */
 	cl_git_pass(git_reference_lookup(&ref0, repo, master));
 	cl_git_pass(git_reference_create(
-		&ref1, repo, REFNAME, git_reference_target(ref0), 0));
+		&ref1, repo, REFNAME, git_reference_target(ref0), 0, NULL, NULL));
 	cl_assert_equal_s(REFNAME, git_reference_name(ref1));
 	git_reference_free(ref0);
 
diff --git a/tests/refs/update.c b/tests/refs/update.c
index 205b526a2..873fc4ebe 100644
--- a/tests/refs/update.c
+++ b/tests/refs/update.c
@@ -22,5 +22,5 @@ void test_refs_update__updating_the_target_of_a_symref_with_an_invalid_name_retu
 	cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head));
 	git_reference_free(head);
 
-	cl_assert_equal_i(GIT_EINVALIDSPEC, git_reference_symbolic_create(&head, g_repo, GIT_HEAD_FILE, "refs/heads/inv@{id", 1));
+	cl_assert_equal_i(GIT_EINVALIDSPEC, git_reference_symbolic_create(&head, g_repo, GIT_HEAD_FILE, "refs/heads/inv@{id", 1, NULL, NULL));
 }
diff --git a/tests/repo/head.c b/tests/repo/head.c
index 5a55984bd..101e30f10 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -26,7 +26,7 @@ void test_repo_head__head_detached(void)
 	cl_assert_equal_i(true, git_repository_head_detached(repo));
 
 	/* take the reop back to it's original state */
-	cl_git_pass(git_reference_symbolic_create(&ref, repo, "HEAD", "refs/heads/master", 1));
+	cl_git_pass(git_reference_symbolic_create(&ref, repo, "HEAD", "refs/heads/master", 1, NULL, NULL));
 	git_reference_free(ref);
 
 	cl_assert_equal_i(false, git_repository_head_detached(repo));
@@ -44,7 +44,7 @@ void test_repo_head__unborn_head(void)
 
 
 	/* take the repo back to it's original state */
-	cl_git_pass(git_reference_symbolic_create(&ref, repo, "HEAD", "refs/heads/master", 1));
+	cl_git_pass(git_reference_symbolic_create(&ref, repo, "HEAD", "refs/heads/master", 1, NULL, NULL));
 	cl_assert(git_repository_head_unborn(repo) == 0);
 
 	git_reference_free(ref);
@@ -156,7 +156,7 @@ void test_repo_head__detach_head_Fails_if_HEAD_and_point_to_a_non_commitish(void
 {
 	git_reference *head;
 
-	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, "refs/tags/point_to_blob", 1));
+	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, "refs/tags/point_to_blob", 1, NULL, NULL));
 
 	cl_git_fail(git_repository_detach_head(repo));
 
diff --git a/tests/repo/repo_helpers.c b/tests/repo/repo_helpers.c
index 3d477ff42..7c5db4a81 100644
--- a/tests/repo/repo_helpers.c
+++ b/tests/repo/repo_helpers.c
@@ -7,7 +7,7 @@ void make_head_unborn(git_repository* repo, const char *target)
 {
 	git_reference *head;
 
-	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, target, 1));
+	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, target, 1, NULL, NULL));
 	git_reference_free(head);
 }
 
diff --git a/tests/stash/save.c b/tests/stash/save.c
index 3d92b26bd..293a89a97 100644
--- a/tests/stash/save.c
+++ b/tests/stash/save.c
@@ -174,7 +174,7 @@ void test_stash_save__cannot_stash_against_an_unborn_branch(void)
 {
 	git_reference *head;
 
-	cl_git_pass(git_reference_symbolic_create(&head, repo, "HEAD", "refs/heads/unborn", 1));
+	cl_git_pass(git_reference_symbolic_create(&head, repo, "HEAD", "refs/heads/unborn", 1, NULL, NULL));
 
 	cl_assert_equal_i(GIT_EUNBORNBRANCH,
 		git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT));
diff --git a/tests/submodule/lookup.c b/tests/submodule/lookup.c
index 5f320e702..ac3fa0415 100644
--- a/tests/submodule/lookup.c
+++ b/tests/submodule/lookup.c
@@ -108,7 +108,7 @@ void test_submodule_lookup__lookup_even_with_unborn_head(void)
 
 	/* put us on an unborn branch */
 	cl_git_pass(git_reference_symbolic_create(
-		&head, g_repo, "HEAD", "refs/heads/garbage", 1));
+		&head, g_repo, "HEAD", "refs/heads/garbage", 1, NULL, NULL));
 	git_reference_free(head);
 
 	/* lookup existing */
diff --git a/tests/threads/refdb.c b/tests/threads/refdb.c
index 3c651e341..fbf6ac09b 100644
--- a/tests/threads/refdb.c
+++ b/tests/threads/refdb.c
@@ -58,7 +58,7 @@ void test_threads_refdb__iterator(void)
 
 	for (r = 0; r < 200; ++r) {
 		snprintf(name, sizeof(name), "refs/heads/direct-%03d", r);
-		cl_git_pass(git_reference_create(&ref, g_repo, name, &head, 0));
+		cl_git_pass(git_reference_create(&ref, g_repo, name, &head, 0, NULL, NULL));
 		git_reference_free(ref);
 	}
 
@@ -102,7 +102,7 @@ static void *create_refs(void *arg)
 
 	for (i = 0; i < 10; ++i) {
 		snprintf(name, sizeof(name), "refs/heads/thread-%03d-%02d", *id, i);
-		cl_git_pass(git_reference_create(&ref[i], g_repo, name, &head, 0));
+		cl_git_pass(git_reference_create(&ref[i], g_repo, name, &head, 0, NULL, NULL));
 
 		if (i == 5) {
 			git_refdb *refdb;
@@ -165,7 +165,7 @@ void test_threads_refdb__edit_while_iterate(void)
 
 	for (r = 0; r < 50; ++r) {
 		snprintf(name, sizeof(name), "refs/heads/starter-%03d", r);
-		cl_git_pass(git_reference_create(&ref, g_repo, name, &head, 0));
+		cl_git_pass(git_reference_create(&ref, g_repo, name, &head, 0, NULL, NULL));
 		git_reference_free(ref);
 	}
 
-- 
cgit v1.2.3


From 53e6f4804b67b757fab065da51901be452b1c765 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 15 Jan 2014 12:12:17 -0800
Subject: Only run coverity on development

---
 script/coverity.sh | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/script/coverity.sh b/script/coverity.sh
index e75395948..945a450f1 100755
--- a/script/coverity.sh
+++ b/script/coverity.sh
@@ -4,6 +4,9 @@ set -e
 # Environment check
 [ -z "$COVERITY_TOKEN" ] && echo "Need to set a coverity token" && exit 1
 
+# Only run this on development
+[ "$TRAVIS_BRANCH" != "development" ] && echo "Not development; bailing." && exit 0
+
 COV_VERSION=6.6.1
 case `uname -m` in
 	i?86)				BITS=32 ;;
-- 
cgit v1.2.3


From 998f0016ff2788ee78d47ac2be6d6b9cc6890e11 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 15 Jan 2014 12:32:12 -0800
Subject: Refine build limitation

---
 script/coverity.sh | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/script/coverity.sh b/script/coverity.sh
index 945a450f1..e72008883 100755
--- a/script/coverity.sh
+++ b/script/coverity.sh
@@ -4,8 +4,13 @@ set -e
 # Environment check
 [ -z "$COVERITY_TOKEN" ] && echo "Need to set a coverity token" && exit 1
 
-# Only run this on development
-[ "$TRAVIS_BRANCH" != "development" ] && echo "Not development; bailing." && exit 0
+# Only run this on our branches
+echo "Pull request: $TRAVIS_PULL_REQUEST  |  Slug: $TRAVIS_REPO_SLUG"
+if [ "$TRAVIS_PULL_REQUEST" != "false" -o "$TRAVIS_REPO_SLUG" != "libgit2/libgit2" ];
+then
+	echo "Only analyzing 'development' on the main repo."
+	exit 0
+fi
 
 COV_VERSION=6.6.1
 case `uname -m` in
-- 
cgit v1.2.3


From 4ef9a50817b7e527ad65b4c3db13ab862347e381 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 15 Jan 2014 13:58:11 -0800
Subject: Update README to include Java, PowerShell bindings

---
 README.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/README.md b/README.md
index 434cc1937..e6a903cdf 100644
--- a/README.md
+++ b/README.md
@@ -164,6 +164,8 @@ Here are the bindings to libgit2 that are currently available:
     * libgit2-glib <https://live.gnome.org/Libgit2-glib>
 * Haskell
     * hgit2 <https://github.com/fpco/gitlib>
+* Java
+    * Jagged <https://github.com/ethomson/jagged>
 * Lua
     * luagit2 <https://github.com/libgit2/luagit2>
 * .NET
@@ -181,6 +183,8 @@ Here are the bindings to libgit2 that are currently available:
     * Git-Raw <https://github.com/ghedo/p5-Git-Raw>
 * PHP
     * php-git <https://github.com/libgit2/php-git>
+* PowerShell
+    * GitPowerShell <https://github.com/ethomson/gitpowershell>
 * Python
     * pygit2 <https://github.com/libgit2/pygit2>
 * Ruby
-- 
cgit v1.2.3


From 3f0e3e166218b875a3e011c790311fc5c50047d1 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@gmail.com>
Date: Thu, 16 Jan 2014 21:42:28 +0100
Subject: Fix some documentation issues.

---
 include/git2/refs.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index e4c6f1b16..a568b9cde 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -27,7 +27,7 @@ GIT_BEGIN_DECL
  * The returned reference must be freed by the user.
  *
  * The name will be checked for validity.
- * See `git_reference_create_symbolic()` for rules about valid names.
+ * See `git_reference_symbolic_create()` for rules about valid names.
  *
  * @param out pointer to the looked-up reference
  * @param repo the repository to look up the reference
@@ -91,7 +91,7 @@ GIT_EXTERN(int) git_reference_dwim(git_reference **out, git_repository *repo, co
  *
  * The signature and message for the reflog will be ignored if the
  * reference does not belong in the standard set (HEAD, branches and
- * remote-tracking branches) and and it does not have a reflog.
+ * remote-tracking branches) or it does not have a reflog.
  *
  * @param out Pointer to the newly created reference
  * @param repo Repository where that reference will live
@@ -192,7 +192,7 @@ GIT_EXTERN(git_ref_t) git_reference_type(const git_reference *ref);
 /**
  * Get the full name of a reference.
  *
- * See `git_reference_create_symbolic()` for rules about valid names.
+ * See `git_reference_symbolic_create()` for rules about valid names.
  *
  * @param ref The reference
  * @return the full name for the ref
@@ -233,7 +233,7 @@ GIT_EXTERN(git_repository *) git_reference_owner(const git_reference *ref);
  * The new reference will be written to disk, overwriting the given reference.
  *
  * The target name will be checked for validity.
- * See `git_reference_create_symbolic()` for rules about valid names.
+ * See `git_reference_symbolic_create()` for rules about valid names.
  *
  * The signature and message for the reflog will be ignored if the
  * reference does not belong in the standard set (HEAD, branches and
@@ -284,7 +284,7 @@ GIT_EXTERN(int) git_reference_set_target(
  * This method works for both direct and symbolic references.
  *
  * The new name will be checked for validity.
- * See `git_reference_create_symbolic()` for rules about valid names.
+ * See `git_reference_symbolic_create()` for rules about valid names.
  *
  * If the `force` flag is not enabled, and there's already
  * a reference with the given name, the renaming will fail.
@@ -544,7 +544,7 @@ typedef enum {
  * Once normalized, if the reference name is valid, it will be returned in
  * the user allocated buffer.
  *
- * See `git_reference_create_symbolic()` for rules about valid names.
+ * See `git_reference_symbolic_create()` for rules about valid names.
  *
  * @param buffer_out User allocated buffer to store normalized name
  * @param buffer_size Size of buffer_out
-- 
cgit v1.2.3


From 3f033c55950f5ebdb00c6628eaff7583b50b90b3 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@gmail.com>
Date: Thu, 16 Jan 2014 21:53:25 +0100
Subject: Revert a wrong doc change.

---
 include/git2/refs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index a568b9cde..b203f242b 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -91,7 +91,7 @@ GIT_EXTERN(int) git_reference_dwim(git_reference **out, git_repository *repo, co
  *
  * The signature and message for the reflog will be ignored if the
  * reference does not belong in the standard set (HEAD, branches and
- * remote-tracking branches) or it does not have a reflog.
+ * remote-tracking branches) and it does not have a reflog.
  *
  * @param out Pointer to the newly created reference
  * @param repo Repository where that reference will live
-- 
cgit v1.2.3


From 4e974c971f39ac5e72bf656b49e43f208146d29e Mon Sep 17 00:00:00 2001
From: Graham Dennis <graham.dennis@gmail.com>
Date: Sat, 18 Jan 2014 08:02:58 +1100
Subject: Fix local push to file:// URL.

---
 src/transports/local.c | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/src/transports/local.c b/src/transports/local.c
index 253aca30a..bd756c48a 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -344,11 +344,29 @@ static int local_push(
 	git_repository *remote_repo = NULL;
 	push_spec *spec;
 	char *url = NULL;
+	const char *path;
+	git_buf buf = GIT_BUF_INIT;
 	int error;
 	unsigned int i;
 	size_t j;
 
-	if ((error = git_repository_open(&remote_repo, push->remote->url)) < 0)
+	/* The repo layer doesn't want the prefix */
+	if (!git__prefixcmp(push->remote->url, "file://")) {
+		if (git_path_fromurl(&buf, push->remote->url) < 0) {
+			git_buf_free(&buf);
+			return -1;
+		}
+		path = git_buf_cstr(&buf);
+
+	} else { /* We assume push->remote->url is already a path */
+		path = push->remote->url;
+	}
+
+	error = git_repository_open(&remote_repo, path);
+
+	git_buf_free(&buf);
+
+	if (error < 0)
 		return error;
 
 	/* We don't currently support pushing locally to non-bare repos. Proper
-- 
cgit v1.2.3


From 194d077c4f6eeea0451753bf5f43355f6520a359 Mon Sep 17 00:00:00 2001
From: Graham Dennis <graham.dennis@gmail.com>
Date: Sat, 18 Jan 2014 08:43:29 +1100
Subject: Add test for pushing to a local file:// URL.

---
 tests/network/remote/local.c | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/tests/network/remote/local.c b/tests/network/remote/local.c
index 309142925..2ec5780e5 100644
--- a/tests/network/remote/local.c
+++ b/tests/network/remote/local.c
@@ -197,6 +197,46 @@ void test_network_remote_local__push_to_bare_remote(void)
 	cl_fixture_cleanup("localbare.git");
 }
 
+void test_network_remote_local__push_to_bare_remote_with_file_url(void)
+{
+	/* Should be able to push to a bare remote */
+	git_remote *localremote;
+	git_push *push;
+
+	/* Get some commits */
+	connect_to_local_repository(cl_fixture("testrepo.git"));
+	cl_git_pass(git_remote_add_fetch(remote, "master:master"));
+	cl_git_pass(git_remote_download(remote));
+	cl_git_pass(git_remote_update_tips(remote));
+	git_remote_disconnect(remote);
+
+	/* Set up an empty bare repo to push into */
+	{
+		git_repository *localbarerepo;
+		cl_git_pass(git_repository_init(&localbarerepo, "./localbare.git", 1));
+		git_repository_free(localbarerepo);
+	}
+
+	/* Create a file URL */
+	char *url = cl_git_path_url("./localbare.git");
+
+	/* Connect to the bare repo */
+	cl_git_pass(git_remote_create_inmemory(&localremote, repo, NULL, url));
+	cl_git_pass(git_remote_connect(localremote, GIT_DIRECTION_PUSH));
+
+	/* Try to push */
+	cl_git_pass(git_push_new(&push, localremote));
+	cl_git_pass(git_push_add_refspec(push, "refs/heads/master:"));
+	cl_git_pass(git_push_finish(push));
+	cl_assert(git_push_unpack_ok(push));
+
+	/* Clean up */
+	git_push_free(push);
+	git_remote_free(localremote);
+	cl_fixture_cleanup("localbare.git");
+}
+
+
 void test_network_remote_local__push_to_non_bare_remote(void)
 {
 	/* Shouldn't be able to push to a non-bare remote */
-- 
cgit v1.2.3


From 6b415f622e93a81471ac485411ae9126a1e1938f Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 17 Jan 2014 13:46:44 -0800
Subject: Convert gitdir paths to posix on Windows

Apparently, a .git file with "gitdir: path" link on Windows is
allowed to use backslashes in the path.  Who knew?
---
 src/repository.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/repository.c b/src/repository.c
index c584d30c8..8645357b8 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -289,16 +289,20 @@ static int read_gitfile(git_buf *path_out, const char *file_path)
 		return -1;
 
 	git_buf_rtrim(&file);
+	/* apparently on Windows, some people use backslashes in paths */
+	git_path_mkposix(file.ptr);
 
 	if (git_buf_len(&file) <= prefix_len ||
 		memcmp(git_buf_cstr(&file), GIT_FILE_CONTENT_PREFIX, prefix_len) != 0)
 	{
-		giterr_set(GITERR_REPOSITORY, "The `.git` file at '%s' is malformed", file_path);
+		giterr_set(GITERR_REPOSITORY,
+			"The `.git` file at '%s' is malformed", file_path);
 		error = -1;
 	}
 	else if ((error = git_path_dirname_r(path_out, file_path)) >= 0) {
 		const char *gitlink = git_buf_cstr(&file) + prefix_len;
 		while (*gitlink && git__isspace(*gitlink)) gitlink++;
+
 		error = git_path_prettify_dir(
 			path_out, gitlink, git_buf_cstr(path_out));
 	}
-- 
cgit v1.2.3


From c7015424ccd2a7cb95a0cd3ed65d22495cd2d78f Mon Sep 17 00:00:00 2001
From: Graham Dennis <graham.dennis@gmail.com>
Date: Sat, 18 Jan 2014 08:54:19 +1100
Subject: Fix a compile warning.

---
 tests/network/remote/local.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/network/remote/local.c b/tests/network/remote/local.c
index 2ec5780e5..c713ade5b 100644
--- a/tests/network/remote/local.c
+++ b/tests/network/remote/local.c
@@ -218,7 +218,7 @@ void test_network_remote_local__push_to_bare_remote_with_file_url(void)
 	}
 
 	/* Create a file URL */
-	char *url = cl_git_path_url("./localbare.git");
+	const char *url = cl_git_path_url("./localbare.git");
 
 	/* Connect to the bare repo */
 	cl_git_pass(git_remote_create_inmemory(&localremote, repo, NULL, url));
-- 
cgit v1.2.3


From c24130e06896e9838a05301079bdb8f09912e546 Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Sat, 18 Jan 2014 22:58:31 +0800
Subject: Fix segfault when calling git_config_get_* functions when a config
 fails to load

Reinitialize the result code of get_entry() to GIT_ENOTFOUND
---
 src/config.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/config.c b/src/config.c
index 056a6ae13..6dcaba5fd 100644
--- a/src/config.c
+++ b/src/config.c
@@ -651,6 +651,7 @@ static int get_entry(
 		key = normalized;
 	}
 
+	res = GIT_ENOTFOUND;
 	git_vector_foreach(&cfg->files, i, internal) {
 		if (!internal || !internal->file)
 			continue;
-- 
cgit v1.2.3


From 8bf476ac31f77ad27646d43a5d498992ddf4c5df Mon Sep 17 00:00:00 2001
From: Graham Dennis <graham.dennis@gmail.com>
Date: Sun, 19 Jan 2014 16:24:58 +1100
Subject: Factor out code to convert local "url" into a path.

Previously this code was shared between `local_push` and `local_connect`.
---
 src/transports/local.c | 48 ++++++++++++++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 20 deletions(-)

diff --git a/src/transports/local.c b/src/transports/local.c
index bd756c48a..26ada48e6 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -156,6 +156,24 @@ on_error:
 	return -1;
 }
 
+static int path_from_url_or_path(git_buf *local_path_out, const char *url_or_path)
+{
+	int error;
+
+	/* If url_or_path begins with file:// treat it as a URL */
+	if (!git__prefixcmp(url_or_path, "file://")) {
+		if ((error = git_path_fromurl(local_path_out, url_or_path)) < 0) {
+			return error;
+		}
+	} else { /* We assume url_or_path is already a path */
+		if ((error = git_buf_sets(local_path_out, url_or_path)) < 0) {
+			return error;
+		}
+	}
+
+	return 0;
+}
+
 /*
  * Try to open the url as a git directory. The direction doesn't
  * matter in this case because we're calulating the heads ourselves.
@@ -181,17 +199,12 @@ static int local_connect(
 	t->direction = direction;
 	t->flags = flags;
 
-	/* The repo layer doesn't want the prefix */
-	if (!git__prefixcmp(t->url, "file://")) {
-		if (git_path_fromurl(&buf, t->url) < 0) {
-			git_buf_free(&buf);
-			return -1;
-		}
-		path = git_buf_cstr(&buf);
-
-	} else { /* We assume transport->url is already a path */
-		path = t->url;
+	/* 'url' may be a url or path; convert to a path */
+	if ((error = path_from_url_or_path(&buf, url)) < 0) {
+		git_buf_free(&buf);
+		return error;
 	}
+	path = git_buf_cstr(&buf);
 
 	error = git_repository_open(&repo, path);
 
@@ -350,17 +363,12 @@ static int local_push(
 	unsigned int i;
 	size_t j;
 
-	/* The repo layer doesn't want the prefix */
-	if (!git__prefixcmp(push->remote->url, "file://")) {
-		if (git_path_fromurl(&buf, push->remote->url) < 0) {
-			git_buf_free(&buf);
-			return -1;
-		}
-		path = git_buf_cstr(&buf);
-
-	} else { /* We assume push->remote->url is already a path */
-		path = push->remote->url;
+	/* 'push->remote->url' may be a url or path; convert to a path */
+	if ((error = path_from_url_or_path(&buf, push->remote->url)) < 0) {
+		git_buf_free(&buf);
+		return error;
 	}
+	path = git_buf_cstr(&buf);
 
 	error = git_repository_open(&remote_repo, path);
 
-- 
cgit v1.2.3


From e7c66fc89b2ff34c014f402ee7f91188eea5e0f6 Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Mon, 20 Jan 2014 23:32:18 +0800
Subject: git_reflog_entry_message can be null

---
 src/revparse.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/revparse.c b/src/revparse.c
index c120b466f..5cce3be63 100644
--- a/src/revparse.c
+++ b/src/revparse.c
@@ -168,6 +168,8 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
 	for (i = 0; i < numentries; i++) {
 		entry = git_reflog_entry_byindex(reflog, i);
 		msg = git_reflog_entry_message(entry);
+		if (!msg)
+			continue;
 
 		if (regexec(&preg, msg, 2, regexmatches, 0))
 			continue;
-- 
cgit v1.2.3


From 7cbc6241cf75bd8bd198273231e994711c998716 Mon Sep 17 00:00:00 2001
From: Patrick Reynolds <patrick.reynolds@github.com>
Date: Mon, 20 Jan 2014 11:41:21 -0600
Subject: fix corner cases and an undefined behavior

---
 src/buffer.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/buffer.c b/src/buffer.c
index 3283c2d4f..318fee753 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -66,8 +66,10 @@ int git_buf_try_grow(
 	new_ptr = git__realloc(new_ptr, new_size);
 
 	if (!new_ptr) {
-		if (mark_oom)
+		if (mark_oom) {
+			if (buf->ptr) git__free(buf->ptr);
 			buf->ptr = git_buf__oom;
+		}
 		return -1;
 	}
 
@@ -432,7 +434,7 @@ int git_buf_join(
 	ssize_t offset_a = -1;
 
 	/* not safe to have str_b point internally to the buffer */
-	assert(str_b < buf->ptr || str_b > buf->ptr + buf->size);
+	assert(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
 
 	/* figure out if we need to insert a separator */
 	if (separator && strlen_a) {
@@ -447,13 +449,14 @@ int git_buf_join(
 
 	if (git_buf_grow(buf, strlen_a + strlen_b + need_sep + 1) < 0)
 		return -1;
+	assert(buf->ptr);
 
 	/* fix up internal pointers */
 	if (offset_a >= 0)
 		str_a = buf->ptr + offset_a;
 
 	/* do the actual copying */
-	if (offset_a != 0)
+	if (offset_a != 0 && str_a)
 		memmove(buf->ptr, str_a, strlen_a);
 	if (need_sep)
 		buf->ptr[strlen_a] = separator;
-- 
cgit v1.2.3


From abdaf9366262ea034e092e8a9a707f5a7837ca65 Mon Sep 17 00:00:00 2001
From: Patrick Reynolds <patrick.reynolds@github.com>
Date: Mon, 20 Jan 2014 11:42:12 -0600
Subject: add unit tests for git_buf_join corner cases

---
 tests/core/buffer.c | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/tests/core/buffer.c b/tests/core/buffer.c
index 11d173d49..0e7dd3d70 100644
--- a/tests/core/buffer.c
+++ b/tests/core/buffer.c
@@ -405,6 +405,23 @@ check_joinbuf_2(
 	git_buf_free(&buf);
 }
 
+static void
+check_joinbuf_overlapped(
+	const char *oldval,
+	int ofs_a,
+	const char *b,
+	const char *expected)
+{
+	char sep = '/';
+	git_buf buf = GIT_BUF_INIT;
+
+	git_buf_sets(&buf, oldval);
+	git_buf_join(&buf, sep, buf.ptr + ofs_a, b);
+	cl_assert(git_buf_oom(&buf) == 0);
+	cl_assert_equal_s(expected, git_buf_cstr(&buf));
+	git_buf_free(&buf);
+}
+
 static void
 check_joinbuf_n_2(
 	const char *a,
@@ -480,6 +497,20 @@ void test_core_buffer__8(void)
 	check_joinbuf_2("/abcd/", "defg/", "/abcd/defg/");
 	check_joinbuf_2("/abcd/", "/defg/", "/abcd/defg/");
 
+	check_joinbuf_overlapped("abcd", 0, "efg", "abcd/efg");
+	check_joinbuf_overlapped("abcd", 1, "efg", "bcd/efg");
+	check_joinbuf_overlapped("abcd", 2, "efg", "cd/efg");
+	check_joinbuf_overlapped("abcd", 3, "efg", "d/efg");
+	check_joinbuf_overlapped("abcd", 4, "efg", "efg");
+	check_joinbuf_overlapped("abc/", 2, "efg", "c/efg");
+	check_joinbuf_overlapped("abc/", 3, "efg", "/efg");
+	check_joinbuf_overlapped("abc/", 4, "efg", "efg");
+	check_joinbuf_overlapped("abcd", 3, "", "d/");
+	check_joinbuf_overlapped("abcd", 4, "", "");
+	check_joinbuf_overlapped("abc/", 2, "", "c/");
+	check_joinbuf_overlapped("abc/", 3, "", "/");
+	check_joinbuf_overlapped("abc/", 4, "", "");
+
 	check_joinbuf_n_2("", "", "");
 	check_joinbuf_n_2("", "a", "a");
 	check_joinbuf_n_2("", "/a", "/a");
-- 
cgit v1.2.3


From b554ca5dc1b95234589367eda269a94bdda3d6ae Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 20 Jan 2014 15:12:06 -0500
Subject: "Uninitialized" submodules are "unmodified"

Extend the "unmodified" submodule workdir test to include
uninitialized submodules, to prevent reporting submodules as
modified when they're not in the workdir at all.
---
 include/git2/submodule.h  |  3 ++-
 tests/status/submodules.c | 17 +++++++++++++++++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index 907e5a15f..af08ba6eb 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -97,7 +97,8 @@ typedef enum {
 	(((S) & GIT_SUBMODULE_STATUS__INDEX_FLAGS) == 0)
 
 #define GIT_SUBMODULE_STATUS_IS_WD_UNMODIFIED(S) \
-	(((S) & GIT_SUBMODULE_STATUS__WD_FLAGS) == 0)
+	(((S) & (GIT_SUBMODULE_STATUS__WD_FLAGS & \
+	~GIT_SUBMODULE_STATUS_WD_UNINITIALIZED)) == 0)
 
 #define GIT_SUBMODULE_STATUS_IS_WD_DIRTY(S) \
 	(((S) & (GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED | \
diff --git a/tests/status/submodules.c b/tests/status/submodules.c
index ef2888f7d..dc7990cf1 100644
--- a/tests/status/submodules.c
+++ b/tests/status/submodules.c
@@ -221,3 +221,20 @@ void test_status_submodules__dirty_workdir_only(void)
 		git_status_foreach_ext(g_repo, &opts, cb_status__match, &counts));
 	cl_assert_equal_i(6, counts.entry_count);
 }
+
+void test_status_submodules__uninitialized(void)
+{
+	git_repository *cloned_repo;
+	git_status_list *statuslist;
+
+	g_repo = cl_git_sandbox_init("submod2");
+
+	cl_git_pass(git_clone(&cloned_repo, "submod2", "submod2-clone", NULL));
+
+	cl_git_pass(git_status_list_new(&statuslist, cloned_repo, NULL));
+	cl_assert_equal_i(0, git_status_list_entrycount(statuslist));
+
+	git_status_list_free(statuslist);
+	git_repository_free(cloned_repo);
+	cl_git_sandbox_cleanup();
+}
-- 
cgit v1.2.3


From c1d648c5c6361edfb1aa85a31656b628672c7616 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 8 Jan 2014 18:29:42 -0800
Subject: merge_file should use more aggressive levels

The default merge_file level was XDL_MERGE_MINIMAL, which will
produce conflicts where there should not be in the case where
both sides were changed identically.  Change the defaults to be
more aggressive (XDL_MERGE_ZEALOUS) which will more aggressively
compress non-conflicts.  This matches git.git's defaults.

Increase testing around reverting a previously reverted commit to
illustrate this problem.
---
 include/git2/merge.h                               |  21 ++-
 src/checkout.c                                     |   3 +-
 src/merge.c                                        |  17 +-
 src/merge_file.c                                   |  11 +-
 src/merge_file.h                                   |  14 +-
 tests/merge/trees/automerge.c                      |   4 +-
 tests/merge/trees/trivial.c                        |   2 +-
 tests/merge/workdir/simple.c                       |  14 +-
 tests/merge/workdir/trivial.c                      |   2 +-
 tests/resources/revert/.gitted/index               | Bin 320 -> 464 bytes
 .../0a/d19525be6d8cae5e5deb2770fc244b65255057      | Bin 0 -> 133 bytes
 .../13/a6fdfd10bd74b1f258fb58801215985dd2e797      | Bin 0 -> 121 bytes
 .../1b/c915c5cb7185a9438de28a7b1a7dfe8c01ee7f      | Bin 0 -> 1169 bytes
 .../1f/f0c423042b46cb1d617b81efb715defbe8054d      | Bin 0 -> 751 bytes
 .../21/a96a98ed84d45866e1de6e266fd3a61a4ae9dc      | Bin 0 -> 19 bytes
 .../39/9fb3aba3d9d13f7d40a9254ce4402067ef3149      |   2 +
 .../46/ff0854663aeb2182b9838c8da68e33ac23bc1e      | Bin 0 -> 20 bytes
 .../5c/f1d643f100d8112834e540264546ba2c159976      | Bin 0 -> 86 bytes
 .../6b/ccd0dc58cea5ccff86014f3d64b31bd8c02a37      | Bin 0 -> 171 bytes
 .../71/eb9c2b53dbbf3c45fb28b27c850db4b7fb8011      | Bin 0 -> 148 bytes
 .../87/59ad453cf01cf7daf14e2a668f8218f9a678eb      | Bin 0 -> 122 bytes
 .../9a/95fd974e03c5b93828ceedd28755965b5d5c60      | Bin 0 -> 122 bytes
 .../a8/c86221b400b836010567cc3593db6e96c1a83a      | Bin 0 -> 24 bytes
 .../ac/c4d33902092efeb3b714aa0b1007c329e2f2e6      |   2 +
 .../b6/9d88e177455579896e2be495046e2a51456a9a      |   1 +
 .../ca/f99de3a49827117bb66721010eac461b06a80c      | Bin 0 -> 33 bytes
 .../de/03538407ed18914ff05657eeff70425c0f304d      |   2 +
 .../e3/4ef1afe54eb526fd92eec66084125f340f1d65      | Bin 0 -> 150 bytes
 .../ea/392a157085bc32daccd59aa1998fe2f5fb9fc0      | Bin 0 -> 134 bytes
 .../ee/c6adcb2f3ceca0cadeccfe01b19382252ece9b      | Bin 0 -> 66 bytes
 tests/resources/revert/.gitted/refs/heads/master   |   2 +-
 tests/resources/revert/.gitted/refs/heads/two      |   1 +
 tests/revert/workdir.c                             | 199 ++++++++++++++++++++-
 33 files changed, 264 insertions(+), 33 deletions(-)
 create mode 100644 tests/resources/revert/.gitted/objects/0a/d19525be6d8cae5e5deb2770fc244b65255057
 create mode 100644 tests/resources/revert/.gitted/objects/13/a6fdfd10bd74b1f258fb58801215985dd2e797
 create mode 100644 tests/resources/revert/.gitted/objects/1b/c915c5cb7185a9438de28a7b1a7dfe8c01ee7f
 create mode 100644 tests/resources/revert/.gitted/objects/1f/f0c423042b46cb1d617b81efb715defbe8054d
 create mode 100644 tests/resources/revert/.gitted/objects/21/a96a98ed84d45866e1de6e266fd3a61a4ae9dc
 create mode 100644 tests/resources/revert/.gitted/objects/39/9fb3aba3d9d13f7d40a9254ce4402067ef3149
 create mode 100644 tests/resources/revert/.gitted/objects/46/ff0854663aeb2182b9838c8da68e33ac23bc1e
 create mode 100644 tests/resources/revert/.gitted/objects/5c/f1d643f100d8112834e540264546ba2c159976
 create mode 100644 tests/resources/revert/.gitted/objects/6b/ccd0dc58cea5ccff86014f3d64b31bd8c02a37
 create mode 100644 tests/resources/revert/.gitted/objects/71/eb9c2b53dbbf3c45fb28b27c850db4b7fb8011
 create mode 100644 tests/resources/revert/.gitted/objects/87/59ad453cf01cf7daf14e2a668f8218f9a678eb
 create mode 100644 tests/resources/revert/.gitted/objects/9a/95fd974e03c5b93828ceedd28755965b5d5c60
 create mode 100644 tests/resources/revert/.gitted/objects/a8/c86221b400b836010567cc3593db6e96c1a83a
 create mode 100644 tests/resources/revert/.gitted/objects/ac/c4d33902092efeb3b714aa0b1007c329e2f2e6
 create mode 100644 tests/resources/revert/.gitted/objects/b6/9d88e177455579896e2be495046e2a51456a9a
 create mode 100644 tests/resources/revert/.gitted/objects/ca/f99de3a49827117bb66721010eac461b06a80c
 create mode 100644 tests/resources/revert/.gitted/objects/de/03538407ed18914ff05657eeff70425c0f304d
 create mode 100644 tests/resources/revert/.gitted/objects/e3/4ef1afe54eb526fd92eec66084125f340f1d65
 create mode 100644 tests/resources/revert/.gitted/objects/ea/392a157085bc32daccd59aa1998fe2f5fb9fc0
 create mode 100644 tests/resources/revert/.gitted/objects/ee/c6adcb2f3ceca0cadeccfe01b19382252ece9b
 create mode 100644 tests/resources/revert/.gitted/refs/heads/two

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 8a1dfec2e..1888babd1 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -32,14 +32,21 @@ typedef enum {
 } git_merge_tree_flag_t;
 
 /**
- * Automerge options for `git_merge_trees_opts`.
+ * Merge file options for `git_merge_trees_opts`.
  */
 typedef enum {
-	GIT_MERGE_AUTOMERGE_NORMAL = 0,
-	GIT_MERGE_AUTOMERGE_NONE = 1,
-	GIT_MERGE_AUTOMERGE_FAVOR_OURS = 2,
-	GIT_MERGE_AUTOMERGE_FAVOR_THEIRS = 3,
-} git_merge_automerge_flags;
+	/* Produce a conflict in a file when two similar regions are changed. */
+	GIT_MERGE_FILE_FAVOR_NORMAL = 0,
+
+	/* Do not attempt to produce an automerged file during tree merge. */
+	GIT_MERGE_FILE_FAVOR_NO_MERGE = 1,
+
+	/* Produce a file containing the "ours" side of conflicting regions. */
+	GIT_MERGE_FILE_FAVOR_OURS = 2,
+
+	/* Produce a file containing the "theirs" side of conflicting regions. */
+	GIT_MERGE_FILE_FAVOR_THEIRS = 3,
+} git_merge_file_favor_t;
 
 
 typedef struct {
@@ -58,7 +65,7 @@ typedef struct {
 	git_diff_similarity_metric *metric;
 
 	/** Flags for automerging content. */
-	git_merge_automerge_flags automerge_flags;
+	git_merge_file_favor_t file_favor;
 } git_merge_tree_opts;
 
 #define GIT_MERGE_TREE_OPTS_VERSION 1
diff --git a/src/checkout.c b/src/checkout.c
index e642c975e..cc49800a2 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -1626,6 +1626,7 @@ static int checkout_write_merge(
 {
 	git_buf our_label = GIT_BUF_INIT, their_label = GIT_BUF_INIT,
 		path_suffixed = GIT_BUF_INIT, path_workdir = GIT_BUF_INIT;
+	git_merge_file_options merge_file_opts = GIT_MERGE_FILE_OPTIONS_INIT;
 	git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT,
 		ours = GIT_MERGE_FILE_INPUT_INIT,
 		theirs = GIT_MERGE_FILE_INPUT_INIT;
@@ -1662,7 +1663,7 @@ static int checkout_write_merge(
 		theirs.label = git_buf_cstr(&their_label);
 	}
 
-	if ((error = git_merge_files(&result, &ancestor, &ours, &theirs, 0)) < 0)
+	if ((error = git_merge_files(&result, &ancestor, &ours, &theirs, &merge_file_opts)) < 0)
 		goto done;
 
 	if (result.path == NULL || result.mode == 0) {
diff --git a/src/merge.c b/src/merge.c
index c0be37dd8..3ac9167e3 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -511,8 +511,9 @@ static int merge_conflict_resolve_automerge(
 	int *resolved,
 	git_merge_diff_list *diff_list,
 	const git_merge_diff *conflict,
-	unsigned int automerge_flags)
+	unsigned int merge_file_favor)
 {
+	git_merge_file_options merge_file_opts = GIT_MERGE_FILE_OPTIONS_INIT;
 	git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT,
 		ours = GIT_MERGE_FILE_INPUT_INIT,
 		theirs = GIT_MERGE_FILE_INPUT_INIT;
@@ -526,9 +527,11 @@ static int merge_conflict_resolve_automerge(
 
 	*resolved = 0;
 
-	if (automerge_flags == GIT_MERGE_AUTOMERGE_NONE)
+	if (merge_file_favor == GIT_MERGE_FILE_FAVOR_NO_MERGE)
 		return 0;
 
+	merge_file_opts.favor = merge_file_favor;
+
 	/* Reject D/F conflicts */
 	if (conflict->type == GIT_MERGE_DIFF_DIRECTORY_FILE)
 		return 0;
@@ -552,7 +555,7 @@ static int merge_conflict_resolve_automerge(
 		(error = git_merge_file_input_from_index_entry(&ancestor, diff_list->repo, &conflict->ancestor_entry)) < 0 ||
 		(error = git_merge_file_input_from_index_entry(&ours, diff_list->repo, &conflict->our_entry)) < 0 ||
 		(error = git_merge_file_input_from_index_entry(&theirs, diff_list->repo, &conflict->their_entry)) < 0 ||
-		(error = git_merge_files(&result, &ancestor, &ours, &theirs, automerge_flags)) < 0 ||
+		(error = git_merge_files(&result, &ancestor, &ours, &theirs, &merge_file_opts)) < 0 ||
 		!result.automergeable ||
 		(error = git_odb_write(&automerge_oid, odb, result.data, result.len, GIT_OBJ_BLOB)) < 0)
 		goto done;
@@ -586,7 +589,7 @@ static int merge_conflict_resolve(
 	int *out,
 	git_merge_diff_list *diff_list,
 	const git_merge_diff *conflict,
-	unsigned int automerge_flags)
+	unsigned int merge_file_favor)
 {
 	int resolved = 0;
 	int error = 0;
@@ -596,14 +599,14 @@ static int merge_conflict_resolve(
 	if ((error = merge_conflict_resolve_trivial(&resolved, diff_list, conflict)) < 0)
 		goto done;
 
-	if (automerge_flags != GIT_MERGE_AUTOMERGE_NONE) {
+	if (merge_file_favor != GIT_MERGE_FILE_FAVOR_NO_MERGE) {
 		if (!resolved && (error = merge_conflict_resolve_one_removed(&resolved, diff_list, conflict)) < 0)
 			goto done;
 
 		if (!resolved && (error = merge_conflict_resolve_one_renamed(&resolved, diff_list, conflict)) < 0)
 			goto done;
 
-		if (!resolved && (error = merge_conflict_resolve_automerge(&resolved, diff_list, conflict, automerge_flags)) < 0)
+		if (!resolved && (error = merge_conflict_resolve_automerge(&resolved, diff_list, conflict, merge_file_favor)) < 0)
 			goto done;
 	}
 
@@ -1589,7 +1592,7 @@ int git_merge_trees(
 	git_vector_foreach(&changes, i, conflict) {
 		int resolved = 0;
 
-		if ((error = merge_conflict_resolve(&resolved, diff_list, conflict, opts.automerge_flags)) < 0)
+		if ((error = merge_conflict_resolve(&resolved, diff_list, conflict, opts.file_favor)) < 0)
 			goto done;
 
 		if (!resolved)
diff --git a/src/merge_file.c b/src/merge_file.c
index 48fc46e57..d13190276 100644
--- a/src/merge_file.c
+++ b/src/merge_file.c
@@ -130,7 +130,7 @@ int git_merge_files(
 	git_merge_file_input *ancestor,
 	git_merge_file_input *ours,
 	git_merge_file_input *theirs,
-	git_merge_automerge_flags flags)
+	git_merge_file_options *opts)
 {
 	xmparam_t xmparam;
 	mmbuffer_t mmbuffer;
@@ -152,12 +152,15 @@ int git_merge_files(
 	out->path = merge_file_best_path(ancestor, ours, theirs);
 	out->mode = merge_file_best_mode(ancestor, ours, theirs);
 
-	if (flags == GIT_MERGE_AUTOMERGE_FAVOR_OURS)
+	if (opts && opts->favor == GIT_MERGE_FILE_FAVOR_OURS)
 		xmparam.favor = XDL_MERGE_FAVOR_OURS;
-
-	if (flags == GIT_MERGE_AUTOMERGE_FAVOR_THEIRS)
+	else if (opts && opts->favor == GIT_MERGE_FILE_FAVOR_THEIRS)
 		xmparam.favor = XDL_MERGE_FAVOR_THEIRS;
 
+	xmparam.level = 
+		(opts && (opts->flags & GIT_MERGE_FILE_SIMPLIFY_ALNUM)) ?
+		XDL_MERGE_ZEALOUS_ALNUM : XDL_MERGE_ZEALOUS;
+
 	if ((xdl_result = xdl_merge(&ancestor->mmfile, &ours->mmfile,
 		&theirs->mmfile, &xmparam, &mmbuffer)) < 0) {
 		giterr_set(GITERR_MERGE, "Failed to merge files.");
diff --git a/src/merge_file.h b/src/merge_file.h
index 0af2f0a57..5d7ea9752 100644
--- a/src/merge_file.h
+++ b/src/merge_file.h
@@ -34,6 +34,18 @@ typedef struct {
 
 #define GIT_MERGE_FILE_RESULT_INIT	{0}
 
+typedef enum {
+	/* Condense non-alphanumeric regions for simplified diff file */
+	GIT_MERGE_FILE_SIMPLIFY_ALNUM = (1 << 0),
+} git_merge_file_flags_t;
+
+typedef struct {
+	git_merge_file_favor_t favor;
+	git_merge_file_flags_t flags;
+} git_merge_file_options;
+
+#define GIT_MERGE_FILE_OPTIONS_INIT	{0}
+
 int git_merge_file_input_from_index_entry(
 	git_merge_file_input *input,
 	git_repository *repo,
@@ -49,7 +61,7 @@ int git_merge_files(
 	git_merge_file_input *ancestor,
 	git_merge_file_input *ours,
 	git_merge_file_input *theirs,
-	git_merge_automerge_flags flags);
+	git_merge_file_options *opts);
 
 GIT_INLINE(void) git_merge_file_input_free(git_merge_file_input *input)
 {
diff --git a/tests/merge/trees/automerge.c b/tests/merge/trees/automerge.c
index 746ce5068..ebc6e271d 100644
--- a/tests/merge/trees/automerge.c
+++ b/tests/merge/trees/automerge.c
@@ -149,7 +149,7 @@ void test_merge_trees_automerge__favor_ours(void)
 		REMOVED_IN_MASTER_REUC_ENTRY,
 	};
 
-	opts.automerge_flags = GIT_MERGE_AUTOMERGE_FAVOR_OURS;
+	opts.file_favor = GIT_MERGE_FILE_FAVOR_OURS;
 
 	cl_git_pass(merge_trees_from_branches(&index, repo, "master", THEIRS_AUTOMERGE_BRANCH, &opts));
 
@@ -180,7 +180,7 @@ void test_merge_trees_automerge__favor_theirs(void)
 		REMOVED_IN_MASTER_REUC_ENTRY,
 	};
 
-	opts.automerge_flags = GIT_MERGE_AUTOMERGE_FAVOR_THEIRS;
+	opts.file_favor = GIT_MERGE_FILE_FAVOR_THEIRS;
 
 	cl_git_pass(merge_trees_from_branches(&index, repo, "master", THEIRS_AUTOMERGE_BRANCH, &opts));
 
diff --git a/tests/merge/trees/trivial.c b/tests/merge/trees/trivial.c
index bfd5dfed3..244cd3223 100644
--- a/tests/merge/trees/trivial.c
+++ b/tests/merge/trees/trivial.c
@@ -33,7 +33,7 @@ static int merge_trivial(git_index **index, const char *ours, const char *theirs
 	git_buf branch_buf = GIT_BUF_INIT;
 	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
 
-	opts.automerge_flags |= automerge ? 0 : GIT_MERGE_AUTOMERGE_NONE;
+	opts.file_favor |= automerge ? 0 : GIT_MERGE_FILE_FAVOR_NO_MERGE;
 
 	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, ours);
 	cl_git_pass(git_reference_name_to_id(&our_oid, repo, branch_buf.ptr));
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 98dca53ef..2142fc4f9 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -113,7 +113,7 @@ void test_merge_workdir_simple__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-static git_merge_result *merge_simple_branch(int automerge_flags, int checkout_strategy)
+static git_merge_result *merge_simple_branch(int merge_file_favor, int checkout_strategy)
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
@@ -123,7 +123,7 @@ static git_merge_result *merge_simple_branch(int automerge_flags, int checkout_s
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_SIMPLE_OID));
 	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.automerge_flags = automerge_flags;
+	opts.merge_tree_opts.file_favor = merge_file_favor;
 	opts.checkout_opts.checkout_strategy = checkout_strategy;
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
 
@@ -336,7 +336,7 @@ void test_merge_workdir_simple__favor_ours(void)
 		REMOVED_IN_MASTER_REUC_ENTRY,
 	};
 
-	cl_assert(result = merge_simple_branch(GIT_MERGE_AUTOMERGE_FAVOR_OURS, 0));
+	cl_assert(result = merge_simple_branch(GIT_MERGE_FILE_FAVOR_OURS, 0));
 	cl_assert(!git_merge_result_is_fastforward(result));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
@@ -365,7 +365,7 @@ void test_merge_workdir_simple__favor_theirs(void)
 		REMOVED_IN_MASTER_REUC_ENTRY,
 	};
 
-	cl_assert(result = merge_simple_branch(GIT_MERGE_AUTOMERGE_FAVOR_THEIRS, 0));
+	cl_assert(result = merge_simple_branch(GIT_MERGE_FILE_FAVOR_THEIRS, 0));
 	cl_assert(!git_merge_result_is_fastforward(result));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
@@ -414,7 +414,7 @@ void test_merge_workdir_simple__directory_file(void)
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_DIRECTORY_FILE));
 	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.automerge_flags = 0;
+	opts.merge_tree_opts.file_favor = 0;
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 20));
@@ -447,7 +447,7 @@ void test_merge_workdir_simple__unrelated(void)
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_UNRELATED_PARENT));
 	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.automerge_flags = 0;
+	opts.merge_tree_opts.file_favor = 0;
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 9));
@@ -480,7 +480,7 @@ void test_merge_workdir_simple__unrelated_with_conflicts(void)
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_UNRELATED_OID));
 	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.automerge_flags = 0;
+	opts.merge_tree_opts.file_favor = 0;
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 11));
diff --git a/tests/merge/workdir/trivial.c b/tests/merge/workdir/trivial.c
index df18b0e0b..ebf09095c 100644
--- a/tests/merge/workdir/trivial.c
+++ b/tests/merge/workdir/trivial.c
@@ -39,7 +39,7 @@ static int merge_trivial(const char *ours, const char *theirs, bool automerge)
 
 	checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
-	opts.merge_tree_opts.automerge_flags |= automerge ? 0 : GIT_MERGE_AUTOMERGE_NONE;
+	opts.merge_tree_opts.file_favor |= automerge ? 0 : GIT_MERGE_FILE_FAVOR_NO_MERGE;
 
 	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, ours);
 	cl_git_pass(git_reference_symbolic_create(&our_ref, repo, "HEAD", branch_buf.ptr, 1, NULL, NULL));
diff --git a/tests/resources/revert/.gitted/index b/tests/resources/revert/.gitted/index
index 87419ff57..3513c04a6 100644
Binary files a/tests/resources/revert/.gitted/index and b/tests/resources/revert/.gitted/index differ
diff --git a/tests/resources/revert/.gitted/objects/0a/d19525be6d8cae5e5deb2770fc244b65255057 b/tests/resources/revert/.gitted/objects/0a/d19525be6d8cae5e5deb2770fc244b65255057
new file mode 100644
index 000000000..4aa0459d8
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/0a/d19525be6d8cae5e5deb2770fc244b65255057 differ
diff --git a/tests/resources/revert/.gitted/objects/13/a6fdfd10bd74b1f258fb58801215985dd2e797 b/tests/resources/revert/.gitted/objects/13/a6fdfd10bd74b1f258fb58801215985dd2e797
new file mode 100644
index 000000000..3c54aab0c
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/13/a6fdfd10bd74b1f258fb58801215985dd2e797 differ
diff --git a/tests/resources/revert/.gitted/objects/1b/c915c5cb7185a9438de28a7b1a7dfe8c01ee7f b/tests/resources/revert/.gitted/objects/1b/c915c5cb7185a9438de28a7b1a7dfe8c01ee7f
new file mode 100644
index 000000000..0a6955b5d
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/1b/c915c5cb7185a9438de28a7b1a7dfe8c01ee7f differ
diff --git a/tests/resources/revert/.gitted/objects/1f/f0c423042b46cb1d617b81efb715defbe8054d b/tests/resources/revert/.gitted/objects/1f/f0c423042b46cb1d617b81efb715defbe8054d
new file mode 100644
index 000000000..2ed1a2292
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/1f/f0c423042b46cb1d617b81efb715defbe8054d differ
diff --git a/tests/resources/revert/.gitted/objects/21/a96a98ed84d45866e1de6e266fd3a61a4ae9dc b/tests/resources/revert/.gitted/objects/21/a96a98ed84d45866e1de6e266fd3a61a4ae9dc
new file mode 100644
index 000000000..95842dbf8
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/21/a96a98ed84d45866e1de6e266fd3a61a4ae9dc differ
diff --git a/tests/resources/revert/.gitted/objects/39/9fb3aba3d9d13f7d40a9254ce4402067ef3149 b/tests/resources/revert/.gitted/objects/39/9fb3aba3d9d13f7d40a9254ce4402067ef3149
new file mode 100644
index 000000000..6cb6839d6
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/39/9fb3aba3d9d13f7d40a9254ce4402067ef3149
@@ -0,0 +1,2 @@
+x
¥ŽK!]s
+. á;@bŒoàzºA\0mŒ×Ïàª<äÖžC§£ç,3Ød@û ¢_ÑDò	@§K6Å—5Tâ=oS$çT1«Õ.�%@zªQ["-—D	x�Ê]Þè�ä½rÛy“ç<éo]Û;ï\Æ	¹]¤¶1Y�üåQE¥Ä¤óèÈ$l<ê,`…í‘ÅaGNÅ
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/46/ff0854663aeb2182b9838c8da68e33ac23bc1e b/tests/resources/revert/.gitted/objects/46/ff0854663aeb2182b9838c8da68e33ac23bc1e
new file mode 100644
index 000000000..7064dab52
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/46/ff0854663aeb2182b9838c8da68e33ac23bc1e differ
diff --git a/tests/resources/revert/.gitted/objects/5c/f1d643f100d8112834e540264546ba2c159976 b/tests/resources/revert/.gitted/objects/5c/f1d643f100d8112834e540264546ba2c159976
new file mode 100644
index 000000000..dbbf711b5
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/5c/f1d643f100d8112834e540264546ba2c159976 differ
diff --git a/tests/resources/revert/.gitted/objects/6b/ccd0dc58cea5ccff86014f3d64b31bd8c02a37 b/tests/resources/revert/.gitted/objects/6b/ccd0dc58cea5ccff86014f3d64b31bd8c02a37
new file mode 100644
index 000000000..2664da480
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/6b/ccd0dc58cea5ccff86014f3d64b31bd8c02a37 differ
diff --git a/tests/resources/revert/.gitted/objects/71/eb9c2b53dbbf3c45fb28b27c850db4b7fb8011 b/tests/resources/revert/.gitted/objects/71/eb9c2b53dbbf3c45fb28b27c850db4b7fb8011
new file mode 100644
index 000000000..995a1e626
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/71/eb9c2b53dbbf3c45fb28b27c850db4b7fb8011 differ
diff --git a/tests/resources/revert/.gitted/objects/87/59ad453cf01cf7daf14e2a668f8218f9a678eb b/tests/resources/revert/.gitted/objects/87/59ad453cf01cf7daf14e2a668f8218f9a678eb
new file mode 100644
index 000000000..ab19acf83
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/87/59ad453cf01cf7daf14e2a668f8218f9a678eb differ
diff --git a/tests/resources/revert/.gitted/objects/9a/95fd974e03c5b93828ceedd28755965b5d5c60 b/tests/resources/revert/.gitted/objects/9a/95fd974e03c5b93828ceedd28755965b5d5c60
new file mode 100644
index 000000000..bb93a34bb
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/9a/95fd974e03c5b93828ceedd28755965b5d5c60 differ
diff --git a/tests/resources/revert/.gitted/objects/a8/c86221b400b836010567cc3593db6e96c1a83a b/tests/resources/revert/.gitted/objects/a8/c86221b400b836010567cc3593db6e96c1a83a
new file mode 100644
index 000000000..29654616e
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/a8/c86221b400b836010567cc3593db6e96c1a83a differ
diff --git a/tests/resources/revert/.gitted/objects/ac/c4d33902092efeb3b714aa0b1007c329e2f2e6 b/tests/resources/revert/.gitted/objects/ac/c4d33902092efeb3b714aa0b1007c329e2f2e6
new file mode 100644
index 000000000..91bb68b41
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/ac/c4d33902092efeb3b714aa0b1007c329e2f2e6
@@ -0,0 +1,2 @@
+x
�Í[
+1@QßJW‘
étÒ6 F,LâþWàßý8peé½ø1llU.L�ÊiTB‡<dQ­uȉˆ#MTI"ºò¶ç²Âv·?OçË7ঽ´ù>dN�0z¸"!:ùMLÿ䮽š¹õ$Î
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/b6/9d88e177455579896e2be495046e2a51456a9a b/tests/resources/revert/.gitted/objects/b6/9d88e177455579896e2be495046e2a51456a9a
new file mode 100644
index 000000000..a5f69f2c8
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/b6/9d88e177455579896e2be495046e2a51456a9a
@@ -0,0 +1 @@
+x
¥�]j!…ûì*.yoÐÑ™{…RòÒ
„l@½NF¨ZÔ´Ûï$Ù@¡o‡�Ãù	5ç4@+z-FP¤œó2{�ÞH¶n"³zƒZ‹R.<£´J|¹Ë€‰�‘ëäµ2Èš:V’fRÚ ñ´Xž�aánc«
>øÇ5†ËVs¯ÞâNïê”Shµ×uCÍï 4Yk‹¯’¤;݇Žø�qŽß±
8„ZÖÏF*W›+×ØB\¶Ô¡=,žu¾w¿‡ödÞ
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/ca/f99de3a49827117bb66721010eac461b06a80c b/tests/resources/revert/.gitted/objects/ca/f99de3a49827117bb66721010eac461b06a80c
new file mode 100644
index 000000000..7f6f4e0c6
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/ca/f99de3a49827117bb66721010eac461b06a80c differ
diff --git a/tests/resources/revert/.gitted/objects/de/03538407ed18914ff05657eeff70425c0f304d b/tests/resources/revert/.gitted/objects/de/03538407ed18914ff05657eeff70425c0f304d
new file mode 100644
index 000000000..e651676fd
--- /dev/null
+++ b/tests/resources/revert/.gitted/objects/de/03538407ed18914ff05657eeff70425c0f304d
@@ -0,0 +1,2 @@
+x
¥Ž]J1„}Î)š}wéIw~D|ñ²H:vÀl–LÔë;ê|)Šú ª¤·¶M æPLeY�uY}‰’Ô©+šmXÅ2g0‡.˜{z›,U…5’_¼'¬•ò!Ê‚5i!agÒǼö
¯å+�—ko{¿Á“é�{i›Œ¾÷:ÏÒÛ3,×u
H1"š#=ŽNýG…yÓONûÖîï
+Z¶y2ærÝv¿h‡¿(Ka¤b­dµìV[‚u•ÙFrRÙWõ(1ÉÙ|_c&
\ No newline at end of file
diff --git a/tests/resources/revert/.gitted/objects/e3/4ef1afe54eb526fd92eec66084125f340f1d65 b/tests/resources/revert/.gitted/objects/e3/4ef1afe54eb526fd92eec66084125f340f1d65
new file mode 100644
index 000000000..fc19ebd3d
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/e3/4ef1afe54eb526fd92eec66084125f340f1d65 differ
diff --git a/tests/resources/revert/.gitted/objects/ea/392a157085bc32daccd59aa1998fe2f5fb9fc0 b/tests/resources/revert/.gitted/objects/ea/392a157085bc32daccd59aa1998fe2f5fb9fc0
new file mode 100644
index 000000000..1451a6ac4
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/ea/392a157085bc32daccd59aa1998fe2f5fb9fc0 differ
diff --git a/tests/resources/revert/.gitted/objects/ee/c6adcb2f3ceca0cadeccfe01b19382252ece9b b/tests/resources/revert/.gitted/objects/ee/c6adcb2f3ceca0cadeccfe01b19382252ece9b
new file mode 100644
index 000000000..f59f3d48d
Binary files /dev/null and b/tests/resources/revert/.gitted/objects/ee/c6adcb2f3ceca0cadeccfe01b19382252ece9b differ
diff --git a/tests/resources/revert/.gitted/refs/heads/master b/tests/resources/revert/.gitted/refs/heads/master
index d3850daa6..180f407e3 100644
--- a/tests/resources/revert/.gitted/refs/heads/master
+++ b/tests/resources/revert/.gitted/refs/heads/master
@@ -1 +1 @@
-2d440f2b3147d3dc7ad1085813478d6d869d5a4d
+2d440f2b3147d3dc7ad1085813478d6d869d5a4d
diff --git a/tests/resources/revert/.gitted/refs/heads/two b/tests/resources/revert/.gitted/refs/heads/two
new file mode 100644
index 000000000..f31ec00e5
--- /dev/null
+++ b/tests/resources/revert/.gitted/refs/heads/two
@@ -0,0 +1 @@
+e34ef1afe54eb526fd92eec66084125f340f1d65
diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
index 9dc72a9a8..bca1ff926 100644
--- a/tests/revert/workdir.c
+++ b/tests/revert/workdir.c
@@ -137,6 +137,203 @@ void test_revert_workdir__orphan(void)
 	git_commit_free(head);
 }
 
+/*
+ * revert the same commit twice (when the first reverts cleanly):
+ *
+ * git revert 2d440f2
+ * git revert 2d440f2
+ */
+void test_revert_workdir__again(void)
+{
+	git_reference *head_ref;
+	git_commit *orig_head;
+	git_tree *reverted_tree;
+	git_oid reverted_tree_oid, reverted_commit_oid;
+	git_signature *signature;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	cl_git_pass(git_repository_head(&head_ref, repo));
+	cl_git_pass(git_reference_peel((git_object **)&orig_head, head_ref, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, (git_object *)orig_head, GIT_RESET_HARD));
+
+	cl_git_pass(git_revert(repo, orig_head, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+
+	cl_git_pass(git_index_write_tree(&reverted_tree_oid, repo_index));
+	cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid));
+
+	cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0));
+	cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&orig_head));
+
+	cl_git_pass(git_revert(repo, orig_head, NULL));
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+
+	git_signature_free(signature);
+	git_tree_free(reverted_tree);
+	git_commit_free(orig_head);
+	git_reference_free(head_ref);
+}
+
+/* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45
+ * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */
+void test_revert_workdir__again_after_automerge(void)
+{
+	git_commit *head, *commit;
+	git_tree *reverted_tree;
+	git_oid head_oid, revert_oid, reverted_tree_oid, reverted_commit_oid;
+	git_signature *signature;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	struct merge_index_entry second_revert_entries[] = {
+		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 1, "file1.txt" },
+		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 2, "file1.txt" },
+		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 3, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+
+	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+
+	cl_git_pass(git_index_write_tree(&reverted_tree_oid, repo_index));
+	cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid));
+
+	cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0));
+	cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&head));
+
+	cl_git_pass(git_revert(repo, commit, NULL));
+	cl_assert(merge_test_index(repo_index, second_revert_entries, 6));
+
+	git_signature_free(signature);
+	git_tree_free(reverted_tree);
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/*
+ * revert the same commit twice (when the first reverts cleanly):
+ *
+ * git revert 2d440f2
+ * git revert 2d440f2
+ */
+void test_revert_workdir__again_after_edit(void)
+{
+	git_reference *head_ref;
+	git_commit *orig_head, *commit;
+	git_tree *reverted_tree;
+	git_oid orig_head_oid, revert_oid, reverted_tree_oid, reverted_commit_oid;
+	git_signature *signature;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "3721552e06c4bdc7d478e0674e6304888545d5fd", 0, "file1.txt" },
+		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
+		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
+		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
+	};
+
+	cl_git_pass(git_repository_head(&head_ref, repo));
+
+	cl_git_pass(git_oid_fromstr(&orig_head_oid, "399fb3aba3d9d13f7d40a9254ce4402067ef3149"));
+	cl_git_pass(git_commit_lookup(&orig_head, repo, &orig_head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)orig_head, GIT_RESET_HARD));
+
+	cl_git_pass(git_oid_fromstr(&revert_oid, "2d440f2b3147d3dc7ad1085813478d6d869d5a4d"));
+	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
+
+	cl_git_pass(git_revert(repo, commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+
+	cl_git_pass(git_index_write_tree(&reverted_tree_oid, repo_index));
+	cl_git_pass(git_tree_lookup(&reverted_tree, repo, &reverted_tree_oid));
+
+	cl_git_pass(git_signature_new(&signature, "Reverter", "reverter@example.org", time(NULL), 0));
+	cl_git_pass(git_commit_create(&reverted_commit_oid, repo, "HEAD", signature, signature, NULL, "Reverted!", reverted_tree, 1, (const git_commit **)&orig_head));
+
+	cl_git_pass(git_revert(repo, commit, NULL));
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
+
+	git_signature_free(signature);
+	git_tree_free(reverted_tree);
+	git_commit_free(commit);
+	git_commit_free(orig_head);
+	git_reference_free(head_ref);
+}
+
+/*
+ * revert the same commit twice (when the first reverts cleanly):
+ *
+ * git reset --hard e34ef1a
+ * git revert 71eb9c2
+ */
+void test_revert_workdir__again_after_edit_two(void)
+{
+	git_buf diff_buf = GIT_BUF_INIT;
+	git_config *config;
+	git_oid head_commit_oid, revert_commit_oid;
+	git_commit *head_commit, *revert_commit;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "1ff0c423042b46cb1d617b81efb715defbe8054d", 0, ".gitattributes" },
+		{ 0100644, "1bc915c5cb7185a9438de28a7b1a7dfe8c01ee7f", 0, ".gitignore" },
+		{ 0100644, "a8c86221b400b836010567cc3593db6e96c1a83a", 1, "file.txt" },
+		{ 0100644, "46ff0854663aeb2182b9838c8da68e33ac23bc1e", 2, "file.txt" },
+		{ 0100644, "21a96a98ed84d45866e1de6e266fd3a61a4ae9dc", 3, "file.txt" },
+	};
+
+	cl_git_pass(git_repository_config(&config, repo));
+	cl_git_pass(git_config_set_bool(config, "core.autocrlf", 0));
+
+	cl_git_pass(git_oid_fromstr(&head_commit_oid, "e34ef1afe54eb526fd92eec66084125f340f1d65"));
+	cl_git_pass(git_commit_lookup(&head_commit, repo, &head_commit_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD));
+
+	cl_git_pass(git_oid_fromstr(&revert_commit_oid, "71eb9c2b53dbbf3c45fb28b27c850db4b7fb8011"));
+	cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_commit_oid));
+
+	cl_git_pass(git_revert(repo, revert_commit, NULL));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 5));
+
+	cl_git_pass(git_futils_readbuffer(&diff_buf, "revert/file.txt"));
+	cl_assert(strcmp(diff_buf.ptr,	"a\n" \
+		"<<<<<<< HEAD\n" \
+		"=======\n" \
+		"a\n" \
+		">>>>>>> parent of 71eb9c2... revert me\n" \
+		"a\n" \
+		"a\n" \
+		"a\n" \
+		"a\n" \
+		"ab\n") == 0);
+
+	git_commit_free(revert_commit);
+	git_commit_free(head_commit);
+	git_config_free(config);
+	git_buf_free(&diff_buf);
+}
+
 /* git reset --hard 72333f47d4e83616630ff3b0ffe4c0faebcc3c45
  * git revert --no-commit d1d403d22cbe24592d725f442835cf46fe60c8ac */
 void test_revert_workdir__conflict_use_ours(void)
@@ -161,7 +358,7 @@ void test_revert_workdir__conflict_use_ours(void)
 		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
 	};
 
-	opts.merge_tree_opts.automerge_flags = GIT_MERGE_AUTOMERGE_NONE;
+	opts.merge_tree_opts.file_favor = GIT_MERGE_FILE_FAVOR_NO_MERGE;
 	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
 
 	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
-- 
cgit v1.2.3


From 6b92c99bcbf32de131754a4f750278f84bf5b766 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 19 Jan 2014 01:20:25 -0800
Subject: Don't try to merge binary files

---
 src/checkout.c                                     |  47 ++++++++++++++++++++-
 src/merge.c                                        |  43 +++++++++++++++++++
 src/merge.h                                        |   2 +
 tests/merge/workdir/simple.c                       |  37 ++++++++++++++++
 .../11/aeee27ac45a8402c2fd5b875d66dd844e5df00      | Bin 0 -> 51 bytes
 .../1c/51d885170f57a0c4e8c69ff6363d91a5b51f85      | Bin 0 -> 30 bytes
 .../23/ed141a6ae1e798b2f721afedbe947c119111ba      | Bin 0 -> 30 bytes
 .../34/8dcd41e2b467991578e92bedd16971b877ef1e      | Bin 0 -> 51 bytes
 .../6e/3b9eb35214d4e31ed5789afc7d520ac798ce55      | Bin 0 -> 51 bytes
 .../83/6b8b82b26cab22eaaed8820877c76d6c8bca19      | Bin 0 -> 30 bytes
 .../ad/01aebfdf2ac13145efafe3f9fcf798882f1730      | Bin 0 -> 158 bytes
 .../cc/338e4710c9b257106b8d16d82f86458d5beaf1      |   2 +
 .../d7/308cc367b2cc23f710834ec1fd8ffbacf1b460      |   1 +
 13 files changed, 130 insertions(+), 2 deletions(-)
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/11/aeee27ac45a8402c2fd5b875d66dd844e5df00
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/1c/51d885170f57a0c4e8c69ff6363d91a5b51f85
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/23/ed141a6ae1e798b2f721afedbe947c119111ba
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/34/8dcd41e2b467991578e92bedd16971b877ef1e
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/6e/3b9eb35214d4e31ed5789afc7d520ac798ce55
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/83/6b8b82b26cab22eaaed8820877c76d6c8bca19
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/ad/01aebfdf2ac13145efafe3f9fcf798882f1730
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/cc/338e4710c9b257106b8d16d82f86458d5beaf1
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/d7/308cc367b2cc23f710834ec1fd8ffbacf1b460

diff --git a/src/checkout.c b/src/checkout.c
index cc49800a2..f64aa9a77 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -70,7 +70,8 @@ typedef struct {
 
 	int name_collision:1,
 		directoryfile:1,
-		one_to_two:1;
+		one_to_two:1,
+		binary:1;
 } checkout_conflictdata;
 
 static int checkout_notify(
@@ -681,6 +682,40 @@ GIT_INLINE(bool) conflict_pathspec_match(
 	return false;
 }
 
+GIT_INLINE(int) checkout_conflict_detect_binary(git_repository *repo, checkout_conflictdata *conflict)
+{
+	git_blob *ancestor_blob = NULL, *our_blob = NULL, *their_blob = NULL;
+	int error = 0;
+
+	if (conflict->ancestor) {
+		if ((error = git_blob_lookup(&ancestor_blob, repo, &conflict->ancestor->oid)) < 0)
+			goto done;
+
+		conflict->binary = git_blob_is_binary(ancestor_blob);
+	}
+
+	if (!conflict->binary && conflict->ours) {
+		if ((error = git_blob_lookup(&our_blob, repo, &conflict->ours->oid)) < 0)
+			goto done;
+
+		conflict->binary = git_blob_is_binary(our_blob);
+	}
+
+	if (!conflict->binary && conflict->theirs) {
+		if ((error = git_blob_lookup(&their_blob, repo, &conflict->theirs->oid)) < 0)
+			goto done;
+
+		conflict->binary = git_blob_is_binary(their_blob);
+	}
+
+done:
+	git_blob_free(ancestor_blob);
+	git_blob_free(our_blob);
+	git_blob_free(their_blob);
+
+	return error;
+}
+
 static int checkout_conflicts_load(checkout_data *data, git_iterator *workdir, git_vector *pathspec)
 {
 	git_index_conflict_iterator *iterator = NULL;
@@ -705,6 +740,9 @@ static int checkout_conflicts_load(checkout_data *data, git_iterator *workdir, g
 		conflict->ours = ours;
 		conflict->theirs = theirs;
 
+		if ((error = checkout_conflict_detect_binary(data->repo, conflict)) < 0)
+			goto done;
+
 		git_vector_insert(&data->conflicts, conflict);
 	}
 
@@ -1706,6 +1744,7 @@ static int checkout_create_conflicts(checkout_data *data)
 	int error = 0;
 
 	git_vector_foreach(&data->conflicts, i, conflict) {
+
 		/* Both deleted: nothing to do */
 		if (conflict->ours == NULL && conflict->theirs == NULL)
 			error = 0;
@@ -1749,7 +1788,11 @@ static int checkout_create_conflicts(checkout_data *data)
 		else if (S_ISLNK(conflict->theirs->mode))
 			error = checkout_write_entry(data, conflict, conflict->ours);
 
-		else
+		/* If any side is binary, write the ours side */
+		else if (conflict->binary)
+			error = checkout_write_entry(data, conflict, conflict->ours);
+
+		else if (!error)
 			error = checkout_write_merge(data, conflict);
 
 		if (error)
diff --git a/src/merge.c b/src/merge.c
index 3ac9167e3..124befc14 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -551,6 +551,10 @@ static int merge_conflict_resolve_automerge(
 		strcmp(conflict->ancestor_entry.path, conflict->their_entry.path) != 0)
 		return 0;
 
+	/* Reject binary conflicts */
+	if (conflict->binary)
+		return 0;
+
 	if ((error = git_repository_odb(&odb, diff_list->repo)) < 0 ||
 		(error = git_merge_file_input_from_index_entry(&ancestor, diff_list->repo, &conflict->ancestor_entry)) < 0 ||
 		(error = git_merge_file_input_from_index_entry(&ours, diff_list->repo, &conflict->our_entry)) < 0 ||
@@ -1150,6 +1154,44 @@ GIT_INLINE(int) merge_diff_detect_type(
 	return 0;
 }
 
+GIT_INLINE(int) merge_diff_detect_binary(
+	git_repository *repo,
+	git_merge_diff *conflict)
+{
+	git_blob *ancestor_blob = NULL, *our_blob = NULL, *their_blob = NULL;
+	int error = 0;
+
+	if (GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->ancestor_entry)) {
+		if ((error = git_blob_lookup(&ancestor_blob, repo, &conflict->ancestor_entry.oid)) < 0)
+			goto done;
+
+		conflict->binary = git_blob_is_binary(ancestor_blob);
+	}
+
+	if (!conflict->binary &&
+		GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry)) {
+		if ((error = git_blob_lookup(&our_blob, repo, &conflict->our_entry.oid)) < 0)
+			goto done;
+
+		conflict->binary = git_blob_is_binary(our_blob);
+	}
+
+	if (!conflict->binary &&
+		GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry)) {
+		if ((error = git_blob_lookup(&their_blob, repo, &conflict->their_entry.oid)) < 0)
+			goto done;
+
+		conflict->binary = git_blob_is_binary(their_blob);
+	}
+
+done:
+	git_blob_free(ancestor_blob);
+	git_blob_free(our_blob);
+	git_blob_free(their_blob);
+
+	return error;
+}
+
 GIT_INLINE(int) index_entry_dup(
 	git_index_entry *out,
 	git_pool *pool,
@@ -1221,6 +1263,7 @@ static int merge_diff_list_insert_conflict(
 	if ((conflict = merge_diff_from_index_entries(diff_list, tree_items)) == NULL ||
 		merge_diff_detect_type(conflict) < 0 ||
 		merge_diff_detect_df_conflict(merge_df_data, conflict) < 0 ||
+		merge_diff_detect_binary(diff_list->repo, conflict) < 0 ||
 		git_vector_insert(&diff_list->conflicts, conflict) < 0)
 		return -1;
 
diff --git a/src/merge.h b/src/merge.h
index b240f6c44..dda023528 100644
--- a/src/merge.h
+++ b/src/merge.h
@@ -106,6 +106,8 @@ typedef struct {
 
 	git_index_entry their_entry;
 	git_delta_t their_status;
+
+	int binary:1;
 } git_merge_diff;
 
 /** Internal structure for merge inputs */
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 2142fc4f9..d4f387a26 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -489,3 +489,40 @@ void test_merge_workdir_simple__unrelated_with_conflicts(void)
 	git_merge_result_free(result);
 }
 
+void test_merge_workdir_simple__binary(void)
+{
+	git_oid our_oid, their_oid, our_file_oid;
+	git_commit *our_commit;
+	git_merge_head *their_head;
+	git_merge_result *result;
+	const git_index_entry *binary_entry;
+	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "1c51d885170f57a0c4e8c69ff6363d91a5b51f85", 1, "binary" },
+		{ 0100644, "23ed141a6ae1e798b2f721afedbe947c119111ba", 2, "binary" },
+		{ 0100644, "836b8b82b26cab22eaaed8820877c76d6c8bca19", 3, "binary" },
+	};
+
+	cl_git_pass(git_oid_fromstr(&our_oid, "cc338e4710c9b257106b8d16d82f86458d5beaf1"));
+	cl_git_pass(git_oid_fromstr(&their_oid, "ad01aebfdf2ac13145efafe3f9fcf798882f1730"));
+
+	cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid));
+	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD));
+
+	cl_git_pass(git_merge_head_from_oid(&their_head, repo, &their_oid));
+
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
+
+	cl_git_pass(git_index_add_bypath(repo_index, "binary"));
+	cl_assert((binary_entry = git_index_get_bypath(repo_index, "binary", 0)) != NULL);
+
+	cl_git_pass(git_oid_fromstr(&our_file_oid, "23ed141a6ae1e798b2f721afedbe947c119111ba"));
+	cl_assert(git_oid_cmp(&binary_entry->oid, &our_file_oid) == 0);
+
+	git_merge_head_free(their_head);
+	git_merge_result_free(result);
+	git_commit_free(our_commit);
+}
diff --git a/tests/resources/merge-resolve/.gitted/objects/11/aeee27ac45a8402c2fd5b875d66dd844e5df00 b/tests/resources/merge-resolve/.gitted/objects/11/aeee27ac45a8402c2fd5b875d66dd844e5df00
new file mode 100644
index 000000000..90e729f6d
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/11/aeee27ac45a8402c2fd5b875d66dd844e5df00 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/1c/51d885170f57a0c4e8c69ff6363d91a5b51f85 b/tests/resources/merge-resolve/.gitted/objects/1c/51d885170f57a0c4e8c69ff6363d91a5b51f85
new file mode 100644
index 000000000..9a21e26c0
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/1c/51d885170f57a0c4e8c69ff6363d91a5b51f85 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/23/ed141a6ae1e798b2f721afedbe947c119111ba b/tests/resources/merge-resolve/.gitted/objects/23/ed141a6ae1e798b2f721afedbe947c119111ba
new file mode 100644
index 000000000..06dee3b23
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/23/ed141a6ae1e798b2f721afedbe947c119111ba differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/34/8dcd41e2b467991578e92bedd16971b877ef1e b/tests/resources/merge-resolve/.gitted/objects/34/8dcd41e2b467991578e92bedd16971b877ef1e
new file mode 100644
index 000000000..fd61b6ce5
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/34/8dcd41e2b467991578e92bedd16971b877ef1e differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/6e/3b9eb35214d4e31ed5789afc7d520ac798ce55 b/tests/resources/merge-resolve/.gitted/objects/6e/3b9eb35214d4e31ed5789afc7d520ac798ce55
new file mode 100644
index 000000000..c6100cb01
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/6e/3b9eb35214d4e31ed5789afc7d520ac798ce55 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/83/6b8b82b26cab22eaaed8820877c76d6c8bca19 b/tests/resources/merge-resolve/.gitted/objects/83/6b8b82b26cab22eaaed8820877c76d6c8bca19
new file mode 100644
index 000000000..99f828649
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/83/6b8b82b26cab22eaaed8820877c76d6c8bca19 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/ad/01aebfdf2ac13145efafe3f9fcf798882f1730 b/tests/resources/merge-resolve/.gitted/objects/ad/01aebfdf2ac13145efafe3f9fcf798882f1730
new file mode 100644
index 000000000..ae3ef8ce3
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/ad/01aebfdf2ac13145efafe3f9fcf798882f1730 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/cc/338e4710c9b257106b8d16d82f86458d5beaf1 b/tests/resources/merge-resolve/.gitted/objects/cc/338e4710c9b257106b8d16d82f86458d5beaf1
new file mode 100644
index 000000000..85b3b8112
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/objects/cc/338e4710c9b257106b8d16d82f86458d5beaf1
@@ -0,0 +1,2 @@
+x
¥ŽK!]sŠ¾€†æ3`bŒoà »ÉÌ1Æë‹gpW©E½G­Öm€±x]“ˆ˜�Èù�6d
+ûƒçeaŽÎ‰ç¢µz¥.Ï
¬ŽDv	Ù[êh�Ž¥äD³[´Jﱶwþ¤ÎðX[ÝÛ.2í�nu£ÞöVƉZ½Ú³F´!x8ê8÷¦�G‡ü‘PÂÛP_’?KN
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/objects/d7/308cc367b2cc23f710834ec1fd8ffbacf1b460 b/tests/resources/merge-resolve/.gitted/objects/d7/308cc367b2cc23f710834ec1fd8ffbacf1b460
new file mode 100644
index 000000000..b02cda4fa
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/objects/d7/308cc367b2cc23f710834ec1fd8ffbacf1b460
@@ -0,0 +1 @@
+x
¥�K @]sŠ¹€†)Ð�Ä7ÞÀð™¦]ÐI(Æx{ñî^Þâ½,µnлSoÌ`¬/¹Xä)Ù™B@GžÃ”¸œaòD¼ «øê«4x”wlž«ÔCv¸ò°?º×-79dé—,õh‚F4Žœµ×Z
;Æ�ÿH¨´í±}Ô·š= 
\ No newline at end of file
-- 
cgit v1.2.3


From e651e8e2b5c5eb021448fb0f0a36cb3f10fa9326 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 19 Jan 2014 15:05:08 -0800
Subject: Introduce diff3 mode for checking out conflicts

---
 include/git2/checkout.h      |  7 +++++++
 src/checkout.c               |  5 ++++-
 src/merge.c                  | 24 +++++++++++++++++-----
 src/merge_file.c             |  3 +++
 src/merge_file.h             |  9 ++++++++
 tests/merge/workdir/simple.c | 49 +++++++++++++++++++++++++++++++++++++++++++-
 6 files changed, 90 insertions(+), 7 deletions(-)

diff --git a/include/git2/checkout.h b/include/git2/checkout.h
index b94a5e2ff..0faf4ab14 100644
--- a/include/git2/checkout.h
+++ b/include/git2/checkout.h
@@ -152,6 +152,12 @@ typedef enum {
 	/** Don't overwrite ignored files that exist in the checkout target */
 	GIT_CHECKOUT_DONT_OVERWRITE_IGNORED = (1u << 19),
 
+	/** Write normal merge files for conflicts */
+	GIT_CHECKOUT_CONFLICT_STYLE_MERGE = (1u << 20),
+
+	/** Include common ancestor data in diff3 format files for conflicts */
+	GIT_CHECKOUT_CONFLICT_STYLE_DIFF3 = (1u << 21),
+
 	/**
 	 * THE FOLLOWING OPTIONS ARE NOT YET IMPLEMENTED
 	 */
@@ -252,6 +258,7 @@ typedef struct git_checkout_opts {
 
 	const char *target_directory; /** alternative checkout path to workdir */
 
+	const char *ancestor_label; /** the name of the common ancestor side of conflicts */
 	const char *our_label; /** the name of the "our" side of conflicts */
 	const char *their_label; /** the name of the "their" side of conflicts */
 } git_checkout_opts;
diff --git a/src/checkout.c b/src/checkout.c
index f64aa9a77..fcc0f872a 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -1672,6 +1672,9 @@ static int checkout_write_merge(
 	git_filebuf output = GIT_FILEBUF_INIT;
 	int error = 0;
 
+	if (data->opts.checkout_strategy & GIT_CHECKOUT_CONFLICT_STYLE_DIFF3)
+		merge_file_opts.style = GIT_MERGE_FILE_STYLE_DIFF3;
+
 	if ((conflict->ancestor &&
 		(error = git_merge_file_input_from_index_entry(
 		&ancestor, data->repo, conflict->ancestor)) < 0) ||
@@ -1681,7 +1684,7 @@ static int checkout_write_merge(
 		&theirs, data->repo, conflict->theirs)) < 0)
 		goto done;
 
-	ancestor.label = NULL;
+	ancestor.label = data->opts.ancestor_label ? data->opts.ancestor_label : "ancestor";
 	ours.label = data->opts.our_label ? data->opts.our_label : "ours";
 	theirs.label = data->opts.their_label ? data->opts.their_label : "theirs";
 
diff --git a/src/merge.c b/src/merge.c
index 124befc14..8554bf02b 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2165,6 +2165,8 @@ static int merge_normalize_opts(
 	git_repository *repo,
 	git_merge_opts *opts,
 	const git_merge_opts *given,
+	const git_merge_head *ancestor_head,
+	const git_merge_head *our_head,
 	size_t their_heads_len,
 	const git_merge_head **their_heads)
 {
@@ -2184,8 +2186,20 @@ static int merge_normalize_opts(
 	if (!opts->checkout_opts.checkout_strategy)
 		opts->checkout_opts.checkout_strategy = default_checkout_strategy;
 
-	if (!opts->checkout_opts.our_label)
-		opts->checkout_opts.our_label = "HEAD";
+	/* TODO: for multiple ancestors in merge-recursive, this is "merged common ancestors" */
+	if (!opts->checkout_opts.ancestor_label) {
+		if (ancestor_head && ancestor_head->commit)
+			opts->checkout_opts.ancestor_label = git_commit_summary(ancestor_head->commit);
+		else
+			opts->checkout_opts.ancestor_label = "ancestor";
+	}
+
+	if (!opts->checkout_opts.our_label) {
+		if (our_head && our_head->ref_name)
+			opts->checkout_opts.our_label = our_head->ref_name;
+		else
+			opts->checkout_opts.our_label = "ours";
+	}
 
 	if (!opts->checkout_opts.their_label) {
 		if (their_heads_len == 1 && their_heads[0]->ref_name)
@@ -2480,9 +2494,6 @@ int git_merge(
 	their_trees = git__calloc(their_heads_len, sizeof(git_tree *));
 	GITERR_CHECK_ALLOC(their_trees);
 
-	if ((error = merge_normalize_opts(repo, &opts, given_opts, their_heads_len, their_heads)) < 0)
-		goto on_error;
-
 	if ((error = git_repository__ensure_not_bare(repo, "merge")) < 0)
 		goto on_error;
 
@@ -2494,6 +2505,9 @@ int git_merge(
 		error != GIT_ENOTFOUND)
 		goto on_error;
 
+	if ((error = merge_normalize_opts(repo, &opts, given_opts, ancestor_head, our_head, their_heads_len, their_heads)) < 0)
+		goto on_error;
+
 	if (their_heads_len == 1 &&
 		ancestor_head != NULL &&
 		(merge_check_uptodate(result, ancestor_head, their_heads[0]) ||
diff --git a/src/merge_file.c b/src/merge_file.c
index d13190276..fb0e29960 100644
--- a/src/merge_file.c
+++ b/src/merge_file.c
@@ -161,6 +161,9 @@ int git_merge_files(
 		(opts && (opts->flags & GIT_MERGE_FILE_SIMPLIFY_ALNUM)) ?
 		XDL_MERGE_ZEALOUS_ALNUM : XDL_MERGE_ZEALOUS;
 
+	if (opts && opts->style == GIT_MERGE_FILE_STYLE_DIFF3)
+		xmparam.style = XDL_MERGE_DIFF3;
+
 	if ((xdl_result = xdl_merge(&ancestor->mmfile, &ours->mmfile,
 		&theirs->mmfile, &xmparam, &mmbuffer)) < 0) {
 		giterr_set(GITERR_MERGE, "Failed to merge files.");
diff --git a/src/merge_file.h b/src/merge_file.h
index 5d7ea9752..332be490b 100644
--- a/src/merge_file.h
+++ b/src/merge_file.h
@@ -39,9 +39,18 @@ typedef enum {
 	GIT_MERGE_FILE_SIMPLIFY_ALNUM = (1 << 0),
 } git_merge_file_flags_t;
 
+typedef enum {
+	/* Create standard conflicted merge files */
+	GIT_MERGE_FILE_STYLE_MERGE = 0,
+
+	/* Create diff3-style files */
+	GIT_MERGE_FILE_STYLE_DIFF3 = 1,
+} git_merge_file_style_t;
+
 typedef struct {
 	git_merge_file_favor_t favor;
 	git_merge_file_flags_t flags;
+	git_merge_file_style_t style;
 } git_merge_file_options;
 
 #define GIT_MERGE_FILE_OPTIONS_INIT	{0}
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index d4f387a26..40a07d5e7 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -93,9 +93,18 @@ static git_index *repo_index;
 	"this file is automergeable\r\n" \
 	"this file is changed in branch\r\n"
 
+#define CONFLICTING_MERGE_FILE \
+	"<<<<<<< HEAD\n" \
+	"this file is changed in master and branch\n" \
+	"=======\n" \
+	"this file is changed in branch and master\n" \
+	">>>>>>> 7cb63eed597130ba4abb87b3e544b85021905520\n"
+
 #define CONFLICTING_DIFF3_FILE \
 	"<<<<<<< HEAD\n" \
 	"this file is changed in master and branch\n" \
+	"||||||| initial\n" \
+	"this file is a conflict\n" \
 	"=======\n" \
 	"this file is changed in branch and master\n" \
 	">>>>>>> 7cb63eed597130ba4abb87b3e544b85021905520\n"
@@ -244,7 +253,7 @@ void test_merge_workdir_simple__automerge_crlf(void)
 #endif /* GIT_WIN32 */
 }
 
-void test_merge_workdir_simple__diff3(void)
+void test_merge_workdir_simple__mergefile(void)
 {
 	git_merge_result *result;
 	git_buf conflicting_buf = GIT_BUF_INIT;
@@ -271,6 +280,44 @@ void test_merge_workdir_simple__diff3(void)
 	cl_assert(result = merge_simple_branch(0, 0));
 	cl_assert(!git_merge_result_is_fastforward(result));
 
+	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
+		TEST_REPO_PATH "/conflicting.txt"));
+	cl_assert(strcmp(conflicting_buf.ptr, CONFLICTING_MERGE_FILE) == 0);
+	git_buf_free(&conflicting_buf);
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
+	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
+
+	git_merge_result_free(result);
+}
+
+void test_merge_workdir_simple__diff3(void)
+{
+	git_merge_result *result;
+	git_buf conflicting_buf = GIT_BUF_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		ADDED_IN_MASTER_INDEX_ENTRY,
+		AUTOMERGEABLE_INDEX_ENTRY,
+		CHANGED_IN_BRANCH_INDEX_ENTRY,
+		CHANGED_IN_MASTER_INDEX_ENTRY,
+
+		{ 0100644, "d427e0b2e138501a3d15cc376077a3631e15bd46", 1, "conflicting.txt" },
+		{ 0100644, "4e886e602529caa9ab11d71f86634bd1b6e0de10", 2, "conflicting.txt" },
+		{ 0100644, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", 3, "conflicting.txt" },
+
+		UNCHANGED_INDEX_ENTRY,
+	};
+
+	struct merge_reuc_entry merge_reuc_entries[] = {
+		AUTOMERGEABLE_REUC_ENTRY,
+		REMOVED_IN_BRANCH_REUC_ENTRY,
+		REMOVED_IN_MASTER_REUC_ENTRY
+	};
+
+	cl_assert(result = merge_simple_branch(0, GIT_CHECKOUT_CONFLICT_STYLE_DIFF3));
+	cl_assert(!git_merge_result_is_fastforward(result));
+
 	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
 		TEST_REPO_PATH "/conflicting.txt"));
 	cl_assert(strcmp(conflicting_buf.ptr, CONFLICTING_DIFF3_FILE) == 0);
-- 
cgit v1.2.3


From 6891a862bbde86f9262c4b367effb1e29d7c513b Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 19 Jan 2014 18:12:22 -0800
Subject: Load merge.conflictstyle setting from config

---
 src/checkout.c               | 23 ++++++++++++
 tests/merge/workdir/simple.c | 86 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 109 insertions(+)

diff --git a/src/checkout.c b/src/checkout.c
index fcc0f872a..960bc6140 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -1938,6 +1938,29 @@ static int checkout_data_init(
 			goto cleanup;
 	}
 
+	if ((data->opts.checkout_strategy &
+		(GIT_CHECKOUT_CONFLICT_STYLE_MERGE | GIT_CHECKOUT_CONFLICT_STYLE_DIFF3)) == 0) {
+		const char *conflict_style;
+		git_config *cfg = NULL;
+
+		if ((error = git_repository_config__weakptr(&cfg, repo)) < 0 ||
+			(error = git_config_get_string(&conflict_style, cfg, "merge.conflictstyle")) < 0 ||
+			error == GIT_ENOTFOUND)
+			;
+		else if (error)
+			goto cleanup;
+		else if (strcmp(conflict_style, "merge") == 0)
+			data->opts.checkout_strategy |= GIT_CHECKOUT_CONFLICT_STYLE_MERGE;
+		else if (strcmp(conflict_style, "diff3") == 0)
+			data->opts.checkout_strategy |= GIT_CHECKOUT_CONFLICT_STYLE_DIFF3;
+		else {
+			giterr_set(GITERR_CHECKOUT, "unknown style '%s' given for 'merge.conflictstyle'",
+				conflict_style);
+			error = -1;
+			goto cleanup;
+		}
+	}
+
 	if ((error = git_vector_init(&data->removes, 0, git__strcmp_cb)) < 0 ||
 		(error = git_vector_init(&data->conflicts, 0, NULL)) < 0 ||
 		(error = git_pool_init(&data->pool, 1, 0)) < 0 ||
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 40a07d5e7..757e20c6c 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -329,6 +329,92 @@ void test_merge_workdir_simple__diff3(void)
 	git_merge_result_free(result);
 }
 
+void test_merge_workdir_simple__diff3_from_config(void)
+{
+	git_merge_result *result;
+	git_config *config;
+	git_buf conflicting_buf = GIT_BUF_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		ADDED_IN_MASTER_INDEX_ENTRY,
+		AUTOMERGEABLE_INDEX_ENTRY,
+		CHANGED_IN_BRANCH_INDEX_ENTRY,
+		CHANGED_IN_MASTER_INDEX_ENTRY,
+
+		{ 0100644, "d427e0b2e138501a3d15cc376077a3631e15bd46", 1, "conflicting.txt" },
+		{ 0100644, "4e886e602529caa9ab11d71f86634bd1b6e0de10", 2, "conflicting.txt" },
+		{ 0100644, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", 3, "conflicting.txt" },
+
+		UNCHANGED_INDEX_ENTRY,
+	};
+
+	struct merge_reuc_entry merge_reuc_entries[] = {
+		AUTOMERGEABLE_REUC_ENTRY,
+		REMOVED_IN_BRANCH_REUC_ENTRY,
+		REMOVED_IN_MASTER_REUC_ENTRY
+	};
+
+	cl_git_pass(git_repository_config(&config, repo));
+	cl_git_pass(git_config_set_string(config, "merge.conflictstyle", "diff3"));
+
+	cl_assert(result = merge_simple_branch(0, 0));
+	cl_assert(!git_merge_result_is_fastforward(result));
+
+	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
+		TEST_REPO_PATH "/conflicting.txt"));
+	cl_assert(strcmp(conflicting_buf.ptr, CONFLICTING_DIFF3_FILE) == 0);
+	git_buf_free(&conflicting_buf);
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
+	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
+
+	git_merge_result_free(result);
+	git_config_free(config);
+}
+
+void test_merge_workdir_simple__merge_overrides_config(void)
+{
+	git_merge_result *result;
+	git_config *config;
+	git_buf conflicting_buf = GIT_BUF_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		ADDED_IN_MASTER_INDEX_ENTRY,
+		AUTOMERGEABLE_INDEX_ENTRY,
+		CHANGED_IN_BRANCH_INDEX_ENTRY,
+		CHANGED_IN_MASTER_INDEX_ENTRY,
+
+		{ 0100644, "d427e0b2e138501a3d15cc376077a3631e15bd46", 1, "conflicting.txt" },
+		{ 0100644, "4e886e602529caa9ab11d71f86634bd1b6e0de10", 2, "conflicting.txt" },
+		{ 0100644, "2bd0a343aeef7a2cf0d158478966a6e587ff3863", 3, "conflicting.txt" },
+
+		UNCHANGED_INDEX_ENTRY,
+	};
+
+	struct merge_reuc_entry merge_reuc_entries[] = {
+		AUTOMERGEABLE_REUC_ENTRY,
+		REMOVED_IN_BRANCH_REUC_ENTRY,
+		REMOVED_IN_MASTER_REUC_ENTRY
+	};
+
+	cl_git_pass(git_repository_config(&config, repo));
+	cl_git_pass(git_config_set_string(config, "merge.conflictstyle", "diff3"));
+
+	cl_assert(result = merge_simple_branch(0, GIT_CHECKOUT_CONFLICT_STYLE_MERGE));
+	cl_assert(!git_merge_result_is_fastforward(result));
+
+	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
+		TEST_REPO_PATH "/conflicting.txt"));
+	cl_assert(strcmp(conflicting_buf.ptr, CONFLICTING_MERGE_FILE) == 0);
+	git_buf_free(&conflicting_buf);
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
+	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
+
+	git_merge_result_free(result);
+	git_config_free(config);
+}
+
 void test_merge_workdir_simple__checkout_ours(void)
 {
 	git_merge_result *result;
-- 
cgit v1.2.3


From 0e1ba46cfbca0eec00d8af713fc2059158685381 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 19 Jan 2014 20:03:13 -0800
Subject: Remove the "merge none" flag

The "merge none" (don't automerge) flag was only to aide in
merge trivial tests.  We can easily determine whether merge
trivial resulted in a trivial merge or an automerge by examining
the REUC after automerge has completed.
---
 include/git2/merge.h          |   7 +--
 src/merge.c                   |  17 +++---
 tests/merge/trees/trivial.c   | 119 +++++-------------------------------------
 tests/merge/workdir/trivial.c | 104 +++++-------------------------------
 tests/revert/workdir.c        |   9 ++--
 5 files changed, 39 insertions(+), 217 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 1888babd1..c079ef9c2 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -38,14 +38,11 @@ typedef enum {
 	/* Produce a conflict in a file when two similar regions are changed. */
 	GIT_MERGE_FILE_FAVOR_NORMAL = 0,
 
-	/* Do not attempt to produce an automerged file during tree merge. */
-	GIT_MERGE_FILE_FAVOR_NO_MERGE = 1,
-
 	/* Produce a file containing the "ours" side of conflicting regions. */
-	GIT_MERGE_FILE_FAVOR_OURS = 2,
+	GIT_MERGE_FILE_FAVOR_OURS = 1,
 
 	/* Produce a file containing the "theirs" side of conflicting regions. */
-	GIT_MERGE_FILE_FAVOR_THEIRS = 3,
+	GIT_MERGE_FILE_FAVOR_THEIRS = 2,
 } git_merge_file_favor_t;
 
 
diff --git a/src/merge.c b/src/merge.c
index 8554bf02b..04c74212a 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -527,9 +527,6 @@ static int merge_conflict_resolve_automerge(
 
 	*resolved = 0;
 
-	if (merge_file_favor == GIT_MERGE_FILE_FAVOR_NO_MERGE)
-		return 0;
-
 	merge_file_opts.favor = merge_file_favor;
 
 	/* Reject D/F conflicts */
@@ -603,16 +600,14 @@ static int merge_conflict_resolve(
 	if ((error = merge_conflict_resolve_trivial(&resolved, diff_list, conflict)) < 0)
 		goto done;
 
-	if (merge_file_favor != GIT_MERGE_FILE_FAVOR_NO_MERGE) {
-		if (!resolved && (error = merge_conflict_resolve_one_removed(&resolved, diff_list, conflict)) < 0)
-			goto done;
+	if (!resolved && (error = merge_conflict_resolve_one_removed(&resolved, diff_list, conflict)) < 0)
+		goto done;
 
-		if (!resolved && (error = merge_conflict_resolve_one_renamed(&resolved, diff_list, conflict)) < 0)
-			goto done;
+	if (!resolved && (error = merge_conflict_resolve_one_renamed(&resolved, diff_list, conflict)) < 0)
+		goto done;
 
-		if (!resolved && (error = merge_conflict_resolve_automerge(&resolved, diff_list, conflict, merge_file_favor)) < 0)
-			goto done;
-	}
+	if (!resolved && (error = merge_conflict_resolve_automerge(&resolved, diff_list, conflict, merge_file_favor)) < 0)
+		goto done;
 
 	*out = resolved;
 
diff --git a/tests/merge/trees/trivial.c b/tests/merge/trees/trivial.c
index 244cd3223..2de187bf4 100644
--- a/tests/merge/trees/trivial.c
+++ b/tests/merge/trees/trivial.c
@@ -25,7 +25,7 @@ void test_merge_trees_trivial__cleanup(void)
 }
 
 
-static int merge_trivial(git_index **index, const char *ours, const char *theirs, bool automerge)
+static int merge_trivial(git_index **index, const char *ours, const char *theirs)
 {
 	git_commit *our_commit, *their_commit, *ancestor_commit;
 	git_tree *our_tree, *their_tree, *ancestor_tree;
@@ -33,8 +33,6 @@ static int merge_trivial(git_index **index, const char *ours, const char *theirs
 	git_buf branch_buf = GIT_BUF_INIT;
 	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
 
-	opts.file_favor |= automerge ? 0 : GIT_MERGE_FILE_FAVOR_NO_MERGE;
-
 	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, ours);
 	cl_git_pass(git_reference_name_to_id(&our_oid, repo, branch_buf.ptr));
 	cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid));
@@ -86,7 +84,7 @@ void test_merge_trees_trivial__2alt(void)
 	git_index *result;
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial(&result, "trivial-2alt", "trivial-2alt-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-2alt", "trivial-2alt-branch"));
 
 	cl_assert(entry = git_index_get_bypath(result, "new-in-branch.txt", 0));
 	cl_assert(git_index_reuc_entrycount(result) == 0);
@@ -101,7 +99,7 @@ void test_merge_trees_trivial__3alt(void)
 	git_index *result;
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial(&result, "trivial-3alt", "trivial-3alt-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-3alt", "trivial-3alt-branch"));
 
 	cl_assert(entry = git_index_get_bypath(result, "new-in-3alt.txt", 0));
 	cl_assert(git_index_reuc_entrycount(result) == 0);
@@ -116,7 +114,7 @@ void test_merge_trees_trivial__4(void)
 	git_index *result;
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial(&result, "trivial-4", "trivial-4-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-4", "trivial-4-branch"));
 
 	cl_assert((entry = git_index_get_bypath(result, "new-and-different.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(result) == 0);
@@ -134,7 +132,7 @@ void test_merge_trees_trivial__5alt_1(void)
 	git_index *result;
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial(&result, "trivial-5alt-1", "trivial-5alt-1-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-5alt-1", "trivial-5alt-1-branch"));
 
 	cl_assert(entry = git_index_get_bypath(result, "new-and-same.txt", 0));
 	cl_assert(git_index_reuc_entrycount(result) == 0);
@@ -149,7 +147,7 @@ void test_merge_trees_trivial__5alt_2(void)
 	git_index *result;
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial(&result, "trivial-5alt-2", "trivial-5alt-2-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-5alt-2", "trivial-5alt-2-branch"));
 
 	cl_assert(entry = git_index_get_bypath(result, "modified-to-same.txt", 0));
 	cl_assert(git_index_reuc_entrycount(result) == 0);
@@ -160,29 +158,12 @@ void test_merge_trees_trivial__5alt_2(void)
 
 /* 6: ancest:ancest+, head:(empty), remote:(empty) = result:no merge */
 void test_merge_trees_trivial__6(void)
-{
-	git_index *result;
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial(&result, "trivial-6", "trivial-6-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(result, "removed-in-both.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(result) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount(result) == 1);
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-both.txt", 1));
-
-	git_index_free(result);
-}
-
-/* 6: ancest:ancest+, head:(empty), remote:(empty) = result:no merge */
-void test_merge_trees_trivial__6_automerge(void)
 {
 	git_index *result;
 	const git_index_entry *entry;
 	const git_index_reuc_entry *reuc;
 
-	cl_git_pass(merge_trivial(&result, "trivial-6", "trivial-6-branch", 1));
+	cl_git_pass(merge_trivial(&result, "trivial-6", "trivial-6-branch"));
 
 	cl_assert((entry = git_index_get_bypath(result, "removed-in-both.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(result) == 1);
@@ -195,30 +176,12 @@ void test_merge_trees_trivial__6_automerge(void)
 
 /* 8: ancest:ancest^, head:(empty), remote:ancest = result:no merge */
 void test_merge_trees_trivial__8(void)
-{
-	git_index *result;
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial(&result, "trivial-8", "trivial-8-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(result, "removed-in-8.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(result) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount(result) == 2);
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-8.txt", 1));
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-8.txt", 3));
-
-	git_index_free(result);
-}
-
-/* 8: ancest:ancest^, head:(empty), remote:ancest = result:no merge */
-void test_merge_trees_trivial__8_automerge(void)
 {
 	git_index *result;
 	const git_index_entry *entry;
 	const git_index_reuc_entry *reuc;
 
-	cl_git_pass(merge_trivial(&result, "trivial-8", "trivial-8-branch", 1));
+	cl_git_pass(merge_trivial(&result, "trivial-8", "trivial-8-branch"));
 
 	cl_assert((entry = git_index_get_bypath(result, "removed-in-8.txt", 0)) == NULL);
 
@@ -236,25 +199,7 @@ void test_merge_trees_trivial__7(void)
 	git_index *result;
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial(&result, "trivial-7", "trivial-7-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(result, "removed-in-7.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(result) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount(result) == 2);
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-7.txt", 1));
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-7.txt", 3));
-
-	git_index_free(result);
-}
-
-/* 7: ancest:ancest+, head:(empty), remote:remote = result:no merge */
-void test_merge_trees_trivial__7_automerge(void)
-{
-	git_index *result;
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial(&result, "trivial-7", "trivial-7-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-7", "trivial-7-branch"));
 
 	cl_assert((entry = git_index_get_bypath(result, "removed-in-7.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(result) == 0);
@@ -268,30 +213,12 @@ void test_merge_trees_trivial__7_automerge(void)
 
 /* 10: ancest:ancest^, head:ancest, remote:(empty) = result:no merge */
 void test_merge_trees_trivial__10(void)
-{
-	git_index *result;
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial(&result, "trivial-10", "trivial-10-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(result, "removed-in-10-branch.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(result) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount(result) == 2);
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-10-branch.txt", 1));
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-10-branch.txt", 2));
-
-	git_index_free(result);
-}
-
-/* 10: ancest:ancest^, head:ancest, remote:(empty) = result:no merge */
-void test_merge_trees_trivial__10_automerge(void)
 {
 	git_index *result;
 	const git_index_entry *entry;
 	const git_index_reuc_entry *reuc;
 
-	cl_git_pass(merge_trivial(&result, "trivial-10", "trivial-10-branch", 1));
+	cl_git_pass(merge_trivial(&result, "trivial-10", "trivial-10-branch"));
 
 	cl_assert((entry = git_index_get_bypath(result, "removed-in-10-branch.txt", 0)) == NULL);
 
@@ -309,25 +236,7 @@ void test_merge_trees_trivial__9(void)
 	git_index *result;
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial(&result, "trivial-9", "trivial-9-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(result, "removed-in-9-branch.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(result) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount(result) == 2);
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-9-branch.txt", 1));
-	cl_assert(entry = git_index_get_bypath(result, "removed-in-9-branch.txt", 2));
-
-	git_index_free(result);
-}
-
-/* 9: ancest:ancest+, head:head, remote:(empty) = result:no merge */
-void test_merge_trees_trivial__9_automerge(void)
-{
-	git_index *result;
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial(&result, "trivial-9", "trivial-9-branch", 1));
+	cl_git_pass(merge_trivial(&result, "trivial-9", "trivial-9-branch"));
 
 	cl_assert((entry = git_index_get_bypath(result, "removed-in-9-branch.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(result) == 0);
@@ -346,7 +255,7 @@ void test_merge_trees_trivial__13(void)
 	const git_index_entry *entry;
 	git_oid expected_oid;
 
-	cl_git_pass(merge_trivial(&result, "trivial-13", "trivial-13-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-13", "trivial-13-branch"));
 
 	cl_assert(entry = git_index_get_bypath(result, "modified-in-13.txt", 0));
 	cl_git_pass(git_oid_fromstr(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b"));
@@ -365,7 +274,7 @@ void test_merge_trees_trivial__14(void)
 	const git_index_entry *entry;
 	git_oid expected_oid;
 
-	cl_git_pass(merge_trivial(&result, "trivial-14", "trivial-14-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-14", "trivial-14-branch"));
 
 	cl_assert(entry = git_index_get_bypath(result, "modified-in-14-branch.txt", 0));
 	cl_git_pass(git_oid_fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9"));
@@ -383,7 +292,7 @@ void test_merge_trees_trivial__11(void)
 	git_index *result;
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial(&result, "trivial-11", "trivial-11-branch", 0));
+	cl_git_pass(merge_trivial(&result, "trivial-11", "trivial-11-branch"));
 
 	cl_assert((entry = git_index_get_bypath(result, "modified-in-both.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(result) == 0);
diff --git a/tests/merge/workdir/trivial.c b/tests/merge/workdir/trivial.c
index ebf09095c..71437d48e 100644
--- a/tests/merge/workdir/trivial.c
+++ b/tests/merge/workdir/trivial.c
@@ -28,7 +28,7 @@ void test_merge_workdir_trivial__cleanup(void)
 }
 
 
-static int merge_trivial(const char *ours, const char *theirs, bool automerge)
+static int merge_trivial(const char *ours, const char *theirs)
 {
 	git_buf branch_buf = GIT_BUF_INIT;
 	git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT;
@@ -39,8 +39,6 @@ static int merge_trivial(const char *ours, const char *theirs, bool automerge)
 
 	checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
-	opts.merge_tree_opts.file_favor |= automerge ? 0 : GIT_MERGE_FILE_FAVOR_NO_MERGE;
-
 	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, ours);
 	cl_git_pass(git_reference_symbolic_create(&our_ref, repo, "HEAD", branch_buf.ptr, 1, NULL, NULL));
 
@@ -83,7 +81,7 @@ void test_merge_workdir_trivial__2alt(void)
 {
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial("trivial-2alt", "trivial-2alt-branch", 0));
+	cl_git_pass(merge_trivial("trivial-2alt", "trivial-2alt-branch"));
 
 	cl_assert(entry = git_index_get_bypath(repo_index, "new-in-branch.txt", 0));
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
@@ -95,7 +93,7 @@ void test_merge_workdir_trivial__3alt(void)
 {
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial("trivial-3alt", "trivial-3alt-branch", 0));
+	cl_git_pass(merge_trivial("trivial-3alt", "trivial-3alt-branch"));
 
 	cl_assert(entry = git_index_get_bypath(repo_index, "new-in-3alt.txt", 0));
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
@@ -107,7 +105,7 @@ void test_merge_workdir_trivial__4(void)
 {
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial("trivial-4", "trivial-4-branch", 0));
+	cl_git_pass(merge_trivial("trivial-4", "trivial-4-branch"));
 
 	cl_assert((entry = git_index_get_bypath(repo_index, "new-and-different.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
@@ -122,7 +120,7 @@ void test_merge_workdir_trivial__5alt_1(void)
 {
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial("trivial-5alt-1", "trivial-5alt-1-branch", 0));
+	cl_git_pass(merge_trivial("trivial-5alt-1", "trivial-5alt-1-branch"));
 
 	cl_assert(entry = git_index_get_bypath(repo_index, "new-and-same.txt", 0));
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
@@ -134,7 +132,7 @@ void test_merge_workdir_trivial__5alt_2(void)
 {
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial("trivial-5alt-2", "trivial-5alt-2-branch", 0));
+	cl_git_pass(merge_trivial("trivial-5alt-2", "trivial-5alt-2-branch"));
 
 	cl_assert(entry = git_index_get_bypath(repo_index, "modified-to-same.txt", 0));
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
@@ -143,25 +141,11 @@ void test_merge_workdir_trivial__5alt_2(void)
 
 /* 6: ancest:ancest+, head:(empty), remote:(empty) = result:no merge */
 void test_merge_workdir_trivial__6(void)
-{
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial("trivial-6", "trivial-6-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-both.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount() == 1);
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-both.txt", 1));
-}
-
-/* 6: ancest:ancest+, head:(empty), remote:(empty) = result:no merge */
-void test_merge_workdir_trivial__6_automerge(void)
 {
 	const git_index_entry *entry;
 	const git_index_reuc_entry *reuc;
 
-	cl_git_pass(merge_trivial("trivial-6", "trivial-6-branch", 1));
+	cl_git_pass(merge_trivial("trivial-6", "trivial-6-branch"));
 
 	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-both.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(repo_index) == 1);
@@ -172,26 +156,11 @@ void test_merge_workdir_trivial__6_automerge(void)
 
 /* 8: ancest:ancest^, head:(empty), remote:ancest = result:no merge */
 void test_merge_workdir_trivial__8(void)
-{
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial("trivial-8", "trivial-8-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-8.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount() == 2);
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-8.txt", 1));
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-8.txt", 3));
-}
-
-/* 8: ancest:ancest^, head:(empty), remote:ancest = result:no merge */
-void test_merge_workdir_trivial__8_automerge(void)
 {
 	const git_index_entry *entry;
 	const git_index_reuc_entry *reuc;
 
-	cl_git_pass(merge_trivial("trivial-8", "trivial-8-branch", 1));
+	cl_git_pass(merge_trivial("trivial-8", "trivial-8-branch"));
 
 	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-8.txt", 0)) == NULL);
 
@@ -206,22 +175,7 @@ void test_merge_workdir_trivial__7(void)
 {
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial("trivial-7", "trivial-7-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-7.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount() == 2);
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-7.txt", 1));
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-7.txt", 3));
-}
-
-/* 7: ancest:ancest+, head:(empty), remote:remote = result:no merge */
-void test_merge_workdir_trivial__7_automerge(void)
-{
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial("trivial-7", "trivial-7-branch", 0));
+	cl_git_pass(merge_trivial("trivial-7", "trivial-7-branch"));
 
 	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-7.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
@@ -233,26 +187,11 @@ void test_merge_workdir_trivial__7_automerge(void)
 
 /* 10: ancest:ancest^, head:ancest, remote:(empty) = result:no merge */
 void test_merge_workdir_trivial__10(void)
-{
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial("trivial-10", "trivial-10-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-10-branch.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount() == 2);
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-10-branch.txt", 1));
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-10-branch.txt", 2));
-}
-
-/* 10: ancest:ancest^, head:ancest, remote:(empty) = result:no merge */
-void test_merge_workdir_trivial__10_automerge(void)
 {
 	const git_index_entry *entry;
 	const git_index_reuc_entry *reuc;
 
-	cl_git_pass(merge_trivial("trivial-10", "trivial-10-branch", 1));
+	cl_git_pass(merge_trivial("trivial-10", "trivial-10-branch"));
 
 	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-10-branch.txt", 0)) == NULL);
 
@@ -267,22 +206,7 @@ void test_merge_workdir_trivial__9(void)
 {
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial("trivial-9", "trivial-9-branch", 0));
-
-	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-9-branch.txt", 0)) == NULL);
-	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
-
-	cl_assert(merge_trivial_conflict_entrycount() == 2);
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-9-branch.txt", 1));
-	cl_assert(entry = git_index_get_bypath(repo_index, "removed-in-9-branch.txt", 2));
-}
-
-/* 9: ancest:ancest+, head:head, remote:(empty) = result:no merge */
-void test_merge_workdir_trivial__9_automerge(void)
-{
-	const git_index_entry *entry;
-
-	cl_git_pass(merge_trivial("trivial-9", "trivial-9-branch", 1));
+	cl_git_pass(merge_trivial("trivial-9", "trivial-9-branch"));
 
 	cl_assert((entry = git_index_get_bypath(repo_index, "removed-in-9-branch.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
@@ -298,7 +222,7 @@ void test_merge_workdir_trivial__13(void)
 	const git_index_entry *entry;
 	git_oid expected_oid;
 
-	cl_git_pass(merge_trivial("trivial-13", "trivial-13-branch", 0));
+	cl_git_pass(merge_trivial("trivial-13", "trivial-13-branch"));
 
 	cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-13.txt", 0));
 	cl_git_pass(git_oid_fromstr(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b"));
@@ -314,7 +238,7 @@ void test_merge_workdir_trivial__14(void)
 	const git_index_entry *entry;
 	git_oid expected_oid;
 
-	cl_git_pass(merge_trivial("trivial-14", "trivial-14-branch", 0));
+	cl_git_pass(merge_trivial("trivial-14", "trivial-14-branch"));
 
 	cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-14-branch.txt", 0));
 	cl_git_pass(git_oid_fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9"));
@@ -329,7 +253,7 @@ void test_merge_workdir_trivial__11(void)
 {
 	const git_index_entry *entry;
 
-	cl_git_pass(merge_trivial("trivial-11", "trivial-11-branch", 0));
+	cl_git_pass(merge_trivial("trivial-11", "trivial-11-branch"));
 
 	cl_assert((entry = git_index_get_bypath(repo_index, "modified-in-both.txt", 0)) == NULL);
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
index bca1ff926..5be397c93 100644
--- a/tests/revert/workdir.c
+++ b/tests/revert/workdir.c
@@ -343,22 +343,19 @@ void test_revert_workdir__conflict_use_ours(void)
 	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "3a3ef367eaf3fe79effbfb0a56b269c04c2b59fe", 1, "file1.txt" },
-		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 2, "file1.txt" },
-		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 3, "file1.txt" },
+		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" },
 		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
 		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
 		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
 	};
 
 	struct merge_index_entry merge_filesystem_entries[] = {
-		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 0, "file1.txt" },
+		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" },
 		{ 0100644, "0ab09ea6d4c3634bdf6c221626d8b6f7dd890767", 0, "file2.txt" },
 		{ 0100644, "f4e107c230d08a60fb419d19869f1f282b272d9c", 0, "file3.txt" },
 		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 0, "file6.txt" },
 	};
 
-	opts.merge_tree_opts.file_favor = GIT_MERGE_FILE_FAVOR_NO_MERGE;
 	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
 
 	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
@@ -369,7 +366,7 @@ void test_revert_workdir__conflict_use_ours(void)
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
 	cl_git_pass(git_revert(repo, commit, &opts));
 
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
 	cl_assert(merge_test_workdir(repo, merge_filesystem_entries, 4));
 
 	git_commit_free(commit);
-- 
cgit v1.2.3


From db3462ce7714e2a6ce23130a7046a77860739e05 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 19 Jan 2014 22:36:50 -0800
Subject: Support union merges

---
 include/git2/merge.h         |  3 +++
 src/merge_file.c             |  2 ++
 tests/merge/workdir/simple.c | 43 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 48 insertions(+)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index c079ef9c2..ad9b5e2ea 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -43,6 +43,9 @@ typedef enum {
 
 	/* Produce a file containing the "theirs" side of conflicting regions. */
 	GIT_MERGE_FILE_FAVOR_THEIRS = 2,
+
+	/* Produce a file blending the sides in a union of conflicting regions */
+	GIT_MERGE_FILE_FAVOR_UNION = 3,
 } git_merge_file_favor_t;
 
 
diff --git a/src/merge_file.c b/src/merge_file.c
index fb0e29960..9961ef297 100644
--- a/src/merge_file.c
+++ b/src/merge_file.c
@@ -156,6 +156,8 @@ int git_merge_files(
 		xmparam.favor = XDL_MERGE_FAVOR_OURS;
 	else if (opts && opts->favor == GIT_MERGE_FILE_FAVOR_THEIRS)
 		xmparam.favor = XDL_MERGE_FAVOR_THEIRS;
+	else if (opts && opts->favor == GIT_MERGE_FILE_FAVOR_UNION)
+		xmparam.favor = XDL_MERGE_FAVOR_UNION;
 
 	xmparam.level = 
 		(opts && (opts->flags & GIT_MERGE_FILE_SIMPLIFY_ALNUM)) ?
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 757e20c6c..6b152cc4d 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -109,6 +109,10 @@ static git_index *repo_index;
 	"this file is changed in branch and master\n" \
 	">>>>>>> 7cb63eed597130ba4abb87b3e544b85021905520\n"
 
+#define CONFLICTING_UNION_FILE \
+	"this file is changed in master and branch\n" \
+	"this file is changed in branch and master\n"
+
 // Fixture setup and teardown
 void test_merge_workdir_simple__initialize(void)
 {
@@ -329,6 +333,45 @@ void test_merge_workdir_simple__diff3(void)
 	git_merge_result_free(result);
 }
 
+void test_merge_workdir_simple__union(void)
+{
+	git_merge_result *result;
+	git_buf conflicting_buf = GIT_BUF_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		ADDED_IN_MASTER_INDEX_ENTRY,
+		AUTOMERGEABLE_INDEX_ENTRY,
+		CHANGED_IN_BRANCH_INDEX_ENTRY,
+		CHANGED_IN_MASTER_INDEX_ENTRY,
+
+		{ 0100644, "72cdb057b340205164478565e91eb71647e66891", 0, "conflicting.txt" },
+
+		UNCHANGED_INDEX_ENTRY,
+	};
+
+	struct merge_reuc_entry merge_reuc_entries[] = {
+		AUTOMERGEABLE_REUC_ENTRY,
+		CONFLICTING_REUC_ENTRY,
+		REMOVED_IN_BRANCH_REUC_ENTRY,
+		REMOVED_IN_MASTER_REUC_ENTRY
+	};
+
+	set_core_autocrlf_to(repo, false);
+
+	cl_assert(result = merge_simple_branch(GIT_MERGE_FILE_FAVOR_UNION, 0));
+	cl_assert(!git_merge_result_is_fastforward(result));
+
+	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
+		TEST_REPO_PATH "/conflicting.txt"));
+	cl_assert(strcmp(conflicting_buf.ptr, CONFLICTING_UNION_FILE) == 0);
+	git_buf_free(&conflicting_buf);
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
+	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 4));
+
+	git_merge_result_free(result);
+}
+
 void test_merge_workdir_simple__diff3_from_config(void)
 {
 	git_merge_result *result;
-- 
cgit v1.2.3


From 0ef19fe14ce5a5f7b5ac90966a56997bf04ea5a9 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 20 Jan 2014 17:13:55 -0500
Subject: Merge submodules

---
 src/checkout.c                                     |  21 ++++-
 src/merge.c                                        |  14 ++-
 tests/merge/workdir/submodules.c                   | 101 +++++++++++++++++++++
 tests/resources/merge-resolve/.gitted/config       |   2 +
 .../merge-resolve/.gitted/modules/submodule/HEAD   |   1 +
 .../.gitted/modules/submodule/ORIG_HEAD            |   1 +
 .../merge-resolve/.gitted/modules/submodule/config |  15 +++
 .../merge-resolve/.gitted/modules/submodule/index  | Bin 0 -> 153 bytes
 .../.gitted/modules/submodule/info/exclude         |   6 ++
 .../18/fae1354bba0a5f1e6a531f9988369142c24a9e      | Bin 0 -> 54 bytes
 .../29/7aa6cd028b3336c7802c7a6f49143da4e1602d      | Bin 0 -> 161 bytes
 .../38/6c80dc813b89d719797668f40c1be0a6efa996      | Bin 0 -> 32 bytes
 .../ab/435a147bae6d5906ecfd0916a570c4ab3eeea8      | Bin 0 -> 64 bytes
 .../ad/16e0a7684ea95bf892980a2ee412293ae979cc      | Bin 0 -> 64 bytes
 .../ae/39c77c70cb6bad18bb471912460c4e1ba0f586      |   2 +
 .../c2/0765f6e24e8bbb63a648d0d11d84da63170190      | Bin 0 -> 52 bytes
 .../d3/d806a4bef96889117fd7ebac0e3cb5ec152932      |   3 +
 .../f1/065ff5593604072837fecaad3e2e268cb0147b      | Bin 0 -> 64 bytes
 .../.gitted/modules/submodule/packed-refs          |   3 +
 .../.gitted/modules/submodule/refs/heads/master    |   1 +
 .../modules/submodule/refs/remotes/origin/HEAD     |   1 +
 .../0f/3fc5dddc8964b9ac1040d0e957f9eb02d9efb3      | Bin 0 -> 47 bytes
 .../27/4bbe983022fb4c02f8a2bf2ebe8da4fe130054      | Bin 0 -> 24 bytes
 .../2b/fdd7e1b6c6ae993f23dfe8e84a8e06a772fa2a      | Bin 0 -> 231 bytes
 .../42/18670ab81cc219a9f94befb5c5dad90ec52648      | Bin 0 -> 47 bytes
 .../49/fd9edac79d15c8fbfca2d481cbb900beba22a6      |   3 +
 .../58/87a5e516c53bd58efb0f02ec6aa031b6fe9ad7      | Bin 0 -> 47 bytes
 .../60/61fe116ecba0800c26113ea1a7dfac2e16eeaf      | Bin 0 -> 87 bytes
 .../62/33c6a0670228627f93c01cef32485a30403670      | Bin 0 -> 44 bytes
 .../67/110d77886b2af6309b9212961e72b8583e5fa9      |   1 +
 .../72/cdb057b340205164478565e91eb71647e66891      | Bin 0 -> 65 bytes
 .../7a/f14d9c679baaef35555095f4f5d33e9a569ab9      | Bin 0 -> 149 bytes
 .../7c/04ca611203ed320c5f495b9813054dd23be3be      |   2 +
 .../81/1c70fcb6d5bbd022d04cc31836d30b436f9551      | Bin 0 -> 169 bytes
 .../8b/7cd60d49ce3a1a770ece43b7d29b5cf462a33a      | Bin 0 -> 82 bytes
 .../91/f44111cb1cb1358ac6944ad356ca1738813ea1      | Bin 0 -> 149 bytes
 .../96/bca8d4f05cc4c5e33e4389f80a1309e86fe054      | Bin 0 -> 149 bytes
 .../ad/26b598134264fd284292cb233fc0b2f25851da      | Bin 0 -> 43 bytes
 .../ca/ff6b7d44973f53e3e0cf31d0d695188b19aec6      | Bin 0 -> 54 bytes
 .../d3/3cedf513c059e0515653fa2c2e386631387a05      | Bin 0 -> 46 bytes
 .../d8/dec75ff2f8b41d1c5bfef0cd57b7300c834f66      | Bin 0 -> 164 bytes
 .../dd/2ae5ab264e5592aa754235d5ad5eac8f0ecdfd      | Bin 0 -> 149 bytes
 .../e5/060729746ca9888239cba08fdcf4bee907b406      | Bin 0 -> 24 bytes
 .../f2/e1550a0c9e53d5811175864a29536642ae3821      | Bin 0 -> 73 bytes
 .../f6/65b45cde9b568009c6e6b7b568e89cfe717df8      | Bin 0 -> 132 bytes
 .../merge-resolve/.gitted/refs/heads/submodules    |   1 +
 .../.gitted/refs/heads/submodules-branch           |   1 +
 .../.gitted/refs/heads/submodules-branch2          |   1 +
 48 files changed, 174 insertions(+), 6 deletions(-)
 create mode 100644 tests/merge/workdir/submodules.c
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/HEAD
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/ORIG_HEAD
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/config
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/index
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/info/exclude
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/18/fae1354bba0a5f1e6a531f9988369142c24a9e
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/29/7aa6cd028b3336c7802c7a6f49143da4e1602d
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/38/6c80dc813b89d719797668f40c1be0a6efa996
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/ab/435a147bae6d5906ecfd0916a570c4ab3eeea8
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/ad/16e0a7684ea95bf892980a2ee412293ae979cc
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/ae/39c77c70cb6bad18bb471912460c4e1ba0f586
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/c2/0765f6e24e8bbb63a648d0d11d84da63170190
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/d3/d806a4bef96889117fd7ebac0e3cb5ec152932
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/objects/f1/065ff5593604072837fecaad3e2e268cb0147b
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/packed-refs
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/refs/heads/master
 create mode 100644 tests/resources/merge-resolve/.gitted/modules/submodule/refs/remotes/origin/HEAD
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/0f/3fc5dddc8964b9ac1040d0e957f9eb02d9efb3
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/27/4bbe983022fb4c02f8a2bf2ebe8da4fe130054
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/2b/fdd7e1b6c6ae993f23dfe8e84a8e06a772fa2a
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/42/18670ab81cc219a9f94befb5c5dad90ec52648
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/49/fd9edac79d15c8fbfca2d481cbb900beba22a6
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/58/87a5e516c53bd58efb0f02ec6aa031b6fe9ad7
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/60/61fe116ecba0800c26113ea1a7dfac2e16eeaf
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/62/33c6a0670228627f93c01cef32485a30403670
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/67/110d77886b2af6309b9212961e72b8583e5fa9
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/72/cdb057b340205164478565e91eb71647e66891
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/7a/f14d9c679baaef35555095f4f5d33e9a569ab9
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/7c/04ca611203ed320c5f495b9813054dd23be3be
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/81/1c70fcb6d5bbd022d04cc31836d30b436f9551
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/8b/7cd60d49ce3a1a770ece43b7d29b5cf462a33a
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/91/f44111cb1cb1358ac6944ad356ca1738813ea1
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/96/bca8d4f05cc4c5e33e4389f80a1309e86fe054
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/ad/26b598134264fd284292cb233fc0b2f25851da
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/ca/ff6b7d44973f53e3e0cf31d0d695188b19aec6
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/d3/3cedf513c059e0515653fa2c2e386631387a05
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/d8/dec75ff2f8b41d1c5bfef0cd57b7300c834f66
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/dd/2ae5ab264e5592aa754235d5ad5eac8f0ecdfd
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/e5/060729746ca9888239cba08fdcf4bee907b406
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/f2/e1550a0c9e53d5811175864a29536642ae3821
 create mode 100644 tests/resources/merge-resolve/.gitted/objects/f6/65b45cde9b568009c6e6b7b568e89cfe717df8
 create mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/submodules
 create mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/submodules-branch
 create mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/submodules-branch2

diff --git a/src/checkout.c b/src/checkout.c
index 960bc6140..cfb0e72ab 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -71,7 +71,8 @@ typedef struct {
 	int name_collision:1,
 		directoryfile:1,
 		one_to_two:1,
-		binary:1;
+		binary:1,
+		submodule:1;
 } checkout_conflictdata;
 
 static int checkout_notify(
@@ -682,11 +683,22 @@ GIT_INLINE(bool) conflict_pathspec_match(
 	return false;
 }
 
+GIT_INLINE(int) checkout_conflict_detect_submodule(checkout_conflictdata *conflict)
+{
+	conflict->submodule = ((conflict->ancestor && S_ISGITLINK(conflict->ancestor->mode)) ||
+		(conflict->ours && S_ISGITLINK(conflict->ours->mode)) ||
+		(conflict->theirs && S_ISGITLINK(conflict->theirs->mode)));
+	return 0;
+}
+
 GIT_INLINE(int) checkout_conflict_detect_binary(git_repository *repo, checkout_conflictdata *conflict)
 {
 	git_blob *ancestor_blob = NULL, *our_blob = NULL, *their_blob = NULL;
 	int error = 0;
 
+	if (conflict->submodule)
+		return 0;
+
 	if (conflict->ancestor) {
 		if ((error = git_blob_lookup(&ancestor_blob, repo, &conflict->ancestor->oid)) < 0)
 			goto done;
@@ -740,7 +752,8 @@ static int checkout_conflicts_load(checkout_data *data, git_iterator *workdir, g
 		conflict->ours = ours;
 		conflict->theirs = theirs;
 
-		if ((error = checkout_conflict_detect_binary(data->repo, conflict)) < 0)
+		if ((error = checkout_conflict_detect_submodule(conflict)) < 0 ||
+			(error = checkout_conflict_detect_binary(data->repo, conflict)) < 0)
 			goto done;
 
 		git_vector_insert(&data->conflicts, conflict);
@@ -1791,6 +1804,10 @@ static int checkout_create_conflicts(checkout_data *data)
 		else if (S_ISLNK(conflict->theirs->mode))
 			error = checkout_write_entry(data, conflict, conflict->ours);
 
+		/* If any side is a gitlink, do nothing. */
+		else if (conflict->submodule)
+			error = 0;
+
 		/* If any side is binary, write the ours side */
 		else if (conflict->binary)
 			error = checkout_write_entry(data, conflict, conflict->ours);
diff --git a/src/merge.c b/src/merge.c
index 04c74212a..2fb1c5898 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -42,6 +42,7 @@
 #include "git2/sys/index.h"
 
 #define GIT_MERGE_INDEX_ENTRY_EXISTS(X)	((X).mode != 0)
+#define GIT_MERGE_INDEX_ENTRY_ISFILE(X) S_ISREG((X).mode)
 
 typedef enum {
 	TREE_IDX_ANCESTOR = 0,
@@ -447,7 +448,6 @@ static int merge_conflict_resolve_one_removed(
 	return error;
 }
 
-
 static int merge_conflict_resolve_one_renamed(
 	int *resolved,
 	git_merge_diff_list *diff_list,
@@ -533,6 +533,12 @@ static int merge_conflict_resolve_automerge(
 	if (conflict->type == GIT_MERGE_DIFF_DIRECTORY_FILE)
 		return 0;
 
+	/* Reject submodules. */
+	if (S_ISGITLINK(conflict->ancestor_entry.mode) ||
+		S_ISGITLINK(conflict->our_entry.mode) ||
+		S_ISGITLINK(conflict->their_entry.mode))
+		return 0;
+
 	/* Reject link/file conflicts. */
 	if ((S_ISLNK(conflict->ancestor_entry.mode) ^ S_ISLNK(conflict->our_entry.mode)) ||
 		(S_ISLNK(conflict->ancestor_entry.mode) ^ S_ISLNK(conflict->their_entry.mode)))
@@ -1156,7 +1162,7 @@ GIT_INLINE(int) merge_diff_detect_binary(
 	git_blob *ancestor_blob = NULL, *our_blob = NULL, *their_blob = NULL;
 	int error = 0;
 
-	if (GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->ancestor_entry)) {
+	if (GIT_MERGE_INDEX_ENTRY_ISFILE(conflict->ancestor_entry)) {
 		if ((error = git_blob_lookup(&ancestor_blob, repo, &conflict->ancestor_entry.oid)) < 0)
 			goto done;
 
@@ -1164,7 +1170,7 @@ GIT_INLINE(int) merge_diff_detect_binary(
 	}
 
 	if (!conflict->binary &&
-		GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry)) {
+		GIT_MERGE_INDEX_ENTRY_ISFILE(conflict->our_entry)) {
 		if ((error = git_blob_lookup(&our_blob, repo, &conflict->our_entry.oid)) < 0)
 			goto done;
 
@@ -1172,7 +1178,7 @@ GIT_INLINE(int) merge_diff_detect_binary(
 	}
 
 	if (!conflict->binary &&
-		GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry)) {
+		GIT_MERGE_INDEX_ENTRY_ISFILE(conflict->their_entry)) {
 		if ((error = git_blob_lookup(&their_blob, repo, &conflict->their_entry.oid)) < 0)
 			goto done;
 
diff --git a/tests/merge/workdir/submodules.c b/tests/merge/workdir/submodules.c
new file mode 100644
index 000000000..f01faac43
--- /dev/null
+++ b/tests/merge/workdir/submodules.c
@@ -0,0 +1,101 @@
+#include "clar_libgit2.h"
+#include "git2/repository.h"
+#include "git2/merge.h"
+#include "buffer.h"
+#include "merge.h"
+#include "../merge_helpers.h"
+
+static git_repository *repo;
+
+#define TEST_REPO_PATH "merge-resolve"
+
+#define SUBMODULE_MAIN_BRANCH		"submodules"
+#define SUBMODULE_OTHER_BRANCH		"submodules-branch"
+#define SUBMODULE_OTHER2_BRANCH		"submodules-branch2"
+
+#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
+
+// Fixture setup and teardown
+void test_merge_workdir_submodules__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+}
+
+void test_merge_workdir_submodules__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_merge_workdir_submodules__automerge(void)
+{
+	git_reference *our_ref, *their_ref;
+	git_commit *our_commit;
+	git_merge_head *their_head;
+	git_merge_result *result;
+	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_index *index;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "caff6b7d44973f53e3e0cf31d0d695188b19aec6", 0, ".gitmodules" },
+		{ 0100644, "950a663a6a7b2609eed1ed1ba9f41eb1a3192a9f", 0, "file1.txt" },
+		{ 0100644, "343e660b9cb4bee5f407c2e33fcb9df24d9407a4", 0, "file2.txt" },
+		{ 0160000, "d3d806a4bef96889117fd7ebac0e3cb5ec152932", 1, "submodule" },
+		{ 0160000, "297aa6cd028b3336c7802c7a6f49143da4e1602d", 2, "submodule" },
+		{ 0160000, "ae39c77c70cb6bad18bb471912460c4e1ba0f586", 3, "submodule" },
+	};
+
+	cl_git_pass(git_reference_lookup(&our_ref, repo, "refs/heads/" SUBMODULE_MAIN_BRANCH));
+	cl_git_pass(git_commit_lookup(&our_commit, repo, git_reference_target(our_ref)));
+	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD));
+
+	cl_git_pass(git_reference_lookup(&their_ref, repo, "refs/heads/" SUBMODULE_OTHER_BRANCH));
+	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
+
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, &opts));
+
+	cl_git_pass(git_repository_index(&index, repo));
+	cl_assert(merge_test_index(index, merge_index_entries, 6));
+
+	git_index_free(index);
+	git_merge_result_free(result);
+	git_merge_head_free(their_head);
+	git_commit_free(our_commit);
+	git_reference_free(their_ref);
+	git_reference_free(our_ref);
+}
+
+void test_merge_workdir_submodules__take_changed(void)
+{
+	git_reference *our_ref, *their_ref;
+	git_commit *our_commit;
+	git_merge_head *their_head;
+	git_merge_result *result;
+	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_index *index;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "caff6b7d44973f53e3e0cf31d0d695188b19aec6", 0, ".gitmodules" },
+		{ 0100644, "b438ff23300b2e0f80b84a6f30140dfa91e71423", 0, "file1.txt" },
+		{ 0100644, "f27fbafdfa6693f8f7a5128506fe3e338dbfcad2", 0, "file2.txt" },
+		{ 0160000, "297aa6cd028b3336c7802c7a6f49143da4e1602d", 0, "submodule" },
+	};
+
+	cl_git_pass(git_reference_lookup(&our_ref, repo, "refs/heads/" SUBMODULE_MAIN_BRANCH));
+	cl_git_pass(git_commit_lookup(&our_commit, repo, git_reference_target(our_ref)));
+	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD));
+
+	cl_git_pass(git_reference_lookup(&their_ref, repo, "refs/heads/" SUBMODULE_OTHER2_BRANCH));
+	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
+
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, &opts));
+
+	cl_git_pass(git_repository_index(&index, repo));
+	cl_assert(merge_test_index(index, merge_index_entries, 4));
+
+	git_index_free(index);
+	git_merge_result_free(result);
+	git_merge_head_free(their_head);
+	git_commit_free(our_commit);
+	git_reference_free(their_ref);
+	git_reference_free(our_ref);
+}
diff --git a/tests/resources/merge-resolve/.gitted/config b/tests/resources/merge-resolve/.gitted/config
index af107929f..26c48426d 100644
--- a/tests/resources/merge-resolve/.gitted/config
+++ b/tests/resources/merge-resolve/.gitted/config
@@ -4,3 +4,5 @@
 	bare = false
 	logallrefupdates = true
 	ignorecase = true
+[submodule "submodule"]
+	url = ../submodule
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/HEAD b/tests/resources/merge-resolve/.gitted/modules/submodule/HEAD
new file mode 100644
index 000000000..cb089cd89
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/master
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/ORIG_HEAD b/tests/resources/merge-resolve/.gitted/modules/submodule/ORIG_HEAD
new file mode 100644
index 000000000..d1bfcf0f4
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/ORIG_HEAD
@@ -0,0 +1 @@
+ae39c77c70cb6bad18bb471912460c4e1ba0f586
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/config b/tests/resources/merge-resolve/.gitted/modules/submodule/config
new file mode 100644
index 000000000..575cc8599
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/config
@@ -0,0 +1,15 @@
+[core]
+	repositoryformatversion = 0
+	filemode = false
+	bare = false
+	logallrefupdates = true
+	worktree = ../../../submodule
+	symlinks = false
+	ignorecase = true
+	hideDotFiles = dotGitOnly
+[remote "origin"]
+	url = c:/Temp/TestRepos/submodule
+	fetch = +refs/heads/*:refs/remotes/origin/*
+[branch "master"]
+	remote = origin
+	merge = refs/heads/master
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/index b/tests/resources/merge-resolve/.gitted/modules/submodule/index
new file mode 100644
index 000000000..e948afb27
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/modules/submodule/index differ
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/info/exclude b/tests/resources/merge-resolve/.gitted/modules/submodule/info/exclude
new file mode 100644
index 000000000..a5196d1be
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/info/exclude
@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/18/fae1354bba0a5f1e6a531f9988369142c24a9e b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/18/fae1354bba0a5f1e6a531f9988369142c24a9e
new file mode 100644
index 000000000..fcf1c6381
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/18/fae1354bba0a5f1e6a531f9988369142c24a9e differ
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/29/7aa6cd028b3336c7802c7a6f49143da4e1602d b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/29/7aa6cd028b3336c7802c7a6f49143da4e1602d
new file mode 100644
index 000000000..aa9fc5006
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/29/7aa6cd028b3336c7802c7a6f49143da4e1602d differ
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/38/6c80dc813b89d719797668f40c1be0a6efa996 b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/38/6c80dc813b89d719797668f40c1be0a6efa996
new file mode 100644
index 000000000..bc9a32ebc
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/38/6c80dc813b89d719797668f40c1be0a6efa996 differ
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ab/435a147bae6d5906ecfd0916a570c4ab3eeea8 b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ab/435a147bae6d5906ecfd0916a570c4ab3eeea8
new file mode 100644
index 000000000..65a8d759f
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ab/435a147bae6d5906ecfd0916a570c4ab3eeea8 differ
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ad/16e0a7684ea95bf892980a2ee412293ae979cc b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ad/16e0a7684ea95bf892980a2ee412293ae979cc
new file mode 100644
index 000000000..49e1aafeb
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ad/16e0a7684ea95bf892980a2ee412293ae979cc differ
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ae/39c77c70cb6bad18bb471912460c4e1ba0f586 b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ae/39c77c70cb6bad18bb471912460c4e1ba0f586
new file mode 100644
index 000000000..6ceffdd4e
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/ae/39c77c70cb6bad18bb471912460c4e1ba0f586
@@ -0,0 +1,2 @@
+x
¥ŽË
!@=S
hfù%Æx±†!ë�Å Æö]kðöò/�{k�©-âa]
xW«s	=,lÄP…‰
+Šë#g0KÈêIC¶©–ž–,5ù“1¡– ™9;aãlB«è=×>ô­|h}_{{õMŸe·?º¶�þêuž¸·‹6˜Àšˆô"€Úí>:å�„ʃ6^Õ¤±Kd
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/c2/0765f6e24e8bbb63a648d0d11d84da63170190 b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/c2/0765f6e24e8bbb63a648d0d11d84da63170190
new file mode 100644
index 000000000..14781032f
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/c2/0765f6e24e8bbb63a648d0d11d84da63170190 differ
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/d3/d806a4bef96889117fd7ebac0e3cb5ec152932 b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/d3/d806a4bef96889117fd7ebac0e3cb5ec152932
new file mode 100644
index 000000000..8df72a45c
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/d3/d806a4bef96889117fd7ebac0e3cb5ec152932
@@ -0,0 +1,3 @@
+x
¥�A
+Â0E]çs
e¦mÚDÜx½À$™Ò‚é@šâõ�gpóø¼ÅQs^+�·§ZD€ÃÐ[¦a
+,c²G‰sBO#Û	ãÀ¡v†�ºh�GúpIðZ4ïºÁUšý­{^cÑ]çz‰šo@½ÇŽ\çÎèM³-\å�ó<BÖt¼æµ�Ì·ÈA›
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/objects/f1/065ff5593604072837fecaad3e2e268cb0147b b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/f1/065ff5593604072837fecaad3e2e268cb0147b
new file mode 100644
index 000000000..e0d73e1c2
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/modules/submodule/objects/f1/065ff5593604072837fecaad3e2e268cb0147b differ
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/packed-refs b/tests/resources/merge-resolve/.gitted/modules/submodule/packed-refs
new file mode 100644
index 000000000..992c4eec6
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/packed-refs
@@ -0,0 +1,3 @@
+# pack-refs with: peeled 
+297aa6cd028b3336c7802c7a6f49143da4e1602d refs/remotes/origin/master
+ae39c77c70cb6bad18bb471912460c4e1ba0f586 refs/remotes/origin/submodule-branch
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/refs/heads/master b/tests/resources/merge-resolve/.gitted/modules/submodule/refs/heads/master
new file mode 100644
index 000000000..fe282569b
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/refs/heads/master
@@ -0,0 +1 @@
+297aa6cd028b3336c7802c7a6f49143da4e1602d
diff --git a/tests/resources/merge-resolve/.gitted/modules/submodule/refs/remotes/origin/HEAD b/tests/resources/merge-resolve/.gitted/modules/submodule/refs/remotes/origin/HEAD
new file mode 100644
index 000000000..6efe28fff
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/modules/submodule/refs/remotes/origin/HEAD
@@ -0,0 +1 @@
+ref: refs/remotes/origin/master
diff --git a/tests/resources/merge-resolve/.gitted/objects/0f/3fc5dddc8964b9ac1040d0e957f9eb02d9efb3 b/tests/resources/merge-resolve/.gitted/objects/0f/3fc5dddc8964b9ac1040d0e957f9eb02d9efb3
new file mode 100644
index 000000000..d0ca42dad
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/0f/3fc5dddc8964b9ac1040d0e957f9eb02d9efb3 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/27/4bbe983022fb4c02f8a2bf2ebe8da4fe130054 b/tests/resources/merge-resolve/.gitted/objects/27/4bbe983022fb4c02f8a2bf2ebe8da4fe130054
new file mode 100644
index 000000000..c7afad2a8
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/27/4bbe983022fb4c02f8a2bf2ebe8da4fe130054 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/2b/fdd7e1b6c6ae993f23dfe8e84a8e06a772fa2a b/tests/resources/merge-resolve/.gitted/objects/2b/fdd7e1b6c6ae993f23dfe8e84a8e06a772fa2a
new file mode 100644
index 000000000..c86edfb68
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/2b/fdd7e1b6c6ae993f23dfe8e84a8e06a772fa2a differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/42/18670ab81cc219a9f94befb5c5dad90ec52648 b/tests/resources/merge-resolve/.gitted/objects/42/18670ab81cc219a9f94befb5c5dad90ec52648
new file mode 100644
index 000000000..33ead6112
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/42/18670ab81cc219a9f94befb5c5dad90ec52648 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/49/fd9edac79d15c8fbfca2d481cbb900beba22a6 b/tests/resources/merge-resolve/.gitted/objects/49/fd9edac79d15c8fbfca2d481cbb900beba22a6
new file mode 100644
index 000000000..d808d9fd9
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/objects/49/fd9edac79d15c8fbfca2d481cbb900beba22a6
@@ -0,0 +1,3 @@
+x
U�Á
+Â0D=ç+æ¼èÅ
+‚…þÆf»5�dIŽ~¼ÑEhße3Ìó©xœ¯—ÓÍÀ2?ž®‡Ø°Å$É�ô%+¢"SëRAºÂWRîm Kýn¸ä\tXZ/µŸhôº¥ÈÝMƱߙìþg2©»ñj>#
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/objects/58/87a5e516c53bd58efb0f02ec6aa031b6fe9ad7 b/tests/resources/merge-resolve/.gitted/objects/58/87a5e516c53bd58efb0f02ec6aa031b6fe9ad7
new file mode 100644
index 000000000..550d288d4
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/58/87a5e516c53bd58efb0f02ec6aa031b6fe9ad7 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/60/61fe116ecba0800c26113ea1a7dfac2e16eeaf b/tests/resources/merge-resolve/.gitted/objects/60/61fe116ecba0800c26113ea1a7dfac2e16eeaf
new file mode 100644
index 000000000..3f266f6df
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/60/61fe116ecba0800c26113ea1a7dfac2e16eeaf differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/62/33c6a0670228627f93c01cef32485a30403670 b/tests/resources/merge-resolve/.gitted/objects/62/33c6a0670228627f93c01cef32485a30403670
new file mode 100644
index 000000000..81428dd62
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/62/33c6a0670228627f93c01cef32485a30403670 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/67/110d77886b2af6309b9212961e72b8583e5fa9 b/tests/resources/merge-resolve/.gitted/objects/67/110d77886b2af6309b9212961e72b8583e5fa9
new file mode 100644
index 000000000..877bad703
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/objects/67/110d77886b2af6309b9212961e72b8583e5fa9
@@ -0,0 +1 @@
+x
¥�=N1„©÷î^rœ	!J:.`'ûŠlP^×gâT3ú43Ò”Ñûu
åp·¦*�´Z£	%°ælÙÚ4irœÇH�‰·žz,�ê³¥ä[‰M]a“J©ÂÒ�bó5¤lÐ8OùX$XÕ³�EaÇ")ŠUïœ$�d2zO¸ñçÚÇ„—úųÂÛ>úmð¨'ýqÏýZæ¸�¶ÊèO`lF“³O
î1!n'=�-ýÇÄöªó]A&e‡Ë¯^¶o––^Ý
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/objects/72/cdb057b340205164478565e91eb71647e66891 b/tests/resources/merge-resolve/.gitted/objects/72/cdb057b340205164478565e91eb71647e66891
new file mode 100644
index 000000000..84aa8336b
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/72/cdb057b340205164478565e91eb71647e66891 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/7a/f14d9c679baaef35555095f4f5d33e9a569ab9 b/tests/resources/merge-resolve/.gitted/objects/7a/f14d9c679baaef35555095f4f5d33e9a569ab9
new file mode 100644
index 000000000..b4c4ef734
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/7a/f14d9c679baaef35555095f4f5d33e9a569ab9 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/7c/04ca611203ed320c5f495b9813054dd23be3be b/tests/resources/merge-resolve/.gitted/objects/7c/04ca611203ed320c5f495b9813054dd23be3be
new file mode 100644
index 000000000..e3ba6056d
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/objects/7c/04ca611203ed320c5f495b9813054dd23be3be
@@ -0,0 +1,2 @@
+x
¥ŽQ Dýæ{

-,tcüñ^`�%õƒb(ÆëKÏà|ͼd&k)¯³±§ÞDÀsžl¢è<fɇ4a¶“1BŒŽ8�zs“­CvƒÅ˜„ºEëQüd¡˜ÅO>åEñ§¯µÁ#}¹%x®µìuƒ«z¸{yÅV÷šû%ÖrƒÉ�žÇ†·pÖ¨µtíòÇ„
+�·¸ÎêUrL
\ No newline at end of file
diff --git a/tests/resources/merge-resolve/.gitted/objects/81/1c70fcb6d5bbd022d04cc31836d30b436f9551 b/tests/resources/merge-resolve/.gitted/objects/81/1c70fcb6d5bbd022d04cc31836d30b436f9551
new file mode 100644
index 000000000..6d8702404
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/81/1c70fcb6d5bbd022d04cc31836d30b436f9551 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/8b/7cd60d49ce3a1a770ece43b7d29b5cf462a33a b/tests/resources/merge-resolve/.gitted/objects/8b/7cd60d49ce3a1a770ece43b7d29b5cf462a33a
new file mode 100644
index 000000000..790750c0f
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/8b/7cd60d49ce3a1a770ece43b7d29b5cf462a33a differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/91/f44111cb1cb1358ac6944ad356ca1738813ea1 b/tests/resources/merge-resolve/.gitted/objects/91/f44111cb1cb1358ac6944ad356ca1738813ea1
new file mode 100644
index 000000000..51a456f42
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/91/f44111cb1cb1358ac6944ad356ca1738813ea1 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/96/bca8d4f05cc4c5e33e4389f80a1309e86fe054 b/tests/resources/merge-resolve/.gitted/objects/96/bca8d4f05cc4c5e33e4389f80a1309e86fe054
new file mode 100644
index 000000000..8938d3e56
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/96/bca8d4f05cc4c5e33e4389f80a1309e86fe054 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/ad/26b598134264fd284292cb233fc0b2f25851da b/tests/resources/merge-resolve/.gitted/objects/ad/26b598134264fd284292cb233fc0b2f25851da
new file mode 100644
index 000000000..5819a2e25
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/ad/26b598134264fd284292cb233fc0b2f25851da differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/ca/ff6b7d44973f53e3e0cf31d0d695188b19aec6 b/tests/resources/merge-resolve/.gitted/objects/ca/ff6b7d44973f53e3e0cf31d0d695188b19aec6
new file mode 100644
index 000000000..6d0f60077
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/ca/ff6b7d44973f53e3e0cf31d0d695188b19aec6 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/d3/3cedf513c059e0515653fa2c2e386631387a05 b/tests/resources/merge-resolve/.gitted/objects/d3/3cedf513c059e0515653fa2c2e386631387a05
new file mode 100644
index 000000000..d6d4c2b45
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/d3/3cedf513c059e0515653fa2c2e386631387a05 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/d8/dec75ff2f8b41d1c5bfef0cd57b7300c834f66 b/tests/resources/merge-resolve/.gitted/objects/d8/dec75ff2f8b41d1c5bfef0cd57b7300c834f66
new file mode 100644
index 000000000..74f807e68
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/d8/dec75ff2f8b41d1c5bfef0cd57b7300c834f66 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/dd/2ae5ab264e5592aa754235d5ad5eac8f0ecdfd b/tests/resources/merge-resolve/.gitted/objects/dd/2ae5ab264e5592aa754235d5ad5eac8f0ecdfd
new file mode 100644
index 000000000..55626a57b
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/dd/2ae5ab264e5592aa754235d5ad5eac8f0ecdfd differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/e5/060729746ca9888239cba08fdcf4bee907b406 b/tests/resources/merge-resolve/.gitted/objects/e5/060729746ca9888239cba08fdcf4bee907b406
new file mode 100644
index 000000000..33299c2b0
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/e5/060729746ca9888239cba08fdcf4bee907b406 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/f2/e1550a0c9e53d5811175864a29536642ae3821 b/tests/resources/merge-resolve/.gitted/objects/f2/e1550a0c9e53d5811175864a29536642ae3821
new file mode 100644
index 000000000..1fdcbe22a
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/f2/e1550a0c9e53d5811175864a29536642ae3821 differ
diff --git a/tests/resources/merge-resolve/.gitted/objects/f6/65b45cde9b568009c6e6b7b568e89cfe717df8 b/tests/resources/merge-resolve/.gitted/objects/f6/65b45cde9b568009c6e6b7b568e89cfe717df8
new file mode 100644
index 000000000..7af50d7df
Binary files /dev/null and b/tests/resources/merge-resolve/.gitted/objects/f6/65b45cde9b568009c6e6b7b568e89cfe717df8 differ
diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/submodules b/tests/resources/merge-resolve/.gitted/refs/heads/submodules
new file mode 100644
index 000000000..e5511eca9
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/refs/heads/submodules
@@ -0,0 +1 @@
+d8dec75ff2f8b41d1c5bfef0cd57b7300c834f66
diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/submodules-branch b/tests/resources/merge-resolve/.gitted/refs/heads/submodules-branch
new file mode 100644
index 000000000..7d47e07b8
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/refs/heads/submodules-branch
@@ -0,0 +1 @@
+811c70fcb6d5bbd022d04cc31836d30b436f9551
diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/submodules-branch2 b/tests/resources/merge-resolve/.gitted/refs/heads/submodules-branch2
new file mode 100644
index 000000000..ced60d813
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/refs/heads/submodules-branch2
@@ -0,0 +1 @@
+7c04ca611203ed320c5f495b9813054dd23be3be
-- 
cgit v1.2.3


From 450e8e9e623b8c172ba4628c146838cbf4c56519 Mon Sep 17 00:00:00 2001
From: Nicolas Hake <nh@nosebud.de>
Date: Wed, 22 Jan 2014 13:22:15 +0100
Subject: Expose patch serialization to git_buf

Returning library-allocated strings from libgit2 works fine on Linux,
but may cause problems on Windows because there is no one C Runtime that
everything links against. With libgit2 not exposing its own allocator,
freeing the string is a gamble.

git_patch_to_str already serializes to a buffer, then returns the
underlying memory. Expose the functionality directly, so callers can use
the git_buf_free function to free the memory later.
---
 include/git2/patch.h | 10 ++++++++++
 src/diff_print.c     | 12 ++++++++++--
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/include/git2/patch.h b/include/git2/patch.h
index e09f625c0..e5dd5d8d4 100644
--- a/include/git2/patch.h
+++ b/include/git2/patch.h
@@ -242,6 +242,16 @@ GIT_EXTERN(int) git_patch_to_str(
 	char **string,
 	git_patch *patch);
 
+/**
+ * Get the content of a patch as a single diff text.
+ *
+ * @param out The git_buf to be filled in
+ * @param patch A git_patch representing changes to one file
+ * @return 0 on success, <0 on failure.
+ */
+GIT_EXTERN(int) git_patch_to_buf(
+	git_buf *out,
+	git_patch *patch);
 
 GIT_END_DECL
 
diff --git a/src/diff_print.c b/src/diff_print.c
index 7a70e2b18..0ab21d033 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -452,7 +452,15 @@ static int diff_print_to_buffer_cb(
 	return git_buf_put(output, line->content, line->content_len);
 }
 
-/* print a git_patch to a string buffer */
+/* print a git_patch to a git_buf */
+int git_patch_to_buf(
+	git_buf *out,
+	git_patch *patch)
+{
+	return git_patch_print(patch, diff_print_to_buffer_cb, out);
+}
+
+/* print a git_patch to a char* */
 int git_patch_to_str(
 	char **string,
 	git_patch *patch)
@@ -460,7 +468,7 @@ int git_patch_to_str(
 	int error;
 	git_buf output = GIT_BUF_INIT;
 
-	if (!(error = git_patch_print(patch, diff_print_to_buffer_cb, &output)))
+	if (!(error = git_patch_to_buf(&output, patch)))
 		*string = git_buf_detach(&output);
 	else {
 		git_buf_free(&output);
-- 
cgit v1.2.3


From c05cd7924d2409741bb4cb1eb3ba843bea7ec4a2 Mon Sep 17 00:00:00 2001
From: Nicolas Hake <nh@nosebud.de>
Date: Wed, 22 Jan 2014 17:51:32 +0100
Subject: Drop git_patch_to_str

It's hard or even impossible to correctly free the string buffer
allocated by git_patch_to_str in some circumstances. Drop the function
so people have to use git_patch_to_buf instead - git_buf has a dedicated
destructor.
---
 include/git2/patch.h    | 11 -----------
 src/diff_print.c        | 18 -----------------
 tests/diff/blob.c       | 51 +++++++++++++++++++++++++------------------------
 tests/diff/diffiter.c   |  8 ++++----
 tests/diff/drivers.c    | 45 +++++++++++++++++++++----------------------
 tests/diff/patch.c      | 43 +++++++++++++++++++++--------------------
 tests/diff/rename.c     |  8 ++++----
 tests/diff/submodules.c | 12 +++++++-----
 tests/diff/workdir.c    | 16 +++++++++-------
 9 files changed, 94 insertions(+), 118 deletions(-)

diff --git a/include/git2/patch.h b/include/git2/patch.h
index e5dd5d8d4..1eca29d4a 100644
--- a/include/git2/patch.h
+++ b/include/git2/patch.h
@@ -231,17 +231,6 @@ GIT_EXTERN(int) git_patch_print(
 	git_diff_line_cb print_cb,
 	void *payload);
 
-/**
- * Get the content of a patch as a single diff text.
- *
- * @param string Allocated string; caller must free.
- * @param patch A git_patch representing changes to one file
- * @return 0 on success, <0 on failure.
- */
-GIT_EXTERN(int) git_patch_to_str(
-	char **string,
-	git_patch *patch);
-
 /**
  * Get the content of a patch as a single diff text.
  *
diff --git a/src/diff_print.c b/src/diff_print.c
index 0ab21d033..dd31d1ffa 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -459,21 +459,3 @@ int git_patch_to_buf(
 {
 	return git_patch_print(patch, diff_print_to_buffer_cb, out);
 }
-
-/* print a git_patch to a char* */
-int git_patch_to_str(
-	char **string,
-	git_patch *patch)
-{
-	int error;
-	git_buf output = GIT_BUF_INIT;
-
-	if (!(error = git_patch_to_buf(&output, patch)))
-		*string = git_buf_detach(&output);
-	else {
-		git_buf_free(&output);
-		*string = NULL;
-	}
-
-	return error;
-}
diff --git a/tests/diff/blob.c b/tests/diff/blob.c
index 93f20711c..63e3c5b7d 100644
--- a/tests/diff/blob.c
+++ b/tests/diff/blob.c
@@ -853,7 +853,7 @@ void test_diff_blob__using_path_and_attributes(void)
 	size_t bin_len = 33;
 	const char *changed;
 	git_patch *p;
-	char *pout;
+	git_buf buf = GIT_BUF_INIT;
 
 	/* set up custom diff drivers and 'diff' attribute mappings for them */
 
@@ -951,7 +951,7 @@ void test_diff_blob__using_path_and_attributes(void)
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, nonbin, "zzz.normal", changed, strlen(changed), NULL, &opts));
-	cl_git_pass(git_patch_to_str(&pout, p));
+	cl_git_pass(git_patch_to_buf(&buf, p));
 	cl_assert_equal_s(
 		"diff --git a/zzz.normal b/zzz.normal\n"
 		"index 45141a7..75b0dbb 100644\n"
@@ -960,23 +960,23 @@ void test_diff_blob__using_path_and_attributes(void)
 		"@@ -1,0 +2,3 @@ Hello from the root\n"
 		"+More lines\n"
 		"+And more\n"
-		"+Go here\n", pout);
-	git__free(pout);
+		"+Go here\n", buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(p);
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, nonbin, "zzz.binary", changed, strlen(changed), NULL, &opts));
-	cl_git_pass(git_patch_to_str(&pout, p));
+	cl_git_pass(git_patch_to_buf(&buf, p));
 	cl_assert_equal_s(
 		"diff --git a/zzz.binary b/zzz.binary\n"
 		"index 45141a7..75b0dbb 100644\n"
-		"Binary files a/zzz.binary and b/zzz.binary differ\n", pout);
-	git__free(pout);
+		"Binary files a/zzz.binary and b/zzz.binary differ\n", buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(p);
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, nonbin, "zzz.alphary", changed, strlen(changed), NULL, &opts));
-	cl_git_pass(git_patch_to_str(&pout, p));
+	cl_git_pass(git_patch_to_buf(&buf, p));
 	cl_assert_equal_s(
 		"diff --git a/zzz.alphary b/zzz.alphary\n"
 		"index 45141a7..75b0dbb 100644\n"
@@ -985,13 +985,13 @@ void test_diff_blob__using_path_and_attributes(void)
 		"@@ -1,0 +2,3 @@ Hello from the root\n"
 		"+More lines\n"
 		"+And more\n"
-		"+Go here\n", pout);
-	git__free(pout);
+		"+Go here\n", buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(p);
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, nonbin, "zzz.numary", changed, strlen(changed), NULL, &opts));
-	cl_git_pass(git_patch_to_str(&pout, p));
+	cl_git_pass(git_patch_to_buf(&buf, p));
 	cl_assert_equal_s(
 		"diff --git a/zzz.numary b/zzz.numary\n"
 		"index 45141a7..75b0dbb 100644\n"
@@ -1000,8 +1000,8 @@ void test_diff_blob__using_path_and_attributes(void)
 		"@@ -1,0 +2,3 @@\n"
 		"+More lines\n"
 		"+And more\n"
-		"+Go here\n", pout);
-	git__free(pout);
+		"+Go here\n", buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(p);
 
 	/* "0123456789\n\x01\x02\x03\x04\x05\x06\x07\x08\x09\x00\n0123456789\n"
@@ -1012,17 +1012,17 @@ void test_diff_blob__using_path_and_attributes(void)
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, bin, "zzz.normal", changed, 37, NULL, &opts));
-	cl_git_pass(git_patch_to_str(&pout, p));
+	cl_git_pass(git_patch_to_buf(&buf, p));
 	cl_assert_equal_s(
 		"diff --git a/zzz.normal b/zzz.normal\n"
 		"index b435cd5..1604519 100644\n"
-		"Binary files a/zzz.normal and b/zzz.normal differ\n", pout);
-	git__free(pout);
+		"Binary files a/zzz.normal and b/zzz.normal differ\n", buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(p);
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, bin, "zzz.textary", changed, 37, NULL, &opts));
-	cl_git_pass(git_patch_to_str(&pout, p));
+	cl_git_pass(git_patch_to_buf(&buf, p));
 	cl_assert_equal_s(
 		"diff --git a/zzz.textary b/zzz.textary\n"
 		"index b435cd5..1604519 100644\n"
@@ -1030,13 +1030,13 @@ void test_diff_blob__using_path_and_attributes(void)
 		"+++ b/zzz.textary\n"
 		"@@ -3 +3 @@\n"
 		"-0123456789\n"
-		"+replace a line\n", pout);
-	git__free(pout);
+		"+replace a line\n", buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(p);
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, bin, "zzz.textalphary", changed, 37, NULL, &opts));
-	cl_git_pass(git_patch_to_str(&pout, p));
+	cl_git_pass(git_patch_to_buf(&buf, p));
 	cl_assert_equal_s(
 		"diff --git a/zzz.textalphary b/zzz.textalphary\n"
 		"index b435cd5..1604519 100644\n"
@@ -1044,13 +1044,13 @@ void test_diff_blob__using_path_and_attributes(void)
 		"+++ b/zzz.textalphary\n"
 		"@@ -3 +3 @@\n"
 		"-0123456789\n"
-		"+replace a line\n", pout);
-	git__free(pout);
+		"+replace a line\n", buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(p);
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, bin, "zzz.textnumary", changed, 37, NULL, &opts));
-	cl_git_pass(git_patch_to_str(&pout, p));
+	cl_git_pass(git_patch_to_buf(&buf, p));
 	cl_assert_equal_s(
 		"diff --git a/zzz.textnumary b/zzz.textnumary\n"
 		"index b435cd5..1604519 100644\n"
@@ -1058,10 +1058,11 @@ void test_diff_blob__using_path_and_attributes(void)
 		"+++ b/zzz.textnumary\n"
 		"@@ -3 +3 @@ 0123456789\n"
 		"-0123456789\n"
-		"+replace a line\n", pout);
-	git__free(pout);
+		"+replace a line\n", buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(p);
 
+	git_buf_free(&buf);
 	git_blob_free(nonbin);
 	git_blob_free(bin);
 }
diff --git a/tests/diff/diffiter.c b/tests/diff/diffiter.c
index f886e1baa..c976e30e2 100644
--- a/tests/diff/diffiter.c
+++ b/tests/diff/diffiter.c
@@ -414,16 +414,16 @@ void test_diff_diffiter__iterate_and_generate_patch_text(void)
 
 	for (d = 0; d < num_d; ++d) {
 		git_patch *patch;
-		char *text;
+		git_buf buf = GIT_BUF_INIT;
 
 		cl_git_pass(git_patch_from_diff(&patch, diff, d));
 		cl_assert(patch != NULL);
 
-		cl_git_pass(git_patch_to_str(&text, patch));
+		cl_git_pass(git_patch_to_buf(&buf, patch));
 
-		cl_assert_equal_s(expected_patch_text[d], text);
+		cl_assert_equal_s(expected_patch_text[d], buf.ptr);
 
-		git__free(text);
+		git_buf_free(&buf);
 		git_patch_free(patch);
 	}
 
diff --git a/tests/diff/drivers.c b/tests/diff/drivers.c
index fbd1dff81..c80fad4c2 100644
--- a/tests/diff/drivers.c
+++ b/tests/diff/drivers.c
@@ -22,7 +22,7 @@ void test_diff_drivers__patterns(void)
 	git_tree *one;
 	git_diff *diff;
 	git_patch *patch;
-	char *text;
+	git_buf buf = GIT_BUF_INIT;
 	const char *expected0 = "diff --git a/untimely.txt b/untimely.txt\nindex 9a69d96..57fd0cf 100644\n--- a/untimely.txt\n+++ b/untimely.txt\n@@ -22,3 +22,5 @@ Comes through the blood of the vanguards who\n   dreamed--too soon--it had sounded.\r\n \r\n                 -- Rudyard Kipling\r\n+\r\n+Some new stuff\r\n";
 	const char *expected1 = "diff --git a/untimely.txt b/untimely.txt\nindex 9a69d96..57fd0cf 100644\nBinary files a/untimely.txt and b/untimely.txt differ\n";
 	const char *expected2 = "diff --git a/untimely.txt b/untimely.txt\nindex 9a69d96..57fd0cf 100644\n--- a/untimely.txt\n+++ b/untimely.txt\n@@ -22,3 +22,5 @@ Heaven delivers on earth the Hour that cannot be\n   dreamed--too soon--it had sounded.\r\n \r\n                 -- Rudyard Kipling\r\n+\r\n+Some new stuff\r\n";
@@ -45,10 +45,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected0, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected0, buf.ptr);
 
-	git__free(text);
+	git_buf_free(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -60,10 +60,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected1, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected1, buf.ptr);
 
-	git__free(text);
+	git_buf_free(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -75,10 +75,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected0, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected0, buf.ptr);
 
-	git__free(text);
+	git_buf_free(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -92,10 +92,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected1, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected1, buf.ptr);
 
-	git__free(text);
+	git_buf_free(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -113,10 +113,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected2, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected2, buf.ptr);
 
-	git__free(text);
+	git_buf_free(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -129,7 +129,7 @@ void test_diff_drivers__long_lines(void)
 	git_index *idx;
 	git_diff *diff;
 	git_patch *patch;
-	char *actual;
+	git_buf buf = GIT_BUF_INIT;
 	const char *expected = "diff --git a/longlines.txt b/longlines.txt\nindex c1ce6ef..0134431 100644\n--- a/longlines.txt\n+++ b/longlines.txt\n@@ -3,3 +3,5 @@ Phasellus eget erat odio. Praesent at est iaculis, ultricies augue vel, dignissi\n Nam eget dolor fermentum, aliquet nisl at, convallis tellus. Pellentesque rhoncus erat enim, id porttitor elit euismod quis.\n Mauris sollicitudin magna odio, non egestas libero vehicula ut. Etiam et quam velit. Fusce eget libero rhoncus, ultricies felis sit amet, egestas purus.\n Aliquam in semper tellus. Pellentesque adipiscing rutrum velit, quis malesuada lacus consequat eget.\n+newline\n+newline\n";
 
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
@@ -145,18 +145,17 @@ void test_diff_drivers__long_lines(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
 	cl_assert_equal_sz(1, git_diff_num_deltas(diff));
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&actual, patch));
+	cl_git_pass(git_patch_to_buf(&buf, patch));
 
 	/* if chmod not supported, overwrite mode bits since anything is possible */
 	if (!cl_is_chmod_supported()) {
-		size_t actual_len = strlen(actual);
-		if (actual_len > 72 && memcmp(&actual[66], "100644", 6) != 0)
-			memcpy(&actual[66], "100644", 6);
+		if (buf.size > 72 && memcmp(&buf.ptr[66], "100644", 6) != 0)
+			memcpy(&buf.ptr[66], "100644", 6);
 	}
 
-	cl_assert_equal_s(expected, actual);
+	cl_assert_equal_s(expected, buf.ptr);
 
-	free(actual);
+	git_buf_free(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 }
diff --git a/tests/diff/patch.c b/tests/diff/patch.c
index 0cef3bd3a..76d7fcde3 100644
--- a/tests/diff/patch.c
+++ b/tests/diff/patch.c
@@ -141,7 +141,7 @@ void test_diff_patch__to_string(void)
 	git_tree *one, *another;
 	git_diff *diff;
 	git_patch *patch;
-	char *text;
+	git_buf buf = GIT_BUF_INIT;
 	const char *expected = "diff --git a/subdir.txt b/subdir.txt\ndeleted file mode 100644\nindex e8ee89e..0000000\n--- a/subdir.txt\n+++ /dev/null\n@@ -1,2 +0,0 @@\n-Is it a bird?\n-Is it a plane?\n";
 
 	g_repo = cl_git_sandbox_init("status");
@@ -155,16 +155,16 @@ void test_diff_patch__to_string(void)
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
 
-	cl_git_pass(git_patch_to_str(&text, patch));
+	cl_git_pass(git_patch_to_buf(&buf, patch));
 
-	cl_assert_equal_s(expected, text);
+	cl_assert_equal_s(expected, buf.ptr);
 
 	cl_assert_equal_sz(31, git_patch_size(patch, 0, 0, 0));
 	cl_assert_equal_sz(31, git_patch_size(patch, 1, 0, 0));
 	cl_assert_equal_sz(31 + 16, git_patch_size(patch, 1, 1, 0));
 	cl_assert_equal_sz(strlen(expected), git_patch_size(patch, 1, 1, 1));
 
-	git__free(text);
+	git_buf_free(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 	git_tree_free(another);
@@ -178,7 +178,7 @@ void test_diff_patch__config_options(void)
 	git_config *cfg;
 	git_diff *diff;
 	git_patch *patch;
-	char *text;
+	git_buf buf = GIT_BUF_INIT;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	char *onefile = "staged_changes_modified_file";
 	const char *expected1 = "diff --git c/staged_changes_modified_file i/staged_changes_modified_file\nindex 70bd944..906ee77 100644\n--- c/staged_changes_modified_file\n+++ i/staged_changes_modified_file\n@@ -1 +1,2 @@\n staged_changes_modified_file\n+staged_changes_modified_file\n";
@@ -199,10 +199,10 @@ void test_diff_patch__config_options(void)
 
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected1, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected1, buf.ptr);
 
-	git__free(text);
+	git_buf_clear(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -210,10 +210,10 @@ void test_diff_patch__config_options(void)
 
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected2, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected2, buf.ptr);
 
-	git__free(text);
+	git_buf_clear(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -224,10 +224,10 @@ void test_diff_patch__config_options(void)
 
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected3, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected3, buf.ptr);
 
-	git__free(text);
+	git_buf_clear(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -238,13 +238,14 @@ void test_diff_patch__config_options(void)
 
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected4, text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected4, buf.ptr);
 
-	git__free(text);
+	git_buf_clear(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
+	git_buf_free(&buf);
 	git_tree_free(one);
 	git_config_free(cfg);
 }
@@ -465,10 +466,10 @@ static void check_single_patch_stats(
 	cl_assert_equal_sz(dels, actual_dels);
 
 	if (expected != NULL) {
-		char *text;
-		cl_git_pass(git_patch_to_str(&text, patch));
-		cl_assert_equal_s(expected, text);
-		git__free(text);
+		git_buf buf = GIT_BUF_INIT;
+		cl_git_pass(git_patch_to_buf(&buf, patch));
+		cl_assert_equal_s(expected, buf.ptr);
+		git_buf_free(&buf);
 
 		cl_assert_equal_sz(
 			strlen(expected), git_patch_size(patch, 1, 1, 1));
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index 4d1f7646e..ca08d15f3 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -584,7 +584,7 @@ void test_diff_rename__patch(void)
 	git_diff_find_options opts = GIT_DIFF_FIND_OPTIONS_INIT;
 	git_patch *patch;
 	const git_diff_delta *delta;
-	char *text;
+	git_buf buf = GIT_BUF_INIT;
 	const char *expected = "diff --git a/sixserving.txt b/ikeepsix.txt\nindex ad0a8e5..36020db 100644\n--- a/sixserving.txt\n+++ b/ikeepsix.txt\n@@ -1,3 +1,6 @@\n+I Keep Six Honest Serving-Men\n+=============================\n+\n I KEEP six honest serving-men\n  (They taught me all I knew);\n Their names are What and Why and When\n@@ -21,4 +24,4 @@ She sends'em abroad on her own affairs,\n One million Hows, two million Wheres,\n And seven million Whys!\n \n-                -- Rudyard Kipling\n+  -- Rudyard Kipling\n";
 
 	old_tree = resolve_commit_oid_to_tree(g_repo, sha0);
@@ -610,9 +610,9 @@ void test_diff_rename__patch(void)
 	cl_assert((delta = git_patch_get_delta(patch)) != NULL);
 	cl_assert_equal_i(GIT_DELTA_COPIED, (int)delta->status);
 
-	cl_git_pass(git_patch_to_str(&text, patch));
-	cl_assert_equal_s(expected, text);
-	git__free(text);
+	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_assert_equal_s(expected, buf.ptr);
+	git_buf_free(&buf);
 
 	git_patch_free(patch);
 
diff --git a/tests/diff/submodules.c b/tests/diff/submodules.c
index 24545b2c7..da96ba9c5 100644
--- a/tests/diff/submodules.c
+++ b/tests/diff/submodules.c
@@ -13,13 +13,15 @@ void test_diff_submodules__cleanup(void)
 {
 }
 
+#define get_buf_ptr(buf) ((buf)->asize ? (buf)->ptr : NULL)
+
 static void check_diff_patches_at_line(
 	git_diff *diff, const char **expected, const char *file, int line)
 {
 	const git_diff_delta *delta;
 	git_patch *patch = NULL;
 	size_t d, num_d = git_diff_num_deltas(diff);
-	char *patch_text;
+	git_buf buf = GIT_BUF_INIT;
 
 	for (d = 0; d < num_d; ++d, git_patch_free(patch)) {
 		cl_git_pass(git_patch_from_diff(&patch, diff, d));
@@ -33,16 +35,16 @@ static void check_diff_patches_at_line(
 		if (expected[d] && !strcmp(expected[d], "<SKIP>"))
 			continue;
 		if (expected[d] && !strcmp(expected[d], "<END>")) {
-			cl_git_pass(git_patch_to_str(&patch_text, patch));
+			cl_git_pass(git_patch_to_buf(&buf, patch));
 			cl_assert_at_line(!strcmp(expected[d], "<END>"), file, line);
 		}
 
-		cl_git_pass(git_patch_to_str(&patch_text, patch));
+		cl_git_pass(git_patch_to_buf(&buf, patch));
 
 		clar__assert_equal(
 			file, line, "expected diff did not match actual diff", 1,
-			"%s", expected[d], patch_text);
-		git__free(patch_text);
+			"%s", expected[d], get_buf_ptr(&buf));
+		git_buf_free(&buf);
 	}
 
 	cl_assert_at_line(expected[d] && !strcmp(expected[d], "<END>"), file, line);
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 7cc032232..449dc6363 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -1375,7 +1375,7 @@ void test_diff_workdir__patience_diff(void)
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	git_diff *diff = NULL;
 	git_patch *patch = NULL;
-	char *as_str = NULL;
+	git_buf buf = GIT_BUF_INIT;
 	const char *expected_normal = "diff --git a/test.txt b/test.txt\nindex 34a5acc..d52725f 100644\n--- a/test.txt\n+++ b/test.txt\n@@ -1,10 +1,7 @@\n When I wrote this\n I did not know\n-how to create\n-a patience diff\n I did not know\n how to create\n+a patience diff\n another problem\n-I did not know\n-how to create\n a minimal diff\n";
 	const char *expected_patience = "diff --git a/test.txt b/test.txt\nindex 34a5acc..d52725f 100644\n--- a/test.txt\n+++ b/test.txt\n@@ -1,10 +1,7 @@\n When I wrote this\n I did not know\n+I did not know\n how to create\n a patience diff\n-I did not know\n-how to create\n another problem\n-I did not know\n-how to create\n a minimal diff\n";
 
@@ -1397,10 +1397,10 @@ void test_diff_workdir__patience_diff(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	cl_assert_equal_i(1, git_diff_num_deltas(diff));
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&as_str, patch));
+	cl_git_pass(git_patch_to_buf(&buf, patch));
 
-	cl_assert_equal_s(expected_normal, as_str);
-	git__free(as_str);
+	cl_assert_equal_s(expected_normal, buf.ptr);
+	git_buf_clear(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -1409,10 +1409,12 @@ void test_diff_workdir__patience_diff(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	cl_assert_equal_i(1, git_diff_num_deltas(diff));
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_str(&as_str, patch));
+	cl_git_pass(git_patch_to_buf(&buf, patch));
 
-	cl_assert_equal_s(expected_patience, as_str);
-	git__free(as_str);
+	cl_assert_equal_s(expected_patience, buf.ptr);
+	git_buf_clear(&buf);
+
+	git_buf_free(&buf);
 	git_patch_free(patch);
 	git_diff_free(diff);
 }
-- 
cgit v1.2.3


From e8b81c698c52a7197c0842b6503e8b980d773c74 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 22 Jan 2014 13:24:32 -0500
Subject: Preserve tree filemode in index during checkout

Don't try to determine whether the system supports file modes
when putting the tree data in the index during checkout.  The tree's
mode is canonical and did not come from stat(2) in the first place.
---
 src/checkout.c                                     |   3 +--
 tests/checkout/tree.c                              |  23 +++++++++++++++++++++
 .../1d/d0968be3ff95fcaecb6fa4245662db9fdc4568      | Bin 0 -> 73 bytes
 .../af/e4393b2b2a965f06acf2ca9658eaa01e0cd6b6      | Bin 0 -> 171 bytes
 .../ce/054d4c5e3c83522aed8bc061987b46b7ede3be      | Bin 0 -> 194 bytes
 5 files changed, 24 insertions(+), 2 deletions(-)
 create mode 100644 tests/resources/testrepo/.gitted/objects/1d/d0968be3ff95fcaecb6fa4245662db9fdc4568
 create mode 100644 tests/resources/testrepo/.gitted/objects/af/e4393b2b2a965f06acf2ca9658eaa01e0cd6b6
 create mode 100644 tests/resources/testrepo/.gitted/objects/ce/054d4c5e3c83522aed8bc061987b46b7ede3be

diff --git a/src/checkout.c b/src/checkout.c
index cfb0e72ab..962929075 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -1217,8 +1217,7 @@ static int checkout_update_index(
 
 	memset(&entry, 0, sizeof(entry));
 	entry.path = (char *)file->path; /* cast to prevent warning */
-	git_index_entry__init_from_stat(
-		&entry, st, !(git_index_caps(data->index) & GIT_INDEXCAP_NO_FILEMODE));
+	git_index_entry__init_from_stat(&entry, st, true);
 	git_oid_cpy(&entry.oid, &file->oid);
 
 	return git_index_add(data->index, &entry);
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index f0699fdb7..047c9ed98 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -925,3 +925,26 @@ void test_checkout_tree__fails_when_conflicts_exist_in_index(void)
 
 	git_object_free(obj);
 }
+
+void test_checkout_tree__filemode_preserved_in_index(void)
+{
+	git_oid executable_oid;
+	git_commit *commit;
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_index *index;
+	const git_index_entry *entry;
+
+	cl_git_pass(git_repository_index(&index, g_repo));
+
+	cl_git_pass(git_oid_fromstr(&executable_oid, "afe4393b2b2a965f06acf2ca9658eaa01e0cd6b6"));
+	cl_git_pass(git_commit_lookup(&commit, g_repo, &executable_oid));
+
+	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
+
+	cl_git_pass(git_checkout_tree(g_repo, (const git_object *)commit, &opts));
+	cl_assert(entry = git_index_get_bypath(index, "executable.txt", 0));
+	cl_assert_equal_i(0100755, entry->mode);
+
+	git_commit_free(commit);
+	git_index_free(index);
+}
diff --git a/tests/resources/testrepo/.gitted/objects/1d/d0968be3ff95fcaecb6fa4245662db9fdc4568 b/tests/resources/testrepo/.gitted/objects/1d/d0968be3ff95fcaecb6fa4245662db9fdc4568
new file mode 100644
index 000000000..97c6b2cfa
Binary files /dev/null and b/tests/resources/testrepo/.gitted/objects/1d/d0968be3ff95fcaecb6fa4245662db9fdc4568 differ
diff --git a/tests/resources/testrepo/.gitted/objects/af/e4393b2b2a965f06acf2ca9658eaa01e0cd6b6 b/tests/resources/testrepo/.gitted/objects/af/e4393b2b2a965f06acf2ca9658eaa01e0cd6b6
new file mode 100644
index 000000000..6948f1b1c
Binary files /dev/null and b/tests/resources/testrepo/.gitted/objects/af/e4393b2b2a965f06acf2ca9658eaa01e0cd6b6 differ
diff --git a/tests/resources/testrepo/.gitted/objects/ce/054d4c5e3c83522aed8bc061987b46b7ede3be b/tests/resources/testrepo/.gitted/objects/ce/054d4c5e3c83522aed8bc061987b46b7ede3be
new file mode 100644
index 000000000..4910e4c0a
Binary files /dev/null and b/tests/resources/testrepo/.gitted/objects/ce/054d4c5e3c83522aed8bc061987b46b7ede3be differ
-- 
cgit v1.2.3


From 238e8149724ea462153cc082385f60dccc2a3cf9 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 22 Jan 2014 14:41:04 -0500
Subject: Summarize empty messages

---
 src/commit.c          | 5 ++++-
 tests/commit/commit.c | 4 ++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/commit.c b/src/commit.c
index f0e304a84..e437cffe6 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -311,7 +311,10 @@ const char *git_commit_summary(git_commit *commit)
 				git_buf_putc(&summary, *msg);
 		}
 
-		commit->summary = git_buf_detach(&summary);
+		if (summary.asize == 0)
+			commit->summary = git__strdup("");
+		else
+			commit->summary = git_buf_detach(&summary);
 	}
 
 	return commit->summary;
diff --git a/tests/commit/commit.c b/tests/commit/commit.c
index 4af9190b5..38397d2df 100644
--- a/tests/commit/commit.c
+++ b/tests/commit/commit.c
@@ -72,4 +72,8 @@ void test_commit_commit__summary(void)
 	assert_commit_summary("Trailing spaces  are removed", "Trailing spaces  are removed  ");
 	assert_commit_summary("Trailing tabs", "Trailing tabs\t\n\nare removed");
 	assert_commit_summary("Trailing spaces", "Trailing spaces \n\nare removed");
+	assert_commit_summary("", "");
+	assert_commit_summary("", " ");
+	assert_commit_summary("", "\n");
+	assert_commit_summary("", "\n \n");
 }
-- 
cgit v1.2.3


From ab4bcc038aebb68975935809cd328fc9ccb70ba7 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 22 Jan 2014 14:14:37 -0800
Subject: Plug a small memory leak

---
 src/checkout.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/checkout.c b/src/checkout.c
index 962929075..6769cbc3d 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -753,8 +753,11 @@ static int checkout_conflicts_load(checkout_data *data, git_iterator *workdir, g
 		conflict->theirs = theirs;
 
 		if ((error = checkout_conflict_detect_submodule(conflict)) < 0 ||
-			(error = checkout_conflict_detect_binary(data->repo, conflict)) < 0)
+		    (error = checkout_conflict_detect_binary(data->repo, conflict)) < 0)
+		{
+			git__free(conflict);
 			goto done;
+		}
 
 		git_vector_insert(&data->conflicts, conflict);
 	}
-- 
cgit v1.2.3


From 410a8e6fede33f0330d9cda36cc5f01546133eae Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 22 Jan 2014 18:31:25 -0500
Subject: Sometimes a zero byte file is just a zero byte file

Don't go to the ODB to resolve zero byte files in the workdir
---
 src/diff_tform.c       |  2 +-
 tests/status/renames.c | 28 ++++++++++++++++++++++++++++
 2 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index 263a64d12..fc1b1d586 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -472,7 +472,7 @@ static int similarity_init(
 	info->blob = NULL;
 	git_buf_init(&info->data, 0);
 
-	if (info->file->size > 0)
+	if (info->file->size > 0 || info->src == GIT_ITERATOR_TYPE_WORKDIR)
 		return 0;
 
 	return git_diff_file__resolve_zero_size(
diff --git a/tests/status/renames.c b/tests/status/renames.c
index 16fd02676..a81910e36 100644
--- a/tests/status/renames.c
+++ b/tests/status/renames.c
@@ -555,3 +555,31 @@ void test_status_renames__both_casechange_two(void)
 
 	git_index_free(index);
 }
+
+void test_status_renames__zero_byte_file_does_not_fail(void)
+{
+	git_status_list *statuslist;
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	status_entry_counts counts = {0};
+
+	struct status_entry expected[] = {
+		{ GIT_STATUS_WT_DELETED, "ikeepsix.txt", "ikeepsix.txt" },
+		{ GIT_STATUS_WT_NEW, "zerobyte.txt", "zerobyte.txt" },
+	};
+
+	opts.flags |= GIT_STATUS_OPT_RENAMES_FROM_REWRITES |
+		GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX |
+		GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR |
+		GIT_STATUS_OPT_INCLUDE_IGNORED |
+		GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS |
+		GIT_STATUS_SHOW_INDEX_AND_WORKDIR |
+		GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
+
+	p_unlink("renames/ikeepsix.txt");
+	cl_git_mkfile("renames/zerobyte.txt", "");
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	test_status(statuslist, expected, 2);
+	git_status_list_free(statuslist);
+}
-- 
cgit v1.2.3


From 8610487cd321052d156202b7dd213add29fe6b21 Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Thu, 23 Jan 2014 23:28:28 +0800
Subject: Drop parsing pack filename SHA1 part, no one cares the filename

---
 src/pack.c | 5 -----
 src/pack.h | 1 -
 2 files changed, 6 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index 23fcf3530..de038a45c 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -997,11 +997,6 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
 		return -1;
 	}
 
-	/* see if we can parse the sha1 oid in the packfile name */
-	if (path_len < 40 ||
-		git_oid_fromstr(&p->sha1, path + path_len - GIT_OID_HEXSZ) < 0)
-		memset(&p->sha1, 0x0, GIT_OID_RAWSZ);
-
 	*pack_out = p;
 
 	return 0;
diff --git a/src/pack.h b/src/pack.h
index 28146ab30..58f81e2f0 100644
--- a/src/pack.h
+++ b/src/pack.h
@@ -88,7 +88,6 @@ struct git_pack_file {
 	int index_version;
 	git_time_t mtime;
 	unsigned pack_local:1, pack_keep:1, has_cache:1;
-	git_oid sha1;
 	git_oidmap *idx_cache;
 	git_oid **oids;
 
-- 
cgit v1.2.3


From d0a3de720e085d335d9ad46dc00a23dd03eda793 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 24 Jan 2014 11:18:51 +0100
Subject: note: rename the id getter to git_note_id()

This was left over when we did the general switch.
---
 include/git2/notes.h   | 6 +++---
 src/notes.c            | 6 +++---
 src/notes.h            | 2 +-
 tests/notes/notes.c    | 4 ++--
 tests/notes/notesref.c | 4 ++--
 5 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/include/git2/notes.h b/include/git2/notes.h
index 0cb6ce5f1..98eb2aef3 100644
--- a/include/git2/notes.h
+++ b/include/git2/notes.h
@@ -106,12 +106,12 @@ GIT_EXTERN(const char *) git_note_message(const git_note *note);
 
 
 /**
- * Get the note object OID
+ * Get the note object's id
  *
  * @param note the note
- * @return the note object OID
+ * @return the note object's id
  */
-GIT_EXTERN(const git_oid *) git_note_oid(const git_note *note);
+GIT_EXTERN(const git_oid *) git_note_id(const git_note *note);
 
 /**
  * Add a note for an object
diff --git a/src/notes.c b/src/notes.c
index 795904917..1ff0e35c3 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -313,7 +313,7 @@ static int note_new(git_note **out, git_oid *note_oid, git_blob *blob)
 	note = (git_note *)git__malloc(sizeof(git_note));
 	GITERR_CHECK_ALLOC(note);
 
-	git_oid_cpy(&note->oid, note_oid);
+	git_oid_cpy(&note->id, note_oid);
 	note->message = git__strdup((char *)git_blob_rawcontent(blob));
 	GITERR_CHECK_ALLOC(note->message);
 
@@ -508,10 +508,10 @@ const char * git_note_message(const git_note *note)
 	return note->message;
 }
 
-const git_oid * git_note_oid(const git_note *note)
+const git_oid * git_note_id(const git_note *note)
 {
 	assert(note);
-	return &note->oid;
+	return &note->id;
 }
 
 void git_note_free(git_note *note)
diff --git a/src/notes.h b/src/notes.h
index 39e18b621..e9cfa00fa 100644
--- a/src/notes.h
+++ b/src/notes.h
@@ -21,7 +21,7 @@
 	"Notes removed by 'git_note_remove' from libgit2"
 
 struct git_note {
-	git_oid oid;
+	git_oid id;
 
 	char *message;
 };
diff --git a/tests/notes/notes.c b/tests/notes/notes.c
index c2579a2c4..e48d9df0e 100644
--- a/tests/notes/notes.c
+++ b/tests/notes/notes.c
@@ -21,7 +21,7 @@ static void assert_note_equal(git_note *note, char *message, git_oid *note_oid)
 	git_blob *blob;
 
 	cl_assert_equal_s(git_note_message(note), message);
-	cl_assert(!git_oid_cmp(git_note_oid(note), note_oid));
+	cl_assert(!git_oid_cmp(git_note_id(note), note_oid));
 
 	cl_git_pass(git_blob_lookup(&blob, _repo, note_oid));
 	cl_assert_equal_s(git_note_message(note), (const char *)git_blob_rawcontent(blob));
@@ -290,7 +290,7 @@ void test_notes_notes__can_read_a_note_in_an_existing_fanout(void)
 	cl_git_pass(git_note_read(&note, _repo, "refs/notes/fanout", &target_oid));
 
 	cl_git_pass(git_oid_fromstr(&note_oid, "08b041783f40edfe12bb406c9c9a8a040177c125"));
-	cl_assert(!git_oid_cmp(git_note_oid(note), &note_oid));
+	cl_assert(!git_oid_cmp(git_note_id(note), &note_oid));
 
 	git_note_free(note);
 }
diff --git a/tests/notes/notesref.c b/tests/notes/notesref.c
index c89b71ba5..a33141979 100644
--- a/tests/notes/notesref.c
+++ b/tests/notes/notesref.c
@@ -46,13 +46,13 @@ void test_notes_notesref__config_corenotesref(void)
 
 	cl_git_pass(git_note_read(&_note, _repo, NULL, &oid));
 	cl_assert_equal_s("test123test\n", git_note_message(_note));
-	cl_assert(!git_oid_cmp(git_note_oid(_note), &note_oid));
+	cl_assert(!git_oid_cmp(git_note_id(_note), &note_oid));
 
 	git_note_free(_note);
 
 	cl_git_pass(git_note_read(&_note, _repo, "refs/notes/mydefaultnotesref", &oid));
 	cl_assert_equal_s("test123test\n", git_note_message(_note));
-	cl_assert(!git_oid_cmp(git_note_oid(_note), &note_oid));
+	cl_assert(!git_oid_cmp(git_note_id(_note), &note_oid));
 
 	cl_git_pass(git_note_default_ref(&default_ref, _repo));
 	cl_assert_equal_s("refs/notes/mydefaultnotesref", default_ref);
-- 
cgit v1.2.3


From a5a386436b823257b9e1b1365d3e36c00a1a5d89 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 20 Jan 2014 14:53:59 -0800
Subject: Initial take on builtin drivers with multiline

This extends the diff driver parser to support multiline driver
definitions along with ! prefixing for negated matches.  This
brings the driver function pattern parsing in line with core Git.

This also adds an internal table of driver definitions and a
fallback code path that will look in that table for diff drivers
that are set with attributes without having a definition in the
config file.  Right now, I just populated the table with a kind
of simple HTML definition that is similar to the core Git def.
---
 src/diff_driver.c | 181 +++++++++++++++++++++++++++++++++++++++++-------------
 src/diff_driver.h |   2 +-
 2 files changed, 140 insertions(+), 43 deletions(-)

diff --git a/src/diff_driver.c b/src/diff_driver.c
index 167c0cc5a..dcd74adf0 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -26,10 +26,13 @@ typedef enum {
 	DIFF_DRIVER_PATTERNLIST = 3,
 } git_diff_driver_t;
 
+typedef struct {
+	regex_t re;
+	int flags;
+} git_diff_driver_pattern;
+
 enum {
-	DIFF_CONTEXT_FIND_NORMAL = 0,
-	DIFF_CONTEXT_FIND_ICASE = (1 << 0),
-	DIFF_CONTEXT_FIND_EXT = (1 << 1),
+	REG_NEGATE = (1 << 15) /* get out of the way of existing flags */
 };
 
 /* data for finding function context for a given file type */
@@ -37,11 +40,22 @@ struct git_diff_driver {
 	git_diff_driver_t type;
 	uint32_t binary_flags;
 	uint32_t other_flags;
-	git_array_t(regex_t) fn_patterns;
+	git_array_t(git_diff_driver_pattern) fn_patterns;
 	regex_t  word_pattern;
 	char name[GIT_FLEX_ARRAY];
 };
 
+typedef struct {
+	const char *name;
+	const char *fns;
+	const char *words;
+	int flags;
+} git_diff_driver_definition;
+
+static git_diff_driver_definition builtin_defs[] = {
+	{ "html", "^[ \t]*(<h[1-8]([ \t][^>]*)?>.*)$", "[^<> \t]+", REG_ICASE },
+};
+
 struct git_diff_driver_registry {
 	git_strmap *drivers;
 };
@@ -81,34 +95,59 @@ void git_diff_driver_registry_free(git_diff_driver_registry *reg)
 	git__free(reg);
 }
 
-static int diff_driver_add_funcname(
-	git_diff_driver *drv, const char *name, int regex_flags)
+static int diff_driver_add_patterns(
+	git_diff_driver *drv, const char *regex_str, int regex_flags)
 {
-	int error;
-	regex_t re, *re_ptr;
+	int error = 0;
+	const char *scan, *end;
+	git_diff_driver_pattern *pat = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	for (scan = regex_str; scan; scan = end) {
+		/* get pattern to fill in */
+		if ((pat = git_array_alloc(drv->fn_patterns)) == NULL) {
+			error = -1;
+			break;
+		}
 
-	if ((error = regcomp(&re, name, regex_flags)) != 0) {
-		/* TODO: warning about bad regex instead of failure */
-		error = giterr_set_regex(&re, error);
-		regfree(&re);
-		return error;
+		pat->flags = regex_flags;
+		if (*scan == '!') {
+			pat->flags |= REG_NEGATE;
+			++scan;
+		}
+
+		if ((end = strchr(scan, '\n')) != NULL) {
+			error = git_buf_set(&buf, scan, end - scan);
+			end++;
+		} else {
+			error = git_buf_sets(&buf, scan);
+		}
+		if (error < 0)
+			break;
+
+		if ((error = regcomp(&pat->re, buf.ptr, regex_flags)) < 0) {
+			/* if regex fails to compile, warn? fail? */
+			error = giterr_set_regex(&pat->re, error);
+			regfree(&pat->re);
+			break;
+		}
 	}
 
-	re_ptr = git_array_alloc(drv->fn_patterns);
-	GITERR_CHECK_ALLOC(re_ptr);
+	if (error && pat != NULL)
+		(void)git_array_pop(drv->fn_patterns); /* release last item */
+	git_buf_free(&buf);
 
-	memcpy(re_ptr, &re, sizeof(re));
-	return 0;
+	return error;
 }
 
 static int diff_driver_xfuncname(const git_config_entry *entry, void *payload)
 {
-	return diff_driver_add_funcname(payload, entry->value, REG_EXTENDED);
+	return diff_driver_add_patterns(payload, entry->value, REG_EXTENDED);
 }
 
 static int diff_driver_funcname(const git_config_entry *entry, void *payload)
 {
-	return diff_driver_add_funcname(payload, entry->value, 0);
+	return diff_driver_add_patterns(payload, entry->value, 0);
 }
 
 static git_diff_driver_registry *git_repository_driver_registry(
@@ -128,12 +167,65 @@ static git_diff_driver_registry *git_repository_driver_registry(
 	return repo->diff_drivers;
 }
 
+static int git_diff_driver_builtin(
+	git_diff_driver **out,
+	git_diff_driver_registry *reg,
+	const char *driver_name)
+{
+	int error = 0;
+	git_diff_driver_definition *ddef = NULL;
+	git_diff_driver *drv = NULL;
+	size_t namelen, idx;
+
+	for (idx = 0; idx < ARRAY_SIZE(builtin_defs); ++idx) {
+		if (!strcasecmp(driver_name, builtin_defs[idx].name)) {
+			ddef = &builtin_defs[idx];
+			break;
+		}
+	}
+	if (!ddef)
+		goto done;
+
+	namelen = strlen(ddef->name);
+
+	drv = git__calloc(1, sizeof(git_diff_driver) + namelen + 1);
+	GITERR_CHECK_ALLOC(drv);
+
+	drv->type = DIFF_DRIVER_PATTERNLIST;
+	memcpy(drv->name, ddef->name, namelen);
+
+	if (ddef->fns &&
+		(error = diff_driver_add_patterns(
+			drv, ddef->fns, ddef->flags | REG_EXTENDED)) < 0)
+		goto done;
+
+	if (ddef->words &&
+		(error = regcomp(
+			&drv->word_pattern, ddef->words, ddef->flags | REG_EXTENDED)))
+	{
+		error = giterr_set_regex(&drv->word_pattern, error);
+		goto done;
+	}
+
+	git_strmap_insert(reg->drivers, drv->name, drv, error);
+
+done:
+	if (error || !drv) {
+		git_diff_driver_free(drv);
+		*out = &global_drivers[DIFF_DRIVER_AUTO];
+	} else {
+		*out = drv;
+	}
+
+	return error;
+}
+
 static int git_diff_driver_load(
 	git_diff_driver **out, git_repository *repo, const char *driver_name)
 {
 	int error = 0;
 	git_diff_driver_registry *reg;
-	git_diff_driver *drv;
+	git_diff_driver *drv = NULL;
 	size_t namelen = strlen(driver_name);
 	khiter_t pos;
 	git_config *cfg;
@@ -141,21 +233,19 @@ static int git_diff_driver_load(
 	const git_config_entry *ce;
 	bool found_driver = false;
 
-	reg = git_repository_driver_registry(repo);
-	if (!reg)
+	if ((reg = git_repository_driver_registry(repo)) == NULL)
 		return -1;
-	else {
-		pos = git_strmap_lookup_index(reg->drivers, driver_name);
-		if (git_strmap_valid_index(reg->drivers, pos)) {
-			*out = git_strmap_value_at(reg->drivers, pos);
-			return 0;
-		}
+
+	pos = git_strmap_lookup_index(reg->drivers, driver_name);
+	if (git_strmap_valid_index(reg->drivers, pos)) {
+		*out = git_strmap_value_at(reg->drivers, pos);
+		return 0;
 	}
 
 	/* if you can't read config for repo, just use default driver */
 	if (git_repository_config__weakptr(&cfg, repo) < 0) {
 		giterr_clear();
-		return GIT_ENOTFOUND;
+		goto done;
 	}
 
 	drv = git__calloc(1, sizeof(git_diff_driver) + namelen + 1);
@@ -178,7 +268,7 @@ static int git_diff_driver_load(
 		found_driver = true;
 		break;
 	default:
-		/* diff.<driver>.binary unspecified, so just continue */
+		/* diff.<driver>.binary unspecified or "auto", so just continue */
 		break;
 	}
 
@@ -240,8 +330,11 @@ static int git_diff_driver_load(
 done:
 	git_buf_free(&name);
 
-	if (!*out)
-		*out = &global_drivers[DIFF_DRIVER_AUTO];
+	if (!*out) {
+		int error2 = git_diff_driver_builtin(out, reg, driver_name);
+		if (!error)
+			error = error2;
+	}
 
 	if (drv && drv != *out)
 		git_diff_driver_free(drv);
@@ -293,7 +386,7 @@ void git_diff_driver_free(git_diff_driver *driver)
 		return;
 
 	for (i = 0; i < git_array_size(driver->fn_patterns); ++i)
-		regfree(git_array_get(driver->fn_patterns, i));
+		regfree(& git_array_get(driver->fn_patterns, i)->re);
 	git_array_clear(driver->fn_patterns);
 
 	regfree(&driver->word_pattern);
@@ -330,23 +423,28 @@ int git_diff_driver_content_is_binary(
 }
 
 static int diff_context_line__simple(
-	git_diff_driver *driver, const char *line, size_t line_len)
+	git_diff_driver *driver, git_buf *line)
 {
+	char firstch = line->ptr[0];
 	GIT_UNUSED(driver);
-	GIT_UNUSED(line_len);
-	return (git__isalpha(*line) || *line == '_' || *line == '$');
+	return (git__isalpha(firstch) || firstch == '_' || firstch == '$');
 }
 
 static int diff_context_line__pattern_match(
-	git_diff_driver *driver, const char *line, size_t line_len)
+	git_diff_driver *driver, git_buf *line)
 {
 	size_t i;
-
-	GIT_UNUSED(line_len);
+	regmatch_t pmatch[2];
 
 	for (i = 0; i < git_array_size(driver->fn_patterns); ++i) {
-		if (!regexec(git_array_get(driver->fn_patterns, i), line, 0, NULL, 0))
+		git_diff_driver_pattern *pat = git_array_get(driver->fn_patterns, i);
+
+		if (!regexec(&pat->re, line->ptr, 2, pmatch, 0)) {
+			if (pat->flags & REG_NEGATE)
+				return false;
+			/* TODO: use pmatch data to trim line data */
 			return true;
+		}
 	}
 
 	return false;
@@ -368,8 +466,7 @@ static long diff_context_find(
 	if (!ctxt->line.size)
 		return -1;
 
-	if (!ctxt->match_line ||
-		!ctxt->match_line(ctxt->driver, ctxt->line.ptr, ctxt->line.size))
+	if (!ctxt->match_line || !ctxt->match_line(ctxt->driver, &ctxt->line))
 		return -1;
 
 	if (out_size > (long)ctxt->line.size)
diff --git a/src/diff_driver.h b/src/diff_driver.h
index 9d3f18660..0706dcfc5 100644
--- a/src/diff_driver.h
+++ b/src/diff_driver.h
@@ -31,7 +31,7 @@ typedef long (*git_diff_find_context_fn)(
 	const char *, long, char *, long, void *);
 
 typedef int (*git_diff_find_context_line)(
-	git_diff_driver *, const char *, size_t);
+	git_diff_driver *, git_buf *);
 
 typedef struct {
 	git_diff_driver *driver;
-- 
cgit v1.2.3


From 2c65602e45964f695bda91a6b1cfbf6b2f4903ea Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 21 Jan 2014 10:39:27 -0800
Subject: Import git drivers and test HTML driver

Reorganize the builtin driver table slightly so that core Git
builtin definitions can be imported verbatim.  Then take a few of
the core Git drivers and pull them in.

This also creates a test of diffs with the builtin HTML driver
which led to some small error handling fixes in the driver
selection logic.
---
 src/diff_driver.c    |  59 +++++++++++++++++-------
 tests/diff/drivers.c | 123 +++++++++++++++++++++++++++++++++++++++++----------
 2 files changed, 142 insertions(+), 40 deletions(-)

diff --git a/src/diff_driver.c b/src/diff_driver.c
index dcd74adf0..169f7b025 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -52,10 +52,38 @@ typedef struct {
 	int flags;
 } git_diff_driver_definition;
 
+#define WORD_DEFAULT "|[^[:space:]]|[\xc0-\xff][\x80-\xbf]+"
+
+/* builtin driver definition macros have same signature as in core git
+ * userdiff.c so that the data can be extracted verbatim
+ */
+#define PATTERNS(NAME, FN_PATS, WORD_PAT) \
+	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, 0 }
+#define IPATTERN(NAME, FN_PATS, WORD_PAT) \
+	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, REG_ICASE }
+
 static git_diff_driver_definition builtin_defs[] = {
-	{ "html", "^[ \t]*(<h[1-8]([ \t][^>]*)?>.*)$", "[^<> \t]+", REG_ICASE },
+PATTERNS("html", "^[ \t]*(<[Hh][1-6][ \t].*>.*)$",
+	 "[^<>= \t]+"),
+PATTERNS("java",
+	 "!^[ \t]*(catch|do|for|if|instanceof|new|return|switch|throw|while)\n"
+	 "^[ \t]*(([A-Za-z_][A-Za-z_0-9]*[ \t]+)+[A-Za-z_][A-Za-z_0-9]*[ \t]*\\([^;]*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
+	 "|[-+*/<>%&^|=!]="
+	 "|--|\\+\\+|<<=?|>>>?=?|&&|\\|\\|"),
+PATTERNS("ruby", "^[ \t]*((class|module|def)[ \t].*)$",
+	 /* -- */
+	 "(@|@@|\\$)?[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+|0[xXbB]?[0-9a-fA-F]+|\\?(\\\\C-)?(\\\\M-)?."
+	 "|//=?|[-+*/<>%&^|=!]=|<<=?|>>=?|===|\\.{1,3}|::|[!=]~"),
 };
 
+#undef IPATTERN
+#undef PATTERNS
+#undef WORD_DEFAULT
+
 struct git_diff_driver_registry {
 	git_strmap *drivers;
 };
@@ -208,14 +236,14 @@ static int git_diff_driver_builtin(
 	}
 
 	git_strmap_insert(reg->drivers, drv->name, drv, error);
+	if (error > 0)
+		error = 0;
 
 done:
-	if (error || !drv) {
+	if (error && drv)
 		git_diff_driver_free(drv);
-		*out = &global_drivers[DIFF_DRIVER_AUTO];
-	} else {
+	else
 		*out = drv;
-	}
 
 	return error;
 }
@@ -324,6 +352,7 @@ static int git_diff_driver_load(
 	git_strmap_insert(reg->drivers, drv->name, drv, error);
 	if (error < 0)
 		goto done;
+	error = 0;
 
 	*out = drv;
 
@@ -349,14 +378,13 @@ int git_diff_driver_lookup(
 	const char *value;
 
 	assert(out);
+	*out = NULL;
 
 	if (!repo || !path || !strlen(path))
-		goto use_auto;
-
-	if ((error = git_attr_get(&value, repo, 0, path, "diff")) < 0)
-		return error;
-
-	if (GIT_ATTR_UNSPECIFIED(value))
+		/* just use the auto value */;
+	else if ((error = git_attr_get(&value, repo, 0, path, "diff")) < 0)
+		/* return error below */;
+	else if (GIT_ATTR_UNSPECIFIED(value))
 		/* just use the auto value */;
 	else if (GIT_ATTR_FALSE(value))
 		*out = &global_drivers[DIFF_DRIVER_BINARY];
@@ -365,17 +393,16 @@ int git_diff_driver_lookup(
 
 	/* otherwise look for driver information in config and build driver */
 	else if ((error = git_diff_driver_load(out, repo, value)) < 0) {
-		if (error != GIT_ENOTFOUND)
-			return error;
-		else
+		if (error == GIT_ENOTFOUND) {
+			error = 0;
 			giterr_clear();
+		}
 	}
 
-use_auto:
 	if (!*out)
 		*out = &global_drivers[DIFF_DRIVER_AUTO];
 
-	return 0;
+	return error;
 }
 
 void git_diff_driver_free(git_diff_driver *driver)
diff --git a/tests/diff/drivers.c b/tests/diff/drivers.c
index c80fad4c2..4524cd0db 100644
--- a/tests/diff/drivers.c
+++ b/tests/diff/drivers.c
@@ -15,6 +15,15 @@ void test_diff_drivers__cleanup(void)
 	g_repo = NULL;
 }
 
+static void overwrite_chmod_at_offset(git_buf *buf, size_t offset)
+{
+	if (cl_is_chmod_supported())
+		return;
+
+	if (buf->size > offset + 6 && memcmp(&buf->ptr[offset], "100644", 6) != 0)
+		memcpy(&buf->ptr[offset], "100644", 6);
+}
+
 void test_diff_drivers__patterns(void)
 {
 	git_config *cfg;
@@ -22,7 +31,7 @@ void test_diff_drivers__patterns(void)
 	git_tree *one;
 	git_diff *diff;
 	git_patch *patch;
-	git_buf buf = GIT_BUF_INIT;
+	git_buf actual = GIT_BUF_INIT;
 	const char *expected0 = "diff --git a/untimely.txt b/untimely.txt\nindex 9a69d96..57fd0cf 100644\n--- a/untimely.txt\n+++ b/untimely.txt\n@@ -22,3 +22,5 @@ Comes through the blood of the vanguards who\n   dreamed--too soon--it had sounded.\r\n \r\n                 -- Rudyard Kipling\r\n+\r\n+Some new stuff\r\n";
 	const char *expected1 = "diff --git a/untimely.txt b/untimely.txt\nindex 9a69d96..57fd0cf 100644\nBinary files a/untimely.txt and b/untimely.txt differ\n";
 	const char *expected2 = "diff --git a/untimely.txt b/untimely.txt\nindex 9a69d96..57fd0cf 100644\n--- a/untimely.txt\n+++ b/untimely.txt\n@@ -22,3 +22,5 @@ Heaven delivers on earth the Hour that cannot be\n   dreamed--too soon--it had sounded.\r\n \r\n                 -- Rudyard Kipling\r\n+\r\n+Some new stuff\r\n";
@@ -45,10 +54,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_buf(&buf, patch));
-	cl_assert_equal_s(expected0, buf.ptr);
+	cl_git_pass(git_patch_to_buf(&actual, patch));
+	cl_assert_equal_s(expected0, actual.ptr);
 
-	git_buf_free(&buf);
+	git_buf_free(&actual);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -60,10 +69,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_buf(&buf, patch));
-	cl_assert_equal_s(expected1, buf.ptr);
+	cl_git_pass(git_patch_to_buf(&actual, patch));
+	cl_assert_equal_s(expected1, actual.ptr);
 
-	git_buf_free(&buf);
+	git_buf_free(&actual);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -75,10 +84,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_buf(&buf, patch));
-	cl_assert_equal_s(expected0, buf.ptr);
+	cl_git_pass(git_patch_to_buf(&actual, patch));
+	cl_assert_equal_s(expected0, actual.ptr);
 
-	git_buf_free(&buf);
+	git_buf_free(&actual);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -92,10 +101,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_buf(&buf, patch));
-	cl_assert_equal_s(expected1, buf.ptr);
+	cl_git_pass(git_patch_to_buf(&actual, patch));
+	cl_assert_equal_s(expected1, actual.ptr);
 
-	git_buf_free(&buf);
+	git_buf_free(&actual);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -113,10 +122,10 @@ void test_diff_drivers__patterns(void)
 	cl_assert_equal_i(1, (int)git_diff_num_deltas(diff));
 
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_buf(&buf, patch));
-	cl_assert_equal_s(expected2, buf.ptr);
+	cl_git_pass(git_patch_to_buf(&actual, patch));
+	cl_assert_equal_s(expected2, actual.ptr);
 
-	git_buf_free(&buf);
+	git_buf_free(&actual);
 	git_patch_free(patch);
 	git_diff_free(diff);
 
@@ -129,7 +138,7 @@ void test_diff_drivers__long_lines(void)
 	git_index *idx;
 	git_diff *diff;
 	git_patch *patch;
-	git_buf buf = GIT_BUF_INIT;
+	git_buf actual = GIT_BUF_INIT;
 	const char *expected = "diff --git a/longlines.txt b/longlines.txt\nindex c1ce6ef..0134431 100644\n--- a/longlines.txt\n+++ b/longlines.txt\n@@ -3,3 +3,5 @@ Phasellus eget erat odio. Praesent at est iaculis, ultricies augue vel, dignissi\n Nam eget dolor fermentum, aliquet nisl at, convallis tellus. Pellentesque rhoncus erat enim, id porttitor elit euismod quis.\n Mauris sollicitudin magna odio, non egestas libero vehicula ut. Etiam et quam velit. Fusce eget libero rhoncus, ultricies felis sit amet, egestas purus.\n Aliquam in semper tellus. Pellentesque adipiscing rutrum velit, quis malesuada lacus consequat eget.\n+newline\n+newline\n";
 
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
@@ -145,18 +154,84 @@ void test_diff_drivers__long_lines(void)
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
 	cl_assert_equal_sz(1, git_diff_num_deltas(diff));
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_buf(&buf, patch));
+	cl_git_pass(git_patch_to_buf(&actual, patch));
 
 	/* if chmod not supported, overwrite mode bits since anything is possible */
-	if (!cl_is_chmod_supported()) {
-		if (buf.size > 72 && memcmp(&buf.ptr[66], "100644", 6) != 0)
-			memcpy(&buf.ptr[66], "100644", 6);
-	}
+	overwrite_chmod_at_offset(&actual, 66);
 
-	cl_assert_equal_s(expected, buf.ptr);
+	cl_assert_equal_s(expected, actual.ptr);
 
-	git_buf_free(&buf);
+	git_buf_free(&actual);
 	git_patch_free(patch);
 	git_diff_free(diff);
 }
 
+void test_diff_drivers__builtins(void)
+{
+	git_index *idx;
+	git_diff *diff;
+	git_patch *patch;
+	git_buf actual = GIT_BUF_INIT;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *base =
+		"<html>\n<body>\n"
+		"  <h1 id=\"first section\">\n  <ol>\n    <li>item 1.1</li>\n    <li>item 1.2</li>\n    <li>item 1.3</li>\n    <li>item 1.4</li>\n    <li>item 1.5</li>\n    <li>item 1.6</li>\n    <li>item 1.7</li>\n    <li>item 1.8</li>\n    <li>item 1.9</li>\n  </ol>\n  </h1>\n"
+		"  <h1 id=\"second section\">\n  <ol>\n    <li>item 2.1</li>\n    <li>item 2.2</li>\n    <li>item 2.3</li>\n    <li>item 2.4</li>\n    <li>item 2.5</li>\n    <li>item 2.6</li>\n    <li>item 2.7</li>\n    <li>item 2.8</li>\n  </ol>\n  </h1>\n"
+		"  <h1 id=\"third section\">\n  <ol>\n    <li>item 3.1</li>\n    <li>item 3.2</li>\n    <li>item 3.3</li>\n    <li>item 3.4</li>\n    <li>item 3.5</li>\n    <li>item 3.6</li>\n    <li>item 3.7</li>\n    <li>item 3.8</li>\n  </ol>\n  </h1>\n"
+		"</body></html>\n";
+	const char *modified =
+		"<html>\n<body>\n"
+		"  <h1 id=\"first section\">\n  <ol>\n    <li>item 1.1</li>\n    <li>item 1.2 changed</li>\n    <li>item 1.3 changed</li>\n    <li>item 1.4</li>\n    <li>item 1.5</li>\n    <li>item 1.6</li>\n    <li>item 1.7</li>\n    <li>item 1.8</li>\n    <li>item 1.9</li>\n  <li>item 1.10 added</li>\n  </ol>\n  </h1>\n"
+		"  <h1 id=\"second section\">\n  <ol>\n    <li>item 2.1</li>\n    <li>item 2.2</li>\n    <li>item 2.3</li>\n    <li>item 2.4</li>\n    <li>item 2.5</li>\n    <li>item 2.6</li>\n    <li>item 2.7 changed</li>\n    <li>item 2.7.1 added</li>\n    <li>item 2.8</li>\n  </ol>\n  </h1>\n"
+		"  <h1 id=\"third section\">\n  <ol>\n    <li>item 3.1</li>\n    <li>item 3.2</li>\n    <li>item 3.3</li>\n    <li>item 3.4</li>\n    <li>item 3.5</li>\n    <li>item 3.6</li>\n  </ol>\n  </h1>\n"
+		"</body></html>\n";
+	const char *expected_nodriver =
+		"diff --git a/file.html b/file.html\nindex 97b34db..c7dbed3 100644\n--- a/file.html\n+++ b/file.html\n@@ -5,4 +5,4 @@\n     <li>item 1.1</li>\n-    <li>item 1.2</li>\n-    <li>item 1.3</li>\n+    <li>item 1.2 changed</li>\n+    <li>item 1.3 changed</li>\n     <li>item 1.4</li>\n@@ -13,2 +13,3 @@\n     <li>item 1.9</li>\n+  <li>item 1.10 added</li>\n   </ol>\n@@ -23,3 +24,4 @@\n     <li>item 2.6</li>\n-    <li>item 2.7</li>\n+    <li>item 2.7 changed</li>\n+    <li>item 2.7.1 added</li>\n     <li>item 2.8</li>\n@@ -35,4 +37,2 @@\n     <li>item 3.6</li>\n-    <li>item 3.7</li>\n-    <li>item 3.8</li>\n   </ol>\n";
+	const char *expected_driver =
+		"diff --git a/file.html b/file.html\nindex 97b34db..c7dbed3 100644\n--- a/file.html\n+++ b/file.html\n@@ -5,4 +5,4 @@   <h1 id=\"first section\">\n     <li>item 1.1</li>\n-    <li>item 1.2</li>\n-    <li>item 1.3</li>\n+    <li>item 1.2 changed</li>\n+    <li>item 1.3 changed</li>\n     <li>item 1.4</li>\n@@ -13,2 +13,3 @@   <h1 id=\"first section\">\n     <li>item 1.9</li>\n+  <li>item 1.10 added</li>\n   </ol>\n@@ -23,3 +24,4 @@   <h1 id=\"second section\">\n     <li>item 2.6</li>\n-    <li>item 2.7</li>\n+    <li>item 2.7 changed</li>\n+    <li>item 2.7.1 added</li>\n     <li>item 2.8</li>\n@@ -35,4 +37,2 @@   <h1 id=\"third section\">\n     <li>item 3.6</li>\n-    <li>item 3.7</li>\n-    <li>item 3.8</li>\n   </ol>\n";
+
+	g_repo = cl_git_sandbox_init("empty_standard_repo");
+
+	cl_git_mkfile("empty_standard_repo/file.html", base);
+	cl_git_pass(git_repository_index(&idx, g_repo));
+	cl_git_pass(git_index_add_bypath(idx, "file.html"));
+	cl_git_pass(git_index_write(idx));
+	git_index_free(idx);
+
+	cl_git_rewritefile("empty_standard_repo/file.html", modified);
+
+	/* do diff with no special driver */
+
+	opts.interhunk_lines = 1;
+	opts.context_lines = 1;
+
+	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+	cl_assert_equal_sz(1, git_diff_num_deltas(diff));
+	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
+	cl_git_pass(git_patch_to_buf(&actual, patch));
+
+	overwrite_chmod_at_offset(&actual, 59);
+
+	cl_assert_equal_s(expected_nodriver, actual.ptr);
+
+	git_buf_free(&actual);
+	git_patch_free(patch);
+	git_diff_free(diff);
+
+	/* do diff with HTML driver */
+
+	cl_git_mkfile("empty_standard_repo/.gitattributes", "*.html diff=html\n");
+
+	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+	cl_assert_equal_sz(1, git_diff_num_deltas(diff));
+	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
+	cl_git_pass(git_patch_to_buf(&actual, patch));
+
+	overwrite_chmod_at_offset(&actual, 59);
+
+	cl_assert_equal_s(expected_driver, actual.ptr);
+
+	git_buf_free(&actual);
+	git_patch_free(patch);
+	git_diff_free(diff);
+}
-- 
cgit v1.2.3


From 9bbc53d6d424cbdc8b5ca47f6a85b49794c516fe Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 21 Jan 2014 11:36:43 -0800
Subject: Fix filemode updating in diff text

---
 tests/diff/drivers.c | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/tests/diff/drivers.c b/tests/diff/drivers.c
index 4524cd0db..003a84485 100644
--- a/tests/diff/drivers.c
+++ b/tests/diff/drivers.c
@@ -15,13 +15,21 @@ void test_diff_drivers__cleanup(void)
 	g_repo = NULL;
 }
 
-static void overwrite_chmod_at_offset(git_buf *buf, size_t offset)
+static void overwrite_filemode(const char *expected, git_buf *actual)
 {
-	if (cl_is_chmod_supported())
+	size_t offset;
+	char *found;
+
+	found = strstr(expected, "100644");
+	if (!found)
+		return;
+
+	offset = ((const char *)found) - expected;
+	if (actual->size < offset + 6)
 		return;
 
-	if (buf->size > offset + 6 && memcmp(&buf->ptr[offset], "100644", 6) != 0)
-		memcpy(&buf->ptr[offset], "100644", 6);
+	if (memcmp(&actual->ptr[offset], "100644", 6) != 0)
+		memcpy(&actual->ptr[offset], "100644", 6);
 }
 
 void test_diff_drivers__patterns(void)
@@ -157,7 +165,7 @@ void test_diff_drivers__long_lines(void)
 	cl_git_pass(git_patch_to_buf(&actual, patch));
 
 	/* if chmod not supported, overwrite mode bits since anything is possible */
-	overwrite_chmod_at_offset(&actual, 66);
+	overwrite_filemode(expected, &actual);
 
 	cl_assert_equal_s(expected, actual.ptr);
 
@@ -210,7 +218,7 @@ void test_diff_drivers__builtins(void)
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
 	cl_git_pass(git_patch_to_buf(&actual, patch));
 
-	overwrite_chmod_at_offset(&actual, 59);
+	overwrite_filemode(expected_nodriver, &actual);
 
 	cl_assert_equal_s(expected_nodriver, actual.ptr);
 
@@ -227,7 +235,7 @@ void test_diff_drivers__builtins(void)
 	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
 	cl_git_pass(git_patch_to_buf(&actual, patch));
 
-	overwrite_chmod_at_offset(&actual, 59);
+	overwrite_filemode(expected_driver, &actual);
 
 	cl_assert_equal_s(expected_driver, actual.ptr);
 
-- 
cgit v1.2.3


From b8e86c62f7512425e29f340a38152978d869e316 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 21 Jan 2014 12:00:08 -0800
Subject: Implement matched pattern extract for fn headers

---
 src/diff_driver.c    | 11 ++++++++---
 tests/diff/drivers.c |  4 ++--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/diff_driver.c b/src/diff_driver.c
index 169f7b025..56b5b5a51 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -460,16 +460,21 @@ static int diff_context_line__simple(
 static int diff_context_line__pattern_match(
 	git_diff_driver *driver, git_buf *line)
 {
-	size_t i;
+	size_t i, maxi = git_array_size(driver->fn_patterns);
 	regmatch_t pmatch[2];
 
-	for (i = 0; i < git_array_size(driver->fn_patterns); ++i) {
+	for (i = 0; i < maxi; ++i) {
 		git_diff_driver_pattern *pat = git_array_get(driver->fn_patterns, i);
 
 		if (!regexec(&pat->re, line->ptr, 2, pmatch, 0)) {
 			if (pat->flags & REG_NEGATE)
 				return false;
-			/* TODO: use pmatch data to trim line data */
+
+			/* use pmatch data to trim line data */
+			i = (pmatch[1].rm_so >= 0) ? 1 : 0;
+			git_buf_consume(line, git_buf_cstr(line) + pmatch[i].rm_so);
+			git_buf_truncate(line, pmatch[i].rm_eo - pmatch[i].rm_so);
+
 			return true;
 		}
 	}
diff --git a/tests/diff/drivers.c b/tests/diff/drivers.c
index 003a84485..119132149 100644
--- a/tests/diff/drivers.c
+++ b/tests/diff/drivers.c
@@ -123,7 +123,7 @@ void test_diff_drivers__patterns(void)
 
 	cl_git_pass(git_repository_config(&cfg, g_repo));
 	cl_git_pass(git_config_set_bool(cfg, "diff.kipling0.binary", 0));
-	cl_git_pass(git_config_set_string(cfg, "diff.kipling0.xfuncname", "^H"));
+	cl_git_pass(git_config_set_string(cfg, "diff.kipling0.xfuncname", "^H.*$"));
 	git_config_free(cfg);
 
 	cl_git_pass(git_diff_tree_to_workdir(&diff, g_repo, one, NULL));
@@ -196,7 +196,7 @@ void test_diff_drivers__builtins(void)
 	const char *expected_nodriver =
 		"diff --git a/file.html b/file.html\nindex 97b34db..c7dbed3 100644\n--- a/file.html\n+++ b/file.html\n@@ -5,4 +5,4 @@\n     <li>item 1.1</li>\n-    <li>item 1.2</li>\n-    <li>item 1.3</li>\n+    <li>item 1.2 changed</li>\n+    <li>item 1.3 changed</li>\n     <li>item 1.4</li>\n@@ -13,2 +13,3 @@\n     <li>item 1.9</li>\n+  <li>item 1.10 added</li>\n   </ol>\n@@ -23,3 +24,4 @@\n     <li>item 2.6</li>\n-    <li>item 2.7</li>\n+    <li>item 2.7 changed</li>\n+    <li>item 2.7.1 added</li>\n     <li>item 2.8</li>\n@@ -35,4 +37,2 @@\n     <li>item 3.6</li>\n-    <li>item 3.7</li>\n-    <li>item 3.8</li>\n   </ol>\n";
 	const char *expected_driver =
-		"diff --git a/file.html b/file.html\nindex 97b34db..c7dbed3 100644\n--- a/file.html\n+++ b/file.html\n@@ -5,4 +5,4 @@   <h1 id=\"first section\">\n     <li>item 1.1</li>\n-    <li>item 1.2</li>\n-    <li>item 1.3</li>\n+    <li>item 1.2 changed</li>\n+    <li>item 1.3 changed</li>\n     <li>item 1.4</li>\n@@ -13,2 +13,3 @@   <h1 id=\"first section\">\n     <li>item 1.9</li>\n+  <li>item 1.10 added</li>\n   </ol>\n@@ -23,3 +24,4 @@   <h1 id=\"second section\">\n     <li>item 2.6</li>\n-    <li>item 2.7</li>\n+    <li>item 2.7 changed</li>\n+    <li>item 2.7.1 added</li>\n     <li>item 2.8</li>\n@@ -35,4 +37,2 @@   <h1 id=\"third section\">\n     <li>item 3.6</li>\n-    <li>item 3.7</li>\n-    <li>item 3.8</li>\n   </ol>\n";
+		"diff --git a/file.html b/file.html\nindex 97b34db..c7dbed3 100644\n--- a/file.html\n+++ b/file.html\n@@ -5,4 +5,4 @@ <h1 id=\"first section\">\n     <li>item 1.1</li>\n-    <li>item 1.2</li>\n-    <li>item 1.3</li>\n+    <li>item 1.2 changed</li>\n+    <li>item 1.3 changed</li>\n     <li>item 1.4</li>\n@@ -13,2 +13,3 @@ <h1 id=\"first section\">\n     <li>item 1.9</li>\n+  <li>item 1.10 added</li>\n   </ol>\n@@ -23,3 +24,4 @@ <h1 id=\"second section\">\n     <li>item 2.6</li>\n-    <li>item 2.7</li>\n+    <li>item 2.7 changed</li>\n+    <li>item 2.7.1 added</li>\n     <li>item 2.8</li>\n@@ -35,4 +37,2 @@ <h1 id=\"third section\">\n     <li>item 3.6</li>\n-    <li>item 3.7</li>\n-    <li>item 3.8</li>\n   </ol>\n";
 
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
 
-- 
cgit v1.2.3


From 5d82c0df13ad3bd8edf85ba8d5f3796e93f926d8 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 21 Jan 2014 12:08:02 -0800
Subject: Update all tests for new pattern extraction

---
 tests/diff/blob.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/diff/blob.c b/tests/diff/blob.c
index 63e3c5b7d..843937728 100644
--- a/tests/diff/blob.c
+++ b/tests/diff/blob.c
@@ -861,15 +861,15 @@ void test_diff_blob__using_path_and_attributes(void)
 	cl_git_pass(git_config_set_bool(cfg, "diff.iam_binary.binary", 1));
 	cl_git_pass(git_config_set_bool(cfg, "diff.iam_text.binary", 0));
 	cl_git_pass(git_config_set_string(
-		cfg, "diff.iam_alphactx.xfuncname", "^[A-Za-z]"));
+		cfg, "diff.iam_alphactx.xfuncname", "^[A-Za-z].*$"));
 	cl_git_pass(git_config_set_bool(cfg, "diff.iam_textalpha.binary", 0));
 	cl_git_pass(git_config_set_string(
-		cfg, "diff.iam_textalpha.xfuncname", "^[A-Za-z]"));
+		cfg, "diff.iam_textalpha.xfuncname", "^[A-Za-z].*$"));
 	cl_git_pass(git_config_set_string(
-		cfg, "diff.iam_numctx.funcname", "^[0-9]"));
+		cfg, "diff.iam_numctx.funcname", "^[0-9][0-9]*"));
 	cl_git_pass(git_config_set_bool(cfg, "diff.iam_textnum.binary", 0));
 	cl_git_pass(git_config_set_string(
-		cfg, "diff.iam_textnum.funcname", "^[0-9]"));
+		cfg, "diff.iam_textnum.funcname", "^[0-9][0-9]*"));
 	git_config_free(cfg);
 
 	cl_git_append2file(
-- 
cgit v1.2.3


From c7c260a5ff217c822e227428e712970e02fa56d9 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 23 Jan 2014 16:12:39 -0800
Subject: Got some permission to use userdiff patterns

I contacted a number of Git authors and lined up their permission
to relicense their work for use in libgit2 and copied over their
code for diff driver xfuncname patterns.  At this point, the code
I've copied is taken verbatim from core Git although Thomas Rast
warned me that the C++ patterns, at least, really need an update.
I've left off patterns where I don't feel like I have permission
at this point until I hear from more authors.
---
 git.git-authors   |   5 ++
 src/diff_driver.c |  39 +------------
 src/userdiff.h    | 164 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 170 insertions(+), 38 deletions(-)
 create mode 100644 src/userdiff.h

diff --git a/git.git-authors b/git.git-authors
index 7d4c95bb3..9620844a9 100644
--- a/git.git-authors
+++ b/git.git-authors
@@ -39,8 +39,10 @@
 #  but has otherwise not contributed to git.)
 #
 ok	Adam Simpkins <adam@adamsimpkins.net> (http transport)
+ok	Adrian Johnson <ajohnson@redneon.com>
 ok	Andreas Ericsson <ae@op5.se>
 ok	Boyd Lynn Gerber <gerberb@zenez.com>
+ok	Brandon Casey <drafnel@gmail.com>
 ok	Brian Downing <bdowning@lavos.net>
 ok	Brian Gernhardt <benji@silverinsanity.com>
 ok	Christian Couder <chriscool@tuxfamily.org>
@@ -50,11 +52,13 @@ ok	Holger Weiss <holger@zedat.fu-berlin.de>
 ok	Jeff King <peff@peff.net>
 ok	Johannes Schindelin <Johannes.Schindelin@gmx.de>
 ok	Johannes Sixt <j6t@kdbg.org>
+ask	Jonathan Nieder <jrnieder@gmail.com>
 ok	Junio C Hamano <gitster@pobox.com>
 ok	Kristian Høgsberg <krh@redhat.com>
 ok	Linus Torvalds <torvalds@linux-foundation.org>
 ok	Lukas Sandström <lukass@etek.chalmers.se>
 ok	Matthieu Moy <Matthieu.Moy@imag.fr>
+ok	Michael Haggerty <mhagger@alum.mit.edu>
 ign	Mike McCormack <mike@codeweavers.com> (imap-send)
 ok	Nicolas Pitre <nico@fluxnic.net> <nico@cam.org>
 ok	Paolo Bonzini <bonzini@gnu.org>
@@ -68,4 +72,5 @@ ok	Sebastian Schuberth <sschuberth@gmail.com>
 ok	Shawn O. Pearce <spearce@spearce.org>
 ok	Steffen Prohaska <prohaska@zib.de>
 ok	Sven Verdoolaege <skimo@kotnet.org>
+ask	Thomas Rast <tr@thomasrast.ch> (ok before 6-Oct-2013)
 ok	Torsten Bögershausen <tboegi@web.de>
diff --git a/src/diff_driver.c b/src/diff_driver.c
index 56b5b5a51..9249d1415 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -45,44 +45,7 @@ struct git_diff_driver {
 	char name[GIT_FLEX_ARRAY];
 };
 
-typedef struct {
-	const char *name;
-	const char *fns;
-	const char *words;
-	int flags;
-} git_diff_driver_definition;
-
-#define WORD_DEFAULT "|[^[:space:]]|[\xc0-\xff][\x80-\xbf]+"
-
-/* builtin driver definition macros have same signature as in core git
- * userdiff.c so that the data can be extracted verbatim
- */
-#define PATTERNS(NAME, FN_PATS, WORD_PAT) \
-	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, 0 }
-#define IPATTERN(NAME, FN_PATS, WORD_PAT) \
-	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, REG_ICASE }
-
-static git_diff_driver_definition builtin_defs[] = {
-PATTERNS("html", "^[ \t]*(<[Hh][1-6][ \t].*>.*)$",
-	 "[^<>= \t]+"),
-PATTERNS("java",
-	 "!^[ \t]*(catch|do|for|if|instanceof|new|return|switch|throw|while)\n"
-	 "^[ \t]*(([A-Za-z_][A-Za-z_0-9]*[ \t]+)+[A-Za-z_][A-Za-z_0-9]*[ \t]*\\([^;]*)$",
-	 /* -- */
-	 "[a-zA-Z_][a-zA-Z0-9_]*"
-	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
-	 "|[-+*/<>%&^|=!]="
-	 "|--|\\+\\+|<<=?|>>>?=?|&&|\\|\\|"),
-PATTERNS("ruby", "^[ \t]*((class|module|def)[ \t].*)$",
-	 /* -- */
-	 "(@|@@|\\$)?[a-zA-Z_][a-zA-Z0-9_]*"
-	 "|[-+0-9.e]+|0[xXbB]?[0-9a-fA-F]+|\\?(\\\\C-)?(\\\\M-)?."
-	 "|//=?|[-+*/<>%&^|=!]=|<<=?|>>=?|===|\\.{1,3}|::|[!=]~"),
-};
-
-#undef IPATTERN
-#undef PATTERNS
-#undef WORD_DEFAULT
+#include "userdiff.h"
 
 struct git_diff_driver_registry {
 	git_strmap *drivers;
diff --git a/src/userdiff.h b/src/userdiff.h
new file mode 100644
index 000000000..a4f3686ad
--- /dev/null
+++ b/src/userdiff.h
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_userdiff_h__
+#define INCLUDE_userdiff_h__
+
+/*
+ * This file isolates the built in diff driver function name patterns.
+ * Most of these patterns are taken from Git (with permission from the
+ * original authors for relicensing to libgit2).
+ */
+
+typedef struct {
+	const char *name;
+	const char *fns;
+	const char *words;
+	int flags;
+} git_diff_driver_definition;
+
+#define WORD_DEFAULT "|[^[:space:]]|[\xc0-\xff][\x80-\xbf]+"
+
+/*
+ * These builtin driver definition macros have same signature as in core
+ * git userdiff.c so that the data can be extracted verbatim
+ */
+#define PATTERNS(NAME, FN_PATS, WORD_PAT) \
+	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, 0 }
+#define IPATTERN(NAME, FN_PATS, WORD_PAT) \
+	{ NAME, FN_PATS, WORD_PAT WORD_DEFAULT, REG_ICASE }
+
+/*
+ * The table of diff driver patterns
+ *
+ * Function name patterns are a list of newline separated patterns that
+ * match a function declaration (i.e. the line you want in the hunk header),
+ * or a negative pattern prefixed with a '!' to reject a pattern (such as
+ * rejecting goto labels in C code).
+ *
+ * Word boundary patterns are just a simple pattern that will be OR'ed with
+ * the default value above (i.e. whitespace or non-ASCII characters).
+ */
+static git_diff_driver_definition builtin_defs[] = {
+
+IPATTERN("ada",
+	 "!^(.*[ \t])?(is new|renames|is separate)([ \t].*)?$\n"
+	 "!^[ \t]*with[ \t].*$\n"
+	 "^[ \t]*((procedure|function)[ \t]+.*)$\n"
+	 "^[ \t]*((package|protected|task)[ \t]+.*)$",
+	 /* -- */
+	 "[a-zA-Z][a-zA-Z0-9_]*"
+	 "|[0-9][-+0-9#_.eE]"
+	 "|=>|\\.\\.|\\*\\*|:=|/=|>=|<=|<<|>>|<>"),
+
+IPATTERN("fortran",
+	 "!^([C*]|[ \t]*!)\n"
+	 "!^[ \t]*MODULE[ \t]+PROCEDURE[ \t]\n"
+	 "^[ \t]*((END[ \t]+)?(PROGRAM|MODULE|BLOCK[ \t]+DATA"
+		"|([^'\" \t]+[ \t]+)*(SUBROUTINE|FUNCTION))[ \t]+[A-Z].*)$",
+	 /* -- */
+	 "[a-zA-Z][a-zA-Z0-9_]*"
+	 "|\\.([Ee][Qq]|[Nn][Ee]|[Gg][TtEe]|[Ll][TtEe]|[Tt][Rr][Uu][Ee]|[Ff][Aa][Ll][Ss][Ee]|[Aa][Nn][Dd]|[Oo][Rr]|[Nn]?[Ee][Qq][Vv]|[Nn][Oo][Tt])\\."
+	 /* numbers and format statements like 2E14.4, or ES12.6, 9X.
+	  * Don't worry about format statements without leading digits since
+	  * they would have been matched above as a variable anyway. */
+	 "|[-+]?[0-9.]+([AaIiDdEeFfLlTtXx][Ss]?[-+]?[0-9.]*)?(_[a-zA-Z0-9][a-zA-Z0-9_]*)?"
+	 "|//|\\*\\*|::|[/<>=]="),
+
+PATTERNS("html", "^[ \t]*(<[Hh][1-6][ \t].*>.*)$",
+	 "[^<>= \t]+"),
+
+PATTERNS("java",
+	 "!^[ \t]*(catch|do|for|if|instanceof|new|return|switch|throw|while)\n"
+	 "^[ \t]*(([A-Za-z_][A-Za-z_0-9]*[ \t]+)+[A-Za-z_][A-Za-z_0-9]*[ \t]*\\([^;]*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
+	 "|[-+*/<>%&^|=!]="
+	 "|--|\\+\\+|<<=?|>>>?=?|&&|\\|\\|"),
+
+PATTERNS("objc",
+	 /* Negate C statements that can look like functions */
+	 "!^[ \t]*(do|for|if|else|return|switch|while)\n"
+	 /* Objective-C methods */
+	 "^[ \t]*([-+][ \t]*\\([ \t]*[A-Za-z_][A-Za-z_0-9* \t]*\\)[ \t]*[A-Za-z_].*)$\n"
+	 /* C functions */
+	 "^[ \t]*(([A-Za-z_][A-Za-z_0-9]*[ \t]+)+[A-Za-z_][A-Za-z_0-9]*[ \t]*\\([^;]*)$\n"
+	 /* Objective-C class/protocol definitions */
+	 "^(@(implementation|interface|protocol)[ \t].*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
+	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
+
+PATTERNS("perl",
+	 "^package .*\n"
+	 "^sub [[:alnum:]_':]+[ \t]*"
+		"(\\([^)]*\\)[ \t]*)?" /* prototype */
+		/*
+		 * Attributes.  A regex can't count nested parentheses,
+		 * so just slurp up whatever we see, taking care not
+		 * to accept lines like "sub foo; # defined elsewhere".
+		 *
+		 * An attribute could contain a semicolon, but at that
+		 * point it seems reasonable enough to give up.
+		 */
+		"(:[^;#]*)?"
+		"(\\{[ \t]*)?" /* brace can come here or on the next line */
+		"(#.*)?$\n" /* comment */
+	 "^(BEGIN|END|INIT|CHECK|UNITCHECK|AUTOLOAD|DESTROY)[ \t]*"
+		"(\\{[ \t]*)?" /* brace can come here or on the next line */
+		"(#.*)?$\n"
+	 "^=head[0-9] .*",	/* POD */
+	 /* -- */
+	 "[[:alpha:]_'][[:alnum:]_']*"
+	 "|0[xb]?[0-9a-fA-F_]*"
+	 /* taking care not to interpret 3..5 as (3.)(.5) */
+	 "|[0-9a-fA-F_]+(\\.[0-9a-fA-F_]+)?([eE][-+]?[0-9_]+)?"
+	 "|=>|-[rwxoRWXOezsfdlpSugkbctTBMAC>]|~~|::"
+	 "|&&=|\\|\\|=|//=|\\*\\*="
+	 "|&&|\\|\\||//|\\+\\+|--|\\*\\*|\\.\\.\\.?"
+	 "|[-+*/%.^&<>=!|]="
+	 "|=~|!~"
+	 "|<<|<>|<=>|>>"),
+
+PATTERNS("python", "^[ \t]*((class|def)[ \t].*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+[jJlL]?|0[xX]?[0-9a-fA-F]+[lL]?"
+	 "|[-+*/<>%&^|=!]=|//=?|<<=?|>>=?|\\*\\*=?"),
+
+PATTERNS("ruby", "^[ \t]*((class|module|def)[ \t].*)$",
+	 /* -- */
+	 "(@|@@|\\$)?[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+|0[xXbB]?[0-9a-fA-F]+|\\?(\\\\C-)?(\\\\M-)?."
+	 "|//=?|[-+*/<>%&^|=!]=|<<=?|>>=?|===|\\.{1,3}|::|[!=]~"),
+
+PATTERNS("bibtex", "(@[a-zA-Z]{1,}[ \t]*\\{{0,1}[ \t]*[^ \t\"@',\\#}{~%]*).*$",
+	 "[={}\"]|[^={}\" \t]+"),
+
+PATTERNS("tex", "^(\\\\((sub)*section|chapter|part)\\*{0,1}\\{.*)$",
+	 "\\\\[a-zA-Z@]+|\\\\.|[a-zA-Z0-9\x80-\xff]+"),
+
+PATTERNS("cpp",
+	 /* Jump targets or access declarations */
+	 "!^[ \t]*[A-Za-z_][A-Za-z_0-9]*:.*$\n"
+	 /* C/++ functions/methods at top level */
+	 "^([A-Za-z_][A-Za-z_0-9]*([ \t*]+[A-Za-z_][A-Za-z_0-9]*([ \t]*::[ \t]*[^[:space:]]+)?){1,}[ \t]*\\([^;]*)$\n"
+	 /* compound type at top level */
+	 "^((struct|class|enum)[^;]*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
+	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
+};
+
+#undef IPATTERN
+#undef PATTERNS
+#undef WORD_DEFAULT
+
+#endif
+
-- 
cgit v1.2.3


From 3b19d2fdcbd9f6185490fc10e7c4540758954321 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 24 Jan 2014 09:46:22 -0800
Subject: Permission for Git code from a couple more

This brings over the Pascal and CSharp userdiff data.
---
 git.git-authors |  2 ++
 src/userdiff.h  | 26 ++++++++++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/git.git-authors b/git.git-authors
index 9620844a9..7e53d66a9 100644
--- a/git.git-authors
+++ b/git.git-authors
@@ -40,6 +40,7 @@
 #
 ok	Adam Simpkins <adam@adamsimpkins.net> (http transport)
 ok	Adrian Johnson <ajohnson@redneon.com>
+ok	Alexey Shumkin <alex.crezoff@gmail.com>
 ok	Andreas Ericsson <ae@op5.se>
 ok	Boyd Lynn Gerber <gerberb@zenez.com>
 ok	Brandon Casey <drafnel@gmail.com>
@@ -64,6 +65,7 @@ ok	Nicolas Pitre <nico@fluxnic.net> <nico@cam.org>
 ok	Paolo Bonzini <bonzini@gnu.org>
 ok	Paul Kocher <paul@cryptography.com>
 ok	Peter Hagervall <hager@cs.umu.se>
+ok	Petr Onderka <gsvick@gmail.com>
 ok	Pierre Habouzit <madcoder@debian.org>
 ok	Pieter de Bie <pdebie@ai.rug.nl>
 ok	René Scharfe <rene.scharfe@lsrfire.ath.cx>
diff --git a/src/userdiff.h b/src/userdiff.h
index a4f3686ad..1f2318507 100644
--- a/src/userdiff.h
+++ b/src/userdiff.h
@@ -94,6 +94,16 @@ PATTERNS("objc",
 	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
 	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
 
+PATTERNS("pascal",
+	 "^(((class[ \t]+)?(procedure|function)|constructor|destructor|interface|"
+		"implementation|initialization|finalization)[ \t]*.*)$"
+	 "\n"
+	 "^(.*=[ \t]*(class|record).*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+|0[xXbB]?[0-9a-fA-F]+"
+	 "|<>|<=|>=|:=|\\.\\."),
+
 PATTERNS("perl",
 	 "^package .*\n"
 	 "^sub [[:alnum:]_':]+[ \t]*"
@@ -154,6 +164,22 @@ PATTERNS("cpp",
 	 "[a-zA-Z_][a-zA-Z0-9_]*"
 	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
 	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
+
+PATTERNS("csharp",
+	 /* Keywords */
+	 "!^[ \t]*(do|while|for|if|else|instanceof|new|return|switch|case|throw|catch|using)\n"
+	 /* Methods and constructors */
+	 "^[ \t]*(((static|public|internal|private|protected|new|virtual|sealed|override|unsafe)[ \t]+)*[][<>@.~_[:alnum:]]+[ \t]+[<>@._[:alnum:]]+[ \t]*\\(.*\\))[ \t]*$\n"
+	 /* Properties */
+	 "^[ \t]*(((static|public|internal|private|protected|new|virtual|sealed|override|unsafe)[ \t]+)*[][<>@.~_[:alnum:]]+[ \t]+[@._[:alnum:]]+)[ \t]*$\n"
+	 /* Type definitions */
+	 "^[ \t]*(((static|public|internal|private|protected|new|unsafe|sealed|abstract|partial)[ \t]+)*(class|enum|interface|struct)[ \t]+.*)$\n"
+	 /* Namespace */
+	 "^[ \t]*(namespace[ \t]+.*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
+	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
 };
 
 #undef IPATTERN
-- 
cgit v1.2.3


From 027b8edac7e91480623815193ed994db808064f6 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 24 Jan 2014 15:45:49 -0800
Subject: Move userdiff tests to be data driven

This moves the expected and actual test data along with the source
data for the userdiff tests into the tests/resources/userdiff test
repo and updates the test to use that.
---
 tests/diff/drivers.c                               |  97 +++++++++++----------
 tests/resources/userdiff/.gitted/HEAD              |   1 +
 tests/resources/userdiff/.gitted/config            |   7 ++
 tests/resources/userdiff/.gitted/description       |   1 +
 tests/resources/userdiff/.gitted/index             | Bin 0 -> 456 bytes
 .../05/d669073b39d36847315e3a5b4512cf4cba4546      | Bin 0 -> 54 bytes
 .../20/ab776b6ff3169fa0e5eff65df30d45187d22ba      | Bin 0 -> 54 bytes
 .../23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd      | Bin 0 -> 207 bytes
 .../2e/a4b8a16d737c180dfdd2b119dec9501592326c      | Bin 0 -> 228 bytes
 .../49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0      | Bin 0 -> 118 bytes
 .../50/346bde7428a29c9845470a14d87b1634293d48      |   1 +
 .../5a/428e7dcffb41b65984517f1e6b8547babc8dff      | Bin 0 -> 263 bytes
 .../87/2d19663f32459389597b52beec6457c1dc971f      | Bin 0 -> 178 bytes
 .../9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5      |   2 +
 .../d6/3c806de4f666369ed169495657bec24b558165      | Bin 0 -> 76 bytes
 .../ef/1641511d6cb425c6b4f59ef1feffe7762e86e0      |   1 +
 tests/resources/userdiff/.gitted/refs/heads/master |   1 +
 tests/resources/userdiff/after/file.html           |  41 +++++++++
 tests/resources/userdiff/before/file.html          |  41 +++++++++
 tests/resources/userdiff/expected/driver/diff.html |  26 ++++++
 .../resources/userdiff/expected/nodriver/diff.html |  26 ++++++
 tests/resources/userdiff/files/file.html           |  41 +++++++++
 22 files changed, 239 insertions(+), 47 deletions(-)
 create mode 100644 tests/resources/userdiff/.gitted/HEAD
 create mode 100644 tests/resources/userdiff/.gitted/config
 create mode 100644 tests/resources/userdiff/.gitted/description
 create mode 100644 tests/resources/userdiff/.gitted/index
 create mode 100644 tests/resources/userdiff/.gitted/objects/05/d669073b39d36847315e3a5b4512cf4cba4546
 create mode 100644 tests/resources/userdiff/.gitted/objects/20/ab776b6ff3169fa0e5eff65df30d45187d22ba
 create mode 100644 tests/resources/userdiff/.gitted/objects/23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd
 create mode 100644 tests/resources/userdiff/.gitted/objects/2e/a4b8a16d737c180dfdd2b119dec9501592326c
 create mode 100644 tests/resources/userdiff/.gitted/objects/49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0
 create mode 100644 tests/resources/userdiff/.gitted/objects/50/346bde7428a29c9845470a14d87b1634293d48
 create mode 100644 tests/resources/userdiff/.gitted/objects/5a/428e7dcffb41b65984517f1e6b8547babc8dff
 create mode 100644 tests/resources/userdiff/.gitted/objects/87/2d19663f32459389597b52beec6457c1dc971f
 create mode 100644 tests/resources/userdiff/.gitted/objects/9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5
 create mode 100644 tests/resources/userdiff/.gitted/objects/d6/3c806de4f666369ed169495657bec24b558165
 create mode 100644 tests/resources/userdiff/.gitted/objects/ef/1641511d6cb425c6b4f59ef1feffe7762e86e0
 create mode 100644 tests/resources/userdiff/.gitted/refs/heads/master
 create mode 100644 tests/resources/userdiff/after/file.html
 create mode 100644 tests/resources/userdiff/before/file.html
 create mode 100644 tests/resources/userdiff/expected/driver/diff.html
 create mode 100644 tests/resources/userdiff/expected/nodriver/diff.html
 create mode 100644 tests/resources/userdiff/files/file.html

diff --git a/tests/diff/drivers.c b/tests/diff/drivers.c
index 119132149..1cbf9e211 100644
--- a/tests/diff/drivers.c
+++ b/tests/diff/drivers.c
@@ -176,70 +176,73 @@ void test_diff_drivers__long_lines(void)
 
 void test_diff_drivers__builtins(void)
 {
-	git_index *idx;
 	git_diff *diff;
 	git_patch *patch;
-	git_buf actual = GIT_BUF_INIT;
+	git_buf file = GIT_BUF_INIT, actual = GIT_BUF_INIT, expected = GIT_BUF_INIT;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
-	const char *base =
-		"<html>\n<body>\n"
-		"  <h1 id=\"first section\">\n  <ol>\n    <li>item 1.1</li>\n    <li>item 1.2</li>\n    <li>item 1.3</li>\n    <li>item 1.4</li>\n    <li>item 1.5</li>\n    <li>item 1.6</li>\n    <li>item 1.7</li>\n    <li>item 1.8</li>\n    <li>item 1.9</li>\n  </ol>\n  </h1>\n"
-		"  <h1 id=\"second section\">\n  <ol>\n    <li>item 2.1</li>\n    <li>item 2.2</li>\n    <li>item 2.3</li>\n    <li>item 2.4</li>\n    <li>item 2.5</li>\n    <li>item 2.6</li>\n    <li>item 2.7</li>\n    <li>item 2.8</li>\n  </ol>\n  </h1>\n"
-		"  <h1 id=\"third section\">\n  <ol>\n    <li>item 3.1</li>\n    <li>item 3.2</li>\n    <li>item 3.3</li>\n    <li>item 3.4</li>\n    <li>item 3.5</li>\n    <li>item 3.6</li>\n    <li>item 3.7</li>\n    <li>item 3.8</li>\n  </ol>\n  </h1>\n"
-		"</body></html>\n";
-	const char *modified =
-		"<html>\n<body>\n"
-		"  <h1 id=\"first section\">\n  <ol>\n    <li>item 1.1</li>\n    <li>item 1.2 changed</li>\n    <li>item 1.3 changed</li>\n    <li>item 1.4</li>\n    <li>item 1.5</li>\n    <li>item 1.6</li>\n    <li>item 1.7</li>\n    <li>item 1.8</li>\n    <li>item 1.9</li>\n  <li>item 1.10 added</li>\n  </ol>\n  </h1>\n"
-		"  <h1 id=\"second section\">\n  <ol>\n    <li>item 2.1</li>\n    <li>item 2.2</li>\n    <li>item 2.3</li>\n    <li>item 2.4</li>\n    <li>item 2.5</li>\n    <li>item 2.6</li>\n    <li>item 2.7 changed</li>\n    <li>item 2.7.1 added</li>\n    <li>item 2.8</li>\n  </ol>\n  </h1>\n"
-		"  <h1 id=\"third section\">\n  <ol>\n    <li>item 3.1</li>\n    <li>item 3.2</li>\n    <li>item 3.3</li>\n    <li>item 3.4</li>\n    <li>item 3.5</li>\n    <li>item 3.6</li>\n  </ol>\n  </h1>\n"
-		"</body></html>\n";
-	const char *expected_nodriver =
-		"diff --git a/file.html b/file.html\nindex 97b34db..c7dbed3 100644\n--- a/file.html\n+++ b/file.html\n@@ -5,4 +5,4 @@\n     <li>item 1.1</li>\n-    <li>item 1.2</li>\n-    <li>item 1.3</li>\n+    <li>item 1.2 changed</li>\n+    <li>item 1.3 changed</li>\n     <li>item 1.4</li>\n@@ -13,2 +13,3 @@\n     <li>item 1.9</li>\n+  <li>item 1.10 added</li>\n   </ol>\n@@ -23,3 +24,4 @@\n     <li>item 2.6</li>\n-    <li>item 2.7</li>\n+    <li>item 2.7 changed</li>\n+    <li>item 2.7.1 added</li>\n     <li>item 2.8</li>\n@@ -35,4 +37,2 @@\n     <li>item 3.6</li>\n-    <li>item 3.7</li>\n-    <li>item 3.8</li>\n   </ol>\n";
-	const char *expected_driver =
-		"diff --git a/file.html b/file.html\nindex 97b34db..c7dbed3 100644\n--- a/file.html\n+++ b/file.html\n@@ -5,4 +5,4 @@ <h1 id=\"first section\">\n     <li>item 1.1</li>\n-    <li>item 1.2</li>\n-    <li>item 1.3</li>\n+    <li>item 1.2 changed</li>\n+    <li>item 1.3 changed</li>\n     <li>item 1.4</li>\n@@ -13,2 +13,3 @@ <h1 id=\"first section\">\n     <li>item 1.9</li>\n+  <li>item 1.10 added</li>\n   </ol>\n@@ -23,3 +24,4 @@ <h1 id=\"second section\">\n     <li>item 2.6</li>\n-    <li>item 2.7</li>\n+    <li>item 2.7 changed</li>\n+    <li>item 2.7.1 added</li>\n     <li>item 2.8</li>\n@@ -35,4 +37,2 @@ <h1 id=\"third section\">\n     <li>item 3.6</li>\n-    <li>item 3.7</li>\n-    <li>item 3.8</li>\n   </ol>\n";
+	int i;
+	static const char *files[] = {
+		"html",
+		NULL
+	};
 
-	g_repo = cl_git_sandbox_init("empty_standard_repo");
+	g_repo = cl_git_sandbox_init("userdiff");
 
-	cl_git_mkfile("empty_standard_repo/file.html", base);
-	cl_git_pass(git_repository_index(&idx, g_repo));
-	cl_git_pass(git_index_add_bypath(idx, "file.html"));
-	cl_git_pass(git_index_write(idx));
-	git_index_free(idx);
+	opts.interhunk_lines = 1;
+	opts.context_lines = 1;
+	opts.pathspec.count = 1;
 
-	cl_git_rewritefile("empty_standard_repo/file.html", modified);
+	for (i = 0; files[i]; ++i) {
+		git_buf_sets(&file, "files/file.");
+		git_buf_puts(&file, files[i]);
+		opts.pathspec.strings = &file.ptr;
 
-	/* do diff with no special driver */
+		/* do diff with no special driver */
 
-	opts.interhunk_lines = 1;
-	opts.context_lines = 1;
+		cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+		cl_assert_equal_sz(1, git_diff_num_deltas(diff));
+		cl_git_pass(git_patch_from_diff(&patch, diff, 0));
+		cl_git_pass(git_patch_to_buf(&actual, patch));
 
-	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
-	cl_assert_equal_sz(1, git_diff_num_deltas(diff));
-	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_buf(&actual, patch));
+		git_buf_sets(&expected, "userdiff/expected/nodriver/diff.");
+		git_buf_puts(&expected, files[i]);
+		cl_git_pass(git_futils_readbuffer(&expected, expected.ptr));
 
-	overwrite_filemode(expected_nodriver, &actual);
+		overwrite_filemode(expected.ptr, &actual);
 
-	cl_assert_equal_s(expected_nodriver, actual.ptr);
+		cl_assert_equal_s(expected.ptr, actual.ptr);
 
-	git_buf_free(&actual);
-	git_patch_free(patch);
-	git_diff_free(diff);
+		git_buf_clear(&actual);
+		git_patch_free(patch);
+		git_diff_free(diff);
 
-	/* do diff with HTML driver */
+		/* do diff with driver */
 
-	cl_git_mkfile("empty_standard_repo/.gitattributes", "*.html diff=html\n");
+		{
+			FILE *fp = fopen("userdiff/.gitattributes", "w");
+			fprintf(fp, "*.%s diff=%s\n", files[i], files[i]);
+			fclose(fp);
+		}
 
-	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
-	cl_assert_equal_sz(1, git_diff_num_deltas(diff));
-	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
-	cl_git_pass(git_patch_to_buf(&actual, patch));
+		cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+		cl_assert_equal_sz(1, git_diff_num_deltas(diff));
+		cl_git_pass(git_patch_from_diff(&patch, diff, 0));
+		cl_git_pass(git_patch_to_buf(&actual, patch));
+
+		git_buf_sets(&expected, "userdiff/expected/driver/diff.");
+		git_buf_puts(&expected, files[i]);
+		cl_git_pass(git_futils_readbuffer(&expected, expected.ptr));
+
+		overwrite_filemode(expected.ptr, &actual);
 
-	overwrite_filemode(expected_driver, &actual);
+		cl_assert_equal_s(expected.ptr, actual.ptr);
 
-	cl_assert_equal_s(expected_driver, actual.ptr);
+		git_buf_clear(&actual);
+		git_patch_free(patch);
+		git_diff_free(diff);
+	}
 
+	git_buf_free(&file);
 	git_buf_free(&actual);
-	git_patch_free(patch);
-	git_diff_free(diff);
+	git_buf_free(&expected);
 }
diff --git a/tests/resources/userdiff/.gitted/HEAD b/tests/resources/userdiff/.gitted/HEAD
new file mode 100644
index 000000000..cb089cd89
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/master
diff --git a/tests/resources/userdiff/.gitted/config b/tests/resources/userdiff/.gitted/config
new file mode 100644
index 000000000..6c9406b7d
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/config
@@ -0,0 +1,7 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+	ignorecase = true
+	precomposeunicode = true
diff --git a/tests/resources/userdiff/.gitted/description b/tests/resources/userdiff/.gitted/description
new file mode 100644
index 000000000..498b267a8
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/description
@@ -0,0 +1 @@
+Unnamed repository; edit this file 'description' to name the repository.
diff --git a/tests/resources/userdiff/.gitted/index b/tests/resources/userdiff/.gitted/index
new file mode 100644
index 000000000..9372411cd
Binary files /dev/null and b/tests/resources/userdiff/.gitted/index differ
diff --git a/tests/resources/userdiff/.gitted/objects/05/d669073b39d36847315e3a5b4512cf4cba4546 b/tests/resources/userdiff/.gitted/objects/05/d669073b39d36847315e3a5b4512cf4cba4546
new file mode 100644
index 000000000..3a9d75cc1
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/05/d669073b39d36847315e3a5b4512cf4cba4546 differ
diff --git a/tests/resources/userdiff/.gitted/objects/20/ab776b6ff3169fa0e5eff65df30d45187d22ba b/tests/resources/userdiff/.gitted/objects/20/ab776b6ff3169fa0e5eff65df30d45187d22ba
new file mode 100644
index 000000000..3d57061ce
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/20/ab776b6ff3169fa0e5eff65df30d45187d22ba differ
diff --git a/tests/resources/userdiff/.gitted/objects/23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd b/tests/resources/userdiff/.gitted/objects/23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd
new file mode 100644
index 000000000..6dbcafed4
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd differ
diff --git a/tests/resources/userdiff/.gitted/objects/2e/a4b8a16d737c180dfdd2b119dec9501592326c b/tests/resources/userdiff/.gitted/objects/2e/a4b8a16d737c180dfdd2b119dec9501592326c
new file mode 100644
index 000000000..e7d2fba41
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/2e/a4b8a16d737c180dfdd2b119dec9501592326c differ
diff --git a/tests/resources/userdiff/.gitted/objects/49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0 b/tests/resources/userdiff/.gitted/objects/49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0
new file mode 100644
index 000000000..49d59c11d
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0 differ
diff --git a/tests/resources/userdiff/.gitted/objects/50/346bde7428a29c9845470a14d87b1634293d48 b/tests/resources/userdiff/.gitted/objects/50/346bde7428a29c9845470a14d87b1634293d48
new file mode 100644
index 000000000..9de1b3598
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/objects/50/346bde7428a29c9845470a14d87b1634293d48
@@ -0,0 +1 @@
+x
+)JMU06g040031QHËÌIÕË(ÉÍahוL³7r�ÜY´ïMJøÁ;Óå
8¿ð
\ No newline at end of file
diff --git a/tests/resources/userdiff/.gitted/objects/5a/428e7dcffb41b65984517f1e6b8547babc8dff b/tests/resources/userdiff/.gitted/objects/5a/428e7dcffb41b65984517f1e6b8547babc8dff
new file mode 100644
index 000000000..143a1cecf
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/5a/428e7dcffb41b65984517f1e6b8547babc8dff differ
diff --git a/tests/resources/userdiff/.gitted/objects/87/2d19663f32459389597b52beec6457c1dc971f b/tests/resources/userdiff/.gitted/objects/87/2d19663f32459389597b52beec6457c1dc971f
new file mode 100644
index 000000000..415f40a66
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/87/2d19663f32459389597b52beec6457c1dc971f differ
diff --git a/tests/resources/userdiff/.gitted/objects/9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5 b/tests/resources/userdiff/.gitted/objects/9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5
new file mode 100644
index 000000000..c0a03a241
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/objects/9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5
@@ -0,0 +1,2 @@
+x
•�M F]sŠ¹€fJ+”Äãέ7àg°$P:Ü_OàöË{ïóµ”Ä0éë‰,ÆcŒ«ÑN:ÔV’E
+¨gRÒšàJ�‹³(lç­6x÷ã œáI9Rƒ[s�Oâ­»‹¯åÓlP¡Òf…3®ˆb¬ã�ú¯)^{âd3üâóÍ9
\ No newline at end of file
diff --git a/tests/resources/userdiff/.gitted/objects/d6/3c806de4f666369ed169495657bec24b558165 b/tests/resources/userdiff/.gitted/objects/d6/3c806de4f666369ed169495657bec24b558165
new file mode 100644
index 000000000..2c0fbcc09
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/d6/3c806de4f666369ed169495657bec24b558165 differ
diff --git a/tests/resources/userdiff/.gitted/objects/ef/1641511d6cb425c6b4f59ef1feffe7762e86e0 b/tests/resources/userdiff/.gitted/objects/ef/1641511d6cb425c6b4f59ef1feffe7762e86e0
new file mode 100644
index 000000000..223f3b380
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/objects/ef/1641511d6cb425c6b4f59ef1feffe7762e86e0
@@ -0,0 +1 @@
+x
+)JMU06g040031QHÉLKÓË(ÉÍaˆrê«=ÿÛq[dK`½\v«û®=½ÿ
Már
\ No newline at end of file
diff --git a/tests/resources/userdiff/.gitted/refs/heads/master b/tests/resources/userdiff/.gitted/refs/heads/master
new file mode 100644
index 000000000..2ec79ec86
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/refs/heads/master
@@ -0,0 +1 @@
+9db1d09ff9ad5190bcf12d72ea3c818ffca344c5
diff --git a/tests/resources/userdiff/after/file.html b/tests/resources/userdiff/after/file.html
new file mode 100644
index 000000000..2320e2f1e
--- /dev/null
+++ b/tests/resources/userdiff/after/file.html
@@ -0,0 +1,41 @@
+<html>
+<body>
+  <h1 id="first section">
+  <ol>
+    <li>item 1.1</li>
+    <li>item 1.2 changed</li>
+    <li>item 1.3 changed</li>
+    <li>item 1.4</li>
+    <li>item 1.5</li>
+    <li>item 1.6</li>
+    <li>item 1.7</li>
+    <li>item 1.8</li>
+    <li>item 1.9</li>
+  <li>item 1.10 added</li>
+  </ol>
+  </h1>
+  <h1 id="second section">
+  <ol>
+    <li>item 2.1</li>
+    <li>item 2.2</li>
+    <li>item 2.3</li>
+    <li>item 2.4</li>
+    <li>item 2.5</li>
+    <li>item 2.6</li>
+    <li>item 2.7 changed</li>
+    <li>item 2.7.1 added</li>
+    <li>item 2.8</li>
+  </ol>
+  </h1>
+  <h1 id="third section">
+  <ol>
+    <li>item 3.1</li>
+    <li>item 3.2</li>
+    <li>item 3.3</li>
+    <li>item 3.4</li>
+    <li>item 3.5</li>
+    <li>item 3.6</li>
+  </ol>
+  </h1>
+</body>
+</html>
diff --git a/tests/resources/userdiff/before/file.html b/tests/resources/userdiff/before/file.html
new file mode 100644
index 000000000..872d19663
--- /dev/null
+++ b/tests/resources/userdiff/before/file.html
@@ -0,0 +1,41 @@
+<html>
+<body>
+  <h1 id="first section">
+  <ol>
+    <li>item 1.1</li>
+    <li>item 1.2</li>
+    <li>item 1.3</li>
+    <li>item 1.4</li>
+    <li>item 1.5</li>
+    <li>item 1.6</li>
+    <li>item 1.7</li>
+    <li>item 1.8</li>
+    <li>item 1.9</li>
+  </ol>
+  </h1>
+  <h1 id="second section">
+  <ol>
+    <li>item 2.1</li>
+    <li>item 2.2</li>
+    <li>item 2.3</li>
+    <li>item 2.4</li>
+    <li>item 2.5</li>
+    <li>item 2.6</li>
+    <li>item 2.7</li>
+    <li>item 2.8</li>
+  </ol>
+  </h1>
+  <h1 id="third section">
+  <ol>
+    <li>item 3.1</li>
+    <li>item 3.2</li>
+    <li>item 3.3</li>
+    <li>item 3.4</li>
+    <li>item 3.5</li>
+    <li>item 3.6</li>
+    <li>item 3.7</li>
+    <li>item 3.8</li>
+  </ol>
+  </h1>
+</body>
+</html>
diff --git a/tests/resources/userdiff/expected/driver/diff.html b/tests/resources/userdiff/expected/driver/diff.html
new file mode 100644
index 000000000..5a428e7dc
--- /dev/null
+++ b/tests/resources/userdiff/expected/driver/diff.html
@@ -0,0 +1,26 @@
+diff --git a/files/file.html b/files/file.html
+index 872d196..2320e2f 100644
+--- a/files/file.html
++++ b/files/file.html
+@@ -5,4 +5,4 @@ <h1 id="first section">
+     <li>item 1.1</li>
+-    <li>item 1.2</li>
+-    <li>item 1.3</li>
++    <li>item 1.2 changed</li>
++    <li>item 1.3 changed</li>
+     <li>item 1.4</li>
+@@ -13,2 +13,3 @@ <h1 id="first section">
+     <li>item 1.9</li>
++  <li>item 1.10 added</li>
+   </ol>
+@@ -23,3 +24,4 @@ <h1 id="second section">
+     <li>item 2.6</li>
+-    <li>item 2.7</li>
++    <li>item 2.7 changed</li>
++    <li>item 2.7.1 added</li>
+     <li>item 2.8</li>
+@@ -35,4 +37,2 @@ <h1 id="third section">
+     <li>item 3.6</li>
+-    <li>item 3.7</li>
+-    <li>item 3.8</li>
+   </ol>
diff --git a/tests/resources/userdiff/expected/nodriver/diff.html b/tests/resources/userdiff/expected/nodriver/diff.html
new file mode 100644
index 000000000..2ea4b8a16
--- /dev/null
+++ b/tests/resources/userdiff/expected/nodriver/diff.html
@@ -0,0 +1,26 @@
+diff --git a/files/file.html b/files/file.html
+index 872d196..2320e2f 100644
+--- a/files/file.html
++++ b/files/file.html
+@@ -5,4 +5,4 @@
+     <li>item 1.1</li>
+-    <li>item 1.2</li>
+-    <li>item 1.3</li>
++    <li>item 1.2 changed</li>
++    <li>item 1.3 changed</li>
+     <li>item 1.4</li>
+@@ -13,2 +13,3 @@
+     <li>item 1.9</li>
++  <li>item 1.10 added</li>
+   </ol>
+@@ -23,3 +24,4 @@
+     <li>item 2.6</li>
+-    <li>item 2.7</li>
++    <li>item 2.7 changed</li>
++    <li>item 2.7.1 added</li>
+     <li>item 2.8</li>
+@@ -35,4 +37,2 @@
+     <li>item 3.6</li>
+-    <li>item 3.7</li>
+-    <li>item 3.8</li>
+   </ol>
diff --git a/tests/resources/userdiff/files/file.html b/tests/resources/userdiff/files/file.html
new file mode 100644
index 000000000..2320e2f1e
--- /dev/null
+++ b/tests/resources/userdiff/files/file.html
@@ -0,0 +1,41 @@
+<html>
+<body>
+  <h1 id="first section">
+  <ol>
+    <li>item 1.1</li>
+    <li>item 1.2 changed</li>
+    <li>item 1.3 changed</li>
+    <li>item 1.4</li>
+    <li>item 1.5</li>
+    <li>item 1.6</li>
+    <li>item 1.7</li>
+    <li>item 1.8</li>
+    <li>item 1.9</li>
+  <li>item 1.10 added</li>
+  </ol>
+  </h1>
+  <h1 id="second section">
+  <ol>
+    <li>item 2.1</li>
+    <li>item 2.2</li>
+    <li>item 2.3</li>
+    <li>item 2.4</li>
+    <li>item 2.5</li>
+    <li>item 2.6</li>
+    <li>item 2.7 changed</li>
+    <li>item 2.7.1 added</li>
+    <li>item 2.8</li>
+  </ol>
+  </h1>
+  <h1 id="third section">
+  <ol>
+    <li>item 3.1</li>
+    <li>item 3.2</li>
+    <li>item 3.3</li>
+    <li>item 3.4</li>
+    <li>item 3.5</li>
+    <li>item 3.6</li>
+  </ol>
+  </h1>
+</body>
+</html>
-- 
cgit v1.2.3


From 7cc001cefb787ddacb53c74a94173674ac6bd587 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 24 Jan 2014 15:46:15 -0800
Subject: Add PHP and Javascript diff drivers

Since I don't have permission yet on the code from Git, I decided
I'd take a stab at writing patterns for PHP and Javascript myself.
I think these are pretty weak, but probably better than the
default behavior without them.
---
 src/userdiff.h | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/userdiff.h b/src/userdiff.h
index 1f2318507..318761567 100644
--- a/src/userdiff.h
+++ b/src/userdiff.h
@@ -180,6 +180,22 @@ PATTERNS("csharp",
 	 "[a-zA-Z_][a-zA-Z0-9_]*"
 	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
 	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
+
+PATTERNS("php",
+	 "^[ \t]*((public|private|protected|static|final)[ \t]+)*((class|function)[ \t].*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+[fFlL]?|0[xX]?[0-9a-fA-F]+[lL]?"
+	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
+
+PATTERNS("javascript",
+	 "^[ \t]*(\(?function[ \t].*)$\n"
+	 "^[ \t]*(var[ \t]+[a-zA-Z_][a-zA-Z0-9_]*[ \t]*=[ \t]*function[ \t\(].*)$\n"
+	 "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*[ \t]*:[ \t]*function[ \t\(].*)$",
+	 /* -- */
+	 "[a-zA-Z_][a-zA-Z0-9_]*"
+	 "|[-+0-9.e]+[fFlL]?|0[xX]?[0-9a-fA-F]+[lL]?"
+	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
 };
 
 #undef IPATTERN
-- 
cgit v1.2.3


From d541170c77b7ac738e2ffcdd04c838fb7cbbfb87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 24 Jan 2014 11:36:41 +0100
Subject: index: rename an entry's id to 'id'

This was not converted when we converted the rest, so do it now.
---
 examples/showindex.c                   |  2 +-
 include/git2/index.h                   |  2 +-
 src/attr.c                             |  4 ++--
 src/checkout.c                         | 14 ++++++------
 src/crlf.c                             |  2 +-
 src/diff.c                             | 32 +++++++++++++--------------
 src/index.c                            | 18 +++++++--------
 src/iterator.c                         |  2 +-
 src/merge.c                            | 26 +++++++++++-----------
 src/merge_file.c                       |  2 +-
 src/notes.c                            |  2 +-
 src/reset.c                            |  2 +-
 src/submodule.c                        | 12 +++++-----
 src/tree.c                             |  2 +-
 tests/attr/repo.c                      |  2 +-
 tests/checkout/conflict.c              |  2 +-
 tests/checkout/crlf.c                  |  4 ++--
 tests/checkout/tree.c                  |  6 ++---
 tests/diff/iterator.c                  |  2 +-
 tests/filter/custom.c                  |  4 ++--
 tests/index/conflicts.c                | 40 +++++++++++++++++-----------------
 tests/index/rename.c                   |  4 ++--
 tests/index/tests.c                    |  8 +++----
 tests/merge/merge_helpers.c            |  4 ++--
 tests/merge/trees/automerge.c          |  2 +-
 tests/merge/trees/commits.c            |  2 +-
 tests/merge/trees/trivial.c            |  4 ++--
 tests/merge/workdir/simple.c           |  2 +-
 tests/merge/workdir/trivial.c          |  4 ++--
 tests/object/commit/commitstagedfile.c |  2 +-
 tests/object/tree/duplicateentries.c   |  6 ++---
 tests/reset/default.c                  |  2 +-
 tests/reset/hard.c                     |  2 +-
 tests/status/worktree.c                | 12 +++++-----
 34 files changed, 118 insertions(+), 118 deletions(-)

diff --git a/examples/showindex.c b/examples/showindex.c
index 7f7c38379..ad4a16e8e 100644
--- a/examples/showindex.c
+++ b/examples/showindex.c
@@ -49,7 +49,7 @@ int main (int argc, char** argv)
 	for (i = 0; i < ecount; ++i) {
 		const git_index_entry *e = git_index_get_byindex(index, i);
 
-		git_oid_fmt(out, &e->oid);
+		git_oid_fmt(out, &e->id);
 
 		printf("File Path: %s\n", e->path);
 		printf("    Stage: %d\n", git_index_entry_stage(e));
diff --git a/include/git2/index.h b/include/git2/index.h
index ffefad15d..4363a3b9b 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -56,7 +56,7 @@ typedef struct git_index_entry {
 	unsigned int gid;
 	git_off_t file_size;
 
-	git_oid oid;
+	git_oid id;
 
 	unsigned short flags;
 	unsigned short flags_extended;
diff --git a/src/attr.c b/src/attr.c
index e6e274e42..ff4446e2f 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -314,10 +314,10 @@ static int load_attr_blob_from_index(
 
 	entry = git_index_get_byindex(index, pos);
 
-	if (old_oid && git_oid__cmp(old_oid, &entry->oid) == 0)
+	if (old_oid && git_oid__cmp(old_oid, &entry->id) == 0)
 		return GIT_ENOTFOUND;
 
-	if ((error = git_blob_lookup(blob, repo, &entry->oid)) < 0)
+	if ((error = git_blob_lookup(blob, repo, &entry->id)) < 0)
 		return error;
 
 	*content = git_blob_rawcontent(*blob);
diff --git a/src/checkout.c b/src/checkout.c
index 6769cbc3d..efd55db65 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -92,7 +92,7 @@ static int checkout_notify(
 	if (wditem) {
 		memset(&wdfile, 0, sizeof(wdfile));
 
-		git_oid_cpy(&wdfile.oid, &wditem->oid);
+		git_oid_cpy(&wdfile.oid, &wditem->id);
 		wdfile.path = wditem->path;
 		wdfile.size = wditem->file_size;
 		wdfile.flags = GIT_DIFF_FLAG_VALID_OID;
@@ -170,7 +170,7 @@ static bool checkout_is_workdir_modified(
 		if (wditem->mtime.seconds == ie->mtime.seconds &&
 			wditem->mtime.nanoseconds == ie->mtime.nanoseconds &&
 			wditem->file_size == ie->file_size)
-			return (git_oid__cmp(&baseitem->oid, &ie->oid) != 0);
+			return (git_oid__cmp(&baseitem->oid, &ie->id) != 0);
 	}
 
 	/* depending on where base is coming from, we may or may not know
@@ -700,21 +700,21 @@ GIT_INLINE(int) checkout_conflict_detect_binary(git_repository *repo, checkout_c
 		return 0;
 
 	if (conflict->ancestor) {
-		if ((error = git_blob_lookup(&ancestor_blob, repo, &conflict->ancestor->oid)) < 0)
+		if ((error = git_blob_lookup(&ancestor_blob, repo, &conflict->ancestor->id)) < 0)
 			goto done;
 
 		conflict->binary = git_blob_is_binary(ancestor_blob);
 	}
 
 	if (!conflict->binary && conflict->ours) {
-		if ((error = git_blob_lookup(&our_blob, repo, &conflict->ours->oid)) < 0)
+		if ((error = git_blob_lookup(&our_blob, repo, &conflict->ours->id)) < 0)
 			goto done;
 
 		conflict->binary = git_blob_is_binary(our_blob);
 	}
 
 	if (!conflict->binary && conflict->theirs) {
-		if ((error = git_blob_lookup(&their_blob, repo, &conflict->theirs->oid)) < 0)
+		if ((error = git_blob_lookup(&their_blob, repo, &conflict->theirs->id)) < 0)
 			goto done;
 
 		conflict->binary = git_blob_is_binary(their_blob);
@@ -1221,7 +1221,7 @@ static int checkout_update_index(
 	memset(&entry, 0, sizeof(entry));
 	entry.path = (char *)file->path; /* cast to prevent warning */
 	git_index_entry__init_from_stat(&entry, st, true);
-	git_oid_cpy(&entry.oid, &file->oid);
+	git_oid_cpy(&entry.id, &file->oid);
 
 	return git_index_add(data->index, &entry);
 }
@@ -1631,7 +1631,7 @@ static int checkout_write_entry(
 		return error;
 
 	return checkout_write_content(data,
-		&side->oid, git_buf_cstr(&data->path), hint_path, side->mode, &st);
+		&side->id, git_buf_cstr(&data->path), hint_path, side->mode, &st);
 }
 
 static int checkout_write_entries(
diff --git a/src/crlf.c b/src/crlf.c
index b25c02cce..e1bd5572b 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -101,7 +101,7 @@ static int has_cr_in_index(const git_filter_source *src)
 	if (!S_ISREG(entry->mode)) /* don't crlf filter non-blobs */
 		return true;
 
-	if (git_blob_lookup(&blob, repo, &entry->oid) < 0)
+	if (git_blob_lookup(&blob, repo, &entry->id) < 0)
 		return false;
 
 	blobcontent = git_blob_rawcontent(blob);
diff --git a/src/diff.c b/src/diff.c
index 7f2e58c0c..75a90a0b2 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -110,11 +110,11 @@ static int diff_delta__from_one(
 	if (delta->status == GIT_DELTA_DELETED) {
 		delta->old_file.mode = entry->mode;
 		delta->old_file.size = entry->file_size;
-		git_oid_cpy(&delta->old_file.oid, &entry->oid);
+		git_oid_cpy(&delta->old_file.oid, &entry->id);
 	} else /* ADDED, IGNORED, UNTRACKED */ {
 		delta->new_file.mode = entry->mode;
 		delta->new_file.size = entry->file_size;
-		git_oid_cpy(&delta->new_file.oid, &entry->oid);
+		git_oid_cpy(&delta->new_file.oid, &entry->id);
 	}
 
 	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_OID;
@@ -156,12 +156,12 @@ static int diff_delta__from_two(
 	GITERR_CHECK_ALLOC(delta);
 	delta->nfiles = 2;
 
-	git_oid_cpy(&delta->old_file.oid, &old_entry->oid);
+	git_oid_cpy(&delta->old_file.oid, &old_entry->id);
 	delta->old_file.size = old_entry->file_size;
 	delta->old_file.mode = old_mode;
 	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_OID;
 
-	git_oid_cpy(&delta->new_file.oid, &new_entry->oid);
+	git_oid_cpy(&delta->new_file.oid, &new_entry->id);
 	delta->new_file.size = new_entry->file_size;
 	delta->new_file.mode = new_mode;
 
@@ -172,7 +172,7 @@ static int diff_delta__from_two(
 			git_oid_cpy(&delta->new_file.oid, new_oid);
 	}
 
-	if (new_oid || !git_oid_iszero(&new_entry->oid))
+	if (new_oid || !git_oid_iszero(&new_entry->id))
 		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
 
 	return diff_insert_delta(diff, delta, matched_pathspec);
@@ -189,21 +189,21 @@ static git_diff_delta *diff_delta__last_for_item(
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED:
 	case GIT_DELTA_DELETED:
-		if (git_oid__cmp(&delta->old_file.oid, &item->oid) == 0)
+		if (git_oid__cmp(&delta->old_file.oid, &item->id) == 0)
 			return delta;
 		break;
 	case GIT_DELTA_ADDED:
-		if (git_oid__cmp(&delta->new_file.oid, &item->oid) == 0)
+		if (git_oid__cmp(&delta->new_file.oid, &item->id) == 0)
 			return delta;
 		break;
 	case GIT_DELTA_UNTRACKED:
 		if (diff->strcomp(delta->new_file.path, item->path) == 0 &&
-			git_oid__cmp(&delta->new_file.oid, &item->oid) == 0)
+			git_oid__cmp(&delta->new_file.oid, &item->id) == 0)
 			return delta;
 		break;
 	case GIT_DELTA_MODIFIED:
-		if (git_oid__cmp(&delta->old_file.oid, &item->oid) == 0 ||
-			git_oid__cmp(&delta->new_file.oid, &item->oid) == 0)
+		if (git_oid__cmp(&delta->old_file.oid, &item->id) == 0 ||
+			git_oid__cmp(&delta->new_file.oid, &item->id) == 0)
 			return delta;
 		break;
 	default:
@@ -629,7 +629,7 @@ static int maybe_modified_submodule(
 
 	/* now that we have a HEAD OID, check if HEAD moved */
 	if ((sm_status & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&
-		!git_oid_equal(&info->oitem->oid, found_oid))
+		!git_oid_equal(&info->oitem->id, found_oid))
 		*status = GIT_DELTA_MODIFIED;
 
 	return 0;
@@ -689,15 +689,15 @@ static int maybe_modified(
 	}
 
 	/* if oids and modes match (and are valid), then file is unmodified */
-	else if (git_oid_equal(&oitem->oid, &nitem->oid) &&
+	else if (git_oid_equal(&oitem->id, &nitem->id) &&
 			 omode == nmode &&
-			 !git_oid_iszero(&oitem->oid))
+			 !git_oid_iszero(&oitem->id))
 		status = GIT_DELTA_UNMODIFIED;
 
 	/* if we have an unknown OID and a workdir iterator, then check some
 	 * circumstances that can accelerate things or need special handling
 	 */
-	else if (git_oid_iszero(&nitem->oid) && new_is_workdir) {
+	else if (git_oid_iszero(&nitem->id) && new_is_workdir) {
 		bool use_ctime = ((diff->diffcaps & GIT_DIFFCAPS_TRUST_CTIME) != 0);
 		bool use_nanos = ((diff->diffcaps & GIT_DIFFCAPS_TRUST_NANOSECS) != 0);
 
@@ -732,7 +732,7 @@ static int maybe_modified(
 	/* if we got here and decided that the files are modified, but we
 	 * haven't calculated the OID of the new item, then calculate it now
 	 */
-	if (status == GIT_DELTA_MODIFIED && git_oid_iszero(&nitem->oid)) {
+	if (status == GIT_DELTA_MODIFIED && git_oid_iszero(&nitem->id)) {
 		if (git_oid_iszero(&noid)) {
 			if ((error = git_diff__oid_for_file(diff->repo,
 					nitem->path, nitem->mode, nitem->file_size, &noid)) < 0)
@@ -744,7 +744,7 @@ static int maybe_modified(
 		 * matches between the index and the workdir HEAD)
 		 */
 		if (omode == nmode && !S_ISGITLINK(omode) &&
-			git_oid_equal(&oitem->oid, &noid))
+			git_oid_equal(&oitem->id, &noid))
 			status = GIT_DELTA_UNMODIFIED;
 	}
 
diff --git a/src/index.c b/src/index.c
index bb81f666e..d58968454 100644
--- a/src/index.c
+++ b/src/index.c
@@ -643,7 +643,7 @@ static int index_entry_init(
 
 	git_index_entry__init_from_stat(entry, &st, !index->distrust_filemode);
 
-	entry->oid = oid;
+	entry->id = oid;
 	entry->path = git__strdup(rel_path);
 	GITERR_CHECK_ALLOC(entry->path);
 
@@ -757,9 +757,9 @@ static int index_conflict_to_reuc(git_index *index, const char *path)
 	our_mode = conflict_entries[1] == NULL ? 0 : conflict_entries[1]->mode;
 	their_mode = conflict_entries[2] == NULL ? 0 : conflict_entries[2]->mode;
 
-	ancestor_oid = conflict_entries[0] == NULL ? NULL : &conflict_entries[0]->oid;
-	our_oid = conflict_entries[1] == NULL ? NULL : &conflict_entries[1]->oid;
-	their_oid = conflict_entries[2] == NULL ? NULL : &conflict_entries[2]->oid;
+	ancestor_oid = conflict_entries[0] == NULL ? NULL : &conflict_entries[0]->id;
+	our_oid = conflict_entries[1] == NULL ? NULL : &conflict_entries[1]->id;
+	their_oid = conflict_entries[2] == NULL ? NULL : &conflict_entries[2]->id;
 
 	if ((ret = git_index_reuc_add(index, path, ancestor_mode, ancestor_oid,
 		our_mode, our_oid, their_mode, their_oid)) >= 0)
@@ -1515,7 +1515,7 @@ static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffe
 	dest->uid = ntohl(source->uid);
 	dest->gid = ntohl(source->gid);
 	dest->file_size = ntohl(source->file_size);
-	git_oid_cpy(&dest->oid, &source->oid);
+	git_oid_cpy(&dest->id, &source->oid);
 	dest->flags = ntohs(source->flags);
 
 	if (dest->flags & GIT_IDXENTRY_EXTENDED) {
@@ -1756,7 +1756,7 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry)
 	ondisk->gid = htonl(entry->gid);
 	ondisk->file_size = htonl((uint32_t)entry->file_size);
 
-	git_oid_cpy(&ondisk->oid, &entry->oid);
+	git_oid_cpy(&ondisk->oid, &entry->id);
 
 	ondisk->flags = htons(entry->flags);
 
@@ -1983,7 +1983,7 @@ static int read_tree_cb(
 	GITERR_CHECK_ALLOC(entry);
 
 	entry->mode = tentry->attr;
-	entry->oid = tentry->oid;
+	entry->id = tentry->oid;
 
 	/* look for corresponding old entry and copy data to new entry */
 	if (data->old_entries) {
@@ -1997,7 +1997,7 @@ static int read_tree_cb(
 				&pos, data->old_entries, data->entries_search, &skey) &&
 			(old_entry = git_vector_get(data->old_entries, pos)) != NULL &&
 			entry->mode == old_entry->mode &&
-			git_oid_equal(&entry->oid, &old_entry->oid))
+			git_oid_equal(&entry->id, &old_entry->id))
 		{
 			memcpy(entry, old_entry, sizeof(*entry));
 			entry->flags_extended = 0;
@@ -2135,7 +2135,7 @@ int git_index_add_all(
 			error = -1;
 			break;
 		}
-		entry->oid = blobid;
+		entry->id = blobid;
 
 		/* add working directory item to index */
 		if ((error = index_insert(index, entry, 1)) < 0) {
diff --git a/src/iterator.c b/src/iterator.c
index 0e7d0db85..401b5de93 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -447,7 +447,7 @@ static int tree_iterator__update_entry(tree_iterator *ti)
     te = tf->entries[tf->current]->te;
 
 	ti->entry.mode = te->attr;
-	git_oid_cpy(&ti->entry.oid, &te->oid);
+	git_oid_cpy(&ti->entry.id, &te->oid);
 
 	ti->entry.path = tree_iterator__current_filename(ti, te);
 	GITERR_CHECK_ALLOC(ti->entry.path);
diff --git a/src/merge.c b/src/merge.c
index 2fb1c5898..23a1574f7 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -317,7 +317,7 @@ GIT_INLINE(int) index_entry_cmp(const git_index_entry *a, const git_index_entry
 		return (b->path == NULL) ? 0 : 1;
 
 	if ((value = a->mode - b->mode) == 0 &&
-		(value = git_oid__cmp(&a->oid, &b->oid)) == 0)
+		(value = git_oid__cmp(&a->id, &b->id)) == 0)
 		value = strcmp(a->path, b->path);
 
 	return value;
@@ -478,12 +478,12 @@ static int merge_conflict_resolve_one_renamed(
 		conflict->type == GIT_MERGE_DIFF_RENAMED_ADDED)
 		return 0;
 
-	ours_changed = (git_oid__cmp(&conflict->ancestor_entry.oid, &conflict->our_entry.oid) != 0);
-	theirs_changed = (git_oid__cmp(&conflict->ancestor_entry.oid, &conflict->their_entry.oid) != 0);
+	ours_changed = (git_oid__cmp(&conflict->ancestor_entry.id, &conflict->our_entry.id) != 0);
+	theirs_changed = (git_oid__cmp(&conflict->ancestor_entry.id, &conflict->their_entry.id) != 0);
 
 	/* if both are modified (and not to a common target) require a merge */
 	if (ours_changed && theirs_changed &&
-		git_oid__cmp(&conflict->our_entry.oid, &conflict->their_entry.oid) != 0)
+		git_oid__cmp(&conflict->our_entry.id, &conflict->their_entry.id) != 0)
 		return 0;
 
 	if ((merged = git_pool_malloc(&diff_list->pool, sizeof(git_index_entry))) == NULL)
@@ -575,7 +575,7 @@ static int merge_conflict_resolve_automerge(
 
 	index_entry->file_size = result.len;
 	index_entry->mode = result.mode;
-	git_oid_cpy(&index_entry->oid, &automerge_oid);
+	git_oid_cpy(&index_entry->id, &automerge_oid);
 
 	git_vector_insert(&diff_list->staged, index_entry);
 	git_vector_insert(&diff_list->resolved, (git_merge_diff *)conflict);
@@ -643,7 +643,7 @@ static int index_entry_similarity_exact(
 	GIT_UNUSED(cache);
 	GIT_UNUSED(opts);
 
-	if (git_oid__cmp(&a->oid, &b->oid) == 0)
+	if (git_oid__cmp(&a->id, &b->id) == 0)
 		return 100;
 
 	return 0;
@@ -662,10 +662,10 @@ static int index_entry_similarity_calc(
 
 	*out = NULL;
 
-	if ((error = git_blob_lookup(&blob, repo, &entry->oid)) < 0)
+	if ((error = git_blob_lookup(&blob, repo, &entry->id)) < 0)
 		return error;
 
-	git_oid_cpy(&diff_file.oid, &entry->oid);
+	git_oid_cpy(&diff_file.oid, &entry->id);
 	diff_file.path = entry->path;
 	diff_file.size = entry->file_size;
 	diff_file.mode = entry->mode;
@@ -1163,7 +1163,7 @@ GIT_INLINE(int) merge_diff_detect_binary(
 	int error = 0;
 
 	if (GIT_MERGE_INDEX_ENTRY_ISFILE(conflict->ancestor_entry)) {
-		if ((error = git_blob_lookup(&ancestor_blob, repo, &conflict->ancestor_entry.oid)) < 0)
+		if ((error = git_blob_lookup(&ancestor_blob, repo, &conflict->ancestor_entry.id)) < 0)
 			goto done;
 
 		conflict->binary = git_blob_is_binary(ancestor_blob);
@@ -1171,7 +1171,7 @@ GIT_INLINE(int) merge_diff_detect_binary(
 
 	if (!conflict->binary &&
 		GIT_MERGE_INDEX_ENTRY_ISFILE(conflict->our_entry)) {
-		if ((error = git_blob_lookup(&our_blob, repo, &conflict->our_entry.oid)) < 0)
+		if ((error = git_blob_lookup(&our_blob, repo, &conflict->our_entry.id)) < 0)
 			goto done;
 
 		conflict->binary = git_blob_is_binary(our_blob);
@@ -1179,7 +1179,7 @@ GIT_INLINE(int) merge_diff_detect_binary(
 
 	if (!conflict->binary &&
 		GIT_MERGE_INDEX_ENTRY_ISFILE(conflict->their_entry)) {
-		if ((error = git_blob_lookup(&their_blob, repo, &conflict->their_entry.oid)) < 0)
+		if ((error = git_blob_lookup(&their_blob, repo, &conflict->their_entry.id)) < 0)
 			goto done;
 
 		conflict->binary = git_blob_is_binary(their_blob);
@@ -1222,7 +1222,7 @@ GIT_INLINE(int) merge_delta_type_from_index_entries(
 		return GIT_DELTA_TYPECHANGE;
 	else if(S_ISLNK(ancestor->mode) ^ S_ISLNK(other->mode))
 		return GIT_DELTA_TYPECHANGE;
-	else if (git_oid__cmp(&ancestor->oid, &other->oid) ||
+	else if (git_oid__cmp(&ancestor->id, &other->id) ||
 			 ancestor->mode != other->mode)
 		return GIT_DELTA_MODIFIED;
 
@@ -1497,7 +1497,7 @@ static int merge_index_insert_reuc(
 	}
 
 	mode[idx] = entry->mode;
-	oid[idx] = &entry->oid;
+	oid[idx] = &entry->id;
 
 	return git_index_reuc_add(index, entry->path,
 		mode[0], oid[0], mode[1], oid[1], mode[2], oid[2]);
diff --git a/src/merge_file.c b/src/merge_file.c
index 9961ef297..0878866bc 100644
--- a/src/merge_file.c
+++ b/src/merge_file.c
@@ -77,7 +77,7 @@ int git_merge_file_input_from_index_entry(
 		return 0;
 
 	if ((error = git_repository_odb(&odb, repo)) < 0 ||
-		(error = git_odb_read(&input->odb_object, odb, &entry->oid)) < 0)
+		(error = git_odb_read(&input->odb_object, odb, &entry->id)) < 0)
 		goto done;
 
 	input->mode = entry->mode;
diff --git a/src/notes.c b/src/notes.c
index 1ff0e35c3..ffe5d345a 100644
--- a/src/notes.c
+++ b/src/notes.c
@@ -640,7 +640,7 @@ int git_note_next(
 	if ((error = git_iterator_current(&item, it)) < 0)
 		return error;
 
-	git_oid_cpy(note_id, &item->oid);
+	git_oid_cpy(note_id, &item->id);
 
 	if (!(error = process_entry_path(item->path, annotated_id)))
 		git_iterator_advance(NULL, it);
diff --git a/src/reset.c b/src/reset.c
index 32e101357..b9c783be3 100644
--- a/src/reset.c
+++ b/src/reset.c
@@ -72,7 +72,7 @@ int git_reset_default(
 				goto cleanup;
 		} else {
 			entry.mode = delta->new_file.mode;
-			git_oid_cpy(&entry.oid, &delta->new_file.oid);
+			git_oid_cpy(&entry.id, &delta->new_file.oid);
 			entry.path = (char *)delta->new_file.path;
 
 			if ((error = git_index_add(index, &entry)) < 0)
diff --git a/src/submodule.c b/src/submodule.c
index 3ffbfdba4..720681db9 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -387,7 +387,7 @@ int git_submodule_add_to_index(git_submodule *sm, int write_index)
 		error = -1;
 		goto cleanup;
 	}
-	git_oid_cpy(&entry.oid, &sm->wd_oid);
+	git_oid_cpy(&entry.id, &sm->wd_oid);
 
 	if ((error = git_commit_lookup(&head, sm_repo, &sm->wd_oid)) < 0)
 		goto cleanup;
@@ -780,7 +780,7 @@ static void submodule_update_from_index_entry(
 		if (already_found)
 			sm->flags |= GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES;
 		else
-			git_oid_cpy(&sm->index_oid, &ie->oid);
+			git_oid_cpy(&sm->index_oid, &ie->id);
 
 		sm->flags |= GIT_SUBMODULE_STATUS_IN_INDEX |
 			GIT_SUBMODULE_STATUS__INDEX_OID_VALID;
@@ -1281,7 +1281,7 @@ static int load_submodule_config_from_index(
 			if (!submodule_get(&sm, repo, entry->path, NULL))
 				submodule_update_from_index_entry(sm, entry);
 		} else if (strcmp(entry->path, GIT_MODULES_FILE) == 0)
-			git_oid_cpy(gitmodules_oid, &entry->oid);
+			git_oid_cpy(gitmodules_oid, &entry->id);
 	}
 
 	if (error == GIT_ITEROVER)
@@ -1320,16 +1320,16 @@ static int load_submodule_config_from_head(
 
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_head_data(
-					sm, entry->mode, &entry->oid);
+					sm, entry->mode, &entry->id);
 			else
 				sm->flags |= GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE;
 		} else if (S_ISGITLINK(entry->mode)) {
 			if (!submodule_get(&sm, repo, entry->path, NULL))
 				submodule_update_from_head_data(
-					sm, entry->mode, &entry->oid);
+					sm, entry->mode, &entry->id);
 		} else if (strcmp(entry->path, GIT_MODULES_FILE) == 0 &&
 				   git_oid_iszero(gitmodules_oid)) {
-			git_oid_cpy(gitmodules_oid, &entry->oid);
+			git_oid_cpy(gitmodules_oid, &entry->id);
 		}
 	}
 
diff --git a/src/tree.c b/src/tree.c
index fc105ed5e..3fb544e4d 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -551,7 +551,7 @@ static int write_tree(
 			if (error < 0)
 				goto on_error;
 		} else {
-			error = append_entry(bld, filename, &entry->oid, entry->mode);
+			error = append_entry(bld, filename, &entry->id, entry->mode);
 			if (error < 0)
 				goto on_error;
 		}
diff --git a/tests/attr/repo.c b/tests/attr/repo.c
index f9ba585fb..49cccdc5a 100644
--- a/tests/attr/repo.c
+++ b/tests/attr/repo.c
@@ -293,7 +293,7 @@ static void assert_proper_normalization(git_index *index, const char *filename,
 	cl_assert(!git_index_find(&index_pos, index, filename));
 
 	entry = git_index_get_byindex(index, index_pos);
-	cl_assert_equal_i(0, git_oid_streq(&entry->oid, expected_sha));
+	cl_assert_equal_i(0, git_oid_streq(&entry->id, expected_sha));
 }
 
 void test_attr_repo__staging_properly_normalizes_line_endings_according_to_gitattributes_directives(void)
diff --git a/tests/checkout/conflict.c b/tests/checkout/conflict.c
index 66965a89b..a8b93b28d 100644
--- a/tests/checkout/conflict.c
+++ b/tests/checkout/conflict.c
@@ -96,7 +96,7 @@ static void create_index(struct checkout_index_entry *entries, size_t entries_le
 
 		entry.mode = entries[i].mode;
 		entry.flags = entries[i].stage << GIT_IDXENTRY_STAGESHIFT;
-		git_oid_fromstr(&entry.oid, entries[i].oid_str);
+		git_oid_fromstr(&entry.id, entries[i].oid_str);
 		entry.path = entries[i].path;
 
 		cl_git_pass(git_index_add(g_index, &entry));
diff --git a/tests/checkout/crlf.c b/tests/checkout/crlf.c
index 9a4cbd313..cba79432f 100644
--- a/tests/checkout/crlf.c
+++ b/tests/checkout/crlf.c
@@ -174,13 +174,13 @@ void test_checkout_crlf__with_ident(void)
 	/* check that blobs have $Id$ */
 
 	cl_git_pass(git_blob_lookup(&blob, g_repo,
-		& git_index_get_bypath(index, "lf.ident", 0)->oid));
+		& git_index_get_bypath(index, "lf.ident", 0)->id));
 	cl_assert_equal_s(
 		ALL_LF_TEXT_RAW "\n$Id$\n", git_blob_rawcontent(blob));
 	git_blob_free(blob);
 
 	cl_git_pass(git_blob_lookup(&blob, g_repo,
-		& git_index_get_bypath(index, "more2.identcrlf", 0)->oid));
+		& git_index_get_bypath(index, "more2.identcrlf", 0)->id));
 	cl_assert_equal_s(
 		"\n$Id$\n" MORE_CRLF_TEXT_AS_LF, git_blob_rawcontent(blob));
 	git_blob_free(blob);
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index 047c9ed98..3c731c5ae 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -892,16 +892,16 @@ static void create_conflict(void)
 	memset(&entry, 0x0, sizeof(git_index_entry));
 	entry.mode = 0100644;
 	entry.flags = 1 << GIT_IDXENTRY_STAGESHIFT;
-	git_oid_fromstr(&entry.oid, "d427e0b2e138501a3d15cc376077a3631e15bd46");
+	git_oid_fromstr(&entry.id, "d427e0b2e138501a3d15cc376077a3631e15bd46");
 	entry.path = "conflicts.txt";
 	cl_git_pass(git_index_add(index, &entry));
 
 	entry.flags = 2 << GIT_IDXENTRY_STAGESHIFT;
-	git_oid_fromstr(&entry.oid, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf");
+	git_oid_fromstr(&entry.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf");
 	cl_git_pass(git_index_add(index, &entry));
 
 	entry.flags = 3 << GIT_IDXENTRY_STAGESHIFT;
-	git_oid_fromstr(&entry.oid, "2bd0a343aeef7a2cf0d158478966a6e587ff3863");
+	git_oid_fromstr(&entry.id, "2bd0a343aeef7a2cf0d158478966a6e587ff3863");
 	cl_git_pass(git_index_add(index, &entry));
 
 	git_index_write(index);
diff --git a/tests/diff/iterator.c b/tests/diff/iterator.c
index bbdae8ad1..92e6f723b 100644
--- a/tests/diff/iterator.c
+++ b/tests/diff/iterator.c
@@ -377,7 +377,7 @@ static void index_iterator_test(
 		if (expected_oids != NULL) {
 			git_oid oid;
 			cl_git_pass(git_oid_fromstr(&oid, expected_oids[count]));
-			cl_assert_equal_i(git_oid_cmp(&oid, &entry->oid), 0);
+			cl_assert_equal_i(git_oid_cmp(&oid, &entry->id), 0);
 		}
 
 		count++;
diff --git a/tests/filter/custom.c b/tests/filter/custom.c
index a81885c28..70524010e 100644
--- a/tests/filter/custom.c
+++ b/tests/filter/custom.c
@@ -299,7 +299,7 @@ void test_filter_custom__order_dependency(void)
 	git_index_free(index);
 
 	cl_git_pass(git_blob_lookup(&blob, g_repo,
-		& git_index_get_bypath(index, "hero.1.rev-ident", 0)->oid));
+		& git_index_get_bypath(index, "hero.1.rev-ident", 0)->id));
 	cl_assert_equal_s(
 		"\n!nuf evaH\n$dI$\ntset a si sihT", git_blob_rawcontent(blob));
 	cl_git_pass(git_blob_filtered_content(&buf, blob, "hero.1.rev-ident", 0));
@@ -310,7 +310,7 @@ void test_filter_custom__order_dependency(void)
 	git_blob_free(blob);
 
 	cl_git_pass(git_blob_lookup(&blob, g_repo,
-		& git_index_get_bypath(index, "hero.2.rev-ident", 0)->oid));
+		& git_index_get_bypath(index, "hero.2.rev-ident", 0)->id));
 	cl_assert_equal_s(
 		"\n!yzarC\n$Id$\ntset rehtonA", git_blob_rawcontent(blob));
 	cl_git_pass(git_blob_filtered_content(&buf, blob, "hero.2.rev-ident", 0));
diff --git a/tests/index/conflicts.c b/tests/index/conflicts.c
index 6311b3a75..90aaa442d 100644
--- a/tests/index/conflicts.c
+++ b/tests/index/conflicts.c
@@ -47,15 +47,15 @@ void test_index_conflicts__add(void)
 
 	ancestor_entry.path = "test-one.txt";
 	ancestor_entry.flags |= (1 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&ancestor_entry.oid, TEST_ANCESTOR_OID);
+	git_oid_fromstr(&ancestor_entry.id, TEST_ANCESTOR_OID);
 
 	our_entry.path = "test-one.txt";
 	ancestor_entry.flags |= (2 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&our_entry.oid, TEST_OUR_OID);
+	git_oid_fromstr(&our_entry.id, TEST_OUR_OID);
 
 	their_entry.path = "test-one.txt";
 	ancestor_entry.flags |= (3 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&their_entry.oid, TEST_THEIR_OID);
+	git_oid_fromstr(&their_entry.id, TEST_THEIR_OID);
 
 	cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, &our_entry, &their_entry));
 
@@ -75,15 +75,15 @@ void test_index_conflicts__add_fixes_incorrect_stage(void)
 
 	ancestor_entry.path = "test-one.txt";
 	ancestor_entry.flags |= (3 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&ancestor_entry.oid, TEST_ANCESTOR_OID);
+	git_oid_fromstr(&ancestor_entry.id, TEST_ANCESTOR_OID);
 
 	our_entry.path = "test-one.txt";
 	ancestor_entry.flags |= (1 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&our_entry.oid, TEST_OUR_OID);
+	git_oid_fromstr(&our_entry.id, TEST_OUR_OID);
 
 	their_entry.path = "test-one.txt";
 	ancestor_entry.flags |= (2 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&their_entry.oid, TEST_THEIR_OID);
+	git_oid_fromstr(&their_entry.id, TEST_THEIR_OID);
 
 	cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, &our_entry, &their_entry));
 
@@ -107,13 +107,13 @@ void test_index_conflicts__get(void)
 	cl_assert_equal_s("conflicts-one.txt", conflict_entry[0]->path);
 
 	git_oid_fromstr(&oid, CONFLICTS_ONE_ANCESTOR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[0]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[0]->id, &oid) == 0);
 
 	git_oid_fromstr(&oid, CONFLICTS_ONE_OUR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[1]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[1]->id, &oid) == 0);
 
 	git_oid_fromstr(&oid, CONFLICTS_ONE_THEIR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[2]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[2]->id, &oid) == 0);
 
 	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
 		&conflict_entry[2], repo_index, "conflicts-two.txt"));
@@ -121,13 +121,13 @@ void test_index_conflicts__get(void)
 	cl_assert_equal_s("conflicts-two.txt", conflict_entry[0]->path);
 
 	git_oid_fromstr(&oid, CONFLICTS_TWO_ANCESTOR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[0]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[0]->id, &oid) == 0);
 
 	git_oid_fromstr(&oid, CONFLICTS_TWO_OUR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[1]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[1]->id, &oid) == 0);
 
 	git_oid_fromstr(&oid, CONFLICTS_TWO_THEIR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[2]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[2]->id, &oid) == 0);
 }
 
 void test_index_conflicts__iterate(void)
@@ -141,29 +141,29 @@ void test_index_conflicts__iterate(void)
 	cl_git_pass(git_index_conflict_next(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], iterator));
 
 	git_oid_fromstr(&oid, CONFLICTS_ONE_ANCESTOR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[0]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[0]->id, &oid) == 0);
 	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);
 
 	git_oid_fromstr(&oid, CONFLICTS_ONE_OUR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[1]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[1]->id, &oid) == 0);
 	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);
 
 	git_oid_fromstr(&oid, CONFLICTS_ONE_THEIR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[2]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[2]->id, &oid) == 0);
 	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-one.txt") == 0);
 
 	cl_git_pass(git_index_conflict_next(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], iterator));
 
 	git_oid_fromstr(&oid, CONFLICTS_TWO_ANCESTOR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[0]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[0]->id, &oid) == 0);
 	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);
 
 	git_oid_fromstr(&oid, CONFLICTS_TWO_OUR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[1]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[1]->id, &oid) == 0);
 	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);
 
 	git_oid_fromstr(&oid, CONFLICTS_TWO_THEIR_OID);
-	cl_assert(git_oid_cmp(&conflict_entry[2]->oid, &oid) == 0);
+	cl_assert(git_oid_cmp(&conflict_entry[2]->id, &oid) == 0);
 	cl_assert(git__strcmp(conflict_entry[0]->path, "conflicts-two.txt") == 0);
 
 	cl_assert(git_index_conflict_next(&conflict_entry[0], &conflict_entry[1], &conflict_entry[2], iterator) == GIT_ITEROVER);
@@ -273,7 +273,7 @@ void test_index_conflicts__partial(void)
 
 	ancestor_entry.path = "test-one.txt";
 	ancestor_entry.flags |= (1 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&ancestor_entry.oid, TEST_ANCESTOR_OID);
+	git_oid_fromstr(&ancestor_entry.id, TEST_ANCESTOR_OID);
 
 	cl_git_pass(git_index_conflict_add(repo_index, &ancestor_entry, NULL, NULL));
 	cl_assert(git_index_entrycount(repo_index) == 9);
@@ -281,7 +281,7 @@ void test_index_conflicts__partial(void)
 	cl_git_pass(git_index_conflict_get(&conflict_entry[0], &conflict_entry[1],
 		&conflict_entry[2], repo_index, "test-one.txt"));
 
-	cl_assert(git_oid_cmp(&ancestor_entry.oid, &conflict_entry[0]->oid) == 0);
+	cl_assert(git_oid_cmp(&ancestor_entry.id, &conflict_entry[0]->id) == 0);
 	cl_assert(conflict_entry[1] == NULL);
 	cl_assert(conflict_entry[2] == NULL);
 }
diff --git a/tests/index/rename.c b/tests/index/rename.c
index 4deef1332..b6fb61d10 100644
--- a/tests/index/rename.c
+++ b/tests/index/rename.c
@@ -27,7 +27,7 @@ void test_index_rename__single_file(void)
 	cl_assert(!git_index_find(&position, index, "lame.name.txt"));
 
 	entry = git_index_get_byindex(index, position);
-	cl_assert(git_oid_cmp(&expected, &entry->oid) == 0);
+	cl_assert(git_oid_cmp(&expected, &entry->id) == 0);
 
 	/* This removes the entry from the index, but not from the object database */
 	cl_git_pass(git_index_remove(index, "lame.name.txt", 0));
@@ -41,7 +41,7 @@ void test_index_rename__single_file(void)
 	cl_assert(!git_index_find(&position, index, "fancy.name.txt"));
 
 	entry = git_index_get_byindex(index, position);
-	cl_assert(git_oid_cmp(&expected, &entry->oid) == 0);
+	cl_assert(git_oid_cmp(&expected, &entry->id) == 0);
 
 	git_index_free(index);
 	git_repository_free(repo);
diff --git a/tests/index/tests.c b/tests/index/tests.c
index 5a05bd8a9..bd90bc557 100644
--- a/tests/index/tests.c
+++ b/tests/index/tests.c
@@ -243,11 +243,11 @@ void test_index_tests__add(void)
 	entry = git_index_get_byindex(index, 0);
 
 	/* And the built-in hashing mechanism worked as expected */
-	cl_assert(git_oid_cmp(&id1, &entry->oid) == 0);
+	cl_assert(git_oid_cmp(&id1, &entry->id) == 0);
 
 	/* Test access by path instead of index */
 	cl_assert((entry = git_index_get_bypath(index, "test.txt", 0)) != NULL);
-	cl_assert(git_oid_cmp(&id1, &entry->oid) == 0);
+	cl_assert(git_oid_cmp(&id1, &entry->id) == 0);
 
 	git_index_free(index);
 	git_repository_free(repo);
@@ -283,14 +283,14 @@ void test_index_tests__add_issue_1397(void)
 
 	/* Make sure the initial SHA-1 is correct */
 	cl_assert((entry = git_index_get_bypath(index, "crlf_file.txt", 0)) != NULL);
-	cl_assert_(git_oid_cmp(&id1, &entry->oid) == 0, "first oid check");
+	cl_assert_(git_oid_cmp(&id1, &entry->id) == 0, "first oid check");
 
 	/* Update the index */
 	cl_git_pass(git_index_add_bypath(index, "crlf_file.txt"));
 
 	/* Check the new SHA-1 */
 	cl_assert((entry = git_index_get_bypath(index, "crlf_file.txt", 0)) != NULL);
-	cl_assert_(git_oid_cmp(&id1, &entry->oid) == 0, "second oid check");
+	cl_assert_(git_oid_cmp(&id1, &entry->id) == 0, "second oid check");
 
 	git_index_free(index);
 }
diff --git a/tests/merge/merge_helpers.c b/tests/merge/merge_helpers.c
index 7ce5e28ff..8d6ef2dbe 100644
--- a/tests/merge/merge_helpers.c
+++ b/tests/merge/merge_helpers.c
@@ -112,7 +112,7 @@ void merge__dump_index_entries(git_vector *index_entries)
 		index_entry = index_entries->contents[i];
 
 		printf("%o ", index_entry->mode);
-		printf("%s ", git_oid_allocfmt(&index_entry->oid));
+		printf("%s ", git_oid_allocfmt(&index_entry->id));
 		printf("%d ", git_index_entry_stage(index_entry));
 		printf("%s ", index_entry->path);
 		printf("\n");
@@ -166,7 +166,7 @@ static int index_entry_eq_merge_index_entry(const struct merge_index_entry *expe
 		test_oid = 0;
 
 	if (actual->mode != expected->mode ||
-		(test_oid && git_oid_cmp(&actual->oid, &expected_oid) != 0) ||
+		(test_oid && git_oid_cmp(&actual->id, &expected_oid) != 0) ||
 		git_index_entry_stage(actual) != expected->stage)
 		return 0;
 
diff --git a/tests/merge/trees/automerge.c b/tests/merge/trees/automerge.c
index ebc6e271d..bd710e6d8 100644
--- a/tests/merge/trees/automerge.c
+++ b/tests/merge/trees/automerge.c
@@ -121,7 +121,7 @@ void test_merge_trees_automerge__automerge(void)
 	cl_assert((entry = git_index_get_bypath(index, "automergeable.txt", 0)) != NULL);
 	cl_assert(entry->file_size == strlen(AUTOMERGEABLE_MERGED_FILE));
 
-	cl_git_pass(git_object_lookup((git_object **)&blob, repo, &entry->oid, GIT_OBJ_BLOB));
+	cl_git_pass(git_object_lookup((git_object **)&blob, repo, &entry->id, GIT_OBJ_BLOB));
 	cl_assert(memcmp(git_blob_rawcontent(blob), AUTOMERGEABLE_MERGED_FILE, (size_t)entry->file_size) == 0);
 
 	git_index_free(index);
diff --git a/tests/merge/trees/commits.c b/tests/merge/trees/commits.c
index f8f4fbacb..eeb30dae5 100644
--- a/tests/merge/trees/commits.c
+++ b/tests/merge/trees/commits.c
@@ -72,7 +72,7 @@ void test_merge_trees_commits__automerge(void)
 	cl_assert((entry = git_index_get_bypath(index, "automergeable.txt", 0)) != NULL);
 	cl_assert(entry->file_size == strlen(AUTOMERGEABLE_MERGED_FILE));
 
-	cl_git_pass(git_object_lookup((git_object **)&blob, repo, &entry->oid, GIT_OBJ_BLOB));
+	cl_git_pass(git_object_lookup((git_object **)&blob, repo, &entry->id, GIT_OBJ_BLOB));
 	cl_assert(memcmp(git_blob_rawcontent(blob), AUTOMERGEABLE_MERGED_FILE, (size_t)entry->file_size) == 0);
 
 	git_index_free(index);
diff --git a/tests/merge/trees/trivial.c b/tests/merge/trees/trivial.c
index 2de187bf4..377b24742 100644
--- a/tests/merge/trees/trivial.c
+++ b/tests/merge/trees/trivial.c
@@ -259,7 +259,7 @@ void test_merge_trees_trivial__13(void)
 
 	cl_assert(entry = git_index_get_bypath(result, "modified-in-13.txt", 0));
 	cl_git_pass(git_oid_fromstr(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b"));
-	cl_assert(git_oid_cmp(&entry->oid, &expected_oid) == 0);
+	cl_assert(git_oid_cmp(&entry->id, &expected_oid) == 0);
 
 	cl_assert(git_index_reuc_entrycount(result) == 0);
 	cl_assert(merge_trivial_conflict_entrycount(result) == 0);
@@ -278,7 +278,7 @@ void test_merge_trees_trivial__14(void)
 
 	cl_assert(entry = git_index_get_bypath(result, "modified-in-14-branch.txt", 0));
 	cl_git_pass(git_oid_fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9"));
-	cl_assert(git_oid_cmp(&entry->oid, &expected_oid) == 0);
+	cl_assert(git_oid_cmp(&entry->id, &expected_oid) == 0);
 
 	cl_assert(git_index_reuc_entrycount(result) == 0);
 	cl_assert(merge_trivial_conflict_entrycount(result) == 0);
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 6b152cc4d..266719e2a 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -696,7 +696,7 @@ void test_merge_workdir_simple__binary(void)
 	cl_assert((binary_entry = git_index_get_bypath(repo_index, "binary", 0)) != NULL);
 
 	cl_git_pass(git_oid_fromstr(&our_file_oid, "23ed141a6ae1e798b2f721afedbe947c119111ba"));
-	cl_assert(git_oid_cmp(&binary_entry->oid, &our_file_oid) == 0);
+	cl_assert(git_oid_cmp(&binary_entry->id, &our_file_oid) == 0);
 
 	git_merge_head_free(their_head);
 	git_merge_result_free(result);
diff --git a/tests/merge/workdir/trivial.c b/tests/merge/workdir/trivial.c
index 71437d48e..a6bbbf095 100644
--- a/tests/merge/workdir/trivial.c
+++ b/tests/merge/workdir/trivial.c
@@ -226,7 +226,7 @@ void test_merge_workdir_trivial__13(void)
 
 	cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-13.txt", 0));
 	cl_git_pass(git_oid_fromstr(&expected_oid, "1cff9ec6a47a537380dedfdd17c9e76d74259a2b"));
-	cl_assert(git_oid_cmp(&entry->oid, &expected_oid) == 0);
+	cl_assert(git_oid_cmp(&entry->id, &expected_oid) == 0);
 
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
 	cl_assert(merge_trivial_conflict_entrycount() == 0);
@@ -242,7 +242,7 @@ void test_merge_workdir_trivial__14(void)
 
 	cl_assert(entry = git_index_get_bypath(repo_index, "modified-in-14-branch.txt", 0));
 	cl_git_pass(git_oid_fromstr(&expected_oid, "26153a3ff3649b6c2bb652d3f06878c6e0a172f9"));
-	cl_assert(git_oid_cmp(&entry->oid, &expected_oid) == 0);
+	cl_assert(git_oid_cmp(&entry->id, &expected_oid) == 0);
 
 	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
 	cl_assert(merge_trivial_conflict_entrycount() == 0);
diff --git a/tests/object/commit/commitstagedfile.c b/tests/object/commit/commitstagedfile.c
index 9867ab418..05a0d1605 100644
--- a/tests/object/commit/commitstagedfile.c
+++ b/tests/object/commit/commitstagedfile.c
@@ -77,7 +77,7 @@ void test_object_commit_commitstagedfile__generate_predictable_object_ids(void)
 
 	entry = git_index_get_byindex(index, 0);
 
-	cl_assert(git_oid_cmp(&expected_blob_oid, &entry->oid) == 0);
+	cl_assert(git_oid_cmp(&expected_blob_oid, &entry->id) == 0);
 
 	/*
 	 * Information about index entry should match test file
diff --git a/tests/object/tree/duplicateentries.c b/tests/object/tree/duplicateentries.c
index 9262f9a1a..1b752acbb 100644
--- a/tests/object/tree/duplicateentries.c
+++ b/tests/object/tree/duplicateentries.c
@@ -127,17 +127,17 @@ static void add_fake_conflicts(git_index *index)
 	ancestor_entry.path = "duplicate";
 	ancestor_entry.mode = GIT_FILEMODE_BLOB;
 	ancestor_entry.flags |= (1 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&ancestor_entry.oid, "a8233120f6ad708f843d861ce2b7228ec4e3dec6");
+	git_oid_fromstr(&ancestor_entry.id, "a8233120f6ad708f843d861ce2b7228ec4e3dec6");
 
 	our_entry.path = "duplicate";
 	our_entry.mode = GIT_FILEMODE_BLOB;
 	ancestor_entry.flags |= (2 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&our_entry.oid, "45b983be36b73c0788dc9cbcb76cbb80fc7bb057");
+	git_oid_fromstr(&our_entry.id, "45b983be36b73c0788dc9cbcb76cbb80fc7bb057");
 
 	their_entry.path = "duplicate";
 	their_entry.mode = GIT_FILEMODE_BLOB;
 	ancestor_entry.flags |= (3 << GIT_IDXENTRY_STAGESHIFT);
-	git_oid_fromstr(&their_entry.oid, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd");
+	git_oid_fromstr(&their_entry.id, "a71586c1dfe8a71c6cbf6c129f404c5642ff31bd");
 
 	cl_git_pass(git_index_conflict_add(index, &ancestor_entry, &our_entry, &their_entry));
 }
diff --git a/tests/reset/default.c b/tests/reset/default.c
index e29e63550..57a3f7c51 100644
--- a/tests/reset/default.c
+++ b/tests/reset/default.c
@@ -57,7 +57,7 @@ static void assert_content_in_index(
 			if (!expected_shas)
 				continue;
 
-			cl_git_pass(git_oid_streq(&entry->oid, expected_shas->strings[i]));
+			cl_git_pass(git_oid_streq(&entry->id, expected_shas->strings[i]));
 		} else
 			cl_assert_equal_i(should_exist, error != GIT_ENOTFOUND);
 	}
diff --git a/tests/reset/hard.c b/tests/reset/hard.c
index 1c0c84135..0f80d32df 100644
--- a/tests/reset/hard.c
+++ b/tests/reset/hard.c
@@ -111,7 +111,7 @@ static void index_entry_init(git_index *index, int side, git_oid *oid)
 	entry.path = "conflicting_file";
 	entry.flags = (side << GIT_IDXENTRY_STAGESHIFT);
 	entry.mode = 0100644;
-	git_oid_cpy(&entry.oid, oid);
+	git_oid_cpy(&entry.id, oid);
 
 	cl_git_pass(git_index_add(index, &entry));
 }
diff --git a/tests/status/worktree.c b/tests/status/worktree.c
index fd57fcc1e..def3d60f0 100644
--- a/tests/status/worktree.c
+++ b/tests/status/worktree.c
@@ -455,15 +455,15 @@ void test_status_worktree__conflict_with_diff3(void)
 	memset(&their_entry, 0x0, sizeof(git_index_entry));
 
 	ancestor_entry.path = "modified_file";
-	git_oid_fromstr(&ancestor_entry.oid,
+	git_oid_fromstr(&ancestor_entry.id,
 		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
 
 	our_entry.path = "modified_file";
-	git_oid_fromstr(&our_entry.oid,
+	git_oid_fromstr(&our_entry.id,
 		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
 
 	their_entry.path = "modified_file";
-	git_oid_fromstr(&their_entry.oid,
+	git_oid_fromstr(&their_entry.id,
 		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
 
 	cl_git_pass(git_status_file(&status, repo, "modified_file"));
@@ -605,15 +605,15 @@ void test_status_worktree__conflicted_item(void)
 	memset(&their_entry, 0x0, sizeof(git_index_entry));
 
 	ancestor_entry.path = "modified_file";
-	git_oid_fromstr(&ancestor_entry.oid,
+	git_oid_fromstr(&ancestor_entry.id,
 		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
 
 	our_entry.path = "modified_file";
-	git_oid_fromstr(&our_entry.oid,
+	git_oid_fromstr(&our_entry.id,
 		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
 
 	their_entry.path = "modified_file";
-	git_oid_fromstr(&their_entry.oid,
+	git_oid_fromstr(&their_entry.id,
 		"452e4244b5d083ddf0460acf1ecc74db9dcfa11a");
 
 	cl_git_pass(git_status_file(&status, repo, "modified_file"));
-- 
cgit v1.2.3


From 47e28349bc4874114e2cfce0b91c40938b105b25 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 24 Jan 2014 12:01:34 +0100
Subject: commit: remvoe legacy 'oid' naming

---
 include/git2/sys/commit.h | 2 +-
 src/commit.c              | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/git2/sys/commit.h b/include/git2/sys/commit.h
index 34a12fb15..c8ed56b66 100644
--- a/include/git2/sys/commit.h
+++ b/include/git2/sys/commit.h
@@ -29,7 +29,7 @@ GIT_BEGIN_DECL
  * the `tree`, neither the `parents` list of `git_oid`s are checked for
  * validity.
  */
-GIT_EXTERN(int) git_commit_create_from_oids(
+GIT_EXTERN(int) git_commit_create_from_ids(
 	git_oid *oid,
 	git_repository *repo,
 	const char *update_ref,
diff --git a/src/commit.c b/src/commit.c
index e437cffe6..da7c4992e 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -69,7 +69,7 @@ int git_commit_create_v(
 	return res;
 }
 
-int git_commit_create_from_oids(
+int git_commit_create_from_ids(
 	git_oid *oid,
 	git_repository *repo,
 	const char *update_ref,
@@ -148,7 +148,7 @@ int git_commit_create(
 		parent_oids[i] = git_object_id((const git_object *)parents[i]);
 	}
 
-	retval = git_commit_create_from_oids(
+	retval = git_commit_create_from_ids(
 		oid, repo, update_ref, author, committer,
 		message_encoding, message,
 		git_object_id((const git_object *)tree), parent_count, parent_oids);
-- 
cgit v1.2.3


From f000ee4e5b840e9f110123a050777fb1301b19bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 24 Jan 2014 18:23:46 +0100
Subject: tree: remove legacy 'oid' naming

Rename git_tree_entry_byoid() to _byid() as per the convention.
---
 include/git2/tree.h | 6 +++---
 src/tree.c          | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/git2/tree.h b/include/git2/tree.h
index 6350ada9b..6669652ae 100644
--- a/include/git2/tree.h
+++ b/include/git2/tree.h
@@ -121,11 +121,11 @@ GIT_EXTERN(const git_tree_entry *) git_tree_entry_byindex(
  * Warning: this must examine every entry in the tree, so it is not fast.
  *
  * @param tree a previously loaded tree.
- * @param oid the sha being looked for
+ * @param id the sha being looked for
  * @return the tree entry; NULL if not found
  */
-GIT_EXTERN(const git_tree_entry *) git_tree_entry_byoid(
-	const git_tree *tree, const git_oid *oid);
+GIT_EXTERN(const git_tree_entry *) git_tree_entry_byid(
+	const git_tree *tree, const git_oid *id);
 
 /**
  * Retrieve a tree entry contained in a tree or in any of its subtrees,
diff --git a/src/tree.c b/src/tree.c
index 3fb544e4d..877a3fcee 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -305,8 +305,8 @@ const git_tree_entry *git_tree_entry_byindex(
 	return git_vector_get(&tree->entries, idx);
 }
 
-const git_tree_entry *git_tree_entry_byoid(
-	const git_tree *tree, const git_oid *oid)
+const git_tree_entry *git_tree_entry_byid(
+	const git_tree *tree, const git_oid *id)
 {
 	size_t i;
 	const git_tree_entry *e;
@@ -314,7 +314,7 @@ const git_tree_entry *git_tree_entry_byoid(
 	assert(tree);
 
 	git_vector_foreach(&tree->entries, i, e) {
-		if (memcmp(&e->oid.id, &oid->id, sizeof(oid->id)) == 0)
+		if (memcmp(&e->oid.id, &id->id, sizeof(id->id)) == 0)
 			return e;
 	}
 
-- 
cgit v1.2.3


From 9950bb4e8de076565976128559ff273e9d4a2a78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 24 Jan 2014 20:23:17 +0100
Subject: diff: rename the file's 'oid' to 'id'

In the same vein as the previous commits in this series.
---
 include/git2/diff.h    |  4 ++--
 src/checkout.c         | 14 +++++++-------
 src/diff.c             | 32 ++++++++++++++++----------------
 src/diff.h             |  2 +-
 src/diff_file.c        | 26 +++++++++++++-------------
 src/diff_patch.c       | 10 +++++-----
 src/diff_print.c       | 12 ++++++------
 src/diff_tform.c       | 28 ++++++++++++++--------------
 src/merge.c            |  2 +-
 src/merge_file.c       |  2 +-
 src/reset.c            |  2 +-
 src/status.c           | 18 +++++++++---------
 tests/checkout/index.c |  4 ++--
 tests/diff/blob.c      | 32 ++++++++++++++++----------------
 14 files changed, 94 insertions(+), 94 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 76fb23654..d7c294309 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -203,7 +203,7 @@ typedef struct git_diff git_diff;
 typedef enum {
 	GIT_DIFF_FLAG_BINARY     = (1u << 0), /** file(s) treated as binary data */
 	GIT_DIFF_FLAG_NOT_BINARY = (1u << 1), /** file(s) treated as text data */
-	GIT_DIFF_FLAG_VALID_OID  = (1u << 2), /** `oid` value is known correct */
+	GIT_DIFF_FLAG_VALID_ID  = (1u << 2), /** `id` value is known correct */
 } git_diff_flag_t;
 
 /**
@@ -250,7 +250,7 @@ typedef enum {
  * be restricted to one of the `git_filemode_t` values.
  */
 typedef struct {
-	git_oid     oid;
+	git_oid     id;
 	const char *path;
 	git_off_t   size;
 	uint32_t    flags;
diff --git a/src/checkout.c b/src/checkout.c
index efd55db65..f11ab8d46 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -92,10 +92,10 @@ static int checkout_notify(
 	if (wditem) {
 		memset(&wdfile, 0, sizeof(wdfile));
 
-		git_oid_cpy(&wdfile.oid, &wditem->id);
+		git_oid_cpy(&wdfile.id, &wditem->id);
 		wdfile.path = wditem->path;
 		wdfile.size = wditem->file_size;
-		wdfile.flags = GIT_DIFF_FLAG_VALID_OID;
+		wdfile.flags = GIT_DIFF_FLAG_VALID_ID;
 		wdfile.mode = wditem->mode;
 
 		workdir = &wdfile;
@@ -159,7 +159,7 @@ static bool checkout_is_workdir_modified(
 		if (!sm_oid)
 			return false;
 
-		return (git_oid__cmp(&baseitem->oid, sm_oid) != 0);
+		return (git_oid__cmp(&baseitem->id, sm_oid) != 0);
 	}
 
 	/* Look at the cache to decide if the workdir is modified.  If not,
@@ -170,7 +170,7 @@ static bool checkout_is_workdir_modified(
 		if (wditem->mtime.seconds == ie->mtime.seconds &&
 			wditem->mtime.nanoseconds == ie->mtime.nanoseconds &&
 			wditem->file_size == ie->file_size)
-			return (git_oid__cmp(&baseitem->oid, &ie->id) != 0);
+			return (git_oid__cmp(&baseitem->id, &ie->id) != 0);
 	}
 
 	/* depending on where base is coming from, we may or may not know
@@ -184,7 +184,7 @@ static bool checkout_is_workdir_modified(
 			wditem->file_size, &oid) < 0)
 		return false;
 
-	return (git_oid__cmp(&baseitem->oid, &oid) != 0);
+	return (git_oid__cmp(&baseitem->id, &oid) != 0);
 }
 
 #define CHECKOUT_ACTION_IF(FLAG,YES,NO) \
@@ -1221,7 +1221,7 @@ static int checkout_update_index(
 	memset(&entry, 0, sizeof(entry));
 	entry.path = (char *)file->path; /* cast to prevent warning */
 	git_index_entry__init_from_stat(&entry, st, true);
-	git_oid_cpy(&entry.id, &file->oid);
+	git_oid_cpy(&entry.id, &file->id);
 
 	return git_index_add(data->index, &entry);
 }
@@ -1378,7 +1378,7 @@ static int checkout_blob(
 	}
 
 	error = checkout_write_content(
-		data, &file->oid, git_buf_cstr(&data->path), NULL, file->mode, &st);
+		data, &file->id, git_buf_cstr(&data->path), NULL, file->mode, &st);
 
 	/* update the index unless prevented */
 	if (!error && (data->strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) == 0)
diff --git a/src/diff.c b/src/diff.c
index 75a90a0b2..151990ed6 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -110,18 +110,18 @@ static int diff_delta__from_one(
 	if (delta->status == GIT_DELTA_DELETED) {
 		delta->old_file.mode = entry->mode;
 		delta->old_file.size = entry->file_size;
-		git_oid_cpy(&delta->old_file.oid, &entry->id);
+		git_oid_cpy(&delta->old_file.id, &entry->id);
 	} else /* ADDED, IGNORED, UNTRACKED */ {
 		delta->new_file.mode = entry->mode;
 		delta->new_file.size = entry->file_size;
-		git_oid_cpy(&delta->new_file.oid, &entry->id);
+		git_oid_cpy(&delta->new_file.id, &entry->id);
 	}
 
-	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
 	if (delta->status == GIT_DELTA_DELETED ||
-		!git_oid_iszero(&delta->new_file.oid))
-		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+		!git_oid_iszero(&delta->new_file.id))
+		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
 	return diff_insert_delta(diff, delta, matched_pathspec);
 }
@@ -156,24 +156,24 @@ static int diff_delta__from_two(
 	GITERR_CHECK_ALLOC(delta);
 	delta->nfiles = 2;
 
-	git_oid_cpy(&delta->old_file.oid, &old_entry->id);
+	git_oid_cpy(&delta->old_file.id, &old_entry->id);
 	delta->old_file.size = old_entry->file_size;
 	delta->old_file.mode = old_mode;
-	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+	delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
-	git_oid_cpy(&delta->new_file.oid, &new_entry->id);
+	git_oid_cpy(&delta->new_file.id, &new_entry->id);
 	delta->new_file.size = new_entry->file_size;
 	delta->new_file.mode = new_mode;
 
 	if (new_oid) {
 		if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE))
-			git_oid_cpy(&delta->old_file.oid, new_oid);
+			git_oid_cpy(&delta->old_file.id, new_oid);
 		else
-			git_oid_cpy(&delta->new_file.oid, new_oid);
+			git_oid_cpy(&delta->new_file.id, new_oid);
 	}
 
 	if (new_oid || !git_oid_iszero(&new_entry->id))
-		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+		delta->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
 	return diff_insert_delta(diff, delta, matched_pathspec);
 }
@@ -189,21 +189,21 @@ static git_diff_delta *diff_delta__last_for_item(
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED:
 	case GIT_DELTA_DELETED:
-		if (git_oid__cmp(&delta->old_file.oid, &item->id) == 0)
+		if (git_oid__cmp(&delta->old_file.id, &item->id) == 0)
 			return delta;
 		break;
 	case GIT_DELTA_ADDED:
-		if (git_oid__cmp(&delta->new_file.oid, &item->id) == 0)
+		if (git_oid__cmp(&delta->new_file.id, &item->id) == 0)
 			return delta;
 		break;
 	case GIT_DELTA_UNTRACKED:
 		if (diff->strcomp(delta->new_file.path, item->path) == 0 &&
-			git_oid__cmp(&delta->new_file.oid, &item->id) == 0)
+			git_oid__cmp(&delta->new_file.id, &item->id) == 0)
 			return delta;
 		break;
 	case GIT_DELTA_MODIFIED:
-		if (git_oid__cmp(&delta->old_file.oid, &item->id) == 0 ||
-			git_oid__cmp(&delta->new_file.oid, &item->id) == 0)
+		if (git_oid__cmp(&delta->old_file.id, &item->id) == 0 ||
+			git_oid__cmp(&delta->new_file.id, &item->id) == 0)
 			return delta;
 		break;
 	default:
diff --git a/src/diff.h b/src/diff.h
index 2c9298a5f..c588f6301 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -134,7 +134,7 @@ GIT_INLINE(int) git_diff_file__resolve_zero_size(
 		return error;
 
 	error = git_odb__read_header_or_object(
-		odb_obj, &len, &type, odb, &file->oid);
+		odb_obj, &len, &type, odb, &file->id);
 
 	git_odb_free(odb);
 
diff --git a/src/diff_file.c b/src/diff_file.c
index a4c8641bc..fb5d674f7 100644
--- a/src/diff_file.c
+++ b/src/diff_file.c
@@ -143,10 +143,10 @@ int git_diff_file_content__init_from_blob(
 		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
 	} else {
 		fc->flags |= GIT_DIFF_FLAG__LOADED;
-		fc->file->flags |= GIT_DIFF_FLAG_VALID_OID;
+		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 		fc->file->size = git_blob_rawsize(blob);
 		fc->file->mode = GIT_FILEMODE_BLOB;
-		git_oid_cpy(&fc->file->oid, git_blob_id(blob));
+		git_oid_cpy(&fc->file->id, git_blob_id(blob));
 
 		fc->map.len  = (size_t)fc->file->size;
 		fc->map.data = (char *)git_blob_rawcontent(blob);
@@ -171,10 +171,10 @@ int git_diff_file_content__init_from_raw(
 		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
 	} else {
 		fc->flags |= GIT_DIFF_FLAG__LOADED;
-		fc->file->flags |= GIT_DIFF_FLAG_VALID_OID;
+		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 		fc->file->size = buflen;
 		fc->file->mode = GIT_FILEMODE_BLOB;
-		git_odb_hash(&fc->file->oid, buf, buflen, GIT_OBJ_BLOB);
+		git_odb_hash(&fc->file->id, buf, buflen, GIT_OBJ_BLOB);
 
 		fc->map.len  = buflen;
 		fc->map.data = (char *)buf;
@@ -205,19 +205,19 @@ static int diff_file_content_commit_to_str(
 		}
 
 		/* update OID if we didn't have it previously */
-		if ((fc->file->flags & GIT_DIFF_FLAG_VALID_OID) == 0 &&
+		if ((fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0 &&
 			((sm_head = git_submodule_wd_id(sm)) != NULL ||
 			 (sm_head = git_submodule_head_id(sm)) != NULL))
 		{
-			git_oid_cpy(&fc->file->oid, sm_head);
-			fc->file->flags |= GIT_DIFF_FLAG_VALID_OID;
+			git_oid_cpy(&fc->file->id, sm_head);
+			fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 		}
 
 		if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))
 			status = "-dirty";
 	}
 
-	git_oid_tostr(oid, sizeof(oid), &fc->file->oid);
+	git_oid_tostr(oid, sizeof(oid), &fc->file->id);
 	if (git_buf_printf(&content, "Subproject commit %s%s\n", oid, status) < 0)
 		return -1;
 
@@ -233,7 +233,7 @@ static int diff_file_content_load_blob(git_diff_file_content *fc)
 	int error = 0;
 	git_odb_object *odb_obj = NULL;
 
-	if (git_oid_iszero(&fc->file->oid))
+	if (git_oid_iszero(&fc->file->id))
 		return 0;
 
 	if (fc->file->mode == GIT_FILEMODE_COMMIT)
@@ -255,7 +255,7 @@ static int diff_file_content_load_blob(git_diff_file_content *fc)
 		git_odb_object_free(odb_obj);
 	} else {
 		error = git_blob_lookup(
-			(git_blob **)&fc->blob, fc->repo, &fc->file->oid);
+			(git_blob **)&fc->blob, fc->repo, &fc->file->id);
 	}
 
 	if (!error) {
@@ -368,10 +368,10 @@ static int diff_file_content_load_workdir(git_diff_file_content *fc)
 		error = diff_file_content_load_workdir_file(fc, &path);
 
 	/* once data is loaded, update OID if we didn't have it previously */
-	if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_OID) == 0) {
+	if (!error && (fc->file->flags & GIT_DIFF_FLAG_VALID_ID) == 0) {
 		error = git_odb_hash(
-			&fc->file->oid, fc->map.data, fc->map.len, GIT_OBJ_BLOB);
-		fc->file->flags |= GIT_DIFF_FLAG_VALID_OID;
+			&fc->file->id, fc->map.data, fc->map.len, GIT_OBJ_BLOB);
+		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
 	}
 
 	git_buf_free(&path);
diff --git a/src/diff_patch.c b/src/diff_patch.c
index 9c2eb885f..ecae3a8ed 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -133,9 +133,9 @@ static int diff_patch_load(git_patch *patch, git_diff_output *output)
 
 	incomplete_data =
 		(((patch->ofile.flags & GIT_DIFF_FLAG__NO_DATA) != 0 ||
-		  (patch->ofile.file->flags & GIT_DIFF_FLAG_VALID_OID) != 0) &&
+		  (patch->ofile.file->flags & GIT_DIFF_FLAG_VALID_ID) != 0) &&
 		 ((patch->nfile.flags & GIT_DIFF_FLAG__NO_DATA) != 0 ||
-		  (patch->nfile.file->flags & GIT_DIFF_FLAG_VALID_OID) != 0));
+		  (patch->nfile.file->flags & GIT_DIFF_FLAG_VALID_ID) != 0));
 
 	/* always try to load workdir content first because filtering may
 	 * need 2x data size and this minimizes peak memory footprint
@@ -169,7 +169,7 @@ static int diff_patch_load(git_patch *patch, git_diff_output *output)
 	if (incomplete_data &&
 		patch->ofile.file->mode == patch->nfile.file->mode &&
 		patch->ofile.file->mode != GIT_FILEMODE_COMMIT &&
-		git_oid_equal(&patch->ofile.file->oid, &patch->nfile.file->oid) &&
+		git_oid_equal(&patch->ofile.file->id, &patch->nfile.file->id) &&
 		patch->delta->status == GIT_DELTA_MODIFIED) /* not RENAMED/COPIED! */
 		patch->delta->status = GIT_DELTA_UNMODIFIED;
 
@@ -184,7 +184,7 @@ cleanup:
 			patch->delta->status != GIT_DELTA_UNMODIFIED &&
 			(patch->ofile.map.len || patch->nfile.map.len) &&
 			(patch->ofile.map.len != patch->nfile.map.len ||
-			 !git_oid_equal(&patch->ofile.file->oid, &patch->nfile.file->oid)))
+			 !git_oid_equal(&patch->ofile.file->id, &patch->nfile.file->id)))
 			patch->flags |= GIT_DIFF_PATCH_DIFFABLE;
 
 		patch->flags |= GIT_DIFF_PATCH_LOADED;
@@ -315,7 +315,7 @@ static int diff_single_generate(diff_patch_with_delta *pd, git_xdiff_output *xo)
 		(has_old ? GIT_DELTA_MODIFIED : GIT_DELTA_ADDED) :
 		(has_old ? GIT_DELTA_DELETED : GIT_DELTA_UNTRACKED);
 
-	if (git_oid_equal(&patch->nfile.file->oid, &patch->ofile.file->oid))
+	if (git_oid_equal(&patch->nfile.file->id, &patch->ofile.file->id))
 		pd->delta.status = GIT_DELTA_UNMODIFIED;
 
 	patch->delta = &pd->delta;
diff --git a/src/diff_print.c b/src/diff_print.c
index dd31d1ffa..5bacc5cc6 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -170,8 +170,8 @@ static int diff_print_one_raw(
 
 	git_buf_clear(out);
 
-	git_oid_tostr(start_oid, pi->oid_strlen, &delta->old_file.oid);
-	git_oid_tostr(end_oid, pi->oid_strlen, &delta->new_file.oid);
+	git_oid_tostr(start_oid, pi->oid_strlen, &delta->old_file.id);
+	git_oid_tostr(end_oid, pi->oid_strlen, &delta->new_file.id);
 
 	git_buf_printf(
 		out, ":%06o %06o %s... %s... %c",
@@ -203,8 +203,8 @@ static int diff_print_oid_range(
 {
 	char start_oid[GIT_OID_HEXSZ+1], end_oid[GIT_OID_HEXSZ+1];
 
-	git_oid_tostr(start_oid, oid_strlen, &delta->old_file.oid);
-	git_oid_tostr(end_oid, oid_strlen, &delta->new_file.oid);
+	git_oid_tostr(start_oid, oid_strlen, &delta->old_file.id);
+	git_oid_tostr(end_oid, oid_strlen, &delta->new_file.id);
 
 	/* TODO: Match git diff more closely */
 	if (delta->old_file.mode == delta->new_file.mode) {
@@ -235,11 +235,11 @@ static int diff_delta_format_with_paths(
 	const char *oldpath = delta->old_file.path;
 	const char *newpath = delta->new_file.path;
 
-	if (git_oid_iszero(&delta->old_file.oid)) {
+	if (git_oid_iszero(&delta->old_file.id)) {
 		oldpfx = "";
 		oldpath = "/dev/null";
 	}
-	if (git_oid_iszero(&delta->new_file.oid)) {
+	if (git_oid_iszero(&delta->new_file.id)) {
 		newpfx = "";
 		newpath = "/dev/null";
 	}
diff --git a/src/diff_tform.c b/src/diff_tform.c
index fc1b1d586..dfb59a3f8 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -91,7 +91,7 @@ static git_diff_delta *diff_delta__merge_like_cgit(
 		dup->status = a->status;
 	}
 
-	git_oid_cpy(&dup->old_file.oid, &a->old_file.oid);
+	git_oid_cpy(&dup->old_file.id, &a->old_file.id);
 	dup->old_file.mode  = a->old_file.mode;
 	dup->old_file.size  = a->old_file.size;
 	dup->old_file.flags = a->old_file.flags;
@@ -124,7 +124,7 @@ static git_diff_delta *diff_delta__merge_like_cgit_reversed(
 		dup->status = b->status;
 	}
 
-	git_oid_cpy(&dup->old_file.oid, &b->old_file.oid);
+	git_oid_cpy(&dup->old_file.id, &b->old_file.id);
 	dup->old_file.mode  = b->old_file.mode;
 	dup->old_file.size  = b->old_file.size;
 	dup->old_file.flags = b->old_file.flags;
@@ -375,7 +375,7 @@ static int insert_delete_side_of_split(
 	deleted->nfiles = 1;
 	memset(&deleted->new_file, 0, sizeof(deleted->new_file));
 	deleted->new_file.path = deleted->old_file.path;
-	deleted->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+	deleted->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
 	return git_vector_insert(onto, deleted);
 }
@@ -408,7 +408,7 @@ static int apply_splits_and_deletes(
 			delta->nfiles = 1;
 			memset(&delta->old_file, 0, sizeof(delta->old_file));
 			delta->old_file.path = delta->new_file.path;
-			delta->old_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+			delta->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 		}
 
 		/* clean up delta before inserting into new list */
@@ -510,7 +510,7 @@ static int similarity_sig(
 				(git_object **)&info->blob, info->repo,
 				info->odb_obj, GIT_OBJ_BLOB);
 		else
-			error = git_blob_lookup(&info->blob, info->repo, &file->oid);
+			error = git_blob_lookup(&info->blob, info->repo, &file->id);
 
 		if (error < 0) {
 			/* if lookup fails, just skip this item in similarity calc */
@@ -572,21 +572,21 @@ static int similarity_measure(
 
 	/* if exact match is requested, force calculation of missing OIDs now */
 	if (exact_match) {
-		if (git_oid_iszero(&a_file->oid) &&
+		if (git_oid_iszero(&a_file->id) &&
 			diff->old_src == GIT_ITERATOR_TYPE_WORKDIR &&
 			!git_diff__oid_for_file(diff->repo, a_file->path,
-				a_file->mode, a_file->size, &a_file->oid))
-			a_file->flags |= GIT_DIFF_FLAG_VALID_OID;
+				a_file->mode, a_file->size, &a_file->id))
+			a_file->flags |= GIT_DIFF_FLAG_VALID_ID;
 
-		if (git_oid_iszero(&b_file->oid) &&
+		if (git_oid_iszero(&b_file->id) &&
 			diff->new_src == GIT_ITERATOR_TYPE_WORKDIR &&
 			!git_diff__oid_for_file(diff->repo, b_file->path,
-				b_file->mode, b_file->size, &b_file->oid))
-			b_file->flags |= GIT_DIFF_FLAG_VALID_OID;
+				b_file->mode, b_file->size, &b_file->id))
+			b_file->flags |= GIT_DIFF_FLAG_VALID_ID;
 	}
 
 	/* check OID match as a quick test */
-	if (git_oid__cmp(&a_file->oid, &b_file->oid) == 0) {
+	if (git_oid__cmp(&a_file->id, &b_file->id) == 0) {
 		*score = 100;
 		return 0;
 	}
@@ -999,7 +999,7 @@ find_best_matches:
 				memcpy(&src->old_file, &swap, sizeof(src->old_file));
 				memset(&src->new_file, 0, sizeof(src->new_file));
 				src->new_file.path = src->old_file.path;
-				src->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+				src->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
 				num_updates++;
 
@@ -1024,7 +1024,7 @@ find_best_matches:
 				src->nfiles = 1;
 				memset(&src->old_file, 0, sizeof(src->old_file));
 				src->old_file.path = src->new_file.path;
-				src->old_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+				src->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
 				src->flags &= ~GIT_DIFF_FLAG__TO_SPLIT;
 				num_rewrites--;
diff --git a/src/merge.c b/src/merge.c
index 23a1574f7..ee000d522 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -665,7 +665,7 @@ static int index_entry_similarity_calc(
 	if ((error = git_blob_lookup(&blob, repo, &entry->id)) < 0)
 		return error;
 
-	git_oid_cpy(&diff_file.oid, &entry->id);
+	git_oid_cpy(&diff_file.id, &entry->id);
 	diff_file.path = entry->path;
 	diff_file.size = entry->file_size;
 	diff_file.mode = entry->mode;
diff --git a/src/merge_file.c b/src/merge_file.c
index 0878866bc..986fbf9fe 100644
--- a/src/merge_file.c
+++ b/src/merge_file.c
@@ -108,7 +108,7 @@ int git_merge_file_input_from_diff_file(
 		return 0;
 
 	if ((error = git_repository_odb(&odb, repo)) < 0 ||
-		(error = git_odb_read(&input->odb_object, odb, &file->oid)) < 0)
+		(error = git_odb_read(&input->odb_object, odb, &file->id)) < 0)
 		goto done;
 
 	input->mode = file->mode;
diff --git a/src/reset.c b/src/reset.c
index b9c783be3..15f7fe13a 100644
--- a/src/reset.c
+++ b/src/reset.c
@@ -72,7 +72,7 @@ int git_reset_default(
 				goto cleanup;
 		} else {
 			entry.mode = delta->new_file.mode;
-			git_oid_cpy(&entry.id, &delta->new_file.oid);
+			git_oid_cpy(&entry.id, &delta->new_file.id);
 			entry.path = (char *)delta->new_file.path;
 
 			if ((error = git_index_add(index, &entry)) < 0)
diff --git a/src/status.c b/src/status.c
index 7a1472d8d..3c95b347c 100644
--- a/src/status.c
+++ b/src/status.c
@@ -38,7 +38,7 @@ static unsigned int index_delta2status(const git_diff_delta *head2idx)
 	case GIT_DELTA_RENAMED:
 		st = GIT_STATUS_INDEX_RENAMED;
 
-		if (!git_oid_equal(&head2idx->old_file.oid, &head2idx->new_file.oid))
+		if (!git_oid_equal(&head2idx->old_file.id, &head2idx->new_file.id))
 			st |= GIT_STATUS_INDEX_MODIFIED;
 		break;
 	case GIT_DELTA_TYPECHANGE:
@@ -74,25 +74,25 @@ static unsigned int workdir_delta2status(
 	case GIT_DELTA_RENAMED:
 		st = GIT_STATUS_WT_RENAMED;
 
-		if (!git_oid_equal(&idx2wd->old_file.oid, &idx2wd->new_file.oid)) {
+		if (!git_oid_equal(&idx2wd->old_file.id, &idx2wd->new_file.id)) {
 			/* if OIDs don't match, we might need to calculate them now to
 			 * discern between RENAMED vs RENAMED+MODIFED
 			 */
-			if (git_oid_iszero(&idx2wd->old_file.oid) &&
+			if (git_oid_iszero(&idx2wd->old_file.id) &&
 				diff->old_src == GIT_ITERATOR_TYPE_WORKDIR &&
 				!git_diff__oid_for_file(
 					diff->repo, idx2wd->old_file.path, idx2wd->old_file.mode,
-					idx2wd->old_file.size, &idx2wd->old_file.oid))
-			idx2wd->old_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+					idx2wd->old_file.size, &idx2wd->old_file.id))
+			idx2wd->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
-			if (git_oid_iszero(&idx2wd->new_file.oid) &&
+			if (git_oid_iszero(&idx2wd->new_file.id) &&
 				diff->new_src == GIT_ITERATOR_TYPE_WORKDIR &&
 				!git_diff__oid_for_file(
 					diff->repo, idx2wd->new_file.path, idx2wd->new_file.mode,
-					idx2wd->new_file.size, &idx2wd->new_file.oid))
-				idx2wd->new_file.flags |= GIT_DIFF_FLAG_VALID_OID;
+					idx2wd->new_file.size, &idx2wd->new_file.id))
+				idx2wd->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
-			if (!git_oid_equal(&idx2wd->old_file.oid, &idx2wd->new_file.oid))
+			if (!git_oid_equal(&idx2wd->old_file.id, &idx2wd->new_file.id))
 				st |= GIT_STATUS_WT_MODIFIED;
 		}
 		break;
diff --git a/tests/checkout/index.c b/tests/checkout/index.c
index 48d6d79f9..57ce4313b 100644
--- a/tests/checkout/index.c
+++ b/tests/checkout/index.c
@@ -307,8 +307,8 @@ static int test_checkout_notify_cb(
 
 	cl_assert_equal_i(GIT_CHECKOUT_NOTIFY_CONFLICT, why);
 	cl_assert_equal_s(expectations->file, path);
-	cl_assert_equal_i(0, git_oid_streq(&baseline->oid, expectations->sha));
-	cl_assert_equal_i(0, git_oid_streq(&target->oid, expectations->sha));
+	cl_assert_equal_i(0, git_oid_streq(&baseline->id, expectations->sha));
+	cl_assert_equal_i(0, git_oid_streq(&target->id, expectations->sha));
 
 	return 0;
 }
diff --git a/tests/diff/blob.c b/tests/diff/blob.c
index 63e3c5b7d..17f64c915 100644
--- a/tests/diff/blob.c
+++ b/tests/diff/blob.c
@@ -167,9 +167,9 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
 	delta = git_patch_get_delta(p);
 	cl_assert(delta != NULL);
 	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(a), delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(b), &delta->new_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(b), &delta->new_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(b), delta->new_file.size);
 
 	cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
@@ -190,9 +190,9 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
 	delta = git_patch_get_delta(p);
 	cl_assert(delta != NULL);
 	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(b), &delta->old_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(b), &delta->old_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(b), delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(c), &delta->new_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(c), &delta->new_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(c), delta->new_file.size);
 
 	cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
@@ -213,9 +213,9 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
 	delta = git_patch_get_delta(p);
 	cl_assert(delta != NULL);
 	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(a), delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(c), &delta->new_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(c), &delta->new_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(c), delta->new_file.size);
 
 	cl_git_pass(git_patch_line_stats(&tc, &ta, &td, p));
@@ -233,9 +233,9 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
 	delta = git_patch_get_delta(p);
 	cl_assert(delta != NULL);
 	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(c), &delta->old_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(c), &delta->old_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(c), delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(d), delta->new_file.size);
 
 	cl_assert_equal_i(2, (int)git_patch_num_hunks(p));
@@ -328,9 +328,9 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
 	delta = git_patch_get_delta(p);
 	cl_assert(delta != NULL);
 	cl_assert_equal_i(GIT_DELTA_DELETED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(d), &delta->old_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(d), &delta->old_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(d), delta->old_file.size);
-	cl_assert(git_oid_iszero(&delta->new_file.oid));
+	cl_assert(git_oid_iszero(&delta->new_file.id));
 	cl_assert_equal_sz(0, delta->new_file.size);
 
 	cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
@@ -353,9 +353,9 @@ void test_diff_blob__can_compare_against_null_blobs_with_patch(void)
 	delta = git_patch_get_delta(p);
 	cl_assert(delta != NULL);
 	cl_assert_equal_i(GIT_DELTA_ADDED, delta->status);
-	cl_assert(git_oid_iszero(&delta->old_file.oid));
+	cl_assert(git_oid_iszero(&delta->old_file.id));
 	cl_assert_equal_sz(0, delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.id));
 	cl_assert_equal_sz(git_blob_rawsize(d), delta->new_file.size);
 
 	cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
@@ -446,9 +446,9 @@ void test_diff_blob__can_compare_identical_blobs_with_patch(void)
 	cl_assert(delta != NULL);
 	cl_assert_equal_i(GIT_DELTA_UNMODIFIED, delta->status);
 	cl_assert_equal_sz(delta->old_file.size, git_blob_rawsize(d));
-	cl_assert(git_oid_equal(git_blob_id(d), &delta->old_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(d), &delta->old_file.id));
 	cl_assert_equal_sz(delta->new_file.size, git_blob_rawsize(d));
-	cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.oid));
+	cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.id));
 
 	cl_assert_equal_i(0, (int)git_patch_num_hunks(p));
 	git_patch_free(p);
@@ -460,9 +460,9 @@ void test_diff_blob__can_compare_identical_blobs_with_patch(void)
 	cl_assert(delta != NULL);
 	cl_assert_equal_i(GIT_DELTA_UNMODIFIED, delta->status);
 	cl_assert_equal_sz(0, delta->old_file.size);
-	cl_assert(git_oid_iszero(&delta->old_file.oid));
+	cl_assert(git_oid_iszero(&delta->old_file.id));
 	cl_assert_equal_sz(0, delta->new_file.size);
-	cl_assert(git_oid_iszero(&delta->new_file.oid));
+	cl_assert(git_oid_iszero(&delta->new_file.id));
 
 	cl_assert_equal_i(0, (int)git_patch_num_hunks(p));
 	git_patch_free(p);
-- 
cgit v1.2.3


From 86bfc3e1c64c2c0277f1e795c0a15cba992ac6f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 24 Jan 2014 20:30:10 +0100
Subject: diff: change id abbrev option's name to id_abbrev

Same as the other commits in the series, we use 'id' when talking about
thing rather than the datatype.
---
 include/git2/diff.h | 2 +-
 src/diff_print.c    | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index d7c294309..a3cdd8193 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -361,7 +361,7 @@ typedef struct {
 
 	uint16_t    context_lines;    /**< defaults to 3 */
 	uint16_t    interhunk_lines;  /**< defaults to 0 */
-	uint16_t    oid_abbrev;       /**< default 'core.abbrev' or 7 if unset */
+	uint16_t    id_abbrev;       /**< default 'core.abbrev' or 7 if unset */
 	git_off_t   max_size;         /**< defaults to 512MB */
 	const char *old_prefix;       /**< defaults to "a" */
 	const char *new_prefix;       /**< defaults to "b" */
diff --git a/src/diff_print.c b/src/diff_print.c
index 5bacc5cc6..1a09bed54 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -37,8 +37,8 @@ static int diff_print_info_init(
 	if (diff)
 		pi->flags = diff->opts.flags;
 
-	if (diff && diff->opts.oid_abbrev != 0)
-		pi->oid_strlen = diff->opts.oid_abbrev;
+	if (diff && diff->opts.id_abbrev != 0)
+		pi->oid_strlen = diff->opts.id_abbrev;
 	else if (!diff || !diff->repo)
 		pi->oid_strlen = GIT_ABBREV_DEFAULT;
 	else if (git_repository__cvar(
-- 
cgit v1.2.3


From a1bbc0ce205b6d3496338d3253c847aa91cabc7b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 25 Jan 2014 04:14:37 +0100
Subject: merge: rename _oid() -> id()

Following the rest of the series, use 'id' when refering to the value.
---
 include/git2/merge.h              |  8 ++--
 src/merge.c                       |  6 +--
 tests/merge/workdir/fastforward.c | 10 ++---
 tests/merge/workdir/setup.c       | 78 +++++++++++++++++++--------------------
 tests/merge/workdir/simple.c      | 10 ++---
 5 files changed, 56 insertions(+), 56 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index ad9b5e2ea..3ef27e3c7 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -160,13 +160,13 @@ GIT_EXTERN(int) git_merge_head_from_fetchhead(
  *
  * @param out pointer to store the git_merge_head result in
  * @param repo repository that contains the given commit
- * @param oid the commit object id to use as a merge input
+ * @param id the commit object id to use as a merge input
  * @return zero on success, -1 on failure.
  */
-GIT_EXTERN(int) git_merge_head_from_oid(
+GIT_EXTERN(int) git_merge_head_from_id(
 	git_merge_head **out,
 	git_repository *repo,
-	const git_oid *oid);
+	const git_oid *id);
 
 /**
  * Frees a `git_merge_head`
@@ -251,7 +251,7 @@ GIT_EXTERN(int) git_merge_result_is_fastforward(git_merge_result *merge_result);
  * @param out the OID of the fast-forward
  * @param merge_result the results of the merge
  */
-GIT_EXTERN(int) git_merge_result_fastforward_oid(git_oid *out, git_merge_result *merge_result);
+GIT_EXTERN(int) git_merge_result_fastforward_id(git_oid *out, git_merge_result *merge_result);
 
 GIT_EXTERN(void) git_merge_result_free(git_merge_result *merge_result);
 
diff --git a/src/merge.c b/src/merge.c
index ee000d522..f4224955a 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2111,7 +2111,7 @@ static int merge_ancestor_head(
 	if ((error = git_merge_base_many(&ancestor_oid, repo, their_heads_len + 1, oids)) < 0)
 		goto on_error;
 
-	error = git_merge_head_from_oid(ancestor_head, repo, &ancestor_oid);
+	error = git_merge_head_from_id(ancestor_head, repo, &ancestor_oid);
 
 on_error:
 	git__free(oids);
@@ -2615,7 +2615,7 @@ int git_merge_result_is_fastforward(git_merge_result *merge_result)
 	return merge_result->is_fastforward;
 }
 
-int git_merge_result_fastforward_oid(git_oid *out, git_merge_result *merge_result)
+int git_merge_result_fastforward_id(git_oid *out, git_merge_result *merge_result)
 {
 	assert(out && merge_result);
 
@@ -2699,7 +2699,7 @@ int git_merge_head_from_ref(
 	return error;
 }
 
-int git_merge_head_from_oid(
+int git_merge_head_from_id(
 	git_merge_head **out,
 	git_repository *repo,
 	const git_oid *oid)
diff --git a/tests/merge/workdir/fastforward.c b/tests/merge/workdir/fastforward.c
index 861f38354..d6b31481f 100644
--- a/tests/merge/workdir/fastforward.c
+++ b/tests/merge/workdir/fastforward.c
@@ -13,10 +13,10 @@ static git_index *repo_index;
 #define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
 
 #define THEIRS_FASTFORWARD_BRANCH	"ff_branch"
-#define THEIRS_FASTFORWARD_OID		"fd89f8cffb663ac89095a0f9764902e93ceaca6a"
+#define THEIRS_FASTFORWARD_ID		"fd89f8cffb663ac89095a0f9764902e93ceaca6a"
 
 #define THEIRS_NOFASTFORWARD_BRANCH	"branch"
-#define THEIRS_NOFASTFORWARD_OID	"7cb63eed597130ba4abb87b3e544b85021905520"
+#define THEIRS_NOFASTFORWARD_ID	"7cb63eed597130ba4abb87b3e544b85021905520"
 
 
 // Fixture setup and teardown
@@ -57,11 +57,11 @@ void test_merge_workdir_fastforward__fastforward(void)
 	git_merge_result *result;
 	git_oid expected, ff_oid;
 
-	cl_git_pass(git_oid_fromstr(&expected, THEIRS_FASTFORWARD_OID));
+	cl_git_pass(git_oid_fromstr(&expected, THEIRS_FASTFORWARD_ID));
 
 	cl_assert(result = merge_fastforward_branch(0));
 	cl_assert(git_merge_result_is_fastforward(result));
-	cl_git_pass(git_merge_result_fastforward_oid(&ff_oid, result));
+	cl_git_pass(git_merge_result_fastforward_id(&ff_oid, result));
 	cl_assert(git_oid_cmp(&ff_oid, &expected) == 0);
 
 	git_merge_result_free(result);
@@ -136,7 +136,7 @@ void test_merge_workdir_fastforward__uptodate_merging_prev_commit(void)
 	git_merge_result *result;
 
 	cl_git_pass(git_oid_fromstr(&their_oid, "c607fc30883e335def28cd686b51f6cfa02b06ec"));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oid));
 
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, NULL));
 
diff --git a/tests/merge/workdir/setup.c b/tests/merge/workdir/setup.c
index 870d55ef2..05f994ecd 100644
--- a/tests/merge/workdir/setup.c
+++ b/tests/merge/workdir/setup.c
@@ -79,7 +79,7 @@ void test_merge_workdir_setup__one_branch(void)
 	git_merge_head *our_head, *their_heads[1];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -105,7 +105,7 @@ void test_merge_workdir_setup__no_fastforward(void)
 	git_merge_head *our_head, *their_heads[1];
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -131,10 +131,10 @@ void test_merge_workdir_setup__one_oid(void)
 	git_merge_head *our_head, *their_heads[1];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &octo1_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &octo1_oid));
 
 	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1, 0));
 
@@ -156,7 +156,7 @@ void test_merge_workdir_setup__two_branches(void)
 	git_merge_head *our_head, *their_heads[2];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -189,7 +189,7 @@ void test_merge_workdir_setup__three_branches(void)
 	git_merge_head *our_head, *their_heads[3];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -227,16 +227,16 @@ void test_merge_workdir_setup__three_oids(void)
 	git_merge_head *our_head, *their_heads[3];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &octo1_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &octo1_oid));
 	
 	cl_git_pass(git_oid_fromstr(&octo2_oid, OCTO2_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[1], repo, &octo2_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[1], repo, &octo2_oid));
 
 	cl_git_pass(git_oid_fromstr(&octo3_oid, OCTO3_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[2], repo, &octo3_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[2], repo, &octo3_oid));
 
 	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
 
@@ -260,13 +260,13 @@ void test_merge_workdir_setup__branches_and_oids_1(void)
 	git_merge_head *our_head, *their_heads[2];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
 
 	cl_git_pass(git_oid_fromstr(&octo2_oid, OCTO2_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[1], repo, &octo2_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[1], repo, &octo2_oid));
 
 	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2, 0));
 
@@ -293,19 +293,19 @@ void test_merge_workdir_setup__branches_and_oids_2(void)
 	git_merge_head *our_head, *their_heads[4];
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
 	
 	cl_git_pass(git_oid_fromstr(&octo2_oid, OCTO2_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[1], repo, &octo2_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[1], repo, &octo2_oid));
 
 	cl_git_pass(git_reference_lookup(&octo3_ref, repo, GIT_REFS_HEADS_DIR OCTO3_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[2], repo, octo3_ref));
 	
 	cl_git_pass(git_oid_fromstr(&octo4_oid, OCTO4_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[3], repo, &octo4_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[3], repo, &octo4_oid));
 	
 	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4, 0));
 
@@ -335,16 +335,16 @@ void test_merge_workdir_setup__branches_and_oids_3(void)
 	git_merge_head *our_head, *their_heads[4];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &octo1_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &octo1_oid));
 
 	cl_git_pass(git_reference_lookup(&octo2_ref, repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[1], repo, octo2_ref));
 
 	cl_git_pass(git_oid_fromstr(&octo3_oid, OCTO3_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[2], repo, &octo3_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[2], repo, &octo3_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo4_ref, repo, GIT_REFS_HEADS_DIR OCTO4_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[3], repo, octo4_ref));
@@ -378,16 +378,16 @@ void test_merge_workdir_setup__branches_and_oids_4(void)
 	git_merge_head *our_head, *their_heads[5];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &octo1_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &octo1_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo2_ref, repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[1], repo, octo2_ref));
 	
 	cl_git_pass(git_oid_fromstr(&octo3_oid, OCTO3_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[2], repo, &octo3_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[2], repo, &octo3_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo4_ref, repo, GIT_REFS_HEADS_DIR OCTO4_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[3], repo, octo4_ref));
@@ -424,7 +424,7 @@ void test_merge_workdir_setup__three_same_branches(void)
 	git_merge_head *our_head, *their_heads[3];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo1_1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_1_ref));
@@ -462,16 +462,16 @@ void test_merge_workdir_setup__three_same_oids(void)
 	git_merge_head *our_head, *their_heads[3];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_oid_fromstr(&octo1_1_oid, OCTO1_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &octo1_1_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &octo1_1_oid));
 	
 	cl_git_pass(git_oid_fromstr(&octo1_2_oid, OCTO1_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[1], repo, &octo1_2_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[1], repo, &octo1_2_oid));
 	
 	cl_git_pass(git_oid_fromstr(&octo1_3_oid, OCTO1_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[2], repo, &octo1_3_oid));
+	cl_git_pass(git_merge_head_from_id(&their_heads[2], repo, &octo1_3_oid));
 	
 	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
 	
@@ -539,7 +539,7 @@ void test_merge_workdir_setup__remote_tracking_one_branch(void)
 	cl_git_pass(create_remote_tracking_branch(OCTO1_BRANCH, OCTO1_OID));
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -569,7 +569,7 @@ void test_merge_workdir_setup__remote_tracking_two_branches(void)
 	cl_git_pass(create_remote_tracking_branch(OCTO2_BRANCH, OCTO2_OID));
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -606,7 +606,7 @@ void test_merge_workdir_setup__remote_tracking_three_branches(void)
 	cl_git_pass(create_remote_tracking_branch(OCTO3_BRANCH, OCTO3_OID));
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -645,7 +645,7 @@ void test_merge_workdir_setup__normal_branch_and_remote_tracking_branch(void)
 	cl_git_pass(create_remote_tracking_branch(OCTO2_BRANCH, OCTO2_OID));
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -679,7 +679,7 @@ void test_merge_workdir_setup__remote_tracking_branch_and_normal_branch(void)
 	cl_git_pass(create_remote_tracking_branch(OCTO1_BRANCH, OCTO1_OID));
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -716,7 +716,7 @@ void test_merge_workdir_setup__two_remote_tracking_branch_and_two_normal_branche
 	cl_git_pass(create_remote_tracking_branch(OCTO4_BRANCH, OCTO4_OID));
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 	
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
@@ -757,7 +757,7 @@ void test_merge_workdir_setup__pull_one(void)
 	git_merge_head *our_head, *their_heads[1];
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_oid_fromstr(&octo1_1_oid, OCTO1_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &octo1_1_oid));
@@ -782,7 +782,7 @@ void test_merge_workdir_setup__pull_two(void)
 	git_merge_head *our_head, *their_heads[2];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &octo1_oid));
@@ -812,7 +812,7 @@ void test_merge_workdir_setup__pull_three(void)
 	git_merge_head *our_head, *their_heads[3];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &octo1_oid));
@@ -845,7 +845,7 @@ void test_merge_workdir_setup__three_remotes(void)
 	git_merge_head *our_head, *their_heads[3];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.first/repo.git", &octo1_oid));
@@ -879,7 +879,7 @@ void test_merge_workdir_setup__two_remotes(void)
 	git_merge_head *our_head, *their_heads[4];
 	
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.first/repo.git", &octo1_oid));
@@ -1002,7 +1002,7 @@ void test_merge_workdir_setup__retained_after_success(void)
 	opts.merge_flags |= GIT_MERGE_NO_FASTFORWARD;
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 
@@ -1033,7 +1033,7 @@ void test_merge_workdir_setup__removed_after_failure(void)
 	opts.merge_flags |= GIT_MERGE_NO_FASTFORWARD;
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_oid(&our_head, repo, &our_oid));
+	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 266719e2a..4ff761cf8 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -134,7 +134,7 @@ static git_merge_result *merge_simple_branch(int merge_file_favor, int checkout_
 	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
 
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_SIMPLE_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oids[0]));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
 	opts.merge_tree_opts.file_favor = merge_file_favor;
 	opts.checkout_opts.checkout_strategy = checkout_strategy;
@@ -588,7 +588,7 @@ void test_merge_workdir_simple__directory_file(void)
 	cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD));
 
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_DIRECTORY_FILE));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oids[0]));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
 	opts.merge_tree_opts.file_favor = 0;
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
@@ -621,7 +621,7 @@ void test_merge_workdir_simple__unrelated(void)
 	};
 
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_UNRELATED_PARENT));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oids[0]));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
 	opts.merge_tree_opts.file_favor = 0;
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
@@ -654,7 +654,7 @@ void test_merge_workdir_simple__unrelated_with_conflicts(void)
 	};
 
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_UNRELATED_OID));
-	cl_git_pass(git_merge_head_from_oid(&their_heads[0], repo, &their_oids[0]));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
 	opts.merge_tree_opts.file_favor = 0;
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
@@ -686,7 +686,7 @@ void test_merge_workdir_simple__binary(void)
 	cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid));
 	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD));
 
-	cl_git_pass(git_merge_head_from_oid(&their_head, repo, &their_oid));
+	cl_git_pass(git_merge_head_from_id(&their_head, repo, &their_oid));
 
 	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, &opts));
 
-- 
cgit v1.2.3


From 1cb5a8119445bb62c6868eb61649b9b901c855cb Mon Sep 17 00:00:00 2001
From: XTao <xutao881001@gmail.com>
Date: Sun, 26 Jan 2014 17:07:39 +0800
Subject: Fix write_object.

---
 src/pack-objects.c | 8 +++++---
 src/zstream.c      | 3 +--
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/pack-objects.c b/src/pack-objects.c
index c4ed4dce3..1774b07dc 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -288,6 +288,7 @@ static int write_object(
 	git_odb_object *obj = NULL;
 	git_otype type;
 	unsigned char hdr[10], *zbuf = NULL;
+	void *delta_data = NULL;
 	void *data;
 	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
 	ssize_t written;
@@ -295,10 +296,11 @@ static int write_object(
 
 	if (po->delta) {
 		if (po->delta_data)
-			data = po->delta_data;
-		else if ((error = get_delta(&data, pb->odb, po)) < 0)
+			delta_data = po->delta_data;
+		else if ((error = get_delta(&delta_data, pb->odb, po)) < 0)
 				goto done;
 
+		data = delta_data;
 		data_len = po->delta_size;
 		type = GIT_OBJ_REF_DELTA;
 	} else {
@@ -351,7 +353,7 @@ static int write_object(
 		}
 
 		if (po->delta)
-			git__free(data);
+			git__free(delta_data);
 	}
 
 	if (po->delta_data) {
diff --git a/src/zstream.c b/src/zstream.c
index 7def0440b..0bca72ff3 100644
--- a/src/zstream.c
+++ b/src/zstream.c
@@ -70,7 +70,7 @@ int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len)
 	int error = 0;
 
 	if ((error = git_zstream_init(&zstream)) < 0)
-		goto done;
+		return error;
 
 	do {
 		if (out->asize - out->size < BUFFER_SIZE)
@@ -89,7 +89,6 @@ int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len)
 	if (written < 0)
 		error = written;
 
-done:
 	git_zstream_free(&zstream);
 	return error;
 }
-- 
cgit v1.2.3


From 11f6ad5fcf5f1251ef1b51d18409f84cb87cb8b7 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Wed, 15 Jan 2014 21:15:34 +0100
Subject: Add some missing const declarations.

---
 include/git2/remote.h | 12 ++++++------
 src/remote.c          | 14 +++++++-------
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index d3e6caa48..c3fd932c9 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -194,7 +194,7 @@ GIT_EXTERN(int) git_remote_add_fetch(git_remote *remote, const char *refspec);
  * @param array pointer to the array in which to store the strings
  * @param remote the remote to query
  */
-GIT_EXTERN(int) git_remote_get_fetch_refspecs(git_strarray *array, git_remote *remote);
+GIT_EXTERN(int) git_remote_get_fetch_refspecs(git_strarray *array, const git_remote *remote);
 
 /**
  * Set the remote's list of fetch refspecs
@@ -227,7 +227,7 @@ GIT_EXTERN(int) git_remote_add_push(git_remote *remote, const char *refspec);
  * @param array pointer to the array in which to store the strings
  * @param remote the remote to query
  */
-GIT_EXTERN(int) git_remote_get_push_refspecs(git_strarray *array, git_remote *remote);
+GIT_EXTERN(int) git_remote_get_push_refspecs(git_strarray *array, const git_remote *remote);
 
 /**
  * Set the remote's list of push refspecs
@@ -254,7 +254,7 @@ GIT_EXTERN(void) git_remote_clear_refspecs(git_remote *remote);
  * @param remote the remote
  * @return the amount of refspecs configured in this remote
  */
-GIT_EXTERN(size_t) git_remote_refspec_count(git_remote *remote);
+GIT_EXTERN(size_t) git_remote_refspec_count(const git_remote *remote);
 
 /**
  * Get a refspec from the remote
@@ -263,7 +263,7 @@ GIT_EXTERN(size_t) git_remote_refspec_count(git_remote *remote);
  * @param n the refspec to get
  * @return the nth refspec
  */
-GIT_EXTERN(const git_refspec *)git_remote_get_refspec(git_remote *remote, size_t n);
+GIT_EXTERN(const git_refspec *)git_remote_get_refspec(const git_remote *remote, size_t n);
 
 /**
  * Open a connection to a remote
@@ -319,7 +319,7 @@ GIT_EXTERN(int) git_remote_download(git_remote *remote);
  * @param remote the remote
  * @return 1 if it's connected, 0 otherwise.
  */
-GIT_EXTERN(int) git_remote_connected(git_remote *remote);
+GIT_EXTERN(int) git_remote_connected(const git_remote *remote);
 
 /**
  * Cancel the operation
@@ -510,7 +510,7 @@ typedef enum {
  * @param remote the remote to query
  * @return the auto-follow setting
  */
-GIT_EXTERN(git_remote_autotag_option_t) git_remote_autotag(git_remote *remote);
+GIT_EXTERN(git_remote_autotag_option_t) git_remote_autotag(const git_remote *remote);
 
 /**
  * Set the tag auto-follow setting
diff --git a/src/remote.c b/src/remote.c
index 306cb0b9a..29bffeeba 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1089,7 +1089,7 @@ out:
 	return error;
 }
 
-int git_remote_connected(git_remote *remote)
+int git_remote_connected(const git_remote *remote)
 {
 	assert(remote);
 
@@ -1233,7 +1233,7 @@ const git_transfer_progress* git_remote_stats(git_remote *remote)
 	return &remote->stats;
 }
 
-git_remote_autotag_option_t git_remote_autotag(git_remote *remote)
+git_remote_autotag_option_t git_remote_autotag(const git_remote *remote)
 {
 	return remote->download_tags;
 }
@@ -1626,7 +1626,7 @@ int git_remote_set_push_refspecs(git_remote *remote, git_strarray *array)
 	return set_refspecs(remote, array, true);
 }
 
-static int copy_refspecs(git_strarray *array, git_remote *remote, unsigned int push)
+static int copy_refspecs(git_strarray *array, const git_remote *remote, unsigned int push)
 {
 	size_t i;
 	git_vector refspecs;
@@ -1660,22 +1660,22 @@ on_error:
 	return -1;
 }
 
-int git_remote_get_fetch_refspecs(git_strarray *array, git_remote *remote)
+int git_remote_get_fetch_refspecs(git_strarray *array, const git_remote *remote)
 {
 	return copy_refspecs(array, remote, false);
 }
 
-int git_remote_get_push_refspecs(git_strarray *array, git_remote *remote)
+int git_remote_get_push_refspecs(git_strarray *array, const git_remote *remote)
 {
 	return copy_refspecs(array, remote, true);
 }
 
-size_t git_remote_refspec_count(git_remote *remote)
+size_t git_remote_refspec_count(const git_remote *remote)
 {
 	return remote->refspecs.length;
 }
 
-const git_refspec *git_remote_get_refspec(git_remote *remote, size_t n)
+const git_refspec *git_remote_get_refspec(const git_remote *remote, size_t n)
 {
 	return git_vector_get(&remote->refspecs, n);
 }
-- 
cgit v1.2.3


From 991b2840eb6389048bccdb40b51889e32e8f1460 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Sun, 26 Jan 2014 19:35:02 +0100
Subject: Make sure git_remote_dup copies a remote's refspecs correctly.

---
 include/git2/remote.h          |  2 +-
 src/remote.c                   | 34 ++++++++++++++++++++++++++--------
 tests/network/remote/remotes.c |  2 ++
 3 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index c3fd932c9..eba6ca7f9 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -117,7 +117,7 @@ GIT_EXTERN(int) git_remote_save(const git_remote *remote);
  * @param source object to copy
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_remote_dup(git_remote **dest, const git_remote *source);
+GIT_EXTERN(int) git_remote_dup(git_remote **dest, git_remote *source);
 
 /**
  * Get the remote's repository
diff --git a/src/remote.c b/src/remote.c
index 29bffeeba..5b3656a81 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -248,9 +248,10 @@ int git_remote_create_inmemory(git_remote **out, git_repository *repo, const cha
 	return 0;
 }
 
-int git_remote_dup(git_remote **dest, const git_remote *source)
+int git_remote_dup(git_remote **dest, git_remote *source)
 {
-	int error;
+	int error = 0;
+	git_strarray refspecs = { 0 };
 	git_remote *remote = git__calloc(1, sizeof(git_remote));
 	GITERR_CHECK_ALLOC(remote);
 
@@ -274,16 +275,33 @@ int git_remote_dup(git_remote **dest, const git_remote *source)
 	remote->check_cert = source->check_cert;
 	remote->update_fetchhead = source->update_fetchhead;
 
-	if ((error = git_vector_dup(&remote->refs, &source->refs, NULL)) < 0 ||
-		(error = git_vector_dup(&remote->refspecs, &source->refspecs, NULL)) < 0 ||
-		(error = git_vector_dup(&remote->active_refspecs, &source->active_refspecs, NULL))) {
-		git__free(remote);
-		return error;
+	if (git_vector_init(&remote->refs, 32, NULL) < 0 ||
+	    git_vector_init(&remote->refspecs, 2, NULL) < 0 ||
+	    git_vector_init(&remote->active_refspecs, 2, NULL) < 0) {
+		error = -1;
+		goto cleanup;
 	}
 
+	if ((error = git_remote_get_fetch_refspecs(&refspecs, source)) < 0 ||
+	    (error = git_remote_set_fetch_refspecs(remote, &refspecs)) < 0)
+		goto cleanup;
+
+	git_strarray_free(&refspecs);
+
+	if ((error = git_remote_get_push_refspecs(&refspecs, source)) < 0 ||
+	    (error = git_remote_set_push_refspecs(remote, &refspecs)) < 0)
+		goto cleanup;
+
 	*dest = remote;
 
-	return 0;
+cleanup:
+
+	git_strarray_free(&refspecs);
+
+	if (error < 0)
+		git__free(remote);
+
+	return error;
 }
 
 struct refspec_cb_data {
diff --git a/tests/network/remote/remotes.c b/tests/network/remote/remotes.c
index 235a1022d..44a98d31a 100644
--- a/tests/network/remote/remotes.c
+++ b/tests/network/remote/remotes.c
@@ -148,6 +148,8 @@ void test_network_remote_remotes__dup(void)
 	cl_git_pass(git_remote_get_push_refspecs(&array, _remote));
 	cl_assert_equal_i(0, (int)array.count);
 	git_strarray_free(&array);
+
+	git_remote_free(dup);
 }
 
 void test_network_remote_remotes__add_pushspec(void)
-- 
cgit v1.2.3


From 7a3bd1e73215f8939f270092e0673d6c0f3f32af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 26 Jan 2014 15:35:17 +0100
Subject: repository: move to use a git_buf for outputting strings

Since we now export that type, we can avoid making the user guess a
size.
---
 include/git2/repository.h | 26 ++++++-------------
 src/repository.c          | 41 +++++++-----------------------
 tests/repo/discover.c     | 63 ++++++++++++++++++++++++-----------------------
 tests/repo/message.c      | 25 ++++++-------------
 4 files changed, 55 insertions(+), 100 deletions(-)

diff --git a/include/git2/repository.h b/include/git2/repository.h
index 9f71d2959..a0453da5c 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -10,6 +10,7 @@
 #include "common.h"
 #include "types.h"
 #include "oid.h"
+#include "buffer.h"
 
 /**
  * @file git2/repository.h
@@ -58,10 +59,8 @@ GIT_EXTERN(int) git_repository_wrap_odb(git_repository **out, git_odb *odb);
  * The method will automatically detect if the repository is bare
  * (if there is a repository).
  *
- * @param path_out The user allocated buffer which will
- * contain the found path.
- *
- * @param path_size repository_path size
+ * @param out A pointer to a user-allocated git_buf which will contain
+ * the found path.
  *
  * @param start_path The base path where the lookup starts.
  *
@@ -77,8 +76,7 @@ GIT_EXTERN(int) git_repository_wrap_odb(git_repository **out, git_odb *odb);
  * @return 0 or an error code
  */
 GIT_EXTERN(int) git_repository_discover(
-		char *path_out,
-		size_t path_size,
+		git_buf *out,
 		const char *start_path,
 		int across_fs,
 		const char *ceiling_dirs);
@@ -464,21 +462,11 @@ GIT_EXTERN(int) git_repository_index(git_index **out, git_repository *repo);
  * Use this function to get the contents of this file. Don't forget to
  * remove the file after you create the commit.
  *
- * If the repository message exists and there are no errors reading it, this
- * returns the bytes needed to store the message in memory (i.e. message
- * file size plus one terminating NUL byte).  That value is returned even if
- * `out` is NULL or `len` is shorter than the necessary size.
- *
- * The `out` buffer will *always* be NUL terminated, even if truncation
- * occurs.
- *
- * @param out Buffer to write data into or NULL to just read required size
- * @param len Length of `out` buffer in bytes
+ * @param out git_buf to write data into
  * @param repo Repository to read prepared message from
- * @return GIT_ENOTFOUND if no message exists, other value < 0 for other
- *         errors, or total bytes in message (may be > `len`) on success
+ * @return 0, GIT_ENOTFOUND if no message exists or an error code
  */
-GIT_EXTERN(int) git_repository_message(char *out, size_t len, git_repository *repo);
+GIT_EXTERN(int) git_repository_message(git_buf *out, git_repository *repo);
 
 /**
  * Remove git's prepared message.
diff --git a/src/repository.c b/src/repository.c
index 8645357b8..db66e6bd5 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -495,34 +495,18 @@ int git_repository_wrap_odb(git_repository **repo_out, git_odb *odb)
 }
 
 int git_repository_discover(
-	char *repository_path,
-	size_t size,
+	git_buf *out,
 	const char *start_path,
 	int across_fs,
 	const char *ceiling_dirs)
 {
-	git_buf path = GIT_BUF_INIT;
 	uint32_t flags = across_fs ? GIT_REPOSITORY_OPEN_CROSS_FS : 0;
-	int error;
-
-	assert(start_path && repository_path && size > 0);
-
-	*repository_path = '\0';
 
-	if ((error = find_repo(&path, NULL, start_path, flags, ceiling_dirs)) < 0)
-		return error != GIT_ENOTFOUND ? -1 : error;
+	assert(start_path);
 
-	if (size < (size_t)(path.size + 1)) {
-		giterr_set(GITERR_REPOSITORY,
-			"The given buffer is too small to store the discovered path");
-		git_buf_free(&path);
-		return -1;
-	}
+	git_buf_sanitize(out);
 
-	/* success: we discovered a repository */
-	git_buf_copy_cstr(repository_path, size, &path);
-	git_buf_free(&path);
-	return 0;
+	return find_repo(out, NULL, start_path, flags, ceiling_dirs);
 }
 
 static int load_config(
@@ -1732,14 +1716,13 @@ cleanup:
 	return error;
 }
 
-int git_repository_message(char *buffer, size_t len, git_repository *repo)
+int git_repository_message(git_buf *out,  git_repository *repo)
 {
-	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
+	git_buf path = GIT_BUF_INIT;
 	struct stat st;
 	int error;
 
-	if (buffer != NULL)
-		*buffer = '\0';
+	git_buf_sanitize(out);
 
 	if (git_buf_joinpath(&path, repo->path_repository, GIT_MERGE_MSG_FILE) < 0)
 		return -1;
@@ -1749,16 +1732,10 @@ int git_repository_message(char *buffer, size_t len, git_repository *repo)
 			error = GIT_ENOTFOUND;
 		giterr_set(GITERR_OS, "Could not access message file");
 	}
-	else if (buffer != NULL) {
-		error = git_futils_readbuffer(&buf, git_buf_cstr(&path));
-		git_buf_copy_cstr(buffer, len, &buf);
-	}
 
-	git_buf_free(&path);
-	git_buf_free(&buf);
+	error = git_futils_readbuffer(out, git_buf_cstr(&path));
 
-	if (!error)
-		error = (int)st.st_size + 1; /* add 1 for NUL byte */
+	git_buf_free(&path);
 
 	return error;
 }
diff --git a/tests/repo/discover.c b/tests/repo/discover.c
index f93ff2462..7904b6496 100644
--- a/tests/repo/discover.c
+++ b/tests/repo/discover.c
@@ -25,12 +25,13 @@
 
 static void ensure_repository_discover(const char *start_path,
                                        const char *ceiling_dirs,
-                                       const char *expected_path)
+				       git_buf *expected_path)
 {
-	char found_path[GIT_PATH_MAX];
-	cl_git_pass(git_repository_discover(found_path, sizeof(found_path), start_path, 0, ceiling_dirs));
+	git_buf found_path = GIT_BUF_INIT;
+	cl_git_pass(git_repository_discover(&found_path, start_path, 0, ceiling_dirs));
 	//across_fs is always 0 as we can't automate the filesystem change tests
-	cl_assert_equal_s(found_path, expected_path);
+	cl_assert_equal_s(found_path.ptr, expected_path->ptr);
+	git_buf_free(&found_path);
 }
 
 static void write_file(const char *path, const char *content)
@@ -69,42 +70,40 @@ static void append_ceiling_dir(git_buf *ceiling_dirs, const char *path)
 
 void test_repo_discover__0(void)
 {
-   // test discover
+	// test discover
 	git_repository *repo;
-	git_buf ceiling_dirs_buf = GIT_BUF_INIT;
+	git_buf ceiling_dirs_buf = GIT_BUF_INIT, repository_path = GIT_BUF_INIT,
+		sub_repository_path = GIT_BUF_INIT, found_path = GIT_BUF_INIT;
 	const char *ceiling_dirs;
-	char repository_path[GIT_PATH_MAX];
-	char sub_repository_path[GIT_PATH_MAX];
-	char found_path[GIT_PATH_MAX];
 	const mode_t mode = 0777;
 
 	git_futils_mkdir_r(DISCOVER_FOLDER, NULL, mode);
 	append_ceiling_dir(&ceiling_dirs_buf, TEMP_REPO_FOLDER);
 	ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);
 
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(&repository_path, DISCOVER_FOLDER, 0, ceiling_dirs));
 
 	cl_git_pass(git_repository_init(&repo, DISCOVER_FOLDER, 1));
-	cl_git_pass(git_repository_discover(repository_path, sizeof(repository_path), DISCOVER_FOLDER, 0, ceiling_dirs));
+	cl_git_pass(git_repository_discover(&repository_path, DISCOVER_FOLDER, 0, ceiling_dirs));
 	git_repository_free(repo);
 
 	cl_git_pass(git_repository_init(&repo, SUB_REPOSITORY_FOLDER, 0));
 	cl_git_pass(git_futils_mkdir_r(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, NULL, mode));
-	cl_git_pass(git_repository_discover(sub_repository_path, sizeof(sub_repository_path), SUB_REPOSITORY_FOLDER, 0, ceiling_dirs));
+	cl_git_pass(git_repository_discover(&sub_repository_path, SUB_REPOSITORY_FOLDER, 0, ceiling_dirs));
 
 	cl_git_pass(git_futils_mkdir_r(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, NULL, mode));
-	ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB, ceiling_dirs, sub_repository_path);
-	ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path);
-	ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, ceiling_dirs, sub_repository_path);
+	ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB, ceiling_dirs, &sub_repository_path);
+	ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB_SUB, ceiling_dirs, &sub_repository_path);
+	ensure_repository_discover(SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, ceiling_dirs, &sub_repository_path);
 
 	cl_git_pass(git_futils_mkdir_r(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, NULL, mode));
 	write_file(REPOSITORY_ALTERNATE_FOLDER "/" DOT_GIT, "gitdir: ../" SUB_REPOSITORY_FOLDER_NAME "/" DOT_GIT);
 	write_file(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB "/" DOT_GIT, "gitdir: ../../../" SUB_REPOSITORY_FOLDER_NAME "/" DOT_GIT);
 	write_file(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB "/" DOT_GIT, "gitdir: ../../../../");
-	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, sub_repository_path);
-	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB, ceiling_dirs, sub_repository_path);
-	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path);
-	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, ceiling_dirs, repository_path);
+	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, &sub_repository_path);
+	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB, ceiling_dirs, &sub_repository_path);
+	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB, ceiling_dirs, &sub_repository_path);
+	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, ceiling_dirs, &repository_path);
 
 	cl_git_pass(git_futils_mkdir_r(ALTERNATE_MALFORMED_FOLDER1, NULL, mode));
 	write_file(ALTERNATE_MALFORMED_FOLDER1 "/" DOT_GIT, "Anything but not gitdir:");
@@ -114,29 +113,31 @@ void test_repo_discover__0(void)
 	write_file(ALTERNATE_MALFORMED_FOLDER3 "/" DOT_GIT, "gitdir: \n\n\n");
 	cl_git_pass(git_futils_mkdir_r(ALTERNATE_NOT_FOUND_FOLDER, NULL, mode));
 	write_file(ALTERNATE_NOT_FOUND_FOLDER "/" DOT_GIT, "gitdir: a_repository_that_surely_does_not_exist");
-	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER1, 0, ceiling_dirs));
-	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER2, 0, ceiling_dirs));
-	cl_git_fail(git_repository_discover(found_path, sizeof(found_path), ALTERNATE_MALFORMED_FOLDER3, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), ALTERNATE_NOT_FOUND_FOLDER, 0, ceiling_dirs));
+	cl_git_fail(git_repository_discover(&found_path, ALTERNATE_MALFORMED_FOLDER1, 0, ceiling_dirs));
+	cl_git_fail(git_repository_discover(&found_path, ALTERNATE_MALFORMED_FOLDER2, 0, ceiling_dirs));
+	cl_git_fail(git_repository_discover(&found_path, ALTERNATE_MALFORMED_FOLDER3, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(&found_path, ALTERNATE_NOT_FOUND_FOLDER, 0, ceiling_dirs));
 
 	append_ceiling_dir(&ceiling_dirs_buf, SUB_REPOSITORY_FOLDER);
 	ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);
 
 	//this must pass as ceiling_directories cannot predent the current
 	//working directory to be checked
-	cl_git_pass(git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB, 0, ceiling_dirs));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(found_path, sizeof(found_path), SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, 0, ceiling_dirs));
+	cl_git_pass(git_repository_discover(&found_path, SUB_REPOSITORY_FOLDER, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(&found_path, SUB_REPOSITORY_FOLDER_SUB, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(&found_path, SUB_REPOSITORY_FOLDER_SUB_SUB, 0, ceiling_dirs));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_discover(&found_path, SUB_REPOSITORY_FOLDER_SUB_SUB_SUB, 0, ceiling_dirs));
 
 	//.gitfile redirection should not be affected by ceiling directories
-	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, sub_repository_path);
-	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB, ceiling_dirs, sub_repository_path);
-	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB, ceiling_dirs, sub_repository_path);
-	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, ceiling_dirs, repository_path);
+	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER, ceiling_dirs, &sub_repository_path);
+	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB, ceiling_dirs, &sub_repository_path);
+	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB, ceiling_dirs, &sub_repository_path);
+	ensure_repository_discover(REPOSITORY_ALTERNATE_FOLDER_SUB_SUB_SUB, ceiling_dirs, &repository_path);
 
 	cl_git_pass(git_futils_rmdir_r(TEMP_REPO_FOLDER, NULL, GIT_RMDIR_REMOVE_FILES));
 	git_repository_free(repo);
 	git_buf_free(&ceiling_dirs_buf);
+	git_buf_free(&repository_path);
+	git_buf_free(&sub_repository_path);
 }
 
diff --git a/tests/repo/message.c b/tests/repo/message.c
index 629d40c12..57e8e5f4d 100644
--- a/tests/repo/message.c
+++ b/tests/repo/message.c
@@ -5,48 +5,37 @@
 
 static git_repository *_repo;
 static git_buf _path;
-static char *_actual;
+static git_buf _actual;
 
 void test_repo_message__initialize(void)
 {
         _repo = cl_git_sandbox_init("testrepo.git");
+	git_buf_init(&_actual, 0);
 }
 
 void test_repo_message__cleanup(void)
 {
         cl_git_sandbox_cleanup();
 	git_buf_free(&_path);
-	git__free(_actual);
-	_actual = NULL;
+	git_buf_free(&_actual);
 }
 
 void test_repo_message__none(void)
 {
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(NULL, 0, _repo));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(&_actual, _repo));
 }
 
 void test_repo_message__message(void)
 {
 	const char expected[] = "Test\n\nThis is a test of the emergency broadcast system\n";
-	ssize_t len;
 
 	cl_git_pass(git_buf_joinpath(&_path, git_repository_path(_repo), "MERGE_MSG"));
 	cl_git_mkfile(git_buf_cstr(&_path), expected);
 
-	len = git_repository_message(NULL, 0, _repo);
-	cl_assert(len > 0);
-
-	_actual = git__malloc(len + 1);
-	cl_assert(_actual != NULL);
-
-	/* Test non truncation */
-	cl_assert(git_repository_message(_actual, len, _repo) > 0);
+	cl_git_pass(git_repository_message(&_actual, _repo));
 	cl_assert_equal_s(expected, _actual);
-
-	/* Test truncation and that trailing NUL is inserted */
-	cl_assert(git_repository_message(_actual, 6, _repo) > 0);
-	cl_assert_equal_s("Test\n", _actual);
+	git_buf_free(&_actual);
 
 	cl_git_pass(p_unlink(git_buf_cstr(&_path)));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(NULL, 0, _repo));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(&_actual, _repo));
 }
-- 
cgit v1.2.3


From b25d87c9cdef0bc09007c756d7e52f15eb4622d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 26 Jan 2014 16:03:37 +0100
Subject: branch: move to git_buf when outputting newly-allocated strings

Internally we already did everything with git_bufs, so this is just
exposing those functions with public names.
---
 include/git2/branch.h              | 31 ++++--------
 src/branch.c                       | 98 ++++++++++----------------------------
 tests/clone/empty.c                | 12 ++---
 tests/refs/branches/remote.c       | 39 +++++----------
 tests/refs/branches/upstreamname.c | 10 +---
 5 files changed, 56 insertions(+), 134 deletions(-)

diff --git a/include/git2/branch.h b/include/git2/branch.h
index 44d6fd9c3..851de290a 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -200,25 +200,20 @@ GIT_EXTERN(int) git_branch_set_upstream(git_reference *branch, const char *upstr
  * Return the name of the reference supporting the remote tracking branch,
  * given the name of a local branch reference.
  *
- * @param tracking_branch_name_out The user-allocated buffer which will be
- *     filled with the name of the reference. Pass NULL if you just want to
- *     get the needed size of the name of the reference as the output value.
- *
- * @param buffer_size Size of the `out` buffer in bytes.
+ * @param out Pointer to the user-allocated git_buf which will be
+ * filled with the name of the reference.
  *
  * @param repo the repository where the branches live
  *
- * @param canonical_branch_name name of the local branch.
+ * @param refname reference name of the local branch.
  *
- * @return number of characters in the reference name
- *     including the trailing NUL byte; GIT_ENOTFOUND when no remote tracking
- *     reference exists, otherwise an error code.
+ * @return 0, GIT_ENOTFOUND when no remote tracking reference exists,
+ *     otherwise an error code.
  */
 GIT_EXTERN(int) git_branch_upstream_name(
-	char *tracking_branch_name_out,
-	size_t buffer_size,
+	git_buf *out,
 	git_repository *repo,
-	const char *canonical_branch_name);
+	const char *refname);
 
 /**
  * Determine if the current local branch is pointed at by HEAD.
@@ -234,25 +229,19 @@ GIT_EXTERN(int) git_branch_is_head(
 /**
  * Return the name of remote that the remote tracking branch belongs to.
  *
- * @param remote_name_out The user-allocated buffer which will be
- *     filled with the name of the remote. Pass NULL if you just want to
- *     get the needed size of the name of the remote as the output value.
- *
- * @param buffer_size Size of the `out` buffer in bytes.
+ * @param out Pointer to the user-allocated git_buf which will be filled iwth the name of the remote.
  *
  * @param repo The repository where the branch lives.
  *
  * @param canonical_branch_name name of the remote tracking branch.
  *
- * @return Number of characters in the reference name
- *     including the trailing NUL byte; GIT_ENOTFOUND
+ * @return 0, GIT_ENOTFOUND
  *     when no remote matching remote was found,
  *     GIT_EAMBIGUOUS when the branch maps to several remotes,
  *     otherwise an error code.
  */
 GIT_EXTERN(int) git_branch_remote_name(
-	char *remote_name_out,
-	size_t buffer_size,
+	git_buf *out,
 	git_repository *repo,
 	const char *canonical_branch_name);
 
diff --git a/src/branch.c b/src/branch.c
index 3b9aa0d20..a702c661e 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -286,10 +286,10 @@ static int retrieve_upstream_configuration(
 	return error;
 }
 
-int git_branch_upstream__name(
-	git_buf *tracking_name,
+int git_branch_upstream_name(
+	git_buf *out,
 	git_repository *repo,
-	const char *canonical_branch_name)
+	const char *refname)
 {
 	const char *remote_name, *merge_name;
 	git_buf buf = GIT_BUF_INIT;
@@ -297,22 +297,24 @@ int git_branch_upstream__name(
 	git_remote *remote = NULL;
 	const git_refspec *refspec;
 
-	assert(tracking_name && canonical_branch_name);
+	assert(out && refname);
+
+	git_buf_sanitize(out);
 
-	if (!git_reference__is_branch(canonical_branch_name))
-		return not_a_local_branch(canonical_branch_name);
+	if (!git_reference__is_branch(refname))
+		return not_a_local_branch(refname);
 
 	if ((error = retrieve_upstream_configuration(
-		&remote_name, repo, canonical_branch_name, "branch.%s.remote")) < 0)
+		&remote_name, repo, refname, "branch.%s.remote")) < 0)
 			goto cleanup;
 
 	if ((error = retrieve_upstream_configuration(
-		&merge_name, repo, canonical_branch_name, "branch.%s.merge")) < 0)
+		&merge_name, repo, refname, "branch.%s.merge")) < 0)
 			goto cleanup;
 
 	if (!*remote_name || !*merge_name) {
 		giterr_set(GITERR_REFERENCE,
-			"branch '%s' does not have an upstream", canonical_branch_name);
+			"branch '%s' does not have an upstream", refname);
 		error = GIT_ENOTFOUND;
 		goto cleanup;
 	}
@@ -333,7 +335,7 @@ int git_branch_upstream__name(
 		if (git_buf_sets(&buf, merge_name) < 0)
 			goto cleanup;
 
-	error = git_buf_set(tracking_name, git_buf_cstr(&buf), git_buf_len(&buf));
+	error = git_buf_set(out, git_buf_cstr(&buf), git_buf_len(&buf));
 
 cleanup:
 	git_remote_free(remote);
@@ -341,7 +343,7 @@ cleanup:
 	return error;
 }
 
-static int remote_name(git_buf *buf, git_repository *repo, const char *canonical_branch_name)
+int git_branch_remote_name(git_buf *buf, git_repository *repo, const char *refname)
 {
 	git_strarray remote_list = {0};
 	size_t i;
@@ -350,12 +352,14 @@ static int remote_name(git_buf *buf, git_repository *repo, const char *canonical
 	int error = 0;
 	char *remote_name = NULL;
 
-	assert(buf && repo && canonical_branch_name);
+	assert(buf && repo && refname);
+
+	git_buf_sanitize(buf);
 
 	/* Verify that this is a remote branch */
-	if (!git_reference__is_remote(canonical_branch_name)) {
+	if (!git_reference__is_remote(refname)) {
 		giterr_set(GITERR_INVALID, "Reference '%s' is not a remote branch.",
-			canonical_branch_name);
+			refname);
 		error = GIT_ERROR;
 		goto cleanup;
 	}
@@ -369,7 +373,7 @@ static int remote_name(git_buf *buf, git_repository *repo, const char *canonical
 		if ((error = git_remote_load(&remote, repo, remote_list.strings[i])) < 0)
 			continue;
 
-		fetchspec = git_remote__matching_dst_refspec(remote, canonical_branch_name);
+		fetchspec = git_remote__matching_dst_refspec(remote, refname);
 		if (fetchspec) {
 			/* If we have not already set out yet, then set
 			 * it to the matching remote name. Otherwise
@@ -381,7 +385,7 @@ static int remote_name(git_buf *buf, git_repository *repo, const char *canonical
 				git_remote_free(remote);
 
 				giterr_set(GITERR_REFERENCE,
-					"Reference '%s' is ambiguous", canonical_branch_name);
+					"Reference '%s' is ambiguous", refname);
 				error = GIT_EAMBIGUOUS;
 				goto cleanup;
 			}
@@ -395,68 +399,18 @@ static int remote_name(git_buf *buf, git_repository *repo, const char *canonical
 		error = git_buf_puts(buf, remote_name);
 	} else {
 		giterr_set(GITERR_REFERENCE,
-			"Could not determine remote for '%s'", canonical_branch_name);
+			"Could not determine remote for '%s'", refname);
 		error = GIT_ENOTFOUND;
 	}
 
 cleanup:
+	if (error < 0)
+		git_buf_free(buf);
+
 	git_strarray_free(&remote_list);
 	return error;
 }
 
-int git_branch_remote_name(char *buffer, size_t buffer_len, git_repository *repo, const char *refname)
-{
-	int ret;
-	git_buf buf = GIT_BUF_INIT;
-
-	if ((ret = remote_name(&buf, repo, refname)) < 0)
-		return ret;
-
-	if (buffer)
-		git_buf_copy_cstr(buffer, buffer_len, &buf);
-
-	ret = (int)git_buf_len(&buf) + 1;
-	git_buf_free(&buf);
-
-	return ret;
-}
-
-int git_branch_upstream_name(
-	char *tracking_branch_name_out,
-	size_t buffer_size,
-	git_repository *repo,
-	const char *canonical_branch_name)
-{
-	git_buf buf = GIT_BUF_INIT;
-	int error;
-
-	assert(canonical_branch_name);
-
-	if (tracking_branch_name_out && buffer_size)
-		*tracking_branch_name_out = '\0';
-
-	if ((error = git_branch_upstream__name(
-		&buf, repo, canonical_branch_name)) < 0)
-			goto cleanup;
-
-	if (tracking_branch_name_out && buf.size + 1 > buffer_size) { /* +1 for NUL byte */
-		giterr_set(
-			GITERR_INVALID,
-			"Buffer too short to hold the tracked reference name.");
-		error = -1;
-		goto cleanup;
-	}
-
-	if (tracking_branch_name_out)
-		git_buf_copy_cstr(tracking_branch_name_out, buffer_size, &buf);
-
-	error = (int)buf.size + 1;
-
-cleanup:
-	git_buf_free(&buf);
-	return (int)error;
-}
-
 int git_branch_upstream(
 		git_reference **tracking_out,
 		git_reference *branch)
@@ -464,7 +418,7 @@ int git_branch_upstream(
 	int error;
 	git_buf tracking_name = GIT_BUF_INIT;
 
-	if ((error = git_branch_upstream__name(&tracking_name,
+	if ((error = git_branch_upstream_name(&tracking_name,
 		git_reference_owner(branch), git_reference_name(branch))) < 0)
 			return error;
 
@@ -547,7 +501,7 @@ int git_branch_set_upstream(git_reference *branch, const char *upstream_name)
 	if (local)
 		git_buf_puts(&value, ".");
 	else
-		remote_name(&value, repo, git_reference_name(upstream));
+		git_branch_remote_name(&value, repo, git_reference_name(upstream));
 
 	if (git_buf_printf(&key, "branch.%s.remote", shortname) < 0)
 		goto on_error;
diff --git a/tests/clone/empty.c b/tests/clone/empty.c
index 6d19244cc..78aef7dae 100644
--- a/tests/clone/empty.c
+++ b/tests/clone/empty.c
@@ -38,7 +38,7 @@ void test_clone_empty__can_clone_an_empty_local_repo_barely(void)
 	char *local_name = "refs/heads/master";
 	const char *expected_tracked_branch_name = "refs/remotes/origin/master";
 	const char *expected_remote_name = "origin";
-	char buffer[1024];
+	git_buf buf = GIT_BUF_INIT;
 	git_reference *ref;
 
 	cl_set_cleanup(&cleanup_repository, "./empty");
@@ -50,16 +50,14 @@ void test_clone_empty__can_clone_an_empty_local_repo_barely(void)
 	cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&ref, g_repo_cloned, local_name));
 
 	/* ...one can still retrieve the name of the remote tracking reference */
-	cl_assert_equal_i((int)strlen(expected_tracked_branch_name) + 1,
-		git_branch_upstream_name(buffer, 1024, g_repo_cloned, local_name));
+	cl_git_pass(git_branch_upstream_name(&buf, g_repo_cloned, local_name));
 
-	cl_assert_equal_s(expected_tracked_branch_name, buffer);
+	cl_assert_equal_s(expected_tracked_branch_name, buf.ptr);
 
 	/* ...and the name of the remote... */
-	cl_assert_equal_i((int)strlen(expected_remote_name) + 1,
-		git_branch_remote_name(buffer, 1024, g_repo_cloned, expected_tracked_branch_name));
+	cl_git_pass(git_branch_remote_name(&buf, g_repo_cloned, expected_tracked_branch_name));
 
-	cl_assert_equal_s(expected_remote_name, buffer);
+	cl_assert_equal_s(expected_remote_name, buf.ptr);
 
 	/* ...even when the remote HEAD is unborn as well */
 	cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&ref, g_repo_cloned,
diff --git a/tests/refs/branches/remote.c b/tests/refs/branches/remote.c
index c110adb33..bac088454 100644
--- a/tests/refs/branches/remote.c
+++ b/tests/refs/branches/remote.c
@@ -21,53 +21,40 @@ void test_refs_branches_remote__cleanup(void)
 
 void test_refs_branches_remote__can_get_remote_for_branch(void)
 {
-	char remotename[1024] = {0};
+	git_buf remotename = {0};
 
-	cl_assert_equal_i(expected_remote_name_length,
-		git_branch_remote_name(NULL, 0, g_repo, remote_tracking_branch_name));
+	cl_git_pass(git_branch_remote_name(&remotename, g_repo, remote_tracking_branch_name));
 
-	cl_assert_equal_i(expected_remote_name_length,
-		git_branch_remote_name(remotename, expected_remote_name_length, g_repo,
-			remote_tracking_branch_name));
-
-	cl_assert_equal_s("test", remotename);
-}
-
-void test_refs_branches_remote__insufficient_buffer_returns_error(void)
-{
-	char remotename[1024] = {0};
-
-	cl_assert_equal_i(expected_remote_name_length,
-		git_branch_remote_name(NULL, 0, g_repo, remote_tracking_branch_name));
-
-	cl_git_fail_with(git_branch_remote_name(remotename,
-		expected_remote_name_length - 1, g_repo, remote_tracking_branch_name),
-			expected_remote_name_length);
+	cl_assert_equal_s("test", remotename.ptr);
+	git_buf_free(&remotename);
 }
 
 void test_refs_branches_remote__no_matching_remote_returns_error(void)
 {
 	const char *unknown = "refs/remotes/nonexistent/master";
+	git_buf buf;
 
 	giterr_clear();
-	cl_git_fail_with(git_branch_remote_name(
-		NULL, 0, g_repo, unknown), GIT_ENOTFOUND);
+	memset(&buf, 0, sizeof(git_buf));
+	cl_git_fail_with(git_branch_remote_name(&buf, g_repo, unknown), GIT_ENOTFOUND);
 	cl_assert(giterr_last() != NULL);
 }
 
 void test_refs_branches_remote__local_remote_returns_error(void)
 {
 	const char *local = "refs/heads/master";
+	git_buf buf;
 
 	giterr_clear();
-	cl_git_fail_with(git_branch_remote_name(
-		NULL, 0, g_repo, local), GIT_ERROR);
+	memset(&buf, 0, sizeof(git_buf));
+	cl_git_fail_with(git_branch_remote_name(&buf, g_repo, local), GIT_ERROR);
 	cl_assert(giterr_last() != NULL);
 }
 
 void test_refs_branches_remote__ambiguous_remote_returns_error(void)
 {
 	git_remote *remote;
+	git_buf buf;
 
 	/* Create the remote */
 	cl_git_pass(git_remote_create(&remote, g_repo, "addtest", "http://github.com/libgit2/libgit2"));
@@ -80,7 +67,7 @@ void test_refs_branches_remote__ambiguous_remote_returns_error(void)
 	git_remote_free(remote);
 
 	giterr_clear();
-	cl_git_fail_with(git_branch_remote_name(NULL, 0, g_repo,
-		remote_tracking_branch_name), GIT_EAMBIGUOUS);
+	memset(&buf, 0, sizeof(git_buf));
+	cl_git_fail_with(git_branch_remote_name(&buf, g_repo, remote_tracking_branch_name), GIT_EAMBIGUOUS);
 	cl_assert(giterr_last() != NULL);
 }
diff --git a/tests/refs/branches/upstreamname.c b/tests/refs/branches/upstreamname.c
index f05607d44..d30002e08 100644
--- a/tests/refs/branches/upstreamname.c
+++ b/tests/refs/branches/upstreamname.c
@@ -21,7 +21,7 @@ void test_refs_branches_upstreamname__cleanup(void)
 
 void test_refs_branches_upstreamname__can_retrieve_the_remote_tracking_reference_name_of_a_local_branch(void)
 {
-	cl_git_pass(git_branch_upstream__name(
+	cl_git_pass(git_branch_upstream_name(
 		&upstream_name, repo, "refs/heads/master"));
 
 	cl_assert_equal_s("refs/remotes/test/master", git_buf_cstr(&upstream_name));
@@ -29,14 +29,8 @@ void test_refs_branches_upstreamname__can_retrieve_the_remote_tracking_reference
 
 void test_refs_branches_upstreamname__can_retrieve_the_local_upstream_reference_name_of_a_local_branch(void)
 {
-	cl_git_pass(git_branch_upstream__name(
+	cl_git_pass(git_branch_upstream_name(
 		&upstream_name, repo, "refs/heads/track-local"));
 
 	cl_assert_equal_s("refs/heads/master", git_buf_cstr(&upstream_name));
 }
-
-void test_refs_branches_upstreamname__can_return_the_size_of_thelocal_upstream_reference_name_of_a_local_branch(void)
-{
-	cl_assert_equal_i((int)strlen("refs/heads/master") + 1,
-		git_branch_upstream_name(NULL, 0, repo, "refs/heads/track-local"));
-}
-- 
cgit v1.2.3


From ee550477d1c22273d6d9701b444041ff101144ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 26 Jan 2014 16:11:18 +0100
Subject: config: use git_buf for returning paths

Again, we already did this internally, so simply remove the conversions.
---
 include/git2/config.h | 24 +++++++++++-------------
 src/config.c          | 52 ++++++---------------------------------------------
 src/config.h          |  5 -----
 src/repository.c      |  6 +++---
 4 files changed, 20 insertions(+), 67 deletions(-)

diff --git a/include/git2/config.h b/include/git2/config.h
index f650f1b41..663b4f6ba 100644
--- a/include/git2/config.h
+++ b/include/git2/config.h
@@ -9,6 +9,7 @@
 
 #include "common.h"
 #include "types.h"
+#include "buffer.h"
 
 /**
  * @file git2/config.h
@@ -90,11 +91,10 @@ typedef struct {
  * This method will not guess the path to the xdg compatible
  * config file (.config/git/config).
  *
- * @param out Buffer to store the path in
- * @param length size of the buffer in bytes
- * @return 0 if a global configuration file has been found. Its path will be stored in `buffer`.
+ * @param out Pointer to a user-allocated git_buf in which to store the path
+ * @return 0 if a global configuration file has been found. Its path will be stored in `out`.
  */
-GIT_EXTERN(int) git_config_find_global(char *out, size_t length);
+GIT_EXTERN(int) git_config_find_global(git_buf *out);
 
 /**
  * Locate the path to the global xdg compatible configuration file
@@ -107,25 +107,23 @@ GIT_EXTERN(int) git_config_find_global(char *out, size_t length);
  * may be used on any `git_config` call to load the
  * xdg compatible configuration file.
  *
- * @param out Buffer to store the path in
- * @param length size of the buffer in bytes
+ * @param out Pointer to a user-allocated git_buf in which to store the path
  * @return 0 if a xdg compatible configuration file has been
- *	found. Its path will be stored in `buffer`.
+ *	found. Its path will be stored in `out`.
  */
-GIT_EXTERN(int) git_config_find_xdg(char *out, size_t length);
+GIT_EXTERN(int) git_config_find_xdg(git_buf *out);
 
 /**
  * Locate the path to the system configuration file
  *
  * If /etc/gitconfig doesn't exist, it will look for
  * %PROGRAMFILES%\Git\etc\gitconfig.
-
- * @param out Buffer to store the path in
- * @param length size of the buffer in bytes
+ *
+ * @param out Pointer to a user-allocated git_buf in which to store the path
  * @return 0 if a system configuration file has been
- *	found. Its path will be stored in `buffer`.
+ *	found. Its path will be stored in `out`.
  */
-GIT_EXTERN(int) git_config_find_system(char *out, size_t length);
+GIT_EXTERN(int) git_config_find_system(git_buf *out);
 
 /**
  * Open the global, XDG and system configuration files
diff --git a/src/config.c b/src/config.c
index fa1dd8182..6aa71468a 100644
--- a/src/config.c
+++ b/src/config.c
@@ -935,61 +935,21 @@ void git_config_iterator_free(git_config_iterator *iter)
 	iter->free(iter);
 }
 
-static int git_config__find_file_to_path(
-	char *out, size_t outlen, int (*find)(git_buf *buf))
-{
-	int error = 0;
-	git_buf path = GIT_BUF_INIT;
-
-	if ((error = find(&path)) < 0)
-		goto done;
-
-	if (path.size >= outlen) {
-		giterr_set(GITERR_NOMEMORY, "Buffer is too short for the path");
-		error = GIT_EBUFS;
-		goto done;
-	}
-
-	git_buf_copy_cstr(out, outlen, &path);
-
-done:
-	git_buf_free(&path);
-	return error;
-}
-
-int git_config_find_global_r(git_buf *path)
+int git_config_find_global(git_buf *path)
 {
 	return git_futils_find_global_file(path, GIT_CONFIG_FILENAME_GLOBAL);
 }
 
-int git_config_find_global(char *global_config_path, size_t length)
-{
-	return git_config__find_file_to_path(
-		global_config_path, length, git_config_find_global_r);
-}
-
-int git_config_find_xdg_r(git_buf *path)
+int git_config_find_xdg(git_buf *path)
 {
 	return git_futils_find_xdg_file(path, GIT_CONFIG_FILENAME_XDG);
 }
 
-int git_config_find_xdg(char *xdg_config_path, size_t length)
-{
-	return git_config__find_file_to_path(
-		xdg_config_path, length, git_config_find_xdg_r);
-}
-
-int git_config_find_system_r(git_buf *path)
+int git_config_find_system(git_buf *path)
 {
 	return git_futils_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
 }
 
-int git_config_find_system(char *system_config_path, size_t length)
-{
-	return git_config__find_file_to_path(
-		system_config_path, length, git_config_find_system_r);
-}
-
 int git_config__global_location(git_buf *buf)
 {
 	const git_buf *paths;
@@ -1026,16 +986,16 @@ int git_config_open_default(git_config **out)
 	if ((error = git_config_new(&cfg)) < 0)
 		return error;
 
-	if (!git_config_find_global_r(&buf) || !git_config__global_location(&buf)) {
+	if (!git_config_find_global(&buf) || !git_config__global_location(&buf)) {
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_GLOBAL, 0);
 	}
 
-	if (!error && !git_config_find_xdg_r(&buf))
+	if (!error && !git_config_find_xdg(&buf))
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_XDG, 0);
 
-	if (!error && !git_config_find_system_r(&buf))
+	if (!error && !git_config_find_system(&buf))
 		error = git_config_add_file_ondisk(cfg, buf.ptr,
 			GIT_CONFIG_LEVEL_SYSTEM, 0);
 
diff --git a/src/config.h b/src/config.h
index 3cd888c88..03d910616 100644
--- a/src/config.h
+++ b/src/config.h
@@ -24,11 +24,6 @@ struct git_config {
 	git_vector files;
 };
 
-extern int git_config_find_global_r(git_buf *global_config_path);
-extern int git_config_find_xdg_r(git_buf *system_config_path);
-extern int git_config_find_system_r(git_buf *system_config_path);
-
-
 extern int git_config__global_location(git_buf *buf);
 
 extern int git_config_rename_section(
diff --git a/src/repository.c b/src/repository.c
index db66e6bd5..285d8897f 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -582,9 +582,9 @@ int git_repository_config__weakptr(git_config **out, git_repository *repo)
 		git_buf system_buf = GIT_BUF_INIT;
 		git_config *config;
 
-		git_config_find_global_r(&global_buf);
-		git_config_find_xdg_r(&xdg_buf);
-		git_config_find_system_r(&system_buf);
+		git_config_find_global(&global_buf);
+		git_config_find_xdg(&xdg_buf);
+		git_config_find_system(&system_buf);
 
 		/* If there is no global file, open a backend for it anyway */
 		if (git_buf_len(&global_buf) == 0)
-- 
cgit v1.2.3


From e1d7f0035e8683423271f1f63b57fd9c663e4fb0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 26 Jan 2014 16:32:49 +0100
Subject: messsage: use git_buf in prettify()

A lot of the tests were checking for overflow, which we don't have
anymore, so we can remove them.
---
 include/git2/message.h                 | 17 ++-----
 src/message.c                          | 30 ++----------
 tests/object/commit/commitstagedfile.c |  8 ++--
 tests/object/message.c                 | 87 ++++++++++------------------------
 4 files changed, 38 insertions(+), 104 deletions(-)

diff --git a/include/git2/message.h b/include/git2/message.h
index 395c88690..bcdb72f6a 100644
--- a/include/git2/message.h
+++ b/include/git2/message.h
@@ -8,6 +8,7 @@
 #define INCLUDE_git_message_h__
 
 #include "common.h"
+#include "buffer.h"
 
 /**
  * @file git2/message.h
@@ -23,25 +24,17 @@ GIT_BEGIN_DECL
  *
  * Optionally, can remove lines starting with a "#".
  *
- * @param out The user-allocated buffer which will be filled with the
- *     cleaned up message. Pass NULL if you just want to get the needed
- *     size of the prettified message as the output value.
- *
- * @param out_size Size of the `out` buffer in bytes.
+ * @param out The user-allocated git_buf which will be filled with the
+ *     cleaned up message.
  *
  * @param message The message to be prettified.
  *
  * @param strip_comments Non-zero to remove lines starting with "#", 0 to
  *     leave them in.
  *
- * @return -1 on error, else number of characters in prettified message
- *     including the trailing NUL byte
+ * @return 0 or an error code.
  */
-GIT_EXTERN(int) git_message_prettify(
-	char *out,
-	size_t out_size,
-	const char *message,
-	int strip_comments);
+GIT_EXTERN(int) git_message_prettify(git_buf *out, const char *message, int strip_comments);
 
 /** @} */
 GIT_END_DECL
diff --git a/src/message.c b/src/message.c
index 0eff426f2..07b2569ad 100644
--- a/src/message.c
+++ b/src/message.c
@@ -21,7 +21,7 @@ static size_t line_length_without_trailing_spaces(const char *line, size_t len)
 
 /* Greatly inspired from git.git "stripspace" */
 /* see https://github.com/git/git/blob/497215d8811ac7b8955693ceaad0899ecd894ed2/builtin/stripspace.c#L4-67 */
-int git_message__prettify(git_buf *message_out, const char *message, int strip_comments)
+int git_message_prettify(git_buf *message_out, const char *message, int strip_comments)
 {
 	const size_t message_len = strlen(message);
 
@@ -29,6 +29,8 @@ int git_message__prettify(git_buf *message_out, const char *message, int strip_c
 	size_t i, line_length, rtrimmed_line_length;
 	char *next_newline;
 
+	git_buf_sanitize(message_out);
+
 	for (i = 0; i < strlen(message); i += line_length) {
 		next_newline = memchr(message + i, '\n', message_len - i);
 
@@ -58,29 +60,3 @@ int git_message__prettify(git_buf *message_out, const char *message, int strip_c
 
 	return git_buf_oom(message_out) ? -1 : 0;
 }
-
-int git_message_prettify(char *message_out, size_t buffer_size, const char *message, int strip_comments)
-{
-	git_buf buf = GIT_BUF_INIT;
-	ssize_t out_size = -1;
-
-	if (message_out && buffer_size)
-		*message_out = '\0';
-
-	if (git_message__prettify(&buf, message, strip_comments) < 0)
-		goto done;
-
-	if (message_out && buf.size + 1 > buffer_size) { /* +1 for NUL byte */
-		giterr_set(GITERR_INVALID, "Buffer too short to hold the cleaned message");
-		goto done;
-	}
-
-	if (message_out)
-		git_buf_copy_cstr(message_out, buffer_size, &buf);
-
-	out_size = buf.size + 1;
-
-done:
-	git_buf_free(&buf);
-	return (int)out_size;
-}
diff --git a/tests/object/commit/commitstagedfile.c b/tests/object/commit/commitstagedfile.c
index 9867ab418..150927728 100644
--- a/tests/object/commit/commitstagedfile.c
+++ b/tests/object/commit/commitstagedfile.c
@@ -25,7 +25,7 @@ void test_object_commit_commitstagedfile__generate_predictable_object_ids(void)
 	git_oid expected_blob_oid, tree_oid, expected_tree_oid, commit_oid, expected_commit_oid;
 	git_signature *signature;
 	git_tree *tree;
-	char buffer[128];
+	git_buf buffer;
 
 	/*
 	 * The test below replicates the following git scenario
@@ -111,7 +111,8 @@ void test_object_commit_commitstagedfile__generate_predictable_object_ids(void)
 	cl_git_pass(git_signature_new(&signature, "nulltoken", "emeric.fermas@gmail.com", 1323847743, 60));
 	cl_git_pass(git_tree_lookup(&tree, repo, &tree_oid));
 
-	cl_assert_equal_i(16, git_message_prettify(buffer, 128, "Initial commit", 0));
+	memset(&buffer, 0, sizeof(git_buf));
+	cl_git_pass(git_message_prettify(&buffer, "Initial commit", 0));
 
 	cl_git_pass(git_commit_create_v(
 		&commit_oid,
@@ -120,12 +121,13 @@ void test_object_commit_commitstagedfile__generate_predictable_object_ids(void)
 		signature,
 		signature,
 		NULL,
-		buffer,
+		buffer.ptr,
 		tree,
 		0));
 
 	cl_assert(git_oid_cmp(&expected_commit_oid, &commit_oid) == 0);
 
+	git_buf_free(&buffer);
 	git_signature_free(signature);
 	git_tree_free(tree);
 	git_index_free(index);
diff --git a/tests/object/message.c b/tests/object/message.c
index 7ef6374b3..ab5565341 100644
--- a/tests/object/message.c
+++ b/tests/object/message.c
@@ -6,7 +6,7 @@ static void assert_message_prettifying(char *expected_output, char *input, int s
 {
 	git_buf prettified_message = GIT_BUF_INIT;
 
-	git_message__prettify(&prettified_message, input, strip_comments);
+	git_message_prettify(&prettified_message, input, strip_comments);
 	cl_assert_equal_s(expected_output, git_buf_cstr(&prettified_message));
 
 	git_buf_free(&prettified_message);
@@ -172,65 +172,28 @@ void test_object_message__keep_comments(void)
 
 void test_object_message__message_prettify(void)
 {
-	char buffer[100];
-
-	cl_assert(git_message_prettify(buffer, sizeof(buffer), "", 0) == 1);
-	cl_assert_equal_s(buffer, "");
-	cl_assert(git_message_prettify(buffer, sizeof(buffer), "", 1) == 1);
-	cl_assert_equal_s(buffer, "");
-
-	cl_assert_equal_i(7, git_message_prettify(buffer, sizeof(buffer), "Short", 0));
-	cl_assert_equal_s("Short\n", buffer);
-	cl_assert_equal_i(7, git_message_prettify(buffer, sizeof(buffer), "Short", 1));
-	cl_assert_equal_s("Short\n", buffer);
-
-	cl_assert(git_message_prettify(buffer, sizeof(buffer), "This is longer\nAnd multiline\n# with some comments still in\n", 0) > 0);
-	cl_assert_equal_s(buffer, "This is longer\nAnd multiline\n# with some comments still in\n");
-
-	cl_assert(git_message_prettify(buffer, sizeof(buffer), "This is longer\nAnd multiline\n# with some comments still in\n", 1) > 0);
-	cl_assert_equal_s(buffer, "This is longer\nAnd multiline\n");
-
-	/* try out overflow */
-	cl_assert(git_message_prettify(buffer, sizeof(buffer),
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890"
-		"1234567890" "1234567890" "1234567890" "1234567890" "12345678",
-		0) > 0);
-	cl_assert_equal_s(buffer,
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890"
-		"1234567890" "1234567890" "1234567890" "1234567890" "12345678\n");
-
-	cl_assert(git_message_prettify(buffer, sizeof(buffer),
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890"
-		"1234567890" "1234567890" "1234567890" "1234567890" "12345678\n",
-		0) > 0);
-	cl_assert_equal_s(buffer,
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890"
-		"1234567890" "1234567890" "1234567890" "1234567890" "12345678\n");
-
-	cl_git_fail(git_message_prettify(buffer, sizeof(buffer),
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890"
-		"1234567890" "1234567890" "1234567890" "1234567890" "123456789",
-		0));
-	cl_git_fail(git_message_prettify(buffer, sizeof(buffer),
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890"
-		"1234567890" "1234567890" "1234567890" "1234567890" "123456789\n",
-		0));
-	cl_git_fail(git_message_prettify(buffer, sizeof(buffer),
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890"
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890",
-		0));
-	cl_git_fail(git_message_prettify(buffer, sizeof(buffer),
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890"
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890""x",
-		0));
-
-	cl_assert(git_message_prettify(buffer, sizeof(buffer),
-		"1234567890" "1234567890" "1234567890" "1234567890" "1234567890\n"
-		"# 1234567890" "1234567890" "1234567890" "1234567890" "1234567890\n"
-		"1234567890",
-		1) > 0);
-
-	cl_assert(git_message_prettify(NULL, 0, "", 0) == 1);
-	cl_assert(git_message_prettify(NULL, 0, "Short test", 0) == 12);
-	cl_assert(git_message_prettify(NULL, 0, "Test\n# with\nComments", 1) == 15);
+	git_buf buffer;
+
+	memset(&buffer, 0, sizeof(buffer));
+	cl_git_pass(git_message_prettify(&buffer, "", 0));
+	cl_assert_equal_s(buffer.ptr, "");
+	git_buf_free(&buffer);
+	cl_git_pass(git_message_prettify(&buffer, "", 1));
+	cl_assert_equal_s(buffer.ptr, "");
+	git_buf_free(&buffer);
+
+	cl_git_pass(git_message_prettify(&buffer, "Short", 0));
+	cl_assert_equal_s("Short\n", buffer.ptr);
+	git_buf_free(&buffer);
+	cl_git_pass(git_message_prettify(&buffer, "Short", 1));
+	cl_assert_equal_s("Short\n", buffer.ptr);
+	git_buf_free(&buffer);
+
+	cl_git_pass(git_message_prettify(&buffer, "This is longer\nAnd multiline\n# with some comments still in\n", 0));
+	cl_assert_equal_s(buffer.ptr, "This is longer\nAnd multiline\n# with some comments still in\n");
+	git_buf_free(&buffer);
+
+	cl_git_pass(git_message_prettify(&buffer, "This is longer\nAnd multiline\n# with some comments still in\n", 1));
+	cl_assert_equal_s(buffer.ptr, "This is longer\nAnd multiline\n");
+	git_buf_free(&buffer);
 }
-- 
cgit v1.2.3


From bf522e08114a4dc25815b09db201266a0791381c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 26 Jan 2014 16:59:36 +0100
Subject: refspec: move to git_buf for outputting strings

---
 include/git2/refspec.h         |  7 +++---
 src/branch.c                   |  4 ++--
 src/clone.c                    |  4 ++--
 src/push.c                     |  2 +-
 src/refspec.c                  | 54 ++++--------------------------------------
 src/refspec.h                  | 22 -----------------
 src/remote.c                   |  4 ++--
 tests/network/remote/remotes.c | 21 ++++++----------
 tests/online/push.c            |  2 +-
 9 files changed, 22 insertions(+), 98 deletions(-)

diff --git a/include/git2/refspec.h b/include/git2/refspec.h
index d96b83ce2..9acdc72d5 100644
--- a/include/git2/refspec.h
+++ b/include/git2/refspec.h
@@ -10,6 +10,7 @@
 #include "common.h"
 #include "types.h"
 #include "net.h"
+#include "buffer.h"
 
 /**
  * @file git2/refspec.h
@@ -82,23 +83,21 @@ GIT_EXTERN(int) git_refspec_dst_matches(const git_refspec *refspec, const char *
  * Transform a reference to its target following the refspec's rules
  *
  * @param out where to store the target name
- * @param outlen the size of the `out` buffer
  * @param spec the refspec
  * @param name the name of the reference to transform
  * @return 0, GIT_EBUFS or another error
  */
-GIT_EXTERN(int) git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, const char *name);
+GIT_EXTERN(int) git_refspec_transform(git_buf *out, const git_refspec *spec, const char *name);
 
 /**
  * Transform a target reference to its source reference following the refspec's rules
  *
  * @param out where to store the source reference name
- * @param outlen the size of the `out` buffer
  * @param spec the refspec
  * @param name the name of the reference to transform
  * @return 0, GIT_EBUFS or another error
  */
-GIT_EXTERN(int) git_refspec_rtransform(char *out, size_t outlen, const git_refspec *spec, const char *name);
+GIT_EXTERN(int) git_refspec_rtransform(git_buf *out, const git_refspec *spec, const char *name);
 
 GIT_END_DECL
 
diff --git a/src/branch.c b/src/branch.c
index a702c661e..a1a04b2b4 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -329,7 +329,7 @@ int git_branch_upstream_name(
 			goto cleanup;
 		}
 
-		if (git_refspec_transform_r(&buf, refspec, merge_name) < 0)
+		if (git_refspec_transform(&buf, refspec, merge_name) < 0)
 			goto cleanup;
 	} else
 		if (git_buf_sets(&buf, merge_name) < 0)
@@ -520,7 +520,7 @@ int git_branch_set_upstream(git_reference *branch, const char *upstream_name)
 
 		fetchspec = git_remote__matching_dst_refspec(remote, git_reference_name(upstream));
 		git_buf_clear(&value);
-		if (!fetchspec || git_refspec_transform_l(&value, fetchspec, git_reference_name(upstream)) < 0)
+		if (!fetchspec || git_refspec_rtransform(&value, fetchspec, git_reference_name(upstream)) < 0)
 			goto on_error;
 
 		git_remote_free(remote);
diff --git a/src/clone.c b/src/clone.c
index 828c47ffb..2e9d72ab9 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -131,7 +131,7 @@ static int reference_matches_remote_head(
 
 	if (!error && !git_oid__cmp(&head_info->remote_head_oid, &oid)) {
 		/* Determine the local reference name from the remote tracking one */
-		error = git_refspec_transform_l(
+		error = git_refspec_rtransform(
 			&head_info->branchname, head_info->refspec, reference_name);
 
 		if (!error &&
@@ -199,7 +199,7 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 	}
 
 	/* Determine the remote tracking reference name from the local master */
-	if ((error = git_refspec_transform_r(
+	if ((error = git_refspec_transform(
 		&remote_master_name,
 		head_info.refspec,
 		GIT_REFS_HEADS_MASTER_FILE)) < 0)
diff --git a/src/push.c b/src/push.c
index 0be82f3b2..d39a27182 100644
--- a/src/push.c
+++ b/src/push.c
@@ -214,7 +214,7 @@ int git_push_update_tips(git_push *push)
 		if (!fetch_spec)
 			continue;
 
-		if ((error = git_refspec_transform_r(&remote_ref_name, fetch_spec, status->ref)) < 0)
+		if ((error = git_refspec_transform(&remote_ref_name, fetch_spec, status->ref)) < 0)
 			goto on_error;
 
 		/* Find matching  push ref spec */
diff --git a/src/refspec.c b/src/refspec.c
index a97340071..fa60aa7aa 100644
--- a/src/refspec.c
+++ b/src/refspec.c
@@ -178,54 +178,6 @@ int git_refspec_dst_matches(const git_refspec *refspec, const char *refname)
 	return (p_fnmatch(refspec->dst, refname, 0) == 0);
 }
 
-static int refspec_transform_internal(char *out, size_t outlen, const char *from, const char *to, const char *name)
-{
-	size_t baselen, namelen;
-
-	baselen = strlen(to);
-	if (outlen <= baselen) {
-		giterr_set(GITERR_INVALID, "Reference name too long");
-		return GIT_EBUFS;
-	}
-
-	/*
-	 * No '*' at the end means that it's mapped to one specific local
-	 * branch, so no actual transformation is needed.
-	 */
-	if (to[baselen - 1] != '*') {
-		memcpy(out, to, baselen + 1); /* include '\0' */
-		return 0;
-	}
-
-	/* There's a '*' at the end, so remove its length */
-	baselen--;
-
-	/* skip the prefix, -1 is for the '*' */
-	name += strlen(from) - 1;
-
-	namelen = strlen(name);
-
-	if (outlen <= baselen + namelen) {
-		giterr_set(GITERR_INVALID, "Reference name too long");
-		return GIT_EBUFS;
-	}
-
-	memcpy(out, to, baselen);
-	memcpy(out + baselen, name, namelen + 1);
-
-	return 0;
-}
-
-int git_refspec_transform(char *out, size_t outlen, const git_refspec *spec, const char *name)
-{
-	return refspec_transform_internal(out, outlen, spec->src, spec->dst, name);
-}
-
-int git_refspec_rtransform(char *out, size_t outlen, const git_refspec *spec, const char *name)
-{
-	return refspec_transform_internal(out, outlen, spec->dst, spec->src, name);
-}
-
 static int refspec_transform(
 	git_buf *out, const char *from, const char *to, const char *name)
 {
@@ -233,6 +185,8 @@ static int refspec_transform(
 	size_t from_len = from ? strlen(from) : 0;
 	size_t name_len = name ? strlen(name) : 0;
 
+	git_buf_sanitize(out);
+
 	if (git_buf_set(out, to, to_len) < 0)
 		return -1;
 
@@ -253,12 +207,12 @@ static int refspec_transform(
 	return git_buf_put(out, name + from_len, name_len - from_len);
 }
 
-int git_refspec_transform_r(git_buf *out, const git_refspec *spec, const char *name)
+int git_refspec_transform(git_buf *out, const git_refspec *spec, const char *name)
 {
 	return refspec_transform(out, spec->src, spec->dst, name);
 }
 
-int git_refspec_transform_l(git_buf *out, const git_refspec *spec, const char *name)
+int git_refspec_rtransform(git_buf *out, const git_refspec *spec, const char *name)
 {
 	return refspec_transform(out, spec->dst, spec->src, name);
 }
diff --git a/src/refspec.h b/src/refspec.h
index 51b7bfee9..375465f61 100644
--- a/src/refspec.h
+++ b/src/refspec.h
@@ -31,28 +31,6 @@ int git_refspec__parse(
 
 void git_refspec__free(git_refspec *refspec);
 
-/**
- * Transform a reference to its target following the refspec's rules,
- * and writes the results into a git_buf.
- *
- * @param out where to store the target name
- * @param spec the refspec
- * @param name the name of the reference to transform
- * @return 0 or error if buffer allocation fails
- */
-int git_refspec_transform_r(git_buf *out, const git_refspec *spec, const char *name);
-
-/**
- * Transform a reference from its target following the refspec's rules,
- * and writes the results into a git_buf.
- *
- * @param out where to store the source name
- * @param spec the refspec
- * @param name the name of the reference to transform
- * @return 0 or error if buffer allocation fails
- */
-int git_refspec_transform_l(git_buf *out, const git_refspec *spec, const char *name);
-
 int git_refspec__serialize(git_buf *out, const git_refspec *refspec);
 
 /**
diff --git a/src/remote.c b/src/remote.c
index 5b3656a81..5d35affd1 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -896,7 +896,7 @@ static int remote_head_for_ref(git_remote_head **out, git_refspec *spec, git_vec
 	if ((error = git_reference_resolve(&resolved_ref, ref)) < 0 ||
 		(!git_reference_is_branch(resolved_ref)) ||
 		(error = git_branch_upstream(&tracking_ref, resolved_ref)) < 0 ||
-		(error = git_refspec_transform_l(&remote_name, spec, git_reference_name(tracking_ref))) < 0) {
+		(error = git_refspec_rtransform(&remote_name, spec, git_reference_name(tracking_ref))) < 0) {
 		/* Not an error if HEAD is unborn or no tracking branch */
 		if (error == GIT_ENOTFOUND)
 			error = 0;
@@ -1011,7 +1011,7 @@ static int update_tips_for_spec(git_remote *remote, git_refspec *spec, git_vecto
 			continue;
 
 		if (git_refspec_src_matches(spec, head->name) && spec->dst) {
-			if (git_refspec_transform_r(&refname, spec, head->name) < 0)
+			if (git_refspec_transform(&refname, spec, head->name) < 0)
 				goto on_error;
 		} else if (remote->download_tags != GIT_REMOTE_DOWNLOAD_TAGS_NONE) {
 
diff --git a/tests/network/remote/remotes.c b/tests/network/remote/remotes.c
index 44a98d31a..09963e8ef 100644
--- a/tests/network/remote/remotes.c
+++ b/tests/network/remote/remotes.c
@@ -230,27 +230,20 @@ void test_network_remote_remotes__fnmatch(void)
 
 void test_network_remote_remotes__transform(void)
 {
-	char ref[1024] = {0};
+	git_buf ref = GIT_BUF_INIT;
 
-	cl_git_pass(git_refspec_transform(ref, sizeof(ref), _refspec, "refs/heads/master"));
+	cl_git_pass(git_refspec_transform(&ref, _refspec, "refs/heads/master"));
 	cl_assert_equal_s(ref, "refs/remotes/test/master");
+	git_buf_free(&ref);
 }
 
 void test_network_remote_remotes__transform_destination_to_source(void)
 {
-	char ref[1024] = {0};
+	git_buf ref = GIT_BUF_INIT;
 
-	cl_git_pass(git_refspec_rtransform(ref, sizeof(ref), _refspec, "refs/remotes/test/master"));
-	cl_assert_equal_s(ref, "refs/heads/master");
-}
-
-void test_network_remote_remotes__transform_r(void)
-{
-	git_buf buf = GIT_BUF_INIT;
-
-	cl_git_pass(git_refspec_transform_r(&buf,  _refspec, "refs/heads/master"));
-	cl_assert_equal_s(git_buf_cstr(&buf), "refs/remotes/test/master");
-	git_buf_free(&buf);
+	cl_git_pass(git_refspec_rtransform(&ref, _refspec, "refs/remotes/test/master"));
+	cl_assert_equal_s(ref.ptr, "refs/heads/master");
+	git_buf_free(&ref);
 }
 
 void test_network_remote_remotes__missing_refspecs(void)
diff --git a/tests/online/push.c b/tests/online/push.c
index 33f174654..8efe21e0e 100644
--- a/tests/online/push.c
+++ b/tests/online/push.c
@@ -219,7 +219,7 @@ static void verify_tracking_branches(git_remote *remote, expected_ref expected_r
 		if (!fetch_spec)
 			continue;
 
-		cl_git_pass(git_refspec_transform_r(&ref_name, fetch_spec, expected_refs[i].name));
+		cl_git_pass(git_refspec_transform(&ref_name, fetch_spec, expected_refs[i].name));
 
 		/* Find matching remote branch */
 		git_vector_foreach(&actual_refs, j, actual_ref) {
-- 
cgit v1.2.3


From 66d585c6b344562c67812840aca5ea76881f7446 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 27 Jan 2014 04:58:23 +0100
Subject: MSVC doesn't like modern code

---
 tests/network/remote/local.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/network/remote/local.c b/tests/network/remote/local.c
index c713ade5b..9b9f716b9 100644
--- a/tests/network/remote/local.c
+++ b/tests/network/remote/local.c
@@ -202,6 +202,7 @@ void test_network_remote_local__push_to_bare_remote_with_file_url(void)
 	/* Should be able to push to a bare remote */
 	git_remote *localremote;
 	git_push *push;
+	const char *url;
 
 	/* Get some commits */
 	connect_to_local_repository(cl_fixture("testrepo.git"));
@@ -218,7 +219,7 @@ void test_network_remote_local__push_to_bare_remote_with_file_url(void)
 	}
 
 	/* Create a file URL */
-	const char *url = cl_git_path_url("./localbare.git");
+	url = cl_git_path_url("./localbare.git");
 
 	/* Connect to the bare repo */
 	cl_git_pass(git_remote_create_inmemory(&localremote, repo, NULL, url));
-- 
cgit v1.2.3


From fbc5661ebfd7106d579d22f06150fded2e707070 Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Mon, 27 Jan 2014 20:51:46 +0800
Subject: MSVC doesn't like modern code neither

---
 examples/general.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/examples/general.c b/examples/general.c
index 58e141b35..ae8756338 100644
--- a/examples/general.c
+++ b/examples/general.c
@@ -47,11 +47,10 @@
 // as an example.
 static void check_error(int error_code, const char *action)
 {
+	const git_error *error = giterr_last();
 	if (!error_code)
 		return;
 
-	const git_error *error = giterr_last();
-
 	printf("Error %d %s - %s\n", error_code, action,
 		   (error && error->message) ? error->message : "???");
 
-- 
cgit v1.2.3


From 1664aaaa2678f7fe329ee046cfa0a5720f36c1be Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Tue, 5 Nov 2013 23:39:05 +0800
Subject: Make blame example compile on MSVC

---
 examples/blame.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/examples/blame.c b/examples/blame.c
index 06310d540..1f5db69a1 100644
--- a/examples/blame.c
+++ b/examples/blame.c
@@ -14,6 +14,11 @@
 
 #include "common.h"
 
+#ifdef _MSC_VER
+#define snprintf sprintf_s
+#define strcasecmp strcmpi
+#endif
+
 /**
  * This example demonstrates how to invoke the libgit2 blame API to roughly
  * simulate the output of `git blame` and a few of its command line arguments.
-- 
cgit v1.2.3


From 4115987739fb9cc4dd82edd9998db6dbb6bc9d95 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 27 Jan 2014 10:23:55 -0800
Subject: Got permission from Gustaf for userdiff patterns

---
 git.git-authors | 1 +
 src/userdiff.h  | 4 ++++
 2 files changed, 5 insertions(+)

diff --git a/git.git-authors b/git.git-authors
index 7e53d66a9..7c72c4bf6 100644
--- a/git.git-authors
+++ b/git.git-authors
@@ -49,6 +49,7 @@ ok	Brian Gernhardt <benji@silverinsanity.com>
 ok	Christian Couder <chriscool@tuxfamily.org>
 ok	Daniel Barkalow <barkalow@iabervon.org>
 ok	Florian Forster <octo@verplant.org>
+ok	Gustaf Hendeby <hendeby@isy.liu.se>
 ok	Holger Weiss <holger@zedat.fu-berlin.de>
 ok	Jeff King <peff@peff.net>
 ok	Johannes Schindelin <Johannes.Schindelin@gmx.de>
diff --git a/src/userdiff.h b/src/userdiff.h
index 318761567..93b4d0d58 100644
--- a/src/userdiff.h
+++ b/src/userdiff.h
@@ -80,6 +80,10 @@ PATTERNS("java",
 	 "|[-+*/<>%&^|=!]="
 	 "|--|\\+\\+|<<=?|>>>?=?|&&|\\|\\|"),
 
+PATTERNS("matlab",
+	 "^[[:space:]]*((classdef|function)[[:space:]].*)$|^%%[[:space:]].*$",
+	 "[a-zA-Z_][a-zA-Z0-9_]*|[-+0-9.e]+|[=~<>]=|\\.[*/\\^']|\\|\\||&&"),
+
 PATTERNS("objc",
 	 /* Negate C statements that can look like functions */
 	 "!^[ \t]*(do|for|if|else|return|switch|while)\n"
-- 
cgit v1.2.3


From 082e82dba5b5174756b3a5fc2e385ccc59626164 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 27 Jan 2014 11:45:06 -0800
Subject: Update Javascript userdiff driver and tests

Writing a sample Javascript driver pointed out some extra
whitespace handling that needed to be done in the diff driver.
This adds some tests with some sample javascript code that I
pulled off of GitHub just to see what would happen.  Also, to
clean up the userdiff test data, I did a "git gc" and packed
up the test objects.
---
 src/diff_driver.c                                  |   1 +
 src/userdiff.h                                     |   6 +-
 tests/diff/drivers.c                               |  28 +++---
 tests/resources/userdiff/.gitted/index             | Bin 456 -> 912 bytes
 tests/resources/userdiff/.gitted/info/refs         |   1 +
 .../05/d669073b39d36847315e3a5b4512cf4cba4546      | Bin 54 -> 0 bytes
 .../20/ab776b6ff3169fa0e5eff65df30d45187d22ba      | Bin 54 -> 0 bytes
 .../23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd      | Bin 207 -> 0 bytes
 .../2e/a4b8a16d737c180dfdd2b119dec9501592326c      | Bin 228 -> 0 bytes
 .../49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0      | Bin 118 -> 0 bytes
 .../50/346bde7428a29c9845470a14d87b1634293d48      |   1 -
 .../5a/428e7dcffb41b65984517f1e6b8547babc8dff      | Bin 263 -> 0 bytes
 .../87/2d19663f32459389597b52beec6457c1dc971f      | Bin 178 -> 0 bytes
 .../9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5      |   2 -
 .../d6/3c806de4f666369ed169495657bec24b558165      | Bin 76 -> 0 bytes
 .../ef/1641511d6cb425c6b4f59ef1feffe7762e86e0      |   1 -
 .../resources/userdiff/.gitted/objects/info/packs  |   2 +
 ...ck-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx | Bin 0 -> 2192 bytes
 ...k-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack | Bin 0 -> 5697 bytes
 tests/resources/userdiff/.gitted/packed-refs       |   2 +
 tests/resources/userdiff/.gitted/refs/heads/master |   1 -
 tests/resources/userdiff/after/file.javascript     | 108 ++++++++++++++++++++
 tests/resources/userdiff/before/file.javascript    | 109 +++++++++++++++++++++
 .../userdiff/expected/driver/diff.javascript       |  40 ++++++++
 .../userdiff/expected/nodriver/diff.javascript     |  40 ++++++++
 tests/resources/userdiff/files/file.javascript     | 108 ++++++++++++++++++++
 26 files changed, 430 insertions(+), 20 deletions(-)
 create mode 100644 tests/resources/userdiff/.gitted/info/refs
 delete mode 100644 tests/resources/userdiff/.gitted/objects/05/d669073b39d36847315e3a5b4512cf4cba4546
 delete mode 100644 tests/resources/userdiff/.gitted/objects/20/ab776b6ff3169fa0e5eff65df30d45187d22ba
 delete mode 100644 tests/resources/userdiff/.gitted/objects/23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd
 delete mode 100644 tests/resources/userdiff/.gitted/objects/2e/a4b8a16d737c180dfdd2b119dec9501592326c
 delete mode 100644 tests/resources/userdiff/.gitted/objects/49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0
 delete mode 100644 tests/resources/userdiff/.gitted/objects/50/346bde7428a29c9845470a14d87b1634293d48
 delete mode 100644 tests/resources/userdiff/.gitted/objects/5a/428e7dcffb41b65984517f1e6b8547babc8dff
 delete mode 100644 tests/resources/userdiff/.gitted/objects/87/2d19663f32459389597b52beec6457c1dc971f
 delete mode 100644 tests/resources/userdiff/.gitted/objects/9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5
 delete mode 100644 tests/resources/userdiff/.gitted/objects/d6/3c806de4f666369ed169495657bec24b558165
 delete mode 100644 tests/resources/userdiff/.gitted/objects/ef/1641511d6cb425c6b4f59ef1feffe7762e86e0
 create mode 100644 tests/resources/userdiff/.gitted/objects/info/packs
 create mode 100644 tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx
 create mode 100644 tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack
 create mode 100644 tests/resources/userdiff/.gitted/packed-refs
 delete mode 100644 tests/resources/userdiff/.gitted/refs/heads/master
 create mode 100644 tests/resources/userdiff/after/file.javascript
 create mode 100644 tests/resources/userdiff/before/file.javascript
 create mode 100644 tests/resources/userdiff/expected/driver/diff.javascript
 create mode 100644 tests/resources/userdiff/expected/nodriver/diff.javascript
 create mode 100644 tests/resources/userdiff/files/file.javascript

diff --git a/src/diff_driver.c b/src/diff_driver.c
index 9249d1415..4c9a0af65 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -437,6 +437,7 @@ static int diff_context_line__pattern_match(
 			i = (pmatch[1].rm_so >= 0) ? 1 : 0;
 			git_buf_consume(line, git_buf_cstr(line) + pmatch[i].rm_so);
 			git_buf_truncate(line, pmatch[i].rm_eo - pmatch[i].rm_so);
+			git_buf_rtrim(line);
 
 			return true;
 		}
diff --git a/src/userdiff.h b/src/userdiff.h
index 93b4d0d58..2257035ac 100644
--- a/src/userdiff.h
+++ b/src/userdiff.h
@@ -193,9 +193,9 @@ PATTERNS("php",
 	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
 
 PATTERNS("javascript",
-	 "^[ \t]*(\(?function[ \t].*)$\n"
-	 "^[ \t]*(var[ \t]+[a-zA-Z_][a-zA-Z0-9_]*[ \t]*=[ \t]*function[ \t\(].*)$\n"
-	 "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*[ \t]*:[ \t]*function[ \t\(].*)$",
+	 "^[ \t]*(function[ \t][a-zA-Z_][^\{]*)\n"
+	 "^[ \t]*(var[ \t]+[a-zA-Z_][a-zA-Z0-9_]*[ \t]*=[ \t]*function[ \t\(][^\{]*)\n"
+	 "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*[ \t]*:[ \t]*function[ \t\(][^\{]*)",
 	 /* -- */
 	 "[a-zA-Z_][a-zA-Z0-9_]*"
 	 "|[-+0-9.e]+[fFlL]?|0[xX]?[0-9a-fA-F]+[lL]?"
diff --git a/tests/diff/drivers.c b/tests/diff/drivers.c
index 1cbf9e211..8b12368ea 100644
--- a/tests/diff/drivers.c
+++ b/tests/diff/drivers.c
@@ -180,22 +180,23 @@ void test_diff_drivers__builtins(void)
 	git_patch *patch;
 	git_buf file = GIT_BUF_INIT, actual = GIT_BUF_INIT, expected = GIT_BUF_INIT;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
-	int i;
-	static const char *files[] = {
-		"html",
-		NULL
-	};
+	git_vector files = GIT_VECTOR_INIT;
+	size_t i;
+	char *path, *extension;
 
 	g_repo = cl_git_sandbox_init("userdiff");
 
+	cl_git_pass(git_path_dirload("userdiff/files", 9, 0, 0, &files));
+
 	opts.interhunk_lines = 1;
 	opts.context_lines = 1;
 	opts.pathspec.count = 1;
 
-	for (i = 0; files[i]; ++i) {
-		git_buf_sets(&file, "files/file.");
-		git_buf_puts(&file, files[i]);
-		opts.pathspec.strings = &file.ptr;
+	git_vector_foreach(&files, i, path) {
+		if (git__prefixcmp(path, "files/file."))
+			continue;
+		extension = path + strlen("files/file.");
+		opts.pathspec.strings = &path;
 
 		/* do diff with no special driver */
 
@@ -205,7 +206,7 @@ void test_diff_drivers__builtins(void)
 		cl_git_pass(git_patch_to_buf(&actual, patch));
 
 		git_buf_sets(&expected, "userdiff/expected/nodriver/diff.");
-		git_buf_puts(&expected, files[i]);
+		git_buf_puts(&expected, extension);
 		cl_git_pass(git_futils_readbuffer(&expected, expected.ptr));
 
 		overwrite_filemode(expected.ptr, &actual);
@@ -220,7 +221,7 @@ void test_diff_drivers__builtins(void)
 
 		{
 			FILE *fp = fopen("userdiff/.gitattributes", "w");
-			fprintf(fp, "*.%s diff=%s\n", files[i], files[i]);
+			fprintf(fp, "*.%s diff=%s\n", extension, extension);
 			fclose(fp);
 		}
 
@@ -230,7 +231,7 @@ void test_diff_drivers__builtins(void)
 		cl_git_pass(git_patch_to_buf(&actual, patch));
 
 		git_buf_sets(&expected, "userdiff/expected/driver/diff.");
-		git_buf_puts(&expected, files[i]);
+		git_buf_puts(&expected, extension);
 		cl_git_pass(git_futils_readbuffer(&expected, expected.ptr));
 
 		overwrite_filemode(expected.ptr, &actual);
@@ -240,9 +241,12 @@ void test_diff_drivers__builtins(void)
 		git_buf_clear(&actual);
 		git_patch_free(patch);
 		git_diff_free(diff);
+
+		git__free(path);
 	}
 
 	git_buf_free(&file);
 	git_buf_free(&actual);
 	git_buf_free(&expected);
+	git_vector_free(&files);
 }
diff --git a/tests/resources/userdiff/.gitted/index b/tests/resources/userdiff/.gitted/index
index 9372411cd..df041cf72 100644
Binary files a/tests/resources/userdiff/.gitted/index and b/tests/resources/userdiff/.gitted/index differ
diff --git a/tests/resources/userdiff/.gitted/info/refs b/tests/resources/userdiff/.gitted/info/refs
new file mode 100644
index 000000000..261695f80
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/info/refs
@@ -0,0 +1 @@
+802734c801bffc466d69876bc4814f747aaac4fe	refs/heads/master
diff --git a/tests/resources/userdiff/.gitted/objects/05/d669073b39d36847315e3a5b4512cf4cba4546 b/tests/resources/userdiff/.gitted/objects/05/d669073b39d36847315e3a5b4512cf4cba4546
deleted file mode 100644
index 3a9d75cc1..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/05/d669073b39d36847315e3a5b4512cf4cba4546 and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/20/ab776b6ff3169fa0e5eff65df30d45187d22ba b/tests/resources/userdiff/.gitted/objects/20/ab776b6ff3169fa0e5eff65df30d45187d22ba
deleted file mode 100644
index 3d57061ce..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/20/ab776b6ff3169fa0e5eff65df30d45187d22ba and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd b/tests/resources/userdiff/.gitted/objects/23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd
deleted file mode 100644
index 6dbcafed4..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/23/20e2f1e4d9e6201a8e15949a0c10a533fa51cd and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/2e/a4b8a16d737c180dfdd2b119dec9501592326c b/tests/resources/userdiff/.gitted/objects/2e/a4b8a16d737c180dfdd2b119dec9501592326c
deleted file mode 100644
index e7d2fba41..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/2e/a4b8a16d737c180dfdd2b119dec9501592326c and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0 b/tests/resources/userdiff/.gitted/objects/49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0
deleted file mode 100644
index 49d59c11d..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/49/c0ff897b2b07a2ea0ed073e62a9dcd02704ba0 and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/50/346bde7428a29c9845470a14d87b1634293d48 b/tests/resources/userdiff/.gitted/objects/50/346bde7428a29c9845470a14d87b1634293d48
deleted file mode 100644
index 9de1b3598..000000000
--- a/tests/resources/userdiff/.gitted/objects/50/346bde7428a29c9845470a14d87b1634293d48
+++ /dev/null
@@ -1 +0,0 @@
-x
+)JMU06g040031QHËÌIÕË(ÉÍahוL³7r�ÜY´ïMJøÁ;Óå
8¿ð
\ No newline at end of file
diff --git a/tests/resources/userdiff/.gitted/objects/5a/428e7dcffb41b65984517f1e6b8547babc8dff b/tests/resources/userdiff/.gitted/objects/5a/428e7dcffb41b65984517f1e6b8547babc8dff
deleted file mode 100644
index 143a1cecf..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/5a/428e7dcffb41b65984517f1e6b8547babc8dff and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/87/2d19663f32459389597b52beec6457c1dc971f b/tests/resources/userdiff/.gitted/objects/87/2d19663f32459389597b52beec6457c1dc971f
deleted file mode 100644
index 415f40a66..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/87/2d19663f32459389597b52beec6457c1dc971f and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5 b/tests/resources/userdiff/.gitted/objects/9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5
deleted file mode 100644
index c0a03a241..000000000
--- a/tests/resources/userdiff/.gitted/objects/9d/b1d09ff9ad5190bcf12d72ea3c818ffca344c5
+++ /dev/null
@@ -1,2 +0,0 @@
-x
•�M F]sŠ¹€fJ+”Äãέ7àg°$P:Ü_OàöË{ïóµ”Ä0éë‰,ÆcŒ«ÑN:ÔV’E
-¨gRÒšàJ�‹³(lç­6x÷ã œáI9Rƒ[s�Oâ­»‹¯åÓlP¡Òf…3®ˆb¬ã�ú¯)^{âd3üâóÍ9
\ No newline at end of file
diff --git a/tests/resources/userdiff/.gitted/objects/d6/3c806de4f666369ed169495657bec24b558165 b/tests/resources/userdiff/.gitted/objects/d6/3c806de4f666369ed169495657bec24b558165
deleted file mode 100644
index 2c0fbcc09..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/d6/3c806de4f666369ed169495657bec24b558165 and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/ef/1641511d6cb425c6b4f59ef1feffe7762e86e0 b/tests/resources/userdiff/.gitted/objects/ef/1641511d6cb425c6b4f59ef1feffe7762e86e0
deleted file mode 100644
index 223f3b380..000000000
--- a/tests/resources/userdiff/.gitted/objects/ef/1641511d6cb425c6b4f59ef1feffe7762e86e0
+++ /dev/null
@@ -1 +0,0 @@
-x
+)JMU06g040031QHÉLKÓË(ÉÍaˆrê«=ÿÛq[dK`½\v«û®=½ÿ
Már
\ No newline at end of file
diff --git a/tests/resources/userdiff/.gitted/objects/info/packs b/tests/resources/userdiff/.gitted/objects/info/packs
new file mode 100644
index 000000000..6970fd7b0
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/objects/info/packs
@@ -0,0 +1,2 @@
+P pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack
+
diff --git a/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx b/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx
new file mode 100644
index 000000000..6d723f525
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx differ
diff --git a/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack b/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack
new file mode 100644
index 000000000..5b263e27d
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack differ
diff --git a/tests/resources/userdiff/.gitted/packed-refs b/tests/resources/userdiff/.gitted/packed-refs
new file mode 100644
index 000000000..6d24ee4ed
--- /dev/null
+++ b/tests/resources/userdiff/.gitted/packed-refs
@@ -0,0 +1,2 @@
+# pack-refs with: peeled fully-peeled 
+802734c801bffc466d69876bc4814f747aaac4fe refs/heads/master
diff --git a/tests/resources/userdiff/.gitted/refs/heads/master b/tests/resources/userdiff/.gitted/refs/heads/master
deleted file mode 100644
index 2ec79ec86..000000000
--- a/tests/resources/userdiff/.gitted/refs/heads/master
+++ /dev/null
@@ -1 +0,0 @@
-9db1d09ff9ad5190bcf12d72ea3c818ffca344c5
diff --git a/tests/resources/userdiff/after/file.javascript b/tests/resources/userdiff/after/file.javascript
new file mode 100644
index 000000000..7cd3c5a8a
--- /dev/null
+++ b/tests/resources/userdiff/after/file.javascript
@@ -0,0 +1,108 @@
+/*
+  Some code extracted from https://github.com/julianlloyd/scrollReveal.js
+  which happens to be a trending Javascript repo with an MIT license at
+  the time I was working on Javascript userdiff support in libgit2
+
+  I extracted just some of the code, so I suspect this is no longer valid
+  Javascript code, but it contains enough example patterns to work.
+*/
+;(function (window) {
+
+  'use strict';
+
+  var docElem = window.document.documentElement;
+
+  function getViewportH () {
+    var client = docElem['clientHeight'],
+      inner = window['innerHeight'],
+      sample = window['otherProperty'];
+
+    return (client < inner) ? inner : client;
+  }
+
+  function getOffset (el) {
+    var offsetTop = 0,
+        offsetLeft = 0;
+
+    do {
+      if (!isNaN(el.offsetTop)) {
+        offsetTop += el.offsetTop + 1;
+      }
+      if (!isNaN(el.offsetLeft)) {
+        offsetLeft += el.offsetLeft;
+      }
+    } while (el = el.offsetParent)
+
+    return {
+      top: offsetTop,
+      left: offsetLeft
+    }
+  }
+
+  function isElementInViewport (el, h) {
+    var scrolled = window.pageYOffset,
+        viewed = scrolled + getViewportH(),
+        elTop = getOffset(el).top,
+        elBottom = elTop + el.offsetHeight,
+        h = h || 0;
+
+    return (elTop + el.offsetHeight * h) <= viewed && (elBottom) >= scrolled;
+  }
+
+  scrollReveal.prototype = {
+
+    _init: function () {
+
+      var self = this;
+
+      this.elems = Array.prototype.slice.call(docElem.querySelectorAll('[data-scrollReveal]'));
+      this.scrolled = false;
+
+      this.elems.forEach(function (el, i) {
+        self.animate(el);
+      });
+
+      var scrollHandler = function () {
+        if (!self.scrolled) {
+          self.scrolled = true;
+          setTimeout(function () {
+            self._scrollPage();
+          }, 61);
+        }
+      };
+
+      var resizeHandler = function () {
+        function delayed() {
+          self._scrollPage();
+          self.resizeTimeout = null;
+        }
+        if (self.resizeTimeout) {
+          clearTimeout(self.resizeTimeout);
+        }
+        self.resizeTimeout = setTimeout(delayed, 200);
+      };
+
+      window.addEventListener('scroll', scrollHandler, false);
+      window.addEventListener('resize', resizeHandler, false);
+    },
+
+    /*=============================================================================*/
+
+    _scrollPage: function () {
+        var self = this;
+
+        this.elems.forEach(function (el, i) {
+            if (isElementInViewport(el, self.options.viewportFactor)) {
+                self.animate(el);
+            }
+        });
+        this.scrolled = false;
+		this.tested = true;
+    },
+  }; // end scrollReveal.prototype
+
+  document.addEventListener("DOMContentLoaded", function (evt) {
+    window.scrollReveal = new scrollReveal();
+  });
+
+})(window);
diff --git a/tests/resources/userdiff/before/file.javascript b/tests/resources/userdiff/before/file.javascript
new file mode 100644
index 000000000..b9f1286e5
--- /dev/null
+++ b/tests/resources/userdiff/before/file.javascript
@@ -0,0 +1,109 @@
+/*
+  Some code extracted from https://github.com/julianlloyd/scrollReveal.js
+  which happens to be a trending Javascript repo with an MIT license at
+  the time I was working on Javascript userdiff support in libgit2
+
+  I extracted just some of the code, so I suspect this is no longer valid
+  Javascript code, but it contains enough example patterns to work.
+*/
+;(function (window) {
+
+  'use strict';
+
+  var docElem = window.document.documentElement;
+
+  function getViewportH () {
+    var client = docElem['clientHeight'],
+      inner = window['innerHeight'];
+
+    return (client < inner) ? inner : client;
+  }
+
+  function getOffset (el) {
+    var offsetTop = 0,
+        offsetLeft = 0;
+
+    do {
+      if (!isNaN(el.offsetTop)) {
+        offsetTop += el.offsetTop;
+      }
+      if (!isNaN(el.offsetLeft)) {
+        offsetLeft += el.offsetLeft;
+      }
+    } while (el = el.offsetParent)
+
+    return {
+      top: offsetTop,
+      left: offsetLeft
+    }
+  }
+
+  function isElementInViewport (el, h) {
+    var scrolled = window.pageYOffset,
+        viewed = scrolled + getViewportH(),
+        elH = el.offsetHeight,
+        elTop = getOffset(el).top,
+        elBottom = elTop + elH,
+        h = h || 0;
+
+    return (elTop + elH * h) <= viewed && (elBottom) >= scrolled;
+  }
+
+  scrollReveal.prototype = {
+
+    _init: function () {
+
+      var self = this;
+
+      this.elems = Array.prototype.slice.call(docElem.querySelectorAll('[data-scrollReveal]'));
+      this.scrolled = false;
+
+  //  Initialize all scrollreveals, triggering all
+  //  reveals on visible elements.
+      this.elems.forEach(function (el, i) {
+        self.animate(el);
+      });
+
+      var scrollHandler = function () {
+        if (!self.scrolled) {
+          self.scrolled = true;
+          setTimeout(function () {
+            self._scrollPage();
+          }, 60);
+        }
+      };
+
+      var resizeHandler = function () {
+        function delayed() {
+          self._scrollPage();
+          self.resizeTimeout = null;
+        }
+        if (self.resizeTimeout) {
+          clearTimeout(self.resizeTimeout);
+        }
+        self.resizeTimeout = setTimeout(delayed, 200);
+      };
+
+      window.addEventListener('scroll', scrollHandler, false);
+      window.addEventListener('resize', resizeHandler, false);
+    },
+
+    /*=============================================================================*/
+
+    _scrollPage: function () {
+        var self = this;
+
+        this.elems.forEach(function (el, i) {
+            if (isElementInViewport(el, self.options.viewportFactor)) {
+                self.animate(el);
+            }
+        });
+        this.scrolled = false;
+    },
+  }; // end scrollReveal.prototype
+
+  document.addEventListener("DOMContentLoaded", function (evt) {
+    window.scrollReveal = new scrollReveal();
+  });
+
+})(window);
diff --git a/tests/resources/userdiff/expected/driver/diff.javascript b/tests/resources/userdiff/expected/driver/diff.javascript
new file mode 100644
index 000000000..4e65d0746
--- /dev/null
+++ b/tests/resources/userdiff/expected/driver/diff.javascript
@@ -0,0 +1,40 @@
+diff --git a/files/file.javascript b/files/file.javascript
+index b9f1286..7cd3c5a 100644
+--- a/files/file.javascript
++++ b/files/file.javascript
+@@ -16,3 +16,4 @@ function getViewportH ()
+     var client = docElem['clientHeight'],
+-      inner = window['innerHeight'];
++      inner = window['innerHeight'],
++      sample = window['otherProperty'];
+ 
+@@ -27,3 +28,3 @@ function getOffset (el)
+       if (!isNaN(el.offsetTop)) {
+-        offsetTop += el.offsetTop;
++        offsetTop += el.offsetTop + 1;
+       }
+@@ -43,8 +44,7 @@ function isElementInViewport (el, h)
+         viewed = scrolled + getViewportH(),
+-        elH = el.offsetHeight,
+         elTop = getOffset(el).top,
+-        elBottom = elTop + elH,
++        elBottom = elTop + el.offsetHeight,
+         h = h || 0;
+ 
+-    return (elTop + elH * h) <= viewed && (elBottom) >= scrolled;
++    return (elTop + el.offsetHeight * h) <= viewed && (elBottom) >= scrolled;
+   }
+@@ -60,4 +60,2 @@ _init: function ()
+ 
+-  //  Initialize all scrollreveals, triggering all
+-  //  reveals on visible elements.
+       this.elems.forEach(function (el, i) {
+@@ -71,3 +69,3 @@ var scrollHandler = function ()
+             self._scrollPage();
+-          }, 60);
++          }, 61);
+         }
+@@ -101,2 +99,3 @@ _scrollPage: function ()
+         this.scrolled = false;
++		this.tested = true;
+     },
diff --git a/tests/resources/userdiff/expected/nodriver/diff.javascript b/tests/resources/userdiff/expected/nodriver/diff.javascript
new file mode 100644
index 000000000..69afe4fd8
--- /dev/null
+++ b/tests/resources/userdiff/expected/nodriver/diff.javascript
@@ -0,0 +1,40 @@
+diff --git a/files/file.javascript b/files/file.javascript
+index b9f1286..7cd3c5a 100644
+--- a/files/file.javascript
++++ b/files/file.javascript
+@@ -16,3 +16,4 @@
+     var client = docElem['clientHeight'],
+-      inner = window['innerHeight'];
++      inner = window['innerHeight'],
++      sample = window['otherProperty'];
+ 
+@@ -27,3 +28,3 @@
+       if (!isNaN(el.offsetTop)) {
+-        offsetTop += el.offsetTop;
++        offsetTop += el.offsetTop + 1;
+       }
+@@ -43,8 +44,7 @@
+         viewed = scrolled + getViewportH(),
+-        elH = el.offsetHeight,
+         elTop = getOffset(el).top,
+-        elBottom = elTop + elH,
++        elBottom = elTop + el.offsetHeight,
+         h = h || 0;
+ 
+-    return (elTop + elH * h) <= viewed && (elBottom) >= scrolled;
++    return (elTop + el.offsetHeight * h) <= viewed && (elBottom) >= scrolled;
+   }
+@@ -60,4 +60,2 @@
+ 
+-  //  Initialize all scrollreveals, triggering all
+-  //  reveals on visible elements.
+       this.elems.forEach(function (el, i) {
+@@ -71,3 +69,3 @@
+             self._scrollPage();
+-          }, 60);
++          }, 61);
+         }
+@@ -101,2 +99,3 @@
+         this.scrolled = false;
++		this.tested = true;
+     },
diff --git a/tests/resources/userdiff/files/file.javascript b/tests/resources/userdiff/files/file.javascript
new file mode 100644
index 000000000..7cd3c5a8a
--- /dev/null
+++ b/tests/resources/userdiff/files/file.javascript
@@ -0,0 +1,108 @@
+/*
+  Some code extracted from https://github.com/julianlloyd/scrollReveal.js
+  which happens to be a trending Javascript repo with an MIT license at
+  the time I was working on Javascript userdiff support in libgit2
+
+  I extracted just some of the code, so I suspect this is no longer valid
+  Javascript code, but it contains enough example patterns to work.
+*/
+;(function (window) {
+
+  'use strict';
+
+  var docElem = window.document.documentElement;
+
+  function getViewportH () {
+    var client = docElem['clientHeight'],
+      inner = window['innerHeight'],
+      sample = window['otherProperty'];
+
+    return (client < inner) ? inner : client;
+  }
+
+  function getOffset (el) {
+    var offsetTop = 0,
+        offsetLeft = 0;
+
+    do {
+      if (!isNaN(el.offsetTop)) {
+        offsetTop += el.offsetTop + 1;
+      }
+      if (!isNaN(el.offsetLeft)) {
+        offsetLeft += el.offsetLeft;
+      }
+    } while (el = el.offsetParent)
+
+    return {
+      top: offsetTop,
+      left: offsetLeft
+    }
+  }
+
+  function isElementInViewport (el, h) {
+    var scrolled = window.pageYOffset,
+        viewed = scrolled + getViewportH(),
+        elTop = getOffset(el).top,
+        elBottom = elTop + el.offsetHeight,
+        h = h || 0;
+
+    return (elTop + el.offsetHeight * h) <= viewed && (elBottom) >= scrolled;
+  }
+
+  scrollReveal.prototype = {
+
+    _init: function () {
+
+      var self = this;
+
+      this.elems = Array.prototype.slice.call(docElem.querySelectorAll('[data-scrollReveal]'));
+      this.scrolled = false;
+
+      this.elems.forEach(function (el, i) {
+        self.animate(el);
+      });
+
+      var scrollHandler = function () {
+        if (!self.scrolled) {
+          self.scrolled = true;
+          setTimeout(function () {
+            self._scrollPage();
+          }, 61);
+        }
+      };
+
+      var resizeHandler = function () {
+        function delayed() {
+          self._scrollPage();
+          self.resizeTimeout = null;
+        }
+        if (self.resizeTimeout) {
+          clearTimeout(self.resizeTimeout);
+        }
+        self.resizeTimeout = setTimeout(delayed, 200);
+      };
+
+      window.addEventListener('scroll', scrollHandler, false);
+      window.addEventListener('resize', resizeHandler, false);
+    },
+
+    /*=============================================================================*/
+
+    _scrollPage: function () {
+        var self = this;
+
+        this.elems.forEach(function (el, i) {
+            if (isElementInViewport(el, self.options.viewportFactor)) {
+                self.animate(el);
+            }
+        });
+        this.scrolled = false;
+		this.tested = true;
+    },
+  }; // end scrollReveal.prototype
+
+  document.addEventListener("DOMContentLoaded", function (evt) {
+    window.scrollReveal = new scrollReveal();
+  });
+
+})(window);
-- 
cgit v1.2.3


From daebb598690c47600cf033be77acaad1ae8c4a70 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 27 Jan 2014 14:57:03 -0800
Subject: Add PHP tests and fix bug in PHP builtin driver

---
 src/userdiff.h                                     |   2 +-
 tests/resources/userdiff/.gitted/index             | Bin 912 -> 1336 bytes
 tests/resources/userdiff/.gitted/info/refs         |   2 +-
 .../resources/userdiff/.gitted/objects/info/packs  |   2 +-
 ...ck-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx | Bin 2192 -> 0 bytes
 ...k-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack | Bin 5697 -> 0 bytes
 ...ck-1652578900ac63564f2a24b9714529821276ceb9.idx | Bin 0 -> 2500 bytes
 ...k-1652578900ac63564f2a24b9714529821276ceb9.pack | Bin 0 -> 7102 bytes
 tests/resources/userdiff/.gitted/packed-refs       |   2 +-
 .../userdiff/.gitted/refs/dummy-marker.txt         |   0
 tests/resources/userdiff/after/file.php            |  50 +++++++++++++++++++++
 tests/resources/userdiff/before/file.php           |  49 ++++++++++++++++++++
 tests/resources/userdiff/expected/driver/diff.php  |  26 +++++++++++
 .../resources/userdiff/expected/nodriver/diff.php  |  26 +++++++++++
 tests/resources/userdiff/files/file.php            |  50 +++++++++++++++++++++
 15 files changed, 205 insertions(+), 4 deletions(-)
 delete mode 100644 tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx
 delete mode 100644 tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack
 create mode 100644 tests/resources/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.idx
 create mode 100644 tests/resources/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.pack
 create mode 100644 tests/resources/userdiff/.gitted/refs/dummy-marker.txt
 create mode 100644 tests/resources/userdiff/after/file.php
 create mode 100644 tests/resources/userdiff/before/file.php
 create mode 100644 tests/resources/userdiff/expected/driver/diff.php
 create mode 100644 tests/resources/userdiff/expected/nodriver/diff.php
 create mode 100644 tests/resources/userdiff/files/file.php

diff --git a/src/userdiff.h b/src/userdiff.h
index 2257035ac..9318b5476 100644
--- a/src/userdiff.h
+++ b/src/userdiff.h
@@ -186,7 +186,7 @@ PATTERNS("csharp",
 	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
 
 PATTERNS("php",
-	 "^[ \t]*((public|private|protected|static|final)[ \t]+)*((class|function)[ \t].*)$",
+	 "^[ \t]*(((public|private|protected|static|final)[ \t]+)*((class|function)[ \t].*))$",
 	 /* -- */
 	 "[a-zA-Z_][a-zA-Z0-9_]*"
 	 "|[-+0-9.e]+[fFlL]?|0[xX]?[0-9a-fA-F]+[lL]?"
diff --git a/tests/resources/userdiff/.gitted/index b/tests/resources/userdiff/.gitted/index
index df041cf72..b69d5cfb1 100644
Binary files a/tests/resources/userdiff/.gitted/index and b/tests/resources/userdiff/.gitted/index differ
diff --git a/tests/resources/userdiff/.gitted/info/refs b/tests/resources/userdiff/.gitted/info/refs
index 261695f80..b0743141d 100644
--- a/tests/resources/userdiff/.gitted/info/refs
+++ b/tests/resources/userdiff/.gitted/info/refs
@@ -1 +1 @@
-802734c801bffc466d69876bc4814f747aaac4fe	refs/heads/master
+60e3f7b244a5305e2c9fa4ef0e897f3b14f3b8dd	refs/heads/master
diff --git a/tests/resources/userdiff/.gitted/objects/info/packs b/tests/resources/userdiff/.gitted/objects/info/packs
index 6970fd7b0..0c5fc2a30 100644
--- a/tests/resources/userdiff/.gitted/objects/info/packs
+++ b/tests/resources/userdiff/.gitted/objects/info/packs
@@ -1,2 +1,2 @@
-P pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack
+P pack-1652578900ac63564f2a24b9714529821276ceb9.pack
 
diff --git a/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx b/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx
deleted file mode 100644
index 6d723f525..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.idx and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack b/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack
deleted file mode 100644
index 5b263e27d..000000000
Binary files a/tests/resources/userdiff/.gitted/objects/pack/pack-03f78c35e3ca74fffd9d6c2b6dcd60d6ab6a614a.pack and /dev/null differ
diff --git a/tests/resources/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.idx b/tests/resources/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.idx
new file mode 100644
index 000000000..6f4381cc7
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.idx differ
diff --git a/tests/resources/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.pack b/tests/resources/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.pack
new file mode 100644
index 000000000..39bd1d8f0
Binary files /dev/null and b/tests/resources/userdiff/.gitted/objects/pack/pack-1652578900ac63564f2a24b9714529821276ceb9.pack differ
diff --git a/tests/resources/userdiff/.gitted/packed-refs b/tests/resources/userdiff/.gitted/packed-refs
index 6d24ee4ed..802f67ce0 100644
--- a/tests/resources/userdiff/.gitted/packed-refs
+++ b/tests/resources/userdiff/.gitted/packed-refs
@@ -1,2 +1,2 @@
 # pack-refs with: peeled fully-peeled 
-802734c801bffc466d69876bc4814f747aaac4fe refs/heads/master
+60e3f7b244a5305e2c9fa4ef0e897f3b14f3b8dd refs/heads/master
diff --git a/tests/resources/userdiff/.gitted/refs/dummy-marker.txt b/tests/resources/userdiff/.gitted/refs/dummy-marker.txt
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/resources/userdiff/after/file.php b/tests/resources/userdiff/after/file.php
new file mode 100644
index 000000000..967d6466c
--- /dev/null
+++ b/tests/resources/userdiff/after/file.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Faker;
+
+/**
+ * Proxy for other generators, to return only unique values. Works with
+ * Faker\Generator\Base->unique()
+ */
+class UniqueGenerator
+{
+    protected $generator;
+    protected $maxRetries;
+	protected $moreStuff;
+    protected $uniques = array();
+
+    public function __construct(Generator $generator, $maxRetries)
+    {
+        $this->generator = $generator;
+        $this->maxRetries = $maxRetries + 1;
+    }
+
+    /**
+     * Catch and proxy all generator calls but return only unique values
+     */
+    public function __get($attribute)
+    {
+        return $this->__call($attribute, array());
+    }
+
+    /**
+     * Catch and proxy all generator calls with arguments but return only unique values
+     */
+    public function __call($name, $arguments)
+    {
+        $i = 0;
+        if (!isset($this->uniques[$name])) {
+            $this->uniques[$name] = array();
+        }
+        do {
+            $res = call_user_func_array(array($this->generator, $name), $arguments);
+            $i++;
+            if ($i >= $this->maxRetries) {
+                throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries));
+            }
+        } while (in_array($res, $this->uniques[$name]));
+        $this->uniques[$name][]= $res;
+
+        return $res;
+    }
+}
diff --git a/tests/resources/userdiff/before/file.php b/tests/resources/userdiff/before/file.php
new file mode 100644
index 000000000..63250ad01
--- /dev/null
+++ b/tests/resources/userdiff/before/file.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Faker;
+
+/**
+ * Proxy for other generators, to return only unique values. Works with
+ * Faker\Generator\Base->unique()
+ */
+class UniqueGenerator
+{
+    protected $generator;
+    protected $maxRetries;
+    protected $uniques = array();
+
+    public function __construct(Generator $generator, $maxRetries)
+    {
+        $this->generator = $generator;
+        $this->maxRetries = $maxRetries;
+    }
+
+    /**
+     * Catch and proxy all generator calls but return only unique values
+     */
+    public function __get($attribute)
+    {
+        return $this->__call($attribute, array());
+    }
+
+    /**
+     * Catch and proxy all generator calls with arguments but return only unique values
+     */
+    public function __call($name, $arguments)
+    {
+        if (!isset($this->uniques[$name])) {
+            $this->uniques[$name] = array();
+        }
+        $i = 0;
+        do {
+            $res = call_user_func_array(array($this->generator, $name), $arguments);
+            $i++;
+            if ($i > $this->maxRetries) {
+                throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries));
+            }
+        } while (in_array($res, $this->uniques[$name]));
+        $this->uniques[$name][]= $res;
+
+        return $res;
+    }
+}
diff --git a/tests/resources/userdiff/expected/driver/diff.php b/tests/resources/userdiff/expected/driver/diff.php
new file mode 100644
index 000000000..9711b5b3e
--- /dev/null
+++ b/tests/resources/userdiff/expected/driver/diff.php
@@ -0,0 +1,26 @@
+diff --git a/files/file.php b/files/file.php
+index 63250ad..967d646 100644
+--- a/files/file.php
++++ b/files/file.php
+@@ -12,2 +12,3 @@ class UniqueGenerator
+     protected $maxRetries;
++	protected $moreStuff;
+     protected $uniques = array();
+@@ -17,3 +18,3 @@ public function __construct(Generator $generator, $maxRetries)
+         $this->generator = $generator;
+-        $this->maxRetries = $maxRetries;
++        $this->maxRetries = $maxRetries + 1;
+     }
+@@ -33,10 +34,10 @@ public function __call($name, $arguments)
+     {
++        $i = 0;
+         if (!isset($this->uniques[$name])) {
+             $this->uniques[$name] = array();
+         }
+-        $i = 0;
+         do {
+             $res = call_user_func_array(array($this->generator, $name), $arguments);
+             $i++;
+-            if ($i > $this->maxRetries) {
++            if ($i >= $this->maxRetries) {
+                 throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries));
diff --git a/tests/resources/userdiff/expected/nodriver/diff.php b/tests/resources/userdiff/expected/nodriver/diff.php
new file mode 100644
index 000000000..e77c094aa
--- /dev/null
+++ b/tests/resources/userdiff/expected/nodriver/diff.php
@@ -0,0 +1,26 @@
+diff --git a/files/file.php b/files/file.php
+index 63250ad..967d646 100644
+--- a/files/file.php
++++ b/files/file.php
+@@ -12,2 +12,3 @@ class UniqueGenerator
+     protected $maxRetries;
++	protected $moreStuff;
+     protected $uniques = array();
+@@ -17,3 +18,3 @@ class UniqueGenerator
+         $this->generator = $generator;
+-        $this->maxRetries = $maxRetries;
++        $this->maxRetries = $maxRetries + 1;
+     }
+@@ -33,10 +34,10 @@ class UniqueGenerator
+     {
++        $i = 0;
+         if (!isset($this->uniques[$name])) {
+             $this->uniques[$name] = array();
+         }
+-        $i = 0;
+         do {
+             $res = call_user_func_array(array($this->generator, $name), $arguments);
+             $i++;
+-            if ($i > $this->maxRetries) {
++            if ($i >= $this->maxRetries) {
+                 throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries));
diff --git a/tests/resources/userdiff/files/file.php b/tests/resources/userdiff/files/file.php
new file mode 100644
index 000000000..967d6466c
--- /dev/null
+++ b/tests/resources/userdiff/files/file.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Faker;
+
+/**
+ * Proxy for other generators, to return only unique values. Works with
+ * Faker\Generator\Base->unique()
+ */
+class UniqueGenerator
+{
+    protected $generator;
+    protected $maxRetries;
+	protected $moreStuff;
+    protected $uniques = array();
+
+    public function __construct(Generator $generator, $maxRetries)
+    {
+        $this->generator = $generator;
+        $this->maxRetries = $maxRetries + 1;
+    }
+
+    /**
+     * Catch and proxy all generator calls but return only unique values
+     */
+    public function __get($attribute)
+    {
+        return $this->__call($attribute, array());
+    }
+
+    /**
+     * Catch and proxy all generator calls with arguments but return only unique values
+     */
+    public function __call($name, $arguments)
+    {
+        $i = 0;
+        if (!isset($this->uniques[$name])) {
+            $this->uniques[$name] = array();
+        }
+        do {
+            $res = call_user_func_array(array($this->generator, $name), $arguments);
+            $i++;
+            if ($i >= $this->maxRetries) {
+                throw new \OverflowException(sprintf('Maximum retries of %d reached without finding a unique value', $this->maxRetries));
+            }
+        } while (in_array($res, $this->uniques[$name]));
+        $this->uniques[$name][]= $res;
+
+        return $res;
+    }
+}
-- 
cgit v1.2.3


From e7c16943f4551830a148995640f87bec2fe08e8f Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Tue, 28 Jan 2014 19:39:14 +0100
Subject: Add `git_graph_descendant_of`.

---
 include/git2/graph.h        | 14 ++++++++++++++
 src/graph.c                 | 14 ++++++++++++++
 tests/graph/descendant_of.c | 47 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 75 insertions(+)
 create mode 100644 tests/graph/descendant_of.c

diff --git a/include/git2/graph.h b/include/git2/graph.h
index a2710219e..c997d8ca9 100644
--- a/include/git2/graph.h
+++ b/include/git2/graph.h
@@ -36,6 +36,20 @@ GIT_BEGIN_DECL
  */
 GIT_EXTERN(int) git_graph_ahead_behind(size_t *ahead, size_t *behind, git_repository *repo, const git_oid *local, const git_oid *upstream);
 
+
+/**
+ * Determine if a commit is the descendant of another commit.
+ *
+ * @param commit a previously loaded commit.
+ * @param ancestor a potential ancestor commit.
+ * @return 1 if the given commit is a descendant of the potential ancestor,
+ * 0 if not, error code otherwise.
+ */
+GIT_EXTERN(int) git_graph_descendant_of(
+	git_repository *repo,
+	const git_oid *commit,
+	const git_oid *ancestor);
+
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/src/graph.c b/src/graph.c
index 277f588ca..f39af5ed5 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -176,3 +176,17 @@ on_error:
 	git_revwalk_free(walk);
 	return -1;
 }
+
+int git_graph_descendant_of(git_repository *repo, const git_oid *commit, const git_oid *ancestor)
+{
+	git_oid merge_base;
+	int error;
+
+	if (git_oid_equal(commit, ancestor))
+		return 0;
+
+	if ((error = git_merge_base(&merge_base, repo, commit, ancestor) < 0))
+		return error;
+
+	return git_oid_equal(&merge_base, ancestor);
+}
diff --git a/tests/graph/descendant_of.c b/tests/graph/descendant_of.c
new file mode 100644
index 000000000..ffdd0cfc8
--- /dev/null
+++ b/tests/graph/descendant_of.c
@@ -0,0 +1,47 @@
+#include "clar_libgit2.h"
+
+static git_repository *_repo;
+static git_commit *commit;
+
+void test_graph_descendant_of__initialize(void)
+{
+	git_oid oid;
+
+	cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
+
+	git_oid_fromstr(&oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
+}
+
+void test_graph_descendant_of__cleanup(void)
+{
+	git_commit_free(commit);
+	commit = NULL;
+
+	git_repository_free(_repo);
+	_repo = NULL;
+}
+
+void test_graph_descendant_of__returns_correct_result(void)
+{
+	git_commit *other;
+
+	cl_assert_equal_i(0, git_graph_descendant_of(_repo, git_commit_id(commit), git_commit_id(commit)));
+
+
+	cl_git_pass(git_commit_nth_gen_ancestor(&other, commit, 1));
+
+	cl_assert_equal_i(1, git_graph_descendant_of(_repo, git_commit_id(commit), git_commit_id(other)));
+	cl_assert_equal_i(0, git_graph_descendant_of(_repo, git_commit_id(other), git_commit_id(commit)));
+
+	git_commit_free(other);
+
+
+	cl_git_pass(git_commit_nth_gen_ancestor(&other, commit, 3));
+
+	cl_assert_equal_i(1, git_graph_descendant_of(_repo, git_commit_id(commit), git_commit_id(other)));
+	cl_assert_equal_i(0, git_graph_descendant_of(_repo, git_commit_id(other), git_commit_id(commit)));
+
+	git_commit_free(other);
+
+}
-- 
cgit v1.2.3


From 96f12e709b60e2d570c804c49a6364e94fd0e4b0 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 29 Jan 2014 12:50:42 -0800
Subject: Don't strcmp a git_buf, strcmp its char *

---
 tests/network/remote/remotes.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/network/remote/remotes.c b/tests/network/remote/remotes.c
index 09963e8ef..fe40d1085 100644
--- a/tests/network/remote/remotes.c
+++ b/tests/network/remote/remotes.c
@@ -233,7 +233,7 @@ void test_network_remote_remotes__transform(void)
 	git_buf ref = GIT_BUF_INIT;
 
 	cl_git_pass(git_refspec_transform(&ref, _refspec, "refs/heads/master"));
-	cl_assert_equal_s(ref, "refs/remotes/test/master");
+	cl_assert_equal_s(ref.ptr, "refs/remotes/test/master");
 	git_buf_free(&ref);
 }
 
-- 
cgit v1.2.3


From 95fbedcd8eaaff2747196e20abd959596baf7e98 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 28 Jan 2014 16:22:37 -0800
Subject: Add test for blob/tree name collisions in index

---
 tests/index/collision.c | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 tests/index/collision.c

diff --git a/tests/index/collision.c b/tests/index/collision.c
new file mode 100644
index 000000000..957418870
--- /dev/null
+++ b/tests/index/collision.c
@@ -0,0 +1,42 @@
+#include "clar_libgit2.h"
+#include "git2/repository.h"
+#include "git2/index.h"
+
+git_repository *repo = NULL;
+
+void test_index_collision__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+	repo = NULL;
+}
+
+void test_index_collision__add(void)
+{
+	git_index *index;
+	git_index_entry entry;
+	git_oid tree_id;
+	git_tree *tree;
+
+	repo = cl_git_sandbox_init("empty_standard_repo");
+	cl_git_pass(git_repository_index(&index, repo));
+
+	memset(&entry, 0, sizeof(entry));
+	entry.ctime.seconds = 12346789;
+	entry.mtime.seconds = 12346789;
+	entry.mode  = 0100644;
+	entry.file_size = 0;
+	git_oid_fromstr(&entry.id, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391");
+
+	entry.path = "a/b";
+	cl_git_pass(git_index_add(index, &entry));
+
+	/* create a tree/blob collision */
+	entry.path = "a/b/c";
+	cl_git_fail(git_index_add(index, &entry));
+
+	cl_git_pass(git_index_write_tree(&tree_id, index));
+	cl_git_pass(git_tree_lookup(&tree, repo, &tree_id));
+
+	git_tree_free(tree);
+	git_index_free(index);
+}
-- 
cgit v1.2.3


From 53bec813a81cb0e1e970df69281ab4a3e6c2a47c Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Wed, 29 Jan 2014 18:17:08 +0100
Subject: index: Compare with given len

---
 src/index.c    | 136 ++++++++++++++++++++++++++++++++++++++++++++++++++++-----
 src/index.h    |   2 +-
 src/pathspec.c |   2 +-
 3 files changed, 127 insertions(+), 13 deletions(-)

diff --git a/src/index.c b/src/index.c
index d58968454..e16529d74 100644
--- a/src/index.c
+++ b/src/index.c
@@ -90,6 +90,7 @@ struct entry_long {
 
 struct entry_srch_key {
 	const char *path;
+	int path_len;
 	int stage;
 };
 
@@ -109,14 +110,24 @@ static int index_srch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
 	const git_index_entry *entry = array_member;
-	int ret;
+	int cmp, len1, len2, len;
 
-	ret = strcmp(srch_key->path, entry->path);
+	len1 = srch_key->path_len;
+	len2 = strlen(entry->path);
+	len = len1 < len2 ? len1 : len2;
 
-	if (ret == 0 && srch_key->stage != GIT_INDEX_STAGE_ANY)
-		ret = srch_key->stage - GIT_IDXENTRY_STAGE(entry);
+	cmp = memcmp(srch_key->path, entry->path, len);
+	if (cmp)
+		return cmp;
+	if (len1 < len2)
+		return -1;
+	if (len1 > len2)
+		return 1;
 
-	return ret;
+	if (srch_key->stage != GIT_INDEX_STAGE_ANY)
+		return srch_key->stage - GIT_IDXENTRY_STAGE(entry);
+
+	return 0;
 }
 
 static int index_isrch(const void *key, const void *array_member)
@@ -579,7 +590,7 @@ const git_index_entry *git_index_get_bypath(
 
 	git_vector_sort(&index->entries);
 
-	if (git_index__find(&pos, index, path, stage) < 0) {
+	if (git_index__find(&pos, index, path, strlen(path), stage) < 0) {
 		giterr_set(GITERR_INDEX, "Index does not contain %s", path);
 		return NULL;
 	}
@@ -701,6 +712,106 @@ static git_index_entry *index_entry_dup(const git_index_entry *source_entry)
 	return entry;
 }
 
+#if 0
+static int has_file_name(git_index *index,
+	 const git_index_entry *entry, int pos, int ok_to_replace)
+{
+	int retval = 0;
+	int len = ce_namelen(ce);
+	int stage = ce_stage(ce);
+	const char *name = ce->name;
+
+	while (pos < istate->cache_nr) {
+		struct cache_entry *p = istate->cache[pos++];
+
+		if (len >= ce_namelen(p))
+			break;
+		if (memcmp(name, p->name, len))
+			break;
+		if (ce_stage(p) != stage)
+			continue;
+		if (p->name[len] != '/')
+			continue;
+		if (p->ce_flags & CE_REMOVE)
+			continue;
+		retval = -1;
+		if (!ok_to_replace)
+			break;
+		remove_index_entry_at(istate, --pos);
+	}
+	return retval;
+}
+
+/*
+ * Do we have another file with a pathname that is a proper
+ * subset of the name we're trying to add?
+ */
+static int has_dir_name(git_index *index,
+		const git_index_entry *entry, int ok_to_replace)
+{
+	int retval = 0;
+	int stage = ce_stage(ce);
+	const char *name = ce->name;
+	const char *slash = name + ce_namelen(ce);
+
+	for (;;) {
+		int len;
+
+		for (;;) {
+			if (*--slash == '/')
+				break;
+			if (slash <= ce->name)
+				return retval;
+		}
+		len = slash - name;
+
+		pos = index_name_stage_pos(istate, name, len, stage);
+		if (pos >= 0) {
+			/*
+			 * Found one, but not so fast.  This could
+			 * be a marker that says "I was here, but
+			 * I am being removed".  Such an entry is
+			 * not a part of the resulting tree, and
+			 * it is Ok to have a directory at the same
+			 * path.
+			 */
+			if (!(istate->cache[pos]->ce_flags & CE_REMOVE)) {
+				retval = -1;
+				if (!ok_to_replace)
+					break;
+				remove_index_entry_at(istate, pos);
+				continue;
+			}
+		}
+		else
+			pos = -pos-1;
+
+		/*
+		 * Trivial optimization: if we find an entry that
+		 * already matches the sub-directory, then we know
+		 * we're ok, and we can exit.
+		 */
+		while (pos < istate->cache_nr) {
+			struct cache_entry *p = istate->cache[pos];
+			if ((ce_namelen(p) <= len) ||
+			    (p->name[len] != '/') ||
+			    memcmp(p->name, name, len))
+				break; /* not our subdirectory */
+			if (ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))
+				/*
+				 * p is at the same stage as our entry, and
+				 * is a subdirectory of what we are looking
+				 * at, so we cannot have conflicts at our
+				 * level or anything shorter.
+				 */
+				return retval;
+			pos++;
+		}
+	}
+	return retval;
+}
+#endif
+
 static int index_insert(git_index *index, git_index_entry *entry, int replace)
 {
 	size_t path_length, position;
@@ -720,9 +831,9 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace)
 
 	/* look if an entry with this path already exists */
 	if (!git_index__find(
-			&position, index, entry->path, GIT_IDXENTRY_STAGE(entry))) {
+			&position, index, entry->path, strlen(entry->path),
+			GIT_IDXENTRY_STAGE(entry))) {
 		existing = (git_index_entry **)&index->entries.contents[position];
-
 		/* update filemode to existing values if stat is not trusted */
 		entry->mode = index_merge_mode(index, *existing, entry->mode);
 	}
@@ -832,7 +943,7 @@ int git_index_remove(git_index *index, const char *path, int stage)
 
 	git_vector_sort(&index->entries);
 
-	if (git_index__find(&position, index, path, stage) < 0) {
+	if (git_index__find(&position, index, path, strlen(path), stage) < 0) {
 		giterr_set(GITERR_INDEX, "Index does not contain %s at stage %d",
 			path, stage);
 		return GIT_ENOTFOUND;
@@ -889,13 +1000,14 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 }
 
 int git_index__find(
-	size_t *at_pos, git_index *index, const char *path, int stage)
+	size_t *at_pos, git_index *index, const char *path, int path_len, int stage)
 {
 	struct entry_srch_key srch_key;
 
 	assert(path);
 
 	srch_key.path = path;
+	srch_key.path_len = path_len;
 	srch_key.stage = stage;
 
 	return git_vector_bsearch2(
@@ -937,6 +1049,7 @@ size_t git_index__prefix_position(git_index *index, const char *path)
 	size_t pos;
 
 	srch_key.path = path;
+	srch_key.path_len = strlen(path);
 	srch_key.stage = 0;
 
 	git_vector_sort(&index->entries);
@@ -1991,6 +2104,7 @@ static int read_tree_cb(
 		struct entry_srch_key skey;
 
 		skey.path = path.ptr;
+		skey.path_len = strlen(path.ptr);
 		skey.stage = 0;
 
 		if (!git_vector_bsearch2(
@@ -2109,7 +2223,7 @@ int git_index_add_all(
 		/* skip ignored items that are not already in the index */
 		if ((flags & GIT_INDEX_ADD_FORCE) == 0 &&
 			git_iterator_current_is_ignored(wditer) &&
-			git_index__find(&existing, index, wd->path, 0) < 0)
+			git_index__find(&existing, index, wd->path, strlen(wd->path), 0) < 0)
 			continue;
 
 		/* issue notification callback if requested */
diff --git a/src/index.h b/src/index.h
index 4c448fabf..3dea4aa14 100644
--- a/src/index.h
+++ b/src/index.h
@@ -56,7 +56,7 @@ extern int git_index_entry__cmp(const void *a, const void *b);
 extern int git_index_entry__cmp_icase(const void *a, const void *b);
 
 extern int git_index__find(
-	size_t *at_pos, git_index *index, const char *path, int stage);
+	size_t *at_pos, git_index *index, const char *path, int path_len, int stage);
 
 extern void git_index__set_ignore_case(git_index *index, bool ignore_case);
 
diff --git a/src/pathspec.c b/src/pathspec.c
index d6ce09c02..bee320576 100644
--- a/src/pathspec.c
+++ b/src/pathspec.c
@@ -445,7 +445,7 @@ static int pathspec_match_from_iterator(
 		/* check if path is ignored and untracked */
 		if (index != NULL &&
 			git_iterator_current_is_ignored(iter) &&
-			git_index__find(NULL, index, entry->path, GIT_INDEX_STAGE_ANY) < 0)
+			git_index__find(NULL, index, entry->path, strlen(entry->path), GIT_INDEX_STAGE_ANY) < 0)
 			continue;
 
 		/* mark the matched pattern as used */
-- 
cgit v1.2.3


From 1eefd3561225bfdedfe52a7e9faa6e7c88d7a046 Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Wed, 29 Jan 2014 18:44:29 +0100
Subject: index: Implement folder-file checks

---
 src/index.c | 102 +++++++++++++++++++++++++++++-------------------------------
 1 file changed, 50 insertions(+), 52 deletions(-)

diff --git a/src/index.c b/src/index.c
index e16529d74..aa30f9d32 100644
--- a/src/index.c
+++ b/src/index.c
@@ -712,32 +712,29 @@ static git_index_entry *index_entry_dup(const git_index_entry *source_entry)
 	return entry;
 }
 
-#if 0
 static int has_file_name(git_index *index,
-	 const git_index_entry *entry, int pos, int ok_to_replace)
+	 const git_index_entry *entry, size_t pos, int ok_to_replace)
 {
 	int retval = 0;
-	int len = ce_namelen(ce);
-	int stage = ce_stage(ce);
-	const char *name = ce->name;
+	size_t len = strlen(entry->path);
+	int stage = GIT_IDXENTRY_STAGE(entry);
+	const char *name = entry->path;
 
-	while (pos < istate->cache_nr) {
-		struct cache_entry *p = istate->cache[pos++];
+	while (pos < index->entries.length) {
+		git_index_entry *p = index->entries.contents[pos++];
 
-		if (len >= ce_namelen(p))
+		if (len >= strlen(p->path))
 			break;
-		if (memcmp(name, p->name, len))
+		if (memcmp(name, p->path, len))
 			break;
-		if (ce_stage(p) != stage)
-			continue;
-		if (p->name[len] != '/')
+		if (GIT_IDXENTRY_STAGE(p) != stage)
 			continue;
-		if (p->ce_flags & CE_REMOVE)
+		if (p->path[len] != '/')
 			continue;
 		retval = -1;
 		if (!ok_to_replace)
 			break;
-		remove_index_entry_at(istate, --pos);
+		git_vector_remove(&index->entries, --pos);
 	}
 	return retval;
 }
@@ -750,67 +747,65 @@ static int has_dir_name(git_index *index,
 		const git_index_entry *entry, int ok_to_replace)
 {
 	int retval = 0;
-	int stage = ce_stage(ce);
-	const char *name = ce->name;
-	const char *slash = name + ce_namelen(ce);
+	int stage = GIT_IDXENTRY_STAGE(entry);
+	const char *name = entry->path;
+	const char *slash = name + strlen(name);
 
 	for (;;) {
-		int len;
+		size_t len, position;
 
 		for (;;) {
 			if (*--slash == '/')
 				break;
-			if (slash <= ce->name)
+			if (slash <= entry->path)
 				return retval;
 		}
 		len = slash - name;
 
-		pos = index_name_stage_pos(istate, name, len, stage);
-		if (pos >= 0) {
-			/*
-			 * Found one, but not so fast.  This could
-			 * be a marker that says "I was here, but
-			 * I am being removed".  Such an entry is
-			 * not a part of the resulting tree, and
-			 * it is Ok to have a directory at the same
-			 * path.
-			 */
-			if (!(istate->cache[pos]->ce_flags & CE_REMOVE)) {
-				retval = -1;
-				if (!ok_to_replace)
-					break;
-				remove_index_entry_at(istate, pos);
-				continue;
-			}
+		if (git_index__find(&position, index, name, len, stage) == 0) {
+			retval = -1;
+			if (!ok_to_replace)
+				break;
+
+			git_vector_remove(&index->entries, position);
+			continue;
 		}
-		else
-			pos = -pos-1;
 
 		/*
 		 * Trivial optimization: if we find an entry that
 		 * already matches the sub-directory, then we know
 		 * we're ok, and we can exit.
 		 */
-		while (pos < istate->cache_nr) {
-			struct cache_entry *p = istate->cache[pos];
-			if ((ce_namelen(p) <= len) ||
-			    (p->name[len] != '/') ||
-			    memcmp(p->name, name, len))
+		while (position < index->entries.length) {
+			git_index_entry *p = index->entries.contents[position];
+
+			if ((strlen(p->path) <= len) ||
+			    (p->path[len] != '/') ||
+			    memcmp(p->path, name, len))
 				break; /* not our subdirectory */
-			if (ce_stage(p) == stage && !(p->ce_flags & CE_REMOVE))
-				/*
-				 * p is at the same stage as our entry, and
-				 * is a subdirectory of what we are looking
-				 * at, so we cannot have conflicts at our
-				 * level or anything shorter.
-				 */
+
+			if (GIT_IDXENTRY_STAGE(p) == stage)
 				return retval;
-			pos++;
+
+			position++;
 		}
 	}
 	return retval;
 }
-#endif
+
+static int check_file_directory_conflict(git_index *index,
+		git_index_entry *entry, size_t pos, int ok_to_replace)
+{
+	int retval = has_file_name(index, entry, pos, ok_to_replace);
+	retval = retval + has_dir_name(index, entry, ok_to_replace);
+
+	if (retval) {
+		giterr_set(GITERR_INDEX, "'%s' appears as both a file an a directory", entry->path);
+		return -1;
+	}
+
+	return 0;
+}
 
 static int index_insert(git_index *index, git_index_entry *entry, int replace)
 {
@@ -838,6 +833,9 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace)
 		entry->mode = index_merge_mode(index, *existing, entry->mode);
 	}
 
+	if (check_file_directory_conflict(index, entry, position, replace) < 0)
+		return -1;
+
 	/* if replacing is not requested or no existing entry exists, just
 	 * insert entry at the end; the index is no longer sorted
 	 */
-- 
cgit v1.2.3


From bae8bea051806682fef48137e32f0305e94398b8 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 29 Jan 2014 12:53:01 -0800
Subject: More index collision tests

---
 tests/index/collision.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/tests/index/collision.c b/tests/index/collision.c
index 957418870..1f002e8d3 100644
--- a/tests/index/collision.c
+++ b/tests/index/collision.c
@@ -40,3 +40,67 @@ void test_index_collision__add(void)
 	git_tree_free(tree);
 	git_index_free(index);
 }
+
+void test_index_collision__add_with_highstage_1(void)
+{
+	git_index *index;
+	git_index_entry entry;
+
+	repo = cl_git_sandbox_init("empty_standard_repo");
+	cl_git_pass(git_repository_index(&index, repo));
+
+	memset(&entry, 0, sizeof(entry));
+	entry.ctime.seconds = 12346789;
+	entry.mtime.seconds = 12346789;
+	entry.mode  = 0100644;
+	entry.file_size = 0;
+	git_oid_fromstr(&entry.id, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391");
+
+	entry.path = "a/b";
+	entry.flags = (2 << GIT_IDXENTRY_STAGESHIFT);
+	cl_git_pass(git_index_add(index, &entry));
+
+	/* create a blob beneath the previous tree entry */
+	entry.path = "a/b/c";
+	entry.flags = 0;
+	cl_git_pass(git_index_add(index, &entry));
+
+	/* create another tree entry above the blob */
+	entry.path = "a/b";
+	entry.flags = (1 << GIT_IDXENTRY_STAGESHIFT);
+	cl_git_pass(git_index_add(index, &entry));
+
+	git_index_free(index);
+}
+
+void test_index_collision__add_with_highstage_2(void)
+{
+	git_index *index;
+	git_index_entry entry;
+
+	repo = cl_git_sandbox_init("empty_standard_repo");
+	cl_git_pass(git_repository_index(&index, repo));
+
+	memset(&entry, 0, sizeof(entry));
+	entry.ctime.seconds = 12346789;
+	entry.mtime.seconds = 12346789;
+	entry.mode  = 0100644;
+	entry.file_size = 0;
+	git_oid_fromstr(&entry.id, "e69de29bb2d1d6434b8b29ae775ad8c2e48c5391");
+
+	entry.path = "a/b/c";
+	entry.flags = (1 << GIT_IDXENTRY_STAGESHIFT);
+	cl_git_pass(git_index_add(index, &entry));
+
+	/* create a blob beneath the previous tree entry */
+	entry.path = "a/b/c";
+	entry.flags = (2 << GIT_IDXENTRY_STAGESHIFT);
+	cl_git_pass(git_index_add(index, &entry));
+
+	/* create another tree entry above the blob */
+	entry.path = "a/b";
+	entry.flags = (3 << GIT_IDXENTRY_STAGESHIFT);
+	cl_git_pass(git_index_add(index, &entry));
+
+	git_index_free(index);
+}
-- 
cgit v1.2.3


From b747eb1445fa54675044b6d05e892904b517239c Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 29 Jan 2014 12:55:33 -0800
Subject: Give index_isrch the same semantics as index_srch

In case insensitive index mode, we would stop at a prefixed entry,
treating the provided search key length as a substring, not the
length of the string to match.
---
 src/index.c | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/src/index.c b/src/index.c
index aa30f9d32..01321d8a1 100644
--- a/src/index.c
+++ b/src/index.c
@@ -134,14 +134,25 @@ static int index_isrch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
 	const git_index_entry *entry = array_member;
-	int ret;
+	int cmp, len1, len2, len;
 
-	ret = strcasecmp(srch_key->path, entry->path);
+	len1 = srch_key->path_len;
+	len2 = strlen(entry->path);
+	len = len1 < len2 ? len1 : len2;
 
-	if (ret == 0 && srch_key->stage != GIT_INDEX_STAGE_ANY)
-		ret = srch_key->stage - GIT_IDXENTRY_STAGE(entry);
+	cmp = strncasecmp(srch_key->path, entry->path, len);
 
-	return ret;
+	if (cmp)
+		return cmp;
+	if (len1 < len2)
+		return -1;
+	if (len1 > len2)
+		return 1;
+
+	if (srch_key->stage != GIT_INDEX_STAGE_ANY)
+		return srch_key->stage - GIT_IDXENTRY_STAGE(entry);
+
+	return 0;
 }
 
 static int index_cmp_path(const void *a, const void *b)
-- 
cgit v1.2.3


From 0972c59205a0cf29e75b45695cde5dc699983bc0 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 29 Jan 2014 13:14:00 -0800
Subject: Two-phase index merging

When three-way merging indexes, we previously changed each path
as we read them, which would lead to us adding an index entry for
'foo', then removing an index entry for 'foo/file'.  With the new
index requirements, this is not allowed.  Removing entries in the
merged index, then adding them, resolves this.  In the previous
example, we now remove 'foo/file' before adding 'foo'.
---
 src/merge.c | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/src/merge.c b/src/merge.c
index f4224955a..20cfc0e23 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2398,12 +2398,21 @@ int git_merge__indexes(git_repository *repo, git_index *index_new)
 		goto done;
 	}
 
-	/* Update the new index */
+	/* Remove removed items from the index */
 	git_vector_foreach(&paths, i, path) {
-		if ((e = git_index_get_bypath(index_new, path, 0)) != NULL)
-			error = git_index_add(index_repo, e);
-		else
-			error = git_index_remove(index_repo, path, 0);
+		if ((e = git_index_get_bypath(index_new, path, 0)) == NULL) {
+			if ((error = git_index_remove(index_repo, path, 0)) < 0 &&
+				error != GIT_ENOTFOUND)
+				goto done;
+		}
+	}
+
+	/* Add updated items to the index */
+	git_vector_foreach(&paths, i, path) {
+		if ((e = git_index_get_bypath(index_new, path, 0)) != NULL) {
+			if ((error = git_index_add(index_repo, e)) < 0)
+				goto done;
+		}
 	}
 
 	/* Add conflicts */
-- 
cgit v1.2.3


From 60306450b7a7354825660e69a30877760c48395a Mon Sep 17 00:00:00 2001
From: Sascha Cunz <sascha.cunz@gmail.com>
Date: Wed, 29 Jan 2014 23:47:20 +0000
Subject: Use relative path to set cmake module path

This has actually no effect on a "normal" build, but allows to use
libgit2 as a part of a larger project via CMake's ADD_SUBDIRECTORY()

Closes #2087
---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f1c81eb6f..611cd9eec 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,7 +15,7 @@ PROJECT(libgit2 C)
 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 
 # Add find modules to the path
-SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/cmake/Modules/")
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/Modules/")
 
 # Build options
 #
-- 
cgit v1.2.3


From 39949f0604cb009d850ff080f630ccdf7ab11715 Mon Sep 17 00:00:00 2001
From: Sascha Cunz <sascha.cunz@gmail.com>
Date: Thu, 30 Jan 2014 02:28:53 +0000
Subject: Cleanup FindIconv.cmake

Doesn't change anything. Just removes stuff that was probably missed
to remove when this was imported.
---
 cmake/Modules/FindIconv.cmake | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/cmake/Modules/FindIconv.cmake b/cmake/Modules/FindIconv.cmake
index fb6d1e210..487b2f557 100644
--- a/cmake/Modules/FindIconv.cmake
+++ b/cmake/Modules/FindIconv.cmake
@@ -4,13 +4,12 @@
 # ICONV_FOUND - system has Iconv
 # ICONV_INCLUDE_DIR - the Iconv include directory
 # ICONV_LIBRARIES - Link these to use Iconv
-# ICONV_SECOND_ARGUMENT_IS_CONST - the second argument for iconv() is const
 #
 
-IF (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
+IF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
 	# Already in cache, be silent
 	SET(ICONV_FIND_QUIETLY TRUE)
-ENDIF (ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
+ENDIF()
 
 FIND_PATH(ICONV_INCLUDE_DIR iconv.h)
 
@@ -18,25 +17,19 @@ FIND_LIBRARY(ICONV_LIBRARIES NAMES iconv libiconv libiconv-2 c PATH)
 
 IF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
 	 SET(ICONV_FOUND TRUE)
-ENDIF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
-
-set(CMAKE_REQUIRED_INCLUDES ${ICONV_INCLUDE_DIR})
-set(CMAKE_REQUIRED_LIBRARIES ${ICONV_LIBRARIES})
-set(CMAKE_REQUIRED_INCLUDES)
-set(CMAKE_REQUIRED_LIBRARIES)
+ENDIF()
 
 IF(ICONV_FOUND)
 	IF(NOT ICONV_FIND_QUIETLY)
 		MESSAGE(STATUS "Found Iconv: ${ICONV_LIBRARIES}")
 	ENDIF(NOT ICONV_FIND_QUIETLY)
-ELSE(ICONV_FOUND)
+ELSE()
 	IF(Iconv_FIND_REQUIRED)
 		MESSAGE(FATAL_ERROR "Could not find Iconv")
 	ENDIF(Iconv_FIND_REQUIRED)
-ENDIF(ICONV_FOUND)
+ENDIF()
 
 MARK_AS_ADVANCED(
 	ICONV_INCLUDE_DIR
 	ICONV_LIBRARIES
-	ICONV_SECOND_ARGUMENT_IS_CONST
 )
-- 
cgit v1.2.3


From 6e0ff093fb955adeeeed5c83a0fafc568d4b8074 Mon Sep 17 00:00:00 2001
From: Sascha Cunz <sascha.cunz@gmail.com>
Date: Thu, 30 Jan 2014 02:30:55 +0000
Subject: Find and use a MacPorts version of libiconv. Fixes #2017.

- Add correct -I, -L and -l flags
- Search for libiconv in /opt/local/[include|lib] before in the
  system path. See #2017 for details.
- Give splitted -L and -l arguments to pkg-config
---
 CMakeLists.txt                |  3 ++-
 cmake/Modules/FindIconv.cmake | 12 ++++++++++--
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 611cd9eec..4483be338 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -202,8 +202,9 @@ IF (USE_ICONV)
 ENDIF()
 IF (ICONV_FOUND)
 	ADD_DEFINITIONS(-DGIT_USE_ICONV)
+	INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR})
 	IF(ICONV_LIBRARIES MATCHES "libiconv")
-		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -liconv")
+		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} ${ICONV_LIBRARIES}")
 	ELSE()
 		SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} iconv")
 	ENDIF()
diff --git a/cmake/Modules/FindIconv.cmake b/cmake/Modules/FindIconv.cmake
index 487b2f557..f1406c557 100644
--- a/cmake/Modules/FindIconv.cmake
+++ b/cmake/Modules/FindIconv.cmake
@@ -11,15 +11,23 @@ IF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
 	SET(ICONV_FIND_QUIETLY TRUE)
 ENDIF()
 
+FIND_PATH(ICONV_INCLUDE_DIR iconv.h PATHS /opt/local/include NO_DEFAULT_PATH)
 FIND_PATH(ICONV_INCLUDE_DIR iconv.h)
 
-FIND_LIBRARY(ICONV_LIBRARIES NAMES iconv libiconv libiconv-2 c PATH)
+FIND_LIBRARY(iconv_lib NAMES iconv libiconv libiconv-2 c NO_DEFAULT_PATH PATHS /opt/local/lib)
+FIND_LIBRARY(iconv_lib NAMES iconv libiconv libiconv-2 c)
 
-IF(ICONV_INCLUDE_DIR AND ICONV_LIBRARIES)
+IF(ICONV_INCLUDE_DIR AND iconv_lib)
 	 SET(ICONV_FOUND TRUE)
 ENDIF()
 
 IF(ICONV_FOUND)
+	# split iconv into -L and -l linker options, so we can set them for pkg-config
+	GET_FILENAME_COMPONENT(iconv_path ${iconv_lib} PATH)
+	GET_FILENAME_COMPONENT(iconv_name ${iconv_lib} NAME_WE)
+	STRING(REGEX REPLACE "^lib" "" iconv_name ${iconv_name})
+	SET(ICONV_LIBRARIES -L${iconv_path} -l${iconv_name})
+
 	IF(NOT ICONV_FIND_QUIETLY)
 		MESSAGE(STATUS "Found Iconv: ${ICONV_LIBRARIES}")
 	ENDIF(NOT ICONV_FIND_QUIETLY)
-- 
cgit v1.2.3


From 4bc94eb5f049d1d0fd23128b05bb0d65ffac84d9 Mon Sep 17 00:00:00 2001
From: Sascha Cunz <sascha.cunz@gmail.com>
Date: Thu, 30 Jan 2014 03:01:46 +0000
Subject: We never search for libiconv via pkg-config

So we actually also never know that we can set a dependency on it in
pkg-config. Instead always give it the -L and -l options.
---
 CMakeLists.txt                | 6 +-----
 cmake/Modules/FindIconv.cmake | 2 +-
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4483be338..6f2a2bb82 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -203,11 +203,7 @@ ENDIF()
 IF (ICONV_FOUND)
 	ADD_DEFINITIONS(-DGIT_USE_ICONV)
 	INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR})
-	IF(ICONV_LIBRARIES MATCHES "libiconv")
-		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} ${ICONV_LIBRARIES}")
-	ELSE()
-		SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} iconv")
-	ENDIF()
+	SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} ${ICONV_LIBRARIES}")
 ENDIF()
 
 # Platform specific compilation flags
diff --git a/cmake/Modules/FindIconv.cmake b/cmake/Modules/FindIconv.cmake
index f1406c557..c5a419011 100644
--- a/cmake/Modules/FindIconv.cmake
+++ b/cmake/Modules/FindIconv.cmake
@@ -26,7 +26,7 @@ IF(ICONV_FOUND)
 	GET_FILENAME_COMPONENT(iconv_path ${iconv_lib} PATH)
 	GET_FILENAME_COMPONENT(iconv_name ${iconv_lib} NAME_WE)
 	STRING(REGEX REPLACE "^lib" "" iconv_name ${iconv_name})
-	SET(ICONV_LIBRARIES -L${iconv_path} -l${iconv_name})
+	SET(ICONV_LIBRARIES "-L${iconv_path} -l${iconv_name}")
 
 	IF(NOT ICONV_FIND_QUIETLY)
 		MESSAGE(STATUS "Found Iconv: ${ICONV_LIBRARIES}")
-- 
cgit v1.2.3


From 5572d2b8a1668f3c2f35ec91d3f864f28f8ef987 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 28 Jan 2014 11:44:17 -0800
Subject: Some missing oid to id renames

---
 include/git2/blob.h |  5 +++--
 src/blob.c          | 41 ++++++++++++++++++++++-------------------
 2 files changed, 25 insertions(+), 21 deletions(-)

diff --git a/include/git2/blob.h b/include/git2/blob.h
index 6ba5e9f9c..ac4d84392 100644
--- a/include/git2/blob.h
+++ b/include/git2/blob.h
@@ -196,13 +196,14 @@ GIT_EXTERN(int) git_blob_create_fromchunks(
 /**
  * Write an in-memory buffer to the ODB as a blob
  *
- * @param oid return the oid of the written blob
+ * @param id return the id of the written blob
  * @param repo repository where to blob will be written
  * @param buffer data to be written into the blob
  * @param len length of the data
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_blob_create_frombuffer(git_oid *oid, git_repository *repo, const void *buffer, size_t len);
+GIT_EXTERN(int) git_blob_create_frombuffer(
+	git_oid *id, git_repository *repo, const void *buffer, size_t len);
 
 /**
  * Determine if the blob content is most certainly binary or not.
diff --git a/src/blob.c b/src/blob.c
index 2e924f37f..faf8a4a99 100644
--- a/src/blob.c
+++ b/src/blob.c
@@ -50,25 +50,28 @@ int git_blob__parse(void *blob, git_odb_object *odb_obj)
 	return 0;
 }
 
-int git_blob_create_frombuffer(git_oid *oid, git_repository *repo, const void *buffer, size_t len)
+int git_blob_create_frombuffer(
+	git_oid *id, git_repository *repo, const void *buffer, size_t len)
 {
 	int error;
 	git_odb *odb;
 	git_odb_stream *stream;
 
+	assert(id && repo);
+
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
 		(error = git_odb_open_wstream(&stream, odb, len, GIT_OBJ_BLOB)) < 0)
 		return error;
 
 	if ((error = git_odb_stream_write(stream, buffer, len)) == 0)
-		error = git_odb_stream_finalize_write(oid, stream);
+		error = git_odb_stream_finalize_write(id, stream);
 
 	git_odb_stream_free(stream);
 	return error;
 }
 
 static int write_file_stream(
-	git_oid *oid, git_odb *odb, const char *path, git_off_t file_size)
+	git_oid *id, git_odb *odb, const char *path, git_off_t file_size)
 {
 	int fd, error;
 	char buffer[4096];
@@ -97,14 +100,14 @@ static int write_file_stream(
 	}
 
 	if (!error)
-		error = git_odb_stream_finalize_write(oid, stream);
+		error = git_odb_stream_finalize_write(id, stream);
 
 	git_odb_stream_free(stream);
 	return error;
 }
 
 static int write_file_filtered(
-	git_oid *oid,
+	git_oid *id,
 	git_off_t *size,
 	git_odb *odb,
 	const char *full_path,
@@ -119,7 +122,7 @@ static int write_file_filtered(
 	if (!error) {
 		*size = tgt.size;
 
-		error = git_odb_write(oid, odb, tgt.ptr, tgt.size, GIT_OBJ_BLOB);
+		error = git_odb_write(id, odb, tgt.ptr, tgt.size, GIT_OBJ_BLOB);
 	}
 
 	git_buf_free(&tgt);
@@ -127,7 +130,7 @@ static int write_file_filtered(
 }
 
 static int write_symlink(
-	git_oid *oid, git_odb *odb, const char *path, size_t link_size)
+	git_oid *id, git_odb *odb, const char *path, size_t link_size)
 {
 	char *link_data;
 	ssize_t read_len;
@@ -143,13 +146,13 @@ static int write_symlink(
 		return -1;
 	}
 
-	error = git_odb_write(oid, odb, (void *)link_data, link_size, GIT_OBJ_BLOB);
+	error = git_odb_write(id, odb, (void *)link_data, link_size, GIT_OBJ_BLOB);
 	git__free(link_data);
 	return error;
 }
 
 int git_blob__create_from_paths(
-	git_oid *oid,
+	git_oid *id,
 	struct stat *out_st,
 	git_repository *repo,
 	const char *content_path,
@@ -188,7 +191,7 @@ int git_blob__create_from_paths(
 	mode = hint_mode ? hint_mode : st.st_mode;
 
 	if (S_ISLNK(mode)) {
-		error = write_symlink(oid, odb, content_path, (size_t)size);
+		error = write_symlink(id, odb, content_path, (size_t)size);
 	} else {
 		git_filter_list *fl = NULL;
 
@@ -202,10 +205,10 @@ int git_blob__create_from_paths(
 		else if (fl == NULL)
 			/* No filters need to be applied to the document: we can stream
 			 * directly from disk */
-			error = write_file_stream(oid, odb, content_path, size);
+			error = write_file_stream(id, odb, content_path, size);
 		else {
 			/* We need to apply one or more filters */
-			error = write_file_filtered(oid, &size, odb, content_path, fl);
+			error = write_file_filtered(id, &size, odb, content_path, fl);
 
 			git_filter_list_free(fl);
 		}
@@ -233,13 +236,13 @@ done:
 }
 
 int git_blob_create_fromworkdir(
-	git_oid *oid, git_repository *repo, const char *path)
+	git_oid *id, git_repository *repo, const char *path)
 {
-	return git_blob__create_from_paths(oid, NULL, repo, NULL, path, 0, true);
+	return git_blob__create_from_paths(id, NULL, repo, NULL, path, 0, true);
 }
 
 int git_blob_create_fromdisk(
-	git_oid *oid, git_repository *repo, const char *path)
+	git_oid *id, git_repository *repo, const char *path)
 {
 	int error;
 	git_buf full_path = GIT_BUF_INIT;
@@ -257,7 +260,7 @@ int git_blob_create_fromdisk(
 		hintpath += strlen(workdir);
 
 	error = git_blob__create_from_paths(
-		oid, NULL, repo, git_buf_cstr(&full_path), hintpath, 0, true);
+		id, NULL, repo, git_buf_cstr(&full_path), hintpath, 0, true);
 
 	git_buf_free(&full_path);
 	return error;
@@ -266,7 +269,7 @@ int git_blob_create_fromdisk(
 #define BUFFER_SIZE 4096
 
 int git_blob_create_fromchunks(
-	git_oid *oid,
+	git_oid *id,
 	git_repository *repo,
 	const char *hintpath,
 	int (*source_cb)(char *content, size_t max_length, void *payload),
@@ -277,7 +280,7 @@ int git_blob_create_fromchunks(
 	git_filebuf file = GIT_FILEBUF_INIT;
 	git_buf path = GIT_BUF_INIT;
 
-	assert(oid && repo && source_cb);
+	assert(id && repo && source_cb);
 
 	if ((error = git_buf_joinpath(
 			&path, git_repository_path(repo), GIT_OBJECTS_DIR "streamed")) < 0)
@@ -313,7 +316,7 @@ int git_blob_create_fromchunks(
 		goto cleanup;
 
 	error = git_blob__create_from_paths(
-		oid, NULL, repo, file.path_lock, hintpath, 0, hintpath != NULL);
+		id, NULL, repo, file.path_lock, hintpath, 0, hintpath != NULL);
 
 cleanup:
 	git_buf_free(&path);
-- 
cgit v1.2.3


From c0644c3fbb31c381afb2d0658b5c6e83432fd8c9 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 28 Jan 2014 11:45:06 -0800
Subject: Make submodule fetchRecurse match other options

This removes the fetchRecurse compiler warnings and makes the
behavior match the other submodule options (i.e. the in-memory
setting can be reset to the on-disk value).
---
 include/git2/submodule.h | 13 -------------
 include/git2/types.h     | 19 +++++++++++++++++++
 src/submodule.c          |  7 ++++++-
 src/submodule.h          |  5 ++++-
 tests/submodule/modify.c | 34 ++++++++++++++++++++--------------
 5 files changed, 49 insertions(+), 29 deletions(-)

diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index af08ba6eb..d72432610 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -105,19 +105,6 @@ typedef enum {
 	GIT_SUBMODULE_STATUS_WD_WD_MODIFIED | \
 	GIT_SUBMODULE_STATUS_WD_UNTRACKED)) != 0)
 
-/**
- * Options for submodule recurse.
- *
- * * GIT_SUBMODULE_RECURSE_NO   - do no recurse into submodules
- * * GIT_SUBMODULE_RECURSE_YES  - recurse into submodules
- * * GIT_SUBMODULE_RECURSE_ONDEMAND - recurse into submodules only when commit not already in local clone
- */
-typedef enum {
-	GIT_SUBMODULE_RECURSE_NO = 0,
-	GIT_SUBMODULE_RECURSE_YES = 1,
-	GIT_SUBMODULE_RECURSE_ONDEMAND = 2,
-} git_submodule_recurse_t;
-
 /**
  * Lookup submodule information by name or path.
  *
diff --git a/include/git2/types.h b/include/git2/types.h
index d88815d80..2229f6bf4 100644
--- a/include/git2/types.h
+++ b/include/git2/types.h
@@ -323,6 +323,25 @@ typedef enum {
 	GIT_SUBMODULE_IGNORE_DEFAULT   = 0
 } git_submodule_ignore_t;
 
+/**
+ * Options for submodule recurse.
+ *
+ * Represent the value of `submodule.$name.fetchRecurseSubmodules`
+ *
+ * * GIT_SUBMODULE_RECURSE_RESET - reset to the on-disk value
+ * * GIT_SUBMODULE_RECURSE_NO    - do no recurse into submodules
+ * * GIT_SUBMODULE_RECURSE_YES   - recurse into submodules
+ * * GIT_SUBMODULE_RECURSE_ONDEMAND - recurse into submodules only when
+ *                                    commit not already in local clone
+ */
+typedef enum {
+	GIT_SUBMODULE_RECURSE_RESET = -1,
+
+	GIT_SUBMODULE_RECURSE_NO = 0,
+	GIT_SUBMODULE_RECURSE_YES = 1,
+	GIT_SUBMODULE_RECURSE_ONDEMAND = 2,
+} git_submodule_recurse_t;
+
 /** @} */
 GIT_END_DECL
 
diff --git a/src/submodule.c b/src/submodule.c
index 720681db9..2388bd144 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -498,6 +498,7 @@ int git_submodule_save(git_submodule *submodule)
 
 	submodule->ignore_default = submodule->ignore;
 	submodule->update_default = submodule->update;
+	submodule->fetch_recurse_default = submodule->fetch_recurse;
 	submodule->flags |= GIT_SUBMODULE_STATUS_IN_CONFIG;
 
 cleanup:
@@ -650,6 +651,9 @@ git_submodule_recurse_t git_submodule_set_fetch_recurse_submodules(
 
 	assert(submodule);
 
+	if (fetch_recurse_submodules == GIT_SUBMODULE_RECURSE_RESET)
+		fetch_recurse_submodules = submodule->fetch_recurse_default;
+
 	old = submodule->fetch_recurse;
 	submodule->fetch_recurse = fetch_recurse_submodules;
 	return old;
@@ -1000,7 +1004,7 @@ static git_submodule *submodule_alloc(git_repository *repo, const char *name)
 	GIT_REFCOUNT_INC(sm);
 	sm->ignore = sm->ignore_default = GIT_SUBMODULE_IGNORE_NONE;
 	sm->update = sm->update_default = GIT_SUBMODULE_UPDATE_CHECKOUT;
-	sm->fetch_recurse = GIT_SUBMODULE_RECURSE_YES;
+	sm->fetch_recurse = sm->fetch_recurse_default = GIT_SUBMODULE_RECURSE_NO;
 	sm->repo   = repo;
 	sm->branch = NULL;
 
@@ -1218,6 +1222,7 @@ static int submodule_load_from_config(
 	else if (strcasecmp(property, "fetchRecurseSubmodules") == 0) {
 		if (git_submodule_parse_recurse(&sm->fetch_recurse, value) < 0)
 			return -1;
+		sm->fetch_recurse_default = sm->fetch_recurse;
 	}
 	else if (strcasecmp(property, "ignore") == 0) {
 		if ((error = git_submodule_parse_ignore(&sm->ignore, value)) < 0)
diff --git a/src/submodule.h b/src/submodule.h
index 94748aca0..5e532e1ae 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -60,7 +60,9 @@
  * - `update_default` is the update value from the config
  * - `ignore` is a git_submodule_ignore_t value - see gitmodules(5) ignore.
  * - `ignore_default` is the ignore value from the config
- * - `fetch_recurse` is 0 or 1 - see gitmodules(5) fetchRecurseSubmodules.
+ * - `fetch_recurse` is a git_submodule_recurse_t value - see gitmodules(5)
+ *    fetchRecurseSubmodules.
+ * - `fetch_recurse_default` is the recurse value from the config
  *
  * - `repo` is the parent repository that contains this submodule.
  * - `flags` after for internal use, tracking where this submodule has been
@@ -87,6 +89,7 @@ struct git_submodule {
 	git_submodule_ignore_t ignore;
 	git_submodule_ignore_t ignore_default;
 	git_submodule_recurse_t fetch_recurse;
+	git_submodule_recurse_t fetch_recurse_default;
 
 	/* internal information */
 	git_repository *repo;
diff --git a/tests/submodule/modify.c b/tests/submodule/modify.c
index 8ec9fceb0..e3e4d8aed 100644
--- a/tests/submodule/modify.c
+++ b/tests/submodule/modify.c
@@ -178,25 +178,28 @@ void test_submodule_modify__edit_and_save(void)
 	cl_git_pass(git_submodule_set_url(sm1, SM_LIBGIT2_URL));
 	old_ignore = git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_UNTRACKED);
 	old_update = git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_REBASE);
-	old_fetchrecurse = git_submodule_set_fetch_recurse_submodules(sm1, GIT_SUBMODULE_RECURSE_YES);
+	old_fetchrecurse = git_submodule_set_fetch_recurse_submodules(
+		sm1, GIT_SUBMODULE_RECURSE_YES);
 
 	cl_assert_equal_s(SM_LIBGIT2_URL, git_submodule_url(sm1));
 	cl_assert_equal_i(
-		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm1));
+		GIT_SUBMODULE_IGNORE_UNTRACKED, git_submodule_ignore(sm1));
 	cl_assert_equal_i(
-		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm1));
-	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_YES, git_submodule_fetch_recurse_submodules(sm1));
+		GIT_SUBMODULE_UPDATE_REBASE, git_submodule_update(sm1));
+	cl_assert_equal_i(
+		GIT_SUBMODULE_RECURSE_YES, git_submodule_fetch_recurse_submodules(sm1));
 
 	/* revert without saving (and confirm setters return old value) */
 	cl_git_pass(git_submodule_set_url(sm1, old_url));
 	cl_assert_equal_i(
-		(int)GIT_SUBMODULE_IGNORE_UNTRACKED,
-		(int)git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_RESET));
+		GIT_SUBMODULE_IGNORE_UNTRACKED,
+		git_submodule_set_ignore(sm1, GIT_SUBMODULE_IGNORE_RESET));
 	cl_assert_equal_i(
-		(int)GIT_SUBMODULE_UPDATE_REBASE,
-		(int)git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_RESET));
+		GIT_SUBMODULE_UPDATE_REBASE,
+		git_submodule_set_update(sm1, GIT_SUBMODULE_UPDATE_RESET));
 	cl_assert_equal_i(
-		GIT_SUBMODULE_RECURSE_YES, git_submodule_set_fetch_recurse_submodules(sm1, old_fetchrecurse));
+		GIT_SUBMODULE_RECURSE_YES, git_submodule_set_fetch_recurse_submodules(
+			sm1, GIT_SUBMODULE_RECURSE_RESET));
 
 	/* check that revert was successful */
 	cl_assert_equal_s(old_url, git_submodule_url(sm1));
@@ -243,19 +246,22 @@ void test_submodule_modify__edit_and_save(void)
 
 	cl_assert_equal_s(SM_LIBGIT2_URL, git_submodule_url(sm2));
 	cl_assert_equal_i(
-		(int)GIT_SUBMODULE_IGNORE_UNTRACKED, (int)git_submodule_ignore(sm2));
+		GIT_SUBMODULE_IGNORE_UNTRACKED, git_submodule_ignore(sm2));
 	cl_assert_equal_i(
-		(int)GIT_SUBMODULE_UPDATE_REBASE, (int)git_submodule_update(sm2));
-	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_YES, git_submodule_fetch_recurse_submodules(sm2));
+		GIT_SUBMODULE_UPDATE_REBASE, git_submodule_update(sm2));
+	cl_assert_equal_i(
+		GIT_SUBMODULE_RECURSE_NO, git_submodule_fetch_recurse_submodules(sm2));
 
 	/* set fetchRecurseSubmodules on-demand */
 	cl_git_pass(git_submodule_reload(sm1));
 	git_submodule_set_fetch_recurse_submodules(sm1, GIT_SUBMODULE_RECURSE_ONDEMAND);
-	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_ONDEMAND, git_submodule_fetch_recurse_submodules(sm1));
+	cl_assert_equal_i(
+		GIT_SUBMODULE_RECURSE_ONDEMAND, git_submodule_fetch_recurse_submodules(sm1));
 	/* call save */
 	cl_git_pass(git_submodule_save(sm1));
 	cl_git_pass(git_submodule_reload(sm1));
-	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_ONDEMAND, git_submodule_fetch_recurse_submodules(sm1));
+	cl_assert_equal_i(
+		GIT_SUBMODULE_RECURSE_ONDEMAND, git_submodule_fetch_recurse_submodules(sm1));
 
 	git_repository_free(r2);
 	git__free(old_url);
-- 
cgit v1.2.3


From 3cf11eef17d8359c032844de945da6e983572ecc Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 28 Jan 2014 11:47:33 -0800
Subject: Misc cleanups

---
 src/attr.c             |  9 +++++++++
 src/branch.c           | 39 ++++++++++++++++-----------------------
 tests/status/renames.c |  1 -
 3 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/src/attr.c b/src/attr.c
index ff4446e2f..15ed5c9e0 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -49,6 +49,8 @@ int git_attr_get(
 	git_attr_name attr;
 	git_attr_rule *rule;
 
+	assert(value && repo && name);
+
 	*value = NULL;
 
 	if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)
@@ -103,6 +105,11 @@ int git_attr_get_many(
 	attr_get_many_info *info = NULL;
 	size_t num_found = 0;
 
+	if (!num_attr)
+		return 0;
+
+	assert(values && repo && names);
+
 	if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)
 		return -1;
 
@@ -169,6 +176,8 @@ int git_attr_foreach(
 	git_attr_assignment *assign;
 	git_strmap *seen = NULL;
 
+	assert(repo && callback);
+
 	if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)
 		return -1;
 
diff --git a/src/branch.c b/src/branch.c
index a1a04b2b4..d0dc21b85 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -21,27 +21,22 @@ static int retrieve_branch_reference(
 	const char *branch_name,
 	int is_remote)
 {
-	git_reference *branch;
-	int error = -1;
+	git_reference *branch = NULL;
+	int error = 0;
 	char *prefix;
 	git_buf ref_name = GIT_BUF_INIT;
 
-	*branch_reference_out = NULL;
-
 	prefix = is_remote ? GIT_REFS_REMOTES_DIR : GIT_REFS_HEADS_DIR;
 
-	if (git_buf_joinpath(&ref_name, prefix, branch_name) < 0)
-		goto cleanup;
+	if ((error = git_buf_joinpath(&ref_name, prefix, branch_name)) < 0)
+		/* OOM */;
+	else if ((error = git_reference_lookup(&branch, repo, ref_name.ptr)) < 0)
+		giterr_set(
+			GITERR_REFERENCE, "Cannot locate %s branch '%s'",
+			is_remote ? "remote-tracking" : "local", branch_name);
 
-	if ((error = git_reference_lookup(&branch, repo, ref_name.ptr)) < 0) {
-		giterr_set(GITERR_REFERENCE,
-			"Cannot locate %s branch '%s'.", is_remote ? "remote-tracking" : "local", branch_name);
-		goto cleanup;
-	}
+	*branch_reference_out = branch; /* will be NULL on error */
 
-	*branch_reference_out = branch;
-
-cleanup:
 	git_buf_free(&ref_name);
 	return error;
 }
@@ -63,21 +58,19 @@ int git_branch_create(
 {
 	git_reference *branch = NULL;
 	git_buf canonical_branch_name = GIT_BUF_INIT;
-	int error = -1;
+	int error = 0;
 
 	assert(branch_name && commit && ref_out);
 	assert(git_object_owner((const git_object *)commit) == repository);
 
-	if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0)
-		goto cleanup;
-
-	error = git_reference_create(&branch, repository,
-		git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force, NULL, NULL);
+	if (!(error = git_buf_joinpath(
+			&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name)))
+		error = git_reference_create(
+			&branch, repository, git_buf_cstr(&canonical_branch_name),
+			git_commit_id(commit), force, NULL, NULL);
 
-	if (!error)
-		*ref_out = branch;
+	*ref_out = branch;
 
-cleanup:
 	git_buf_free(&canonical_branch_name);
 	return error;
 }
diff --git a/tests/status/renames.c b/tests/status/renames.c
index a81910e36..df5e23087 100644
--- a/tests/status/renames.c
+++ b/tests/status/renames.c
@@ -560,7 +560,6 @@ void test_status_renames__zero_byte_file_does_not_fail(void)
 {
 	git_status_list *statuslist;
 	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
-	status_entry_counts counts = {0};
 
 	struct status_entry expected[] = {
 		{ GIT_STATUS_WT_DELETED, "ikeepsix.txt", "ikeepsix.txt" },
-- 
cgit v1.2.3


From e9d5e5f3d41846b5f3be1bfb6a5cb1e501f428c8 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 28 Jan 2014 16:25:42 -0800
Subject: Some fixes for Windows x64 warnings

---
 include/git2/blame.h | 2 +-
 src/blame.c          | 2 +-
 src/indexer.c        | 2 +-
 src/pack-objects.c   | 2 +-
 src/userdiff.h       | 6 +++---
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/git2/blame.h b/include/git2/blame.h
index 73bcc5bc6..b98c6f0d7 100644
--- a/include/git2/blame.h
+++ b/include/git2/blame.h
@@ -183,7 +183,7 @@ GIT_EXTERN(int) git_blame_buffer(
 		git_blame **out,
 		git_blame *reference,
 		const char *buffer,
-		uint32_t buffer_len);
+		size_t buffer_len);
 
 /**
  * Free memory allocated by git_blame_file or git_blame_buffer.
diff --git a/src/blame.c b/src/blame.c
index 0f2d906d2..71bc460c6 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -450,7 +450,7 @@ int git_blame_buffer(
 		git_blame **out,
 		git_blame *reference,
 		const char *buffer,
-		uint32_t buffer_len)
+		size_t buffer_len)
 {
 	git_blame *blame;
 	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
diff --git a/src/indexer.c b/src/indexer.c
index 9b60ef413..346870faa 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -659,7 +659,7 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	hdr_len = git_packfile__object_header(hdr, len, git_odb_object_type(obj));
 	git_filebuf_write(&idx->pack_file, hdr, hdr_len);
 	idx->pack->mwf.size += hdr_len;
-	entry->crc = crc32(entry->crc, hdr, hdr_len);
+	entry->crc = crc32(entry->crc, hdr, (uInt)hdr_len);
 
 	if ((error = git_zstream_deflatebuf(&buf, data, len)) < 0)
 		goto cleanup;
diff --git a/src/pack-objects.c b/src/pack-objects.c
index 1774b07dc..8475f64f2 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -348,7 +348,7 @@ static int write_object(
 		}
 
 		if (written < 0) {
-			error = written;
+			error = (int)written;
 			goto done;
 		}
 
diff --git a/src/userdiff.h b/src/userdiff.h
index 9318b5476..7eb095246 100644
--- a/src/userdiff.h
+++ b/src/userdiff.h
@@ -193,9 +193,9 @@ PATTERNS("php",
 	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
 
 PATTERNS("javascript",
-	 "^[ \t]*(function[ \t][a-zA-Z_][^\{]*)\n"
-	 "^[ \t]*(var[ \t]+[a-zA-Z_][a-zA-Z0-9_]*[ \t]*=[ \t]*function[ \t\(][^\{]*)\n"
-	 "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*[ \t]*:[ \t]*function[ \t\(][^\{]*)",
+	 "^[ \t]*(function[ \t][a-zA-Z_][^\\{]*)\n"
+	 "^[ \t]*(var[ \t]+[a-zA-Z_][a-zA-Z0-9_]*[ \t]*=[ \t]*function[ \t\\(][^\\{]*)\n"
+	 "^[ \t]*([a-zA-Z_][a-zA-Z0-9_]*[ \t]*:[ \t]*function[ \t\\(][^\\{]*)",
 	 /* -- */
 	 "[a-zA-Z_][a-zA-Z0-9_]*"
 	 "|[-+0-9.e]+[fFlL]?|0[xX]?[0-9a-fA-F]+[lL]?"
-- 
cgit v1.2.3


From d9b04d78a396f771eada206b726ad6e8259a19b8 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 29 Jan 2014 15:02:35 -0800
Subject: Reorganize zstream API and fix wrap problems

There were some confusing issues mixing up the number of bytes
written to the zstream output buffer with the number of bytes
consumed from the zstream input.  This reorganizes the zstream
API and makes it easier to deflate an arbitrarily large input
while still using a fixed size output.
---
 src/pack-objects.c   |  17 +++---
 src/zstream.c        | 146 +++++++++++++++++++++++++++++++++++----------------
 src/zstream.h        |  21 ++++++--
 tests/core/zstream.c |  98 ++++++++++++++++++++++++++++++++++
 4 files changed, 223 insertions(+), 59 deletions(-)
 create mode 100644 tests/core/zstream.c

diff --git a/src/pack-objects.c b/src/pack-objects.c
index 8475f64f2..8b65ac26a 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -291,7 +291,6 @@ static int write_object(
 	void *delta_data = NULL;
 	void *data;
 	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
-	ssize_t written;
 	int error;
 
 	if (po->delta) {
@@ -337,19 +336,15 @@ static int write_object(
 		GITERR_CHECK_ALLOC(zbuf);
 
 		git_zstream_reset(&pb->zstream);
+		git_zstream_set_input(&pb->zstream, data, data_len);
 
-		while ((written = git_zstream_deflate(zbuf, zbuf_len, &pb->zstream, data, data_len)) > 0) {
-			if ((error = write_cb(zbuf, written, cb_data)) < 0 ||
-				(error = git_hash_update(&pb->ctx, zbuf, written)) < 0)
+		while (!git_zstream_done(&pb->zstream)) {
+			if ((error = git_zstream_get_output(zbuf, &zbuf_len, &pb->zstream)) < 0 ||
+				(error = write_cb(zbuf, zbuf_len, cb_data)) < 0 ||
+				(error = git_hash_update(&pb->ctx, zbuf, zbuf_len)) < 0)
 				goto done;
 
-			data = (char *)data + written;
-			data_len -= written;
-		}
-
-		if (written < 0) {
-			error = (int)written;
-			goto done;
+			zbuf_len = COMPRESS_BUFLEN; /* reuse buffer */
 		}
 
 		if (po->delta)
diff --git a/src/zstream.c b/src/zstream.c
index 0bca72ff3..c83602297 100644
--- a/src/zstream.c
+++ b/src/zstream.c
@@ -10,14 +10,18 @@
 #include "zstream.h"
 #include "buffer.h"
 
-#define BUFFER_SIZE (1024 * 1024)
+#define ZSTREAM_BUFFER_SIZE (1024 * 1024)
+#define ZSTREAM_BUFFER_MIN_EXTRA 8
 
-static int zstream_seterr(int zerr, git_zstream *zstream)
+static int zstream_seterr(git_zstream *zs)
 {
-	if (zerr == Z_MEM_ERROR)
+	if (zs->zerr == Z_OK || zs->zerr == Z_STREAM_END)
+		return 0;
+
+	if (zs->zerr == Z_MEM_ERROR)
 		giterr_set_oom();
-	else if (zstream->msg)
-		giterr_set(GITERR_ZLIB, zstream->msg);
+	else if (zs->z.msg)
+		giterr_set(GITERR_ZLIB, zs->z.msg);
 	else
 		giterr_set(GITERR_ZLIB, "Unknown compression error");
 
@@ -26,69 +30,123 @@ static int zstream_seterr(int zerr, git_zstream *zstream)
 
 int git_zstream_init(git_zstream *zstream)
 {
-	int zerr;
-
-	if ((zerr = deflateInit(zstream, Z_DEFAULT_COMPRESSION)) != Z_OK)
-		return zstream_seterr(zerr, zstream);
-
-	return 0;
+	zstream->zerr = deflateInit(&zstream->z, Z_DEFAULT_COMPRESSION);
+	return zstream_seterr(zstream);
 }
 
-ssize_t git_zstream_deflate(void *out, size_t out_len, git_zstream *zstream, const void *in, size_t in_len)
+void git_zstream_free(git_zstream *zstream)
 {
-	int zerr;
-
-	if ((ssize_t)out_len < 0)
-		out_len = INT_MAX;
+	deflateEnd(&zstream->z);
+}
 
-	zstream->next_in = (Bytef *)in;
-	zstream->avail_in = in_len;
-	zstream->next_out = out;
-	zstream->avail_out = out_len;
+void git_zstream_reset(git_zstream *zstream)
+{
+	deflateReset(&zstream->z);
+	zstream->in = NULL;
+	zstream->in_len = 0;
+	zstream->zerr = Z_STREAM_END;
+}
 
-	if ((zerr = deflate(zstream, Z_FINISH)) == Z_STREAM_ERROR)
-		return zstream_seterr(zerr, zstream);
+int git_zstream_set_input(git_zstream *zstream, const void *in, size_t in_len)
+{
+	zstream->in = in;
+	zstream->in_len = in_len;
+	zstream->zerr = Z_OK;
+	return 0;
+}
 
-	return (out_len - zstream->avail_out);
+bool git_zstream_done(git_zstream *zstream)
+{
+	return (!zstream->in_len && zstream->zerr == Z_STREAM_END);
 }
 
-void git_zstream_reset(git_zstream *zstream)
+size_t git_zstream_suggest_output_len(git_zstream *zstream)
 {
-	deflateReset(zstream);
+	if (zstream->in_len > ZSTREAM_BUFFER_SIZE)
+		return ZSTREAM_BUFFER_SIZE;
+	else if (zstream->in_len > ZSTREAM_BUFFER_MIN_EXTRA)
+		return zstream->in_len;
+	else
+		return ZSTREAM_BUFFER_MIN_EXTRA;
 }
 
-void git_zstream_free(git_zstream *zstream)
+int git_zstream_get_output(void *out, size_t *out_len, git_zstream *zstream)
 {
-	deflateEnd(zstream);
+	int zflush = Z_FINISH;
+	size_t out_remain = *out_len;
+
+	while (out_remain > 0 && zstream->zerr != Z_STREAM_END) {
+		size_t out_queued, in_queued, out_used, in_used;
+
+		/* set up in data */
+		zstream->z.next_in  = (Bytef *)zstream->in;
+		zstream->z.avail_in = (uInt)zstream->in_len;
+		if ((size_t)zstream->z.avail_in != zstream->in_len) {
+			zstream->z.avail_in = INT_MAX;
+			zflush = Z_NO_FLUSH;
+		} else {
+			zflush = Z_FINISH;
+		}
+		in_queued = (size_t)zstream->z.avail_in;
+
+		/* set up out data */
+		zstream->z.next_out = out;
+		zstream->z.avail_out = (uInt)out_remain;
+		if ((size_t)zstream->z.avail_out != out_remain)
+			zstream->z.avail_out = INT_MAX;
+		out_queued = (size_t)zstream->z.avail_out;
+
+		/* compress next chunk */
+		zstream->zerr = deflate(&zstream->z, zflush);
+		if (zstream->zerr == Z_STREAM_ERROR)
+			return zstream_seterr(zstream);
+
+		out_used = (out_queued - zstream->z.avail_out);
+		out_remain -= out_used;
+		out = ((char *)out) + out_used;
+
+		in_used = (in_queued - zstream->z.avail_in);
+		zstream->in_len -= in_used;
+		zstream->in += in_used;
+	}
+
+	/* either we finished the input or we did not flush the data */
+	assert(zstream->in_len > 0 || zflush == Z_FINISH);
+
+	/* set out_size to number of bytes actually written to output */
+	*out_len = *out_len - out_remain;
+
+	return 0;
 }
 
 int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len)
 {
-	git_zstream zstream = GIT_ZSTREAM_INIT;
-	size_t out_len;
-	ssize_t written;
+	git_zstream zs = GIT_ZSTREAM_INIT;
 	int error = 0;
 
-	if ((error = git_zstream_init(&zstream)) < 0)
+	if ((error = git_zstream_init(&zs)) < 0)
 		return error;
 
-	do {
-		if (out->asize - out->size < BUFFER_SIZE)
-			git_buf_grow(out, out->asize + BUFFER_SIZE);
+	if ((error = git_zstream_set_input(&zs, in, in_len)) < 0)
+		goto done;
 
-		out_len = out->asize - out->size;
+	while (!git_zstream_done(&zs)) {
+		size_t step = git_zstream_suggest_output_len(&zs), written;
 
-		if ((written = git_zstream_deflate(out->ptr + out->size, out_len, &zstream, in, in_len)) <= 0)
-			break;
+		if ((error = git_buf_grow(out, out->asize + step)) < 0)
+			goto done;
 
-		in = (char *)in + written;
-		in_len -= written;
-		out->size += written;
-	} while (written > 0);
+		written = out->asize - out->size;
 
-	if (written < 0)
-		error = written;
+		if ((error = git_zstream_get_output(
+				out->ptr + out->size, &written, &zs)) < 0)
+			goto done;
+
+		out->size += written;
+		out->ptr[out->size] = '\0';
+	}
 
-	git_zstream_free(&zstream);
+done:
+	git_zstream_free(&zs);
 	return error;
 }
diff --git a/src/zstream.h b/src/zstream.h
index 9672903c0..9b5bf6ace 100644
--- a/src/zstream.h
+++ b/src/zstream.h
@@ -12,15 +12,28 @@
 #include "common.h"
 #include "buffer.h"
 
-#define git_zstream z_stream
+typedef struct {
+	z_stream z;
+	const char *in;
+	size_t in_len;
+	int zerr;
+} git_zstream;
 
-#define GIT_ZSTREAM_INIT {0}
+#define GIT_ZSTREAM_INIT {{0}}
 
 int git_zstream_init(git_zstream *zstream);
-ssize_t git_zstream_deflate(void *out, size_t out_len, git_zstream *zstream, const void *in, size_t in_len);
-void git_zstream_reset(git_zstream *zstream);
 void git_zstream_free(git_zstream *zstream);
 
+int git_zstream_set_input(git_zstream *zstream, const void *in, size_t in_len);
+
+size_t git_zstream_suggest_output_len(git_zstream *zstream);
+
+int git_zstream_get_output(void *out, size_t *out_len, git_zstream *zstream);
+
+bool git_zstream_done(git_zstream *zstream);
+
+void git_zstream_reset(git_zstream *zstream);
+
 int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len);
 
 #endif /* INCLUDE_zstream_h__ */
diff --git a/tests/core/zstream.c b/tests/core/zstream.c
new file mode 100644
index 000000000..63ff8c93a
--- /dev/null
+++ b/tests/core/zstream.c
@@ -0,0 +1,98 @@
+#include "clar_libgit2.h"
+#include "buffer.h"
+#include "zstream.h"
+
+static const char *data = "This is a test test test of This is a test";
+
+#define INFLATE_EXTRA 2
+
+static void assert_zlib_equal_(
+	const void *expected, size_t e_len,
+	const void *compressed, size_t c_len,
+	const char *msg, const char *file, int line)
+{
+	z_stream stream;
+	char *expanded = git__calloc(1, e_len + INFLATE_EXTRA);
+	cl_assert(expanded);
+
+	memset(&stream, 0, sizeof(stream));
+	stream.next_out  = (Bytef *)expanded;
+	stream.avail_out = (uInt)(e_len + INFLATE_EXTRA);
+	stream.next_in   = (Bytef *)compressed;
+	stream.avail_in  = (uInt)c_len;
+
+	cl_assert(inflateInit(&stream) == Z_OK);
+	cl_assert(inflate(&stream, Z_FINISH));
+	inflateEnd(&stream);
+
+	clar__assert_equal(
+		file, line, msg, 1,
+		"%d", (int)stream.total_out, (int)e_len);
+	clar__assert_equal(
+		file, line, "Buffer len was not exact match", 1,
+		"%d", (int)stream.avail_out, (int)INFLATE_EXTRA);
+
+	clar__assert(
+		memcmp(expanded, expected, e_len) == 0,
+		file, line, "uncompressed data did not match", NULL, 1);
+
+	git__free(expanded);
+}
+
+#define assert_zlib_equal(E,EL,C,CL) \
+	assert_zlib_equal_(E, EL, C, CL, #EL " != " #CL, __FILE__, (int)__LINE__)
+
+void test_core_zstream__basic(void)
+{
+	git_zstream z = GIT_ZSTREAM_INIT;
+	char out[128];
+	size_t outlen = sizeof(out);
+
+	cl_git_pass(git_zstream_init(&z));
+	cl_git_pass(git_zstream_set_input(&z, data, strlen(data) + 1));
+	cl_git_pass(git_zstream_get_output(out, &outlen, &z));
+	cl_assert(git_zstream_done(&z));
+	cl_assert(outlen > 0);
+	git_zstream_free(&z);
+
+	assert_zlib_equal(data, strlen(data) + 1, out, outlen);
+}
+
+void test_core_zstream__buffer(void)
+{
+	git_buf out = GIT_BUF_INIT;
+	cl_git_pass(git_zstream_deflatebuf(&out, data, strlen(data) + 1));
+	assert_zlib_equal(data, strlen(data) + 1, out.ptr, out.size);
+	git_buf_free(&out);
+}
+
+#define BIG_STRING_PART "Big Data IS Big - Long Data IS Long - We need a buffer larger than 1024 x 1024 to make sure we trigger chunked compression - Big Big Data IS Bigger than Big - Long Long Data IS Longer than Long"
+
+void test_core_zstream__big_data(void)
+{
+	git_buf in = GIT_BUF_INIT;
+	git_buf out = GIT_BUF_INIT;
+	size_t scan;
+
+	/* make a big string that's easy to compress */
+	while (in.size < 1024 * 1024)
+		cl_git_pass(git_buf_put(&in, BIG_STRING_PART, strlen(BIG_STRING_PART)));
+
+	cl_git_pass(git_zstream_deflatebuf(&out, in.ptr, in.size));
+	assert_zlib_equal(in.ptr, in.size, out.ptr, out.size);
+
+	git_buf_free(&out);
+
+	/* make a big string that's hard to compress */
+
+	srand(0xabad1dea);
+	for (scan = 0; scan < in.size; ++scan)
+		in.ptr[scan] = (char)rand();
+
+	cl_git_pass(git_zstream_deflatebuf(&out, in.ptr, in.size));
+	assert_zlib_equal(in.ptr, in.size, out.ptr, out.size);
+
+	git_buf_free(&out);
+
+	git_buf_free(&in);
+}
-- 
cgit v1.2.3


From 8606f33beadf5df48b36a64359c99d50aeb0f496 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 30 Jan 2014 09:59:15 -0800
Subject: Expand zstream tests and fix off-by-one error

---
 src/zstream.c        |  3 +-
 tests/core/zstream.c | 79 +++++++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 64 insertions(+), 18 deletions(-)

diff --git a/src/zstream.c b/src/zstream.c
index c83602297..82ae5e6f0 100644
--- a/src/zstream.c
+++ b/src/zstream.c
@@ -98,6 +98,7 @@ int git_zstream_get_output(void *out, size_t *out_len, git_zstream *zstream)
 
 		/* compress next chunk */
 		zstream->zerr = deflate(&zstream->z, zflush);
+
 		if (zstream->zerr == Z_STREAM_ERROR)
 			return zstream_seterr(zstream);
 
@@ -133,7 +134,7 @@ int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len)
 	while (!git_zstream_done(&zs)) {
 		size_t step = git_zstream_suggest_output_len(&zs), written;
 
-		if ((error = git_buf_grow(out, out->asize + step)) < 0)
+		if ((error = git_buf_grow(out, out->asize + step + 1)) < 0)
 			goto done;
 
 		written = out->asize - out->size;
diff --git a/tests/core/zstream.c b/tests/core/zstream.c
index 63ff8c93a..7ba9424ba 100644
--- a/tests/core/zstream.c
+++ b/tests/core/zstream.c
@@ -68,31 +68,76 @@ void test_core_zstream__buffer(void)
 
 #define BIG_STRING_PART "Big Data IS Big - Long Data IS Long - We need a buffer larger than 1024 x 1024 to make sure we trigger chunked compression - Big Big Data IS Bigger than Big - Long Long Data IS Longer than Long"
 
-void test_core_zstream__big_data(void)
+static void compress_input_various_ways(git_buf *input)
 {
-	git_buf in = GIT_BUF_INIT;
-	git_buf out = GIT_BUF_INIT;
-	size_t scan;
+	git_buf out1 = GIT_BUF_INIT, out2 = GIT_BUF_INIT;
+	size_t i, fixed_size = max(input->size / 2, 256);
+	char *fixed = git__malloc(fixed_size);
+	cl_assert(fixed);
 
-	/* make a big string that's easy to compress */
-	while (in.size < 1024 * 1024)
-		cl_git_pass(git_buf_put(&in, BIG_STRING_PART, strlen(BIG_STRING_PART)));
+	/* compress with deflatebuf */
 
-	cl_git_pass(git_zstream_deflatebuf(&out, in.ptr, in.size));
-	assert_zlib_equal(in.ptr, in.size, out.ptr, out.size);
+	cl_git_pass(git_zstream_deflatebuf(&out1, input->ptr, input->size));
+	assert_zlib_equal(input->ptr, input->size, out1.ptr, out1.size);
 
-	git_buf_free(&out);
+	/* compress with various fixed size buffer (accumulating the output) */
 
-	/* make a big string that's hard to compress */
+	for (i = 0; i < 3; ++i) {
+		git_zstream zs = GIT_ZSTREAM_INIT;
+		size_t use_fixed_size;
 
-	srand(0xabad1dea);
-	for (scan = 0; scan < in.size; ++scan)
-		in.ptr[scan] = (char)rand();
+		switch (i) {
+		case 0: use_fixed_size = 256; break;
+		case 1: use_fixed_size = fixed_size / 2; break;
+		case 2: use_fixed_size = fixed_size; break;
+		}
+		cl_assert(use_fixed_size <= fixed_size);
 
-	cl_git_pass(git_zstream_deflatebuf(&out, in.ptr, in.size));
-	assert_zlib_equal(in.ptr, in.size, out.ptr, out.size);
+		cl_git_pass(git_zstream_init(&zs));
+		cl_git_pass(git_zstream_set_input(&zs, input->ptr, input->size));
 
-	git_buf_free(&out);
+		while (!git_zstream_done(&zs)) {
+			size_t written = use_fixed_size;
+			cl_git_pass(git_zstream_get_output(fixed, &written, &zs));
+			cl_git_pass(git_buf_put(&out2, fixed, written));
+		}
+
+		git_zstream_free(&zs);
+		assert_zlib_equal(input->ptr, input->size, out2.ptr, out2.size);
+
+		/* did both approaches give the same data? */
+		cl_assert_equal_sz(out1.size, out2.size);
+		cl_assert(!memcmp(out1.ptr, out2.ptr, out1.size));
+
+		git_buf_free(&out2);
+	}
+
+	git_buf_free(&out1);
+	git__free(fixed);
+}
+
+void test_core_zstream__big_data(void)
+{
+	git_buf in = GIT_BUF_INIT;
+	size_t scan, target;
+
+	for (target = 1024; target <= 1024 * 1024 * 4; target *= 8) {
+
+		/* make a big string that's easy to compress */
+		git_buf_clear(&in);
+		while (in.size < target)
+			cl_git_pass(
+				git_buf_put(&in, BIG_STRING_PART, strlen(BIG_STRING_PART)));
+
+		compress_input_various_ways(&in);
+
+		/* make a big string that's hard to compress */
+		srand(0xabad1dea);
+		for (scan = 0; scan < in.size; ++scan)
+			in.ptr[scan] = (char)rand();
+
+		compress_input_various_ways(&in);
+	}
 
 	git_buf_free(&in);
 }
-- 
cgit v1.2.3


From 19459b1e29e150c02e733bdefd5e1eb09fdd4bf7 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 30 Jan 2014 10:23:35 -0800
Subject: Defer zstream NUL termination to end

And don't terminate if there isn't space for it (since it's binary
data, it's not worth a reallocation).
---
 src/zstream.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/zstream.c b/src/zstream.c
index 82ae5e6f0..85fa2e0e6 100644
--- a/src/zstream.c
+++ b/src/zstream.c
@@ -134,7 +134,7 @@ int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len)
 	while (!git_zstream_done(&zs)) {
 		size_t step = git_zstream_suggest_output_len(&zs), written;
 
-		if ((error = git_buf_grow(out, out->asize + step + 1)) < 0)
+		if ((error = git_buf_grow(out, out->asize + step)) < 0)
 			goto done;
 
 		written = out->asize - out->size;
@@ -144,9 +144,12 @@ int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len)
 			goto done;
 
 		out->size += written;
-		out->ptr[out->size] = '\0';
 	}
 
+	/* NULL terminate for consistency if possible */
+	if (out->size < out->asize)
+		out->ptr[out->size] = '\0';
+
 done:
 	git_zstream_free(&zs);
 	return error;
-- 
cgit v1.2.3


From 71ae7601160aca672f2b13a461aab6e4aee7f9d0 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 30 Jan 2014 11:30:16 -0800
Subject: Force explicit remove of files instead of defer

The checkout code used to defer removal of "blocking" files in
checkouts until the blocked item was actually being written (since
we have already checked that the removing the block is acceptable
according to the update rules).  Unfortunately, this resulted in
an intermediate index state where both the blocking and new items
were in the index which is no longer allowed.  Now we just remove
the blocking item in the first pass so it never needs to coexist.

In cases where there are typechanges, this could result in a bit
more churn of removing and recreating intermediate directories,
but I'm going to assume that is an unusual case and the churn will
not be too costly.
---
 src/checkout.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/checkout.c b/src/checkout.c
index f11ab8d46..5b1f6cdcc 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -246,6 +246,8 @@ static int checkout_action_no_wd(
 			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
 		break;
 	case GIT_DELTA_DELETED: /* case 8 or 25 */
+		*action = CHECKOUT_ACTION__REMOVE;
+		break;
 	default: /* impossible */
 		break;
 	}
-- 
cgit v1.2.3


From b794cbcdb638676e593cc8d2ff3394ae21f2a185 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 30 Jan 2014 11:38:25 -0800
Subject: Rename conflict to collision to prevent confusion

---
 src/index.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/index.c b/src/index.c
index 01321d8a1..7bc5d5b24 100644
--- a/src/index.c
+++ b/src/index.c
@@ -804,7 +804,7 @@ static int has_dir_name(git_index *index,
 	return retval;
 }
 
-static int check_file_directory_conflict(git_index *index,
+static int check_file_directory_collision(git_index *index,
 		git_index_entry *entry, size_t pos, int ok_to_replace)
 {
 	int retval = has_file_name(index, entry, pos, ok_to_replace);
@@ -844,7 +844,7 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace)
 		entry->mode = index_merge_mode(index, *existing, entry->mode);
 	}
 
-	if (check_file_directory_conflict(index, entry, position, replace) < 0)
+	if (check_file_directory_collision(index, entry, position, replace) < 0)
 		return -1;
 
 	/* if replacing is not requested or no existing entry exists, just
-- 
cgit v1.2.3


From 25babd02a4151f858a631314364fdca97180f2c5 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 30 Jan 2014 11:38:59 -0800
Subject: Fix checkout NONE to not remove file

If you are checking out NONE, then don't remove.
---
 src/checkout.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/checkout.c b/src/checkout.c
index 5b1f6cdcc..72fe5368f 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -246,7 +246,7 @@ static int checkout_action_no_wd(
 			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
 		break;
 	case GIT_DELTA_DELETED: /* case 8 or 25 */
-		*action = CHECKOUT_ACTION__REMOVE;
+		*action = CHECKOUT_ACTION_IF(SAFE, REMOVE, NONE);
 		break;
 	default: /* impossible */
 		break;
-- 
cgit v1.2.3


From 94f263f59be5be74945367b9793c57f297ed4a44 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Sat, 25 Jan 2014 08:04:49 -0800
Subject: Add reflog params to set-head calls

---
 include/git2/repository.h   | 12 ++++++++++--
 src/clone.c                 | 31 +++++++++++++++++++++----------
 src/refs.c                  |  2 +-
 src/repository.c            | 27 ++++++++++++++++++---------
 tests/checkout/tree.c       | 22 +++++++++++-----------
 tests/checkout/typechange.c |  4 ++--
 tests/clone/nonetwork.c     |  2 +-
 tests/repo/head.c           | 16 ++++++++--------
 tests/status/submodules.c   |  2 +-
 9 files changed, 73 insertions(+), 45 deletions(-)

diff --git a/include/git2/repository.h b/include/git2/repository.h
index a0453da5c..648667cd6 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -567,11 +567,15 @@ GIT_EXTERN(int) git_repository_hashfile(
  *
  * @param repo Repository pointer
  * @param refname Canonical name of the reference the HEAD should point at
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message to be appended to the reflog
  * @return 0 on success, or an error code
  */
 GIT_EXTERN(int) git_repository_set_head(
 	git_repository* repo,
-	const char* refname);
+	const char* refname,
+	const git_signature *signature,
+	const char *log_message);
 
 /**
  * Make the repository HEAD directly point to the Commit.
@@ -587,11 +591,15 @@ GIT_EXTERN(int) git_repository_set_head(
  *
  * @param repo Repository pointer
  * @param commitish Object id of the Commit the HEAD should point to
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message to be appended to the reflog
  * @return 0 on success, or an error code
  */
 GIT_EXTERN(int) git_repository_set_head_detached(
 	git_repository* repo,
-	const git_oid* commitish);
+	const git_oid* commitish,
+	const git_signature *signature,
+	const char *log_message);
 
 /**
  * Detach the HEAD.
diff --git a/src/clone.c b/src/clone.c
index 2e9d72ab9..2bf2fc509 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -152,21 +152,26 @@ static int reference_matches_remote_head(
 static int update_head_to_new_branch(
 	git_repository *repo,
 	const git_oid *target,
-	const char *name)
+	const char *name,
+	const char *reflog_message)
 {
 	git_reference *tracking_branch = NULL;
 	int error = create_tracking_branch(&tracking_branch, repo, target, name);
 
 	if (!error)
 		error = git_repository_set_head(
-			repo, git_reference_name(tracking_branch));
+			repo, git_reference_name(tracking_branch),
+			NULL, reflog_message);
 
 	git_reference_free(tracking_branch);
 
 	return error;
 }
 
-static int update_head_to_remote(git_repository *repo, git_remote *remote)
+static int update_head_to_remote(
+		git_repository *repo,
+		git_remote *remote,
+		const char *reflog_message)
 {
 	int error = 0;
 	size_t refs_len;
@@ -215,7 +220,8 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 		error = update_head_to_new_branch(
 			repo,
 			&head_info.remote_head_oid,
-			git_buf_cstr(&head_info.branchname));
+			git_buf_cstr(&head_info.branchname),
+			reflog_message);
 		goto cleanup;
 	}
 
@@ -229,10 +235,11 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 		error = update_head_to_new_branch(
 			repo,
 			&head_info.remote_head_oid,
-			git_buf_cstr(&head_info.branchname));
+			git_buf_cstr(&head_info.branchname),
+			reflog_message);
 	} else {
 		error = git_repository_set_head_detached(
-			repo, &head_info.remote_head_oid);
+			repo, &head_info.remote_head_oid, NULL, reflog_message);
 	}
 
 cleanup:
@@ -244,7 +251,8 @@ cleanup:
 static int update_head_to_branch(
 		git_repository *repo,
 		const char *remote_name,
-		const char *branch)
+		const char *branch,
+		const char *reflog_message)
 {
 	int retcode;
 	git_buf remote_branch_name = GIT_BUF_INIT;
@@ -259,7 +267,7 @@ static int update_head_to_branch(
 	if ((retcode = git_reference_lookup(&remote_ref, repo, git_buf_cstr(&remote_branch_name))) < 0)
 		goto cleanup;
 
-	retcode = update_head_to_new_branch(repo, git_reference_target(remote_ref), branch);
+	retcode = update_head_to_new_branch(repo, git_reference_target(remote_ref), branch, reflog_message);
 
 cleanup:
 	git_reference_free(remote_ref);
@@ -323,6 +331,7 @@ int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_
 {
 	int error = 0, old_fetchhead;
 	git_strarray refspecs;
+	git_buf reflog_message = GIT_BUF_INIT;
 
 	assert(repo && remote);
 
@@ -340,15 +349,16 @@ int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_
 
 	old_fetchhead = git_remote_update_fetchhead(remote);
 	git_remote_set_update_fetchhead(remote, 0);
+	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
 
 	if ((error = git_remote_fetch(remote)) != 0)
 		goto cleanup;
 
 	if (branch)
-		error = update_head_to_branch(repo, git_remote_name(remote), branch);
+		error = update_head_to_branch(repo, git_remote_name(remote), branch, git_buf_cstr(&reflog_message));
 	/* Point HEAD to the same ref as the remote's head */
 	else
-		error = update_head_to_remote(repo, remote);
+		error = update_head_to_remote(repo, remote, git_buf_cstr(&reflog_message));
 
 	if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts))
 		error = git_checkout_head(repo, co_opts);
@@ -364,6 +374,7 @@ cleanup:
 	}
 
 	git_strarray_free(&refspecs);
+	git_buf_free(&reflog_message);
 
 	return error;
 }
diff --git a/src/refs.c b/src/refs.c
index 0f0a380ea..65e7e6439 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -545,7 +545,7 @@ static int reference__rename(git_reference **out, git_reference *ref, const char
 
 	/* Update HEAD it was pointing to the reference being renamed */
 	if (should_head_be_updated &&
-		(error = git_repository_set_head(ref->db->repo, new_name)) < 0) {
+		(error = git_repository_set_head(ref->db->repo, new_name, signature, message)) < 0) {
 		giterr_set(GITERR_REFERENCE, "Failed to update HEAD after renaming reference");
 		return error;
 	}
diff --git a/src/repository.c b/src/repository.c
index 285d8897f..2c1b60266 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1830,7 +1830,9 @@ static bool looks_like_a_branch(const char *refname)
 
 int git_repository_set_head(
 	git_repository* repo,
-	const char* refname)
+	const char* refname,
+	const git_signature *signature,
+	const char *log_message)
 {
 	git_reference *ref,
 		*new_head = NULL;
@@ -1843,12 +1845,17 @@ int git_repository_set_head(
 		return error;
 
 	if (!error) {
-		if (git_reference_is_branch(ref))
-			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, git_reference_name(ref), 1, NULL, NULL);
-		else
-			error = git_repository_set_head_detached(repo, git_reference_target(ref));
-	} else if (looks_like_a_branch(refname))
-		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname, 1, NULL, NULL);
+		if (git_reference_is_branch(ref)) {
+			error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE,
+					git_reference_name(ref), true, signature, log_message);
+		} else {
+			error = git_repository_set_head_detached(repo, git_reference_target(ref),
+					signature, log_message);
+		}
+	} else if (looks_like_a_branch(refname)) {
+		error = git_reference_symbolic_create(&new_head, repo, GIT_HEAD_FILE, refname,
+				true, signature, log_message);
+	}
 
 	git_reference_free(ref);
 	git_reference_free(new_head);
@@ -1857,7 +1864,9 @@ int git_repository_set_head(
 
 int git_repository_set_head_detached(
 	git_repository* repo,
-	const git_oid* commitish)
+	const git_oid* commitish,
+	const git_signature *signature,
+	const char *log_message)
 {
 	int error;
 	git_object *object,
@@ -1872,7 +1881,7 @@ int git_repository_set_head_detached(
 	if ((error = git_object_peel(&peeled, object, GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
-	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), 1, NULL, NULL);
+	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_object_id(peeled), true, signature, log_message);
 
 cleanup:
 	git_object_free(object);
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index 3c731c5ae..4e915e824 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -63,7 +63,7 @@ void test_checkout_tree__can_checkout_and_remove_directory(void)
 	cl_git_pass(git_revparse_single(&g_object, g_repo, "subtrees"));
 	cl_git_pass(git_checkout_tree(g_repo, g_object, &g_opts));
 
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees", NULL, NULL));
 
 	cl_assert_equal_i(true, git_path_isdir("./testrepo/ab/"));
 	cl_assert_equal_i(true, git_path_isfile("./testrepo/ab/de/2.txt"));
@@ -78,7 +78,7 @@ void test_checkout_tree__can_checkout_and_remove_directory(void)
 	cl_git_pass(git_revparse_single(&g_object, g_repo, "master"));
 	cl_git_pass(git_checkout_tree(g_repo, g_object, &g_opts));
 
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/master"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/master", NULL, NULL));
 
 	/* This directory should no longer exist */
 	cl_assert_equal_i(false, git_path_isdir("./testrepo/ab/"));
@@ -163,7 +163,7 @@ void test_checkout_tree__can_switch_branches(void)
 	cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY));
 
 	cl_git_pass(git_checkout_tree(g_repo, obj, &opts));
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/dir"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/dir", NULL, NULL));
 
 	cl_assert(git_path_isfile("testrepo/README"));
 	cl_assert(git_path_isfile("testrepo/branch_file.txt"));
@@ -183,7 +183,7 @@ void test_checkout_tree__can_switch_branches(void)
 	cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY));
 
 	cl_git_pass(git_checkout_tree(g_repo, obj, &opts));
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees", NULL, NULL));
 
 	cl_assert(git_path_isfile("testrepo/README"));
 	cl_assert(git_path_isfile("testrepo/branch_file.txt"));
@@ -253,7 +253,7 @@ static int checkout_tree_with_blob_ignored_in_workdir(int strategy, bool isdir)
 	cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY));
 
 	cl_git_pass(git_checkout_tree(g_repo, obj, &opts));
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/dir"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/dir", NULL, NULL));
 
 	cl_assert(git_path_isfile("testrepo/README"));
 	cl_assert(git_path_isfile("testrepo/branch_file.txt"));
@@ -313,7 +313,7 @@ void test_checkout_tree__can_overwrite_ignored_by_default(void)
 {
 	cl_git_pass(checkout_tree_with_blob_ignored_in_workdir(GIT_CHECKOUT_SAFE, false));
 
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees", NULL, NULL));
 
 	cl_assert(git_path_isfile("testrepo/ab/4.txt"));
 
@@ -334,7 +334,7 @@ void test_checkout_tree__can_overwrite_ignored_folder_by_default(void)
 {
 	cl_git_pass(checkout_tree_with_blob_ignored_in_workdir(GIT_CHECKOUT_SAFE, true));
 
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/subtrees", NULL, NULL));
 
 	cl_assert(git_path_isfile("testrepo/ab/4.txt"));
 
@@ -367,7 +367,7 @@ void test_checkout_tree__can_update_only(void)
 	cl_git_pass(git_object_lookup(&obj, g_repo, &oid, GIT_OBJ_ANY));
 
 	cl_git_pass(git_checkout_tree(g_repo, obj, &opts));
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/dir"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/dir", NULL, NULL));
 
 	assert_on_branch(g_repo, "dir");
 
@@ -396,7 +396,7 @@ void test_checkout_tree__can_checkout_with_pattern(void)
 
 	cl_git_pass(git_checkout_tree(g_repo, g_object, &g_opts));
 	cl_git_pass(
-		git_repository_set_head_detached(g_repo, git_object_id(g_object)));
+		git_repository_set_head_detached(g_repo, git_object_id(g_object), NULL, NULL));
 
 	git_object_free(g_object);
 	g_object = NULL;
@@ -435,7 +435,7 @@ void test_checkout_tree__can_disable_pattern_match(void)
 
 	cl_git_pass(git_checkout_tree(g_repo, g_object, &g_opts));
 	cl_git_pass(
-		git_repository_set_head_detached(g_repo, git_object_id(g_object)));
+		git_repository_set_head_detached(g_repo, git_object_id(g_object), NULL, NULL));
 
 	git_object_free(g_object);
 	g_object = NULL;
@@ -687,7 +687,7 @@ void test_checkout_tree__can_checkout_with_last_workdir_item_missing(void)
 	cl_git_pass(git_commit_lookup(&commit, g_repo, &commit_id));
 
 	cl_git_pass(git_checkout_tree(g_repo, (git_object *)commit, &opts));
-	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/master"));
+	cl_git_pass(git_repository_set_head(g_repo, "refs/heads/master", NULL, NULL));
 
 	cl_git_pass(p_mkdir("./testrepo/this-is-dir", 0777));
 	cl_git_mkfile("./testrepo/this-is-dir/contained_file", "content\n");
diff --git a/tests/checkout/typechange.c b/tests/checkout/typechange.c
index 6cf99ac15..d88864cf3 100644
--- a/tests/checkout/typechange.c
+++ b/tests/checkout/typechange.c
@@ -122,7 +122,7 @@ void test_checkout_typechange__checkout_typechanges_safe(void)
 		cl_git_pass(git_checkout_tree(g_repo, obj, &opts));
 
 		cl_git_pass(
-			git_repository_set_head_detached(g_repo, git_object_id(obj)));
+			git_repository_set_head_detached(g_repo, git_object_id(obj), NULL, NULL));
 
 		assert_workdir_matches_tree(g_repo, git_object_id(obj), NULL, true);
 
@@ -231,7 +231,7 @@ void test_checkout_typechange__checkout_with_conflicts(void)
 		cl_assert(!git_path_exists("typechanges/untracked"));
 
 		cl_git_pass(
-			git_repository_set_head_detached(g_repo, git_object_id(obj)));
+			git_repository_set_head_detached(g_repo, git_object_id(obj), NULL, NULL));
 
 		assert_workdir_matches_tree(g_repo, git_object_id(obj), NULL, true);
 
diff --git a/tests/clone/nonetwork.c b/tests/clone/nonetwork.c
index 3cd5fb7f6..863412cdb 100644
--- a/tests/clone/nonetwork.c
+++ b/tests/clone/nonetwork.c
@@ -217,7 +217,7 @@ void test_clone_nonetwork__can_detached_head(void)
 	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
 
 	cl_git_pass(git_revparse_single(&obj, g_repo, "master~1"));
-	cl_git_pass(git_repository_set_head_detached(g_repo, git_object_id(obj)));
+	cl_git_pass(git_repository_set_head_detached(g_repo, git_object_id(obj), NULL, NULL));
 
 	cl_git_pass(git_clone(&cloned, "./foo", "./foo1", &g_options));
 
diff --git a/tests/repo/head.c b/tests/repo/head.c
index 101e30f10..06e837d70 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -54,7 +54,7 @@ void test_repo_head__set_head_Attaches_HEAD_to_un_unborn_branch_when_the_branch_
 {
 	git_reference *head;
 
-	cl_git_pass(git_repository_set_head(repo, "refs/heads/doesnt/exist/yet"));
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/doesnt/exist/yet", NULL, NULL));
 
 	cl_assert_equal_i(false, git_repository_head_detached(repo));
 
@@ -63,19 +63,19 @@ void test_repo_head__set_head_Attaches_HEAD_to_un_unborn_branch_when_the_branch_
 
 void test_repo_head__set_head_Returns_ENOTFOUND_when_the_reference_doesnt_exist(void)
 {
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_set_head(repo, "refs/tags/doesnt/exist/yet"));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_set_head(repo, "refs/tags/doesnt/exist/yet", NULL, NULL));
 }
 
 void test_repo_head__set_head_Fails_when_the_reference_points_to_a_non_commitish(void)
 {
-	cl_git_fail(git_repository_set_head(repo, "refs/tags/point_to_blob"));
+	cl_git_fail(git_repository_set_head(repo, "refs/tags/point_to_blob", NULL, NULL));
 }
 
 void test_repo_head__set_head_Attaches_HEAD_when_the_reference_points_to_a_branch(void)
 {
 	git_reference *head;
 
-	cl_git_pass(git_repository_set_head(repo, "refs/heads/br2"));
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/br2", NULL, NULL));
 
 	cl_assert_equal_i(false, git_repository_head_detached(repo));
 
@@ -102,7 +102,7 @@ static void assert_head_is_correctly_detached(void)
 
 void test_repo_head__set_head_Detaches_HEAD_when_the_reference_doesnt_point_to_a_branch(void)
 {
-	cl_git_pass(git_repository_set_head(repo, "refs/tags/test"));
+	cl_git_pass(git_repository_set_head(repo, "refs/tags/test", NULL, NULL));
 
 	cl_assert_equal_i(true, git_repository_head_detached(repo));
 
@@ -115,7 +115,7 @@ void test_repo_head__set_head_detached_Return_ENOTFOUND_when_the_object_doesnt_e
 
 	cl_git_pass(git_oid_fromstr(&oid, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef"));
 
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_set_head_detached(repo, &oid));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_set_head_detached(repo, &oid, NULL, NULL));
 }
 
 void test_repo_head__set_head_detached_Fails_when_the_object_isnt_a_commitish(void)
@@ -124,7 +124,7 @@ void test_repo_head__set_head_detached_Fails_when_the_object_isnt_a_commitish(vo
 
 	cl_git_pass(git_revparse_single(&blob, repo, "point_to_blob"));
 
-	cl_git_fail(git_repository_set_head_detached(repo, git_object_id(blob)));
+	cl_git_fail(git_repository_set_head_detached(repo, git_object_id(blob), NULL, NULL));
 
 	git_object_free(blob);
 }
@@ -136,7 +136,7 @@ void test_repo_head__set_head_detached_Detaches_HEAD_and_make_it_point_to_the_pe
 	cl_git_pass(git_revparse_single(&tag, repo, "tags/test"));
 	cl_assert_equal_i(GIT_OBJ_TAG, git_object_type(tag));
 
-	cl_git_pass(git_repository_set_head_detached(repo, git_object_id(tag)));
+	cl_git_pass(git_repository_set_head_detached(repo, git_object_id(tag), NULL, NULL));
 
 	assert_head_is_correctly_detached();
 
diff --git a/tests/status/submodules.c b/tests/status/submodules.c
index dc7990cf1..80ff162fd 100644
--- a/tests/status/submodules.c
+++ b/tests/status/submodules.c
@@ -140,7 +140,7 @@ void test_status_submodules__moved_head(void)
 	/* move submodule HEAD to c47800c7266a2be04c571c04d5a6614691ea99bd */
 	cl_git_pass(
 		git_oid_fromstr(&oid, "c47800c7266a2be04c571c04d5a6614691ea99bd"));
-	cl_git_pass(git_repository_set_head_detached(smrepo, &oid));
+	cl_git_pass(git_repository_set_head_detached(smrepo, &oid, NULL, NULL));
 
 	/* first do a normal status, which should now include the submodule */
 
-- 
cgit v1.2.3


From a2311f92c29e0fee5348d580c3318cf6724cd765 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 27 Jan 2014 13:12:31 -0800
Subject: Ensure updating HEAD updates reflog

---
 src/refdb_fs.c    |  7 ++++---
 tests/repo/head.c | 23 +++++++++++++++++++++++
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 53c42458f..9ae784782 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1434,12 +1434,12 @@ success:
 static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_signature *who, const char *message)
 {
 	int error;
-	git_oid old_id, new_id;
+	git_oid old_id, new_id = {{0}};
 	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
 	git_repository *repo = backend->repo;
 
 	/* Creation of symbolic references doesn't get a reflog entry */
-	if (ref->type == GIT_REF_SYMBOLIC)
+	if (ref->type == GIT_REF_SYMBOLIC && strcmp(ref->name, GIT_HEAD_FILE))
 		return 0;
 
 	error = git_reference_name_to_id(&old_id, repo, ref->name);
@@ -1450,7 +1450,8 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	if (error < 0)
 		return error;
 
-	git_oid_cpy(&new_id, git_reference_target(ref));
+	if (git_reference_target(ref) != NULL)
+		git_oid_cpy(&new_id, git_reference_target(ref));
 
 	if ((error = serialize_reflog_entry(&buf, &old_id, &new_id, who, message)) < 0)
 		goto cleanup;
diff --git a/tests/repo/head.c b/tests/repo/head.c
index 06e837d70..df7059fd5 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -194,3 +194,26 @@ void test_repo_head__can_tell_if_an_unborn_head_is_detached(void)
 
 	cl_assert_equal_i(false, git_repository_head_detached(repo));
 }
+
+void test_repo_head__setting_head_updates_reflog(void)
+{
+	git_reflog *log;
+	const git_reflog_entry *entry1, *entry2, *entry3;
+	git_object *tag;
+
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", NULL, "message1"));
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/unborn", NULL, "message2"));
+	cl_git_pass(git_revparse_single(&tag, repo, "tags/test"));
+	cl_git_pass(git_repository_set_head_detached(repo, git_object_id(tag), NULL, "message3"));
+
+	cl_git_pass(git_reflog_read(&log, repo, "HEAD"));
+	entry1 = git_reflog_entry_byindex(log, 2);
+	entry2 = git_reflog_entry_byindex(log, 1);
+	entry3 = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("message1", git_reflog_entry_message(entry1));
+	cl_assert_equal_s("message2", git_reflog_entry_message(entry2));
+	cl_assert_equal_s("message3", git_reflog_entry_message(entry3));
+
+	git_reflog_free(log);
+	git_object_free(tag);
+}
-- 
cgit v1.2.3


From 6357388e983be6ad5831d63b84aeb2f9c449411e Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 27 Jan 2014 13:24:10 -0800
Subject: Enhance clarity

---
 src/refdb_fs.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 9ae784782..41ff01998 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1438,8 +1438,10 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
 	git_repository *repo = backend->repo;
 
-	/* Creation of symbolic references doesn't get a reflog entry */
-	if (ref->type == GIT_REF_SYMBOLIC && strcmp(ref->name, GIT_HEAD_FILE))
+	/* Creation of a symbolic reference doesn't get a reflog entry, except for
+	 * HEAD. git_repository_set_head and friends go through here. */
+	if (ref->type == GIT_REF_SYMBOLIC &&
+	    0 != strcmp(ref->name, GIT_HEAD_FILE))
 		return 0;
 
 	error = git_reference_name_to_id(&old_id, repo, ref->name);
-- 
cgit v1.2.3


From 2952a9d0f474547db88f396dd8cc7c62d61993a2 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 27 Jan 2014 13:39:48 -0800
Subject: Ensure creating HEAD creates its reflog

---
 tests/repo/head.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/tests/repo/head.c b/tests/repo/head.c
index df7059fd5..d28f254c3 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -217,3 +217,24 @@ void test_repo_head__setting_head_updates_reflog(void)
 	git_reflog_free(log);
 	git_object_free(tag);
 }
+
+void test_repo_head__setting_creates_head_ref(void)
+{
+	git_reference *head;
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	cl_git_pass(git_reference_lookup(&head, repo, "HEAD"));
+	cl_git_pass(git_reference_delete(head));
+	cl_git_pass(git_reflog_delete(repo, "HEAD"));
+
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", NULL, "create HEAD"));
+
+	cl_git_pass(git_reflog_read(&log, repo, "HEAD"));
+	cl_assert_equal_i(1, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("create HEAD", git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
+	git_reference_free(head);
+}
-- 
cgit v1.2.3


From 67c4716f74f322b79a3e4355c273bc423eb58ec6 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 27 Jan 2014 13:47:48 -0800
Subject: Add passing reflog tests

---
 tests/refs/branches/create.c | 30 +++++++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index e4ad6683e..43614bd76 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -66,7 +66,6 @@ void test_refs_branches_create__can_force_create_over_an_existing_branch(void)
 	cl_assert_equal_s("refs/heads/br2", git_reference_name(branch));
 }
 
-
 void test_refs_branches_create__creating_a_branch_with_an_invalid_name_returns_EINVALIDSPEC(void)
 {
 	retrieve_known_commit(&target, repo);
@@ -75,3 +74,32 @@ void test_refs_branches_create__creating_a_branch_with_an_invalid_name_returns_E
 		git_branch_create(&branch, repo, "inv@{id", target, 0));
 }
 
+void test_refs_branches_create__creation_creates_new_reflog(void)
+{
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	retrieve_known_commit(&target, repo);
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false));
+	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/" NEW_BRANCH_NAME));
+
+	cl_assert_equal_i(1, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+}
+
+void test_refs_branches_create__recreation_updates_existing_reflog(void)
+{
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	retrieve_known_commit(&target, repo);
+
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false));
+	cl_git_pass(git_branch_delete(branch));
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false));
+	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/" NEW_BRANCH_NAME));
+
+	cl_assert_equal_i(2, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+}
+
-- 
cgit v1.2.3


From b31ebfbc666202fb576f7eb406d7a699134da09d Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 27 Jan 2014 14:12:29 -0800
Subject: Add reflog params to git_branch_create

---
 include/git2/branch.h          |  8 +++++++-
 src/branch.c                   | 16 +++++++++-------
 src/clone.c                    |  2 +-
 tests/checkout/tree.c          |  2 +-
 tests/refs/branches/create.c   | 22 +++++++++++++---------
 tests/refs/branches/upstream.c |  2 +-
 tests/refs/revparse.c          |  6 +++---
 7 files changed, 35 insertions(+), 23 deletions(-)

diff --git a/include/git2/branch.h b/include/git2/branch.h
index 851de290a..28ca6b233 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -43,6 +43,10 @@ GIT_BEGIN_DECL
  *
  * @param force Overwrite existing branch.
  *
+ * @param signature The identity that will used to populate the reflog entry
+ *
+ * @param log_message The one line long message to be appended to the reflog
+ *
  * @return 0, GIT_EINVALIDSPEC or an error code.
  * A proper reference is written in the refs/heads namespace
  * pointing to the provided target commit.
@@ -52,7 +56,9 @@ GIT_EXTERN(int) git_branch_create(
 	git_repository *repo,
 	const char *branch_name,
 	const git_commit *target,
-	int force);
+	int force,
+	const git_signature *signature,
+	const char *log_message);
 
 /**
  * Delete an existing branch reference.
diff --git a/src/branch.c b/src/branch.c
index d0dc21b85..a989cb61d 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -54,7 +54,9 @@ int git_branch_create(
 	git_repository *repository,
 	const char *branch_name,
 	const git_commit *commit,
-	int force)
+	int force,
+	const git_signature *signature,
+	const char *log_message)
 {
 	git_reference *branch = NULL;
 	git_buf canonical_branch_name = GIT_BUF_INIT;
@@ -63,14 +65,14 @@ int git_branch_create(
 	assert(branch_name && commit && ref_out);
 	assert(git_object_owner((const git_object *)commit) == repository);
 
-	if (!(error = git_buf_joinpath(
-			&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name)))
-		error = git_reference_create(
-			&branch, repository, git_buf_cstr(&canonical_branch_name),
-			git_commit_id(commit), force, NULL, NULL);
+	if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0)
+		goto cleanup;
 
-	*ref_out = branch;
+	if (!(error = git_reference_create(&branch, repository,
+		git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force, signature, log_message)))
+		*ref_out = branch;
 
+cleanup:
 	git_buf_free(&canonical_branch_name);
 	return error;
 }
diff --git a/src/clone.c b/src/clone.c
index 2bf2fc509..288e9d2c8 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -38,7 +38,7 @@ static int create_branch(
 		return error;
 
 	/* Create the new branch */
-	error = git_branch_create(&branch_ref, repo, name, head_obj, 0);
+	error = git_branch_create(&branch_ref, repo, name, head_obj, 0, NULL, NULL);
 
 	git_commit_free(head_obj);
 
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index 4e915e824..407908ad3 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -480,7 +480,7 @@ void assert_conflict(
 	/* Create a branch pointing at the parent */
 	cl_git_pass(git_revparse_single(&g_object, g_repo, parent_sha));
 	cl_git_pass(git_branch_create(&branch, g_repo,
-		"potential_conflict", (git_commit *)g_object, 0));
+		"potential_conflict", (git_commit *)g_object, 0, NULL, NULL));
 
 	/* Make HEAD point to this branch */
 	cl_git_pass(git_reference_symbolic_create(
diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 43614bd76..43f2affb9 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -46,7 +46,7 @@ void test_refs_branches_create__can_create_a_local_branch(void)
 {
 	retrieve_known_commit(&target, repo);
 
-	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0));
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, 0, NULL, NULL));
 	cl_git_pass(git_oid_cmp(git_reference_target(branch), git_commit_id(target)));
 }
 
@@ -54,14 +54,14 @@ void test_refs_branches_create__can_not_create_a_branch_if_its_name_collide_with
 {
 	retrieve_known_commit(&target, repo);
 
-	cl_assert_equal_i(GIT_EEXISTS, git_branch_create(&branch, repo, "br2", target, 0));
+	cl_assert_equal_i(GIT_EEXISTS, git_branch_create(&branch, repo, "br2", target, 0, NULL, NULL));
 }
 
 void test_refs_branches_create__can_force_create_over_an_existing_branch(void)
 {
 	retrieve_known_commit(&target, repo);
 
-	cl_git_pass(git_branch_create(&branch, repo, "br2", target, 1));
+	cl_git_pass(git_branch_create(&branch, repo, "br2", target, 1, NULL, NULL));
 	cl_git_pass(git_oid_cmp(git_reference_target(branch), git_commit_id(target)));
 	cl_assert_equal_s("refs/heads/br2", git_reference_name(branch));
 }
@@ -71,7 +71,7 @@ void test_refs_branches_create__creating_a_branch_with_an_invalid_name_returns_E
 	retrieve_known_commit(&target, repo);
 
 	cl_assert_equal_i(GIT_EINVALIDSPEC,
-		git_branch_create(&branch, repo, "inv@{id", target, 0));
+		git_branch_create(&branch, repo, "inv@{id", target, 0, NULL, NULL));
 }
 
 void test_refs_branches_create__creation_creates_new_reflog(void)
@@ -80,26 +80,30 @@ void test_refs_branches_create__creation_creates_new_reflog(void)
 	const git_reflog_entry *entry;
 
 	retrieve_known_commit(&target, repo);
-	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false));
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, NULL, "create!"));
 	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/" NEW_BRANCH_NAME));
 
 	cl_assert_equal_i(1, git_reflog_entrycount(log));
 	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("create!", git_reflog_entry_message(entry));
 }
 
 void test_refs_branches_create__recreation_updates_existing_reflog(void)
 {
 	git_reflog *log;
-	const git_reflog_entry *entry;
+	const git_reflog_entry *entry1, *entry2;
 
 	retrieve_known_commit(&target, repo);
 
-	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false));
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, NULL, "Create 1"));
 	cl_git_pass(git_branch_delete(branch));
-	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false));
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, NULL, "Create 2"));
 	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/" NEW_BRANCH_NAME));
 
 	cl_assert_equal_i(2, git_reflog_entrycount(log));
-	entry = git_reflog_entry_byindex(log, 0);
+	entry1 = git_reflog_entry_byindex(log, 1);
+	entry2 = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("Create 1", git_reflog_entry_message(entry1));
+	cl_assert_equal_s("Create 2", git_reflog_entry_message(entry2));
 }
 
diff --git a/tests/refs/branches/upstream.c b/tests/refs/branches/upstream.c
index 69e55a0c5..ce3569813 100644
--- a/tests/refs/branches/upstream.c
+++ b/tests/refs/branches/upstream.c
@@ -66,7 +66,7 @@ static void assert_merge_and_or_remote_key_missing(git_repository *repository, c
 	git_reference *branch;
 
 	cl_assert_equal_i(GIT_OBJ_COMMIT, git_object_type((git_object*)target));
-	cl_git_pass(git_branch_create(&branch, repository, entry_name, (git_commit*)target, 0));
+	cl_git_pass(git_branch_create(&branch, repository, entry_name, (git_commit*)target, 0, NULL, NULL));
 
 	cl_assert_equal_i(GIT_ENOTFOUND, git_branch_upstream(&upstream, branch));
 
diff --git a/tests/refs/revparse.c b/tests/refs/revparse.c
index 522a44c82..88f270326 100644
--- a/tests/refs/revparse.c
+++ b/tests/refs/revparse.c
@@ -634,7 +634,7 @@ void test_refs_revparse__try_to_retrieve_branch_before_described_tag(void)
 	test_object_inrepo("blah-7-gc47800c", "c47800c7266a2be04c571c04d5a6614691ea99bd", repo);
 
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~3"));
-	cl_git_pass(git_branch_create(&branch, repo, "blah-7-gc47800c", (git_commit *)target, 0));
+	cl_git_pass(git_branch_create(&branch, repo, "blah-7-gc47800c", (git_commit *)target, 0, NULL, NULL));
 
 	git_oid_tostr(sha, GIT_OID_HEXSZ + 1, git_object_id(target));
 
@@ -672,7 +672,7 @@ void test_refs_revparse__try_to_retrieve_sha_before_branch(void)
 	test_object_inrepo("a65fedf39aefe402d3bb6e24df4d4f5fe4547750", "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", repo);
 
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~3"));
-	cl_git_pass(git_branch_create(&branch, repo, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", (git_commit *)target, 0));
+	cl_git_pass(git_branch_create(&branch, repo, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750", (git_commit *)target, 0, NULL, NULL));
 
 	git_oid_tostr(sha, GIT_OID_HEXSZ + 1, git_object_id(target));
 
@@ -708,7 +708,7 @@ void test_refs_revparse__try_to_retrieve_branch_before_abbrev_sha(void)
 	test_object_inrepo("c47800", "c47800c7266a2be04c571c04d5a6614691ea99bd", repo);
 
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~3"));
-	cl_git_pass(git_branch_create(&branch, repo, "c47800", (git_commit *)target, 0));
+	cl_git_pass(git_branch_create(&branch, repo, "c47800", (git_commit *)target, 0, NULL, NULL));
 
 	git_oid_tostr(sha, GIT_OID_HEXSZ + 1, git_object_id(target));
 
-- 
cgit v1.2.3


From 1cc974ab625c2fa0794130eb97ca88c449fc1a06 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 27 Jan 2014 14:40:31 -0800
Subject: Augment clone API with reflog parameters

---
 include/git2/clone.h    |  7 ++++++-
 src/clone.c             | 36 +++++++++++++++++++++++-------------
 tests/clone/nonetwork.c | 44 ++++++++++++++++++++++++++++++++++++++++++++
 tests/online/clone.c    |  2 +-
 4 files changed, 74 insertions(+), 15 deletions(-)

diff --git a/include/git2/clone.h b/include/git2/clone.h
index 59a73aa15..3e885d103 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -45,6 +45,8 @@ GIT_BEGIN_DECL
  *   default is "origin".
  * - `checkout_branch` gives the name of the branch to checkout.  NULL
  *   means use the remote's HEAD.
+ * - `signature` is the identity used when updating the reflog. NULL means to
+ *   use the default signature using the config.
  */
 
 typedef struct git_clone_options {
@@ -57,6 +59,7 @@ typedef struct git_clone_options {
 	int ignore_cert_errors;
 	const char *remote_name;
 	const char* checkout_branch;
+	git_signature *signature;
 } git_clone_options;
 
 #define GIT_CLONE_OPTIONS_VERSION 1
@@ -96,6 +99,7 @@ GIT_EXTERN(int) git_clone(
  * @param co_opts options to use during checkout
  * @param branch the branch to checkout after the clone, pass NULL for the
  *        remote's default branch
+ * @param signature The identity used when updating the reflog.
  * @return 0 on success, any non-zero return value from a callback
  *         function, or a negative value to indicate an error (use
  *         `giterr_last` for a detailed error message)
@@ -104,7 +108,8 @@ GIT_EXTERN(int) git_clone_into(
 	git_repository *repo,
 	git_remote *remote,
 	const git_checkout_opts *co_opts,
-	const char *branch);
+	const char *branch,
+	const git_signature *signature);
 
 /** @} */
 GIT_END_DECL
diff --git a/src/clone.c b/src/clone.c
index 288e9d2c8..97d25bdcd 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -27,7 +27,9 @@ static int create_branch(
 	git_reference **branch,
 	git_repository *repo,
 	const git_oid *target,
-	const char *name)
+	const char *name,
+	const git_signature *signature,
+	const char *log_message)
 {
 	git_commit *head_obj = NULL;
 	git_reference *branch_ref = NULL;
@@ -38,7 +40,7 @@ static int create_branch(
 		return error;
 
 	/* Create the new branch */
-	error = git_branch_create(&branch_ref, repo, name, head_obj, 0, NULL, NULL);
+	error = git_branch_create(&branch_ref, repo, name, head_obj, 0, signature, log_message);
 
 	git_commit_free(head_obj);
 
@@ -87,11 +89,13 @@ static int create_tracking_branch(
 	git_reference **branch,
 	git_repository *repo,
 	const git_oid *target,
-	const char *branch_name)
+	const char *branch_name,
+	const git_signature *signature,
+	const char *log_message)
 {
 	int error;
 
-	if ((error = create_branch(branch, repo, target, branch_name)) < 0)
+	if ((error = create_branch(branch, repo, target, branch_name, signature, log_message)) < 0)
 		return error;
 
 	return setup_tracking_config(
@@ -153,15 +157,17 @@ static int update_head_to_new_branch(
 	git_repository *repo,
 	const git_oid *target,
 	const char *name,
+	const git_signature *signature,
 	const char *reflog_message)
 {
 	git_reference *tracking_branch = NULL;
-	int error = create_tracking_branch(&tracking_branch, repo, target, name);
+	int error = create_tracking_branch(&tracking_branch, repo, target, name,
+			signature, reflog_message);
 
 	if (!error)
 		error = git_repository_set_head(
 			repo, git_reference_name(tracking_branch),
-			NULL, reflog_message);
+			signature, reflog_message);
 
 	git_reference_free(tracking_branch);
 
@@ -171,6 +177,7 @@ static int update_head_to_new_branch(
 static int update_head_to_remote(
 		git_repository *repo,
 		git_remote *remote,
+		const git_signature *signature,
 		const char *reflog_message)
 {
 	int error = 0;
@@ -221,7 +228,7 @@ static int update_head_to_remote(
 			repo,
 			&head_info.remote_head_oid,
 			git_buf_cstr(&head_info.branchname),
-			reflog_message);
+			signature, reflog_message);
 		goto cleanup;
 	}
 
@@ -236,7 +243,7 @@ static int update_head_to_remote(
 			repo,
 			&head_info.remote_head_oid,
 			git_buf_cstr(&head_info.branchname),
-			reflog_message);
+			signature, reflog_message);
 	} else {
 		error = git_repository_set_head_detached(
 			repo, &head_info.remote_head_oid, NULL, reflog_message);
@@ -252,6 +259,7 @@ static int update_head_to_branch(
 		git_repository *repo,
 		const char *remote_name,
 		const char *branch,
+		const git_signature *signature,
 		const char *reflog_message)
 {
 	int retcode;
@@ -267,7 +275,8 @@ static int update_head_to_branch(
 	if ((retcode = git_reference_lookup(&remote_ref, repo, git_buf_cstr(&remote_branch_name))) < 0)
 		goto cleanup;
 
-	retcode = update_head_to_new_branch(repo, git_reference_target(remote_ref), branch, reflog_message);
+	retcode = update_head_to_new_branch(repo, git_reference_target(remote_ref), branch,
+			signature, reflog_message);
 
 cleanup:
 	git_reference_free(remote_ref);
@@ -327,7 +336,7 @@ static bool should_checkout(
 	return !git_repository_head_unborn(repo);
 }
 
-int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_opts *co_opts, const char *branch)
+int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_opts *co_opts, const char *branch, const git_signature *signature)
 {
 	int error = 0, old_fetchhead;
 	git_strarray refspecs;
@@ -355,10 +364,11 @@ int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_
 		goto cleanup;
 
 	if (branch)
-		error = update_head_to_branch(repo, git_remote_name(remote), branch, git_buf_cstr(&reflog_message));
+		error = update_head_to_branch(repo, git_remote_name(remote), branch,
+				signature, git_buf_cstr(&reflog_message));
 	/* Point HEAD to the same ref as the remote's head */
 	else
-		error = update_head_to_remote(repo, remote, git_buf_cstr(&reflog_message));
+		error = update_head_to_remote(repo, remote, signature, git_buf_cstr(&reflog_message));
 
 	if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts))
 		error = git_checkout_head(repo, co_opts);
@@ -414,7 +424,7 @@ int git_clone(
 
 	if (!(error = create_and_configure_origin(&origin, repo, url, &options))) {
 		error = git_clone_into(
-			repo, origin, &options.checkout_opts, options.checkout_branch);
+			repo, origin, &options.checkout_opts, options.checkout_branch, options.signature);
 
 		git_remote_free(origin);
 	}
diff --git a/tests/clone/nonetwork.c b/tests/clone/nonetwork.c
index 863412cdb..14d2bbf59 100644
--- a/tests/clone/nonetwork.c
+++ b/tests/clone/nonetwork.c
@@ -232,3 +232,47 @@ void test_clone_nonetwork__can_detached_head(void)
 
 	cl_fixture_cleanup("./foo1");
 }
+
+static void assert_correct_reflog(const char *name)
+{
+	git_reflog *log;
+	const git_reflog_entry *entry;
+	char expected_log_message[128] = {0};
+
+	sprintf(expected_log_message, "clone: from %s", cl_git_fixture_url("testrepo.git"));
+
+	cl_git_pass(git_reflog_read(&log, g_repo, name));
+	cl_assert_equal_i(1, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s(expected_log_message, git_reflog_entry_message(entry));
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
+
+	git_reflog_free(log);
+}
+
+void test_clone_nonetwork__clone_updates_reflog_properly(void)
+{
+	cl_git_pass(git_signature_now(&g_options.signature, "Me", "foo@example.com"));
+	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
+	assert_correct_reflog("HEAD");
+	assert_correct_reflog("refs/heads/master");
+
+	git_signature_free(g_options.signature);
+}
+
+void test_clone_nonetwork__clone_into_updates_reflog_properly(void)
+{
+	git_remote *remote;
+	git_signature *sig;
+	cl_git_pass(git_signature_now(&sig, "Me", "foo@example.com"));
+
+	cl_git_pass(git_repository_init(&g_repo, "./foo", false));
+	cl_git_pass(git_remote_create(&remote, g_repo, "origin", cl_git_fixture_url("testrepo.git")));
+	cl_git_pass(git_clone_into(g_repo, remote, NULL, NULL, sig));
+
+	assert_correct_reflog("HEAD");
+	assert_correct_reflog("refs/heads/master");
+
+	git_remote_free(remote);
+	git_signature_free(g_options.signature);
+}
diff --git a/tests/online/clone.c b/tests/online/clone.c
index be4421ae5..1222d174d 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -147,7 +147,7 @@ void test_online_clone__clone_into(void)
 	callbacks.payload = &fetch_progress_cb_was_called;
 	git_remote_set_callbacks(remote, &callbacks);
 
-	cl_git_pass(git_clone_into(g_repo, remote, &checkout_opts, NULL));
+	cl_git_pass(git_clone_into(g_repo, remote, &checkout_opts, NULL, NULL));
 
 	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "master.txt"));
 	cl_assert_equal_i(true, git_path_isfile(git_buf_cstr(&path)));
-- 
cgit v1.2.3


From 48110f67e4a21caac1b8157d8239d16cd9781e51 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 28 Jan 2014 10:31:54 -0800
Subject: Deleting a branch deletes its reflog

---
 src/branch.c                 |  3 +++
 tests/refs/branches/create.c | 20 --------------------
 tests/refs/branches/delete.c | 26 ++++++++++++++++++++++++++
 3 files changed, 29 insertions(+), 20 deletions(-)

diff --git a/src/branch.c b/src/branch.c
index a989cb61d..531101f8a 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -111,6 +111,9 @@ int git_branch_delete(git_reference *branch)
 	if (git_reference_delete(branch) < 0)
 		goto on_error;
 
+	if (git_reflog_delete(git_reference_owner(branch), git_reference_name(branch)) < 0)
+		goto on_error;
+
 	error = 0;
 
 on_error:
diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 43f2affb9..0c0fdb013 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -87,23 +87,3 @@ void test_refs_branches_create__creation_creates_new_reflog(void)
 	entry = git_reflog_entry_byindex(log, 0);
 	cl_assert_equal_s("create!", git_reflog_entry_message(entry));
 }
-
-void test_refs_branches_create__recreation_updates_existing_reflog(void)
-{
-	git_reflog *log;
-	const git_reflog_entry *entry1, *entry2;
-
-	retrieve_known_commit(&target, repo);
-
-	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, NULL, "Create 1"));
-	cl_git_pass(git_branch_delete(branch));
-	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, NULL, "Create 2"));
-	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/" NEW_BRANCH_NAME));
-
-	cl_assert_equal_i(2, git_reflog_entrycount(log));
-	entry1 = git_reflog_entry_byindex(log, 1);
-	entry2 = git_reflog_entry_byindex(log, 0);
-	cl_assert_equal_s("Create 1", git_reflog_entry_message(entry1));
-	cl_assert_equal_s("Create 2", git_reflog_entry_message(entry2));
-}
-
diff --git a/tests/refs/branches/delete.c b/tests/refs/branches/delete.c
index a642f8704..7d1d400c8 100644
--- a/tests/refs/branches/delete.c
+++ b/tests/refs/branches/delete.c
@@ -115,3 +115,29 @@ void test_refs_branches_delete__deleting_a_branch_removes_related_configuration_
 	assert_config_entry_existence(repo, "branch.track-local.remote", false);
 	assert_config_entry_existence(repo, "branch.track-local.merge", false);
 }
+
+void test_refs_branches_delete__removes_reflog(void)
+{
+	git_reference *branch;
+	git_reflog *log;
+	git_oid oidzero = {{0}};
+	git_signature *sig;
+
+	/* Ensure the reflog has at least one entry */
+	cl_git_pass(git_signature_now(&sig, "Me", "user@example.com"));
+	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/track-local"));
+	cl_git_pass(git_reflog_append(log, &oidzero, sig, "message"));
+	cl_assert(git_reflog_entrycount(log) > 0);
+	git_signature_free(sig);
+	git_reflog_free(log);
+
+	cl_git_pass(git_branch_lookup(&branch, repo, "track-local", GIT_BRANCH_LOCAL));
+	cl_git_pass(git_branch_delete(branch));
+	git_reference_free(branch);
+
+	/* Reading a nonexistant reflog creates it, but it should be empty */
+	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/track-local"));
+	cl_assert_equal_i(0, git_reflog_entrycount(log));
+	git_reflog_free(log);
+}
+
-- 
cgit v1.2.3


From 540c1809f40c1bb3cf08627a85921309852fa963 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 28 Jan 2014 10:44:33 -0800
Subject: Add reflog parameters to git_branch_move

---
 include/git2/branch.h      |  8 +++++++-
 src/branch.c               |  4 +++-
 tests/refs/branches/move.c | 26 +++++++++++++-------------
 3 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/include/git2/branch.h b/include/git2/branch.h
index 28ca6b233..e653077d5 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -121,13 +121,19 @@ GIT_EXTERN(void) git_branch_iterator_free(git_branch_iterator *iter);
  *
  * @param force Overwrite existing branch.
  *
+ * @param signature The identity that will used to populate the reflog entry
+ *
+ * @param log_message The one line long message to be appended to the reflog
+ *
  * @return 0 on success, GIT_EINVALIDSPEC or an error code.
  */
 GIT_EXTERN(int) git_branch_move(
 	git_reference **out,
 	git_reference *branch,
 	const char *new_branch_name,
-	int force);
+	int force,
+	const git_signature *signature,
+	const char *log_message);
 
 /**
  * Lookup a branch by its name in a repository.
diff --git a/src/branch.c b/src/branch.c
index 531101f8a..4658d3bdd 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -190,7 +190,9 @@ int git_branch_move(
 	git_reference **out,
 	git_reference *branch,
 	const char *new_branch_name,
-	int force)
+	int force,
+	const git_signature *signature,
+	const char *log_message)
 {
 	git_buf new_reference_name = GIT_BUF_INIT,
 		old_config_section = GIT_BUF_INIT,
diff --git a/tests/refs/branches/move.c b/tests/refs/branches/move.c
index 9d233de1a..bea93b9b3 100644
--- a/tests/refs/branches/move.c
+++ b/tests/refs/branches/move.c
@@ -22,7 +22,7 @@ void test_refs_branches_move__can_move_a_local_branch(void)
 
 	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
 
-	cl_git_pass(git_branch_move(&new_ref, original_ref, NEW_BRANCH_NAME, 0));
+	cl_git_pass(git_branch_move(&new_ref, original_ref, NEW_BRANCH_NAME, 0, NULL, NULL));
 	cl_assert_equal_s(GIT_REFS_HEADS_DIR NEW_BRANCH_NAME, git_reference_name(new_ref));
 
 	git_reference_free(original_ref);
@@ -36,11 +36,11 @@ void test_refs_branches_move__can_move_a_local_branch_to_a_different_namespace(v
 	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
 
 	/* Downward */
-	cl_git_pass(git_branch_move(&new_ref, original_ref, "somewhere/" NEW_BRANCH_NAME, 0));
+	cl_git_pass(git_branch_move(&new_ref, original_ref, "somewhere/" NEW_BRANCH_NAME, 0, NULL, NULL));
 	git_reference_free(original_ref);
 
 	/* Upward */
-	cl_git_pass(git_branch_move(&newer_ref, new_ref, "br2", 0));
+	cl_git_pass(git_branch_move(&newer_ref, new_ref, "br2", 0, NULL, NULL));
 	git_reference_free(new_ref);
 
 	git_reference_free(newer_ref);
@@ -53,11 +53,11 @@ void test_refs_branches_move__can_move_a_local_branch_to_a_partially_colliding_n
 	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
 
 	/* Downward */
-	cl_git_pass(git_branch_move(&new_ref, original_ref, "br2/" NEW_BRANCH_NAME, 0));
+	cl_git_pass(git_branch_move(&new_ref, original_ref, "br2/" NEW_BRANCH_NAME, 0, NULL, NULL));
 	git_reference_free(original_ref);
 
 	/* Upward */
-	cl_git_pass(git_branch_move(&newer_ref, new_ref, "br2", 0));
+	cl_git_pass(git_branch_move(&newer_ref, new_ref, "br2", 0, NULL, NULL));
 	git_reference_free(new_ref);
 
 	git_reference_free(newer_ref);
@@ -81,7 +81,7 @@ void test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_coll
 	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
 
 	cl_assert_equal_i(GIT_EEXISTS,
-		git_branch_move(&new_ref, original_ref, "master", 0));
+		git_branch_move(&new_ref, original_ref, "master", 0, NULL, NULL));
 
 	cl_assert(giterr_last()->message != NULL);
 	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.remote"));
@@ -91,7 +91,7 @@ void test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_coll
 
 
 	cl_assert_equal_i(GIT_EEXISTS,
-		git_branch_move(&new_ref, original_ref, "cannot-fetch", 0));
+		git_branch_move(&new_ref, original_ref, "cannot-fetch", 0, NULL, NULL));
 
 	cl_assert(giterr_last()->message != NULL);
 	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.remote"));
@@ -103,7 +103,7 @@ void test_refs_branches_move__can_not_move_a_branch_if_its_destination_name_coll
 	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/track-local"));
 
 	cl_assert_equal_i(GIT_EEXISTS,
-		git_branch_move(&new_ref, original_ref, "master", 0));
+		git_branch_move(&new_ref, original_ref, "master", 0, NULL, NULL));
 
 	cl_assert(giterr_last()->message != NULL);
 	cl_git_pass(git_config_get_entry(&ce, config, "branch.master.remote"));
@@ -122,7 +122,7 @@ void test_refs_branches_move__moving_a_branch_with_an_invalid_name_returns_EINVA
 
 	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
 
-	cl_assert_equal_i(GIT_EINVALIDSPEC, git_branch_move(&new_ref, original_ref, "Inv@{id", 0));
+	cl_assert_equal_i(GIT_EINVALIDSPEC, git_branch_move(&new_ref, original_ref, "Inv@{id", 0, NULL, NULL));
 
 	git_reference_free(original_ref);
 }
@@ -132,7 +132,7 @@ void test_refs_branches_move__can_not_move_a_non_branch(void)
 	git_reference *tag, *new_ref;
 
 	cl_git_pass(git_reference_lookup(&tag, repo, "refs/tags/e90810b"));
-	cl_git_fail(git_branch_move(&new_ref, tag, NEW_BRANCH_NAME, 0));
+	cl_git_fail(git_branch_move(&new_ref, tag, NEW_BRANCH_NAME, 0, NULL, NULL));
 
 	git_reference_free(tag);
 }
@@ -143,7 +143,7 @@ void test_refs_branches_move__can_force_move_over_an_existing_branch(void)
 
 	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
 
-	cl_git_pass(git_branch_move(&new_ref, original_ref, "master", 1));
+	cl_git_pass(git_branch_move(&new_ref, original_ref, "master", 1, NULL, NULL));
 
 	git_reference_free(original_ref);
 	git_reference_free(new_ref);
@@ -161,7 +161,7 @@ void test_refs_branches_move__moving_a_branch_moves_related_configuration_data(v
 	assert_config_entry_existence(repo, "branch.moved.remote", false);
 	assert_config_entry_existence(repo, "branch.moved.merge", false);
 
-	cl_git_pass(git_branch_move(&new_branch, branch, "moved", 0));
+	cl_git_pass(git_branch_move(&new_branch, branch, "moved", 0, NULL, NULL));
 	git_reference_free(branch);
 
 	assert_config_entry_existence(repo, "branch.track-local.remote", false);
@@ -178,7 +178,7 @@ void test_refs_branches_move__moving_the_branch_pointed_at_by_HEAD_updates_HEAD(
 	git_reference *new_branch;
 
 	cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master"));
-	cl_git_pass(git_branch_move(&new_branch, branch, "master2", 0));
+	cl_git_pass(git_branch_move(&new_branch, branch, "master2", 0, NULL, NULL));
 	git_reference_free(branch);
 	git_reference_free(new_branch);
 
-- 
cgit v1.2.3


From ccf6ce5c895c5d2261538150e945c93799de0999 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 28 Jan 2014 11:30:36 -0800
Subject: Ensure renaming a reference updates the reflog

---
 include/git2/refs.h        |  6 +++++-
 src/branch.c               |  3 ++-
 src/refs.c                 | 22 +++++++---------------
 src/remote.c               | 28 ++++++++++++++++++----------
 tests/refs/reflog/reflog.c |  4 ++--
 tests/refs/rename.c        | 40 +++++++++++++++++++++++++++++-----------
 tests/refs/revparse.c      |  2 +-
 7 files changed, 64 insertions(+), 41 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index b203f242b..976b7496b 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -297,6 +297,8 @@ GIT_EXTERN(int) git_reference_set_target(
  * @param ref The reference to rename
  * @param new_name The new name for the reference
  * @param force Overwrite an existing reference
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message to be appended to the reflog
  * @return 0 on success, GIT_EINVALIDSPEC, GIT_EEXISTS or an error code
  *
  */
@@ -304,7 +306,9 @@ GIT_EXTERN(int) git_reference_rename(
 	git_reference **new_ref,
 	git_reference *ref,
 	const char *new_name,
-	int force);
+	int force,
+	const git_signature *signature,
+	const char *log_message);
 
 /**
  * Delete an existing reference.
diff --git a/src/branch.c b/src/branch.c
index 4658d3bdd..c7651c6c3 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -211,7 +211,8 @@ int git_branch_move(
 	/* first update ref then config so failure won't trash config */
 
 	error = git_reference_rename(
-		out, branch, git_buf_cstr(&new_reference_name), force);
+		out, branch, git_buf_cstr(&new_reference_name), force,
+		signature, log_message);
 	if (error < 0)
 		goto done;
 
diff --git a/src/refs.c b/src/refs.c
index 65e7e6439..adbc1666a 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -558,35 +558,27 @@ int git_reference_rename(
 	git_reference **out,
 	git_reference *ref,
 	const char *new_name,
-	int force)
+	int force,
+	const git_signature *signature,
+	const char *log_message)
 {
-	git_signature *who;
+	git_signature *who = (git_signature*)signature;
 	int error;
 
 	/* Should we return an error if there is no default? */
-	if (((error = git_signature_default(&who, ref->db->repo)) < 0) &&
+	if (!who &&
+	    ((error = git_signature_default(&who, ref->db->repo)) < 0) &&
 	    ((error = git_signature_now(&who, "unknown", "unknown")) < 0)) {
 		return error;
 	}
 
-	error = reference__rename(out, ref, new_name, force, who, NULL);
+	error = reference__rename(out, ref, new_name, force, who, log_message);
 
 	git_signature_free(who);
 
 	return error;
 }
 
-int git_reference_rename_with_log(
-	git_reference **out,
-	git_reference *ref,
-	const char *new_name,
-	int force,
-	const git_signature *who,
-	const char * message)
-{
-	return reference__rename(out, ref, new_name, force, who, message);
-}
-
 int git_reference_resolve(git_reference **ref_out, const git_reference *ref)
 {
 	switch (git_reference_type(ref)) {
diff --git a/src/remote.c b/src/remote.c
index 5d35affd1..f33f5ef3c 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1332,20 +1332,28 @@ static int rename_one_remote_reference(
 {
 	int error;
 	git_buf new_name = GIT_BUF_INIT;
+	git_buf log_message = GIT_BUF_INIT;
 
-	error = git_buf_printf(
-		&new_name,
-		GIT_REFS_REMOTES_DIR "%s%s",
-		new_remote_name,
-		reference->name + strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name));
+	if ((error = git_buf_printf(
+					&new_name,
+					GIT_REFS_REMOTES_DIR "%s%s",
+					new_remote_name,
+					reference->name + strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name))) < 0)
+		goto cleanup;
 
-	if (!error) {
-		error = git_reference_rename(
-			NULL, reference, git_buf_cstr(&new_name), 0);
-		git_reference_free(reference);
-	}
+	if ((error = git_buf_printf(&log_message,
+					"renamed remote %s to %s",
+					old_remote_name, new_remote_name)) < 0)
+		goto cleanup;
+
+	error = git_reference_rename(
+		NULL, reference, git_buf_cstr(&new_name), 0,
+		NULL, git_buf_cstr(&log_message));
+	git_reference_free(reference);
 
+cleanup:
 	git_buf_free(&new_name);
+	git_buf_free(&log_message);
 	return error;
 }
 
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index 82b28de15..3f7d7d777 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -114,7 +114,7 @@ void test_refs_reflog_reflog__renaming_the_reference_moves_the_reflog(void)
 	cl_assert_equal_i(false, git_path_isfile(git_buf_cstr(&moved_log_path)));
 
 	cl_git_pass(git_reference_lookup(&master, g_repo, "refs/heads/master"));
-	cl_git_pass(git_reference_rename(&new_master, master, "refs/moved", 0));
+	cl_git_pass(git_reference_rename(&new_master, master, "refs/moved", 0, NULL, NULL));
 	git_reference_free(master);
 
 	cl_assert_equal_i(false, git_path_isfile(git_buf_cstr(&master_log_path)));
@@ -165,7 +165,7 @@ void test_refs_reflog_reflog__cannot_write_a_moved_reflog(void)
 
 	cl_git_pass(git_reflog_write(reflog));
 
-	cl_git_pass(git_reference_rename(&new_master, master, "refs/moved", 0));
+	cl_git_pass(git_reference_rename(&new_master, master, "refs/moved", 0, NULL, NULL));
 	git_reference_free(master);
 
 	cl_git_fail(git_reflog_write(reflog));
diff --git a/tests/refs/rename.c b/tests/refs/rename.c
index 120967892..63f202cbf 100644
--- a/tests/refs/rename.c
+++ b/tests/refs/rename.c
@@ -49,7 +49,7 @@ void test_refs_rename__loose(void)
 	cl_assert(reference_is_packed(looked_up_ref) == 0);
 
 	/* Now that the reference is renamed... */
-	cl_git_pass(git_reference_rename(&new_ref, looked_up_ref, new_name, 0));
+	cl_git_pass(git_reference_rename(&new_ref, looked_up_ref, new_name, 0, NULL, NULL));
 	cl_assert_equal_s(new_ref->name, new_name);
 	git_reference_free(looked_up_ref);
 
@@ -91,7 +91,7 @@ void test_refs_rename__packed(void)
 	cl_assert(reference_is_packed(looked_up_ref) != 0);
 
 	/* Now that the reference is renamed... */
-	cl_git_pass(git_reference_rename(&new_ref, looked_up_ref, brand_new_name, 0));
+	cl_git_pass(git_reference_rename(&new_ref, looked_up_ref, brand_new_name, 0, NULL, NULL));
 	cl_assert_equal_s(new_ref->name, brand_new_name);
 	git_reference_free(looked_up_ref);
 
@@ -140,7 +140,7 @@ void test_refs_rename__packed_doesnt_pack_others(void)
 	cl_assert(reference_is_packed(looked_up_ref) != 0);
 
 	/* Now that the reference is renamed... */
-	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, brand_new_name, 0));
+	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, brand_new_name, 0, NULL, NULL));
 	git_reference_free(looked_up_ref);
 
 	/* Lookup the other reference */
@@ -166,7 +166,7 @@ void test_refs_rename__name_collision(void)
 	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, packed_head_name));
 
 	/* Can not be renamed to the name of another existing reference. */
-	cl_git_fail(git_reference_rename(&renamed_ref, looked_up_ref, packed_test_head_name, 0));
+	cl_git_fail(git_reference_rename(&renamed_ref, looked_up_ref, packed_test_head_name, 0, NULL, NULL));
 	git_reference_free(looked_up_ref);
 
 	/* Failure to rename it hasn't corrupted its state */
@@ -187,12 +187,12 @@ void test_refs_rename__invalid_name(void)
 	/* Can not be renamed with an invalid name. */
 	cl_assert_equal_i(
 		GIT_EINVALIDSPEC,
-		git_reference_rename(&renamed_ref, looked_up_ref, "Hello! I'm a very invalid name.", 0));
+		git_reference_rename(&renamed_ref, looked_up_ref, "Hello! I'm a very invalid name.", 0, NULL, NULL));
 
 	/* Can not be renamed outside of the refs hierarchy
 	 * unless it's ALL_CAPS_AND_UNDERSCORES.
 	 */
-	cl_assert_equal_i(GIT_EINVALIDSPEC, git_reference_rename(&renamed_ref, looked_up_ref, "i-will-sudo-you", 0));
+	cl_assert_equal_i(GIT_EINVALIDSPEC, git_reference_rename(&renamed_ref, looked_up_ref, "i-will-sudo-you", 0, NULL, NULL));
 
 	/* Failure to rename it hasn't corrupted its state */
 	git_reference_free(looked_up_ref);
@@ -213,7 +213,7 @@ void test_refs_rename__force_loose_packed(void)
 	git_oid_cpy(&oid, git_reference_target(looked_up_ref));
 
 	/* Can be force-renamed to the name of another existing reference. */
-	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, packed_test_head_name, 1));
+	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, packed_test_head_name, 1, NULL, NULL));
 	git_reference_free(looked_up_ref);
 	git_reference_free(renamed_ref);
 
@@ -238,7 +238,7 @@ void test_refs_rename__force_loose(void)
 	git_oid_cpy(&oid, git_reference_target(looked_up_ref));
 
 	/* Can be force-renamed to the name of another existing reference. */
-	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, "refs/heads/test", 1));
+	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, "refs/heads/test", 1, NULL, NULL));
 	git_reference_free(looked_up_ref);
 	git_reference_free(renamed_ref);
 
@@ -307,7 +307,7 @@ void test_refs_rename__prefix(void)
 	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name));
 
 	/* Can be rename to a new name starting with the old name. */
-	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, ref_two_name_new, 0));
+	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, ref_two_name_new, 0, NULL, NULL));
 	git_reference_free(looked_up_ref);
 	git_reference_free(renamed_ref);
 
@@ -341,7 +341,7 @@ void test_refs_rename__move_up(void)
 	cl_git_pass(git_reference_lookup(&looked_up_ref, g_repo, ref_two_name_new));
 
 	/* Can be renamed upward the reference tree. */
-	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, ref_two_name, 0));
+	cl_git_pass(git_reference_rename(&renamed_ref, looked_up_ref, ref_two_name, 0, NULL, NULL));
 	git_reference_free(looked_up_ref);
 	git_reference_free(renamed_ref);
 
@@ -361,7 +361,25 @@ void test_refs_rename__propagate_eexists(void)
 
 	cl_git_pass(git_reference_lookup(&ref, g_repo, packed_head_name));
 
-	cl_assert_equal_i(GIT_EEXISTS, git_reference_rename(&new_ref, ref, packed_test_head_name, 0));
+	cl_assert_equal_i(GIT_EEXISTS, git_reference_rename(&new_ref, ref, packed_test_head_name, 0, NULL, NULL));
 
 	git_reference_free(ref);
 }
+
+void test_refs_rename__writes_to_reflog(void)
+{
+	git_reference *ref, *new_ref;
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name));
+	cl_git_pass(git_reference_rename(&new_ref, ref, ref_one_name_new, false,
+				NULL, "message"));
+	cl_git_pass(git_reflog_read(&log, g_repo, git_reference_name(new_ref)));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("message", git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
+	git_reference_free(ref);
+	git_reference_free(new_ref);
+}
diff --git a/tests/refs/revparse.c b/tests/refs/revparse.c
index 88f270326..a540f389d 100644
--- a/tests/refs/revparse.c
+++ b/tests/refs/revparse.c
@@ -325,7 +325,7 @@ static void create_fake_stash_reference_and_reflog(git_repository *repo)
 	cl_assert_equal_i(false, git_path_isfile(git_buf_cstr(&log_path)));
 
 	cl_git_pass(git_reference_lookup(&master, repo, "refs/heads/master"));
-	cl_git_pass(git_reference_rename(&new_master, master, "refs/fakestash", 0));
+	cl_git_pass(git_reference_rename(&new_master, master, "refs/fakestash", 0, NULL, NULL));
 	git_reference_free(master);
 
 	cl_assert_equal_i(true, git_path_isfile(git_buf_cstr(&log_path)));
-- 
cgit v1.2.3


From e871d89b2862ea61a13019705d4074bfcb6b88ae Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 28 Jan 2014 11:32:09 -0800
Subject: Ensure moving a branch updates the reflog

---
 tests/refs/branches/move.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tests/refs/branches/move.c b/tests/refs/branches/move.c
index bea93b9b3..0bdb58a5f 100644
--- a/tests/refs/branches/move.c
+++ b/tests/refs/branches/move.c
@@ -186,3 +186,22 @@ void test_refs_branches_move__moving_the_branch_pointed_at_by_HEAD_updates_HEAD(
 	cl_assert_equal_s("refs/heads/master2", git_reference_name(branch));
 	git_reference_free(branch);
 }
+
+void test_refs_branches_move__updates_the_reflog(void)
+{
+	git_reference *branch;
+	git_reference *new_branch;
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master"));
+	cl_git_pass(git_branch_move(&new_branch, branch, "master2", 0, NULL, "message"));
+
+	cl_git_pass(git_reflog_read(&log, repo, git_reference_name(new_branch)));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("message", git_reflog_entry_message(entry));
+
+	git_reference_free(branch);
+	git_reference_free(new_branch);
+	git_reflog_free(log);
+}
-- 
cgit v1.2.3


From 59bb1126e0a6d5c004f3856e23c75ae440211f1c Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 28 Jan 2014 11:45:30 -0800
Subject: Provide good default reflog messages in branch api

---
 src/branch.c                 | 36 +++++++++++++++++++++++++++---------
 tests/refs/branches/create.c | 17 +++++++++++++++++
 tests/refs/branches/move.c   | 21 +++++++++++++++++++++
 3 files changed, 65 insertions(+), 9 deletions(-)

diff --git a/src/branch.c b/src/branch.c
index c7651c6c3..133d6f6d4 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -59,8 +59,9 @@ int git_branch_create(
 	const char *log_message)
 {
 	git_reference *branch = NULL;
-	git_buf canonical_branch_name = GIT_BUF_INIT;
-	int error = 0;
+	git_buf canonical_branch_name = GIT_BUF_INIT,
+			  log_message_buf = GIT_BUF_INIT;
+	int error = -1;
 
 	assert(branch_name && commit && ref_out);
 	assert(git_object_owner((const git_object *)commit) == repository);
@@ -68,12 +69,19 @@ int git_branch_create(
 	if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0)
 		goto cleanup;
 
-	if (!(error = git_reference_create(&branch, repository,
-		git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force, signature, log_message)))
+	if (git_buf_sets(&log_message_buf, log_message ? log_message : "Branch: created") < 0)
+		goto cleanup;
+
+	error = git_reference_create(&branch, repository,
+		git_buf_cstr(&canonical_branch_name), git_commit_id(commit), force, signature,
+		git_buf_cstr(&log_message_buf));
+
+	if (!error)
 		*ref_out = branch;
 
 cleanup:
 	git_buf_free(&canonical_branch_name);
+	git_buf_free(&log_message_buf);
 	return error;
 }
 
@@ -195,8 +203,9 @@ int git_branch_move(
 	const char *log_message)
 {
 	git_buf new_reference_name = GIT_BUF_INIT,
-		old_config_section = GIT_BUF_INIT,
-		new_config_section = GIT_BUF_INIT;
+	        old_config_section = GIT_BUF_INIT,
+	        new_config_section = GIT_BUF_INIT,
+	        log_message_buf = GIT_BUF_INIT;
 	int error;
 
 	assert(branch && new_branch_name);
@@ -204,15 +213,23 @@ int git_branch_move(
 	if (!git_reference_is_branch(branch))
 		return not_a_local_branch(git_reference_name(branch));
 
-	error = git_buf_joinpath(&new_reference_name, GIT_REFS_HEADS_DIR, new_branch_name);
-	if (error < 0)
+	if ((error = git_buf_joinpath(&new_reference_name, GIT_REFS_HEADS_DIR, new_branch_name)) < 0)
 		goto done;
 
+	if (log_message) {
+		if ((error = git_buf_sets(&log_message_buf, log_message)) < 0)
+			goto done;
+	} else {
+		if ((error = git_buf_printf(&log_message_buf, "Branch: renamed %s to %s",
+						git_reference_name(branch), git_buf_cstr(&new_reference_name))) < 0)
+			goto done;
+	}
+
 	/* first update ref then config so failure won't trash config */
 
 	error = git_reference_rename(
 		out, branch, git_buf_cstr(&new_reference_name), force,
-		signature, log_message);
+		signature, git_buf_cstr(&log_message_buf));
 	if (error < 0)
 		goto done;
 
@@ -229,6 +246,7 @@ done:
 	git_buf_free(&new_reference_name);
 	git_buf_free(&old_config_section);
 	git_buf_free(&new_config_section);
+	git_buf_free(&log_message_buf);
 
 	return error;
 }
diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 0c0fdb013..32e17d600 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -86,4 +86,21 @@ void test_refs_branches_create__creation_creates_new_reflog(void)
 	cl_assert_equal_i(1, git_reflog_entrycount(log));
 	entry = git_reflog_entry_byindex(log, 0);
 	cl_assert_equal_s("create!", git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
+}
+
+void test_refs_branches_create__default_reflog_message(void)
+{
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	retrieve_known_commit(&target, repo);
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, NULL, NULL));
+	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/" NEW_BRANCH_NAME));
+
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("Branch: created", git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
 }
diff --git a/tests/refs/branches/move.c b/tests/refs/branches/move.c
index 0bdb58a5f..622921d4f 100644
--- a/tests/refs/branches/move.c
+++ b/tests/refs/branches/move.c
@@ -205,3 +205,24 @@ void test_refs_branches_move__updates_the_reflog(void)
 	git_reference_free(new_branch);
 	git_reflog_free(log);
 }
+
+void test_refs_branches_move__default_reflog_message(void)
+{
+	git_reference *branch;
+	git_reference *new_branch;
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master"));
+	cl_git_pass(git_branch_move(&new_branch, branch, "master2", 0, NULL, NULL));
+
+	cl_git_pass(git_reflog_read(&log, repo, git_reference_name(new_branch)));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("Branch: renamed refs/heads/master to refs/heads/master2",
+			git_reflog_entry_message(entry));
+
+	git_reference_free(branch);
+	git_reference_free(new_branch);
+	git_reflog_free(log);
+
+}
-- 
cgit v1.2.3


From a1b07dca7d456b5eb1f32e6f25c4f419752778b3 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 29 Jan 2014 09:57:20 -0800
Subject: Document branch-creation reflog better

---
 include/git2/branch.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/git2/branch.h b/include/git2/branch.h
index e653077d5..46aef3206 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -45,7 +45,9 @@ GIT_BEGIN_DECL
  *
  * @param signature The identity that will used to populate the reflog entry
  *
- * @param log_message The one line long message to be appended to the reflog
+ * @param log_message The one line long message to be appended to the reflog.
+ * If NULL, the default is "Branch: created"; if you want something more
+ * useful, provide a message.
  *
  * @return 0, GIT_EINVALIDSPEC or an error code.
  * A proper reference is written in the refs/heads namespace
-- 
cgit v1.2.3


From a1710a28f684298f79a0bab08b0b8930c1d57cf0 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 29 Jan 2014 10:35:46 -0800
Subject: Enhance testing of signature parameters

---
 src/clone.c                  |  2 +-
 src/refs.c                   |  3 ++-
 tests/clone/nonetwork.c      | 14 ++++++++++----
 tests/refs/branches/create.c | 12 +++++++++++-
 tests/refs/branches/move.c   | 13 +++++++++++--
 tests/refs/rename.c          |  7 ++++++-
 tests/repo/head.c            | 13 ++++++++++---
 7 files changed, 51 insertions(+), 13 deletions(-)

diff --git a/src/clone.c b/src/clone.c
index 97d25bdcd..3443528f7 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -246,7 +246,7 @@ static int update_head_to_remote(
 			signature, reflog_message);
 	} else {
 		error = git_repository_set_head_detached(
-			repo, &head_info.remote_head_oid, NULL, reflog_message);
+			repo, &head_info.remote_head_oid, signature, reflog_message);
 	}
 
 cleanup:
diff --git a/src/refs.c b/src/refs.c
index adbc1666a..eb2c34211 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -574,7 +574,8 @@ int git_reference_rename(
 
 	error = reference__rename(out, ref, new_name, force, who, log_message);
 
-	git_signature_free(who);
+	if (!signature)
+		git_signature_free(who);
 
 	return error;
 }
diff --git a/tests/clone/nonetwork.c b/tests/clone/nonetwork.c
index 14d2bbf59..f00d28b7a 100644
--- a/tests/clone/nonetwork.c
+++ b/tests/clone/nonetwork.c
@@ -24,6 +24,7 @@ void test_clone_nonetwork__initialize(void)
 	g_options.checkout_opts = dummy_opts;
 	g_options.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 	g_options.remote_callbacks = dummy_callbacks;
+	cl_git_pass(git_signature_now(&g_options.signature, "Me", "foo@example.com"));
 }
 
 void test_clone_nonetwork__cleanup(void)
@@ -43,6 +44,7 @@ void test_clone_nonetwork__cleanup(void)
 		g_remote = NULL;
 	}
 
+	git_signature_free(g_options.signature);
 	cl_fixture_cleanup("./foo");
 }
 
@@ -213,6 +215,8 @@ void test_clone_nonetwork__can_detached_head(void)
 	git_object *obj;
 	git_repository *cloned;
 	git_reference *cloned_head;
+	git_reflog *log;
+	const git_reflog_entry *entry;
 
 	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
 
@@ -226,8 +230,13 @@ void test_clone_nonetwork__can_detached_head(void)
 	cl_git_pass(git_repository_head(&cloned_head, cloned));
 	cl_assert(!git_oid_cmp(git_object_id(obj), git_reference_target(cloned_head)));
 
+	cl_git_pass(git_reflog_read(&log, cloned, "HEAD"));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
+
 	git_object_free(obj);
 	git_reference_free(cloned_head);
+	git_reflog_free(log);
 	git_repository_free(cloned);
 
 	cl_fixture_cleanup("./foo1");
@@ -252,12 +261,9 @@ static void assert_correct_reflog(const char *name)
 
 void test_clone_nonetwork__clone_updates_reflog_properly(void)
 {
-	cl_git_pass(git_signature_now(&g_options.signature, "Me", "foo@example.com"));
 	cl_git_pass(git_clone(&g_repo, cl_git_fixture_url("testrepo.git"), "./foo", &g_options));
 	assert_correct_reflog("HEAD");
 	assert_correct_reflog("refs/heads/master");
-
-	git_signature_free(g_options.signature);
 }
 
 void test_clone_nonetwork__clone_into_updates_reflog_properly(void)
@@ -274,5 +280,5 @@ void test_clone_nonetwork__clone_into_updates_reflog_properly(void)
 	assert_correct_reflog("refs/heads/master");
 
 	git_remote_free(remote);
-	git_signature_free(g_options.signature);
+	git_signature_free(sig);
 }
diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 32e17d600..06dcca591 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -78,22 +78,30 @@ void test_refs_branches_create__creation_creates_new_reflog(void)
 {
 	git_reflog *log;
 	const git_reflog_entry *entry;
+	git_signature *sig;
+
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
 
 	retrieve_known_commit(&target, repo);
-	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, NULL, "create!"));
+	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, sig, "create!"));
 	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/" NEW_BRANCH_NAME));
 
 	cl_assert_equal_i(1, git_reflog_entrycount(log));
 	entry = git_reflog_entry_byindex(log, 0);
 	cl_assert_equal_s("create!", git_reflog_entry_message(entry));
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
 
 	git_reflog_free(log);
+	git_signature_free(sig);
 }
 
 void test_refs_branches_create__default_reflog_message(void)
 {
 	git_reflog *log;
 	const git_reflog_entry *entry;
+	git_signature *sig;
+
+	cl_git_pass(git_signature_default(&sig, repo));
 
 	retrieve_known_commit(&target, repo);
 	cl_git_pass(git_branch_create(&branch, repo, NEW_BRANCH_NAME, target, false, NULL, NULL));
@@ -101,6 +109,8 @@ void test_refs_branches_create__default_reflog_message(void)
 
 	entry = git_reflog_entry_byindex(log, 0);
 	cl_assert_equal_s("Branch: created", git_reflog_entry_message(entry));
+	cl_assert_equal_s(sig->email, git_reflog_entry_committer(entry)->email);
 
 	git_reflog_free(log);
+	git_signature_free(sig);
 }
diff --git a/tests/refs/branches/move.c b/tests/refs/branches/move.c
index 622921d4f..3d2c815ae 100644
--- a/tests/refs/branches/move.c
+++ b/tests/refs/branches/move.c
@@ -193,17 +193,22 @@ void test_refs_branches_move__updates_the_reflog(void)
 	git_reference *new_branch;
 	git_reflog *log;
 	const git_reflog_entry *entry;
+	git_signature *sig;
+
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
 
 	cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master"));
-	cl_git_pass(git_branch_move(&new_branch, branch, "master2", 0, NULL, "message"));
+	cl_git_pass(git_branch_move(&new_branch, branch, "master2", 0, sig, "message"));
 
 	cl_git_pass(git_reflog_read(&log, repo, git_reference_name(new_branch)));
 	entry = git_reflog_entry_byindex(log, 0);
 	cl_assert_equal_s("message", git_reflog_entry_message(entry));
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
 
 	git_reference_free(branch);
 	git_reference_free(new_branch);
 	git_reflog_free(log);
+	git_signature_free(sig);
 }
 
 void test_refs_branches_move__default_reflog_message(void)
@@ -212,6 +217,9 @@ void test_refs_branches_move__default_reflog_message(void)
 	git_reference *new_branch;
 	git_reflog *log;
 	const git_reflog_entry *entry;
+	git_signature *sig;
+
+	cl_git_pass(git_signature_default(&sig, repo));
 
 	cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master"));
 	cl_git_pass(git_branch_move(&new_branch, branch, "master2", 0, NULL, NULL));
@@ -220,9 +228,10 @@ void test_refs_branches_move__default_reflog_message(void)
 	entry = git_reflog_entry_byindex(log, 0);
 	cl_assert_equal_s("Branch: renamed refs/heads/master to refs/heads/master2",
 			git_reflog_entry_message(entry));
+	cl_assert_equal_s(sig->email, git_reflog_entry_committer(entry)->email);
 
 	git_reference_free(branch);
 	git_reference_free(new_branch);
 	git_reflog_free(log);
-
+	git_signature_free(sig);
 }
diff --git a/tests/refs/rename.c b/tests/refs/rename.c
index 63f202cbf..88f0afd9c 100644
--- a/tests/refs/rename.c
+++ b/tests/refs/rename.c
@@ -371,15 +371,20 @@ void test_refs_rename__writes_to_reflog(void)
 	git_reference *ref, *new_ref;
 	git_reflog *log;
 	const git_reflog_entry *entry;
+	git_signature *sig;
+
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
 
 	cl_git_pass(git_reference_lookup(&ref, g_repo, ref_master_name));
 	cl_git_pass(git_reference_rename(&new_ref, ref, ref_one_name_new, false,
-				NULL, "message"));
+				sig, "message"));
 	cl_git_pass(git_reflog_read(&log, g_repo, git_reference_name(new_ref)));
 	entry = git_reflog_entry_byindex(log, 0);
 	cl_assert_equal_s("message", git_reflog_entry_message(entry));
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
 
 	git_reflog_free(log);
 	git_reference_free(ref);
 	git_reference_free(new_ref);
+	git_signature_free(sig);
 }
diff --git a/tests/repo/head.c b/tests/repo/head.c
index d28f254c3..71cfc3c33 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -200,11 +200,14 @@ void test_repo_head__setting_head_updates_reflog(void)
 	git_reflog *log;
 	const git_reflog_entry *entry1, *entry2, *entry3;
 	git_object *tag;
+	git_signature *sig;
 
-	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", NULL, "message1"));
-	cl_git_pass(git_repository_set_head(repo, "refs/heads/unborn", NULL, "message2"));
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
+
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", sig, "message1"));
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/unborn", sig, "message2"));
 	cl_git_pass(git_revparse_single(&tag, repo, "tags/test"));
-	cl_git_pass(git_repository_set_head_detached(repo, git_object_id(tag), NULL, "message3"));
+	cl_git_pass(git_repository_set_head_detached(repo, git_object_id(tag), sig, "message3"));
 
 	cl_git_pass(git_reflog_read(&log, repo, "HEAD"));
 	entry1 = git_reflog_entry_byindex(log, 2);
@@ -213,9 +216,13 @@ void test_repo_head__setting_head_updates_reflog(void)
 	cl_assert_equal_s("message1", git_reflog_entry_message(entry1));
 	cl_assert_equal_s("message2", git_reflog_entry_message(entry2));
 	cl_assert_equal_s("message3", git_reflog_entry_message(entry3));
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry1)->email);
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry2)->email);
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry3)->email);
 
 	git_reflog_free(log);
 	git_object_free(tag);
+	git_signature_free(sig);
 }
 
 void test_repo_head__setting_creates_head_ref(void)
-- 
cgit v1.2.3


From db092c1955ff5079d8ca475bbe1d6b0da782b38e Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Thu, 30 Jan 2014 16:10:18 -0800
Subject: Allow tests to run without user config

---
 tests/refs/branches/create.c | 6 ++++++
 tests/refs/branches/move.c   | 6 ++++++
 2 files changed, 12 insertions(+)

diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 06dcca591..abe5f5940 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -100,6 +100,12 @@ void test_refs_branches_create__default_reflog_message(void)
 	git_reflog *log;
 	const git_reflog_entry *entry;
 	git_signature *sig;
+	git_config *cfg;
+
+	cl_git_pass(git_repository_config(&cfg, repo));
+	cl_git_pass(git_config_set_string(cfg, "user.name", "Foo Bar"));
+	cl_git_pass(git_config_set_string(cfg, "user.email", "foo@example.com"));
+	git_config_free(cfg);
 
 	cl_git_pass(git_signature_default(&sig, repo));
 
diff --git a/tests/refs/branches/move.c b/tests/refs/branches/move.c
index 3d2c815ae..6c6dbbe21 100644
--- a/tests/refs/branches/move.c
+++ b/tests/refs/branches/move.c
@@ -218,6 +218,12 @@ void test_refs_branches_move__default_reflog_message(void)
 	git_reflog *log;
 	const git_reflog_entry *entry;
 	git_signature *sig;
+	git_config *cfg;
+
+	cl_git_pass(git_repository_config(&cfg, repo));
+	cl_git_pass(git_config_set_string(cfg, "user.name", "Foo Bar"));
+	cl_git_pass(git_config_set_string(cfg, "user.email", "foo@example.com"));
+	git_config_free(cfg);
 
 	cl_git_pass(git_signature_default(&sig, repo));
 
-- 
cgit v1.2.3


From 7be88b4c4df34e91213a8a66d80ef1eb4b3a02ee Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 31 Jan 2014 13:44:09 -0800
Subject: Update to latest clar

---
 tests/clar/fs.h | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/tests/clar/fs.h b/tests/clar/fs.h
index b7a1ff9d2..7c7dde6fc 100644
--- a/tests/clar/fs.h
+++ b/tests/clar/fs.h
@@ -12,7 +12,7 @@
 
 #endif /* __MINGW32__ */
 
-static int 
+static int
 fs__dotordotdot(WCHAR *_tocheck)
 {
 	return _tocheck[0] == '.' &&
@@ -201,7 +201,7 @@ fs_copy(const char *_source, const char *_dest)
 	DWORD source_attrs, dest_attrs;
 	HANDLE find_handle;
 	WIN32_FIND_DATAW find_data;
-	
+
 	/* The input paths are UTF-8. Convert them to wide characters
 	 * for use with the Windows API. */
 	cl_assert(MultiByteToWideChar(CP_UTF8,
@@ -251,17 +251,22 @@ cl_fs_cleanup(void)
 }
 
 #else
+
+#include <errno.h>
+#include <string.h>
+
 static int
 shell_out(char * const argv[])
 {
-	int status;
+	int status, piderr;
 	pid_t pid;
 
 	pid = fork();
 
 	if (pid < 0) {
 		fprintf(stderr,
-			"System error: `fork()` call failed.\n");
+			"System error: `fork()` call failed (%d) - %s\n",
+			errno, strerror(errno));
 		exit(-1);
 	}
 
@@ -269,7 +274,10 @@ shell_out(char * const argv[])
 		execv(argv[0], argv);
 	}
 
-	waitpid(pid, &status, 0);
+	do {
+		piderr = waitpid(pid, &status, WUNTRACED);
+	} while (piderr < 0 && (errno == EAGAIN || errno == EINTR));
+
 	return WEXITSTATUS(status);
 }
 
-- 
cgit v1.2.3


From 7ac1b89942e78bf73f954136c320e6be6f181c85 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Sat, 1 Feb 2014 11:46:15 -0800
Subject: Add failing test case

---
 tests/repo/head.c | 51 ++++++++++++++++++++++++++++++++++++++-------------
 1 file changed, 38 insertions(+), 13 deletions(-)

diff --git a/tests/repo/head.c b/tests/repo/head.c
index 71cfc3c33..8ea9a0f42 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -195,10 +195,41 @@ void test_repo_head__can_tell_if_an_unborn_head_is_detached(void)
 	cl_assert_equal_i(false, git_repository_head_detached(repo));
 }
 
-void test_repo_head__setting_head_updates_reflog(void)
+static void test_reflog(git_repository *repo, size_t idx,
+		const char *old_spec, const char *new_spec,
+		const char *email, const char *message)
 {
 	git_reflog *log;
-	const git_reflog_entry *entry1, *entry2, *entry3;
+	git_reflog_entry *entry;
+
+	cl_git_pass(git_reflog_read(&log, repo, "HEAD"));
+	entry = git_reflog_entry_byindex(log, idx);
+
+	if (old_spec) {
+		git_object *obj;
+		cl_git_pass(git_revparse_single(&obj, repo, old_spec));
+		cl_assert_equal_i(0, git_oid_cmp(git_object_id(obj), git_reflog_entry_id_old(entry)));
+		git_object_free(obj);
+	}
+	if (new_spec) {
+		git_object *obj;
+		cl_git_pass(git_revparse_single(&obj, repo, new_spec));
+		cl_assert_equal_i(0, git_oid_cmp(git_object_id(obj), git_reflog_entry_id_new(entry)));
+		git_object_free(obj);
+	}
+
+	if (email) {
+		cl_assert_equal_s(email, git_reflog_entry_committer(entry)->email);
+	}
+	if (message) {
+		cl_assert_equal_s(message, git_reflog_entry_message(entry));
+	}
+
+	git_reflog_free(log);
+}
+
+void test_repo_head__setting_head_updates_reflog(void)
+{
 	git_object *tag;
 	git_signature *sig;
 
@@ -208,19 +239,13 @@ void test_repo_head__setting_head_updates_reflog(void)
 	cl_git_pass(git_repository_set_head(repo, "refs/heads/unborn", sig, "message2"));
 	cl_git_pass(git_revparse_single(&tag, repo, "tags/test"));
 	cl_git_pass(git_repository_set_head_detached(repo, git_object_id(tag), sig, "message3"));
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", sig, "message4"));
 
-	cl_git_pass(git_reflog_read(&log, repo, "HEAD"));
-	entry1 = git_reflog_entry_byindex(log, 2);
-	entry2 = git_reflog_entry_byindex(log, 1);
-	entry3 = git_reflog_entry_byindex(log, 0);
-	cl_assert_equal_s("message1", git_reflog_entry_message(entry1));
-	cl_assert_equal_s("message2", git_reflog_entry_message(entry2));
-	cl_assert_equal_s("message3", git_reflog_entry_message(entry3));
-	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry1)->email);
-	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry2)->email);
-	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry3)->email);
+	test_reflog(repo, 3, NULL, "refs/heads/haacked", "foo@example.com", "message1");
+	test_reflog(repo, 2, "refs/heads/haacked", NULL, "foo@example.com", "message2");
+	test_reflog(repo, 1, NULL, "tags/test^{commit}", "foo@example.com", "message3");
+	test_reflog(repo, 0, "tags/test^{commit}", "refs/heads/haacked", "foo@example.com", "message4");
 
-	git_reflog_free(log);
 	git_object_free(tag);
 	git_signature_free(sig);
 }
-- 
cgit v1.2.3


From ee8e6afda9b33a1e20b7db67136cfb9cad9d7846 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Sat, 1 Feb 2014 11:46:44 -0800
Subject: Reflog: correct "new" id for reattaching HEAD

---
 src/refdb_fs.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 41ff01998..829e7c55a 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1452,7 +1452,9 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	if (error < 0)
 		return error;
 
-	if (git_reference_target(ref) != NULL)
+	if (git_reference_symbolic_target(ref) != NULL)
+		git_reference_name_to_id(&new_id, repo, git_reference_symbolic_target(ref));
+	else if (git_reference_target(ref) != NULL)
 		git_oid_cpy(&new_id, git_reference_target(ref));
 
 	if ((error = serialize_reflog_entry(&buf, &old_id, &new_id, who, message)) < 0)
-- 
cgit v1.2.3


From 7f058b86682e2a1566b192dfd1f0d333cc5b8c7c Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Sat, 1 Feb 2014 19:29:48 -0800
Subject: Check for errors when dereferencing symbolic refs

---
 src/refdb_fs.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 829e7c55a..89c77c14c 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1452,8 +1452,12 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	if (error < 0)
 		return error;
 
-	if (git_reference_symbolic_target(ref) != NULL)
-		git_reference_name_to_id(&new_id, repo, git_reference_symbolic_target(ref));
+	if (git_reference_symbolic_target(ref) != NULL) {
+		error = git_reference_name_to_id(&new_id, repo, git_reference_symbolic_target(ref));
+		if (error != 0 && error != GIT_ENOTFOUND)
+			goto cleanup;
+		giterr_clear();
+	}
 	else if (git_reference_target(ref) != NULL)
 		git_oid_cpy(&new_id, git_reference_target(ref));
 
-- 
cgit v1.2.3


From 50ad7cc2089798f65f8fcc49d94ab515f64dd160 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Sun, 2 Feb 2014 18:20:06 +0100
Subject: Add `git_reference_is_note`.

---
 include/git2/refs.h | 10 ++++++++++
 src/refs.c          | 11 +++++++++++
 tests/refs/read.c   | 15 +++++++++++++++
 3 files changed, 36 insertions(+)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 976b7496b..f9aaea827 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -510,6 +510,16 @@ GIT_EXTERN(int) git_reference_is_remote(git_reference *ref);
  */
 GIT_EXTERN(int) git_reference_is_tag(git_reference *ref);
 
+/**
+ * Check if a reference is a note
+ *
+ * @param ref A git reference
+ *
+ * @return 1 when the reference lives in the refs/notes
+ * namespace; 0 otherwise.
+ */
+GIT_EXTERN(int) git_reference_is_note(git_reference *ref);
+
 typedef enum {
 	GIT_REF_FORMAT_NORMAL = 0u,
 
diff --git a/src/refs.c b/src/refs.c
index eb2c34211..ca5f24ea2 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -1113,6 +1113,17 @@ int git_reference_is_tag(git_reference *ref)
 	return git_reference__is_tag(ref->name);
 }
 
+int git_reference__is_note(const char *ref_name)
+{
+	return git__prefixcmp(ref_name, GIT_REFS_NOTES_DIR) == 0;
+}
+
+int git_reference_is_note(git_reference *ref)
+{
+	assert(ref);
+	return git_reference__is_note(ref->name);
+}
+
 static int peel_error(int error, git_reference *ref, const char* msg)
 {
 	giterr_set(
diff --git a/tests/refs/read.c b/tests/refs/read.c
index 35cf17e9e..52c307eb0 100644
--- a/tests/refs/read.c
+++ b/tests/refs/read.c
@@ -271,6 +271,21 @@ void test_refs_read__can_determine_if_a_reference_is_a_tag(void)
 	assert_is_tag("refs/remotes/test/master", false);
 }
 
+static void assert_is_note(const char *name, bool expected_noteness)
+{
+	git_reference *reference;
+	cl_git_pass(git_reference_lookup(&reference, g_repo, name));
+	cl_assert_equal_i(expected_noteness, git_reference_is_note(reference));
+	git_reference_free(reference);
+}
+
+void test_refs_read__can_determine_if_a_reference_is_a_note(void)
+{
+	assert_is_note("refs/notes/fanout", true);
+	assert_is_note("refs/heads/packed", false);
+	assert_is_note("refs/remotes/test/master", false);
+}
+
 void test_refs_read__invalid_name_returns_EINVALIDSPEC(void)
 {
 	git_reference *reference;
-- 
cgit v1.2.3


From 0d847a31598a933877d94430b2fe80bade55fe1a Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 3 Feb 2014 14:08:40 -0800
Subject: Reset helpers: use revparse instead

---
 tests/index/names.c          |  4 ++--
 tests/index/reuc.c           |  6 +++---
 tests/refs/branches/create.c |  9 +++++----
 tests/reset/hard.c           |  9 ++++-----
 tests/reset/mixed.c          |  4 ++--
 tests/reset/reset_helpers.c  |  7 -------
 tests/reset/reset_helpers.h  |  1 -
 tests/reset/soft.c           | 15 +++++++--------
 8 files changed, 23 insertions(+), 32 deletions(-)

diff --git a/tests/index/names.c b/tests/index/names.c
index 9007b1b15..4e9cda5f5 100644
--- a/tests/index/names.c
+++ b/tests/index/names.c
@@ -86,7 +86,7 @@ void test_index_names__cleaned_on_reset_hard(void)
 {
 	git_object *target;
 
-	retrieve_target_from_oid(&target, repo, "3a34580a35add43a4cf361e8e9a30060a905c876");
+	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	test_index_names__add();
 	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
@@ -99,7 +99,7 @@ void test_index_names__cleaned_on_reset_mixed(void)
 {
 	git_object *target;
 
-	retrieve_target_from_oid(&target, repo, "3a34580a35add43a4cf361e8e9a30060a905c876");
+	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	test_index_names__add();
 	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED));
diff --git a/tests/index/reuc.c b/tests/index/reuc.c
index a18d5602e..0d703061a 100644
--- a/tests/index/reuc.c
+++ b/tests/index/reuc.c
@@ -295,7 +295,7 @@ void test_index_reuc__cleaned_on_reset_hard(void)
 {
 	git_object *target;
 
-	retrieve_target_from_oid(&target, repo, "3a34580a35add43a4cf361e8e9a30060a905c876");
+	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	test_index_reuc__add();
 	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
@@ -308,7 +308,7 @@ void test_index_reuc__cleaned_on_reset_mixed(void)
 {
 	git_object *target;
 
-	retrieve_target_from_oid(&target, repo, "3a34580a35add43a4cf361e8e9a30060a905c876");
+	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	test_index_reuc__add();
 	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED));
@@ -321,7 +321,7 @@ void test_index_reuc__retained_on_reset_soft(void)
 {
 	git_object *target;
 
-	retrieve_target_from_oid(&target, repo, "3a34580a35add43a4cf361e8e9a30060a905c876");
+	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	git_reset(repo, target, GIT_RESET_HARD);
 
diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index abe5f5940..94ecc0bca 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -29,15 +29,16 @@ void test_refs_branches_create__cleanup(void)
 
 static void retrieve_target_from_oid(git_commit **out, git_repository *repo, const char *sha)
 {
-	git_oid oid;
+	git_object *obj;
 
-	cl_git_pass(git_oid_fromstr(&oid, sha));
-	cl_git_pass(git_commit_lookup(out, repo, &oid));
+	cl_git_pass(git_revparse_single(&obj, repo, sha));
+	cl_git_pass(git_commit_lookup(out, repo, git_object_id(obj)));
+	git_object_free(obj);
 }
 
 static void retrieve_known_commit(git_commit **commit, git_repository *repo)
 {
-	retrieve_target_from_oid(commit, repo, "e90810b8df3e80c413d903f631643c716887138d");
+	retrieve_target_from_oid(commit, repo, "e90810b8df3");
 }
 
 #define NEW_BRANCH_NAME "new-branch-on-the-block"
diff --git a/tests/reset/hard.c b/tests/reset/hard.c
index 0f80d32df..8e9a94ca1 100644
--- a/tests/reset/hard.c
+++ b/tests/reset/hard.c
@@ -69,8 +69,7 @@ void test_reset_hard__resetting_reverts_modified_files(void)
 		cl_assert_equal_s(before[i], content.ptr);
 	}
 
-	retrieve_target_from_oid(
-		&target, repo, "26a125ee1bfc5df1e1b2e9441bbe63c8a7ae989f");
+	cl_git_pass(git_revparse_single(&target, repo, "26a125e"));
 
 	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
 
@@ -95,7 +94,7 @@ void test_reset_hard__cannot_reset_in_a_bare_repository(void)
 	cl_git_pass(git_repository_open(&bare, cl_fixture("testrepo.git")));
 	cl_assert(git_repository_is_bare(bare) == true);
 
-	retrieve_target_from_oid(&target, bare, KNOWN_COMMIT_IN_BARE_REPO);
+	cl_git_pass(git_revparse_single(&target, bare, KNOWN_COMMIT_IN_BARE_REPO));
 
 	cl_assert_equal_i(GIT_EBAREREPO, git_reset(bare, target, GIT_RESET_HARD));
 
@@ -152,7 +151,7 @@ void test_reset_hard__resetting_reverts_unmerged(void)
 		unmerged_index_init(index, entries);
 		cl_git_pass(git_index_write(index));
 
-		retrieve_target_from_oid(&target, repo, "26a125ee1bfc5df1e1b2e9441bbe63c8a7ae989f");
+		cl_git_pass(git_revparse_single(&target, repo, "26a125e"));
 		cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
 
 		cl_assert(git_path_exists("status/conflicting_file") == 0);
@@ -183,7 +182,7 @@ void test_reset_hard__cleans_up_merge(void)
 	cl_git_pass(git_buf_joinpath(&orig_head_path, git_repository_path(repo), "ORIG_HEAD"));
 	cl_git_mkfile(git_buf_cstr(&orig_head_path), "0017bd4ab1ec30440b17bae1680cff124ab5f1f6");
 
-	retrieve_target_from_oid(&target, repo, "0017bd4ab1ec30440b17bae1680cff124ab5f1f6");
+	cl_git_pass(git_revparse_single(&target, repo, "0017bd4"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
 
 	cl_assert(!git_path_exists(git_buf_cstr(&merge_head_path)));
diff --git a/tests/reset/mixed.c b/tests/reset/mixed.c
index 7b90c23f1..75aedf0fd 100644
--- a/tests/reset/mixed.c
+++ b/tests/reset/mixed.c
@@ -27,7 +27,7 @@ void test_reset_mixed__cannot_reset_in_a_bare_repository(void)
 	cl_git_pass(git_repository_open(&bare, cl_fixture("testrepo.git")));
 	cl_assert(git_repository_is_bare(bare) == true);
 
-	retrieve_target_from_oid(&target, bare, KNOWN_COMMIT_IN_BARE_REPO);
+	cl_git_pass(git_revparse_single(&target, bare, KNOWN_COMMIT_IN_BARE_REPO));
 
 	cl_assert_equal_i(GIT_EBAREREPO, git_reset(bare, target, GIT_RESET_MIXED));
 
@@ -40,7 +40,7 @@ void test_reset_mixed__resetting_refreshes_the_index_to_the_commit_tree(void)
 
 	cl_git_pass(git_status_file(&status, repo, "macro_bad"));
 	cl_assert(status == GIT_STATUS_CURRENT);
-	retrieve_target_from_oid(&target, repo, "605812ab7fe421fdd325a935d35cb06a9234a7d7");
+	cl_git_pass(git_revparse_single(&target, repo, "605812a"));
 
 	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED));
 
diff --git a/tests/reset/reset_helpers.c b/tests/reset/reset_helpers.c
index 17edca4e9..a792c03b9 100644
--- a/tests/reset/reset_helpers.c
+++ b/tests/reset/reset_helpers.c
@@ -1,10 +1,3 @@
 #include "clar_libgit2.h"
 #include "reset_helpers.h"
 
-void retrieve_target_from_oid(git_object **object_out, git_repository *repo, const char *sha)
-{
-	git_oid oid;
-
-	cl_git_pass(git_oid_fromstr(&oid, sha));
-	cl_git_pass(git_object_lookup(object_out, repo, &oid, GIT_OBJ_ANY));
-}
diff --git a/tests/reset/reset_helpers.h b/tests/reset/reset_helpers.h
index 5dbe9d2c7..82249fffa 100644
--- a/tests/reset/reset_helpers.h
+++ b/tests/reset/reset_helpers.h
@@ -3,4 +3,3 @@
 #define KNOWN_COMMIT_IN_BARE_REPO "e90810b8df3e80c413d903f631643c716887138d"
 #define KNOWN_COMMIT_IN_ATTR_REPO "217878ab49e1314388ea2e32dc6fdb58a1b969e0"
 
-extern void retrieve_target_from_oid(git_object **object_out, git_repository *repo, const char *sha);
diff --git a/tests/reset/soft.c b/tests/reset/soft.c
index bd6fcc205..f5501ac5f 100644
--- a/tests/reset/soft.c
+++ b/tests/reset/soft.c
@@ -26,8 +26,7 @@ static void assert_reset_soft(bool should_be_detached)
 
 	cl_git_pass(git_reference_name_to_id(&oid, repo, "HEAD"));
 	cl_git_fail(git_oid_streq(&oid, KNOWN_COMMIT_IN_BARE_REPO));
-
-	retrieve_target_from_oid(&target, repo, KNOWN_COMMIT_IN_BARE_REPO);
+	cl_git_pass(git_revparse_single(&target, repo, KNOWN_COMMIT_IN_BARE_REPO));
 
 	cl_assert(git_repository_head_detached(repo) == should_be_detached);
 
@@ -60,7 +59,7 @@ void test_reset_soft__resetting_to_the_commit_pointed_at_by_the_Head_does_not_ch
 	git_oid_fmt(raw_head_oid, &oid);
 	raw_head_oid[GIT_OID_HEXSZ] = '\0';
 
-	retrieve_target_from_oid(&target, repo, raw_head_oid);
+	cl_git_pass(git_revparse_single(&target, repo, raw_head_oid));
 
 	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
 
@@ -73,7 +72,7 @@ void test_reset_soft__resetting_to_a_tag_sets_the_Head_to_the_peeled_commit(void
 	git_oid oid;
 
 	/* b25fa35 is a tag, pointing to another tag which points to commit e90810b */
-	retrieve_target_from_oid(&target, repo, "b25fa35b38051e4ae45d4222e795f9df2e43f1d1");
+	cl_git_pass(git_revparse_single(&target, repo, "b25fa35"));
 
 	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
 
@@ -85,13 +84,13 @@ void test_reset_soft__resetting_to_a_tag_sets_the_Head_to_the_peeled_commit(void
 void test_reset_soft__cannot_reset_to_a_tag_not_pointing_at_a_commit(void)
 {
 	/* 53fc32d is the tree of commit e90810b */
-	retrieve_target_from_oid(&target, repo, "53fc32d17276939fc79ed05badaef2db09990016");
+	cl_git_pass(git_revparse_single(&target, repo, "53fc32d"));
 
 	cl_git_fail(git_reset(repo, target, GIT_RESET_SOFT));
 	git_object_free(target);
 
 	/* 521d87c is an annotated tag pointing to a blob */
-	retrieve_target_from_oid(&target, repo, "521d87c1ec3aef9824daf6d96cc0ae3710766d91");
+	cl_git_pass(git_revparse_single(&target, repo, "521d87c"));
 	cl_git_fail(git_reset(repo, target, GIT_RESET_SOFT));
 }
 
@@ -99,7 +98,7 @@ void test_reset_soft__resetting_against_an_unborn_head_repo_makes_the_head_no_lo
 {
 	git_reference *head;
 
-	retrieve_target_from_oid(&target, repo, KNOWN_COMMIT_IN_BARE_REPO);
+	cl_git_pass(git_revparse_single(&target, repo, KNOWN_COMMIT_IN_BARE_REPO));
 
 	make_head_unborn(repo, NON_EXISTING_HEAD);
 
@@ -123,7 +122,7 @@ void test_reset_soft__fails_when_merging(void)
 	cl_git_pass(git_buf_joinpath(&merge_head_path, git_repository_path(repo), "MERGE_HEAD"));
 	cl_git_mkfile(git_buf_cstr(&merge_head_path), "beefbeefbeefbeefbeefbeefbeefbeefbeefbeef\n");
 
-	retrieve_target_from_oid(&target, repo, KNOWN_COMMIT_IN_BARE_REPO);
+	cl_git_pass(git_revparse_single(&target, repo, KNOWN_COMMIT_IN_BARE_REPO));
 
 	cl_assert_equal_i(GIT_EUNMERGED, git_reset(repo, target, GIT_RESET_SOFT));
 	cl_git_pass(p_unlink(git_buf_cstr(&merge_head_path)));
-- 
cgit v1.2.3


From 586be3b889c2f8955630da14b6a703cccc340d47 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 3 Feb 2014 15:05:55 -0800
Subject: Add reflog parameters to git_reset

---
 include/git2/reset.h             | 13 ++++++++++++-
 src/reset.c                      | 12 ++++++++++--
 tests/checkout/tree.c            |  2 +-
 tests/index/names.c              |  4 ++--
 tests/index/reuc.c               |  8 ++++----
 tests/merge/workdir/simple.c     |  4 ++--
 tests/merge/workdir/submodules.c |  4 ++--
 tests/reset/hard.c               |  8 ++++----
 tests/reset/mixed.c              |  4 ++--
 tests/reset/soft.c               | 16 ++++++++--------
 tests/revert/workdir.c           | 28 ++++++++++++++--------------
 11 files changed, 61 insertions(+), 42 deletions(-)

diff --git a/include/git2/reset.h b/include/git2/reset.h
index c36781722..1759cc036 100644
--- a/include/git2/reset.h
+++ b/include/git2/reset.h
@@ -48,10 +48,21 @@ typedef enum {
  *
  * @param reset_type Kind of reset operation to perform.
  *
+ * @param signature The identity that will used to populate the reflog entry
+ *
+ * @param log_message The one line long message to be appended to the reflog.
+ * The reflog is only updated if the affected direct reference is actually
+ * changing. If NULL, the default is "reset: moving"; if you want something more
+ * useful, provide a message.
+ *
  * @return 0 on success or an error code
  */
 GIT_EXTERN(int) git_reset(
-	git_repository *repo, git_object *target, git_reset_t reset_type);
+	git_repository *repo,
+	git_object *target,
+	git_reset_t reset_type,
+	git_signature *signature,
+	const char *log_message);
 
 /**
  * Updates some entries in the index from the target commit tree.
diff --git a/src/reset.c b/src/reset.c
index 15f7fe13a..07fd08863 100644
--- a/src/reset.c
+++ b/src/reset.c
@@ -94,13 +94,16 @@ cleanup:
 int git_reset(
 	git_repository *repo,
 	git_object *target,
-	git_reset_t reset_type)
+	git_reset_t reset_type,
+	git_signature *signature,
+	const char *log_message)
 {
 	git_object *commit = NULL;
 	git_index *index = NULL;
 	git_tree *tree = NULL;
 	int error = 0;
 	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_buf log_message_buf = GIT_BUF_INIT;
 
 	assert(repo && target);
 
@@ -129,9 +132,14 @@ int git_reset(
 		goto cleanup;
 	}
 
+	if (log_message)
+		git_buf_sets(&log_message_buf, log_message);
+	else
+		git_buf_sets(&log_message_buf, "reset: moving");
+
 	/* move HEAD to the new target */
 	if ((error = git_reference__update_terminal(repo, GIT_HEAD_FILE,
-		git_object_id(commit), NULL, NULL)) < 0)
+		git_object_id(commit), signature, git_buf_cstr(&log_message_buf))) < 0)
 		goto cleanup;
 
 	if (reset_type == GIT_RESET_HARD) {
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index 407908ad3..f433b2698 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -571,7 +571,7 @@ void test_checkout_tree__donot_update_deleted_file_by_default(void)
 
 	cl_git_pass(git_oid_fromstr(&old_id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"));
 	cl_git_pass(git_commit_lookup(&old_commit, g_repo, &old_id));
-	cl_git_pass(git_reset(g_repo, (git_object *)old_commit, GIT_RESET_HARD));
+	cl_git_pass(git_reset(g_repo, (git_object *)old_commit, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(p_unlink("testrepo/branch_file.txt"));
 	cl_git_pass(git_index_remove_bypath(index ,"branch_file.txt"));
diff --git a/tests/index/names.c b/tests/index/names.c
index 4e9cda5f5..4723449d9 100644
--- a/tests/index/names.c
+++ b/tests/index/names.c
@@ -89,7 +89,7 @@ void test_index_names__cleaned_on_reset_hard(void)
 	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	test_index_names__add();
-	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
 	cl_assert(git_index_name_entrycount(repo_index) == 0);
 
 	git_object_free(target);
@@ -102,7 +102,7 @@ void test_index_names__cleaned_on_reset_mixed(void)
 	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	test_index_names__add();
-	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
 	cl_assert(git_index_name_entrycount(repo_index) == 0);
 
 	git_object_free(target);
diff --git a/tests/index/reuc.c b/tests/index/reuc.c
index 0d703061a..bf051c827 100644
--- a/tests/index/reuc.c
+++ b/tests/index/reuc.c
@@ -298,7 +298,7 @@ void test_index_reuc__cleaned_on_reset_hard(void)
 	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	test_index_reuc__add();
-	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
 	cl_assert(reuc_entry_exists() == false);
 
 	git_object_free(target);
@@ -311,7 +311,7 @@ void test_index_reuc__cleaned_on_reset_mixed(void)
 	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
 	test_index_reuc__add();
-	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
 	cl_assert(reuc_entry_exists() == false);
 
 	git_object_free(target);
@@ -323,10 +323,10 @@ void test_index_reuc__retained_on_reset_soft(void)
 
 	cl_git_pass(git_revparse_single(&target, repo, "3a34580"));
 
-	git_reset(repo, target, GIT_RESET_HARD);
+	git_reset(repo, target, GIT_RESET_HARD, NULL, NULL);
 
 	test_index_reuc__add();
-	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 	cl_assert(reuc_entry_exists() == true);
 
 	git_object_free(target);
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 4ff761cf8..1f128879b 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -585,7 +585,7 @@ void test_merge_workdir_simple__directory_file(void)
 	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, GIT_REFS_HEADS_DIR OURS_DIRECTORY_FILE, 1, NULL, NULL));
 	cl_git_pass(git_reference_name_to_id(&head_commit_id, repo, GIT_HEAD_FILE));
 	cl_git_pass(git_commit_lookup(&head_commit, repo, &head_commit_id));
-	cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_DIRECTORY_FILE));
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
@@ -684,7 +684,7 @@ void test_merge_workdir_simple__binary(void)
 	cl_git_pass(git_oid_fromstr(&their_oid, "ad01aebfdf2ac13145efafe3f9fcf798882f1730"));
 
 	cl_git_pass(git_commit_lookup(&our_commit, repo, &our_oid));
-	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_merge_head_from_id(&their_head, repo, &their_oid));
 
diff --git a/tests/merge/workdir/submodules.c b/tests/merge/workdir/submodules.c
index f01faac43..42451bde7 100644
--- a/tests/merge/workdir/submodules.c
+++ b/tests/merge/workdir/submodules.c
@@ -46,7 +46,7 @@ void test_merge_workdir_submodules__automerge(void)
 
 	cl_git_pass(git_reference_lookup(&our_ref, repo, "refs/heads/" SUBMODULE_MAIN_BRANCH));
 	cl_git_pass(git_commit_lookup(&our_commit, repo, git_reference_target(our_ref)));
-	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_reference_lookup(&their_ref, repo, "refs/heads/" SUBMODULE_OTHER_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
@@ -82,7 +82,7 @@ void test_merge_workdir_submodules__take_changed(void)
 
 	cl_git_pass(git_reference_lookup(&our_ref, repo, "refs/heads/" SUBMODULE_MAIN_BRANCH));
 	cl_git_pass(git_commit_lookup(&our_commit, repo, git_reference_target(our_ref)));
-	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)our_commit, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_reference_lookup(&their_ref, repo, "refs/heads/" SUBMODULE_OTHER2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
diff --git a/tests/reset/hard.c b/tests/reset/hard.c
index 8e9a94ca1..97243605d 100644
--- a/tests/reset/hard.c
+++ b/tests/reset/hard.c
@@ -71,7 +71,7 @@ void test_reset_hard__resetting_reverts_modified_files(void)
 
 	cl_git_pass(git_revparse_single(&target, repo, "26a125e"));
 
-	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
 
 	for (i = 0; i < 4; ++i) {
 		cl_git_pass(git_buf_joinpath(&path, wd, files[i]));
@@ -96,7 +96,7 @@ void test_reset_hard__cannot_reset_in_a_bare_repository(void)
 
 	cl_git_pass(git_revparse_single(&target, bare, KNOWN_COMMIT_IN_BARE_REPO));
 
-	cl_assert_equal_i(GIT_EBAREREPO, git_reset(bare, target, GIT_RESET_HARD));
+	cl_assert_equal_i(GIT_EBAREREPO, git_reset(bare, target, GIT_RESET_HARD, NULL, NULL));
 
 	git_repository_free(bare);
 }
@@ -152,7 +152,7 @@ void test_reset_hard__resetting_reverts_unmerged(void)
 		cl_git_pass(git_index_write(index));
 
 		cl_git_pass(git_revparse_single(&target, repo, "26a125e"));
-		cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
+		cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
 
 		cl_assert(git_path_exists("status/conflicting_file") == 0);
 
@@ -183,7 +183,7 @@ void test_reset_hard__cleans_up_merge(void)
 	cl_git_mkfile(git_buf_cstr(&orig_head_path), "0017bd4ab1ec30440b17bae1680cff124ab5f1f6");
 
 	cl_git_pass(git_revparse_single(&target, repo, "0017bd4"));
-	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
 
 	cl_assert(!git_path_exists(git_buf_cstr(&merge_head_path)));
 	cl_assert(!git_path_exists(git_buf_cstr(&merge_msg_path)));
diff --git a/tests/reset/mixed.c b/tests/reset/mixed.c
index 75aedf0fd..7a2605a82 100644
--- a/tests/reset/mixed.c
+++ b/tests/reset/mixed.c
@@ -29,7 +29,7 @@ void test_reset_mixed__cannot_reset_in_a_bare_repository(void)
 
 	cl_git_pass(git_revparse_single(&target, bare, KNOWN_COMMIT_IN_BARE_REPO));
 
-	cl_assert_equal_i(GIT_EBAREREPO, git_reset(bare, target, GIT_RESET_MIXED));
+	cl_assert_equal_i(GIT_EBAREREPO, git_reset(bare, target, GIT_RESET_MIXED, NULL, NULL));
 
 	git_repository_free(bare);
 }
@@ -42,7 +42,7 @@ void test_reset_mixed__resetting_refreshes_the_index_to_the_commit_tree(void)
 	cl_assert(status == GIT_STATUS_CURRENT);
 	cl_git_pass(git_revparse_single(&target, repo, "605812a"));
 
-	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
 
 	cl_git_pass(git_status_file(&status, repo, "macro_bad"));
 	cl_assert(status == GIT_STATUS_WT_NEW);
diff --git a/tests/reset/soft.c b/tests/reset/soft.c
index f5501ac5f..7c02b8073 100644
--- a/tests/reset/soft.c
+++ b/tests/reset/soft.c
@@ -30,7 +30,7 @@ static void assert_reset_soft(bool should_be_detached)
 
 	cl_assert(git_repository_head_detached(repo) == should_be_detached);
 
-	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 
 	cl_assert(git_repository_head_detached(repo) == should_be_detached);
 
@@ -61,7 +61,7 @@ void test_reset_soft__resetting_to_the_commit_pointed_at_by_the_Head_does_not_ch
 
 	cl_git_pass(git_revparse_single(&target, repo, raw_head_oid));
 
-	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 
 	cl_git_pass(git_reference_name_to_id(&oid, repo, "HEAD"));
 	cl_git_pass(git_oid_streq(&oid, raw_head_oid));
@@ -74,7 +74,7 @@ void test_reset_soft__resetting_to_a_tag_sets_the_Head_to_the_peeled_commit(void
 	/* b25fa35 is a tag, pointing to another tag which points to commit e90810b */
 	cl_git_pass(git_revparse_single(&target, repo, "b25fa35"));
 
-	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 
 	cl_assert(git_repository_head_detached(repo) == false);
 	cl_git_pass(git_reference_name_to_id(&oid, repo, "HEAD"));
@@ -86,12 +86,12 @@ void test_reset_soft__cannot_reset_to_a_tag_not_pointing_at_a_commit(void)
 	/* 53fc32d is the tree of commit e90810b */
 	cl_git_pass(git_revparse_single(&target, repo, "53fc32d"));
 
-	cl_git_fail(git_reset(repo, target, GIT_RESET_SOFT));
+	cl_git_fail(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 	git_object_free(target);
 
 	/* 521d87c is an annotated tag pointing to a blob */
 	cl_git_pass(git_revparse_single(&target, repo, "521d87c"));
-	cl_git_fail(git_reset(repo, target, GIT_RESET_SOFT));
+	cl_git_fail(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 }
 
 void test_reset_soft__resetting_against_an_unborn_head_repo_makes_the_head_no_longer_unborn(void)
@@ -104,7 +104,7 @@ void test_reset_soft__resetting_against_an_unborn_head_repo_makes_the_head_no_lo
 
 	cl_assert_equal_i(true, git_repository_head_unborn(repo));
 
-	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 
 	cl_assert_equal_i(false, git_repository_head_unborn(repo));
 
@@ -124,7 +124,7 @@ void test_reset_soft__fails_when_merging(void)
 
 	cl_git_pass(git_revparse_single(&target, repo, KNOWN_COMMIT_IN_BARE_REPO));
 
-	cl_assert_equal_i(GIT_EUNMERGED, git_reset(repo, target, GIT_RESET_SOFT));
+	cl_assert_equal_i(GIT_EUNMERGED, git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 	cl_git_pass(p_unlink(git_buf_cstr(&merge_head_path)));
 
 	git_buf_free(&merge_head_path);
@@ -152,5 +152,5 @@ void test_reset_soft__fails_when_index_contains_conflicts_independently_of_MERGE
 	cl_git_pass(git_reference_peel(&target, head, GIT_OBJ_COMMIT));
 	git_reference_free(head);
 
-	cl_assert_equal_i(GIT_EUNMERGED, git_reset(repo, target, GIT_RESET_SOFT));
+	cl_assert_equal_i(GIT_EUNMERGED, git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 }
diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
index 5be397c93..f2a0b6bcb 100644
--- a/tests/revert/workdir.c
+++ b/tests/revert/workdir.c
@@ -41,7 +41,7 @@ void test_revert_workdir__automerge(void)
 
 	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
@@ -74,7 +74,7 @@ void test_revert_workdir__conflicts(void)
 
 	cl_git_pass(git_repository_head(&head_ref, repo));
 	cl_git_pass(git_reference_peel((git_object **)&head, head_ref, GIT_OBJ_COMMIT));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
 	cl_git_pass(git_revert(repo, commit, NULL));
@@ -125,7 +125,7 @@ void test_revert_workdir__orphan(void)
 
 	git_oid_fromstr(&head_oid, "39467716290f6df775a91cdb9a4eb39295018145");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	git_oid_fromstr(&revert_oid, "ebb03002cee5d66c7732dd06241119fe72ab96a5");
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
@@ -160,7 +160,7 @@ void test_revert_workdir__again(void)
 
 	cl_git_pass(git_repository_head(&head_ref, repo));
 	cl_git_pass(git_reference_peel((git_object **)&orig_head, head_ref, GIT_OBJ_COMMIT));
-	cl_git_pass(git_reset(repo, (git_object *)orig_head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)orig_head, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_revert(repo, orig_head, NULL));
 
@@ -208,7 +208,7 @@ void test_revert_workdir__again_after_automerge(void)
 
 	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
@@ -256,7 +256,7 @@ void test_revert_workdir__again_after_edit(void)
 
 	cl_git_pass(git_oid_fromstr(&orig_head_oid, "399fb3aba3d9d13f7d40a9254ce4402067ef3149"));
 	cl_git_pass(git_commit_lookup(&orig_head, repo, &orig_head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)orig_head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)orig_head, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_oid_fromstr(&revert_oid, "2d440f2b3147d3dc7ad1085813478d6d869d5a4d"));
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
@@ -307,7 +307,7 @@ void test_revert_workdir__again_after_edit_two(void)
 
 	cl_git_pass(git_oid_fromstr(&head_commit_oid, "e34ef1afe54eb526fd92eec66084125f340f1d65"));
 	cl_git_pass(git_commit_lookup(&head_commit, repo, &head_commit_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head_commit, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_oid_fromstr(&revert_commit_oid, "71eb9c2b53dbbf3c45fb28b27c850db4b7fb8011"));
 	cl_git_pass(git_commit_lookup(&revert_commit, repo, &revert_commit_oid));
@@ -360,7 +360,7 @@ void test_revert_workdir__conflict_use_ours(void)
 
 	git_oid_fromstr(&head_oid, "72333f47d4e83616630ff3b0ffe4c0faebcc3c45");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	git_oid_fromstr(&revert_oid, "d1d403d22cbe24592d725f442835cf46fe60c8ac");
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
@@ -396,7 +396,7 @@ void test_revert_workdir__rename_1_of_2(void)
 
 	git_oid_fromstr(&head_oid, "cef56612d71a6af8d8015691e4865f7fece905b5");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	git_oid_fromstr(&revert_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
@@ -430,7 +430,7 @@ void test_revert_workdir__rename(void)
 
 	git_oid_fromstr(&head_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	git_oid_fromstr(&revert_oid, "0aa8c7e40d342fff78d60b29a4ba8e993ed79c51");
 	cl_git_pass(git_commit_lookup(&commit, repo, &revert_oid));
@@ -459,7 +459,7 @@ void test_revert_workdir__head(void)
 	/* HEAD is 2d440f2b3147d3dc7ad1085813478d6d869d5a4d */
 	cl_git_pass(git_repository_head(&head, repo));
 	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
-	cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)commit, GIT_RESET_HARD, NULL, NULL));
 	cl_git_pass(git_revert(repo, commit, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 4));
@@ -496,7 +496,7 @@ void test_revert_workdir__merge_fails_without_mainline_specified(void)
 
 	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	cl_must_fail(git_revert(repo, head, NULL));
 	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
@@ -523,7 +523,7 @@ void test_revert_workdir__merge_first_parent(void)
 
 	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_revert(repo, head, &opts));
 
@@ -548,7 +548,7 @@ void test_revert_workdir__merge_second_parent(void)
 
 	git_oid_fromstr(&head_oid, "5acdc74af27172ec491d213ee36cea7eb9ef2579");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
-	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
 
 	cl_git_pass(git_revert(repo, head, &opts));
 
-- 
cgit v1.2.3


From eec2761f068a0467ec5ddd140806e4cc9a6f4a58 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 3 Feb 2014 15:06:32 -0800
Subject: Fix warning

---
 tests/repo/head.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/repo/head.c b/tests/repo/head.c
index 8ea9a0f42..127176d12 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -200,7 +200,7 @@ static void test_reflog(git_repository *repo, size_t idx,
 		const char *email, const char *message)
 {
 	git_reflog *log;
-	git_reflog_entry *entry;
+	const git_reflog_entry *entry;
 
 	cl_git_pass(git_reflog_read(&log, repo, "HEAD"));
 	entry = git_reflog_entry_byindex(log, idx);
-- 
cgit v1.2.3


From 86746b4b3ae1508c980a7adcdd088ab87a92af7a Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 3 Feb 2014 15:06:47 -0800
Subject: Add reset tests for reflog

---
 src/refs.c                  |  4 +++-
 tests/reset/hard.c          | 27 +++++++++++++++++++++++++++
 tests/reset/mixed.c         | 26 ++++++++++++++++++++++++++
 tests/reset/reset_helpers.c | 17 +++++++++++++++++
 tests/reset/reset_helpers.h |  2 ++
 tests/reset/soft.c          | 26 ++++++++++++++++++++++++++
 6 files changed, 101 insertions(+), 1 deletion(-)

diff --git a/src/refs.c b/src/refs.c
index ca5f24ea2..3330c3a25 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -1032,8 +1032,10 @@ static int reference__update_terminal(
 			nesting+1, signature, log_message);
 		git_reference_free(ref);
 	} else {
+		/* If we're not moving the target, don't recreate the ref */
+		if (0 != git_oid_cmp(git_reference_target(ref), oid))
+			error = git_reference_create(NULL, repo, ref_name, oid, 1, signature, log_message);
 		git_reference_free(ref);
-		error = git_reference_create(NULL, repo, ref_name, oid, 1, signature, log_message);
 	}
 
 	return error;
diff --git a/tests/reset/hard.c b/tests/reset/hard.c
index 97243605d..d4c7db45f 100644
--- a/tests/reset/hard.c
+++ b/tests/reset/hard.c
@@ -197,3 +197,30 @@ void test_reset_hard__cleans_up_merge(void)
 	git_buf_free(&merge_mode_path);
 	git_buf_free(&orig_head_path);
 }
+
+void test_reset_hard__reflog_is_correct(void)
+{
+	const char *exp_msg = "commit: Add a file which name should appear before the "
+		"\"subdir/\" folder while being dealt with by the treewalker";
+
+	reflog_check(repo, "HEAD", 3, "emeric.fermas@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 3, "emeric.fermas@gmail.com", exp_msg);
+
+	/* Branch not moving, no reflog entry */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
+	reflog_check(repo, "HEAD", 3, "emeric.fermas@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 3, "emeric.fermas@gmail.com", exp_msg);
+
+	/* Moved branch, expect default message */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
+	reflog_check(repo, "HEAD", 3, "emeric.fermas@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 4, NULL, "reset: moving");
+
+	/* Moved branch, expect custom message */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, "message1"));
+	reflog_check(repo, "HEAD", 3, "emeric.fermas@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 5, NULL, "message1");
+}
diff --git a/tests/reset/mixed.c b/tests/reset/mixed.c
index 7a2605a82..25272a75c 100644
--- a/tests/reset/mixed.c
+++ b/tests/reset/mixed.c
@@ -47,3 +47,29 @@ void test_reset_mixed__resetting_refreshes_the_index_to_the_commit_tree(void)
 	cl_git_pass(git_status_file(&status, repo, "macro_bad"));
 	cl_assert(status == GIT_STATUS_WT_NEW);
 }
+
+void test_reset_mixed__reflog_is_correct(void)
+{
+	const char *exp_msg = "commit: Updating test data so we can test inter-hunk-context";
+
+	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 9, "yoram.harmelin@gmail.com", exp_msg);
+
+	/* Branch not moving, no reflog entry */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
+	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 9, "yoram.harmelin@gmail.com", exp_msg);
+
+	/* Moved branch, expect default message */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
+	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 10, NULL, "reset: moving");
+
+	/* Moved branch, expect custom message */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, "message1"));
+	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 11, NULL, "message1");
+}
diff --git a/tests/reset/reset_helpers.c b/tests/reset/reset_helpers.c
index a792c03b9..7a335a600 100644
--- a/tests/reset/reset_helpers.c
+++ b/tests/reset/reset_helpers.c
@@ -1,3 +1,20 @@
 #include "clar_libgit2.h"
 #include "reset_helpers.h"
 
+void reflog_check(git_repository *repo, const char *refname,
+		size_t exp_count, const char *exp_email, const char *exp_msg)
+{
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	cl_git_pass(git_reflog_read(&log, repo, refname));
+	cl_assert_equal_i(exp_count, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+
+	if (exp_email)
+		cl_assert_equal_s(exp_email, git_reflog_entry_committer(entry)->email);
+	if (exp_msg)
+		cl_assert_equal_s(exp_msg, git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
+}
diff --git a/tests/reset/reset_helpers.h b/tests/reset/reset_helpers.h
index 82249fffa..e7e048514 100644
--- a/tests/reset/reset_helpers.h
+++ b/tests/reset/reset_helpers.h
@@ -3,3 +3,5 @@
 #define KNOWN_COMMIT_IN_BARE_REPO "e90810b8df3e80c413d903f631643c716887138d"
 #define KNOWN_COMMIT_IN_ATTR_REPO "217878ab49e1314388ea2e32dc6fdb58a1b969e0"
 
+void reflog_check(git_repository *repo, const char *refname,
+		size_t exp_count, const char *exp_email, const char *exp_msg);
diff --git a/tests/reset/soft.c b/tests/reset/soft.c
index 7c02b8073..6469fce6d 100644
--- a/tests/reset/soft.c
+++ b/tests/reset/soft.c
@@ -154,3 +154,29 @@ void test_reset_soft__fails_when_index_contains_conflicts_independently_of_MERGE
 
 	cl_assert_equal_i(GIT_EUNMERGED, git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
 }
+
+void test_reset_soft_reflog_is_correct(void)
+{
+	const char *exp_msg = "commit: Updating test data so we can test inter-hunk-context";
+
+	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 9, "yoram.harmelin@gmail.com", exp_msg);
+
+	/* Branch not moving, no reflog entry */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
+	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 9, "yoram.harmelin@gmail.com", exp_msg);
+
+	/* Moved branch, expect default message */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, NULL));
+	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 10, NULL, "reset: moving");
+
+	/* Moved branch, expect custom message */
+	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
+	cl_git_pass(git_reset(repo, target, GIT_RESET_SOFT, NULL, "message1"));
+	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
+	reflog_check(repo, "refs/heads/master", 11, NULL, "message1");
+}
-- 
cgit v1.2.3


From b60149ecedab39fffc8607896f653ef7ac81b1e2 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 31 Jan 2014 18:43:50 -0800
Subject: Tests merge when changes exist in workdir/index

---
 tests/merge/workdir/dirty.c | 182 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 182 insertions(+)
 create mode 100644 tests/merge/workdir/dirty.c

diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
new file mode 100644
index 000000000..67026336b
--- /dev/null
+++ b/tests/merge/workdir/dirty.c
@@ -0,0 +1,182 @@
+#include "clar_libgit2.h"
+#include "git2/merge.h"
+#include "buffer.h"
+#include "merge.h"
+#include "../merge_helpers.h"
+
+#define TEST_REPO_PATH "merge-resolve"
+#define MERGE_BRANCH_OID "7cb63eed597130ba4abb87b3e544b85021905520"
+
+static git_repository *repo;
+static git_index *repo_index;
+
+static char *unaffected[][4] = {
+	{ "added-in-master.txt", NULL },
+	{ "changed-in-master.txt", NULL },
+	{ "unchanged.txt", NULL },
+	{ "added-in-master.txt", "changed-in-master.txt", NULL },
+	{ "added-in-master.txt", "unchanged.txt", NULL },
+	{ "changed-in-master.txt", "unchanged.txt", NULL },
+	{ "added-in-master.txt", "changed-in-master.txt", "unchanged.txt", NULL },
+	{ "new_file.txt", NULL },
+	{ "new_file.txt", "unchanged.txt", NULL },
+	{ NULL },
+};
+
+static char *affected[][5] = {
+	{ "automergeable.txt", NULL },
+	{ "changed-in-branch.txt", NULL },
+	{ "conflicting.txt", NULL },
+	{ "removed-in-branch.txt", NULL },
+	{ "automergeable.txt", "changed-in-branch.txt", NULL },
+	{ "automergeable.txt", "conflicting.txt", NULL },
+	{ "automergeable.txt", "removed-in-branch.txt", NULL },
+	{ "changed-in-branch.txt", "conflicting.txt", NULL },
+	{ "changed-in-branch.txt", "removed-in-branch.txt", NULL },
+	{ "conflicting.txt", "removed-in-branch.txt", NULL },
+	{ "automergeable.txt", "changed-in-branch.txt", "conflicting.txt", NULL },
+	{ "automergeable.txt", "changed-in-branch.txt", "removed-in-branch.txt", NULL },
+	{ "automergeable.txt", "conflicting.txt", "removed-in-branch.txt", NULL },
+	{ "changed-in-branch.txt", "conflicting.txt", "removed-in-branch.txt", NULL },
+	{ "automergeable.txt", "changed-in-branch.txt", "conflicting.txt", "removed-in-branch.txt", NULL },
+	{ NULL },
+};
+
+void test_merge_workdir_dirty__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+	git_repository_index(&repo_index, repo);
+}
+
+void test_merge_workdir_dirty__cleanup(void)
+{
+	git_index_free(repo_index);
+	cl_git_sandbox_cleanup();
+}
+
+static void set_core_autocrlf_to(git_repository *repo, bool value)
+{
+	git_config *cfg;
+
+	cl_git_pass(git_repository_config(&cfg, repo));
+	cl_git_pass(git_config_set_bool(cfg, "core.autocrlf", value));
+
+	git_config_free(cfg);
+}
+
+static int merge_branch(git_merge_result **result, int merge_file_favor, int checkout_strategy)
+{
+	git_oid their_oids[1];
+	git_merge_head *their_heads[1];
+	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	int error;
+
+	cl_git_pass(git_oid_fromstr(&their_oids[0], MERGE_BRANCH_OID));
+	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
+
+	opts.merge_tree_opts.file_favor = merge_file_favor;
+	opts.checkout_opts.checkout_strategy = checkout_strategy;
+	error = git_merge(result, repo, (const git_merge_head **)their_heads, 1, &opts);
+
+	git_merge_head_free(their_heads[0]);
+
+	return error;
+}
+
+static void write_files(char *files[])
+{
+	char *filename;
+	git_buf path = GIT_BUF_INIT, content = GIT_BUF_INIT;
+	size_t i;
+
+	for (i = 0, filename = files[i]; filename; filename = files[++i]) {
+		git_buf_clear(&path);
+		git_buf_clear(&content);
+
+		git_buf_printf(&path, "%s/%s", TEST_REPO_PATH, filename);
+		git_buf_printf(&content, "This is a dirty file in the working directory!\n\n"
+			"It will not be staged!  Its filename is %s.\n", filename);
+
+		cl_git_mkfile(path.ptr, content.ptr);
+	}
+
+	git_buf_free(&path);
+	git_buf_free(&content);
+}
+
+static void stage_random_files(char *files[])
+{
+	char *filename;
+	size_t i;
+
+	write_files(files);
+
+	for (i = 0, filename = files[i]; filename; filename = files[++i])
+		cl_git_pass(git_index_add_bypath(repo_index, filename));
+}
+
+static int merge_dirty_files(char *dirty_files[])
+{
+	git_reference *head;
+	git_object *head_object;
+	git_merge_result *result = NULL;
+	int error;
+
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD));
+
+	write_files(dirty_files);
+
+	error = merge_branch(&result, 0, 0);
+
+	git_merge_result_free(result);
+	git_object_free(head_object);
+	git_reference_free(head);
+
+	return error;
+}
+
+static int merge_staged_files(char *staged_files[])
+{
+	git_merge_result *result = NULL;
+	int error;
+	
+	stage_random_files(staged_files);
+
+	error = merge_branch(&result, 0, 0);
+
+	git_merge_result_free(result);
+
+	return error;
+}
+
+void test_merge_workdir_dirty__unaffected_dirty_files_allowed(void)
+{
+	char **files;
+	size_t i;
+
+	for (i = 0, files = unaffected[i]; files[0]; files = unaffected[++i])
+		cl_git_pass(merge_dirty_files(files));
+}
+
+void test_merge_workdir_dirty__affected_dirty_files_disallowed(void)
+{
+	char **files;
+	size_t i;
+
+	for (i = 0, files = affected[i]; files[0]; files = affected[++i])
+		cl_git_fail(merge_dirty_files(files));
+}
+
+void test_merge_workdir_dirty__staged_files_in_index_disallowed(void)
+{
+	char **files;
+	size_t i;
+
+	for (i = 0, files = unaffected[i]; files[0]; files = unaffected[++i])
+		cl_git_fail(merge_staged_files(files));
+
+	for (i = 0, files = affected[i]; files[0]; files = affected[++i])
+		cl_git_fail(merge_staged_files(files));
+}
-- 
cgit v1.2.3


From 16eb8b7c0667ba819e85b7bb4b40c2f71f73e59a Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sat, 1 Feb 2014 12:02:55 -0800
Subject: Tests merging staged files identical to result

---
 tests/merge/workdir/dirty.c | 70 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
index 67026336b..23840c1c3 100644
--- a/tests/merge/workdir/dirty.c
+++ b/tests/merge/workdir/dirty.c
@@ -7,6 +7,20 @@
 #define TEST_REPO_PATH "merge-resolve"
 #define MERGE_BRANCH_OID "7cb63eed597130ba4abb87b3e544b85021905520"
 
+#define AUTOMERGEABLE_MERGED_FILE \
+	"this file is changed in master\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is changed in branch\n"
+
+#define CHANGED_IN_BRANCH_FILE \
+	"changed in branch\n"
+
 static git_repository *repo;
 static git_index *repo_index;
 
@@ -42,6 +56,13 @@ static char *affected[][5] = {
 	{ NULL },
 };
 
+static char *result_contents[4][6] = {
+	{ "automergeable.txt", AUTOMERGEABLE_MERGED_FILE, NULL, NULL },
+	{ "changed-in-branch.txt", CHANGED_IN_BRANCH_FILE, NULL, NULL },
+	{ "automergeable.txt", AUTOMERGEABLE_MERGED_FILE, "changed-in-branch.txt", CHANGED_IN_BRANCH_FILE, NULL, NULL },
+	{ NULL }
+};
+
 void test_merge_workdir_dirty__initialize(void)
 {
 	repo = cl_git_sandbox_init(TEST_REPO_PATH);
@@ -115,6 +136,37 @@ static void stage_random_files(char *files[])
 		cl_git_pass(git_index_add_bypath(repo_index, filename));
 }
 
+static void stage_content(char *content[])
+{
+	git_reference *head;
+	git_object *head_object;
+	git_merge_result *result = NULL;
+	git_buf path = GIT_BUF_INIT;
+	char *filename, *text;
+	size_t i;
+
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD));
+
+	for (i = 0, filename = content[i], text = content[++i];
+		filename && text;
+		filename = content[++i], text = content[++i]) {
+
+		git_buf_clear(&path);
+
+		cl_git_pass(git_buf_printf(&path, "%s/%s", TEST_REPO_PATH, filename));
+
+		cl_git_mkfile(path.ptr, text);
+		cl_git_pass(git_index_add_bypath(repo_index, filename));
+	}
+
+	git_merge_result_free(result);
+	git_object_free(head_object);
+	git_reference_free(head);
+	git_buf_free(&path);
+}
+
 static int merge_dirty_files(char *dirty_files[])
 {
 	git_reference *head;
@@ -180,3 +232,21 @@ void test_merge_workdir_dirty__staged_files_in_index_disallowed(void)
 	for (i = 0, files = affected[i]; files[0]; files = affected[++i])
 		cl_git_fail(merge_staged_files(files));
 }
+
+void test_merge_workdir_dirty__identical_staged_files_allowed(void)
+{
+	git_merge_result *result;
+	char **content;
+	size_t i;
+
+	set_core_autocrlf_to(repo, false);
+	
+	for (i = 0, content = result_contents[i]; content[0]; content = result_contents[++i]) {
+		stage_content(content);
+
+		git_index_write(repo_index);
+		cl_git_pass(merge_branch(&result, 0, 0));
+
+		git_merge_result_free(result);
+	}
+}
-- 
cgit v1.2.3


From bb13d39162b0416585b34f18e9072fc4364d2655 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sat, 1 Feb 2014 12:51:44 -0800
Subject: Test that emulates a strange filter implementation

---
 tests/merge/workdir/dirty.c | 70 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
index 23840c1c3..625d3d01a 100644
--- a/tests/merge/workdir/dirty.c
+++ b/tests/merge/workdir/dirty.c
@@ -3,6 +3,7 @@
 #include "buffer.h"
 #include "merge.h"
 #include "../merge_helpers.h"
+#include "posix.h"
 
 #define TEST_REPO_PATH "merge-resolve"
 #define MERGE_BRANCH_OID "7cb63eed597130ba4abb87b3e544b85021905520"
@@ -125,6 +126,41 @@ static void write_files(char *files[])
 	git_buf_free(&content);
 }
 
+static void hack_index(char *files[])
+{
+	char *filename;
+	struct stat statbuf;
+	git_buf path = GIT_BUF_INIT;
+	git_index_entry *entry;
+	size_t i;
+
+	/* Update the index to suggest that checkout placed these files on
+	 * disk, keeping the object id but updating the cache, which will
+	 * emulate a Git implementation's different filter.
+	 */
+	for (i = 0, filename = files[i]; filename; filename = files[++i]) {
+		git_buf_clear(&path);
+
+		cl_assert(entry = (git_index_entry *)
+			git_index_get_bypath(repo_index, filename, 0));
+
+		cl_git_pass(git_buf_printf(&path, "%s/%s", TEST_REPO_PATH, filename));
+		cl_git_pass(p_stat(path.ptr, &statbuf));
+
+		entry->ctime.seconds = (git_time_t)statbuf.st_ctime;
+		entry->ctime.nanoseconds = 0;
+		entry->mtime.seconds = (git_time_t)statbuf.st_mtime;
+		entry->mtime.nanoseconds = 0;
+		entry->dev = statbuf.st_dev;
+		entry->ino = statbuf.st_ino;
+		entry->uid  = statbuf.st_uid;
+		entry->gid  = statbuf.st_gid;
+		entry->file_size = statbuf.st_size;
+	}
+
+	git_buf_free(&path);
+}
+
 static void stage_random_files(char *files[])
 {
 	char *filename;
@@ -189,6 +225,31 @@ static int merge_dirty_files(char *dirty_files[])
 	return error;
 }
 
+static int merge_differently_filtered_files(char *files[])
+{
+	git_reference *head;
+	git_object *head_object;
+	git_merge_result *result = NULL;
+	int error;
+
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD));
+
+	write_files(files);
+	hack_index(files);
+
+	cl_git_pass(git_index_write(repo_index));
+
+	error = merge_branch(&result, 0, 0);
+
+	git_merge_result_free(result);
+	git_object_free(head_object);
+	git_reference_free(head);
+
+	return error;
+}
+
 static int merge_staged_files(char *staged_files[])
 {
 	git_merge_result *result = NULL;
@@ -250,3 +311,12 @@ void test_merge_workdir_dirty__identical_staged_files_allowed(void)
 		git_merge_result_free(result);
 	}
 }
+
+void test_merge_workdir_dirty__honors_cache(void)
+{
+	char **files;
+	size_t i;
+
+	for (i = 0, files = affected[i]; files[0]; files = affected[++i])
+		cl_git_pass(merge_differently_filtered_files(files));
+}
-- 
cgit v1.2.3


From c0b10c25e02c6922276567600988fb2b85aeede1 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sat, 1 Feb 2014 12:05:00 -0800
Subject: Merge wd validation tests against index not HEAD

Validating the workdir should not compare HEAD to working
directory - this is both inefficient (as it ignores the cache)
and incorrect.  If we had legitimately allowed changes in the
index (identical to the merge result) then comparing HEAD to
workdir would reject these changes as different.  Further, this
will identify files that were filtered strangely as modified,
while testing with the cache would prevent this.

Also, it's stupid slow.
---
 src/merge.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/merge.c b/src/merge.c
index 20cfc0e23..2ae02e54d 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2330,7 +2330,7 @@ done:
 
 static int merge_check_workdir(size_t *conflicts, git_repository *repo, git_index *index_new, git_vector *merged_paths)
 {
-	git_tree *head_tree = NULL;
+	git_index *index_repo = NULL;
 	git_diff *wd_diff_list = NULL;
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	int error = 0;
@@ -2341,9 +2341,6 @@ static int merge_check_workdir(size_t *conflicts, git_repository *repo, git_inde
 
 	opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
 
-	if ((error = git_repository_head_tree(&head_tree, repo)) < 0)
-		goto done;
-
 	/* Workdir changes may exist iff they do not conflict with changes that
 	 * will be applied by the merge (including conflicts).  Ensure that there
 	 * are no changes in the workdir to these paths.
@@ -2351,13 +2348,13 @@ static int merge_check_workdir(size_t *conflicts, git_repository *repo, git_inde
 	opts.pathspec.count = merged_paths->length;
 	opts.pathspec.strings = (char **)merged_paths->contents;
 
-	if ((error = git_diff_tree_to_workdir(&wd_diff_list, repo, head_tree, &opts)) < 0)
+	if ((error = git_diff_index_to_workdir(&wd_diff_list, repo, index_repo, &opts)) < 0)
 		goto done;
 
 	*conflicts = wd_diff_list->deltas.length;
 
 done:
-	git_tree_free(head_tree);
+	git_index_free(index_repo);
 	git_diff_free(wd_diff_list);
 
 	return error;
-- 
cgit v1.2.3


From dbfd83bc6567763e6c363c462e9dd0628eaf3fe6 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 3 Feb 2014 19:56:13 -0800
Subject: Remove unused pointer assignment

---
 src/merge.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/merge.c b/src/merge.c
index 2ae02e54d..ac973efd0 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2397,7 +2397,7 @@ int git_merge__indexes(git_repository *repo, git_index *index_new)
 
 	/* Remove removed items from the index */
 	git_vector_foreach(&paths, i, path) {
-		if ((e = git_index_get_bypath(index_new, path, 0)) == NULL) {
+		if (git_index_get_bypath(index_new, path, 0) == NULL) {
 			if ((error = git_index_remove(index_repo, path, 0)) < 0 &&
 				error != GIT_ENOTFOUND)
 				goto done;
-- 
cgit v1.2.3


From 4075e060b45a73834a24684ed835d52f7176d58b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 3 Feb 2014 21:02:08 -0800
Subject: Replace pqueue with code from hashsig heap

I accidentally wrote a separate priority queue implementation when
I was working on file rename detection as part of the file hash
signature calculation code.  To simplify licensing terms, I just
adapted that to a general purpose priority queue and replace the
old priority queue implementation that was borrowed from elsewhere.

This also removes parts of the COPYING document that no longer
apply to libgit2.
---
 COPYING           |  75 +---------------------
 src/commit_list.c |   6 +-
 src/commit_list.h |   2 +-
 src/graph.c       |  35 +++++------
 src/merge.c       |  15 ++---
 src/pqueue.c      | 184 +++++++++++++++++-------------------------------------
 src/pqueue.h      | 111 +++++++++++++-------------------
 src/revwalk.c     |   5 +-
 src/vector.h      |  10 +++
 9 files changed, 143 insertions(+), 300 deletions(-)

diff --git a/COPYING b/COPYING
index f7e9f3af7..181737284 100644
--- a/COPYING
+++ b/COPYING
@@ -388,19 +388,7 @@ Copyright (C) 1995-2010 Jean-loup Gailly and Mark Adler
 
 ----------------------------------------------------------------------
 
-The priority queue implementation is based on code licensed under the
-Apache 2.0 license:
-
-	Copyright 2010 Volkan Yazıcı <volkan.yazici@gmail.com>
-	Copyright 2006-2010 The Apache Software Foundation
-
-The full text of the Apache 2.0 license is available at:
-
-	http://www.apache.org/licenses/LICENSE-2.0
-
-----------------------------------------------------------------------
-
-The Clay framework is licensed under the MIT license:
+The Clar framework is licensed under the MIT license:
 
 Copyright (C) 2011 by Vicent Marti
 
@@ -930,64 +918,3 @@ necessary.  Here is a sample; alter the names:
 That's all there is to it!
 
 ----------------------------------------------------------------------
-
-Portions of src/win32/posix_w32.c are derrived from link_win32.c in PHP:
-
--------------------------------------------------------------------- 
-                  The PHP License, version 3.01
-Copyright (c) 1999 - 2012 The PHP Group. All rights reserved.
--------------------------------------------------------------------- 
-
-Redistribution and use in source and binary forms, with or without
-modification, is permitted provided that the following conditions
-are met:
-
-  1. Redistributions of source code must retain the above copyright
-     notice, this list of conditions and the following disclaimer.
- 
-  2. Redistributions in binary form must reproduce the above copyright
-     notice, this list of conditions and the following disclaimer in
-     the documentation and/or other materials provided with the
-     distribution.
- 
-  3. The name "PHP" must not be used to endorse or promote products
-     derived from this software without prior written permission. For
-     written permission, please contact group@php.net.
-  
-  4. Products derived from this software may not be called "PHP", nor
-     may "PHP" appear in their name, without prior written permission
-     from group@php.net.  You may indicate that your software works in
-     conjunction with PHP by saying "Foo for PHP" instead of calling
-     it "PHP Foo" or "phpfoo"
- 
-  5. The PHP Group may publish revised and/or new versions of the
-     license from time to time. Each version will be given a
-     distinguishing version number.
-     Once covered code has been published under a particular version
-     of the license, you may always continue to use it under the terms
-     of that version. You may also choose to use such covered code
-     under the terms of any subsequent version of the license
-     published by the PHP Group. No one other than the PHP Group has
-     the right to modify the terms applicable to covered code created
-     under this License.
-
-  6. Redistributions of any form whatsoever must retain the following
-     acknowledgment:
-     "This product includes PHP software, freely available from
-     <http://www.php.net/software/>".
-
-THIS SOFTWARE IS PROVIDED BY THE PHP DEVELOPMENT TEAM ``AS IS'' AND 
-ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A 
-PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE PHP
-DEVELOPMENT TEAM OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
-INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-OF THE POSSIBILITY OF SUCH DAMAGE.
-
--------------------------------------------------------------------- 
-
diff --git a/src/commit_list.c b/src/commit_list.c
index 64416e54d..9db3f5633 100644
--- a/src/commit_list.c
+++ b/src/commit_list.c
@@ -11,10 +11,10 @@
 #include "pool.h"
 #include "odb.h"
 
-int git_commit_list_time_cmp(void *a, void *b)
+int git_commit_list_time_cmp(const void *a, const void *b)
 {
-	git_commit_list_node *commit_a = (git_commit_list_node *)a;
-	git_commit_list_node *commit_b = (git_commit_list_node *)b;
+	const git_commit_list_node *commit_a = a;
+	const git_commit_list_node *commit_b = b;
 
 	return (commit_a->time < commit_b->time);
 }
diff --git a/src/commit_list.h b/src/commit_list.h
index d2f54b3ca..490d841be 100644
--- a/src/commit_list.h
+++ b/src/commit_list.h
@@ -39,7 +39,7 @@ typedef struct git_commit_list {
 } git_commit_list;
 
 git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk);
-int git_commit_list_time_cmp(void *a, void *b);
+int git_commit_list_time_cmp(const void *a, const void *b);
 void git_commit_list_free(git_commit_list **list_p);
 git_commit_list *git_commit_list_insert(git_commit_list_node *item, git_commit_list **list_p);
 git_commit_list *git_commit_list_insert_by_date(git_commit_list_node *item, git_commit_list **list_p);
diff --git a/src/graph.c b/src/graph.c
index f39af5ed5..96fda7add 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -1,4 +1,3 @@
-
 /*
  * Copyright (C) the libgit2 contributors. All rights reserved.
  *
@@ -13,9 +12,9 @@
 static int interesting(git_pqueue *list, git_commit_list *roots)
 {
 	unsigned int i;
-	/* element 0 isn't used - we need to start at 1 */
-	for (i = 1; i < list->size; i++) {
-		git_commit_list_node *commit = list->d[i];
+
+	for (i = 0; i < git_pqueue_size(list); i++) {
+		git_commit_list_node *commit = git_pqueue_get(list, i);
 		if ((commit->flags & STALE) == 0)
 			return 1;
 	}
@@ -42,7 +41,7 @@ static int mark_parents(git_revwalk *walk, git_commit_list_node *one,
 		return 0;
 	}
 
-	if (git_pqueue_init(&list, 2, git_commit_list_time_cmp) < 0)
+	if (git_pqueue_init(&list, 0, 2, git_commit_list_time_cmp) < 0)
 		return -1;
 
 	if (git_commit_list_parse(walk, one) < 0)
@@ -59,10 +58,9 @@ static int mark_parents(git_revwalk *walk, git_commit_list_node *one,
 
 	/* as long as there are non-STALE commits */
 	while (interesting(&list, roots)) {
-		git_commit_list_node *commit;
+		git_commit_list_node *commit = git_pqueue_pop(&list);
 		int flags;
 
-		commit = git_pqueue_pop(&list);
 		if (commit == NULL)
 			break;
 
@@ -110,16 +108,16 @@ static int ahead_behind(git_commit_list_node *one, git_commit_list_node *two,
 {
 	git_commit_list_node *commit;
 	git_pqueue pq;
-	int i;
+	int error = 0, i;
 	*ahead = 0;
 	*behind = 0;
 
-	if (git_pqueue_init(&pq, 2, git_commit_list_time_cmp) < 0)
+	if (git_pqueue_init(&pq, 0, 2, git_commit_list_time_cmp) < 0)
 		return -1;
-	if (git_pqueue_insert(&pq, one) < 0)
-		goto on_error;
-	if (git_pqueue_insert(&pq, two) < 0)
-		goto on_error;
+
+	if ((error = git_pqueue_insert(&pq, one)) < 0 ||
+		(error = git_pqueue_insert(&pq, two)) < 0)
+		goto done;
 
 	while ((commit = git_pqueue_pop(&pq)) != NULL) {
 		if (commit->flags & RESULT ||
@@ -132,18 +130,15 @@ static int ahead_behind(git_commit_list_node *one, git_commit_list_node *two,
 
 		for (i = 0; i < commit->out_degree; i++) {
 			git_commit_list_node *p = commit->parents[i];
-			if (git_pqueue_insert(&pq, p) < 0)
-				return -1;
+			if ((error = git_pqueue_insert(&pq, p)) < 0)
+				goto done;
 		}
 		commit->flags |= RESULT;
 	}
 
+done:
 	git_pqueue_free(&pq);
-	return 0;
-
-on_error:
-	git_pqueue_free(&pq);
-	return -1;
+	return error;
 }
 
 int git_graph_ahead_behind(size_t *ahead, size_t *behind, git_repository *repo,
diff --git a/src/merge.c b/src/merge.c
index 20cfc0e23..d004554cf 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -161,10 +161,10 @@ on_error:
 
 static int interesting(git_pqueue *list)
 {
-	unsigned int i;
-	/* element 0 isn't used - we need to start at 1 */
-	for (i = 1; i < list->size; i++) {
-		git_commit_list_node *commit = list->d[i];
+	size_t i;
+
+	for (i = 0; i < git_pqueue_size(list); i++) {
+		git_commit_list_node *commit = git_pqueue_get(list, i);
 		if ((commit->flags & STALE) == 0)
 			return 1;
 	}
@@ -186,7 +186,7 @@ int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_l
 			return git_commit_list_insert(one, out) ? 0 : -1;
 	}
 
-	if (git_pqueue_init(&list, twos->length * 2, git_commit_list_time_cmp) < 0)
+	if (git_pqueue_init(&list, 0, twos->length * 2, git_commit_list_time_cmp) < 0)
 		return -1;
 
 	if (git_commit_list_parse(walk, one) < 0)
@@ -205,10 +205,11 @@ int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_l
 
 	/* as long as there are non-STALE commits */
 	while (interesting(&list)) {
-		git_commit_list_node *commit;
+		git_commit_list_node *commit = git_pqueue_pop(&list);
 		int flags;
 
-		commit = git_pqueue_pop(&list);
+		if (commit == NULL)
+			break;
 
 		flags = commit->flags & (PARENT1 | PARENT2 | STALE);
 		if (flags == (PARENT1 | PARENT2)) {
diff --git a/src/pqueue.c b/src/pqueue.c
index 7819ed41e..ddbad7a54 100644
--- a/src/pqueue.c
+++ b/src/pqueue.c
@@ -3,161 +3,95 @@
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
- *
- * This file is based on a modified version of the priority queue found
- * in the Apache project and libpqueue library.
- * 
- * https://github.com/vy/libpqueue
- * 
- * Original file notice:
- * 
- * Copyright 2010 Volkan Yazici <volkan.yazici@gmail.com>
- * Copyright 2006-2010 The Apache Software Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
  */
 
-#include "common.h"
 #include "pqueue.h"
+#include "util.h"
 
-#define left(i)	((i) << 1)
-#define right(i) (((i) << 1) + 1)
-#define parent(i) ((i) >> 1)
-
-int git_pqueue_init(git_pqueue *q, size_t n, git_pqueue_cmp cmppri)
-{
-	assert(q);
-
-	/* Need to allocate n+1 elements since element 0 isn't used. */
-	q->d = git__malloc((n + 1) * sizeof(void *));
-	GITERR_CHECK_ALLOC(q->d);
-
-	q->size = 1;
-	q->avail = q->step = (n + 1); /* see comment above about n+1 */
-	q->cmppri = cmppri;
-
-	return 0;
-}
-
+#define PQUEUE_LCHILD_OF(I) (((I)<<1)+1)
+#define PQUEUE_RCHILD_OF(I) (((I)<<1)+2)
+#define PQUEUE_PARENT_OF(I) (((I)-1)>>1)
 
-void git_pqueue_free(git_pqueue *q)
+int git_pqueue_init(
+	git_pqueue *pq,
+	uint32_t flags,
+	size_t est_size,
+	git_vector_cmp cmp)
 {
-	git__free(q->d);
-	q->d = NULL;
+	pq->flags = flags;
+	pq->initial_size = est_size;
+	return git_vector_init(&pq->values, est_size, cmp);
 }
 
-void git_pqueue_clear(git_pqueue *q)
+void git_pqueue_free(git_pqueue *pq)
 {
-	q->size = 1;
+	git_vector_free(&pq->values);
 }
 
-size_t git_pqueue_size(git_pqueue *q)
+static void pqueue_up(git_pqueue *pq, size_t el)
 {
-	/* queue element 0 exists but doesn't count since it isn't used. */
-	return (q->size - 1);
-}
+	size_t parent_el = PQUEUE_PARENT_OF(el);
 
+	while (el > 0 && git_vector_cmp_elements(&pq->values, parent_el, el) > 0) {
+		git_vector_swap_elements(&pq->values, el, parent_el);
 
-static void bubble_up(git_pqueue *q, size_t i)
-{
-	size_t parent_node;
-	void *moving_node = q->d[i];
-
-	for (parent_node = parent(i);
-			((i > 1) && q->cmppri(q->d[parent_node], moving_node));
-			i = parent_node, parent_node = parent(i)) {
-		q->d[i] = q->d[parent_node];
+		el = parent_el;
+		parent_el = PQUEUE_PARENT_OF(el);
 	}
-
-	q->d[i] = moving_node;
 }
 
-
-static size_t maxchild(git_pqueue *q, size_t i)
+static void pqueue_down(git_pqueue *pq, size_t el)
 {
-	size_t child_node = left(i);
+	size_t last = git_vector_length(&pq->values);
 
-	if (child_node >= q->size)
-		return 0;
+	while (1) {
+		size_t kid = PQUEUE_LCHILD_OF(el), rkid = PQUEUE_RCHILD_OF(el);
+		if (kid >= last)
+			break;
+		if (rkid < last && git_vector_cmp_elements(&pq->values, kid, rkid) > 0)
+			kid = rkid;
 
-	if ((child_node + 1) < q->size &&
-		q->cmppri(q->d[child_node], q->d[child_node + 1]))
-		child_node++; /* use right child instead of left */
-
-	return child_node;
-}
+		if (git_vector_cmp_elements(&pq->values, el, kid) < 0)
+			break;
 
-
-static void percolate_down(git_pqueue *q, size_t i)
-{
-	size_t child_node;
-	void *moving_node = q->d[i];
-
-	while ((child_node = maxchild(q, i)) != 0 &&
-			q->cmppri(moving_node, q->d[child_node])) {
-		q->d[i] = q->d[child_node];
-		i = child_node;
+		git_vector_swap_elements(&pq->values, el, kid);
+		el = kid;
 	}
-
-	q->d[i] = moving_node;
 }
 
-
-int git_pqueue_insert(git_pqueue *q, void *d)
+int git_pqueue_insert(git_pqueue *pq, void *item)
 {
-	void *tmp;
-	size_t i;
-	size_t newsize;
-
-	if (!q) return 1;
-
-	/* allocate more memory if necessary */
-	if (q->size >= q->avail) {
-		newsize = q->size + q->step;
-		tmp = git__realloc(q->d, sizeof(void *) * newsize);
-		GITERR_CHECK_ALLOC(tmp);
-
-		q->d = tmp;
-		q->avail = newsize;
+	int error = 0;
+
+	/* if heap is full, pop the top element if new one should replace it */
+	if ((pq->flags & GIT_PQUEUE_FIXED_SIZE) != 0 &&
+		pq->values.length >= pq->initial_size)
+	{
+		/* skip item if below min item in heap */
+		if (pq->values._cmp(item, git_vector_get(&pq->values, 0)) <= 0)
+			return 0;
+		(void)git_pqueue_pop(pq);
 	}
 
-	/* insert item */
-	i = q->size++;
-	q->d[i] = d;
-	bubble_up(q, i);
+	error = git_vector_insert(&pq->values, item);
 
-	return 0;
-}
+	if (!error)
+		pqueue_up(pq, pq->values.length - 1);
 
-
-void *git_pqueue_pop(git_pqueue *q)
-{
-	void *head;
-
-	if (!q || q->size == 1)
-		return NULL;
-
-	head = q->d[1];
-	q->d[1] = q->d[--q->size];
-	percolate_down(q, 1);
-
-	return head;
+	return error;
 }
 
-
-void *git_pqueue_peek(git_pqueue *q)
+void *git_pqueue_pop(git_pqueue *pq)
 {
-	if (!q || q->size == 1)
-		return NULL;
-	return q->d[1];
+	void *rval = git_vector_get(&pq->values, 0);
+
+	if (git_vector_length(&pq->values) > 1) {
+		pq->values.contents[0] = git_vector_last(&pq->values);
+		git_vector_pop(&pq->values);
+		pqueue_down(pq, 0);
+	} else {
+		git_vector_pop(&pq->values);
+	}
+
+	return rval;
 }
diff --git a/src/pqueue.h b/src/pqueue.h
index 9061f8279..3c977e178 100644
--- a/src/pqueue.h
+++ b/src/pqueue.h
@@ -3,99 +3,74 @@
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
- * 
- * This file is based on a modified version of the priority queue found
- * in the Apache project and libpqueue library.
- * 
- * https://github.com/vy/libpqueue
- * 
- * Original file notice:
- * 
- * Copyright 2010 Volkan Yazici <volkan.yazici@gmail.com>
- * Copyright 2006-2010 The Apache Software Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not
- * use this file except in compliance with the License. You may obtain a copy of
- * the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
- * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
- * License for the specific language governing permissions and limitations under
- * the License.
  */
-
 #ifndef INCLUDE_pqueue_h__
 #define INCLUDE_pqueue_h__
 
-/** callback functions to get/set/compare the priority of an element */
-typedef int (*git_pqueue_cmp)(void *a, void *b);
+#include "vector.h"
 
-/** the priority queue handle */
 typedef struct {
-	size_t size, avail, step;
-	git_pqueue_cmp cmppri;
-	void **d;
+	git_vector values;
+	size_t     initial_size;
+	uint32_t   flags;
 } git_pqueue;
 
+enum {
+	GIT_PQUEUE_DEFAULT = 0,
+	GIT_PQUEUE_FIXED_SIZE = (1 << 0), /* don't grow heap, keep highest */
+};
 
 /**
- * initialize the queue
+ * Initialize priority queue
  *
- * @param n the initial estimate of the number of queue items for which memory
- *			should be preallocated
- * @param cmppri the callback function to compare two nodes of the queue
- *
- * @return the handle or NULL for insufficent memory
+ * @param pq The priority queue struct to initialize
+ * @param flags Flags (see above) to control queue behavior
+ * @param est_size The estimated/initial queue size
+ * @param cmp The entry priority comparison function
+ * @return 0 on success, <0 on error
  */
-int git_pqueue_init(git_pqueue *q, size_t n, git_pqueue_cmp cmppri);
-
+extern int git_pqueue_init(
+	git_pqueue *pq,
+	uint32_t flags,
+	size_t est_size,
+	git_vector_cmp cmp);
 
 /**
- * free all memory used by the queue
- * @param q the queue
+ * Free the queue memory
  */
-void git_pqueue_free(git_pqueue *q);
+extern void git_pqueue_free(git_pqueue *pq);
 
 /**
- * clear all the elements in the queue
- * @param q the queue
+ * Get the number of items in the queue
  */
-void git_pqueue_clear(git_pqueue *q);
+GIT_INLINE(size_t) git_pqueue_size(const git_pqueue *pq)
+{
+	return git_vector_length(&pq->values);
+}
 
 /**
- * return the size of the queue.
- * @param q the queue
+ * Get an item in the queue
  */
-size_t git_pqueue_size(git_pqueue *q);
-
+GIT_INLINE(void *) git_pqueue_get(const git_pqueue *pq, size_t pos)
+{
+	return git_vector_get(&pq->values, pos);
+}
 
 /**
- * insert an item into the queue.
- * @param q the queue
- * @param d the item
- * @return 0 on success
- */
-int git_pqueue_insert(git_pqueue *q, void *d);
-
-
-/**
- * pop the highest-ranking item from the queue.
- * @param q the queue
- * @return NULL on error, otherwise the entry
+ * Insert a new item into the queue
+ *
+ * @param pq The priority queue
+ * @param item Pointer to the item data
+ * @return 0 on success, <0 on failure
  */
-void *git_pqueue_pop(git_pqueue *q);
-
+extern int git_pqueue_insert(git_pqueue *pq, void *item);
 
 /**
- * access highest-ranking item without removing it.
- * @param q the queue
- * @return NULL on error, otherwise the entry
+ * Remove the top item in the priority queue
+ *
+ * @param pq The priority queue
+ * @return item from heap on success, NULL if queue is empty
  */
-void *git_pqueue_peek(git_pqueue *q);
-
-#endif /* PQUEUE_H */
-/** @} */
+extern void *git_pqueue_pop(git_pqueue *pq);
 
+#endif
diff --git a/src/revwalk.c b/src/revwalk.c
index c0a053211..d6dc10652 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -439,7 +439,8 @@ int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
 	walk->commits = git_oidmap_alloc();
 	GITERR_CHECK_ALLOC(walk->commits);
 
-	if (git_pqueue_init(&walk->iterator_time, 8, git_commit_list_time_cmp) < 0 ||
+	if (git_pqueue_init(
+			&walk->iterator_time, 0, 8, git_commit_list_time_cmp) < 0 ||
 		git_vector_init(&walk->twos, 4, NULL) < 0 ||
 		git_pool_init(&walk->commit_pool, 1,
 			git_pool__suggest_items_per_page(COMMIT_ALLOC) * COMMIT_ALLOC) < 0)
@@ -542,7 +543,7 @@ void git_revwalk_reset(git_revwalk *walk)
 		commit->uninteresting = 0;
 		});
 
-	git_pqueue_clear(&walk->iterator_time);
+	git_pqueue_free(&walk->iterator_time);
 	git_commit_list_free(&walk->iterator_topo);
 	git_commit_list_free(&walk->iterator_rand);
 	git_commit_list_free(&walk->iterator_reverse);
diff --git a/src/vector.h b/src/vector.h
index d318463c6..e8a967813 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -95,4 +95,14 @@ GIT_INLINE(void) git_vector_set_cmp(git_vector *v, git_vector_cmp cmp)
 	}
 }
 
+/** Swap two elements */
+#define git_vector_swap_elements(V, P1, P2) do { \
+	void *__t = (V)->contents[P1]; \
+	(V)->contents[P1] = (V)->contents[P2]; \
+	(V)->contents[P2] = __t; } while (0)
+
+/** Compare two elements */
+#define git_vector_cmp_elements(V, P1, P2) \
+	(V)->_cmp(git_vector_get(V,P1), git_vector_get(V,P2))
+
 #endif
-- 
cgit v1.2.3


From af4bc6615d9fe0ebcc4abb939273913bcf9aee60 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 3 Feb 2014 21:04:40 -0800
Subject: Add some priority queue tests

I forgot that I wrote some tests for the new priority queue code.
---
 tests/core/pqueue.c | 97 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 tests/core/pqueue.c

diff --git a/tests/core/pqueue.c b/tests/core/pqueue.c
new file mode 100644
index 000000000..d91dbb0cd
--- /dev/null
+++ b/tests/core/pqueue.c
@@ -0,0 +1,97 @@
+#include "clar_libgit2.h"
+#include "pqueue.h"
+
+static int cmp_ints(const void *v1, const void *v2)
+{
+	int i1 = *(int *)v1, i2 = *(int *)v2;
+	return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
+}
+
+void test_core_pqueue__items_are_put_in_order(void)
+{
+	git_pqueue pq;
+	int i, vals[20];
+
+	cl_git_pass(git_pqueue_init(&pq, 0, 20, cmp_ints));
+
+	for (i = 0; i < 20; ++i) {
+		if (i < 10)
+			vals[i] = 10 - i; /* 10 down to 1 */
+		else
+			vals[i] = i + 1;  /* 11 up to 20 */
+
+		cl_git_pass(git_pqueue_insert(&pq, &vals[i]));
+	}
+
+	cl_assert_equal_i(20, git_pqueue_size(&pq));
+
+	for (i = 1; i <= 20; ++i) {
+		void *p = git_pqueue_pop(&pq);
+		cl_assert(p);
+		cl_assert_equal_i(i, *(int *)p);
+	}
+
+	cl_assert_equal_i(0, git_pqueue_size(&pq));
+
+	git_pqueue_free(&pq);
+}
+
+void test_core_pqueue__interleave_inserts_and_pops(void)
+{
+	git_pqueue pq;
+	int chunk, v, i, vals[200];
+
+	cl_git_pass(git_pqueue_init(&pq, 0, 20, cmp_ints));
+
+	for (v = 0, chunk = 20; chunk <= 200; chunk += 20) {
+		/* push the next 20 */
+		for (; v < chunk; ++v) {
+			vals[v] = (v & 1) ? 200 - v : v;
+			cl_git_pass(git_pqueue_insert(&pq, &vals[v]));
+		}
+
+		/* pop the lowest 10 */
+		for (i = 0; i < 10; ++i)
+			(void)git_pqueue_pop(&pq);
+	}
+
+	cl_assert_equal_i(100, git_pqueue_size(&pq));
+
+	/* at this point, we've popped 0-99 */
+
+	for (v = 100; v < 200; ++v) {
+		void *p = git_pqueue_pop(&pq);
+		cl_assert(p);
+		cl_assert_equal_i(v, *(int *)p);
+	}
+
+	cl_assert_equal_i(0, git_pqueue_size(&pq));
+
+	git_pqueue_free(&pq);
+}
+
+void test_core_pqueue__max_heap_size(void)
+{
+	git_pqueue pq;
+	int i, vals[100];
+
+	cl_git_pass(git_pqueue_init(&pq, GIT_PQUEUE_FIXED_SIZE, 50, cmp_ints));
+
+	for (i = 0; i < 100; ++i) {
+		vals[i] = (i & 1) ? 100 - i : i;
+		cl_git_pass(git_pqueue_insert(&pq, &vals[i]));
+	}
+
+	cl_assert_equal_i(50, git_pqueue_size(&pq));
+
+	for (i = 50; i < 100; ++i) {
+		void *p = git_pqueue_pop(&pq);
+		cl_assert(p);
+		cl_assert_equal_i(i, *(int *)p);
+	}
+
+	cl_assert_equal_i(0, git_pqueue_size(&pq));
+
+	git_pqueue_free(&pq);
+
+}
-- 
cgit v1.2.3


From 882c7742711199f757305687c257ac97262a3a30 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 4 Feb 2014 10:01:37 -0800
Subject: Convert pqueue to just be a git_vector

This updates the git_pqueue to simply be a set of specialized
init/insert/pop functions on a git_vector.

To preserve the pqueue feature of having a fixed size heap, I
converted the "sorted" field in git_vectors to a more general
"flags" field so that pqueue could mix in it's own flag.  This
had a bunch of ramifications because a number of places were
directly looking at the vector "sorted" field - I added a couple
new git_vector helpers (is_sorted, set_sorted) so the specific
representation of this information could be abstracted.
---
 src/index.c         |  6 +++---
 src/pqueue.c        | 57 +++++++++++++++++++++++++++++------------------------
 src/pqueue.h        | 38 +++++++++--------------------------
 src/revwalk.c       |  2 +-
 src/sortedcache.c   |  2 +-
 src/tree.c          |  6 ++++--
 src/vector.c        | 17 +++++++++-------
 src/vector.h        | 17 ++++++++++++++--
 tests/index/tests.c |  8 ++++----
 9 files changed, 78 insertions(+), 75 deletions(-)

diff --git a/src/index.c b/src/index.c
index 7bc5d5b24..1ab126c87 100644
--- a/src/index.c
+++ b/src/index.c
@@ -1564,7 +1564,7 @@ static int read_reuc(git_index *index, const char *buffer, size_t size)
 	}
 
 	/* entries are guaranteed to be sorted on-disk */
-	index->reuc.sorted = 1;
+	git_vector_set_sorted(&index->reuc, true);
 
 	return 0;
 }
@@ -1610,7 +1610,7 @@ static int read_conflict_names(git_index *index, const char *buffer, size_t size
 #undef read_conflict_name
 
 	/* entries are guaranteed to be sorted on-disk */
-	index->names.sorted = 1;
+	git_vector_set_sorted(&index->names, true);
 
 	return 0;
 }
@@ -1812,7 +1812,7 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 #undef seek_forward
 
 	/* Entries are stored case-sensitively on disk. */
-	index->entries.sorted = !index->ignore_case;
+	git_vector_set_sorted(&index->entries, index->ignore_case);
 	git_vector_sort(&index->entries);
 
 	return 0;
diff --git a/src/pqueue.c b/src/pqueue.c
index ddbad7a54..cc31a8f95 100644
--- a/src/pqueue.c
+++ b/src/pqueue.c
@@ -15,25 +15,29 @@
 int git_pqueue_init(
 	git_pqueue *pq,
 	uint32_t flags,
-	size_t est_size,
+	size_t init_size,
 	git_vector_cmp cmp)
 {
-	pq->flags = flags;
-	pq->initial_size = est_size;
-	return git_vector_init(&pq->values, est_size, cmp);
-}
+	int error = git_vector_init(pq, init_size, cmp);
 
-void git_pqueue_free(git_pqueue *pq)
-{
-	git_vector_free(&pq->values);
+	if (!error) {
+		/* mix in our flags */
+		pq->flags |= flags;
+
+		/* if fixed size heap, pretend vector is exactly init_size elements */
+		if ((flags & GIT_PQUEUE_FIXED_SIZE) && init_size > 0)
+			pq->_alloc_size = init_size;
+	}
+
+	return error;
 }
 
 static void pqueue_up(git_pqueue *pq, size_t el)
 {
 	size_t parent_el = PQUEUE_PARENT_OF(el);
 
-	while (el > 0 && git_vector_cmp_elements(&pq->values, parent_el, el) > 0) {
-		git_vector_swap_elements(&pq->values, el, parent_el);
+	while (el > 0 && git_vector_cmp_elements(pq, parent_el, el) > 0) {
+		git_vector_swap_elements(pq, el, parent_el);
 
 		el = parent_el;
 		parent_el = PQUEUE_PARENT_OF(el);
@@ -42,19 +46,19 @@ static void pqueue_up(git_pqueue *pq, size_t el)
 
 static void pqueue_down(git_pqueue *pq, size_t el)
 {
-	size_t last = git_vector_length(&pq->values);
+	size_t last = git_pqueue_size(pq);
 
 	while (1) {
 		size_t kid = PQUEUE_LCHILD_OF(el), rkid = PQUEUE_RCHILD_OF(el);
 		if (kid >= last)
 			break;
-		if (rkid < last && git_vector_cmp_elements(&pq->values, kid, rkid) > 0)
+		if (rkid < last && git_vector_cmp_elements(pq, kid, rkid) > 0)
 			kid = rkid;
 
-		if (git_vector_cmp_elements(&pq->values, el, kid) < 0)
+		if (git_vector_cmp_elements(pq, el, kid) < 0)
 			break;
 
-		git_vector_swap_elements(&pq->values, el, kid);
+		git_vector_swap_elements(pq, el, kid);
 		el = kid;
 	}
 }
@@ -65,32 +69,33 @@ int git_pqueue_insert(git_pqueue *pq, void *item)
 
 	/* if heap is full, pop the top element if new one should replace it */
 	if ((pq->flags & GIT_PQUEUE_FIXED_SIZE) != 0 &&
-		pq->values.length >= pq->initial_size)
+		pq->length >= pq->_alloc_size)
 	{
-		/* skip item if below min item in heap */
-		if (pq->values._cmp(item, git_vector_get(&pq->values, 0)) <= 0)
+		/* skip this item if below min item in heap */
+		if (pq->_cmp(item, git_vector_get(pq, 0)) <= 0)
 			return 0;
+		/* otherwise remove the min item before inserting new */
 		(void)git_pqueue_pop(pq);
 	}
 
-	error = git_vector_insert(&pq->values, item);
-
-	if (!error)
-		pqueue_up(pq, pq->values.length - 1);
+	if (!(error = git_vector_insert(pq, item)))
+		pqueue_up(pq, pq->length - 1);
 
 	return error;
 }
 
 void *git_pqueue_pop(git_pqueue *pq)
 {
-	void *rval = git_vector_get(&pq->values, 0);
+	void *rval = git_pqueue_get(pq, 0);
 
-	if (git_vector_length(&pq->values) > 1) {
-		pq->values.contents[0] = git_vector_last(&pq->values);
-		git_vector_pop(&pq->values);
+	if (git_pqueue_size(pq) > 1) {
+		/* move last item to top of heap, shrink, and push item down */
+		pq->contents[0] = git_vector_last(pq);
+		git_vector_pop(pq);
 		pqueue_down(pq, 0);
 	} else {
-		git_vector_pop(&pq->values);
+		/* all we need to do is shrink the heap in this case */
+		git_vector_pop(pq);
 	}
 
 	return rval;
diff --git a/src/pqueue.h b/src/pqueue.h
index 3c977e178..da7b74edf 100644
--- a/src/pqueue.h
+++ b/src/pqueue.h
@@ -9,15 +9,11 @@
 
 #include "vector.h"
 
-typedef struct {
-	git_vector values;
-	size_t     initial_size;
-	uint32_t   flags;
-} git_pqueue;
+typedef git_vector git_pqueue;
 
 enum {
-	GIT_PQUEUE_DEFAULT = 0,
-	GIT_PQUEUE_FIXED_SIZE = (1 << 0), /* don't grow heap, keep highest */
+	/* flag meaning: don't grow heap, keep highest values only */
+	GIT_PQUEUE_FIXED_SIZE = (GIT_VECTOR_FLAG_MAX << 1),
 };
 
 /**
@@ -25,36 +21,20 @@ enum {
  *
  * @param pq The priority queue struct to initialize
  * @param flags Flags (see above) to control queue behavior
- * @param est_size The estimated/initial queue size
+ * @param init_size The initial queue size
  * @param cmp The entry priority comparison function
  * @return 0 on success, <0 on error
  */
 extern int git_pqueue_init(
 	git_pqueue *pq,
 	uint32_t flags,
-	size_t est_size,
+	size_t init_size,
 	git_vector_cmp cmp);
 
-/**
- * Free the queue memory
- */
-extern void git_pqueue_free(git_pqueue *pq);
-
-/**
- * Get the number of items in the queue
- */
-GIT_INLINE(size_t) git_pqueue_size(const git_pqueue *pq)
-{
-	return git_vector_length(&pq->values);
-}
-
-/**
- * Get an item in the queue
- */
-GIT_INLINE(void *) git_pqueue_get(const git_pqueue *pq, size_t pos)
-{
-	return git_vector_get(&pq->values, pos);
-}
+#define git_pqueue_free  git_vector_free
+#define git_pqueue_clear git_vector_clear
+#define git_pqueue_size  git_vector_length
+#define git_pqueue_get   git_vector_get
 
 /**
  * Insert a new item into the queue
diff --git a/src/revwalk.c b/src/revwalk.c
index d6dc10652..3bfc4d1aa 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -543,7 +543,7 @@ void git_revwalk_reset(git_revwalk *walk)
 		commit->uninteresting = 0;
 		});
 
-	git_pqueue_free(&walk->iterator_time);
+	git_pqueue_clear(&walk->iterator_time);
 	git_commit_list_free(&walk->iterator_topo);
 	git_commit_list_free(&walk->iterator_rand);
 	git_commit_list_free(&walk->iterator_reverse);
diff --git a/src/sortedcache.c b/src/sortedcache.c
index 466e55dbe..13f0921f1 100644
--- a/src/sortedcache.c
+++ b/src/sortedcache.c
@@ -321,7 +321,7 @@ size_t git_sortedcache_entrycount(const git_sortedcache *sc)
 void *git_sortedcache_entry(git_sortedcache *sc, size_t pos)
 {
 	/* make sure the items are sorted so this gets the correct item */
-	if (!sc->items.sorted)
+	if (!git_vector_is_sorted(&sc->items))
 		git_vector_sort(&sc->items);
 
 	return git_vector_get(&sc->items, pos);
diff --git a/src/tree.c b/src/tree.c
index 877a3fcee..94f779eca 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -283,7 +283,8 @@ static const git_tree_entry *entry_fromname(
 {
 	size_t idx;
 
-	assert(tree->entries.sorted); /* be safe when we cast away constness */
+	/* be safe when we cast away constness - i.e. don't trigger a sort */
+	assert(git_vector_is_sorted(&tree->entries));
 
 	if (tree_key_search(&idx, (git_vector *)&tree->entries, name, name_len) < 0)
 		return NULL;
@@ -333,7 +334,8 @@ int git_tree__prefix_position(const git_tree *tree, const char *path)
 	ksearch.filename = path;
 	ksearch.filename_len = strlen(path);
 
-	assert(tree->entries.sorted); /* be safe when we cast away constness */
+	/* be safe when we cast away constness - i.e. don't trigger a sort */
+	assert(git_vector_is_sorted(&tree->entries));
 
 	/* Find tree entry with appropriate prefix */
 	git_vector_bsearch2(
diff --git a/src/vector.c b/src/vector.c
index f0c2f06c2..e5d8919d3 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -56,7 +56,9 @@ int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp)
 	v->_alloc_size = src->length;
 	v->_cmp = cmp;
 	v->length = src->length;
-	v->sorted = src->sorted && cmp == src->_cmp;
+	v->flags  = src->flags;
+	if (cmp != src->_cmp)
+		git_vector_set_sorted(v, 0);
 	v->contents = git__malloc(bytes);
 	GITERR_CHECK_ALLOC(v->contents);
 
@@ -97,7 +99,7 @@ int git_vector_init(git_vector *v, size_t initial_size, git_vector_cmp cmp)
 	v->_alloc_size = 0;
 	v->_cmp = cmp;
 	v->length = 0;
-	v->sorted = 1;
+	v->flags = GIT_VECTOR_SORTED;
 	v->contents = NULL;
 
 	return resize_vector(v, max(initial_size, MIN_ALLOCSIZE));
@@ -128,7 +130,8 @@ int git_vector_insert(git_vector *v, void *element)
 		return -1;
 
 	v->contents[v->length++] = element;
-	v->sorted = 0;
+
+	git_vector_set_sorted(v, v->length <= 1);
 
 	return 0;
 }
@@ -141,7 +144,7 @@ int git_vector_insert_sorted(
 
 	assert(v && v->_cmp);
 
-	if (!v->sorted)
+	if (!git_vector_is_sorted(v))
 		git_vector_sort(v);
 
 	if (v->length >= v->_alloc_size &&
@@ -171,11 +174,11 @@ void git_vector_sort(git_vector *v)
 {
 	assert(v);
 
-	if (v->sorted || !v->_cmp)
+	if (git_vector_is_sorted(v) || !v->_cmp)
 		return;
 
 	git__tsort(v->contents, v->length, v->_cmp);
-	v->sorted = 1;
+	git_vector_set_sorted(v, 1);
 }
 
 int git_vector_bsearch2(
@@ -291,7 +294,7 @@ void git_vector_clear(git_vector *v)
 {
 	assert(v);
 	v->length = 0;
-	v->sorted = 1;
+	git_vector_set_sorted(v, 1);
 }
 
 void git_vector_swap(git_vector *a, git_vector *b)
diff --git a/src/vector.h b/src/vector.h
index e8a967813..f983c55d5 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -11,12 +11,17 @@
 
 typedef int (*git_vector_cmp)(const void *, const void *);
 
+enum {
+	GIT_VECTOR_SORTED = (1u << 0),
+	GIT_VECTOR_FLAG_MAX = (1u << 1),
+};
+
 typedef struct git_vector {
 	size_t _alloc_size;
 	git_vector_cmp _cmp;
 	void **contents;
 	size_t length;
-	int sorted;
+	uint32_t flags;
 } git_vector;
 
 #define GIT_VECTOR_INIT {0}
@@ -86,12 +91,20 @@ void git_vector_remove_matching(
 int git_vector_resize_to(git_vector *v, size_t new_length);
 int git_vector_set(void **old, git_vector *v, size_t position, void *value);
 
+/** Check if vector is sorted */
+#define git_vector_is_sorted(V) (((V)->flags & GIT_VECTOR_SORTED) != 0)
+
+/** Directly set sorted state of vector */
+#define git_vector_set_sorted(V,S) do { \
+	(V)->flags = (S) ? ((V)->flags | GIT_VECTOR_SORTED) : \
+		((V)->flags & ~GIT_VECTOR_SORTED); } while (0)
+
 /** Set the comparison function used for sorting the vector */
 GIT_INLINE(void) git_vector_set_cmp(git_vector *v, git_vector_cmp cmp)
 {
 	if (cmp != v->_cmp) {
 		v->_cmp = cmp;
-		v->sorted = 0;
+		git_vector_set_sorted(v, 0);
 	}
 }
 
diff --git a/tests/index/tests.c b/tests/index/tests.c
index bd90bc557..55a2f2c51 100644
--- a/tests/index/tests.c
+++ b/tests/index/tests.c
@@ -80,7 +80,7 @@ void test_index_tests__empty_index(void)
    cl_assert(index->on_disk == 0);
 
    cl_assert(git_index_entrycount(index) == 0);
-   cl_assert(index->entries.sorted);
+   cl_assert(git_vector_is_sorted(&index->entries));
 
    git_index_free(index);
 }
@@ -95,7 +95,7 @@ void test_index_tests__default_test_index(void)
    cl_assert(index->on_disk);
 
    cl_assert(git_index_entrycount(index) == index_entry_count);
-   cl_assert(index->entries.sorted);
+   cl_assert(git_vector_is_sorted(&index->entries));
 
    entries = (git_index_entry **)index->entries.contents;
 
@@ -118,7 +118,7 @@ void test_index_tests__gitgit_index(void)
    cl_assert(index->on_disk);
 
    cl_assert(git_index_entrycount(index) == index_entry_count_2);
-   cl_assert(index->entries.sorted);
+   cl_assert(git_vector_is_sorted(&index->entries));
    cl_assert(index->tree != NULL);
 
    git_index_free(index);
@@ -195,7 +195,7 @@ void test_index_tests__sort1(void)
    cl_git_pass(git_index_open(&index, "fake-index"));
 
    /* FIXME: this test is slightly dumb */
-   cl_assert(index->entries.sorted);
+   cl_assert(git_vector_is_sorted(&index->entries));
 
    git_index_free(index);
 }
-- 
cgit v1.2.3


From 43709ca87811efc3c237eb719611f025502f3928 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 4 Feb 2014 10:33:30 -0800
Subject: Fix typo setting sorted flag when reloading index

This fixes a typo I made for setting the sorted flag on the index
after a reload.  That typo didn't actually cause any test failures
so I'm also adding a test that explicitly checks that the index is
correctly sorted after a reload when ignoring case and when not.
---
 src/index.c         |  6 ++++--
 tests/index/tests.c | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/src/index.c b/src/index.c
index 1ab126c87..42eb5fd49 100644
--- a/src/index.c
+++ b/src/index.c
@@ -1811,8 +1811,10 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 
 #undef seek_forward
 
-	/* Entries are stored case-sensitively on disk. */
-	git_vector_set_sorted(&index->entries, index->ignore_case);
+	/* Entries are stored case-sensitively on disk, so re-sort now if
+	 * in-memory index is supposed to be case-insensitive
+	 */
+	git_vector_set_sorted(&index->entries, !index->ignore_case);
 	git_vector_sort(&index->entries);
 
 	return 0;
diff --git a/tests/index/tests.c b/tests/index/tests.c
index 55a2f2c51..6e28af1f7 100644
--- a/tests/index/tests.c
+++ b/tests/index/tests.c
@@ -543,3 +543,37 @@ void test_index_tests__corrupted_extension(void)
 
 	cl_git_fail_with(git_index_open(&index, TEST_INDEXBAD_PATH), GIT_ERROR);
 }
+
+static void assert_index_is_sorted(git_index *index)
+{
+	git_vector *entries = &index->entries;
+	size_t i;
+
+	cl_assert(git_vector_is_sorted(entries));
+
+	for (i = 1; i < git_vector_length(entries); ++i) {
+		git_index_entry *prev = git_vector_get(entries, i - 1);
+		git_index_entry *curr = git_vector_get(entries, i);
+		cl_assert(index->entries._cmp(prev, curr) <= 0);
+	}
+}
+
+void test_index_tests__reload_while_ignoring_case(void)
+{
+	git_index *index;
+	unsigned int caps;
+
+	cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
+	assert_index_is_sorted(index);
+
+	caps = git_index_caps(index);
+	cl_git_pass(git_index_set_caps(index, caps &= ~GIT_INDEXCAP_IGNORE_CASE));
+	cl_git_pass(git_index_read(index, true));
+	assert_index_is_sorted(index);
+
+	cl_git_pass(git_index_set_caps(index, caps | GIT_INDEXCAP_IGNORE_CASE));
+	cl_git_pass(git_index_read(index, true));
+	assert_index_is_sorted(index);
+
+	git_index_free(index);
+}
-- 
cgit v1.2.3


From 0adb06065b944e755933e11ed9ac7ce544b55d33 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 4 Feb 2014 15:32:57 -0800
Subject: Fix reflog message when creating commits

---
 src/commit.c         | 23 +++++++++++++++++++++--
 tests/commit/write.c | 15 ++++++++++++++-
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/src/commit.c b/src/commit.c
index da7c4992e..b9c21f3cd 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -111,8 +111,27 @@ int git_commit_create_from_ids(
 
 	git_buf_free(&commit);
 
-	if (update_ref != NULL)
-		return git_reference__update_terminal(repo, update_ref, oid, NULL, NULL);
+	if (update_ref != NULL) {
+		int error;
+		git_commit *c;
+		const char *shortmsg;
+		git_buf reflog_msg = GIT_BUF_INIT;
+
+		if (git_commit_lookup(&c, repo, oid) < 0)
+			goto on_error;
+
+		shortmsg = git_commit_summary(c);
+		git_buf_printf(&reflog_msg, "commit%s: %s",
+				git_commit_parentcount(c) == 0 ? " (initial)" : "",
+				shortmsg);
+		git_commit_free(c);
+
+		error = git_reference__update_terminal(repo, update_ref, oid,
+				committer, git_buf_cstr(&reflog_msg));
+
+		git_buf_free(&reflog_msg);
+		return error;
+	}
 
 	return 0;
 
diff --git a/tests/commit/write.c b/tests/commit/write.c
index 8e5b67f2f..b1cdf4485 100644
--- a/tests/commit/write.c
+++ b/tests/commit/write.c
@@ -7,6 +7,8 @@ static const char *commit_message = "This commit has been created in memory\n\
 static const char *tree_oid = "1810dff58d8a660512d4832e740f692884338ccd";
 static const char *root_commit_message = "This is a root commit\n\
    This is a root commit and should be the only one in this branch\n";
+static const char *root_reflog_message = "commit (initial): This is a root commit \
+   This is a root commit and should be the only one in this branch";
 static char *head_old;
 static git_reference *head, *branch;
 static git_commit *commit;
@@ -101,6 +103,8 @@ void test_commit_write__root(void)
 	git_signature *author, *committer;
 	const char *branch_name = "refs/heads/root-commit-branch";
 	git_tree *tree;
+	git_reflog *log;
+	const git_reflog_entry *entry;
 
 	git_oid_fromstr(&tree_id, tree_oid);
 	cl_git_pass(git_tree_lookup(&tree, g_repo, &tree_id));
@@ -130,7 +134,6 @@ void test_commit_write__root(void)
 		0));
 
 	git_object_free((git_object *)tree);
-	git_signature_free(committer);
 	git_signature_free(author);
 
 	/*
@@ -144,4 +147,14 @@ void test_commit_write__root(void)
 	branch_oid = git_reference_target(branch);
 	cl_git_pass(git_oid_cmp(branch_oid, &commit_id));
 	cl_assert_equal_s(root_commit_message, git_commit_message(commit));
+
+	cl_git_pass(git_reflog_read(&log, g_repo, branch_name));
+	cl_assert_equal_i(1, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s(committer->email, git_reflog_entry_committer(entry)->email);
+	cl_assert_equal_s(committer->name, git_reflog_entry_committer(entry)->name);
+	cl_assert_equal_s(root_reflog_message, git_reflog_entry_message(entry));
+
+	git_signature_free(committer);
+	git_reflog_free(log);
 }
-- 
cgit v1.2.3


From 1bbacc9ff617b67831dbfce5e1b04e1bd8571aa0 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 4 Feb 2014 16:46:43 -0800
Subject: Avoid extra copying in pqueue operations

This tweaks the pqueue_up and pqueue_down routines so that they
will not do full element swaps but instead carry over the state
of the previous loop iteration and only assign elements for which
we know the final position.  This will avoid a little bit of data
assignment which should improve performance in theory.

Also got rid of some vector helpers that I'm no longer using.
---
 src/pqueue.c | 35 +++++++++++++++++++++++++----------
 src/vector.h | 10 ----------
 2 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/src/pqueue.c b/src/pqueue.c
index cc31a8f95..172cf43d5 100644
--- a/src/pqueue.c
+++ b/src/pqueue.c
@@ -35,32 +35,47 @@ int git_pqueue_init(
 static void pqueue_up(git_pqueue *pq, size_t el)
 {
 	size_t parent_el = PQUEUE_PARENT_OF(el);
+	void *kid = git_vector_get(pq, el);
 
-	while (el > 0 && git_vector_cmp_elements(pq, parent_el, el) > 0) {
-		git_vector_swap_elements(pq, el, parent_el);
+	while (el > 0) {
+		void *parent = pq->contents[parent_el];
+
+		if (pq->_cmp(parent, kid) <= 0)
+			break;
+
+		pq->contents[el] = parent;
 
 		el = parent_el;
 		parent_el = PQUEUE_PARENT_OF(el);
 	}
+
+	pq->contents[el] = kid;
 }
 
 static void pqueue_down(git_pqueue *pq, size_t el)
 {
-	size_t last = git_pqueue_size(pq);
+	void *parent = git_vector_get(pq, el), *kid, *rkid;
 
 	while (1) {
-		size_t kid = PQUEUE_LCHILD_OF(el), rkid = PQUEUE_RCHILD_OF(el);
-		if (kid >= last)
+		size_t kid_el = PQUEUE_LCHILD_OF(el);
+
+		if ((kid = git_vector_get(pq, kid_el)) == NULL)
 			break;
-		if (rkid < last && git_vector_cmp_elements(pq, kid, rkid) > 0)
-			kid = rkid;
 
-		if (git_vector_cmp_elements(pq, el, kid) < 0)
+		if ((rkid = git_vector_get(pq, kid_el + 1)) != NULL &&
+			pq->_cmp(kid, rkid) > 0) {
+			kid    = rkid;
+			kid_el += 1;
+		}
+
+		if (pq->_cmp(parent, kid) < 0)
 			break;
 
-		git_vector_swap_elements(pq, el, kid);
-		el = kid;
+		pq->contents[el] = kid;
+		el = kid_el;
 	}
+
+	pq->contents[el] = parent;
 }
 
 int git_pqueue_insert(git_pqueue *pq, void *item)
diff --git a/src/vector.h b/src/vector.h
index f983c55d5..f8256853b 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -108,14 +108,4 @@ GIT_INLINE(void) git_vector_set_cmp(git_vector *v, git_vector_cmp cmp)
 	}
 }
 
-/** Swap two elements */
-#define git_vector_swap_elements(V, P1, P2) do { \
-	void *__t = (V)->contents[P1]; \
-	(V)->contents[P1] = (V)->contents[P2]; \
-	(V)->contents[P2] = __t; } while (0)
-
-/** Compare two elements */
-#define git_vector_cmp_elements(V, P1, P2) \
-	(V)->_cmp(git_vector_get(V,P1), git_vector_get(V,P2))
-
 #endif
-- 
cgit v1.2.3


From 491cecfe8ce4c6fbee3357248c7b688b6e1aaab4 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 4 Feb 2014 20:13:50 -0800
Subject: Add reflog parameters to git_push_update_tips

---
 include/git2/push.h |  8 +++++++-
 src/push.c          |  9 +++++++--
 tests/online/push.c | 16 +++++++++++++++-
 3 files changed, 29 insertions(+), 4 deletions(-)

diff --git a/include/git2/push.h b/include/git2/push.h
index 12f0e7f2c..c98c6d96e 100644
--- a/include/git2/push.h
+++ b/include/git2/push.h
@@ -103,10 +103,16 @@ GIT_EXTERN(int) git_push_add_refspec(git_push *push, const char *refspec);
  * Update remote tips after a push
  *
  * @param push The push object
+ * @param signature The identity to use when updating reflogs
+ * @param reflog_message The message to insert into the reflogs. If NULL, the
+ *								 default is "update by push".
  *
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_push_update_tips(git_push *push);
+GIT_EXTERN(int) git_push_update_tips(
+		git_push *push,
+		const git_signature *signature,
+		const char *reflog_message);
 
 /**
  * Actually push all given refspecs
diff --git a/src/push.c b/src/push.c
index d39a27182..c2947808e 100644
--- a/src/push.c
+++ b/src/push.c
@@ -194,7 +194,10 @@ int git_push_add_refspec(git_push *push, const char *refspec)
 	return 0;
 }
 
-int git_push_update_tips(git_push *push)
+int git_push_update_tips(
+		git_push *push,
+		const git_signature *signature,
+		const char *reflog_message)
 {
 	git_buf remote_ref_name = GIT_BUF_INIT;
 	size_t i, j;
@@ -241,7 +244,9 @@ int git_push_update_tips(git_push *push)
 				giterr_clear();
 			else
 				goto on_error;
-		} else if ((error = git_reference_create(NULL, push->remote->repo, git_buf_cstr(&remote_ref_name), &push_spec->loid, 1, NULL, NULL)) < 0)
+		} else if ((error = git_reference_create(NULL, push->remote->repo,
+						git_buf_cstr(&remote_ref_name), &push_spec->loid, 1, signature,
+						reflog_message ? reflog_message : "update by push")) < 0)
 			goto on_error;
 	}
 
diff --git a/tests/online/push.c b/tests/online/push.c
index 8efe21e0e..c0ff2f22c 100644
--- a/tests/online/push.c
+++ b/tests/online/push.c
@@ -414,11 +414,13 @@ static void do_push(
 	git_push_options opts = GIT_PUSH_OPTIONS_INIT;
 	size_t i;
 	int pack_progress_calls = 0, transfer_progress_calls = 0;
+	git_signature *pusher;
 
 	if (_remote) {
 		/* Auto-detect the number of threads to use */
 		opts.pb_parallelism = 0;
 
+		cl_git_pass(git_signature_now(&pusher, "Foo Bar", "foo@example.com"));
 		cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_PUSH));
 
 		cl_git_pass(git_push_new(&push, _remote));
@@ -455,13 +457,15 @@ static void do_push(
 
 		verify_refs(_remote, expected_refs, expected_refs_len);
 
-		cl_git_pass(git_push_update_tips(push));
+		cl_git_pass(git_push_update_tips(push, pusher, "test push"));
 		verify_tracking_branches(_remote, expected_refs, expected_refs_len);
 
 		git_push_free(push);
 
 		git_remote_disconnect(_remote);
+		git_signature_free(pusher);
 	}
+
 }
 
 /* Call push_finish() without ever calling git_push_add_refspec() */
@@ -528,6 +532,9 @@ void test_online_push__b5_cancel(void)
 
 void test_online_push__multi(void)
 {
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
 	const char *specs[] = {
 		"refs/heads/b1:refs/heads/b1",
 		"refs/heads/b2:refs/heads/b2",
@@ -552,6 +559,13 @@ void test_online_push__multi(void)
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
 		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+
+	cl_git_pass(git_reflog_read(&log, _repo, "refs/remotes/test/b1"));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("test push", git_reflog_entry_message(entry));
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
+
+	git_reflog_free(log);
 }
 
 void test_online_push__implicit_tgt(void)
-- 
cgit v1.2.3


From c3ab1e5af4c43d1031969fbb12c559a55c5baf05 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 4 Feb 2014 20:38:13 -0800
Subject: Add reflog parameters to remote apis

Also added a test for git_remote_fetch.
---
 include/git2/remote.h        | 16 +++++++++--
 src/clone.c                  |  2 +-
 src/remote.c                 | 26 ++++++++++++-----
 tests/network/fetchlocal.c   |  4 +--
 tests/network/remote/local.c | 67 ++++++++++++++++++++++++++++++++++++++++----
 tests/online/fetch.c         |  4 +--
 tests/online/fetchhead.c     |  2 +-
 tests/online/push.c          |  2 +-
 8 files changed, 101 insertions(+), 22 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index eba6ca7f9..dff913295 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -355,9 +355,15 @@ GIT_EXTERN(void) git_remote_free(git_remote *remote);
  * Update the tips to the new state
  *
  * @param remote the remote to update
+ * @param signature The identity to use when updating reflogs
+ * @param reflog_message The message to insert into the reflogs. If NULL, the
+ *								 default is "fetch"
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_remote_update_tips(git_remote *remote);
+GIT_EXTERN(int) git_remote_update_tips(
+		git_remote *remote,
+		const git_signature *signature,
+		const char *reflog_message);
 
 /**
  * Download new data and update tips
@@ -366,9 +372,15 @@ GIT_EXTERN(int) git_remote_update_tips(git_remote *remote);
  * disconnect and update the remote-tracking branches.
  *
  * @param remote the remote to fetch from
+ * @param signature The identity to use when updating reflogs
+ * @param reflog_message The message to insert into the reflogs. If NULL, the
+ *								 default is "fetch"
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_remote_fetch(git_remote *remote);
+GIT_EXTERN(int) git_remote_fetch(
+		git_remote *remote,
+		const git_signature *signature,
+		const char *reflog_message);
 
 /**
  * Return whether a string is a valid remote URL
diff --git a/src/clone.c b/src/clone.c
index 3443528f7..bcc38678f 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -360,7 +360,7 @@ int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_
 	git_remote_set_update_fetchhead(remote, 0);
 	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
 
-	if ((error = git_remote_fetch(remote)) != 0)
+	if ((error = git_remote_fetch(remote, signature, git_buf_cstr(&reflog_message))) != 0)
 		goto cleanup;
 
 	if (branch)
diff --git a/src/remote.c b/src/remote.c
index f33f5ef3c..28188acf4 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -845,7 +845,10 @@ int git_remote_download(git_remote *remote)
 	return git_fetch_download_pack(remote);
 }
 
-int git_remote_fetch(git_remote *remote)
+int git_remote_fetch(
+		git_remote *remote,
+		const git_signature *signature,
+		const char *reflog_message)
 {
 	int error;
 
@@ -860,7 +863,7 @@ int git_remote_fetch(git_remote *remote)
 	git_remote_disconnect(remote);
 
 	/* Create "remote/foo" branches for all remote branches */
-	return git_remote_update_tips(remote);
+	return git_remote_update_tips(remote, signature, reflog_message);
 }
 
 static int remote_head_for_fetchspec_src(git_remote_head **out, git_vector *update_heads, const char *fetchspec_src)
@@ -978,7 +981,12 @@ cleanup:
 	return error;
 }
 
-static int update_tips_for_spec(git_remote *remote, git_refspec *spec, git_vector *refs)
+static int update_tips_for_spec(
+		git_remote *remote,
+		git_refspec *spec,
+		git_vector *refs,
+		const git_signature *signature,
+		const char *log_message)
 {
 	int error = 0, autotag;
 	unsigned int i = 0;
@@ -1045,7 +1053,8 @@ static int update_tips_for_spec(git_remote *remote, git_refspec *spec, git_vecto
 			continue;
 
 		/* In autotag mode, don't overwrite any locally-existing tags */
-		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag, NULL, NULL);
+		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag, 
+				signature, log_message);
 		if (error < 0 && error != GIT_EEXISTS)
 			goto on_error;
 
@@ -1074,7 +1083,10 @@ on_error:
 
 }
 
-int git_remote_update_tips(git_remote *remote)
+int git_remote_update_tips(
+		git_remote *remote,
+		const git_signature *signature,
+		const char *reflog_message)
 {
 	git_refspec *spec, tagspec;
 	git_vector refs;
@@ -1089,7 +1101,7 @@ int git_remote_update_tips(git_remote *remote)
 		goto out;
 
 	if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_ALL) {
-		error = update_tips_for_spec(remote, &tagspec, &refs);
+		error = update_tips_for_spec(remote, &tagspec, &refs, signature, reflog_message);
 		goto out;
 	}
 
@@ -1097,7 +1109,7 @@ int git_remote_update_tips(git_remote *remote)
 		if (spec->push)
 			continue;
 
-		if ((error = update_tips_for_spec(remote, spec, &refs)) < 0)
+		if ((error = update_tips_for_spec(remote, spec, &refs, signature, reflog_message)) < 0)
 			goto out;
 	}
 
diff --git a/tests/network/fetchlocal.c b/tests/network/fetchlocal.c
index 28c7115bf..4c39394bb 100644
--- a/tests/network/fetchlocal.c
+++ b/tests/network/fetchlocal.c
@@ -37,7 +37,7 @@ void test_network_fetchlocal__complete(void)
 	git_remote_set_callbacks(origin, &callbacks);
 	cl_git_pass(git_remote_connect(origin, GIT_DIRECTION_FETCH));
 	cl_git_pass(git_remote_download(origin));
-	cl_git_pass(git_remote_update_tips(origin));
+	cl_git_pass(git_remote_update_tips(origin, NULL, NULL));
 
 	cl_git_pass(git_reference_list(&refnames, repo));
 	cl_assert_equal_i(19, (int)refnames.count);
@@ -75,7 +75,7 @@ void test_network_fetchlocal__partial(void)
 	git_remote_set_callbacks(origin, &callbacks);
 	cl_git_pass(git_remote_connect(origin, GIT_DIRECTION_FETCH));
 	cl_git_pass(git_remote_download(origin));
-	cl_git_pass(git_remote_update_tips(origin));
+	cl_git_pass(git_remote_update_tips(origin, NULL, NULL));
 
 	git_strarray_free(&refnames);
 
diff --git a/tests/network/remote/local.c b/tests/network/remote/local.c
index 9b9f716b9..526564721 100644
--- a/tests/network/remote/local.c
+++ b/tests/network/remote/local.c
@@ -115,7 +115,7 @@ void test_network_remote_local__shorthand_fetch_refspec0(void)
 	cl_git_pass(git_remote_add_fetch(remote, refspec2));
 
 	cl_git_pass(git_remote_download(remote));
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 
 	cl_git_pass(git_reference_lookup(&ref, repo, "refs/remotes/sloppy/master"));
 	git_reference_free(ref);
@@ -137,7 +137,7 @@ void test_network_remote_local__shorthand_fetch_refspec1(void)
 	cl_git_pass(git_remote_add_fetch(remote, refspec2));
 
 	cl_git_pass(git_remote_download(remote));
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 
 	cl_git_fail(git_reference_lookup(&ref, repo, "refs/remotes/master"));
 
@@ -152,7 +152,7 @@ void test_network_remote_local__tagopt(void)
 	git_remote_set_autotag(remote, GIT_REMOTE_DOWNLOAD_TAGS_ALL);
 
 	cl_git_pass(git_remote_download(remote));
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 
 
 	cl_git_fail(git_reference_lookup(&ref, repo, "refs/remotes/master"));
@@ -171,7 +171,7 @@ void test_network_remote_local__push_to_bare_remote(void)
 	connect_to_local_repository(cl_fixture("testrepo.git"));
 	cl_git_pass(git_remote_add_fetch(remote, "master:master"));
 	cl_git_pass(git_remote_download(remote));
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 	git_remote_disconnect(remote);
 
 	/* Set up an empty bare repo to push into */
@@ -208,7 +208,7 @@ void test_network_remote_local__push_to_bare_remote_with_file_url(void)
 	connect_to_local_repository(cl_fixture("testrepo.git"));
 	cl_git_pass(git_remote_add_fetch(remote, "master:master"));
 	cl_git_pass(git_remote_download(remote));
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 	git_remote_disconnect(remote);
 
 	/* Set up an empty bare repo to push into */
@@ -248,7 +248,7 @@ void test_network_remote_local__push_to_non_bare_remote(void)
 	connect_to_local_repository(cl_fixture("testrepo.git"));
 	cl_git_pass(git_remote_add_fetch(remote, "master:master"));
 	cl_git_pass(git_remote_download(remote));
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 	git_remote_disconnect(remote);
 
 	/* Set up an empty non-bare repo to push into */
@@ -273,3 +273,58 @@ void test_network_remote_local__push_to_non_bare_remote(void)
 	git_remote_free(localremote);
 	cl_fixture_cleanup("localbare.git");
 }
+
+void test_network_remote_local__fetch(void)
+{
+	const char *refspec = "master:remotes/sloppy/master";
+
+	git_reflog *log;
+	const git_reflog_entry *entry;
+	git_signature *sig;
+	git_reference *ref;
+
+	cl_git_pass(git_signature_now(&sig, "Foo Bar", "foo@example.com"));
+
+	connect_to_local_repository(cl_fixture("testrepo.git"));
+	cl_git_pass(git_remote_add_fetch(remote, refspec));
+
+	cl_git_pass(git_remote_fetch(remote, sig, "UPDAAAAAATE!!"));
+
+	cl_git_pass(git_reference_lookup(&ref, repo, "refs/remotes/sloppy/master"));
+	git_reference_free(ref);
+
+	cl_git_pass(git_reflog_read(&log, repo, "refs/remotes/sloppy/master"));
+	cl_assert_equal_i(1, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
+	cl_assert_equal_s("UPDAAAAAATE!!", git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
+	git_signature_free(sig);
+}
+
+void test_network_remote_local__reflog(void)
+{
+	const char *refspec = "master:remotes/sloppy/master";
+
+	git_reflog *log;
+	const git_reflog_entry *entry;
+	git_signature *sig;
+
+	cl_git_pass(git_signature_now(&sig, "Foo Bar", "foo@example.com"));
+
+	connect_to_local_repository(cl_fixture("testrepo.git"));
+	cl_git_pass(git_remote_add_fetch(remote, refspec));
+
+	cl_git_pass(git_remote_download(remote));
+	cl_git_pass(git_remote_update_tips(remote, sig, "UPDAAAAAATE!!"));
+
+	cl_git_pass(git_reflog_read(&log, repo, "refs/remotes/sloppy/master"));
+	cl_assert_equal_i(1, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
+	cl_assert_equal_s("UPDAAAAAATE!!", git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
+	git_signature_free(sig);
+}
diff --git a/tests/online/fetch.c b/tests/online/fetch.c
index 8f71cf3f5..cb84e846c 100644
--- a/tests/online/fetch.c
+++ b/tests/online/fetch.c
@@ -48,7 +48,7 @@ static void do_fetch(const char *url, git_remote_autotag_option_t flag, int n)
 	git_remote_set_autotag(remote, flag);
 	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
 	cl_git_pass(git_remote_download(remote));
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 	git_remote_disconnect(remote);
 	cl_assert_equal_i(counter, n);
 	cl_assert(bytes_received > 0);
@@ -117,7 +117,7 @@ void test_online_fetch__doesnt_retrieve_a_pack_when_the_repository_is_up_to_date
 
 	cl_assert_equal_i(false, invoked);
 
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 	git_remote_disconnect(remote);
 
 	git_remote_free(remote);
diff --git a/tests/online/fetchhead.c b/tests/online/fetchhead.c
index 57b183f88..0b3f20db1 100644
--- a/tests/online/fetchhead.c
+++ b/tests/online/fetchhead.c
@@ -51,7 +51,7 @@ static void fetchhead_test_fetch(const char *fetchspec, const char *expected_fet
 
 	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
 	cl_git_pass(git_remote_download(remote));
-	cl_git_pass(git_remote_update_tips(remote));
+	cl_git_pass(git_remote_update_tips(remote, NULL, NULL));
 	git_remote_disconnect(remote);
 	git_remote_free(remote);
 
diff --git a/tests/online/push.c b/tests/online/push.c
index c0ff2f22c..9f85ab419 100644
--- a/tests/online/push.c
+++ b/tests/online/push.c
@@ -351,7 +351,7 @@ void test_online_push__initialize(void)
 		/* Now that we've deleted everything, fetch from the remote */
 		cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_FETCH));
 		cl_git_pass(git_remote_download(_remote));
-		cl_git_pass(git_remote_update_tips(_remote));
+		cl_git_pass(git_remote_update_tips(_remote, NULL, NULL));
 		git_remote_disconnect(_remote);
 	} else
 		printf("GITTEST_REMOTE_URL unset; skipping push test\n");
-- 
cgit v1.2.3


From 010cec3ac26ab8445cc8401fb312f60168916bda Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 4 Feb 2014 20:50:40 -0800
Subject: Add reflog params to git_repository_detach_head

---
 include/git2/repository.h    |  6 +++++-
 src/repository.c             |  7 +++++--
 tests/refs/branches/delete.c |  2 +-
 tests/repo/head.c            | 35 ++++++++++++++++++++++++++++-------
 tests/repo/headtree.c        |  2 +-
 tests/repo/state.c           |  2 +-
 tests/reset/soft.c           |  4 ++--
 tests/stash/save.c           |  2 +-
 8 files changed, 44 insertions(+), 16 deletions(-)

diff --git a/include/git2/repository.h b/include/git2/repository.h
index 648667cd6..bf12c7a69 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -615,11 +615,15 @@ GIT_EXTERN(int) git_repository_set_head_detached(
  * Otherwise, the HEAD will be detached and point to the peeled Commit.
  *
  * @param repo Repository pointer
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message to be appended to the reflog
  * @return 0 on success, GIT_EUNBORNBRANCH when HEAD points to a non existing
  * branch or an error code
  */
 GIT_EXTERN(int) git_repository_detach_head(
-	git_repository* repo);
+	git_repository* repo,
+	const git_signature *signature,
+	const char *reflog_message);
 
 typedef enum {
 	GIT_REPOSITORY_STATE_NONE,
diff --git a/src/repository.c b/src/repository.c
index 2c1b60266..848aa565d 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1891,7 +1891,9 @@ cleanup:
 }
 
 int git_repository_detach_head(
-	git_repository* repo)
+	git_repository* repo,
+	const git_signature *signature,
+	const char *reflog_message)
 {
 	git_reference *old_head = NULL,
 		*new_head = NULL;
@@ -1906,7 +1908,8 @@ int git_repository_detach_head(
 	if ((error = git_object_lookup(&object, repo, git_reference_target(old_head), GIT_OBJ_COMMIT)) < 0)
 		goto cleanup;
 
-	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head), 1, NULL, NULL);
+	error = git_reference_create(&new_head, repo, GIT_HEAD_FILE, git_reference_target(old_head),
+			1, signature, reflog_message);
 
 cleanup:
 	git_object_free(object);
diff --git a/tests/refs/branches/delete.c b/tests/refs/branches/delete.c
index 7d1d400c8..ed5f1627b 100644
--- a/tests/refs/branches/delete.c
+++ b/tests/refs/branches/delete.c
@@ -78,7 +78,7 @@ void test_refs_branches_delete__can_delete_a_branch_pointed_at_by_detached_HEAD(
 	git_reference_free(head);
 
 	/* Detach HEAD and make it target the commit that "master" points to */
-	git_repository_detach_head(repo);
+	git_repository_detach_head(repo, NULL, NULL);
 
 	cl_git_pass(git_branch_lookup(&branch, repo, "master", GIT_BRANCH_LOCAL));
 	cl_git_pass(git_branch_delete(branch));
diff --git a/tests/repo/head.c b/tests/repo/head.c
index 127176d12..c5965fac6 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -15,21 +15,42 @@ void test_repo_head__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
+static void check_last_reflog_entry(const char *email, const char *message)
+{
+	git_reflog *log;
+	const git_reflog_entry *entry;
+
+	cl_git_pass(git_reflog_read(&log, repo, GIT_HEAD_FILE));
+	cl_assert(git_reflog_entrycount(log) > 0);
+	entry = git_reflog_entry_byindex(log, 0);
+	if (email)
+		cl_assert_equal_s(email, git_reflog_entry_committer(entry)->email);
+	if (message)
+		cl_assert_equal_s(message, git_reflog_entry_message(entry));
+	git_reflog_free(log);
+}
+
 void test_repo_head__head_detached(void)
 {
 	git_reference *ref;
+	git_signature *sig;
 
-	cl_git_pass(git_repository_head_detached(repo));
+	cl_git_pass(git_signature_now(&sig, "Foo Bar", "foo@example.com"));
 
-	cl_git_pass(git_repository_detach_head(repo));
+	cl_assert_equal_i(false, git_repository_head_detached(repo));
 
+	cl_git_pass(git_repository_detach_head(repo, sig, "CABLE DETACHED"));
+	check_last_reflog_entry(sig->email, "CABLE DETACHED");
 	cl_assert_equal_i(true, git_repository_head_detached(repo));
 
-	/* take the reop back to it's original state */
-	cl_git_pass(git_reference_symbolic_create(&ref, repo, "HEAD", "refs/heads/master", 1, NULL, NULL));
+	/* take the repo back to it's original state */
+	cl_git_pass(git_reference_symbolic_create(&ref, repo, "HEAD", "refs/heads/master",
+				true, sig, "REATTACH"));
 	git_reference_free(ref);
 
+	check_last_reflog_entry(sig->email, "REATTACH");
 	cl_assert_equal_i(false, git_repository_head_detached(repo));
+	git_signature_free(sig);
 }
 
 void test_repo_head__unborn_head(void)
@@ -147,7 +168,7 @@ void test_repo_head__detach_head_Detaches_HEAD_and_make_it_point_to_the_peeled_c
 {
 	cl_assert_equal_i(false, git_repository_head_detached(repo));
 
-	cl_git_pass(git_repository_detach_head(repo));
+	cl_git_pass(git_repository_detach_head(repo, NULL, NULL));
 
 	assert_head_is_correctly_detached();
 }
@@ -158,7 +179,7 @@ void test_repo_head__detach_head_Fails_if_HEAD_and_point_to_a_non_commitish(void
 
 	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, "refs/tags/point_to_blob", 1, NULL, NULL));
 
-	cl_git_fail(git_repository_detach_head(repo));
+	cl_git_fail(git_repository_detach_head(repo, NULL, NULL));
 
 	git_reference_free(head);
 }
@@ -167,7 +188,7 @@ void test_repo_head__detaching_an_unborn_branch_returns_GIT_EUNBORNBRANCH(void)
 {
 	make_head_unborn(repo, NON_EXISTING_HEAD);
 
-	cl_assert_equal_i(GIT_EUNBORNBRANCH, git_repository_detach_head(repo));
+	cl_assert_equal_i(GIT_EUNBORNBRANCH, git_repository_detach_head(repo, NULL, NULL));
 }
 
 void test_repo_head__retrieving_an_unborn_branch_returns_GIT_EUNBORNBRANCH(void)
diff --git a/tests/repo/headtree.c b/tests/repo/headtree.c
index e899ac399..79d88c0a7 100644
--- a/tests/repo/headtree.c
+++ b/tests/repo/headtree.c
@@ -20,7 +20,7 @@ void test_repo_headtree__cleanup(void)
 
 void test_repo_headtree__can_retrieve_the_root_tree_from_a_detached_head(void)
 {
-	cl_git_pass(git_repository_detach_head(repo));
+	cl_git_pass(git_repository_detach_head(repo, NULL, NULL));
 
 	cl_git_pass(git_repository_head_tree(&tree, repo));
 
diff --git a/tests/repo/state.c b/tests/repo/state.c
index 5a0a5f360..5e7227205 100644
--- a/tests/repo/state.c
+++ b/tests/repo/state.c
@@ -37,7 +37,7 @@ void test_repo_state__none_with_HEAD_attached(void)
 
 void test_repo_state__none_with_HEAD_detached(void)
 {
-	cl_git_pass(git_repository_detach_head(_repo));
+	cl_git_pass(git_repository_detach_head(_repo, NULL, NULL));
 	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
diff --git a/tests/reset/soft.c b/tests/reset/soft.c
index 6469fce6d..c889c0355 100644
--- a/tests/reset/soft.c
+++ b/tests/reset/soft.c
@@ -45,7 +45,7 @@ void test_reset_soft__can_reset_the_non_detached_Head_to_the_specified_commit(vo
 
 void test_reset_soft__can_reset_the_detached_Head_to_the_specified_commit(void)
 {
-	git_repository_detach_head(repo);
+	git_repository_detach_head(repo, NULL, NULL);
 
 	assert_reset_soft(true);
 }
@@ -118,7 +118,7 @@ void test_reset_soft__fails_when_merging(void)
 {
 	git_buf merge_head_path = GIT_BUF_INIT;
 
-	cl_git_pass(git_repository_detach_head(repo));
+	cl_git_pass(git_repository_detach_head(repo, NULL, NULL));
 	cl_git_pass(git_buf_joinpath(&merge_head_path, git_repository_path(repo), "MERGE_HEAD"));
 	cl_git_mkfile(git_buf_cstr(&merge_head_path), "beefbeefbeefbeefbeefbeefbeefbeefbeefbeef\n");
 
diff --git a/tests/stash/save.c b/tests/stash/save.c
index 293a89a97..b5a793eef 100644
--- a/tests/stash/save.c
+++ b/tests/stash/save.c
@@ -196,7 +196,7 @@ void test_stash_save__cannot_stash_against_a_bare_repository(void)
 
 void test_stash_save__can_stash_against_a_detached_head(void)
 {
-	git_repository_detach_head(repo);
+	git_repository_detach_head(repo, NULL, NULL);
 
 	cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_DEFAULT));
 
-- 
cgit v1.2.3


From 9b148098e6802f9dd797471fc4f20cfc58a846b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 18 Dec 2013 19:58:16 +0100
Subject: refs: conditional ref updates

Allow updating references if the old value matches the given one.
---
 include/git2/refs.h              | 49 ++++++++++++++++++++++++++++++++++++----
 include/git2/sys/refdb_backend.h |  3 ++-
 src/refdb.c                      |  4 ++--
 src/refdb.h                      |  2 +-
 src/refdb_fs.c                   | 41 +++++++++++++++++++++++++++------
 src/refs.c                       | 47 ++++++++++++++++++++++++++++++--------
 6 files changed, 120 insertions(+), 26 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index f9aaea827..296fcb67d 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -143,6 +143,49 @@ GIT_EXTERN(int) git_reference_symbolic_create(git_reference **out, git_repositor
  */
 GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message);
 
+/**
+ * Conditionally create new direct reference
+ *
+ * A direct reference (also called an object id reference) refers directly
+ * to a specific object id (a.k.a. OID or SHA) in the repository.  The id
+ * permanently refers to the object (although the reference itself can be
+ * moved).  For example, in libgit2 the direct ref "refs/tags/v0.17.0"
+ * refers to OID 5b9fac39d8a76b9139667c26a63e6b3f204b3977.
+ *
+ * The direct reference will be created in the repository and written to
+ * the disk.  The generated reference object must be freed by the user.
+ *
+ * Valid reference names must follow one of two patterns:
+ *
+ * 1. Top-level names must contain only capital letters and underscores,
+ *    and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
+ * 2. Names prefixed with "refs/" can be almost anything.  You must avoid
+ *    the characters '~', '^', ':', '\\', '?', '[', and '*', and the
+ *    sequences ".." and "@{" which have special meaning to revparse.
+ *
+ * This function will return an error if a reference already exists with the
+ * given name unless `force` is true, in which case it will be overwritten.
+ *
+ * The signature and message for the reflog will be ignored if the
+ * reference does not belong in the standard set (HEAD, branches and
+ * remote-tracking branches) and and it does not have a reflog.
+ *
+ * It will also return an error if the reference's value at the time
+ * of updating does not match the one passed.
+ *
+ * @param out Pointer to the newly created reference
+ * @param repo Repository where that reference will live
+ * @param name The name of the reference
+ * @param id The object id pointed to by the reference.
+ * @param force Overwrite existing references
+ * @param force Overwrite existing references
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message to be appended to the reflog
+ * @param old_id The old value which the reference should have
+ * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
+ */
+GIT_EXTERN(int) git_reference_create_if(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message, const git_oid *old_id);
+
 /**
  * Get the OID pointed to by a direct reference.
  *
@@ -254,16 +297,12 @@ GIT_EXTERN(int) git_reference_symbolic_set_target(
 	const char *log_message);
 
 /**
- * Create a new reference with the same name as the given reference but a
+ * Conditionally create a new reference with the same name as the given reference but a
  * different OID target. The reference must be a direct reference, otherwise
  * this will fail.
  *
  * The new reference will be written to disk, overwriting the given reference.
  *
- * The signature and message for the reflog will be ignored if the
- * reference does not belong in the standard set (HEAD, branches and
- * remote-tracking branches) and and it does not have a reflog.
- *
  * @param out Pointer to the newly created reference
  * @param ref The reference
  * @param id The new target OID for the reference
diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index 5bbd4ba4c..e43f9960b 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -94,7 +94,8 @@ struct git_refdb_backend {
 	 */
 	int (*write)(git_refdb_backend *backend,
 		     const git_reference *ref, int force,
-		     const git_signature *who, const char *message);
+		     const git_signature *who, const char *message,
+		     const git_oid *old);
 
 	int (*rename)(
 		git_reference **out, git_refdb_backend *backend,
diff --git a/src/refdb.c b/src/refdb.c
index 411423d57..9ff812433 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -167,14 +167,14 @@ void git_refdb_iterator_free(git_reference_iterator *iter)
 	iter->free(iter);
 }
 
-int git_refdb_write(git_refdb *db, git_reference *ref, int force, const git_signature *who, const char *message)
+int git_refdb_write(git_refdb *db, git_reference *ref, int force, const git_signature *who, const char *message, const git_oid *old)
 {
 	assert(db && db->backend);
 
 	GIT_REFCOUNT_INC(db);
 	ref->db = db;
 
-	return db->backend->write(db->backend, ref, force, who, message);
+	return db->backend->write(db->backend, ref, force, who, message, old);
 }
 
 int git_refdb_rename(
diff --git a/src/refdb.h b/src/refdb.h
index 91eecb782..86a1f8971 100644
--- a/src/refdb.h
+++ b/src/refdb.h
@@ -42,7 +42,7 @@ int git_refdb_iterator_next(git_reference **out, git_reference_iterator *iter);
 int git_refdb_iterator_next_name(const char **out, git_reference_iterator *iter);
 void git_refdb_iterator_free(git_reference_iterator *iter);
 
-int git_refdb_write(git_refdb *refdb, git_reference *ref, int force, const git_signature *who, const char *message);
+int git_refdb_write(git_refdb *refdb, git_reference *ref, int force, const git_signature *who, const char *message, const git_oid *old);
 int git_refdb_delete(git_refdb *refdb, const char *ref_name);
 
 int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name);
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 89c77c14c..fd6d61e1d 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -690,8 +690,11 @@ static int reference_path_available(
 
 static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const git_reference *ref)
 {
+        int error;
 	git_buf ref_path = GIT_BUF_INIT;
 
+	assert(file && backend && ref);
+
 	/* Remove a possibly existing empty directory hierarchy
 	 * which name would collide with the reference name
 	 */
@@ -701,17 +704,16 @@ static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const git_re
 	if (git_buf_joinpath(&ref_path, backend->path, ref->name) < 0)
 		return -1;
 
-	if (git_filebuf_open(file, ref_path.ptr, GIT_FILEBUF_FORCE, GIT_REFS_FILE_MODE) < 0) {
-		git_buf_free(&ref_path);
-		return -1;
-	}
+	error = git_filebuf_open(file, ref_path.ptr, GIT_FILEBUF_FORCE, GIT_REFS_FILE_MODE);
 
 	git_buf_free(&ref_path);
-	return 0;
+        return error;
 }
 
 static int loose_commit(git_filebuf *file, const git_reference *ref)
 {
+	assert(file && ref);
+
 	if (ref->type == GIT_REF_OID) {
 		char oid[GIT_OID_HEXSZ + 1];
 		git_oid_nfmt(oid, sizeof(oid), &ref->target.oid);
@@ -933,10 +935,12 @@ static int refdb_fs_backend__write(
 	const git_reference *ref,
 	int force,
 	const git_signature *who,
-	const char *message)
+	const char *message,
+	const git_oid *old_id)
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
+	git_reference *old_ref;
 	int error;
 
 	assert(backend);
@@ -945,10 +949,28 @@ static int refdb_fs_backend__write(
 	if (error < 0)
 		return error;
 
-	/* We need to perform the reflog append under the ref's lock */
+	/* We need to perform the reflog append and old value check under the ref's lock */
 	if ((error = loose_lock(&file, backend, ref)) < 0)
 		return error;
 
+	if (old_id) {
+		if ((error = refdb_fs_backend__lookup(&old_ref, _backend, ref->name)) < 0) {
+			git_filebuf_cleanup(&file);
+			return error;
+		}
+
+		if (old_ref->type == GIT_REF_SYMBOLIC) {
+			giterr_set(GITERR_REFERENCE, "cannot compare id to symbolic reference target");
+			goto on_error;
+		}
+
+		/* Finally we can compare the ids */
+		if (git_oid_cmp(old_id, &old_ref->target.oid)) {
+			giterr_set(GITERR_REFERENCE, "old reference value does not match");
+			goto on_error;
+		}
+	}
+
 	if (should_write_reflog(backend->repo, ref->name) &&
 	    (error = reflog_append(backend, ref, who, message)) < 0) {
 		git_filebuf_cleanup(&file);
@@ -956,6 +978,11 @@ static int refdb_fs_backend__write(
 	}
 
 	return loose_commit(&file, ref);
+
+on_error:
+        git_filebuf_cleanup(&file);
+        git_reference_free(old_ref);
+        return -1;
 }
 
 static int refdb_fs_backend__delete(
diff --git a/src/refs.c b/src/refs.c
index ca5f24ea2..a5492cf91 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -331,7 +331,8 @@ static int reference__create(
 	const char *symbolic,
 	int force,
 	const git_signature *signature,
-	const char *log_message)
+	const char *log_message,
+	const git_oid *old_id)
 {
 	char normalized[GIT_REFNAME_MAX];
 	git_refdb *refdb;
@@ -380,7 +381,7 @@ static int reference__create(
 
 	GITERR_CHECK_ALLOC(ref);
 
-	if ((error = git_refdb_write(refdb, ref, force, signature, log_message)) < 0) {
+	if ((error = git_refdb_write(refdb, ref, force, signature, log_message, old_id)) < 0) {
 		git_reference_free(ref);
 		return error;
 	}
@@ -410,15 +411,28 @@ int git_reference_create(
 	git_reference **ref_out,
 	git_repository *repo,
 	const char *name,
-	const git_oid *oid,
+	const git_oid *id,
 	int force,
 	const git_signature *signature,
 	const char *log_message)
+{
+        return git_reference_create_if(ref_out, repo, name, id, force, signature, log_message, NULL);
+}
+
+int git_reference_create_if(
+	git_reference **ref_out,
+	git_repository *repo,
+	const char *name,
+	const git_oid *id,
+	int force,
+	const git_signature *signature,
+	const char *log_message,
+	const git_oid *old_id)
 {
 	int error;
 	git_signature *who = NULL;
 	
-	assert(oid);
+	assert(id);
 
 	if (!signature) {
 		if ((error = log_signature(&who, repo)) < 0)
@@ -428,7 +442,7 @@ int git_reference_create(
 	}
 
 	error = reference__create(
-		ref_out, repo, name, oid, NULL, force, signature, log_message);
+		ref_out, repo, name, id, NULL, force, signature, log_message, old_id);
 
 	git_signature_free(who);
 	return error;
@@ -456,7 +470,7 @@ int git_reference_symbolic_create(
 	}
 
 	error = reference__create(
-		ref_out, repo, name, NULL, target, force, signature, log_message);
+		ref_out, repo, name, NULL, target, force, signature, log_message, NULL);
 
 	git_signature_free(who);
 	return error;
@@ -471,22 +485,25 @@ static int ensure_is_an_updatable_direct_reference(git_reference *ref)
 	return -1;
 }
 
-int git_reference_set_target(
+int git_reference_set_target_if(
 	git_reference **out,
 	git_reference *ref,
 	const git_oid *id,
 	const git_signature *signature,
-	const char *log_message)
+	const char *log_message,
+        const git_oid *old_id)
 {
 	int error;
+	git_repository *repo;
 
 	assert(out && ref && id);
 
+	repo = ref->db->repo;
+
 	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
 		return error;
 
-	return git_reference_create(
-		out, ref->db->repo, ref->name, id, 1, signature, log_message);
+	return git_reference_create_if(out, repo, ref->name, id, 1, signature, log_message, old_id);
 }
 
 static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
@@ -498,6 +515,16 @@ static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
 	return -1;
 }
 
+int git_reference_set_target(
+	git_reference **out,
+	git_reference *ref,
+	const git_oid *id,
+	const git_signature *signature,
+	const char *log_message)
+{
+        return git_reference_set_target_if(out, ref, id, signature, log_message, NULL);
+}
+
 int git_reference_symbolic_set_target(
 	git_reference **out,
 	git_reference *ref,
-- 
cgit v1.2.3


From 5d96fe8828505db852671175d5895dfd275f3d06 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 14 Jan 2014 15:33:29 +0100
Subject: refs: changes from feedback

Change the name to _matching() intead of _if(), and force _set_target()
to be a conditional update. If the user doesn't care about the old
value, they should use git_reference_create().
---
 include/git2/refs.h |  2 +-
 src/refs.c          | 44 +++++++++++++++++---------------------------
 2 files changed, 18 insertions(+), 28 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 296fcb67d..72622948b 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -184,7 +184,7 @@ GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo,
  * @param old_id The old value which the reference should have
  * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
  */
-GIT_EXTERN(int) git_reference_create_if(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message, const git_oid *old_id);
+GIT_EXTERN(int) git_reference_create_matching(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message, const git_oid *old_id);
 
 /**
  * Get the OID pointed to by a direct reference.
diff --git a/src/refs.c b/src/refs.c
index a5492cf91..007fdf353 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -407,19 +407,7 @@ static int log_signature(git_signature **out, git_repository *repo)
 	return 0;
 }
 
-int git_reference_create(
-	git_reference **ref_out,
-	git_repository *repo,
-	const char *name,
-	const git_oid *id,
-	int force,
-	const git_signature *signature,
-	const char *log_message)
-{
-        return git_reference_create_if(ref_out, repo, name, id, force, signature, log_message, NULL);
-}
-
-int git_reference_create_if(
+int git_reference_create_matching(
 	git_reference **ref_out,
 	git_repository *repo,
 	const char *name,
@@ -428,6 +416,7 @@ int git_reference_create_if(
 	const git_signature *signature,
 	const char *log_message,
 	const git_oid *old_id)
+
 {
 	int error;
 	git_signature *who = NULL;
@@ -448,6 +437,18 @@ int git_reference_create_if(
 	return error;
 }
 
+int git_reference_create(
+	git_reference **ref_out,
+	git_repository *repo,
+	const char *name,
+	const git_oid *id,
+	int force,
+	const git_signature *signature,
+	const char *log_message)
+{
+        return git_reference_create_matching(ref_out, repo, name, id, force, signature, log_message, NULL);
+}
+
 int git_reference_symbolic_create(
 	git_reference **ref_out,
 	git_repository *repo,
@@ -485,13 +486,12 @@ static int ensure_is_an_updatable_direct_reference(git_reference *ref)
 	return -1;
 }
 
-int git_reference_set_target_if(
+int git_reference_set_target(
 	git_reference **out,
 	git_reference *ref,
 	const git_oid *id,
 	const git_signature *signature,
-	const char *log_message,
-        const git_oid *old_id)
+	const char *log_message)
 {
 	int error;
 	git_repository *repo;
@@ -503,7 +503,7 @@ int git_reference_set_target_if(
 	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
 		return error;
 
-	return git_reference_create_if(out, repo, ref->name, id, 1, signature, log_message, old_id);
+	return git_reference_create_matching(out, repo, ref->name, id, 1, signature, log_message, &ref->target.oid);
 }
 
 static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
@@ -515,16 +515,6 @@ static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
 	return -1;
 }
 
-int git_reference_set_target(
-	git_reference **out,
-	git_reference *ref,
-	const git_oid *id,
-	const git_signature *signature,
-	const char *log_message)
-{
-        return git_reference_set_target_if(out, ref, id, signature, log_message, NULL);
-}
-
 int git_reference_symbolic_set_target(
 	git_reference **out,
 	git_reference *ref,
-- 
cgit v1.2.3


From fc4728e3e2a4094b202a63319232f25adbd55fed Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 29 Jan 2014 14:07:18 +0100
Subject: refs: return GIT_EMODIFIED if the ref target moved

In case we loose the race to update the reference, return GIT_EMODIFIED
to let the user distinguish it from other types of errors.
---
 include/git2/errors.h | 1 +
 include/git2/refs.h   | 6 ++++--
 src/refdb_fs.c        | 6 ++++--
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/include/git2/errors.h b/include/git2/errors.h
index 973d56003..bcf2f80ab 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -40,6 +40,7 @@ typedef enum {
 	GIT_EINVALIDSPEC    = -12,	/*< Name/ref spec was not in a valid format */
 	GIT_EMERGECONFLICT  = -13,	/*< Merge conflicts prevented operation */
 	GIT_ELOCKED         = -14,	/*< Lock file prevented operation */
+	GIT_EMODIFIED       = -15,	/*< Reference value does not match expected */
 
 	GIT_PASSTHROUGH     = -30,	/*< Internal only */
 	GIT_ITEROVER        = -31,	/*< Signals end of iteration with iterator */
diff --git a/include/git2/refs.h b/include/git2/refs.h
index 72622948b..aab8715fb 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -182,7 +182,8 @@ GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo,
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
  * @param old_id The old value which the reference should have
- * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
+ * @return 0 on success, GIT_EMODIFIED if the value of the reference
+ * has changed, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
  */
 GIT_EXTERN(int) git_reference_create_matching(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message, const git_oid *old_id);
 
@@ -308,7 +309,8 @@ GIT_EXTERN(int) git_reference_symbolic_set_target(
  * @param id The new target OID for the reference
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
- * @return 0 or an error code
+ * @return 0 on success, GIT_EMODIFIED if the value of the reference
+ * has changed, or an error code
  */
 GIT_EXTERN(int) git_reference_set_target(
 	git_reference **out,
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index fd6d61e1d..0a2a33a51 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -941,7 +941,7 @@ static int refdb_fs_backend__write(
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
 	git_reference *old_ref;
-	int error;
+	int error = 0;
 
 	assert(backend);
 
@@ -961,12 +961,14 @@ static int refdb_fs_backend__write(
 
 		if (old_ref->type == GIT_REF_SYMBOLIC) {
 			giterr_set(GITERR_REFERENCE, "cannot compare id to symbolic reference target");
+			error = -1;
 			goto on_error;
 		}
 
 		/* Finally we can compare the ids */
 		if (git_oid_cmp(old_id, &old_ref->target.oid)) {
 			giterr_set(GITERR_REFERENCE, "old reference value does not match");
+			error = GIT_EMODIFIED;
 			goto on_error;
 		}
 	}
@@ -982,7 +984,7 @@ static int refdb_fs_backend__write(
 on_error:
         git_filebuf_cleanup(&file);
         git_reference_free(old_ref);
-        return -1;
+        return error;
 }
 
 static int refdb_fs_backend__delete(
-- 
cgit v1.2.3


From 1202c7eaa6f0fd6407bc386881edd686771fc0f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 4 Feb 2014 21:35:44 +0100
Subject: refs: fix leak on successful update

Free the old ref even on success.
---
 src/refdb_fs.c | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 0a2a33a51..554fe42c9 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -941,7 +941,7 @@ static int refdb_fs_backend__write(
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
 	git_reference *old_ref;
-	int error = 0;
+	int error = 0, cmp;
 
 	assert(backend);
 
@@ -954,19 +954,20 @@ static int refdb_fs_backend__write(
 		return error;
 
 	if (old_id) {
-		if ((error = refdb_fs_backend__lookup(&old_ref, _backend, ref->name)) < 0) {
-			git_filebuf_cleanup(&file);
-			return error;
-		}
+		if ((error = refdb_fs_backend__lookup(&old_ref, _backend, ref->name)) < 0)
+			goto on_error;
 
 		if (old_ref->type == GIT_REF_SYMBOLIC) {
+			git_reference_free(old_ref);
 			giterr_set(GITERR_REFERENCE, "cannot compare id to symbolic reference target");
 			error = -1;
 			goto on_error;
 		}
 
 		/* Finally we can compare the ids */
-		if (git_oid_cmp(old_id, &old_ref->target.oid)) {
+		cmp = git_oid_cmp(old_id, &old_ref->target.oid);
+		git_reference_free(old_ref);
+		if (cmp) {
 			giterr_set(GITERR_REFERENCE, "old reference value does not match");
 			error = GIT_EMODIFIED;
 			goto on_error;
@@ -983,7 +984,6 @@ static int refdb_fs_backend__write(
 
 on_error:
         git_filebuf_cleanup(&file);
-        git_reference_free(old_ref);
         return error;
 }
 
-- 
cgit v1.2.3


From d6236cf662ebd4ba8ef4902c81a19bbfd92847f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 4 Feb 2014 21:40:22 +0100
Subject: refs: add tests for conditional updates

---
 tests/refs/races.c | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 tests/refs/races.c

diff --git a/tests/refs/races.c b/tests/refs/races.c
new file mode 100644
index 000000000..4d24896f1
--- /dev/null
+++ b/tests/refs/races.c
@@ -0,0 +1,42 @@
+#include "clar_libgit2.h"
+
+#include "repository.h"
+#include "git2/reflog.h"
+#include "reflog.h"
+#include "ref_helpers.h"
+
+static const char *commit_id = "099fabac3a9ea935598528c27f866e34089c2eff";
+static const char *refname = "refs/heads/master";
+static const char *other_commit_id = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
+
+static git_repository *g_repo;
+
+void test_refs_races__initialize(void)
+{
+   g_repo = cl_git_sandbox_init("testrepo");
+}
+
+void test_refs_races__cleanup(void)
+{
+   cl_git_sandbox_cleanup();
+}
+
+void test_refs_races__create_matching(void)
+{
+	int error;
+	git_reference *ref, *ref2, *ref3;
+	git_oid id, other_id;
+
+	git_oid_fromstr(&id, commit_id);
+	git_oid_fromstr(&other_id, other_commit_id);
+
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_create_matching(&ref, g_repo, refname, &other_id, 1, NULL, NULL, &other_id));
+
+	cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
+	cl_git_pass(git_reference_create_matching(&ref2, g_repo, refname, &other_id, 1, NULL, NULL, &id));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_set_target(&ref3, ref, &other_id, NULL, NULL));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+	git_reference_free(ref3);
+}
-- 
cgit v1.2.3


From 911236619b5d774e33dd9f3de92a7c86c2befb26 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 4 Feb 2014 22:04:00 +0100
Subject: refdb: add conditional symbolic updates

Add a parameter to the backend to allow checking for the old symbolic
target.
---
 include/git2/sys/refdb_backend.h |  2 +-
 src/refdb.c                      |  4 ++--
 src/refdb.h                      |  2 +-
 src/refdb_fs.c                   | 35 ++++++++++++++++++-----------------
 src/refs.c                       |  9 +++++----
 5 files changed, 27 insertions(+), 25 deletions(-)

diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index e43f9960b..13ce9a026 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -95,7 +95,7 @@ struct git_refdb_backend {
 	int (*write)(git_refdb_backend *backend,
 		     const git_reference *ref, int force,
 		     const git_signature *who, const char *message,
-		     const git_oid *old);
+		     const git_oid *old, const char *old_target);
 
 	int (*rename)(
 		git_reference **out, git_refdb_backend *backend,
diff --git a/src/refdb.c b/src/refdb.c
index 9ff812433..66d943e86 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -167,14 +167,14 @@ void git_refdb_iterator_free(git_reference_iterator *iter)
 	iter->free(iter);
 }
 
-int git_refdb_write(git_refdb *db, git_reference *ref, int force, const git_signature *who, const char *message, const git_oid *old)
+int git_refdb_write(git_refdb *db, git_reference *ref, int force, const git_signature *who, const char *message, const git_oid *old_id, const char *old_target)
 {
 	assert(db && db->backend);
 
 	GIT_REFCOUNT_INC(db);
 	ref->db = db;
 
-	return db->backend->write(db->backend, ref, force, who, message, old);
+	return db->backend->write(db->backend, ref, force, who, message, old_id, old_target);
 }
 
 int git_refdb_rename(
diff --git a/src/refdb.h b/src/refdb.h
index 86a1f8971..eabb5969b 100644
--- a/src/refdb.h
+++ b/src/refdb.h
@@ -42,7 +42,7 @@ int git_refdb_iterator_next(git_reference **out, git_reference_iterator *iter);
 int git_refdb_iterator_next_name(const char **out, git_reference_iterator *iter);
 void git_refdb_iterator_free(git_reference_iterator *iter);
 
-int git_refdb_write(git_refdb *refdb, git_reference *ref, int force, const git_signature *who, const char *message, const git_oid *old);
+int git_refdb_write(git_refdb *refdb, git_reference *ref, int force, const git_signature *who, const char *message, const git_oid *old_id, const char *old_target);
 int git_refdb_delete(git_refdb *refdb, const char *ref_name);
 
 int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name);
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 554fe42c9..879e48514 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -936,12 +936,13 @@ static int refdb_fs_backend__write(
 	int force,
 	const git_signature *who,
 	const char *message,
-	const git_oid *old_id)
+	const git_oid *old_id,
+	const char *old_target)
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
-	git_reference *old_ref;
-	int error = 0, cmp;
+	git_reference *old_ref = NULL;
+	int error = 0, cmp = 0;
 
 	assert(backend);
 
@@ -953,25 +954,25 @@ static int refdb_fs_backend__write(
 	if ((error = loose_lock(&file, backend, ref)) < 0)
 		return error;
 
-	if (old_id) {
+	if (old_id || old_target) {
 		if ((error = refdb_fs_backend__lookup(&old_ref, _backend, ref->name)) < 0)
 			goto on_error;
+	}
 
-		if (old_ref->type == GIT_REF_SYMBOLIC) {
-			git_reference_free(old_ref);
-			giterr_set(GITERR_REFERENCE, "cannot compare id to symbolic reference target");
-			error = -1;
-			goto on_error;
-		}
-
-		/* Finally we can compare the ids */
+	if (old_id && old_ref->type == GIT_REF_OID) {
 		cmp = git_oid_cmp(old_id, &old_ref->target.oid);
 		git_reference_free(old_ref);
-		if (cmp) {
-			giterr_set(GITERR_REFERENCE, "old reference value does not match");
-			error = GIT_EMODIFIED;
-			goto on_error;
-		}
+	}
+
+	if (old_target && old_ref->type == GIT_REF_SYMBOLIC) {
+		cmp = git__strcmp(old_target, old_ref->target.symbolic);
+		git_reference_free(old_ref);
+	}
+
+	if (cmp) {
+		giterr_set(GITERR_REFERENCE, "old reference value does not match");
+		error = GIT_EMODIFIED;
+		goto on_error;
 	}
 
 	if (should_write_reflog(backend->repo, ref->name) &&
diff --git a/src/refs.c b/src/refs.c
index 007fdf353..888b5cb3c 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -332,7 +332,8 @@ static int reference__create(
 	int force,
 	const git_signature *signature,
 	const char *log_message,
-	const git_oid *old_id)
+	const git_oid *old_id,
+	const char *old_target)
 {
 	char normalized[GIT_REFNAME_MAX];
 	git_refdb *refdb;
@@ -381,7 +382,7 @@ static int reference__create(
 
 	GITERR_CHECK_ALLOC(ref);
 
-	if ((error = git_refdb_write(refdb, ref, force, signature, log_message, old_id)) < 0) {
+	if ((error = git_refdb_write(refdb, ref, force, signature, log_message, old_id, old_target)) < 0) {
 		git_reference_free(ref);
 		return error;
 	}
@@ -431,7 +432,7 @@ int git_reference_create_matching(
 	}
 
 	error = reference__create(
-		ref_out, repo, name, id, NULL, force, signature, log_message, old_id);
+		ref_out, repo, name, id, NULL, force, signature, log_message, old_id, NULL);
 
 	git_signature_free(who);
 	return error;
@@ -471,7 +472,7 @@ int git_reference_symbolic_create(
 	}
 
 	error = reference__create(
-		ref_out, repo, name, NULL, target, force, signature, log_message, NULL);
+		ref_out, repo, name, NULL, target, force, signature, log_message, NULL, NULL);
 
 	git_signature_free(who);
 	return error;
-- 
cgit v1.2.3


From 878fb66f5765115eff34213cfc8dd04b8a56b2a5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 10:19:17 +0100
Subject: refs: bring conditional symbolic updates to the frontend

Bring the race detection goodness to symbolic references as well.
---
 include/git2/refs.h | 40 ++++++++++++++++++++++++++++++++++++++++
 src/refs.c          | 23 ++++++++++++++++++-----
 tests/refs/races.c  | 21 ++++++++++++++++++++-
 3 files changed, 78 insertions(+), 6 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index aab8715fb..284671d2c 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -67,6 +67,46 @@ GIT_EXTERN(int) git_reference_name_to_id(
  */
 GIT_EXTERN(int) git_reference_dwim(git_reference **out, git_repository *repo, const char *shorthand);
 
+/**
+ * Conditionally create a new symbolic reference.
+ *
+ * A symbolic reference is a reference name that refers to another
+ * reference name.  If the other name moves, the symbolic name will move,
+ * too.  As a simple example, the "HEAD" reference might refer to
+ * "refs/heads/master" while on the "master" branch of a repository.
+ *
+ * The symbolic reference will be created in the repository and written to
+ * the disk.  The generated reference object must be freed by the user.
+ *
+ * Valid reference names must follow one of two patterns:
+ *
+ * 1. Top-level names must contain only capital letters and underscores,
+ *    and must begin and end with a letter. (e.g. "HEAD", "ORIG_HEAD").
+ * 2. Names prefixed with "refs/" can be almost anything.  You must avoid
+ *    the characters '~', '^', ':', '\\', '?', '[', and '*', and the
+ *    sequences ".." and "@{" which have special meaning to revparse.
+ *
+ * This function will return an error if a reference already exists with the
+ * given name unless `force` is true, in which case it will be overwritten.
+ *
+ * The signature and message for the reflog will be ignored if the
+ * reference does not belong in the standard set (HEAD, branches and
+ * remote-tracking branches) and it does not have a reflog.
+ *
+ * It will also return an error if the reference's value at the time
+ * of updating does not match the one passed.
+ *
+ * @param out Pointer to the newly created reference
+ * @param repo Repository where that reference will live
+ * @param name The name of the reference
+ * @param target The target of the reference
+ * @param force Overwrite existing references
+ * @param signature The identity that will used to populate the reflog entry
+ * @param log_message The one line long message to be appended to the reflog
+ * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC, GIT_EMODIFIED or an error code
+ */
+GIT_EXTERN(int) git_reference_symbolic_create_matching(git_reference **out, git_repository *repo, const char *name, const char *target, int force, const git_signature *signature, const char *log_message, const char *old_value);
+
 /**
  * Create a new symbolic reference.
  *
diff --git a/src/refs.c b/src/refs.c
index 888b5cb3c..864bfce59 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -450,14 +450,15 @@ int git_reference_create(
         return git_reference_create_matching(ref_out, repo, name, id, force, signature, log_message, NULL);
 }
 
-int git_reference_symbolic_create(
+int git_reference_symbolic_create_matching(
 	git_reference **ref_out,
 	git_repository *repo,
 	const char *name,
 	const char *target,
 	int force,
 	const git_signature *signature,
-	const char *log_message)
+	const char *log_message,
+	const char *old_target)
 {
 	int error;
 	git_signature *who = NULL;
@@ -472,12 +473,24 @@ int git_reference_symbolic_create(
 	}
 
 	error = reference__create(
-		ref_out, repo, name, NULL, target, force, signature, log_message, NULL, NULL);
+		ref_out, repo, name, NULL, target, force, signature, log_message, NULL, old_target);
 
 	git_signature_free(who);
 	return error;
 }
 
+int git_reference_symbolic_create(
+	git_reference **ref_out,
+	git_repository *repo,
+	const char *name,
+	const char *target,
+	int force,
+	const git_signature *signature,
+	const char *log_message)
+{
+	return git_reference_symbolic_create_matching(ref_out, repo, name, target, force, signature, log_message, NULL);
+}
+
 static int ensure_is_an_updatable_direct_reference(git_reference *ref)
 {
 	if (ref->type == GIT_REF_OID)
@@ -530,8 +543,8 @@ int git_reference_symbolic_set_target(
 	if ((error = ensure_is_an_updatable_symbolic_reference(ref)) < 0)
 		return error;
 
-	return git_reference_symbolic_create(
-		out, ref->db->repo, ref->name, target, 1, signature, log_message);
+	return git_reference_symbolic_create_matching(
+		out, ref->db->repo, ref->name, target, 1, signature, log_message, ref->target.symbolic);
 }
 
 static int reference__rename(git_reference **out, git_reference *ref, const char *new_name, int force,
diff --git a/tests/refs/races.c b/tests/refs/races.c
index 4d24896f1..6613fc20f 100644
--- a/tests/refs/races.c
+++ b/tests/refs/races.c
@@ -7,6 +7,7 @@
 
 static const char *commit_id = "099fabac3a9ea935598528c27f866e34089c2eff";
 static const char *refname = "refs/heads/master";
+static const char *other_refname = "refs/heads/foo";
 static const char *other_commit_id = "a65fedf39aefe402d3bb6e24df4d4f5fe4547750";
 
 static git_repository *g_repo;
@@ -23,7 +24,6 @@ void test_refs_races__cleanup(void)
 
 void test_refs_races__create_matching(void)
 {
-	int error;
 	git_reference *ref, *ref2, *ref3;
 	git_oid id, other_id;
 
@@ -40,3 +40,22 @@ void test_refs_races__create_matching(void)
 	git_reference_free(ref2);
 	git_reference_free(ref3);
 }
+
+void test_refs_races__symbolic_create_matching(void)
+{
+	git_reference *ref, *ref2, *ref3;
+	git_oid id, other_id;
+
+	git_oid_fromstr(&id, commit_id);
+	git_oid_fromstr(&other_id, other_commit_id);
+
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_symbolic_create_matching(&ref, g_repo, "HEAD", other_refname, 1, NULL, NULL, other_refname));
+
+	cl_git_pass(git_reference_lookup(&ref, g_repo, "HEAD"));
+	cl_git_pass(git_reference_symbolic_create_matching(&ref2, g_repo, "HEAD", other_refname, 1, NULL, NULL, refname));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_symbolic_set_target(&ref3, ref, other_refname, NULL, NULL));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+	git_reference_free(ref3);
+}
-- 
cgit v1.2.3


From f8621dde4057aba2df8d7585f6fbf2d6ee4fc023 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 10:42:42 +0100
Subject: refs: factor out old value comparison

We will reuse this later for deletion.
---
 src/refdb_fs.c | 40 ++++++++++++++++++++++++++--------------
 1 file changed, 26 insertions(+), 14 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 879e48514..d1b20f8e3 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -930,6 +930,30 @@ static bool should_write_reflog(git_repository *repo, const char *name)
 	return 0;
 }
 
+static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const git_reference *ref,
+	const git_oid *old_id, const char *old_target)
+{
+	int error = 0;
+	git_reference *old_ref = NULL;
+
+	*cmp = 0;
+	if (old_id || old_target) {
+		if ((error = refdb_fs_backend__lookup(&old_ref, backend, ref->name)) < 0)
+			goto out;
+	}
+
+	if (old_id && old_ref->type == GIT_REF_OID)
+		*cmp = git_oid_cmp(old_id, &old_ref->target.oid);
+
+	if (old_target && old_ref->type == GIT_REF_SYMBOLIC)
+		*cmp = git__strcmp(old_target, old_ref->target.symbolic);
+
+out:
+	git_reference_free(old_ref);
+
+	return error;
+}
+
 static int refdb_fs_backend__write(
 	git_refdb_backend *_backend,
 	const git_reference *ref,
@@ -954,20 +978,8 @@ static int refdb_fs_backend__write(
 	if ((error = loose_lock(&file, backend, ref)) < 0)
 		return error;
 
-	if (old_id || old_target) {
-		if ((error = refdb_fs_backend__lookup(&old_ref, _backend, ref->name)) < 0)
-			goto on_error;
-	}
-
-	if (old_id && old_ref->type == GIT_REF_OID) {
-		cmp = git_oid_cmp(old_id, &old_ref->target.oid);
-		git_reference_free(old_ref);
-	}
-
-	if (old_target && old_ref->type == GIT_REF_SYMBOLIC) {
-		cmp = git__strcmp(old_target, old_ref->target.symbolic);
-		git_reference_free(old_ref);
-	}
+	if ((error = cmp_old_ref(&cmp, _backend, ref, old_id, old_target)) < 0)
+		goto on_error;
 
 	if (cmp) {
 		giterr_set(GITERR_REFERENCE, "old reference value does not match");
-- 
cgit v1.2.3


From 7ee8c7e6776a3c5b3a45cfd10ccf205eebb3f3fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 11:07:34 +0100
Subject: refs: placeholder conditional delete

We don't actually pass the old value yet.
---
 include/git2/sys/refdb_backend.h |  2 +-
 src/refdb.c                      |  4 +--
 src/refdb.h                      |  2 +-
 src/refdb_fs.c                   | 66 ++++++++++++++++++++++++++--------------
 src/refs.c                       |  2 +-
 5 files changed, 49 insertions(+), 27 deletions(-)

diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index 13ce9a026..aa5ef9ecc 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -106,7 +106,7 @@ struct git_refdb_backend {
 	 * Deletes the given reference from the refdb.  A refdb implementation
 	 * must provide this function.
 	 */
-	int (*del)(git_refdb_backend *backend, const char *ref_name);
+	int (*del)(git_refdb_backend *backend, const char *ref_name, const git_oid *old_id, const char *old_target);
 
 	/**
 	 * Suggests that the given refdb compress or optimize its references.
diff --git a/src/refdb.c b/src/refdb.c
index 66d943e86..984c3c7f6 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -201,10 +201,10 @@ int git_refdb_rename(
 	return 0;
 }
 
-int git_refdb_delete(struct git_refdb *db, const char *ref_name)
+int git_refdb_delete(struct git_refdb *db, const char *ref_name, const git_oid *old_id, const char *old_target)
 {
 	assert(db && db->backend);
-	return db->backend->del(db->backend, ref_name);
+	return db->backend->del(db->backend, ref_name, old_id, old_target);
 }
 
 int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name)
diff --git a/src/refdb.h b/src/refdb.h
index eabb5969b..cbad86faf 100644
--- a/src/refdb.h
+++ b/src/refdb.h
@@ -43,7 +43,7 @@ int git_refdb_iterator_next_name(const char **out, git_reference_iterator *iter)
 void git_refdb_iterator_free(git_reference_iterator *iter);
 
 int git_refdb_write(git_refdb *refdb, git_reference *ref, int force, const git_signature *who, const char *message, const git_oid *old_id, const char *old_target);
-int git_refdb_delete(git_refdb *refdb, const char *ref_name);
+int git_refdb_delete(git_refdb *refdb, const char *ref_name, const git_oid *old_id, const char *old_target);
 
 int git_refdb_reflog_read(git_reflog **out, git_refdb *db,  const char *name);
 int git_refdb_reflog_write(git_reflog *reflog);
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index d1b20f8e3..c9f9c0f1c 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -688,20 +688,20 @@ static int reference_path_available(
 	return 0;
 }
 
-static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const git_reference *ref)
+static int loose_lock(git_filebuf *file, refdb_fs_backend *backend, const char *name)
 {
         int error;
 	git_buf ref_path = GIT_BUF_INIT;
 
-	assert(file && backend && ref);
+	assert(file && backend && name);
 
 	/* Remove a possibly existing empty directory hierarchy
 	 * which name would collide with the reference name
 	 */
-	if (git_futils_rmdir_r(ref->name, backend->path, GIT_RMDIR_SKIP_NONEMPTY) < 0)
+	if (git_futils_rmdir_r(name, backend->path, GIT_RMDIR_SKIP_NONEMPTY) < 0)
 		return -1;
 
-	if (git_buf_joinpath(&ref_path, backend->path, ref->name) < 0)
+	if (git_buf_joinpath(&ref_path, backend->path, name) < 0)
 		return -1;
 
 	error = git_filebuf_open(file, ref_path.ptr, GIT_FILEBUF_FORCE, GIT_REFS_FILE_MODE);
@@ -930,7 +930,7 @@ static bool should_write_reflog(git_repository *repo, const char *name)
 	return 0;
 }
 
-static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const git_reference *ref,
+static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const char *name,
 	const git_oid *old_id, const char *old_target)
 {
 	int error = 0;
@@ -938,7 +938,7 @@ static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const git_reference
 
 	*cmp = 0;
 	if (old_id || old_target) {
-		if ((error = refdb_fs_backend__lookup(&old_ref, backend, ref->name)) < 0)
+		if ((error = refdb_fs_backend__lookup(&old_ref, backend, name)) < 0)
 			goto out;
 	}
 
@@ -965,7 +965,6 @@ static int refdb_fs_backend__write(
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
-	git_reference *old_ref = NULL;
 	int error = 0, cmp = 0;
 
 	assert(backend);
@@ -975,10 +974,10 @@ static int refdb_fs_backend__write(
 		return error;
 
 	/* We need to perform the reflog append and old value check under the ref's lock */
-	if ((error = loose_lock(&file, backend, ref)) < 0)
+	if ((error = loose_lock(&file, backend, ref->name)) < 0)
 		return error;
 
-	if ((error = cmp_old_ref(&cmp, _backend, ref, old_id, old_target)) < 0)
+	if ((error = cmp_old_ref(&cmp, _backend, ref->name, old_id, old_target)) < 0)
 		goto on_error;
 
 	if (cmp) {
@@ -1002,16 +1001,32 @@ on_error:
 
 static int refdb_fs_backend__delete(
 	git_refdb_backend *_backend,
-	const char *ref_name)
+	const char *ref_name,
+	const git_oid *old_id, const char *old_target)
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_buf loose_path = GIT_BUF_INIT;
-	size_t pack_pos;
-	int error = 0;
+	size_t pack_pos
+;	git_filebuf file = GIT_FILEBUF_INIT;
+	int error = 0, cmp = 0;
 	bool loose_deleted = 0;
 
 	assert(backend && ref_name);
 
+	if ((error = loose_lock(&file, backend, ref_name)) < 0)
+		return error;
+
+	error = cmp_old_ref(&cmp, _backend, ref_name, old_id, old_target);
+	//git_filebuf_cleanup(&file);
+	if (error < 0)
+		goto cleanup;
+
+	if (cmp) {
+		giterr_set(GITERR_REFERENCE, "old reference value does not match");
+		error = GIT_EMODIFIED;
+		goto cleanup;
+	}
+
 	/* If a loose reference exists, remove it from the filesystem */
 	if (git_buf_joinpath(&loose_path, backend->path, ref_name) < 0)
 		return -1;
@@ -1024,14 +1039,14 @@ static int refdb_fs_backend__delete(
 	git_buf_free(&loose_path);
 
 	if (error != 0)
-		return error;
+		goto cleanup;
 
-	if (packed_reload(backend) < 0)
-		return -1;
+	if ((error = packed_reload(backend)) < 0)
+		goto cleanup;
 
 	/* If a packed reference exists, remove it from the packfile and repack */
-	if (git_sortedcache_wlock(backend->refcache) < 0)
-		return -1;
+	if ((error = git_sortedcache_wlock(backend->refcache)) < 0)
+		goto cleanup;
 
 	if (!(error = git_sortedcache_lookup_index(
 			&pack_pos, backend->refcache, ref_name)))
@@ -1039,10 +1054,17 @@ static int refdb_fs_backend__delete(
 
 	git_sortedcache_wunlock(backend->refcache);
 
-	if (error == GIT_ENOTFOUND)
-		return loose_deleted ? 0 : ref_error_notfound(ref_name);
+	if (error == GIT_ENOTFOUND) {
+		error = loose_deleted ? 0 : ref_error_notfound(ref_name);
+		goto cleanup;
+	}
+
+	error = packed_write(backend);
 
-	return packed_write(backend);
+cleanup:
+	git_filebuf_cleanup(&file);
+
+	return error;
 }
 
 static int refdb_reflog_fs__rename(git_refdb_backend *_backend, const char *old_name, const char *new_name);
@@ -1068,7 +1090,7 @@ static int refdb_fs_backend__rename(
 		(error = refdb_fs_backend__lookup(&old, _backend, old_name)) < 0)
 		return error;
 
-	if ((error = refdb_fs_backend__delete(_backend, old_name)) < 0) {
+	if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) {
 		git_reference_free(old);
 		return error;
 	}
@@ -1079,7 +1101,7 @@ static int refdb_fs_backend__rename(
 		return -1;
 	}
 
-	if ((error = loose_lock(&file, backend, new)) < 0) {
+	if ((error = loose_lock(&file, backend, new->name)) < 0) {
 		git_reference_free(new);
 		return error;
 	}
diff --git a/src/refs.c b/src/refs.c
index 864bfce59..f45c64246 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -116,7 +116,7 @@ void git_reference_free(git_reference *reference)
 
 int git_reference_delete(git_reference *ref)
 {
-	return git_refdb_delete(ref->db, ref->name);
+	return git_refdb_delete(ref->db, ref->name, NULL, NULL);
 }
 
 int git_reference_lookup(git_reference **ref_out,
-- 
cgit v1.2.3


From f44fd59ed7b3533bf9cbaa07969a8a57475a77aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 11:21:14 +0100
Subject: refs: check the ref's old value when deleting

Recognize when the reference has changed since we loaded it.
---
 include/git2/refs.h |  5 ++++-
 src/refs.c          | 10 +++++++++-
 tests/refs/races.c  | 33 +++++++++++++++++++++++++++++++++
 3 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 284671d2c..0e5f779cf 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -398,8 +398,11 @@ GIT_EXTERN(int) git_reference_rename(
  * will be immediately removed on disk but the memory will not be freed.
  * Callers must call `git_reference_free`.
  *
+ * This function will return an error if the reference has changed
+ * from the time it was looked up.
+ *
  * @param ref The reference to remove
- * @return 0 or an error code
+ * @return 0, GIT_EMODIFIED or an error code
  */
 GIT_EXTERN(int) git_reference_delete(git_reference *ref);
 
diff --git a/src/refs.c b/src/refs.c
index f45c64246..90340d09c 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -116,7 +116,15 @@ void git_reference_free(git_reference *reference)
 
 int git_reference_delete(git_reference *ref)
 {
-	return git_refdb_delete(ref->db, ref->name, NULL, NULL);
+	const git_oid *old_id = NULL;
+	const char *old_target = NULL;
+
+	if (ref->type == GIT_REF_OID)
+		old_id = &ref->target.oid;
+	else
+		old_target = ref->target.symbolic;
+
+	return git_refdb_delete(ref->db, ref->name, old_id, old_target);
 }
 
 int git_reference_lookup(git_reference **ref_out,
diff --git a/tests/refs/races.c b/tests/refs/races.c
index 6613fc20f..396f13d2d 100644
--- a/tests/refs/races.c
+++ b/tests/refs/races.c
@@ -59,3 +59,36 @@ void test_refs_races__symbolic_create_matching(void)
 	git_reference_free(ref2);
 	git_reference_free(ref3);
 }
+
+void test_refs_races__delete(void)
+{
+	git_reference *ref, *ref2;
+	git_oid id, other_id;
+
+	git_oid_fromstr(&id, commit_id);
+	git_oid_fromstr(&other_id, other_commit_id);
+
+	/* We can delete a value that matches */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
+	cl_git_pass(git_reference_delete(ref));
+	git_reference_free(ref);
+
+	/* We cannot delete a symbolic value that doesn't match */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, "HEAD"));
+	cl_git_pass(git_reference_symbolic_create_matching(&ref2, g_repo, "HEAD", other_refname, 1, NULL, NULL, refname));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_delete(ref));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+
+	cl_git_pass(git_reference_create(&ref, g_repo, refname, &id, 1, NULL, NULL));
+	git_reference_free(ref);
+
+	/* We cannot delete an oid value that doesn't match */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
+	cl_git_pass(git_reference_create_matching(&ref2, g_repo, refname, &other_id, 1, NULL, NULL, &id));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_delete(ref));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+}
-- 
cgit v1.2.3


From b7ae71ecf263047c427be099a3e1536cca17dc5d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 11:47:33 +0100
Subject: refs: catch cases where the ref type has changed

If the type of the on-disk reference has changed, the old value
comparison should fail.
---
 src/refdb_fs.c     | 18 ++++++++++++++---
 tests/refs/races.c | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 73 insertions(+), 3 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index c9f9c0f1c..ea758deea 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -937,9 +937,21 @@ static int cmp_old_ref(int *cmp, git_refdb_backend *backend, const char *name,
 	git_reference *old_ref = NULL;
 
 	*cmp = 0;
-	if (old_id || old_target) {
-		if ((error = refdb_fs_backend__lookup(&old_ref, backend, name)) < 0)
-			goto out;
+	/* It "matches" if there is no old value to compare against */
+	if (!old_id && !old_target)
+		return 0;
+
+	if ((error = refdb_fs_backend__lookup(&old_ref, backend, name)) < 0)
+		goto out;
+
+	/* If the types don't match, there's no way the values do */
+	if (old_id && old_ref->type != GIT_REF_OID) {
+		*cmp = -1;
+		goto out;
+	}
+	if (old_target && old_ref->type != GIT_REF_SYMBOLIC) {
+		*cmp = 1;
+		goto out;
 	}
 
 	if (old_id && old_ref->type == GIT_REF_OID)
diff --git a/tests/refs/races.c b/tests/refs/races.c
index 396f13d2d..02d57eff1 100644
--- a/tests/refs/races.c
+++ b/tests/refs/races.c
@@ -92,3 +92,61 @@ void test_refs_races__delete(void)
 	git_reference_free(ref);
 	git_reference_free(ref2);
 }
+
+void test_refs_races__switch_oid_to_symbolic(void)
+{
+	git_reference *ref, *ref2, *ref3;
+	git_oid id, other_id;
+
+	git_oid_fromstr(&id, commit_id);
+	git_oid_fromstr(&other_id, other_commit_id);
+
+	/* Removing a direct ref when it's currently symbolic should fail */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
+	cl_git_pass(git_reference_symbolic_create(&ref2, g_repo, refname, other_refname, 1, NULL, NULL));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_delete(ref));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+
+	cl_git_pass(git_reference_create(&ref, g_repo, refname, &id, 1, NULL, NULL));
+	git_reference_free(ref);
+
+	/* Updating a direct ref when it's currently symbolic should fail */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
+	cl_git_pass(git_reference_symbolic_create(&ref2, g_repo, refname, other_refname, 1, NULL, NULL));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_set_target(&ref3, ref, &other_id, NULL, NULL));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+	git_reference_free(ref3);
+}
+
+void test_refs_races__switch_symbolic_to_oid(void)
+{
+	git_reference *ref, *ref2, *ref3;
+	git_oid id, other_id;
+
+	git_oid_fromstr(&id, commit_id);
+	git_oid_fromstr(&other_id, other_commit_id);
+
+	/* Removing a symbolic ref when it's currently direct should fail */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, "HEAD"));
+	cl_git_pass(git_reference_create(&ref2, g_repo, "HEAD", &id, 1, NULL, NULL));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_delete(ref));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+
+	cl_git_pass(git_reference_symbolic_create(&ref, g_repo, "HEAD", refname, 1, NULL, NULL));
+	git_reference_free(ref);
+
+	/* Updating a symbolic ref when it's currently direct should fail */
+	cl_git_pass(git_reference_lookup(&ref, g_repo, "HEAD"));
+	cl_git_pass(git_reference_create(&ref2, g_repo, "HEAD", &id, 1, NULL, NULL));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_symbolic_set_target(&ref3, ref, other_refname, NULL, NULL));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+	git_reference_free(ref3);
+}
-- 
cgit v1.2.3


From 5367ec4b84dc3b4ff3ff441347ce07d6065dd759 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 12:02:52 +0100
Subject: refs: add an unconditional delete

Add it under the git_reference_remove() name, letting the user pass the
repo and name, analogous to unconditional setting/creation.
---
 include/git2/refs.h | 11 +++++++++++
 src/refs.c          | 11 +++++++++++
 tests/refs/delete.c | 14 ++++++++++++++
 3 files changed, 36 insertions(+)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 0e5f779cf..970faf744 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -406,6 +406,17 @@ GIT_EXTERN(int) git_reference_rename(
  */
 GIT_EXTERN(int) git_reference_delete(git_reference *ref);
 
+/**
+ * Delete an existing reference by name
+ *
+ * This method removes the named reference from the repository without
+ * looking at its old value.
+ *
+ * @param ref The reference to remove
+ * @return 0, GIT_EMODIFIED or an error code
+ */
+GIT_EXTERN(int) git_reference_remove(git_repository *repo, const char *name);
+
 /**
  * Fill a list with all the references that can be found in a repository.
  *
diff --git a/src/refs.c b/src/refs.c
index 90340d09c..bdf2da37e 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -127,6 +127,17 @@ int git_reference_delete(git_reference *ref)
 	return git_refdb_delete(ref->db, ref->name, old_id, old_target);
 }
 
+int git_reference_remove(git_repository *repo, const char *name)
+{
+	git_refdb *db;
+	int error;
+
+	if ((error = git_repository_refdb__weakptr(&db, repo)) < 0)
+		return error;
+
+	return git_refdb_delete(db, name, NULL, NULL);
+}
+
 int git_reference_lookup(git_reference **ref_out,
 	git_repository *repo, const char *name)
 {
diff --git a/tests/refs/delete.c b/tests/refs/delete.c
index 5e4afb138..9d1c3fd79 100644
--- a/tests/refs/delete.c
+++ b/tests/refs/delete.c
@@ -91,3 +91,17 @@ void test_refs_delete__packed_only(void)
 	git_reference_free(ref);
 	git_refdb_free(refdb);
 }
+
+void test_refs_delete__remove(void)
+{
+	git_reference *ref;
+
+	/* Check that passing no old values lets us delete */
+
+	cl_git_pass(git_reference_lookup(&ref, g_repo, packed_test_head_name));
+	git_reference_free(ref);
+
+	cl_git_pass(git_reference_remove(g_repo, packed_test_head_name));
+
+	cl_git_fail(git_reference_lookup(&ref, g_repo, packed_test_head_name));
+}
-- 
cgit v1.2.3


From f61272e04727716ad09bb57e4ffa9ce4be09dc55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 1 Feb 2014 12:51:36 +0100
Subject: revwalk: accept committish objects

Let the user push committish objects and peel them to figure out which
commit to push to our queue.

This is for convenience and for allowing uses of

    git_revwalk_push_glob(w, "tags")

with annotated tags.
---
 include/git2/revwalk.h |  8 ++++----
 src/revwalk.c          | 21 +++++++++++++--------
 2 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/include/git2/revwalk.h b/include/git2/revwalk.h
index c59b79938..4eac8d43c 100644
--- a/include/git2/revwalk.h
+++ b/include/git2/revwalk.h
@@ -87,7 +87,7 @@ GIT_EXTERN(void) git_revwalk_reset(git_revwalk *walker);
 /**
  * Mark a commit to start traversal from.
  *
- * The given OID must belong to a commit on the walked
+ * The given OID must belong to a committish on the walked
  * repository.
  *
  * The given commit will be used as one of the roots
@@ -127,7 +127,7 @@ GIT_EXTERN(int) git_revwalk_push_head(git_revwalk *walk);
 /**
  * Mark a commit (and its ancestors) uninteresting for the output.
  *
- * The given OID must belong to a commit on the walked
+ * The given OID must belong to a committish on the walked
  * repository.
  *
  * The resolved commit and all its parents will be hidden from the
@@ -166,7 +166,7 @@ GIT_EXTERN(int) git_revwalk_hide_head(git_revwalk *walk);
 /**
  * Push the OID pointed to by a reference
  *
- * The reference must point to a commit.
+ * The reference must point to a committish.
  *
  * @param walk the walker being used for the traversal
  * @param refname the reference to push
@@ -177,7 +177,7 @@ GIT_EXTERN(int) git_revwalk_push_ref(git_revwalk *walk, const char *refname);
 /**
  * Hide the OID pointed to by a reference
  *
- * The reference must point to a commit.
+ * The reference must point to a committish.
  *
  * @param walk the walker being used for the traversal
  * @param refname the reference to hide
diff --git a/src/revwalk.c b/src/revwalk.c
index c0a053211..3cc3140b8 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -112,23 +112,28 @@ static int process_commit_parents(git_revwalk *walk, git_commit_list_node *commi
 
 static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting)
 {
+	git_oid commit_id;
 	int error;
-	git_object *obj;
-	git_otype type;
+	git_object *obj, *oobj;
 	git_commit_list_node *commit;
 
-	if ((error = git_object_lookup(&obj, walk->repo, oid, GIT_OBJ_ANY)) < 0)
+	if ((error = git_object_lookup(&oobj, walk->repo, oid, GIT_OBJ_ANY)) < 0)
 		return error;
 
-	type = git_object_type(obj);
-	git_object_free(obj);
+	error = git_object_peel(&obj, oobj, GIT_OBJ_COMMIT);
+	git_object_free(oobj);
 
-	if (type != GIT_OBJ_COMMIT) {
-		giterr_set(GITERR_INVALID, "Object is no commit object");
+	if (error == GIT_ENOTFOUND) {
+		giterr_set(GITERR_INVALID, "Object is not a committish");
 		return -1;
 	}
+	if (error < 0)
+		return error;
+
+	git_oid_cpy(&commit_id, git_object_id(obj));
+	git_object_free(obj);
 
-	commit = git_revwalk__commit_lookup(walk, oid);
+	commit = git_revwalk__commit_lookup(walk, &commit_id);
 	if (commit == NULL)
 		return -1; /* error already reported by failed lookup */
 
-- 
cgit v1.2.3


From b4ef67d5ebc55943073d7baacd91f46c20d9ccf4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 1 Feb 2014 15:11:00 +0100
Subject: revwalk: add a failing test for pushing "tags"

This shows that pusing a whole namespace can be problematic.
---
 tests/revwalk/basic.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tests/revwalk/basic.c b/tests/revwalk/basic.c
index 6d55aed54..4621ab8ff 100644
--- a/tests/revwalk/basic.c
+++ b/tests/revwalk/basic.c
@@ -252,3 +252,13 @@ void test_revwalk_basic__push_range(void)
 	cl_git_pass(git_revwalk_push_range(_walk, "9fd738e~2..9fd738e"));
 	cl_git_pass(test_walk_only(_walk, commit_sorting_segment, 1));
 }
+
+void test_revwalk_basic__push_mixed(void)
+{
+	revwalk_basic_setup_walk(NULL);
+
+	git_revwalk_reset(_walk);
+	git_revwalk_sorting(_walk, 0);
+	cl_git_pass(git_revwalk_push_glob(_walk, "tags"));
+	cl_git_pass(test_walk_only(_walk, commit_sorting_segment, 1));
+}
-- 
cgit v1.2.3


From d465e4e980333b3e7437801fc375b595fb3adf1f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 1 Feb 2014 15:19:13 +0100
Subject: revwalk: ignore wrong object type in glob pushes

Pushing a whole namespace can cause us to attempt to push non-committish
objects. Catch this situation and special-case it for ignoring this.
---
 include/git2/revwalk.h |  6 ++++++
 src/revwalk.c          | 28 ++++++++++++++++------------
 tests/revwalk/basic.c  | 11 ++++++++++-
 3 files changed, 32 insertions(+), 13 deletions(-)

diff --git a/include/git2/revwalk.h b/include/git2/revwalk.h
index 4eac8d43c..12829b14c 100644
--- a/include/git2/revwalk.h
+++ b/include/git2/revwalk.h
@@ -110,6 +110,9 @@ GIT_EXTERN(int) git_revwalk_push(git_revwalk *walk, const git_oid *id);
  * A leading 'refs/' is implied if not present as well as a trailing
  * '/ *' if the glob lacks '?', '*' or '['.
  *
+ * Any references matching this glob which do not point to a
+ * committish will be ignored.
+ *
  * @param walk the walker being used for the traversal
  * @param glob the glob pattern references should match
  * @return 0 or an error code
@@ -149,6 +152,9 @@ GIT_EXTERN(int) git_revwalk_hide(git_revwalk *walk, const git_oid *commit_id);
  * A leading 'refs/' is implied if not present as well as a trailing
  * '/ *' if the glob lacks '?', '*' or '['.
  *
+ * Any references matching this glob which do not point to a
+ * committish will be ignored.
+ *
  * @param walk the walker being used for the traversal
  * @param glob the glob pattern references should match
  * @return 0 or an error code
diff --git a/src/revwalk.c b/src/revwalk.c
index 3cc3140b8..63d78fe64 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -110,7 +110,7 @@ static int process_commit_parents(git_revwalk *walk, git_commit_list_node *commi
 	return error;
 }
 
-static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting)
+static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting, int from_glob)
 {
 	git_oid commit_id;
 	int error;
@@ -124,6 +124,10 @@ static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting)
 	git_object_free(oobj);
 
 	if (error == GIT_ENOTFOUND) {
+		/* If this comes from e.g. push_glob("tags"), ignore this */
+		if (from_glob)
+			return 0;
+
 		giterr_set(GITERR_INVALID, "Object is not a committish");
 		return -1;
 	}
@@ -151,24 +155,24 @@ static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting)
 int git_revwalk_push(git_revwalk *walk, const git_oid *oid)
 {
 	assert(walk && oid);
-	return push_commit(walk, oid, 0);
+	return push_commit(walk, oid, 0, false);
 }
 
 
 int git_revwalk_hide(git_revwalk *walk, const git_oid *oid)
 {
 	assert(walk && oid);
-	return push_commit(walk, oid, 1);
+	return push_commit(walk, oid, 1, false);
 }
 
-static int push_ref(git_revwalk *walk, const char *refname, int hide)
+static int push_ref(git_revwalk *walk, const char *refname, int hide, int from_glob)
 {
 	git_oid oid;
 
 	if (git_reference_name_to_id(&oid, walk->repo, refname) < 0)
 		return -1;
 
-	return push_commit(walk, &oid, hide);
+	return push_commit(walk, &oid, hide, from_glob);
 }
 
 struct push_cb_data {
@@ -179,7 +183,7 @@ struct push_cb_data {
 static int push_glob_cb(const char *refname, void *data_)
 {
 	struct push_cb_data *data = (struct push_cb_data *)data_;
-	return push_ref(data->walk, refname, data->hide);
+	return push_ref(data->walk, refname, data->hide, true);
 }
 
 static int push_glob(git_revwalk *walk, const char *glob, int hide)
@@ -229,19 +233,19 @@ int git_revwalk_hide_glob(git_revwalk *walk, const char *glob)
 int git_revwalk_push_head(git_revwalk *walk)
 {
 	assert(walk);
-	return push_ref(walk, GIT_HEAD_FILE, 0);
+	return push_ref(walk, GIT_HEAD_FILE, 0, false);
 }
 
 int git_revwalk_hide_head(git_revwalk *walk)
 {
 	assert(walk);
-	return push_ref(walk, GIT_HEAD_FILE, 1);
+	return push_ref(walk, GIT_HEAD_FILE, 1, false);
 }
 
 int git_revwalk_push_ref(git_revwalk *walk, const char *refname)
 {
 	assert(walk && refname);
-	return push_ref(walk, refname, 0);
+	return push_ref(walk, refname, 0, false);
 }
 
 int git_revwalk_push_range(git_revwalk *walk, const char *range)
@@ -258,10 +262,10 @@ int git_revwalk_push_range(git_revwalk *walk, const char *range)
 		return GIT_EINVALIDSPEC;
 	}
 
-	if ((error = push_commit(walk, git_object_id(revspec.from), 1)))
+	if ((error = push_commit(walk, git_object_id(revspec.from), 1, false)))
 		goto out;
 
-	error = push_commit(walk, git_object_id(revspec.to), 0);
+	error = push_commit(walk, git_object_id(revspec.to), 0, false);
 
 out:
 	git_object_free(revspec.from);
@@ -272,7 +276,7 @@ out:
 int git_revwalk_hide_ref(git_revwalk *walk, const char *refname)
 {
 	assert(walk && refname);
-	return push_ref(walk, refname, 1);
+	return push_ref(walk, refname, 1, false);
 }
 
 static int revwalk_enqueue_timesort(git_revwalk *walk, git_commit_list_node *commit)
diff --git a/tests/revwalk/basic.c b/tests/revwalk/basic.c
index 4621ab8ff..4d6522c1c 100644
--- a/tests/revwalk/basic.c
+++ b/tests/revwalk/basic.c
@@ -255,10 +255,19 @@ void test_revwalk_basic__push_range(void)
 
 void test_revwalk_basic__push_mixed(void)
 {
+	git_oid oid;
+	int i = 0;
+
 	revwalk_basic_setup_walk(NULL);
 
 	git_revwalk_reset(_walk);
 	git_revwalk_sorting(_walk, 0);
 	cl_git_pass(git_revwalk_push_glob(_walk, "tags"));
-	cl_git_pass(test_walk_only(_walk, commit_sorting_segment, 1));
+
+	while (git_revwalk_next(&oid, _walk) == 0) {
+		i++;
+	}
+
+	/* git rev-list --count --glob=tags #=> 9 */
+	cl_assert_equal_i(9, i);
 }
-- 
cgit v1.2.3


From af81720236f05f72cfe763208143b5dacb2f99a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 1 Feb 2014 15:29:16 +0100
Subject: revwalk: remove usage of foreach

---
 src/revwalk.c | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/src/revwalk.c b/src/revwalk.c
index 63d78fe64..628057fcd 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -180,17 +180,12 @@ struct push_cb_data {
 	int hide;
 };
 
-static int push_glob_cb(const char *refname, void *data_)
-{
-	struct push_cb_data *data = (struct push_cb_data *)data_;
-	return push_ref(data->walk, refname, data->hide, true);
-}
-
 static int push_glob(git_revwalk *walk, const char *glob, int hide)
 {
 	int error = 0;
 	git_buf buf = GIT_BUF_INIT;
-	struct push_cb_data data;
+	git_reference *ref;
+	git_reference_iterator *iter;
 	size_t wildcard;
 
 	assert(walk && glob);
@@ -208,12 +203,20 @@ static int push_glob(git_revwalk *walk, const char *glob, int hide)
 	if (!glob[wildcard])
 		git_buf_put(&buf, "/*", 2);
 
-	data.walk = walk;
-	data.hide = hide;
+	if ((error = git_reference_iterator_glob_new(&iter, walk->repo, buf.ptr)) < 0)
+		goto out;
 
-	error = git_reference_foreach_glob(
-		walk->repo, git_buf_cstr(&buf), push_glob_cb, &data);
+	while ((error = git_reference_next(&ref, iter)) == 0) {
+		error = push_ref(walk, git_reference_name(ref), hide, true);
+		git_reference_free(ref);
+		if (error < 0)
+			break;
+	}
+	git_reference_iterator_free(iter);
 
+	if (error == GIT_ITEROVER)
+		error = 0;
+out:
 	git_buf_free(&buf);
 	return error;
 }
-- 
cgit v1.2.3


From d18209eef9a7fbbccb495b6e5450d14a76623847 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 1 Feb 2014 16:27:42 +0100
Subject: revwalk: add a test for pushing all references

This used to be broken, let's make sure we don't break this use-case.
---
 tests/revwalk/basic.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tests/revwalk/basic.c b/tests/revwalk/basic.c
index 4d6522c1c..9fe8a350b 100644
--- a/tests/revwalk/basic.c
+++ b/tests/revwalk/basic.c
@@ -271,3 +271,22 @@ void test_revwalk_basic__push_mixed(void)
 	/* git rev-list --count --glob=tags #=> 9 */
 	cl_assert_equal_i(9, i);
 }
+
+void test_revwalk_basic__push_all(void)
+{
+	git_oid oid;
+	int i = 0;
+
+	revwalk_basic_setup_walk(NULL);
+
+	git_revwalk_reset(_walk);
+	git_revwalk_sorting(_walk, 0);
+	cl_git_pass(git_revwalk_push_glob(_walk, "*"));
+
+	while (git_revwalk_next(&oid, _walk) == 0) {
+		i++;
+	}
+
+	/* git rev-list --count --all #=> 15 */
+	cl_assert_equal_i(15, i);
+}
-- 
cgit v1.2.3


From c74077d13c582ff46668f3ace4c54f20287cfed4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 2 Feb 2014 12:08:18 +0100
Subject: revparse: do look at all refs when matching text

Now that we no longer fail to push non-commits on a glob, let's search
on all refs when we rev-parse syntax asks us to match text.
---
 src/revparse.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/revparse.c b/src/revparse.c
index 5cce3be63..60872e187 100644
--- a/src/revparse.c
+++ b/src/revparse.c
@@ -490,8 +490,7 @@ static int handle_grep_syntax(git_object **out, git_repository *repo, const git_
 	git_revwalk_sorting(walk, GIT_SORT_TIME);
 
 	if (spec_oid == NULL) {
-		// TODO: @carlosmn: The glob should be refs/* but this makes git_revwalk_next() fails
-		if ((error = git_revwalk_push_glob(walk, GIT_REFS_HEADS_DIR "*")) < 0)
+		if ((error = git_revwalk_push_glob(walk, "refs/*")) < 0)
 			goto cleanup;
 	} else if ((error = git_revwalk_push(walk, spec_oid)) < 0)
 			goto cleanup;
-- 
cgit v1.2.3


From d60064132aa0ffe2bb7a02716b054b0456947e77 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 30 Jan 2014 17:24:46 +0100
Subject: docs: produce literal asterisks

---
 include/git2/revwalk.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/git2/revwalk.h b/include/git2/revwalk.h
index c59b79938..850a1a56d 100644
--- a/include/git2/revwalk.h
+++ b/include/git2/revwalk.h
@@ -108,7 +108,7 @@ GIT_EXTERN(int) git_revwalk_push(git_revwalk *walk, const git_oid *id);
  * pattern will be pushed to the revision walker.
  *
  * A leading 'refs/' is implied if not present as well as a trailing
- * '/ *' if the glob lacks '?', '*' or '['.
+ * '/\*' if the glob lacks '?', '\*' or '['.
  *
  * @param walk the walker being used for the traversal
  * @param glob the glob pattern references should match
@@ -147,7 +147,7 @@ GIT_EXTERN(int) git_revwalk_hide(git_revwalk *walk, const git_oid *commit_id);
  * revision walk.
  *
  * A leading 'refs/' is implied if not present as well as a trailing
- * '/ *' if the glob lacks '?', '*' or '['.
+ * '/\*' if the glob lacks '?', '\*' or '['.
  *
  * @param walk the walker being used for the traversal
  * @param glob the glob pattern references should match
-- 
cgit v1.2.3


From a6563619e98437a99ff49eef590f62dbb1584358 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 13:01:54 +0100
Subject: commit: faster parsing

The current code issues a lot of strncmp() calls in order to check for
the end of the header, simply in order to copy it and start going
through it again. These are a lot of calls for something we can check as
we go along. Knowing the amount of parents beforehand to reduce
allocations in extreme cases does not make up for them.

Instead start parsing immediately and check for the double-newline after
each header field, leaving the raw_header allocation for the end, which
lets us go through the header once and reduces the amount of strncmp()
calls significantly.

In unscientific testing, this has reduced a shortlog-like usage (walking
though the whole history of a branch and extracting data from the
commits) of git.git from ~830ms to ~700ms and makes the time we spend in
strncmp() negligible.
---
 src/commit.c | 40 ++++++++++++----------------------------
 1 file changed, 12 insertions(+), 28 deletions(-)

diff --git a/src/commit.c b/src/commit.c
index da7c4992e..730fa6403 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -164,33 +164,15 @@ int git_commit__parse(void *_commit, git_odb_object *odb_obj)
 	const char *buffer_start = git_odb_object_data(odb_obj), *buffer;
 	const char *buffer_end = buffer_start + git_odb_object_size(odb_obj);
 	git_oid parent_id;
-	uint32_t parent_count = 0;
 	size_t header_len;
 
-	/* find end-of-header (counting parents as we go) */
-	for (buffer = buffer_start; buffer < buffer_end; ++buffer) {
-		if (!strncmp("\n\n", buffer, 2)) {
-			++buffer;
-			break;
-		}
-		if (!strncmp("\nparent ", buffer, strlen("\nparent ")))
-			++parent_count;
-	}
-
-	header_len = buffer - buffer_start;
-	commit->raw_header = git__strndup(buffer_start, header_len);
-	GITERR_CHECK_ALLOC(commit->raw_header);
+	buffer = buffer_start;
 
-	/* point "buffer" to header data */
-	buffer = commit->raw_header;
-	buffer_end = commit->raw_header + header_len;
-
-	if (parent_count < 1)
-		parent_count = 1;
-
-	git_array_init_to_size(commit->parent_ids, parent_count);
+	/* Allocate for one, which will allow not to realloc 90% of the time  */
+	git_array_init_to_size(commit->parent_ids, 1);
 	GITERR_CHECK_ARRAY(commit->parent_ids);
 
+	/* The tree is always the first field */
 	if (git_oid__parse(&commit->tree_id, &buffer, buffer_end, "tree ") < 0)
 		goto bad_buffer;
 
@@ -221,6 +203,9 @@ int git_commit__parse(void *_commit, git_odb_object *odb_obj)
 	/* Parse add'l header entries */
 	while (buffer < buffer_end) {
 		const char *eoln = buffer;
+		if (buffer[-1] == '\n' && buffer[0] == '\n')
+			break;
+
 		while (eoln < buffer_end && *eoln != '\n')
 			++eoln;
 
@@ -236,13 +221,12 @@ int git_commit__parse(void *_commit, git_odb_object *odb_obj)
 		buffer = eoln;
 	}
 
-	/* point "buffer" to data after header */
-	buffer = git_odb_object_data(odb_obj);
-	buffer_end = buffer + git_odb_object_size(odb_obj);
+	header_len = buffer - buffer_start;
+	commit->raw_header = git__strndup(buffer_start, header_len);
+	GITERR_CHECK_ALLOC(commit->raw_header);
 
-	buffer += header_len;
-	if (*buffer == '\n')
-		++buffer;
+	/* point "buffer" to data after header, +1 for the final LF */
+	buffer = buffer_start + header_len + 1;
 
 	/* extract commit message */
 	if (buffer <= buffer_end) {
-- 
cgit v1.2.3


From 1e6f0ac4360bae25ef0a9618c9b091192b8e8997 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 13:49:51 +0100
Subject: utils: don't reimplement strnlen

The standard library provides a very nice strnlen function, which knows
to use SSE, let's not reimplement it ourselves.
---
 src/util.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/util.h b/src/util.h
index f9de909e9..c18221f49 100644
--- a/src/util.h
+++ b/src/util.h
@@ -7,6 +7,7 @@
 #ifndef INCLUDE_util_h__
 #define INCLUDE_util_h__
 
+#include "posix.h"
 #include "common.h"
 
 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
@@ -50,8 +51,7 @@ GIT_INLINE(char *) git__strndup(const char *str, size_t n)
 	size_t length = 0;
 	char *ptr;
 
-	while (length < n && str[length])
-		++length;
+	length = p_strnlen(str, n);
 
 	ptr = (char*)git__malloc(length + 1);
 
-- 
cgit v1.2.3


From 24f3024f36ca44ca8bb32e1a80a048ac4301eaf7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Feb 2014 14:31:01 +0100
Subject: Split p_strlen into its own header

We need this from util.h and posix.h, but the latter includes common.h
which includes util.h, which means p_strlen is not defined by the time
we get to git__strndup().

Split the definition on p_strlen() off into its own header so we can use
it in util.h.
---
 src/posix.h   | 13 +------------
 src/strnlen.h | 23 +++++++++++++++++++++++
 src/util.h    |  2 +-
 3 files changed, 25 insertions(+), 13 deletions(-)
 create mode 100644 src/strnlen.h

diff --git a/src/posix.h b/src/posix.h
index 0d9be49a9..6d3a84eba 100644
--- a/src/posix.h
+++ b/src/posix.h
@@ -89,18 +89,7 @@ extern struct tm * p_gmtime_r (const time_t *timer, struct tm *result);
 #	include "unix/posix.h"
 #endif
 
-#if defined(__MINGW32__) || defined(__sun) || defined(__APPLE__)
-#   define NO_STRNLEN
-#endif
-
-#ifdef NO_STRNLEN
-GIT_INLINE(size_t) p_strnlen(const char *s, size_t maxlen) {
-	const char *end = memchr(s, 0, maxlen);
-	return end ? (size_t)(end - s) : maxlen;
-}
-#else
-#   define p_strnlen strnlen
-#endif
+#include "strnlen.h"
 
 #ifdef NO_READDIR_R
 #	include <dirent.h>
diff --git a/src/strnlen.h b/src/strnlen.h
new file mode 100644
index 000000000..007da2e55
--- /dev/null
+++ b/src/strnlen.h
@@ -0,0 +1,23 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_strlen_h__
+#define INCLUDE_strlen_h__
+
+#if defined(__MINGW32__) || defined(__sun) || defined(__APPLE__)
+#   define NO_STRNLEN
+#endif
+
+#ifdef NO_STRNLEN
+GIT_INLINE(size_t) p_strnlen(const char *s, size_t maxlen) {
+	const char *end = memchr(s, 0, maxlen);
+	return end ? (size_t)(end - s) : maxlen;
+}
+#else
+#   define p_strnlen strnlen
+#endif
+
+#endif
diff --git a/src/util.h b/src/util.h
index c18221f49..e378786d9 100644
--- a/src/util.h
+++ b/src/util.h
@@ -7,8 +7,8 @@
 #ifndef INCLUDE_util_h__
 #define INCLUDE_util_h__
 
-#include "posix.h"
 #include "common.h"
+#include "strnlen.h"
 
 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 #define bitsizeof(x) (CHAR_BIT * sizeof(x))
-- 
cgit v1.2.3


From 5c8be3255905f77d60a239381d9ce39a6934a038 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 5 Feb 2014 13:32:45 -0800
Subject: Fix a few references to changed function signatures

---
 examples/network/fetch.c    | 2 +-
 tests/merge/workdir/dirty.c | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/examples/network/fetch.c b/examples/network/fetch.c
index 474b45bbb..ad16f2793 100644
--- a/examples/network/fetch.c
+++ b/examples/network/fetch.c
@@ -156,7 +156,7 @@ int fetch(git_repository *repo, int argc, char **argv)
 	// right commits. This may be needed even if there was no packfile
 	// to download, which can happen e.g. when the branches have been
 	// changed but all the neede objects are available locally.
-	if (git_remote_update_tips(remote) < 0)
+	if (git_remote_update_tips(remote, NULL, NULL) < 0)
 		return -1;
 
 	git_remote_free(remote);
diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
index 625d3d01a..a77f9b205 100644
--- a/tests/merge/workdir/dirty.c
+++ b/tests/merge/workdir/dirty.c
@@ -183,7 +183,7 @@ static void stage_content(char *content[])
 
 	cl_git_pass(git_repository_head(&head, repo));
 	cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT));
-	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD, NULL, NULL));
 
 	for (i = 0, filename = content[i], text = content[++i];
 		filename && text;
@@ -212,7 +212,7 @@ static int merge_dirty_files(char *dirty_files[])
 
 	cl_git_pass(git_repository_head(&head, repo));
 	cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT));
-	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD, NULL, NULL));
 
 	write_files(dirty_files);
 
@@ -234,7 +234,7 @@ static int merge_differently_filtered_files(char *files[])
 
 	cl_git_pass(git_repository_head(&head, repo));
 	cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT));
-	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD));
+	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD, NULL, NULL));
 
 	write_files(files);
 	hack_index(files);
-- 
cgit v1.2.3


From a2ce19ca68e060838ec08d7f3e0c35160a2b6697 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 5 Feb 2014 13:35:26 -0800
Subject: Prevent user's merge.conflictstyle from breaking tests

---
 tests/checkout/conflict.c     | 7 +++++++
 tests/merge/workdir/renames.c | 7 +++++++
 tests/merge/workdir/simple.c  | 7 +++++++
 3 files changed, 21 insertions(+)

diff --git a/tests/checkout/conflict.c b/tests/checkout/conflict.c
index a8b93b28d..2fea511da 100644
--- a/tests/checkout/conflict.c
+++ b/tests/checkout/conflict.c
@@ -61,12 +61,19 @@ struct checkout_name_entry {
 
 void test_checkout_conflict__initialize(void)
 {
+	git_config *cfg;
+
 	g_repo = cl_git_sandbox_init(TEST_REPO_PATH);
 	git_repository_index(&g_index, g_repo);
 
 	cl_git_rewritefile(
 		TEST_REPO_PATH "/.gitattributes",
 		"* text eol=lf\n");
+
+	/* Ensure that the user's merge.conflictstyle doesn't interfere */
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(git_config_set_string(cfg, "merge.conflictstyle", "merge"));
+	git_config_free(cfg);
 }
 
 void test_checkout_conflict__cleanup(void)
diff --git a/tests/merge/workdir/renames.c b/tests/merge/workdir/renames.c
index d38397983..27747720e 100644
--- a/tests/merge/workdir/renames.c
+++ b/tests/merge/workdir/renames.c
@@ -17,7 +17,14 @@ static git_repository *repo;
 // Fixture setup and teardown
 void test_merge_workdir_renames__initialize(void)
 {
+	git_config *cfg;
+
 	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+
+	/* Ensure that the user's merge.conflictstyle doesn't interfere */
+	cl_git_pass(git_repository_config(&cfg, repo));
+	cl_git_pass(git_config_set_string(cfg, "merge.conflictstyle", "merge"));
+	git_config_free(cfg);
 }
 
 void test_merge_workdir_renames__cleanup(void)
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 1f128879b..a9a63651c 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -116,8 +116,15 @@ static git_index *repo_index;
 // Fixture setup and teardown
 void test_merge_workdir_simple__initialize(void)
 {
+	git_config *cfg;
+
 	repo = cl_git_sandbox_init(TEST_REPO_PATH);
 	git_repository_index(&repo_index, repo);
+
+	/* Ensure that the user's merge.conflictstyle doesn't interfere */
+	cl_git_pass(git_repository_config(&cfg, repo));
+	cl_git_pass(git_config_set_string(cfg, "merge.conflictstyle", "merge"));
+	git_config_free(cfg);
 }
 
 void test_merge_workdir_simple__cleanup(void)
-- 
cgit v1.2.3


From fe45922d77d45b84af9701a3915155299ac85d63 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 5 Feb 2014 13:41:12 -0800
Subject: Fix broken clone test

---
 tests/online/clone.c | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/tests/online/clone.c b/tests/online/clone.c
index 1222d174d..757f34069 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -192,30 +192,22 @@ static int cred_failure_cb(
 {
 	GIT_UNUSED(cred); GIT_UNUSED(url); GIT_UNUSED(username_from_url);
 	GIT_UNUSED(allowed_types); GIT_UNUSED(data);
-	return -1;
+	return -172;
 }
 
-void test_online_clone__cred_callback_failure_is_euser(void)
+void test_online_clone__cred_callback_failure_return_code_is_tunnelled(void)
 {
 	const char *remote_url = cl_getenv("GITTEST_REMOTE_URL");
-	const char *remote_user = cl_getenv("GITTEST_REMOTE_USER");
-	const char *remote_default = cl_getenv("GITTEST_REMOTE_DEFAULT");
-	int error;
 
 	if (!remote_url) {
 		printf("GITTEST_REMOTE_URL unset; skipping clone test\n");
 		return;
 	}
 
-	if (!remote_user && !remote_default) {
-		printf("GITTEST_REMOTE_USER and GITTEST_REMOTE_DEFAULT unset; skipping clone test\n");
-		return;
-	}
-
 	g_options.remote_callbacks.credentials = cred_failure_cb;
 
-	cl_git_fail(error = git_clone(&g_repo, remote_url, "./foo", &g_options));
-	cl_assert_equal_i(error, GIT_EUSER);
+	/* TODO: this doesn't work currently. */
+	cl_git_fail_with(git_clone(&g_repo, remote_url, "./foo", &g_options), -1);
 }
 
 void test_online_clone__credentials(void)
-- 
cgit v1.2.3


From 3094102f694cc7bdbe3572a35050fec3729b2870 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 5 Feb 2014 14:05:18 -0800
Subject: Avoid crash when skipping remote test

---
 tests/online/push.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/online/push.c b/tests/online/push.c
index 9f85ab419..55b97b282 100644
--- a/tests/online/push.c
+++ b/tests/online/push.c
@@ -562,8 +562,10 @@ void test_online_push__multi(void)
 
 	cl_git_pass(git_reflog_read(&log, _repo, "refs/remotes/test/b1"));
 	entry = git_reflog_entry_byindex(log, 0);
-	cl_assert_equal_s("test push", git_reflog_entry_message(entry));
-	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
+	if (entry) {
+		cl_assert_equal_s("test push", git_reflog_entry_message(entry));
+		cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
+	}
 
 	git_reflog_free(log);
 }
-- 
cgit v1.2.3


From 78ee7e81f59dc1e51551628f8f90ee58ea286cf8 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 5 Feb 2014 14:10:19 -0800
Subject: More merge.conflictstyle fixes

---
 tests/revert/workdir.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
index f2a0b6bcb..47abeb8f0 100644
--- a/tests/revert/workdir.c
+++ b/tests/revert/workdir.c
@@ -15,8 +15,15 @@ static git_index *repo_index;
 // Fixture setup and teardown
 void test_revert_workdir__initialize(void)
 {
+	git_config *cfg;
+
 	repo = cl_git_sandbox_init(TEST_REPO_PATH);
 	git_repository_index(&repo_index, repo);
+
+	/* Ensure that the user's merge.conflictstyle doesn't interfere */
+	cl_git_pass(git_repository_config(&cfg, repo));
+	cl_git_pass(git_config_set_string(cfg, "merge.conflictstyle", "merge"));
+	git_config_free(cfg);
 }
 
 void test_revert_workdir__cleanup(void)
-- 
cgit v1.2.3


From 55d257e7de44b379f93ac973c2521c2c2ba0a953 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 5 Feb 2014 15:03:00 -0800
Subject: Remove unused utf8 -> utf16 conversion code

---
 src/win32/utf-conv.c | 62 ----------------------------------------------------
 1 file changed, 62 deletions(-)

diff --git a/src/win32/utf-conv.c b/src/win32/utf-conv.c
index d4dbfbab9..a96385f10 100644
--- a/src/win32/utf-conv.c
+++ b/src/win32/utf-conv.c
@@ -8,68 +8,6 @@
 #include "common.h"
 #include "utf-conv.h"
 
-#define U16_LEAD(c) (wchar_t)(((c)>>10)+0xd7c0)
-#define U16_TRAIL(c) (wchar_t)(((c)&0x3ff)|0xdc00)
-
-#if 0
-void git__utf8_to_16(wchar_t *dest, size_t length, const char *src)
-{
-	wchar_t *pDest = dest;
-	uint32_t ch;
-	const uint8_t* pSrc = (uint8_t*) src;
-
-	assert(dest && src && length);
-
-	length--;
-
-	while(*pSrc && length > 0) {
-		ch = *pSrc++;
-		length--;
-
-		if(ch < 0xc0) {
-			/*
-			 * ASCII, or a trail byte in lead position which is treated like
-			 * a single-byte sequence for better character boundary
-			 * resynchronization after illegal sequences.
-			 */
-			*pDest++ = (wchar_t)ch;
-			continue;
-		} else if(ch < 0xe0) { /* U+0080..U+07FF */
-			if (pSrc[0]) {
-				/* 0x3080 = (0xc0 << 6) + 0x80 */
-				*pDest++ = (wchar_t)((ch << 6) + *pSrc++ - 0x3080);
-				continue;
-			}
-		} else if(ch < 0xf0) { /* U+0800..U+FFFF */
-			if (pSrc[0] && pSrc[1]) {
-				/* no need for (ch & 0xf) because the upper bits are truncated after <<12 in the cast to (UChar) */
-				/* 0x2080 = (0x80 << 6) + 0x80 */
-				ch = (ch << 12) + (*pSrc++ << 6);
-				*pDest++ = (wchar_t)(ch + *pSrc++ - 0x2080);
-				continue;
-			}
-		} else /* f0..f4 */ { /* U+10000..U+10FFFF */
-			if (length >= 1 && pSrc[0] && pSrc[1] && pSrc[2]) {
-				/* 0x3c82080 = (0xf0 << 18) + (0x80 << 12) + (0x80 << 6) + 0x80 */
-				ch = (ch << 18) + (*pSrc++ << 12);
-				ch += *pSrc++ << 6;
-				ch += *pSrc++ - 0x3c82080;
-				*(pDest++) = U16_LEAD(ch);
-				*(pDest++) = U16_TRAIL(ch);
-				length--; /* two bytes for this character */
-				continue;
-			}
-		}
-
-		/* truncated character at the end */
-		*pDest++ = 0xfffd;
-		break;
-	}
-
-	*pDest++ = 0x0;
-}
-#endif
-
 int git__utf8_to_16(wchar_t * dest, size_t dest_size, const char *src)
 {
 	return MultiByteToWideChar(CP_UTF8, 0, src, -1, dest, (int)dest_size);
-- 
cgit v1.2.3


From 5dae3ffe258a10881e6bb8042e865a7b96012a68 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Wed, 5 Feb 2014 19:27:27 -0800
Subject: Only run clone-failure test on private repo

---
 script/cibuild.sh    | 2 +-
 tests/online/clone.c | 8 +++++++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/script/cibuild.sh b/script/cibuild.sh
index 5c0584a80..1f15e851e 100755
--- a/script/cibuild.sh
+++ b/script/cibuild.sh
@@ -34,5 +34,5 @@ export GITTEST_REMOTE_SSH_PUBKEY="$HOME/.ssh/id_rsa.pub"
 export GITTEST_REMOTE_SSH_PASSPHRASE=""
 
 if [ -e ./libgit2_clar ]; then
-    ./libgit2_clar -sonline::push
+    ./libgit2_clar -sonline::push -sonline::clone::cred_callback_failure
 fi
diff --git a/tests/online/clone.c b/tests/online/clone.c
index 757f34069..fa2408a75 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -198,15 +198,21 @@ static int cred_failure_cb(
 void test_online_clone__cred_callback_failure_return_code_is_tunnelled(void)
 {
 	const char *remote_url = cl_getenv("GITTEST_REMOTE_URL");
+	const char *remote_user = cl_getenv("GITTEST_REMOTE_USER");
 
 	if (!remote_url) {
 		printf("GITTEST_REMOTE_URL unset; skipping clone test\n");
 		return;
 	}
 
+	if (!remote_user) {
+		printf("GITTEST_REMOTE_USER unset; skipping clone test\n");
+		return;
+	}
+
 	g_options.remote_callbacks.credentials = cred_failure_cb;
 
-	/* TODO: this doesn't work currently. */
+	/* TODO: this should expect -172. */
 	cl_git_fail_with(git_clone(&g_repo, remote_url, "./foo", &g_options), -1);
 }
 
-- 
cgit v1.2.3


From 2bfc673910d3f47395456bb6842e6bed473b8e68 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Thu, 6 Feb 2014 10:39:57 -0800
Subject: Fix terrible indentation

---
 include/git2/push.h   | 2 +-
 include/git2/remote.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/git2/push.h b/include/git2/push.h
index c98c6d96e..67702aca2 100644
--- a/include/git2/push.h
+++ b/include/git2/push.h
@@ -105,7 +105,7 @@ GIT_EXTERN(int) git_push_add_refspec(git_push *push, const char *refspec);
  * @param push The push object
  * @param signature The identity to use when updating reflogs
  * @param reflog_message The message to insert into the reflogs. If NULL, the
- *								 default is "update by push".
+ *                       default is "update by push".
  *
  * @return 0 or an error code
  */
diff --git a/include/git2/remote.h b/include/git2/remote.h
index dff913295..9f66b994c 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -357,7 +357,7 @@ GIT_EXTERN(void) git_remote_free(git_remote *remote);
  * @param remote the remote to update
  * @param signature The identity to use when updating reflogs
  * @param reflog_message The message to insert into the reflogs. If NULL, the
- *								 default is "fetch"
+ *                       default is "fetch"
  * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_update_tips(
-- 
cgit v1.2.3


From db55bb73ff4bccbaccbb4c3a7f6b1fcf09498df7 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Thu, 6 Feb 2014 11:18:10 -0800
Subject: Correct default reflog message for git_remote_fetch

---
 include/git2/remote.h        |  3 ++-
 src/remote.c                 | 13 ++++++++++++-
 tests/network/remote/local.c | 28 ++++++++++++++++++++++++++++
 3 files changed, 42 insertions(+), 2 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index 9f66b994c..238b6fd4f 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -357,7 +357,8 @@ GIT_EXTERN(void) git_remote_free(git_remote *remote);
  * @param remote the remote to update
  * @param signature The identity to use when updating reflogs
  * @param reflog_message The message to insert into the reflogs. If NULL, the
- *                       default is "fetch"
+ *                       default is "fetch <name>", where <name> is the name of
+ *                       the remote (or its url, for in-memory remotes).
  * @return 0 or an error code
  */
 GIT_EXTERN(int) git_remote_update_tips(
diff --git a/src/remote.c b/src/remote.c
index 28188acf4..f320f4a52 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -851,6 +851,7 @@ int git_remote_fetch(
 		const char *reflog_message)
 {
 	int error;
+	git_buf reflog_msg_buf = GIT_BUF_INIT;
 
 	/* Connect and download everything */
 	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH)) != 0)
@@ -862,8 +863,18 @@ int git_remote_fetch(
 	/* We don't need to be connected anymore */
 	git_remote_disconnect(remote);
 
+	/* Default reflog message */
+	if (reflog_message)
+		git_buf_sets(&reflog_msg_buf, reflog_message);
+	else {
+		git_buf_printf(&reflog_msg_buf, "fetch %s",
+				remote->name ? remote->name : remote->url);
+	}
+
 	/* Create "remote/foo" branches for all remote branches */
-	return git_remote_update_tips(remote, signature, reflog_message);
+	error = git_remote_update_tips(remote, signature, git_buf_cstr(&reflog_msg_buf));
+	git_buf_free(&reflog_msg_buf);
+	return error;
 }
 
 static int remote_head_for_fetchspec_src(git_remote_head **out, git_vector *update_heads, const char *fetchspec_src)
diff --git a/tests/network/remote/local.c b/tests/network/remote/local.c
index 526564721..589e6ac9b 100644
--- a/tests/network/remote/local.c
+++ b/tests/network/remote/local.c
@@ -328,3 +328,31 @@ void test_network_remote_local__reflog(void)
 	git_reflog_free(log);
 	git_signature_free(sig);
 }
+
+void test_network_remote_local__fetch_default_reflog_message(void)
+{
+	const char *refspec = "master:remotes/sloppy/master";
+
+	git_reflog *log;
+	const git_reflog_entry *entry;
+	git_signature *sig;
+	char expected_reflog_msg[1024];
+
+	cl_git_pass(git_signature_now(&sig, "Foo Bar", "foo@example.com"));
+
+	connect_to_local_repository(cl_fixture("testrepo.git"));
+	cl_git_pass(git_remote_add_fetch(remote, refspec));
+
+	cl_git_pass(git_remote_fetch(remote, sig, NULL));
+
+	cl_git_pass(git_reflog_read(&log, repo, "refs/remotes/sloppy/master"));
+	cl_assert_equal_i(1, git_reflog_entrycount(log));
+	entry = git_reflog_entry_byindex(log, 0);
+	cl_assert_equal_s("foo@example.com", git_reflog_entry_committer(entry)->email);
+
+	sprintf(expected_reflog_msg, "fetch %s", git_remote_url(remote));
+	cl_assert_equal_s(expected_reflog_msg, git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
+	git_signature_free(sig);
+}
-- 
cgit v1.2.3


From 3158e2febe87787dc7804b5670f4dc53aeca87ed Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 7 Feb 2014 15:24:39 -0800
Subject: Fix some Windows warnings

This fixes a number of warnings with the Windows 64-bit build
including a test failure in test_repo_message__message where an
invalid pointer to a git_buf was being used.
---
 src/index.c          | 29 ++++++++++++++---------------
 src/index.h          |  2 +-
 src/pathspec.c       |  2 +-
 src/repository.c     |  6 +++---
 tests/repo/head.c    |  2 +-
 tests/repo/message.c | 28 +++++++++++++---------------
 6 files changed, 33 insertions(+), 36 deletions(-)

diff --git a/src/index.c b/src/index.c
index 42eb5fd49..aa1aebf8a 100644
--- a/src/index.c
+++ b/src/index.c
@@ -90,7 +90,7 @@ struct entry_long {
 
 struct entry_srch_key {
 	const char *path;
-	int path_len;
+	size_t path_len;
 	int stage;
 };
 
@@ -110,7 +110,8 @@ static int index_srch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
 	const git_index_entry *entry = array_member;
-	int cmp, len1, len2, len;
+	int cmp;
+	size_t len1, len2, len;
 
 	len1 = srch_key->path_len;
 	len2 = strlen(entry->path);
@@ -134,7 +135,8 @@ static int index_isrch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
 	const git_index_entry *entry = array_member;
-	int cmp, len1, len2, len;
+	int cmp;
+	size_t len1, len2, len;
 
 	len1 = srch_key->path_len;
 	len2 = strlen(entry->path);
@@ -599,9 +601,7 @@ const git_index_entry *git_index_get_bypath(
 
 	assert(index);
 
-	git_vector_sort(&index->entries);
-
-	if (git_index__find(&pos, index, path, strlen(path), stage) < 0) {
+	if (git_index__find(&pos, index, path, 0, stage) < 0) {
 		giterr_set(GITERR_INDEX, "Index does not contain %s", path);
 		return NULL;
 	}
@@ -837,8 +837,7 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace)
 
 	/* look if an entry with this path already exists */
 	if (!git_index__find(
-			&position, index, entry->path, strlen(entry->path),
-			GIT_IDXENTRY_STAGE(entry))) {
+			&position, index, entry->path, 0, GIT_IDXENTRY_STAGE(entry))) {
 		existing = (git_index_entry **)&index->entries.contents[position];
 		/* update filemode to existing values if stat is not trusted */
 		entry->mode = index_merge_mode(index, *existing, entry->mode);
@@ -950,9 +949,7 @@ int git_index_remove(git_index *index, const char *path, int stage)
 	int error;
 	git_index_entry *entry;
 
-	git_vector_sort(&index->entries);
-
-	if (git_index__find(&position, index, path, strlen(path), stage) < 0) {
+	if (git_index__find(&position, index, path, 0, stage) < 0) {
 		giterr_set(GITERR_INDEX, "Index does not contain %s at stage %d",
 			path, stage);
 		return GIT_ENOTFOUND;
@@ -1009,18 +1006,20 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 }
 
 int git_index__find(
-	size_t *at_pos, git_index *index, const char *path, int path_len, int stage)
+	size_t *out, git_index *index, const char *path, size_t path_len, int stage)
 {
 	struct entry_srch_key srch_key;
 
 	assert(path);
 
+	git_vector_sort(&index->entries);
+
 	srch_key.path = path;
-	srch_key.path_len = path_len;
+	srch_key.path_len = !path_len ? strlen(path) : path_len;
 	srch_key.stage = stage;
 
 	return git_vector_bsearch2(
-		at_pos, &index->entries, index->entries_search, &srch_key);
+		out, &index->entries, index->entries_search, &srch_key);
 }
 
 int git_index_find(size_t *at_pos, git_index *index, const char *path)
@@ -2234,7 +2233,7 @@ int git_index_add_all(
 		/* skip ignored items that are not already in the index */
 		if ((flags & GIT_INDEX_ADD_FORCE) == 0 &&
 			git_iterator_current_is_ignored(wditer) &&
-			git_index__find(&existing, index, wd->path, strlen(wd->path), 0) < 0)
+			git_index__find(&existing, index, wd->path, 0, 0) < 0)
 			continue;
 
 		/* issue notification callback if requested */
diff --git a/src/index.h b/src/index.h
index 3dea4aa14..f88d110f7 100644
--- a/src/index.h
+++ b/src/index.h
@@ -56,7 +56,7 @@ extern int git_index_entry__cmp(const void *a, const void *b);
 extern int git_index_entry__cmp_icase(const void *a, const void *b);
 
 extern int git_index__find(
-	size_t *at_pos, git_index *index, const char *path, int path_len, int stage);
+	size_t *at_pos, git_index *index, const char *path, size_t path_len, int stage);
 
 extern void git_index__set_ignore_case(git_index *index, bool ignore_case);
 
diff --git a/src/pathspec.c b/src/pathspec.c
index bee320576..471488495 100644
--- a/src/pathspec.c
+++ b/src/pathspec.c
@@ -445,7 +445,7 @@ static int pathspec_match_from_iterator(
 		/* check if path is ignored and untracked */
 		if (index != NULL &&
 			git_iterator_current_is_ignored(iter) &&
-			git_index__find(NULL, index, entry->path, strlen(entry->path), GIT_INDEX_STAGE_ANY) < 0)
+			git_index__find(NULL, index, entry->path, 0, GIT_INDEX_STAGE_ANY) < 0)
 			continue;
 
 		/* mark the matched pattern as used */
diff --git a/src/repository.c b/src/repository.c
index 2c1b60266..44d0f0b7d 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1716,7 +1716,7 @@ cleanup:
 	return error;
 }
 
-int git_repository_message(git_buf *out,  git_repository *repo)
+int git_repository_message(git_buf *out, git_repository *repo)
 {
 	git_buf path = GIT_BUF_INIT;
 	struct stat st;
@@ -1731,10 +1731,10 @@ int git_repository_message(git_buf *out,  git_repository *repo)
 		if (errno == ENOENT)
 			error = GIT_ENOTFOUND;
 		giterr_set(GITERR_OS, "Could not access message file");
+	} else {
+		error = git_futils_readbuffer(out, git_buf_cstr(&path));
 	}
 
-	error = git_futils_readbuffer(out, git_buf_cstr(&path));
-
 	git_buf_free(&path);
 
 	return error;
diff --git a/tests/repo/head.c b/tests/repo/head.c
index 8ea9a0f42..127176d12 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -200,7 +200,7 @@ static void test_reflog(git_repository *repo, size_t idx,
 		const char *email, const char *message)
 {
 	git_reflog *log;
-	git_reflog_entry *entry;
+	const git_reflog_entry *entry;
 
 	cl_git_pass(git_reflog_read(&log, repo, "HEAD"));
 	entry = git_reflog_entry_byindex(log, idx);
diff --git a/tests/repo/message.c b/tests/repo/message.c
index 57e8e5f4d..87574590b 100644
--- a/tests/repo/message.c
+++ b/tests/repo/message.c
@@ -4,38 +4,36 @@
 #include "posix.h"
 
 static git_repository *_repo;
-static git_buf _path;
-static git_buf _actual;
 
 void test_repo_message__initialize(void)
 {
-        _repo = cl_git_sandbox_init("testrepo.git");
-	git_buf_init(&_actual, 0);
+	_repo = cl_git_sandbox_init("testrepo.git");
 }
 
 void test_repo_message__cleanup(void)
 {
-        cl_git_sandbox_cleanup();
-	git_buf_free(&_path);
-	git_buf_free(&_actual);
+	cl_git_sandbox_cleanup();
 }
 
 void test_repo_message__none(void)
 {
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(&_actual, _repo));
+	git_buf actual = GIT_BUF_INIT;
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(&actual, _repo));
 }
 
 void test_repo_message__message(void)
 {
+	git_buf path = GIT_BUF_INIT, actual = GIT_BUF_INIT;
 	const char expected[] = "Test\n\nThis is a test of the emergency broadcast system\n";
 
-	cl_git_pass(git_buf_joinpath(&_path, git_repository_path(_repo), "MERGE_MSG"));
-	cl_git_mkfile(git_buf_cstr(&_path), expected);
+	cl_git_pass(git_buf_joinpath(&path, git_repository_path(_repo), "MERGE_MSG"));
+	cl_git_mkfile(git_buf_cstr(&path), expected);
 
-	cl_git_pass(git_repository_message(&_actual, _repo));
-	cl_assert_equal_s(expected, _actual);
-	git_buf_free(&_actual);
+	cl_git_pass(git_repository_message(&actual, _repo));
+	cl_assert_equal_s(expected, git_buf_cstr(&actual));
+	git_buf_free(&actual);
 
-	cl_git_pass(p_unlink(git_buf_cstr(&_path)));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(&_actual, _repo));
+	cl_git_pass(p_unlink(git_buf_cstr(&path)));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_repository_message(&actual, _repo));
+	git_buf_free(&path);
 }
-- 
cgit v1.2.3


From 80c29fe93e968fd73e861546e1a4cf33b514e3f6 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 17 Jan 2014 10:45:11 -0800
Subject: Add git_commit_amend API

This adds an API to amend an existing commit, basically a shorthand
for creating a new commit filling in missing parameters from the
values of an existing commit.  As part of this, I also added a new
"sys" API to create a commit using a callback to get the parents.
This allowed me to rewrite all the other commit creation APIs so
that temporary allocations are no longer needed.
---
 include/git2/commit.h                  |  45 ++++++-
 include/git2/sys/commit.h              |  40 +++++-
 src/commit.c                           | 227 +++++++++++++++++++++++----------
 src/signature.c                        |   2 +
 tests/object/commit/commitstagedfile.c |  76 +++++++++++
 5 files changed, 314 insertions(+), 76 deletions(-)

diff --git a/include/git2/commit.h b/include/git2/commit.h
index 8b03df0a9..834330b5d 100644
--- a/include/git2/commit.h
+++ b/include/git2/commit.h
@@ -242,8 +242,8 @@ GIT_EXTERN(int) git_commit_nth_gen_ancestor(
 /**
  * Create new commit in the repository from a list of `git_object` pointers
  *
- * The message will not be cleaned up automatically. You can do that with
- * the `git_message_prettify()` function.
+ * The message will **not** be cleaned up automatically. You can do that
+ * with the `git_message_prettify()` function.
  *
  * @param id Pointer in which to store the OID of the newly created commit
  *
@@ -291,20 +291,20 @@ GIT_EXTERN(int) git_commit_create(
 	const char *message_encoding,
 	const char *message,
 	const git_tree *tree,
-	int parent_count,
+	size_t parent_count,
 	const git_commit *parents[]);
 
 /**
  * Create new commit in the repository using a variable argument list.
  *
- * The message will be cleaned up from excess whitespace and it will be made
- * sure that the last line ends with a '\n'.
+ * The message will **not** be cleaned up automatically. You can do that
+ * with the `git_message_prettify()` function.
  *
  * The parents for the commit are specified as a variable list of pointers
  * to `const git_commit *`. Note that this is a convenience method which may
  * not be safe to export for certain languages or compilers
  *
- * All other parameters remain the same at `git_commit_create()`.
+ * All other parameters remain the same as `git_commit_create()`.
  *
  * @see git_commit_create
  */
@@ -317,9 +317,40 @@ GIT_EXTERN(int) git_commit_create_v(
 	const char *message_encoding,
 	const char *message,
 	const git_tree *tree,
-	int parent_count,
+	size_t parent_count,
 	...);
 
+/**
+ * Amend an existing commit by replacing only non-NULL values.
+ *
+ * This creates a new commit that is exactly the same as the old commit,
+ * except that any non-NULL values will be updated.  The new commit has
+ * the same parents as the old commit.
+ *
+ * The `update_ref` value works as in the regular `git_commit_create()`,
+ * updating the ref to point to the newly rewritten commit.  If you want
+ * to amend a commit that is not currently the HEAD of the branch and then
+ * rewrite the following commits to reach a ref, pass this as NULL and
+ * update the rest of the commit chain and ref separately.
+ *
+ * Unlike `git_commit_create()`, the `author`, `committer`, `message`,
+ * `message_encoding`, and `tree` parameters can be NULL in which case this
+ * will use the values from the original `commit_to_amend`.
+ *
+ * All parameters have the same meanings as in `git_commit_create()`.
+ *
+ * @see git_commit_create
+ */
+GIT_EXTERN(int) git_commit_amend(
+	git_oid *id,
+	const git_commit *commit_to_amend,
+	const char *update_ref,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message,
+	const git_tree *tree);
+
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/include/git2/sys/commit.h b/include/git2/sys/commit.h
index c8ed56b66..627d3ae2e 100644
--- a/include/git2/sys/commit.h
+++ b/include/git2/sys/commit.h
@@ -21,16 +21,18 @@
 GIT_BEGIN_DECL
 
 /**
- * Create new commit in the repository from a list of `git_oid` values
+ * Create new commit in the repository from a list of `git_oid` values.
  *
  * See documentation for `git_commit_create()` for information about the
  * parameters, as the meaning is identical excepting that `tree` and
  * `parents` now take `git_oid`.  This is a dangerous API in that nor
  * the `tree`, neither the `parents` list of `git_oid`s are checked for
  * validity.
+ *
+ * @see git_commit_create
  */
 GIT_EXTERN(int) git_commit_create_from_ids(
-	git_oid *oid,
+	git_oid *id,
 	git_repository *repo,
 	const char *update_ref,
 	const git_signature *author,
@@ -38,9 +40,41 @@ GIT_EXTERN(int) git_commit_create_from_ids(
 	const char *message_encoding,
 	const char *message,
 	const git_oid *tree,
-	int parent_count,
+	size_t parent_count,
 	const git_oid *parents[]);
 
+/**
+ * Callback function to return parents for commit.
+ *
+ * This is invoked with the count of the number of parents processed so far
+ * along with the user supplied payload.  This should return a git_oid of
+ * the next parent or NULL if all parents have been provided.
+ */
+typedef const git_oid *(*git_commit_parent_callback)(size_t idx, void *payload);
+
+/**
+ * Create a new commit in the repository with an callback to supply parents.
+ *
+ * See documentation for `git_commit_create()` for information about the
+ * parameters, as the meaning is identical excepting that `tree` takes a
+ * `git_oid` and doesn't check for validity, and `parent_cb` is invoked
+ * with `parent_payload` and should return `git_oid` values or NULL to
+ * indicate that all parents are accounted for.
+ *
+ * @see git_commit_create
+ */
+GIT_EXTERN(int) git_commit_create_from_callback(
+	git_oid *id,
+	git_repository *repo,
+	const char *update_ref,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message,
+	const git_oid *tree,
+	git_commit_parent_callback parent_cb,
+	void *parent_payload);
+
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/src/commit.c b/src/commit.c
index d66cf0c6a..de50e772e 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -36,41 +36,8 @@ void git_commit__free(void *_commit)
 	git__free(commit);
 }
 
-int git_commit_create_v(
-	git_oid *oid,
-	git_repository *repo,
-	const char *update_ref,
-	const git_signature *author,
-	const git_signature *committer,
-	const char *message_encoding,
-	const char *message,
-	const git_tree *tree,
-	int parent_count,
-	...)
-{
-	va_list ap;
-	int i, res;
-	const git_commit **parents;
-
-	parents = git__malloc(parent_count * sizeof(git_commit *));
-	GITERR_CHECK_ALLOC(parents);
-
-	va_start(ap, parent_count);
-	for (i = 0; i < parent_count; ++i)
-		parents[i] = va_arg(ap, const git_commit *);
-	va_end(ap);
-
-	res = git_commit_create(
-		oid, repo, update_ref, author, committer,
-		message_encoding, message,
-		tree, parent_count, parents);
-
-	git__free((void *)parents);
-	return res;
-}
-
-int git_commit_create_from_ids(
-	git_oid *oid,
+int git_commit_create_from_callback(
+	git_oid *id,
 	git_repository *repo,
 	const char *update_ref,
 	const git_signature *author,
@@ -78,19 +45,20 @@ int git_commit_create_from_ids(
 	const char *message_encoding,
 	const char *message,
 	const git_oid *tree,
-	int parent_count,
-	const git_oid *parents[])
+	git_commit_parent_callback parent_cb,
+	void *parent_payload)
 {
 	git_buf commit = GIT_BUF_INIT;
-	int i;
+	size_t i = 0;
 	git_odb *odb;
+	const git_oid *parent;
 
-	assert(oid && repo && tree && parent_count >= 0);
+	assert(id && repo && tree && parent_cb);
 
 	git_oid__writebuf(&commit, "tree ", tree);
 
-	for (i = 0; i < parent_count; ++i)
-		git_oid__writebuf(&commit, "parent ", parents[i]);
+	while ((parent = parent_cb(i++, parent_payload)) != NULL)
+		git_oid__writebuf(&commit, "parent ", parent);
 
 	git_signature__writebuf(&commit, "author ", author);
 	git_signature__writebuf(&commit, "committer ", committer);
@@ -106,7 +74,7 @@ int git_commit_create_from_ids(
 	if (git_repository_odb__weakptr(&odb, repo) < 0)
 		goto on_error;
 
-	if (git_odb_write(oid, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT) < 0)
+	if (git_odb_write(id, odb, commit.ptr, commit.size, GIT_OBJ_COMMIT) < 0)
 		goto on_error;
 
 	git_buf_free(&commit);
@@ -117,7 +85,7 @@ int git_commit_create_from_ids(
 		const char *shortmsg;
 		git_buf reflog_msg = GIT_BUF_INIT;
 
-		if (git_commit_lookup(&c, repo, oid) < 0)
+		if (git_commit_lookup(&c, repo, id) < 0)
 			goto on_error;
 
 		shortmsg = git_commit_summary(c);
@@ -126,7 +94,7 @@ int git_commit_create_from_ids(
 				shortmsg);
 		git_commit_free(c);
 
-		error = git_reference__update_terminal(repo, update_ref, oid,
+		error = git_reference__update_terminal(repo, update_ref, id,
 				committer, git_buf_cstr(&reflog_msg));
 
 		git_buf_free(&reflog_msg);
@@ -141,8 +109,101 @@ on_error:
 	return -1;
 }
 
+typedef struct {
+	size_t total;
+	va_list args;
+} commit_parent_varargs;
+
+static const git_oid *commit_parent_from_varargs(size_t curr, void *payload)
+{
+	commit_parent_varargs *data = payload;
+	const git_commit *commit;
+	if (curr >= data->total)
+		return NULL;
+	commit = va_arg(data->args, const git_commit *);
+	return commit ? git_commit_id(commit) : NULL;
+}
+
+int git_commit_create_v(
+	git_oid *id,
+	git_repository *repo,
+	const char *update_ref,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message,
+	const git_tree *tree,
+	size_t parent_count,
+	...)
+{
+	int error = 0;
+	commit_parent_varargs data;
+
+	assert(tree && git_tree_owner(tree) == repo);
+
+	data.total = parent_count;
+	va_start(data.args, parent_count);
+
+	error = git_commit_create_from_callback(
+		id, repo, update_ref, author, committer,
+		message_encoding, message, git_tree_id(tree),
+		commit_parent_from_varargs, &data);
+
+	va_end(data.args);
+	return error;
+}
+
+typedef struct {
+	size_t total;
+	const git_oid **parents;
+} commit_parent_oids;
+
+static const git_oid *commit_parent_from_ids(size_t curr, void *payload)
+{
+	commit_parent_oids *data = payload;
+	return (curr < data->total) ? data->parents[curr] : NULL;
+}
+
+int git_commit_create_from_ids(
+	git_oid *id,
+	git_repository *repo,
+	const char *update_ref,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message,
+	const git_oid *tree,
+	size_t parent_count,
+	const git_oid *parents[])
+{
+	commit_parent_oids data = { parent_count, parents };
+
+	return git_commit_create_from_callback(
+		id, repo, update_ref, author, committer,
+		message_encoding, message, tree,
+		commit_parent_from_ids, &data);
+}
+
+typedef struct {
+	size_t total;
+	const git_commit **parents;
+	git_repository *repo;
+} commit_parent_data;
+
+static const git_oid *commit_parent_from_array(size_t curr, void *payload)
+{
+	commit_parent_data *data = payload;
+	const git_commit *commit;
+	if (curr >= data->total)
+		return NULL;
+	commit = data->parents[curr];
+	if (git_commit_owner(commit) != data->repo)
+		return NULL;
+	return git_commit_id(commit);
+}
+
 int git_commit_create(
-	git_oid *oid,
+	git_oid *id,
 	git_repository *repo,
 	const char *update_ref,
 	const git_signature *author,
@@ -150,31 +211,66 @@ int git_commit_create(
 	const char *message_encoding,
 	const char *message,
 	const git_tree *tree,
-	int parent_count,
+	size_t parent_count,
 	const git_commit *parents[])
 {
-	int retval, i;
-	const git_oid **parent_oids;
-
-	assert(parent_count >= 0);
-	assert(git_object_owner((const git_object *)tree) == repo);
+	commit_parent_data data = { parent_count, parents, repo };
 
-	parent_oids = git__malloc(parent_count * sizeof(git_oid *));
-	GITERR_CHECK_ALLOC(parent_oids);
+	assert(tree && git_tree_owner(tree) == repo);
 
-	for (i = 0; i < parent_count; ++i) {
-		assert(git_object_owner((const git_object *)parents[i]) == repo);
-		parent_oids[i] = git_object_id((const git_object *)parents[i]);
-	}
+	return git_commit_create_from_callback(
+		id, repo, update_ref, author, committer,
+		message_encoding, message, git_tree_id(tree),
+		commit_parent_from_array, &data);
+}
 
-	retval = git_commit_create_from_ids(
-		oid, repo, update_ref, author, committer,
-		message_encoding, message,
-		git_object_id((const git_object *)tree), parent_count, parent_oids);
+static const git_oid *commit_parent_for_amend(size_t curr, void *payload)
+{
+	const git_commit *commit_to_amend = payload;
+	if (curr >= git_array_size(commit_to_amend->parent_ids))
+		return NULL;
+	return git_array_get(commit_to_amend->parent_ids, curr);
+}
 
-	git__free((void *)parent_oids);
+int git_commit_amend(
+	git_oid *id,
+	const git_commit *commit_to_amend,
+	const char *update_ref,
+	const git_signature *author,
+	const git_signature *committer,
+	const char *message_encoding,
+	const char *message,
+	const git_tree *tree)
+{
+	git_repository *repo;
+	git_oid tree_id;
+
+	assert(id && commit_to_amend);
+
+	repo = git_commit_owner(commit_to_amend);
+
+	if (!author)
+		author = git_commit_author(commit_to_amend);
+	if (!committer)
+		committer = git_commit_committer(commit_to_amend);
+	if (!message_encoding)
+		message_encoding = git_commit_message_encoding(commit_to_amend);
+	if (!message)
+		message = git_commit_message(commit_to_amend);
+
+	if (!tree) {
+		git_tree *old_tree;
+		GITERR_CHECK_ERROR( git_commit_tree(&old_tree, commit_to_amend) );
+		git_oid_cpy(&tree_id, git_tree_id(old_tree));
+		git_tree_free(old_tree);
+	} else {
+		assert(git_tree_owner(tree) == repo);
+		git_oid_cpy(&tree_id, git_tree_id(tree));
+	}
 
-	return retval;
+	return git_commit_create_from_callback(
+		id, repo, update_ref, author, committer, message_encoding, message,
+		&tree_id, commit_parent_for_amend, (void *)commit_to_amend);
 }
 
 int git_commit__parse(void *_commit, git_odb_object *odb_obj)
@@ -314,10 +410,9 @@ const char *git_commit_summary(git_commit *commit)
 				git_buf_putc(&summary, *msg);
 		}
 
-		if (summary.asize == 0)
+		commit->summary = git_buf_detach(&summary);
+		if (!commit->summary)
 			commit->summary = git__strdup("");
-		else
-			commit->summary = git_buf_detach(&summary);
 	}
 
 	return commit->summary;
diff --git a/src/signature.c b/src/signature.c
index f658d6035..f501cd8b6 100644
--- a/src/signature.c
+++ b/src/signature.c
@@ -230,6 +230,8 @@ void git_signature__writebuf(git_buf *buf, const char *header, const git_signatu
 	int offset, hours, mins;
 	char sign;
 
+	assert(buf && sig);
+
 	offset = sig->when.offset;
 	sign = (sig->when.offset < 0) ? '-' : '+';
 
diff --git a/tests/object/commit/commitstagedfile.c b/tests/object/commit/commitstagedfile.c
index fbeeccbbd..3e7b3c02c 100644
--- a/tests/object/commit/commitstagedfile.c
+++ b/tests/object/commit/commitstagedfile.c
@@ -132,3 +132,79 @@ void test_object_commit_commitstagedfile__generate_predictable_object_ids(void)
 	git_tree_free(tree);
 	git_index_free(index);
 }
+
+static void assert_commit_tree_has_n_entries(git_commit *c, int count)
+{
+	git_tree *tree;
+	cl_git_pass(git_commit_tree(&tree, c));
+	cl_assert_equal_i(count, git_tree_entrycount(tree));
+	git_tree_free(tree);
+}
+
+static void assert_commit_is_head_(git_commit *c, const char *file, int line)
+{
+	git_commit *head;
+	cl_git_pass(git_revparse_single((git_object **)&head, repo, "HEAD"));
+	clar__assert(git_oid_equal(git_commit_id(c), git_commit_id(head)), file, line, "Commit is not the HEAD", NULL, 1);
+	git_commit_free(head);
+}
+#define assert_commit_is_head(C) assert_commit_is_head_((C),__FILE__,__LINE__)
+
+void test_object_commit_commitstagedfile__amend_commit(void)
+{
+	git_index *index;
+	git_oid old_oid, new_oid, tree_oid;
+	git_commit *old_commit, *new_commit;
+	git_tree *tree;
+
+	/* make a commit */
+
+	cl_git_mkfile("treebuilder/myfile", "This is a file\n");
+	cl_git_pass(git_repository_index(&index, repo));
+	cl_git_pass(git_index_add_bypath(index, "myfile"));
+	cl_repo_commit_from_index(&old_oid, repo, NULL, 0, "first commit");
+
+	cl_git_pass(git_commit_lookup(&old_commit, repo, &old_oid));
+
+	cl_assert_equal_i(0, git_commit_parentcount(old_commit));
+	assert_commit_tree_has_n_entries(old_commit, 1);
+	assert_commit_is_head(old_commit);
+
+	/* let's amend the message of the HEAD commit */
+
+	cl_git_pass(git_commit_amend(
+		&new_oid, old_commit, "HEAD", NULL, NULL, NULL, "Initial commit", NULL));
+
+	cl_git_pass(git_commit_lookup(&new_commit, repo, &new_oid));
+
+	cl_assert_equal_i(0, git_commit_parentcount(new_commit));
+	assert_commit_tree_has_n_entries(new_commit, 1);
+	assert_commit_is_head(new_commit);
+
+	git_commit_free(old_commit);
+	old_commit = new_commit;
+
+	/* let's amend the tree of that last commit */
+
+	cl_git_mkfile("treebuilder/anotherfile", "This is another file\n");
+	cl_git_pass(git_index_add_bypath(index, "anotherfile"));
+	cl_git_pass(git_index_write_tree(&tree_oid, index));
+	cl_git_pass(git_tree_lookup(&tree, repo, &tree_oid));
+	cl_assert_equal_i(2, git_tree_entrycount(tree));
+
+	cl_git_pass(git_commit_amend(
+		&new_oid, old_commit, "HEAD", NULL, NULL, NULL, "Initial commit", tree));
+	git_tree_free(tree);
+
+	cl_git_pass(git_commit_lookup(&new_commit, repo, &new_oid));
+
+	cl_assert_equal_i(0, git_commit_parentcount(new_commit));
+	assert_commit_tree_has_n_entries(new_commit, 2);
+	assert_commit_is_head(new_commit);
+
+	/* cleanup */
+
+	git_commit_free(old_commit);
+	git_commit_free(new_commit);
+	git_index_free(index);
+}
-- 
cgit v1.2.3


From 4f5a3f400be638de28fb7cc5d926cc79125d52f7 Mon Sep 17 00:00:00 2001
From: rocky-luo <rocky-luo@outlook.com>
Date: Sat, 8 Feb 2014 20:10:19 +0800
Subject: add example for diff with --numstat

---
 examples/diff.c | 46 ++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 38 insertions(+), 8 deletions(-)

diff --git a/examples/diff.c b/examples/diff.c
index daf5d7030..0a9b06453 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -39,6 +39,7 @@ struct opts {
 	git_diff_find_options findopts;
 	int color;
 	int cached;
+	int numstat;
 	git_diff_format_t format;
 	const char *treeish1;
 	const char *treeish2;
@@ -49,6 +50,7 @@ struct opts {
 static void parse_opts(struct opts *o, int argc, char *argv[]);
 static int color_printer(
 	const git_diff_delta*, const git_diff_hunk*, const git_diff_line*, void*);
+static void diff_print_numstat(git_diff *diff);
 
 int main(int argc, char *argv[])
 {
@@ -57,7 +59,7 @@ int main(int argc, char *argv[])
 	git_diff *diff;
 	struct opts o = {
 		GIT_DIFF_OPTIONS_INIT, GIT_DIFF_FIND_OPTIONS_INIT,
-		-1, 0, GIT_DIFF_FORMAT_PATCH, NULL, NULL, "."
+		-1, 0, 0, GIT_DIFF_FORMAT_PATCH, NULL, NULL, "."
 	};
 
 	git_threads_init();
@@ -117,15 +119,19 @@ int main(int argc, char *argv[])
 
 	/** Generate simple output using libgit2 display helper. */
 
-	if (o.color >= 0)
-		fputs(colors[0], stdout);
+	if (o.numstat == 1)
+		diff_print_numstat(diff);
+	else {
+		if (o.color >= 0)
+			fputs(colors[0], stdout);
 
-	check_lg2(
-		git_diff_print(diff, o.format, color_printer, &o.color),
-		"displaying diff", NULL);
+		check_lg2(
+			git_diff_print(diff, o.format, color_printer, &o.color),
+			"displaying diff", NULL);
 
-	if (o.color >= 0)
-		fputs(colors[0], stdout);
+		if (o.color >= 0)
+			fputs(colors[0], stdout);
+	}
 
 	/** Cleanup before exiting. */
 
@@ -228,6 +234,8 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 			o->diffopts.flags |= GIT_DIFF_INCLUDE_IGNORED;
 		else if (!strcmp(a, "--untracked"))
 			o->diffopts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
+		else if (!strcmp(a, "--numstat"))
+			o->numstat = 1;
 		else if (match_uint16_arg(
 				&o->findopts.rename_threshold, &args, "-M") ||
 			match_uint16_arg(
@@ -255,3 +263,25 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 			usage("Unknown command line argument", a);
 	}
 }
+
+/** Display diff output with "--numstat".*/
+static void diff_print_numstat(git_diff *diff)
+{
+	git_patch *out;
+	const git_diff_delta *delta;
+	size_t i;
+	size_t ndeltas;
+	size_t nadditions, ndeletions;
+	ndeltas = git_diff_num_deltas(diff);	
+	for (i = 0; i < ndeltas; i++){
+		check_lg2(
+			git_patch_from_diff(&out, diff, i),
+			"generating patch from diff", NULL);
+		check_lg2(
+			git_patch_line_stats(NULL, &nadditions, &ndeletions, out),
+			"generating the number of additions and deletions", NULL);
+		delta = git_patch_get_delta(out);
+		printf("%u	%u	%s\n", nadditions, ndeletions, delta->new_file.path);
+	}
+	git_patch_free(out);
+}
-- 
cgit v1.2.3


From 8086b78be05dbcffc80e8a87c15fc10bb7534547 Mon Sep 17 00:00:00 2001
From: rocky-luo <rocky-luo@outlook.com>
Date: Sun, 9 Feb 2014 21:08:42 +0800
Subject: replace 'out' with 'patch',replace the literal tabs with '\t'.

---
 examples/diff.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/examples/diff.c b/examples/diff.c
index 0a9b06453..abb9b7103 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -267,7 +267,7 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 /** Display diff output with "--numstat".*/
 static void diff_print_numstat(git_diff *diff)
 {
-	git_patch *out;
+	git_patch *patch;
 	const git_diff_delta *delta;
 	size_t i;
 	size_t ndeltas;
@@ -275,13 +275,13 @@ static void diff_print_numstat(git_diff *diff)
 	ndeltas = git_diff_num_deltas(diff);	
 	for (i = 0; i < ndeltas; i++){
 		check_lg2(
-			git_patch_from_diff(&out, diff, i),
+			git_patch_from_diff(&patch, diff, i),
 			"generating patch from diff", NULL);
 		check_lg2(
-			git_patch_line_stats(NULL, &nadditions, &ndeletions, out),
+			git_patch_line_stats(NULL, &nadditions, &ndeletions, patch),
 			"generating the number of additions and deletions", NULL);
-		delta = git_patch_get_delta(out);
-		printf("%u	%u	%s\n", nadditions, ndeletions, delta->new_file.path);
+		delta = git_patch_get_delta(patch);
+		printf("%u\t%u\t%s\n", nadditions, ndeletions, delta->new_file.path);
 	}
-	git_patch_free(out);
+	git_patch_free(patch);
 }
-- 
cgit v1.2.3


From fb6f4539d1de1f2c171d6be2e088b5b763f3e5f8 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 9 Feb 2014 12:36:24 -0800
Subject: Close files on file diff failure

Not closing the files on a diff failure ensures that clar
cleanup will fail on win32 because we still have the file open.
---
 tests/clar_libgit2.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c
index 50762cdb8..9a37ee4c1 100644
--- a/tests/clar_libgit2.c
+++ b/tests/clar_libgit2.c
@@ -468,6 +468,7 @@ void clar__assert_equal_file(
 			p_snprintf(
 				buf, sizeof(buf), "file content mismatch at byte %d",
 				(int)(total_bytes + pos));
+			p_close(fd);
 			clar__fail(file, line, buf, path, 1);
 		}
 
-- 
cgit v1.2.3


From f77127da12480c65caaddd2af655877978d1f5a7 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 9 Feb 2014 12:37:16 -0800
Subject: Tests for core.autocrlf and .gitattributes

---
 tests/checkout/crlf.c | 119 +++++++++++++++++++++++++++++++++++++++-----------
 tests/clar_libgit2.c  |   8 ++++
 tests/clar_libgit2.h  |   2 +
 3 files changed, 104 insertions(+), 25 deletions(-)

diff --git a/tests/checkout/crlf.c b/tests/checkout/crlf.c
index cba79432f..0d78ee039 100644
--- a/tests/checkout/crlf.c
+++ b/tests/checkout/crlf.c
@@ -18,19 +18,6 @@ void test_checkout_crlf__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-void test_checkout_crlf__detect_crlf_autocrlf_false(void)
-{
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
-	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
-
-	cl_repo_set_bool(g_repo, "core.autocrlf", false);
-
-	git_checkout_head(g_repo, &opts);
-
-	check_file_contents("./crlf/all-lf", ALL_LF_TEXT_RAW);
-	check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
-}
-
 void test_checkout_crlf__autocrlf_false_index_size_is_unfiltered_size(void)
 {
 	git_index *index;
@@ -100,18 +87,6 @@ void test_checkout_crlf__more_crlf_autocrlf_true(void)
 		check_file_contents("./crlf/more-crlf", MORE_CRLF_TEXT_AS_CRLF);
 }
 
-void test_checkout_crlf__all_crlf_autocrlf_true(void)
-{
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
-	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
-
-	cl_repo_set_bool(g_repo, "core.autocrlf", true);
-
-	git_checkout_head(g_repo, &opts);
-
-	check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
-}
-
 void test_checkout_crlf__autocrlf_true_index_size_is_filtered_size(void)
 {
 	git_index *index;
@@ -229,3 +204,97 @@ void test_checkout_crlf__with_ident(void)
 
 	git_index_free(index);
 }
+
+void test_checkout_crlf__autocrlf_false_no_attrs(void)
+{
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", false);
+
+	git_checkout_head(g_repo, &opts);
+
+	check_file_contents("./crlf/all-lf", ALL_LF_TEXT_RAW);
+	check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
+}
+
+void test_checkout_crlf__autocrlf_true_no_attrs(void)
+{
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", true);
+
+	git_checkout_head(g_repo, &opts);
+
+	if (GIT_EOL_NATIVE == GIT_EOL_CRLF) {
+		check_file_contents("./crlf/all-lf", ALL_LF_TEXT_AS_CRLF);
+		check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_AS_CRLF);
+	} else {
+		check_file_contents("./crlf/all-lf", ALL_LF_TEXT_RAW);
+		check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
+	}
+}
+
+void test_checkout_crlf__autocrlf_input_no_attrs(void)
+{
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+
+	cl_repo_set_string(g_repo, "core.autocrlf", "input");
+
+	git_checkout_head(g_repo, &opts);
+
+	check_file_contents("./crlf/all-lf", ALL_LF_TEXT_RAW);
+	check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
+}
+
+void test_checkout_crlf__autocrlf_false_text_auto_attr(void)
+{
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+
+	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", false);
+
+	git_checkout_head(g_repo, &opts);
+
+	check_file_contents("./crlf/all-lf", ALL_LF_TEXT_RAW);
+	check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
+}
+
+void test_checkout_crlf__autocrlf_true_text_auto_attr(void)
+{
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+
+	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", true);
+
+	git_checkout_head(g_repo, &opts);
+
+	if (GIT_EOL_NATIVE == GIT_EOL_CRLF) {
+		check_file_contents("./crlf/all-lf", ALL_LF_TEXT_AS_CRLF);
+		check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_AS_CRLF);
+	} else {
+		check_file_contents("./crlf/all-lf", ALL_LF_TEXT_RAW);
+		check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
+	}
+}
+
+void test_checkout_crlf__autocrlf_input_text_auto_attr(void)
+{
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+
+	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
+
+	cl_repo_set_string(g_repo, "core.autocrlf", "input");
+
+	git_checkout_head(g_repo, &opts);
+
+	check_file_contents("./crlf/all-lf", ALL_LF_TEXT_RAW);
+	check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
+}
diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c
index 9a37ee4c1..9b062ef78 100644
--- a/tests/clar_libgit2.c
+++ b/tests/clar_libgit2.c
@@ -420,6 +420,14 @@ int cl_repo_get_bool(git_repository *repo, const char *cfg)
 	return val;
 }
 
+void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value)
+{
+	git_config *config;
+	cl_git_pass(git_repository_config(&config, repo));
+	cl_git_pass(git_config_set_string(config, cfg, value));
+	git_config_free(config);
+}
+
 /* this is essentially the code from git__unescape modified slightly */
 static size_t strip_cr_from_buf(char *start, size_t len)
 {
diff --git a/tests/clar_libgit2.h b/tests/clar_libgit2.h
index b9ef5627e..915111244 100644
--- a/tests/clar_libgit2.h
+++ b/tests/clar_libgit2.h
@@ -116,4 +116,6 @@ void cl_repo_commit_from_index(
 void cl_repo_set_bool(git_repository *repo, const char *cfg, int value);
 int cl_repo_get_bool(git_repository *repo, const char *cfg);
 
+void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value);
+
 #endif
-- 
cgit v1.2.3


From 9780020b18307e3e6a4707fdf0807aa2ddbfcd40 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 9 Feb 2014 13:37:39 -0800
Subject: Tests for crlf filtering into the repository

---
 tests/index/crlf.c | 136 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 136 insertions(+)
 create mode 100644 tests/index/crlf.c

diff --git a/tests/index/crlf.c b/tests/index/crlf.c
new file mode 100644
index 000000000..cf69c6226
--- /dev/null
+++ b/tests/index/crlf.c
@@ -0,0 +1,136 @@
+#include "clar_libgit2.h"
+#include "../filter/crlf.h"
+
+#include "git2/checkout.h"
+#include "repository.h"
+#include "posix.h"
+
+#define FILE_CONTENTS_LF "one\ntwo\nthree\nfour\n"
+#define FILE_CONTENTS_CRLF "one\r\ntwo\r\nthree\r\nfour\r\n"
+
+#define FILE_OID_LF "f384549cbeb481e437091320de6d1f2e15e11b4a"
+#define FILE_OID_CRLF "7fbf4d847b191141d80f30c8ab03d2ad4cd543a9"
+
+static git_repository *g_repo;
+static git_index *g_index;
+
+void test_index_crlf__initialize(void)
+{
+	g_repo = cl_git_sandbox_init("crlf");
+	cl_git_pass(git_repository_index(&g_index, g_repo));
+}
+
+void test_index_crlf__cleanup(void)
+{
+	git_index_free(g_index);
+	cl_git_sandbox_cleanup();
+}
+
+void test_index_crlf__autocrlf_false_no_attrs(void)
+{
+	const git_index_entry *entry;
+	git_oid oid;
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", false);
+
+	cl_git_mkfile("./crlf/newfile.txt",
+		(GIT_EOL_NATIVE == GIT_EOL_CRLF) ? FILE_CONTENTS_CRLF : FILE_CONTENTS_LF);
+
+	cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
+	entry = git_index_get_bypath(g_index, "newfile.txt", 0);
+
+	cl_git_pass(git_oid_fromstr(&oid,
+		(GIT_EOL_NATIVE == GIT_EOL_CRLF) ? FILE_OID_CRLF : FILE_OID_LF));
+	cl_assert(git_oid_cmp(&oid, &entry->id) == 0);
+}
+
+void test_index_crlf__autocrlf_true_no_attrs(void)
+{
+	const git_index_entry *entry;
+	git_oid oid;
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", true);
+
+	cl_git_mkfile("./crlf/newfile.txt",
+		(GIT_EOL_NATIVE == GIT_EOL_CRLF) ? FILE_CONTENTS_CRLF : FILE_CONTENTS_LF);
+
+	cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
+	entry = git_index_get_bypath(g_index, "newfile.txt", 0);
+
+	cl_git_pass(git_oid_fromstr(&oid, FILE_OID_LF));
+	cl_assert(git_oid_cmp(&oid, &entry->id) == 0);
+}
+
+void test_index_crlf__autocrlf_input_no_attrs(void)
+{
+	const git_index_entry *entry;
+	git_oid oid;
+
+	cl_repo_set_string(g_repo, "core.autocrlf", "input");
+
+	cl_git_mkfile("./crlf/newfile.txt",
+		(GIT_EOL_NATIVE == GIT_EOL_CRLF) ? FILE_CONTENTS_CRLF : FILE_CONTENTS_LF);
+
+	cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
+	entry = git_index_get_bypath(g_index, "newfile.txt", 0);
+
+	cl_git_pass(git_oid_fromstr(&oid, FILE_OID_LF));
+	cl_assert(git_oid_cmp(&oid, &entry->id) == 0);
+}
+
+void test_index_crlf__autocrlf_false_text_auto_attr(void)
+{
+	const git_index_entry *entry;
+	git_oid oid;
+
+	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", false);
+
+	cl_git_mkfile("./crlf/newfile.txt",
+		(GIT_EOL_NATIVE == GIT_EOL_CRLF) ? FILE_CONTENTS_CRLF : FILE_CONTENTS_LF);
+
+	cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
+	entry = git_index_get_bypath(g_index, "newfile.txt", 0);
+
+	cl_git_pass(git_oid_fromstr(&oid, FILE_OID_LF));
+	cl_assert(git_oid_cmp(&oid, &entry->id) == 0);
+}
+
+void test_index_crlf__autocrlf_true_text_auto_attr(void)
+{
+	const git_index_entry *entry;
+	git_oid oid;
+
+	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", false);
+
+	cl_git_mkfile("./crlf/newfile.txt",
+		(GIT_EOL_NATIVE == GIT_EOL_CRLF) ? FILE_CONTENTS_CRLF : FILE_CONTENTS_LF);
+
+	cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
+	entry = git_index_get_bypath(g_index, "newfile.txt", 0);
+
+	cl_git_pass(git_oid_fromstr(&oid, FILE_OID_LF));
+	cl_assert(git_oid_cmp(&oid, &entry->id) == 0);
+}
+
+void test_index_crlf__autocrlf_input_text_auto_attr(void)
+{
+	const git_index_entry *entry;
+	git_oid oid;
+
+	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
+
+	cl_repo_set_string(g_repo, "core.autocrlf", "input");
+
+	cl_git_mkfile("./crlf/newfile.txt",
+		(GIT_EOL_NATIVE == GIT_EOL_CRLF) ? FILE_CONTENTS_CRLF : FILE_CONTENTS_LF);
+
+	cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
+	entry = git_index_get_bypath(g_index, "newfile.txt", 0);
+
+	cl_git_pass(git_oid_fromstr(&oid, FILE_OID_LF));
+	cl_assert(git_oid_cmp(&oid, &entry->id) == 0);
+}
-- 
cgit v1.2.3


From 66b2626c93532df3006232442b471b77f182a92b Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 9 Feb 2014 13:43:56 -0800
Subject: core.autocrlf=input w/ text=auto attr to workdir

---
 src/crlf.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/crlf.c b/src/crlf.c
index e1bd5572b..db69cab5c 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -269,7 +269,9 @@ static int crlf_check(
 	if (ca.crlf_action == GIT_CRLF_BINARY)
 		return GIT_PASSTHROUGH;
 
-	if (ca.crlf_action == GIT_CRLF_GUESS) {
+	if (ca.crlf_action == GIT_CRLF_GUESS ||
+		(ca.crlf_action == GIT_CRLF_AUTO &&
+		git_filter_source_mode(src) == GIT_FILTER_SMUDGE)) {
 		error = git_repository__cvar(
 			&ca.auto_crlf, git_filter_source_repo(src), GIT_CVAR_AUTO_CRLF);
 		if (error < 0)
@@ -277,6 +279,10 @@ static int crlf_check(
 
 		if (ca.auto_crlf == GIT_AUTO_CRLF_FALSE)
 			return GIT_PASSTHROUGH;
+
+		if (ca.auto_crlf == GIT_AUTO_CRLF_INPUT &&
+			git_filter_source_mode(src) == GIT_FILTER_SMUDGE)
+			return GIT_PASSTHROUGH;
 	}
 
 	*payload = git__malloc(sizeof(ca));
-- 
cgit v1.2.3


From 77ad67546492f6ebe2bf53efc867d040bcd2a6a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 10 Feb 2014 14:38:01 +0100
Subject: refs: conditional wording fixups

This addresses arrbee's concerns about wording in the conditional
reference udpate functions.
---
 include/git2/refs.h | 19 +++++++++++--------
 src/refdb_fs.c      |  5 ++---
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 970faf744..478878210 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -93,8 +93,9 @@ GIT_EXTERN(int) git_reference_dwim(git_reference **out, git_repository *repo, co
  * reference does not belong in the standard set (HEAD, branches and
  * remote-tracking branches) and it does not have a reflog.
  *
- * It will also return an error if the reference's value at the time
- * of updating does not match the one passed.
+ * It will return GIT_EMODIFIED if the reference's value at the time
+ * of updating does not match the one passed through `current_value`
+ * (i.e. if the ref has changed since the user read it).
  *
  * @param out Pointer to the newly created reference
  * @param repo Repository where that reference will live
@@ -103,9 +104,10 @@ GIT_EXTERN(int) git_reference_dwim(git_reference **out, git_repository *repo, co
  * @param force Overwrite existing references
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
+ * @param current_value The expected value of the reference when updating
  * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC, GIT_EMODIFIED or an error code
  */
-GIT_EXTERN(int) git_reference_symbolic_create_matching(git_reference **out, git_repository *repo, const char *name, const char *target, int force, const git_signature *signature, const char *log_message, const char *old_value);
+GIT_EXTERN(int) git_reference_symbolic_create_matching(git_reference **out, git_repository *repo, const char *name, const char *target, int force, const git_signature *signature, const char *log_message, const char *current_value);
 
 /**
  * Create a new symbolic reference.
@@ -210,8 +212,9 @@ GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo,
  * reference does not belong in the standard set (HEAD, branches and
  * remote-tracking branches) and and it does not have a reflog.
  *
- * It will also return an error if the reference's value at the time
- * of updating does not match the one passed.
+ * It will return GIT_EMODIFIED if the reference's value at the time
+ * of updating does not match the one passed through `current_id`
+ * (i.e. if the ref has changed since the user read it).
  *
  * @param out Pointer to the newly created reference
  * @param repo Repository where that reference will live
@@ -221,11 +224,11 @@ GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo,
  * @param force Overwrite existing references
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
- * @param old_id The old value which the reference should have
+ * @param current_id The expected value of the reference at the time of update
  * @return 0 on success, GIT_EMODIFIED if the value of the reference
  * has changed, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
  */
-GIT_EXTERN(int) git_reference_create_matching(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message, const git_oid *old_id);
+GIT_EXTERN(int) git_reference_create_matching(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message, const git_oid *current_id);
 
 /**
  * Get the OID pointed to by a direct reference.
@@ -350,7 +353,7 @@ GIT_EXTERN(int) git_reference_symbolic_set_target(
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
  * @return 0 on success, GIT_EMODIFIED if the value of the reference
- * has changed, or an error code
+ * has changed since it was read, or an error code
  */
 GIT_EXTERN(int) git_reference_set_target(
 	git_reference **out,
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index ea758deea..43682f40e 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1018,8 +1018,8 @@ static int refdb_fs_backend__delete(
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_buf loose_path = GIT_BUF_INIT;
-	size_t pack_pos
-;	git_filebuf file = GIT_FILEBUF_INIT;
+	size_t pack_pos;
+	git_filebuf file = GIT_FILEBUF_INIT;
 	int error = 0, cmp = 0;
 	bool loose_deleted = 0;
 
@@ -1029,7 +1029,6 @@ static int refdb_fs_backend__delete(
 		return error;
 
 	error = cmp_old_ref(&cmp, _backend, ref_name, old_id, old_target);
-	//git_filebuf_cleanup(&file);
 	if (error < 0)
 		goto cleanup;
 
-- 
cgit v1.2.3


From 15284a2c5a9185171bfd3acf18b6ab38a032c7af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 10 Feb 2014 14:52:28 +0100
Subject: refs: move current_id before the reflog parameters

Keep the reflog parameters as the last two, as they're the optional
parameters.
---
 include/git2/refs.h |  8 ++++----
 src/refs.c          | 16 ++++++++--------
 tests/refs/races.c  |  8 ++++----
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 478878210..a4e44c543 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -102,12 +102,12 @@ GIT_EXTERN(int) git_reference_dwim(git_reference **out, git_repository *repo, co
  * @param name The name of the reference
  * @param target The target of the reference
  * @param force Overwrite existing references
+ * @param current_value The expected value of the reference when updating
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
- * @param current_value The expected value of the reference when updating
  * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC, GIT_EMODIFIED or an error code
  */
-GIT_EXTERN(int) git_reference_symbolic_create_matching(git_reference **out, git_repository *repo, const char *name, const char *target, int force, const git_signature *signature, const char *log_message, const char *current_value);
+GIT_EXTERN(int) git_reference_symbolic_create_matching(git_reference **out, git_repository *repo, const char *name, const char *target, int force, const char *current_value, const git_signature *signature, const char *log_message);
 
 /**
  * Create a new symbolic reference.
@@ -222,13 +222,13 @@ GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo,
  * @param id The object id pointed to by the reference.
  * @param force Overwrite existing references
  * @param force Overwrite existing references
+ * @param current_id The expected value of the reference at the time of update
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
- * @param current_id The expected value of the reference at the time of update
  * @return 0 on success, GIT_EMODIFIED if the value of the reference
  * has changed, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
  */
-GIT_EXTERN(int) git_reference_create_matching(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_signature *signature, const char *log_message, const git_oid *current_id);
+GIT_EXTERN(int) git_reference_create_matching(git_reference **out, git_repository *repo, const char *name, const git_oid *id, int force, const git_oid *current_id, const git_signature *signature, const char *log_message);
 
 /**
  * Get the OID pointed to by a direct reference.
diff --git a/src/refs.c b/src/refs.c
index 3ba4b0a84..e63796c94 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -433,9 +433,9 @@ int git_reference_create_matching(
 	const char *name,
 	const git_oid *id,
 	int force,
+	const git_oid *old_id,
 	const git_signature *signature,
-	const char *log_message,
-	const git_oid *old_id)
+	const char *log_message)
 
 {
 	int error;
@@ -466,7 +466,7 @@ int git_reference_create(
 	const git_signature *signature,
 	const char *log_message)
 {
-        return git_reference_create_matching(ref_out, repo, name, id, force, signature, log_message, NULL);
+        return git_reference_create_matching(ref_out, repo, name, id, force, NULL, signature, log_message);
 }
 
 int git_reference_symbolic_create_matching(
@@ -475,9 +475,9 @@ int git_reference_symbolic_create_matching(
 	const char *name,
 	const char *target,
 	int force,
+	const char *old_target,
 	const git_signature *signature,
-	const char *log_message,
-	const char *old_target)
+	const char *log_message)
 {
 	int error;
 	git_signature *who = NULL;
@@ -507,7 +507,7 @@ int git_reference_symbolic_create(
 	const git_signature *signature,
 	const char *log_message)
 {
-	return git_reference_symbolic_create_matching(ref_out, repo, name, target, force, signature, log_message, NULL);
+	return git_reference_symbolic_create_matching(ref_out, repo, name, target, force, NULL, signature, log_message);
 }
 
 static int ensure_is_an_updatable_direct_reference(git_reference *ref)
@@ -536,7 +536,7 @@ int git_reference_set_target(
 	if ((error = ensure_is_an_updatable_direct_reference(ref)) < 0)
 		return error;
 
-	return git_reference_create_matching(out, repo, ref->name, id, 1, signature, log_message, &ref->target.oid);
+	return git_reference_create_matching(out, repo, ref->name, id, 1, &ref->target.oid, signature, log_message);
 }
 
 static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
@@ -563,7 +563,7 @@ int git_reference_symbolic_set_target(
 		return error;
 
 	return git_reference_symbolic_create_matching(
-		out, ref->db->repo, ref->name, target, 1, signature, log_message, ref->target.symbolic);
+		out, ref->db->repo, ref->name, target, 1, ref->target.symbolic, signature, log_message);
 }
 
 static int reference__rename(git_reference **out, git_reference *ref, const char *new_name, int force,
diff --git a/tests/refs/races.c b/tests/refs/races.c
index 02d57eff1..643290a8e 100644
--- a/tests/refs/races.c
+++ b/tests/refs/races.c
@@ -30,10 +30,10 @@ void test_refs_races__create_matching(void)
 	git_oid_fromstr(&id, commit_id);
 	git_oid_fromstr(&other_id, other_commit_id);
 
-	cl_git_fail_with(GIT_EMODIFIED, git_reference_create_matching(&ref, g_repo, refname, &other_id, 1, NULL, NULL, &other_id));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_create_matching(&ref, g_repo, refname, &other_id, 1, &other_id, NULL, NULL));
 
 	cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
-	cl_git_pass(git_reference_create_matching(&ref2, g_repo, refname, &other_id, 1, NULL, NULL, &id));
+	cl_git_pass(git_reference_create_matching(&ref2, g_repo, refname, &other_id, 1, &id, NULL, NULL));
 	cl_git_fail_with(GIT_EMODIFIED, git_reference_set_target(&ref3, ref, &other_id, NULL, NULL));
 
 	git_reference_free(ref);
@@ -49,7 +49,7 @@ void test_refs_races__symbolic_create_matching(void)
 	git_oid_fromstr(&id, commit_id);
 	git_oid_fromstr(&other_id, other_commit_id);
 
-	cl_git_fail_with(GIT_EMODIFIED, git_reference_symbolic_create_matching(&ref, g_repo, "HEAD", other_refname, 1, NULL, NULL, other_refname));
+	cl_git_fail_with(GIT_EMODIFIED, git_reference_symbolic_create_matching(&ref, g_repo, "HEAD", other_refname, 1, other_refname, NULL, NULL));
 
 	cl_git_pass(git_reference_lookup(&ref, g_repo, "HEAD"));
 	cl_git_pass(git_reference_symbolic_create_matching(&ref2, g_repo, "HEAD", other_refname, 1, NULL, NULL, refname));
@@ -86,7 +86,7 @@ void test_refs_races__delete(void)
 
 	/* We cannot delete an oid value that doesn't match */
 	cl_git_pass(git_reference_lookup(&ref, g_repo, refname));
-	cl_git_pass(git_reference_create_matching(&ref2, g_repo, refname, &other_id, 1, NULL, NULL, &id));
+	cl_git_pass(git_reference_create_matching(&ref2, g_repo, refname, &other_id, 1, &id, NULL, NULL));
 	cl_git_fail_with(GIT_EMODIFIED, git_reference_delete(ref));
 
 	git_reference_free(ref);
-- 
cgit v1.2.3


From b033f3a3f9a4abd1e6e0c217a1bd16ab768f90ff Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 11 Feb 2014 16:52:08 -0800
Subject: Never convert CRLF->LF

Core git performs no conversion on systems that use LF, emulate that.
---
 src/crlf.c | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)

diff --git a/src/crlf.c b/src/crlf.c
index db69cab5c..2480cc918 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -218,24 +218,11 @@ static int crlf_apply_to_workdir(
 	if (!workdir_ending)
 		return -1;
 
-	if (!strcmp("\n", workdir_ending)) {
-		if (ca->crlf_action == GIT_CRLF_GUESS && ca->auto_crlf)
-			return GIT_PASSTHROUGH;
-
-		if (git_buf_find(from, '\r') < 0)
-			return GIT_PASSTHROUGH;
-
-		if (git_buf_text_crlf_to_lf(to, from) < 0)
-			return -1;
-	} else {
-		/* only other supported option is lf->crlf conversion */
-		assert(!strcmp("\r\n", workdir_ending));
-
-		if (git_buf_text_lf_to_crlf(to, from) < 0)
-			return -1;
-	}
+	/* only LF->CRLF conversion is supported, do nothing on LF platforms */
+	if (strcmp(workdir_ending, "\r\n") != 0)
+		return GIT_PASSTHROUGH;
 
-	return 0;
+	return git_buf_text_lf_to_crlf(to, from);
 }
 
 static int crlf_check(
-- 
cgit v1.2.3


From 2a528bc088f566ad3301963304da8942400f261b Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@edwardthomson.com>
Date: Tue, 11 Feb 2014 19:05:13 -0600
Subject: Fix filter test for CRLF->LF issues

---
 tests/filter/blob.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/filter/blob.c b/tests/filter/blob.c
index 8dce6470a..48edb8405 100644
--- a/tests/filter/blob.c
+++ b/tests/filter/blob.c
@@ -41,7 +41,8 @@ void test_filter_blob__all_crlf(void)
 
 	cl_git_pass(git_blob_filtered_content(&buf, blob, "file.lf", 1));
 
-	cl_assert_equal_s(ALL_CRLF_TEXT_AS_LF, buf.ptr);
+	/* we never convert CRLF -> LF on platforms that have LF */
+	cl_assert_equal_s(ALL_CRLF_TEXT_AS_CRLF, buf.ptr);
 
 	git_buf_free(&buf);
 	git_blob_free(blob);
-- 
cgit v1.2.3


From 0197d4107a2996dc2ed4e98698e281c2d5fa44e1 Mon Sep 17 00:00:00 2001
From: "brian m. carlson" <sandals@crustytoothpaste.net>
Date: Sat, 15 Feb 2014 23:09:01 +0000
Subject: Check for EWOULDBLOCK as well as EAGAIN on write.

On some systems, notably HP PA-RISC systems running Linux or HP-UX,
EWOULDBLOCK and EAGAIN are not the same value.  POSIX (and these OSes) allow
EWOULDBLOCK to occur on write(2) (and send(2), etc.), so check explicitly
for this case as well as EAGAIN by defining and using a macro GIT_ISBLOCKED
that considers both.

The macro is necessary because MSYS does not provide EWOULDBLOCK and
compilation fails if an attempt is made to use it unconditionally.  On most
systems, where the two values are the same, the compiler will simply
optimize this check out and it will have no effect.
---
 src/posix.c | 2 +-
 src/posix.h | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/posix.c b/src/posix.c
index 525785f35..7b2962feb 100644
--- a/src/posix.c
+++ b/src/posix.c
@@ -189,7 +189,7 @@ int p_write(git_file fd, const void *buf, size_t cnt)
 		r = write(fd, b, cnt);
 #endif
 		if (r < 0) {
-			if (errno == EINTR || errno == EAGAIN)
+			if (errno == EINTR || GIT_ISBLOCKED(errno))
 				continue;
 			return -1;
 		}
diff --git a/src/posix.h b/src/posix.h
index 6d3a84eba..f85b1aebd 100644
--- a/src/posix.h
+++ b/src/posix.h
@@ -29,6 +29,15 @@
 #define O_CLOEXEC 0
 #endif
 
+/* Determine whether an errno value indicates that a read or write failed
+ * because the descriptor is blocked.
+ */
+#if defined(EWOULDBLOCK)
+#define GIT_ISBLOCKED(e) ((e) == EAGAIN || (e) == EWOULDBLOCK)
+#else
+#define GIT_ISBLOCKED(e) ((e) == EAGAIN)
+#endif
+
 typedef int git_file;
 
 /**
-- 
cgit v1.2.3


From 9bda5fb8c1fa5d69616477f43b511b6f717115ec Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 18 Feb 2014 14:05:30 -0800
Subject: Improve error propagation in shallow call

---
 src/repository.c     | 9 +++++----
 tests/repo/shallow.c | 6 ++++++
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/repository.c b/src/repository.c
index 9f0c2f68f..89ae32473 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -2001,9 +2001,10 @@ int git_repository_is_shallow(git_repository *repo)
 	error = git_path_lstat(path.ptr, &st);
 	git_buf_free(&path);
 
-	if (error == GIT_ENOTFOUND)
+	if (error == GIT_ENOTFOUND) {
+		giterr_clear();
 		return 0;
-	if (error < 0)
-		return -1;
-	return st.st_size == 0 ? 0 : 1;
+	}
+
+	return error < 0 ? error : st.st_size == 0 ? 0 : 1;
 }
diff --git a/tests/repo/shallow.c b/tests/repo/shallow.c
index 1cc66ae40..5aeaf2def 100644
--- a/tests/repo/shallow.c
+++ b/tests/repo/shallow.c
@@ -31,3 +31,9 @@ void test_repo_shallow__shallow_repo(void)
 	cl_assert_equal_i(1, git_repository_is_shallow(g_repo));
 }
 
+void test_repo_shallow__clears_errors(void)
+{
+	g_repo = cl_git_sandbox_init("testrepo.git");
+	cl_assert_equal_i(0, git_repository_is_shallow(g_repo));
+	cl_assert_equal_p(NULL, giterr_last());
+}
-- 
cgit v1.2.3


From 864535cf850973378c8283f62347055d2593c685 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Tue, 18 Feb 2014 14:07:42 -0800
Subject: Readability

---
 src/repository.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/repository.c b/src/repository.c
index 89ae32473..96ed30666 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -2006,5 +2006,7 @@ int git_repository_is_shallow(git_repository *repo)
 		return 0;
 	}
 
-	return error < 0 ? error : st.st_size == 0 ? 0 : 1;
+	if (error < 0)
+		return error;
+	return st.st_size == 0 ? 0 : 1;
 }
-- 
cgit v1.2.3


From 978a4ed5ebd3892731434e4023f20383f820c112 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 20 Feb 2014 11:00:31 -0800
Subject: Make git_oid_equal a non-inline API

---
 include/git2/oid.h | 5 +----
 src/oid.c          | 5 +++++
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/include/git2/oid.h b/include/git2/oid.h
index 384b656d7..1cfd4e5e2 100644
--- a/include/git2/oid.h
+++ b/include/git2/oid.h
@@ -167,10 +167,7 @@ GIT_EXTERN(int) git_oid_cmp(const git_oid *a, const git_oid *b);
  * @param b second oid structure.
  * @return true if equal, false otherwise
  */
-GIT_INLINE(int) git_oid_equal(const git_oid *a, const git_oid *b)
-{
-	return !git_oid_cmp(a, b);
-}
+GIT_EXTERN(int) git_oid_equal(const git_oid *a, const git_oid *b);
 
 /**
  * Compare the first 'len' hexadecimal characters (packets of 4 bits)
diff --git a/src/oid.c b/src/oid.c
index 567b6cf06..f74c43fe2 100644
--- a/src/oid.c
+++ b/src/oid.c
@@ -179,6 +179,11 @@ int git_oid_cmp(const git_oid *a, const git_oid *b)
 	return git_oid__cmp(a, b);
 }
 
+int git_oid_equal(const git_oid *a, const git_oid *b)
+{
+	return (git_oid__cmp(a, b) == 0);
+}
+
 int git_oid_ncmp(const git_oid *oid_a, const git_oid *oid_b, size_t len)
 {
 	const unsigned char *a = oid_a->id;
-- 
cgit v1.2.3


From 68a19ca9ffb685123038a8d16c0a59845f147778 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 20 Feb 2014 11:26:51 -0800
Subject: Clarify C compatibility policy

and a couple of other minor doc fixups.
---
 CONTRIBUTING.md | 26 +++++++++++++++++---------
 CONVENTIONS.md  | 21 ++++++++++++++-------
 README.md       | 10 +++++-----
 3 files changed, 36 insertions(+), 21 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 807cd5320..0ae75c7ce 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -5,9 +5,13 @@ your help.
 
 ## Licensing
 
-By contributing to libgit2, you agree to release your contribution under the terms of the license.
-For code under `examples`, this is governed by the [CC0 Public Domain Dedication](examples/COPYING).
-All other code is released under the [GPL v2 with linking exception](COPYING).
+By contributing to libgit2, you agree to release your contribution under
+the terms of the license.  Except for the `examples` directory, all code
+is released under the [GPL v2 with linking exception](COPYING).
+
+The `examples` code is governed by the
+[CC0 Public Domain Dedication](examples/COPYING), so that you may copy
+from them into your own application.
 
 ## Discussion & Chat
 
@@ -76,15 +80,19 @@ you're porting code *from* to see what you need to do.  As a general rule,
 MIT and BSD (3-clause) licenses are typically no problem.  Apache 2.0
 license typically doesn't work due to GPL incompatibility.
 
-If you are pulling in code from core Git, another project or code you've pulled from
-a forum / Stack Overflow then please flag this in your PR and also make sure you've
-given proper credit to the original author in the code snippet.
+If you are pulling in code from core Git, another project or code you've
+pulled from a forum / Stack Overflow then please flag this in your PR and
+also make sure you've given proper credit to the original author in the
+code snippet.
 
 ## Style Guide
 
-`libgit2` is written in [ANSI C](http://en.wikipedia.org/wiki/ANSI_C)
-(a.k.a. C89) with some specific conventions for function and type naming,
-code formatting, and testing.
+The public API of `libgit2` is [ANSI C](http://en.wikipedia.org/wiki/ANSI_C)
+(a.k.a. C89) compatible.  Internally, `libgit2` is written using a portable
+subset of C99 - in order to compiler with GCC, Clang, MSVC, etc., we keep
+local variable declarations at the tops of blocks only and avoid `//` style
+comments.  Additionally, `libgit2` follows some extra conventions for
+function and type naming, code formatting, and testing.
 
 We like to keep the source code consistent and easy to read.  Maintaining
 this takes some discipline, but it's been more than worth it.  Take a look
diff --git a/CONVENTIONS.md b/CONVENTIONS.md
index 59b41a2e6..5b8238a78 100644
--- a/CONVENTIONS.md
+++ b/CONVENTIONS.md
@@ -6,14 +6,18 @@ guidelines that should help with that.
 ## Compatibility
 
 `libgit2` runs on many different platforms with many different compilers.
-It is written in [ANSI C](http://en.wikipedia.org/wiki/ANSI_C) (a.k.a. C89)
-with some specific standards for function and type naming, code formatting,
-and testing.
 
-We try to avoid more recent extensions to maximize portability.  We also, to
-the greatest extent possible, try to avoid lots of `#ifdef`s inside the core
-code base.  This is somewhat unavoidable, but since it can really hamper
-maintainability, we keep it to a minimum.
+The public API of `libgit2` is [ANSI C](http://en.wikipedia.org/wiki/ANSI_C)
+(a.k.a. C89) compatible.
+
+Internally, `libgit2` is written using a portable subset of C99 - in order
+to maximize compatibility (e.g. with MSVC) we avoid certain C99
+extensions.  Specifically, we keep local variable declarations at the tops
+of blocks only and we avoid `//` style comments.
+
+Also, to the greatest extent possible, we try to avoid lots of `#ifdef`s
+inside the core code base.  This is somewhat unavoidable, but since it can
+really hamper maintainability, we keep it to a minimum.
 
 ## Match Surrounding Code
 
@@ -209,6 +213,9 @@ All inlined functions must be declared as:
 GIT_INLINE(result_type) git_modulename_functionname(arg_list);
 ```
 
+`GIT_INLINE` (or `inline`) should not be used in public headers in order
+to preserve ANSI C compatibility.
+
 ## Tests
 
 `libgit2` uses the [clar](https://github.com/vmg/clar) testing framework.
diff --git a/README.md b/README.md
index f814b8732..aa75bb093 100644
--- a/README.md
+++ b/README.md
@@ -20,17 +20,17 @@ Additionally, the example code has been released to the public domain (see the
 * API documentation: <http://libgit2.github.com/libgit2>
 * IRC: [#libgit2](irc://irc.freenode.net/libgit2) on irc.freenode.net.
 * Mailing list: The libgit2 mailing list was
-    traditionally hosted in Librelist but has been deprecated. We encourage you to 
+    traditionally hosted in Librelist but has been deprecated. We encourage you to
     [use StackOverflow](http://stackoverflow.com/questions/tagged/libgit2) instead for any questions regarding
-    the library, or [open an issue](https://github.com/libgit2/libgit2/issues) 
-    on GitHub for bug reports.  The mailing list archives are still available at 
+    the library, or [open an issue](https://github.com/libgit2/libgit2/issues)
+    on GitHub for bug reports.  The mailing list archives are still available at
     <http://librelist.com/browser/libgit2/>.
 
 
 What It Can Do
 ==============
 
-`libgit2` is already very usable and is being used in production for many applications including the GitHub.com site, in Plastic SCM 
+`libgit2` is already very usable and is being used in production for many applications including the GitHub.com site, in Plastic SCM
 and also powering Microsoft's Visual Studio tools for Git.  The library provides:
 
 * SHA conversions, formatting and shortening
@@ -65,7 +65,7 @@ Under Unix-like systems, like Linux, \*BSD and Mac OS X, libgit2 expects `pthrea
 they should be installed by default on all systems. Under Windows, libgit2 uses the native Windows API
 for threading.
 
-The `libgit2` library is built using `CMake 2.6+` (<http://www.cmake.org>) on all platforms.
+The `libgit2` library is built using [CMake](<http://www.cmake.org>) (version 2.6 or newer) on all platforms.
 
 On most systems you can build the library using the following commands
 
-- 
cgit v1.2.3


From 72556cc63ba93a187589921c6008caf92686ea9c Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 20 Feb 2014 14:27:10 -0800
Subject: Address PR comments

* Make GIT_INLINE an internal definition so it cannot be used in
  public headers
* Fix language in CONTRIBUTING
* Make index caps API use signed instead of unsigned values
---
 CONTRIBUTING.md       | 19 ++++++++++---------
 include/git2/common.h |  7 -------
 include/git2/index.h  | 12 ++++++------
 src/array.h           |  2 +-
 src/bitvec.h          |  2 +-
 src/common.h          |  7 +++++++
 src/index.c           |  4 ++--
 src/merge.c           |  2 +-
 src/vector.h          |  2 +-
 tests/repo/iterator.c |  2 +-
 10 files changed, 30 insertions(+), 29 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0ae75c7ce..06aa4c1dd 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -89,7 +89,7 @@ code snippet.
 
 The public API of `libgit2` is [ANSI C](http://en.wikipedia.org/wiki/ANSI_C)
 (a.k.a. C89) compatible.  Internally, `libgit2` is written using a portable
-subset of C99 - in order to compiler with GCC, Clang, MSVC, etc., we keep
+subset of C99 - in order to compile with GCC, Clang, MSVC, etc., we keep
 local variable declarations at the tops of blocks only and avoid `//` style
 comments.  Additionally, `libgit2` follows some extra conventions for
 function and type naming, code formatting, and testing.
@@ -109,14 +109,15 @@ are any unresolved issues to jump in on.  Also, here is a list of some
 smaller project ideas that could help you become familiar with the code
 base and make a nice first step:
 
-* Convert a `git_*modulename*_foreach()` callback-based iteration API
-  into a `git_*modulename*_iterator` object with a create/advance style
-  of API.  This helps folks writing language bindings and usually isn't
-  too complicated.
-* Write a new `examples/` program that mirrors a particular core git
-  command.  (See `examples/diff.c` for example.)  This lets you (and us)
-  easily exercise a particular facet of the API and measure compatability
-  and feature parity with core git.
+* Look at the `examples/` programs, find an existing one that mirrors a
+  core Git command and add a missing command-line option.  There are many
+  gaps right now and this helps demonstrate how to use the library.
+* Pick a Git command that is not emulates in `examples/` and write a new
+  example that mirrors the behavior.  Examples don't have to be perfect
+  emulations, but should demonstrate how to use the libgit2 APIs to get
+  results that are similar to Git commands.  This lets you (and us) easily
+  exercise a particular facet of the API and measure compatability and
+  feature parity with core git.
 * Submit a PR to clarify documentation! While we do try to document all of
   the APIs, your fresh eyes on the documentation will find areas that are
   confusing much more easily.
diff --git a/include/git2/common.h b/include/git2/common.h
index dca0c9c21..492715447 100644
--- a/include/git2/common.h
+++ b/include/git2/common.h
@@ -37,13 +37,6 @@
 # define GIT_EXTERN(type) extern type
 #endif
 
-/** Declare a function as always inlined. */
-#if defined(_MSC_VER)
-# define GIT_INLINE(type) static __inline type
-#else
-# define GIT_INLINE(type) static inline type
-#endif
-
 /** Declare a function's takes printf style arguments. */
 #ifdef __GNUC__
 # define GIT_FORMAT_PRINTF(a,b) __attribute__((format (printf, a, b)))
diff --git a/include/git2/index.h b/include/git2/index.h
index 4363a3b9b..ae919e133 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -120,10 +120,10 @@ typedef struct git_index_entry {
 
 /** Capabilities of system that affect index actions. */
 typedef enum {
-	GIT_INDEXCAP_IGNORE_CASE = 1u,
-	GIT_INDEXCAP_NO_FILEMODE = 2u,
-	GIT_INDEXCAP_NO_SYMLINKS = 4u,
-	GIT_INDEXCAP_FROM_OWNER  = ~0u
+	GIT_INDEXCAP_IGNORE_CASE = 1,
+	GIT_INDEXCAP_NO_FILEMODE = 2,
+	GIT_INDEXCAP_NO_SYMLINKS = 4,
+	GIT_INDEXCAP_FROM_OWNER  = -1,
 } git_indexcap_t;
 
 /** Callback for APIs that add/remove/update files matching pathspec */
@@ -206,7 +206,7 @@ GIT_EXTERN(git_repository *) git_index_owner(const git_index *index);
  * @param index An existing index object
  * @return A combination of GIT_INDEXCAP values
  */
-GIT_EXTERN(unsigned int) git_index_caps(const git_index *index);
+GIT_EXTERN(int) git_index_caps(const git_index *index);
 
 /**
  * Set index capabilities flags.
@@ -219,7 +219,7 @@ GIT_EXTERN(unsigned int) git_index_caps(const git_index *index);
  * @param caps A combination of GIT_INDEXCAP values
  * @return 0 on success, -1 on failure
  */
-GIT_EXTERN(int) git_index_set_caps(git_index *index, unsigned int caps);
+GIT_EXTERN(int) git_index_set_caps(git_index *index, int caps);
 
 /**
  * Update the contents of an existing index object in memory by reading
diff --git a/src/array.h b/src/array.h
index 1d4e1c224..f8a48722a 100644
--- a/src/array.h
+++ b/src/array.h
@@ -7,7 +7,7 @@
 #ifndef INCLUDE_array_h__
 #define INCLUDE_array_h__
 
-#include "util.h"
+#include "common.h"
 
 /*
  * Use this to declare a typesafe resizable array of items, a la:
diff --git a/src/bitvec.h b/src/bitvec.h
index fd6f0ccf8..544832d95 100644
--- a/src/bitvec.h
+++ b/src/bitvec.h
@@ -7,7 +7,7 @@
 #ifndef INCLUDE_bitvec_h__
 #define INCLUDE_bitvec_h__
 
-#include "util.h"
+#include "common.h"
 
 /*
  * This is a silly little fixed length bit vector type that will store
diff --git a/src/common.h b/src/common.h
index e315b5979..d389cf85d 100644
--- a/src/common.h
+++ b/src/common.h
@@ -10,6 +10,13 @@
 #include "git2/common.h"
 #include "cc-compat.h"
 
+/** Declare a function as always inlined. */
+#if defined(_MSC_VER)
+# define GIT_INLINE(type) static __inline type
+#else
+# define GIT_INLINE(type) static inline type
+#endif
+
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
diff --git a/src/index.c b/src/index.c
index aa1aebf8a..e0c0022e1 100644
--- a/src/index.c
+++ b/src/index.c
@@ -438,7 +438,7 @@ static int create_index_error(int error, const char *msg)
 	return error;
 }
 
-int git_index_set_caps(git_index *index, unsigned int caps)
+int git_index_set_caps(git_index *index, int caps)
 {
 	unsigned int old_ignore_case;
 
@@ -474,7 +474,7 @@ int git_index_set_caps(git_index *index, unsigned int caps)
 	return 0;
 }
 
-unsigned int git_index_caps(const git_index *index)
+int git_index_caps(const git_index *index)
 {
 	return ((index->ignore_case ? GIT_INDEXCAP_IGNORE_CASE : 0) |
 			(index->distrust_filemode ? GIT_INDEXCAP_NO_FILEMODE : 0) |
diff --git a/src/merge.c b/src/merge.c
index 97c147920..12ff1c91c 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2364,7 +2364,7 @@ done:
 int git_merge__indexes(git_repository *repo, git_index *index_new)
 {
 	git_index *index_repo = NULL;
-	unsigned int index_repo_caps = 0;
+	int index_repo_caps = 0;
 	git_vector paths = GIT_VECTOR_INIT;
 	size_t index_conflicts = 0, wd_conflicts = 0, conflicts, i;
 	char *path;
diff --git a/src/vector.h b/src/vector.h
index f8256853b..682b6ad27 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -7,7 +7,7 @@
 #ifndef INCLUDE_vector_h__
 #define INCLUDE_vector_h__
 
-#include "git2/common.h"
+#include "common.h"
 
 typedef int (*git_vector_cmp)(const void *, const void *);
 
diff --git a/tests/repo/iterator.c b/tests/repo/iterator.c
index 56b51852c..fb70a9ea0 100644
--- a/tests/repo/iterator.c
+++ b/tests/repo/iterator.c
@@ -156,7 +156,7 @@ void test_repo_iterator__index_icase(void)
 {
 	git_iterator *i;
 	git_index *index;
-	unsigned int caps;
+	int caps;
 
 	g_repo = cl_git_sandbox_init("icase");
 
-- 
cgit v1.2.3


From 5bda607c37e99d7257ace09fd8685b52d5f6ae85 Mon Sep 17 00:00:00 2001
From: Tobias Marquardt <tm@tobix.eu>
Date: Fri, 21 Feb 2014 01:09:44 +0100
Subject: Check if librt exists independent of OS, to be able to exclude librt
 on Android builds, even though it is a 'Linux'.

---
 CMakeLists.txt | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6f2a2bb82..d6b327503 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,6 +17,8 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 # Add find modules to the path
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/Modules/")
 
+INCLUDE(CheckLibraryExists)
+
 # Build options
 #
 OPTION( SONAME				"Set the (SO)VERSION of the target"		ON  )
@@ -78,7 +80,9 @@ FUNCTION(TARGET_OS_LIBRARIES target)
 	ELSEIF(CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)")
 		TARGET_LINK_LIBRARIES(${target} socket nsl)
 		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -lsocket -lnsl" PARENT_SCOPE)
-	ELSEIF(CMAKE_SYSTEM_NAME MATCHES "Linux")
+	ENDIF()
+	CHECK_LIBRARY_EXISTS(rt clock_gettime "time.h" NEED_LIBRT)
+	IF(NEED_LIBRT)
 		TARGET_LINK_LIBRARIES(${target} rt)
 		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -lrt" PARENT_SCOPE)
 	ENDIF()
-- 
cgit v1.2.3


From c254e2b641cffd47667de02f77e7f5ef3304841e Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 21 Feb 2014 08:55:30 -0800
Subject: Improve documentation for merging

---
 include/git2/merge.h | 160 ++++++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 127 insertions(+), 33 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 3ef27e3c7..b45d0fd5e 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -27,24 +27,47 @@ GIT_BEGIN_DECL
  * passed in via the `flags` value in the `git_merge_tree_opts`.
  */
 typedef enum {
-	/** Detect renames */
+	/**
+	 * Detect renames that occur between the common ancestor and the "ours"
+	 * side or the common ancestor and the "theirs" side.  This will enable
+	 * the ability to merge between a modified and renamed file.
+	 */
 	GIT_MERGE_TREE_FIND_RENAMES = (1 << 0),
 } git_merge_tree_flag_t;
 
 /**
- * Merge file options for `git_merge_trees_opts`.
+ * Merge file favor options for `git_merge_trees_opts` instruct the file-level
+ * merging functionality how to deal with conflicting regions of the files.
  */
 typedef enum {
-	/* Produce a conflict in a file when two similar regions are changed. */
+	/**
+	 * When a region of a file is changed in both branches, a conflict
+	 * will be recorded in the index so that `git_checkout` can produce
+	 * a merge file with conflict markers in the working directory.
+	 * This is the default.
+	 */
 	GIT_MERGE_FILE_FAVOR_NORMAL = 0,
 
-	/* Produce a file containing the "ours" side of conflicting regions. */
+	/**
+	 * When a region of a file is changed in both branches, the file
+	 * created in the index will contain the "ours" side of any conflicting
+	 * region.  The index will not record a conflict.
+	 */
 	GIT_MERGE_FILE_FAVOR_OURS = 1,
 
-	/* Produce a file containing the "theirs" side of conflicting regions. */
+	/**
+	 * When a region of a file is changed in both branches, the file
+	 * created in the index will contain the "theirs" side of any conflicting
+	 * region.  The index will not record a conflict.
+	 */
 	GIT_MERGE_FILE_FAVOR_THEIRS = 2,
 
-	/* Produce a file blending the sides in a union of conflicting regions */
+	/**
+	 * When a region of a file is changed in both branches, the file
+	 * created in the index will contain each unique line from each side,
+	 * which has the result of combining both files.  The index will not
+	 * record a conflict.
+	 */
 	GIT_MERGE_FILE_FAVOR_UNION = 3,
 } git_merge_file_favor_t;
 
@@ -53,18 +76,28 @@ typedef struct {
 	unsigned int version;
 	git_merge_tree_flag_t flags;
 
-	/** Similarity to consider a file renamed (default 50) */
+	/**
+	 * Similarity to consider a file renamed (default 50).  If
+	 * `GIT_MERGE_TREE_FIND_RENAMES` is enabled, added files will be compared
+	 * with deleted files to determine their similarity.  Files that are
+	 * more similar than the rename threshold (percentage-wise) will be
+	 * treated as a rename.
+	 */
 	unsigned int rename_threshold;
 
-	/** Maximum similarity sources to examine (overrides the
-	 * `merge.renameLimit` config) (default 200)
+	/**
+	 * Maximum similarity sources to examine for renames (default 200).
+	 * If the number of rename candidates (add / delete pairs) is greater
+	 * than this value, inexact rename detection is aborted.
+	 *
+	 * This setting overrides the `merge.renameLimit` configuration value.
 	 */
 	unsigned int target_limit;
 
 	/** Pluggable similarity metric; pass NULL to use internal metric */
 	git_diff_similarity_metric *metric;
 
-	/** Flags for automerging content. */
+	/** Flags for handling conflicting content. */
 	git_merge_file_favor_t file_favor;
 } git_merge_tree_opts;
 
@@ -74,20 +107,37 @@ typedef struct {
 
 /**
  * Option flags for `git_merge`.
- *
- * GIT_MERGE_NO_FASTFORWARD - Do not fast-forward.
  */
 typedef enum {
-	GIT_MERGE_NO_FASTFORWARD      = 1,
-	GIT_MERGE_FASTFORWARD_ONLY    = 2,
+	/**
+	 * The default behavior is to allow fast-forwards, returning
+	 * immediately with the commit ID to fast-forward to.
+	 */
+	GIT_MERGE_DEFAULT = 0,
+
+	/**
+	 * Do not fast-forward; perform a merge and prepare a merge result even
+	 * if the inputs are eligible for fast-forwarding.
+	 */
+	GIT_MERGE_NO_FASTFORWARD = 1,
+
+	/**
+	 * Ensure that the inputs are eligible for fast-forwarding, error if
+	 * a merge needs to be performed.
+	 */
+	GIT_MERGE_FASTFORWARD_ONLY = 2,
 } git_merge_flags_t;
 
 typedef struct {
 	unsigned int version;
 
+	/** Options for handling the commit-level merge. */
 	git_merge_flags_t merge_flags;
+
+	/** Options for handling the merges of individual files. */
 	git_merge_tree_opts merge_tree_opts;
 
+	/** Options for writing the merge result to the working directory. */
 	git_checkout_opts checkout_opts;
 } git_merge_opts;
 
@@ -102,7 +152,7 @@ typedef struct {
  * @param repo the repository where the commits exist
  * @param one one of the commits
  * @param two the other commit
- * @return Zero on success; GIT_ENOTFOUND or -1 on failure.
+ * @return 0 on success, GIT_ENOTFOUND if not found or error code
  */
 GIT_EXTERN(int) git_merge_base(
 	git_oid *out,
@@ -117,7 +167,7 @@ GIT_EXTERN(int) git_merge_base(
  * @param repo the repository where the commits exist
  * @param length The number of commits in the provided `input_array`
  * @param input_array oids of the commits
- * @return Zero on success; GIT_ENOTFOUND or -1 on failure.
+ * @return 0 on success, GIT_ENOTFOUND if not found or error code
  */
 GIT_EXTERN(int) git_merge_base_many(
 	git_oid *out,
@@ -126,12 +176,13 @@ GIT_EXTERN(int) git_merge_base_many(
 	const git_oid input_array[]);
 
 /**
- * Creates a `git_merge_head` from the given reference
+ * Creates a `git_merge_head` from the given reference.  The resulting
+ * git_merge_head must be freed with `git_merge_head_free`.
  *
  * @param out pointer to store the git_merge_head result in
  * @param repo repository that contains the given reference
  * @param ref reference to use as a merge input
- * @return zero on success, -1 on failure.
+ * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge_head_from_ref(
 	git_merge_head **out,
@@ -139,14 +190,15 @@ GIT_EXTERN(int) git_merge_head_from_ref(
 	git_reference *ref);
 
 /**
- * Creates a `git_merge_head` from the given fetch head data
+ * Creates a `git_merge_head` from the given fetch head data.  The resulting
+ * git_merge_head must be freed with `git_merge_head_free`.
  *
  * @param out pointer to store the git_merge_head result in
  * @param repo repository that contains the given commit
  * @param branch_name name of the (remote) branch
  * @param remote_url url of the remote
  * @param oid the commit object id to use as a merge input
- * @return zero on success, -1 on failure.
+ * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge_head_from_fetchhead(
 	git_merge_head **out,
@@ -156,12 +208,13 @@ GIT_EXTERN(int) git_merge_head_from_fetchhead(
 	const git_oid *oid);
 
 /**
- * Creates a `git_merge_head` from the given commit id
+ * Creates a `git_merge_head` from the given commit id.  The resulting
+ * git_merge_head must be freed with `git_merge_head_free`.
  *
  * @param out pointer to store the git_merge_head result in
  * @param repo repository that contains the given commit
  * @param id the commit object id to use as a merge input
- * @return zero on success, -1 on failure.
+ * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge_head_from_id(
 	git_merge_head **out,
@@ -169,7 +222,7 @@ GIT_EXTERN(int) git_merge_head_from_id(
 	const git_oid *id);
 
 /**
- * Frees a `git_merge_head`
+ * Frees a `git_merge_head`.
  *
  * @param head merge head to free
  */
@@ -178,7 +231,9 @@ GIT_EXTERN(void) git_merge_head_free(
 
 /**
  * Merge two trees, producing a `git_index` that reflects the result of
- * the merge.
+ * the merge.  The index may be written as-is to the working directory
+ * or checked out.  If the index is to be converted to a tree, the caller
+ * should resolve any conflicts that arose as part of the merge.
  *
  * The returned index must be freed explicitly with `git_index_free`.
  *
@@ -188,7 +243,7 @@ GIT_EXTERN(void) git_merge_head_free(
  * @param our_tree the tree that reflects the destination tree
  * @param their_tree the tree to merge in to `our_tree`
  * @param opts the merge tree options (or null for defaults)
- * @return zero on success, -1 on failure.
+ * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge_trees(
 	git_index **out,
@@ -200,7 +255,9 @@ GIT_EXTERN(int) git_merge_trees(
 
 /**
  * Merge two commits, producing a `git_index` that reflects the result of
- * the merge.
+ * the merge.  The index may be written as-is to the working directory
+ * or checked out.  If the index is to be converted to a tree, the caller
+ * should resolve any conflicts that arose as part of the merge.
  *
  * The returned index must be freed explicitly with `git_index_free`.
  *
@@ -209,7 +266,7 @@ GIT_EXTERN(int) git_merge_trees(
  * @param our_commit the commit that reflects the destination tree
  * @param their_commit the commit to merge in to `our_commit`
  * @param opts the merge tree options (or null for defaults)
- * @return zero on success, -1 on failure.
+ * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge_commits(
 	git_index **out,
@@ -219,13 +276,32 @@ GIT_EXTERN(int) git_merge_commits(
 	const git_merge_tree_opts *opts);
 
 /**
- * Merges the given commits into HEAD, producing a new commit.
+ * Merges the given commit(s) into HEAD and either returns immediately
+ * if there was no merge to perform (the specified commits have already
+ * been merged or would produce a fast-forward) or performs the merge
+ * and writes the results into the working directory.
+ *
+ * Callers should inspect the `git_merge_result`:
+ *
+ * If `git_merge_result_is_uptodate` is true, there is no work to perform.
+ *
+ * If `git_merge_result_is_fastforward` is true, the caller should update
+ * any necessary references to the commit ID returned by
+ * `git_merge_result_fastforward_id` and check that out in order to complete
+ * the fast-forward.
+ * 
+ * Otherwise, callers should inspect the resulting index, resolve any
+ * conflicts and prepare a commit.
+ *
+ * The resultant `git_merge_result` should be free with
+ * `git_merge_result_free`.
  *
  * @param out the results of the merge
  * @param repo the repository to merge
  * @param merge_heads the heads to merge into
  * @param merge_heads_len the number of heads to merge
- * @param flags merge flags
+ * @param opts merge options
+ * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge(
 	git_merge_result **out,
@@ -235,24 +311,42 @@ GIT_EXTERN(int) git_merge(
 	const git_merge_opts *opts);
 
 /**
- * Returns true if a merge is up-to-date (we were asked to merge the target
- * into itself.)
+ * Returns true if a merge is "up-to-date", meaning that the commit(s) 
+ * that were provided to `git_merge` are already included in `HEAD`
+ * and there is no work to do.
+ *
+ * @return true if the merge is up-to-date, false otherwise
  */
 GIT_EXTERN(int) git_merge_result_is_uptodate(git_merge_result *merge_result);
 
 /**
- * Returns true if a merge is eligible for fastforward
+ * Returns true if a merge is eligible to be "fast-forwarded", meaning that
+ * the commit that was provided to `git_merge` need not be merged, it can
+ * simply be checked out, because the current `HEAD` is the merge base of
+ * itself and the given commit.  To perform the fast-forward, the caller
+ * should check out the results of `git_merge_result_fastforward_id`.
+ * 
+ * This will never be true if `GIT_MERGE_NO_FASTFORWARD` is supplied as
+ * a merge option.
+ *
+ * @return true if the merge is fast-forwardable, false otherwise
  */
 GIT_EXTERN(int) git_merge_result_is_fastforward(git_merge_result *merge_result);
 
 /**
  * Gets the fast-forward OID if the merge was a fastforward.
  *
- * @param out the OID of the fast-forward
+ * @param out pointer to populate with the OID of the fast-forward
  * @param merge_result the results of the merge
+ * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge_result_fastforward_id(git_oid *out, git_merge_result *merge_result);
 
+/**
+ * Frees a `git_merge_result`.
+ *
+ * @param result merge result to free
+ */
 GIT_EXTERN(void) git_merge_result_free(git_merge_result *merge_result);
 
 /** @} */
-- 
cgit v1.2.3


From c7c833947ec7ac446761242c02d32916661daeb7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20Rub=C3=A9n?= <juanruben.segovia@gmail.com>
Date: Fri, 21 Feb 2014 00:22:07 +0100
Subject: Add option to limit blame to first parent

---
 examples/blame.c     | 5 +++++
 include/git2/blame.h | 2 ++
 src/blame_git.c      | 6 ++++--
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/examples/blame.c b/examples/blame.c
index 1f5db69a1..f04c41772 100644
--- a/examples/blame.c
+++ b/examples/blame.c
@@ -31,6 +31,7 @@ struct opts {
 	int M;
 	int start_line;
 	int end_line;
+	int F;
 };
 static void parse_opts(struct opts *o, int argc, char *argv[]);
 
@@ -52,6 +53,7 @@ int main(int argc, char *argv[])
 	parse_opts(&o, argc, argv);
 	if (o.M) blameopts.flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVES;
 	if (o.C) blameopts.flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_COPIES;
+	if (o.F) blameopts.flags |= GIT_BLAME_FIRST_PARENT;
 
 	/** Open the repository. */
 	check_lg2(git_repository_open_ext(&repo, ".", 0, NULL), "Couldn't open repository", NULL);
@@ -146,6 +148,7 @@ static void usage(const char *msg, const char *arg)
 	fprintf(stderr, "   -L <n,m>            process only line range n-m, counting from 1\n");
 	fprintf(stderr, "   -M                  find line moves within and across files\n");
 	fprintf(stderr, "   -C                  find line copies within and across files\n");
+	fprintf(stderr, "   -F                  only care about the first parent\n");
 	fprintf(stderr, "\n");
 	exit(1);
 }
@@ -174,6 +177,8 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 			o->M = 1;
 		else if (!strcasecmp(a, "-C"))
 			o->C = 1;
+		else if (!strcasecmp(a, "-F"))
+			o->F = 1;
 		else if (!strcasecmp(a, "-L")) {
 			i++; a = argv[i];
 			if (i >= argc) fatal("Not enough arguments to -L", NULL);
diff --git a/include/git2/blame.h b/include/git2/blame.h
index b98c6f0d7..873a94ddd 100644
--- a/include/git2/blame.h
+++ b/include/git2/blame.h
@@ -40,6 +40,8 @@ typedef enum {
 	 * commit (like `git blame -CCC`). Implies SAME_COMMIT_COPIES.
 	 * NOT IMPLEMENTED. */
 	GIT_BLAME_TRACK_COPIES_ANY_COMMIT_COPIES = (1<<3),
+
+	GIT_BLAME_FIRST_PARENT = (1<<4),
 } git_blame_flag_t;
 
 /**
diff --git a/src/blame_git.c b/src/blame_git.c
index 800f1f039..c275293c3 100644
--- a/src/blame_git.c
+++ b/src/blame_git.c
@@ -485,12 +485,14 @@ static void pass_blame(git_blame *blame, git_blame__origin *origin, uint32_t opt
 	git_blame__origin *sg_buf[16];
 	git_blame__origin *porigin, **sg_origin = sg_buf;
 
-	GIT_UNUSED(opt);
-
 	num_parents = git_commit_parentcount(commit);
 	if (!git_oid_cmp(git_commit_id(commit), &blame->options.oldest_commit))
 		/* Stop at oldest specified commit */
 		num_parents = 0;
+	else if (opt & GIT_BLAME_FIRST_PARENT)
+		/* Limit search to the first parent */
+		num_parents = 1;
+
 	if (!num_parents) {
 		git_oid_cpy(&blame->options.oldest_commit, git_commit_id(commit));
 		goto finish;
-- 
cgit v1.2.3


From 9e3b901aeb3c3dc4b0bb442745ca59bb7e894f76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20Rub=C3=A9n?= <juanruben.segovia@gmail.com>
Date: Mon, 24 Feb 2014 00:09:29 +0100
Subject: Add unit test

---
 tests/blame/simple.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/blame/simple.c b/tests/blame/simple.c
index 79bd56b83..18b3457af 100644
--- a/tests/blame/simple.c
+++ b/tests/blame/simple.c
@@ -303,3 +303,18 @@ void test_blame_simple__can_restrict_to_newish_commits(void)
 	check_blame_hunk_index(g_repo, g_blame, 0,  1, 1, 1, "be3563a", "branch_file.txt");
 	check_blame_hunk_index(g_repo, g_blame, 1,  2, 1, 0, "a65fedf", "branch_file.txt");
 }
+
+void test_blame_simple__can_restrict_to_first_parent_commits(void)
+{
+	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
+	opts.flags |= GIT_BLAME_FIRST_PARENT;
+
+	cl_git_pass(git_repository_open(&g_repo, cl_fixture("blametest.git")));
+
+	cl_git_pass(git_blame_file(&g_blame, g_repo, "b.txt", &opts));
+	cl_assert_equal_i(4, git_blame_get_hunk_count(g_blame));
+	check_blame_hunk_index(g_repo, g_blame, 0,  1, 4, 0, "da237394", "b.txt");
+	check_blame_hunk_index(g_repo, g_blame, 1,  5, 1, 0, "b99f7ac0", "b.txt");
+	check_blame_hunk_index(g_repo, g_blame, 2,  6, 5, 0, "63d671eb", "b.txt");
+	check_blame_hunk_index(g_repo, g_blame, 3, 11, 5, 0, "bc7c5ac2", "b.txt");
+}
-- 
cgit v1.2.3


From 0d8265c8af1b8ba11ed0818e81276239c47e11db Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Sat, 22 Feb 2014 09:25:41 -0800
Subject: Staticize file-local variables

---
 tests/blame/buffer.c | 4 ++--
 tests/index/addall.c | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/blame/buffer.c b/tests/blame/buffer.c
index 912ee9846..340b1dced 100644
--- a/tests/blame/buffer.c
+++ b/tests/blame/buffer.c
@@ -1,7 +1,7 @@
 #include "blame_helpers.h"
 
-git_repository *g_repo;
-git_blame *g_fileblame, *g_bufferblame;
+static git_repository *g_repo;
+static git_blame *g_fileblame, *g_bufferblame;
 
 void test_blame_buffer__initialize(void)
 {
diff --git a/tests/index/addall.c b/tests/index/addall.c
index 452733710..a7e2583b2 100644
--- a/tests/index/addall.c
+++ b/tests/index/addall.c
@@ -3,7 +3,7 @@
 #include "posix.h"
 #include "fileops.h"
 
-git_repository *g_repo = NULL;
+static git_repository *g_repo = NULL;
 #define TEST_DIR "addall"
 
 void test_index_addall__initialize(void)
-- 
cgit v1.2.3


From 8ac7da796b11b9e4d223cd8d1fe43dc538f7deaa Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Sat, 22 Feb 2014 10:15:11 -0800
Subject: Avoid casting warning

---
 src/diff_tform.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index dfb59a3f8..aac78e931 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -218,7 +218,7 @@ int git_diff_merge(git_diff *onto, const git_diff *from)
 int git_diff_find_similar__hashsig_for_file(
 	void **out, const git_diff_file *f, const char *path, void *p)
 {
-	git_hashsig_option_t opt = (git_hashsig_option_t)p;
+	git_hashsig_option_t opt = (git_hashsig_option_t)(long long)p;
 	int error = 0;
 
 	GIT_UNUSED(f);
@@ -235,7 +235,7 @@ int git_diff_find_similar__hashsig_for_file(
 int git_diff_find_similar__hashsig_for_buf(
 	void **out, const git_diff_file *f, const char *buf, size_t len, void *p)
 {
-	git_hashsig_option_t opt = (git_hashsig_option_t)p;
+	git_hashsig_option_t opt = (git_hashsig_option_t)(long long)p;
 	int error = 0;
 
 	GIT_UNUSED(f);
-- 
cgit v1.2.3


From b1f2c2e25587e57d4869530b7330d73308f70fe5 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Sat, 22 Feb 2014 10:18:42 -0800
Subject: Prevent icc warning

---
 src/index.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/index.c b/src/index.c
index e0c0022e1..2de3dfebb 100644
--- a/src/index.c
+++ b/src/index.c
@@ -2046,13 +2046,15 @@ static int write_index(git_index *index, git_filebuf *file)
 	git_oid hash_final;
 	struct index_header header;
 	bool is_extended;
+	uint32_t index_version_number;
 
 	assert(index && file);
 
 	is_extended = is_index_extended(index);
+	index_version_number = is_extended ? INDEX_VERSION_NUMBER_EXT : INDEX_VERSION_NUMBER;
 
 	header.signature = htonl(INDEX_HEADER_SIG);
-	header.version = htonl(is_extended ? INDEX_VERSION_NUMBER_EXT : INDEX_VERSION_NUMBER);
+	header.version = htonl(index_version_number);
 	header.entry_count = htonl((uint32_t)index->entries.length);
 
 	if (git_filebuf_write(file, &header, sizeof(struct index_header)) < 0)
-- 
cgit v1.2.3


From 899bd19a62c10be929103542aabbf8585de8aecd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20Rub=C3=A9n?= <juanruben.segovia@gmail.com>
Date: Mon, 24 Feb 2014 21:20:57 +0100
Subject: Document enumerator and rewording

---
 examples/blame.c     | 2 +-
 include/git2/blame.h | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/examples/blame.c b/examples/blame.c
index f04c41772..6bc0581ac 100644
--- a/examples/blame.c
+++ b/examples/blame.c
@@ -148,7 +148,7 @@ static void usage(const char *msg, const char *arg)
 	fprintf(stderr, "   -L <n,m>            process only line range n-m, counting from 1\n");
 	fprintf(stderr, "   -M                  find line moves within and across files\n");
 	fprintf(stderr, "   -C                  find line copies within and across files\n");
-	fprintf(stderr, "   -F                  only care about the first parent\n");
+	fprintf(stderr, "   -F                  follow only the first parent commits\n");
 	fprintf(stderr, "\n");
 	exit(1);
 }
diff --git a/include/git2/blame.h b/include/git2/blame.h
index 873a94ddd..4ad51ee50 100644
--- a/include/git2/blame.h
+++ b/include/git2/blame.h
@@ -40,7 +40,8 @@ typedef enum {
 	 * commit (like `git blame -CCC`). Implies SAME_COMMIT_COPIES.
 	 * NOT IMPLEMENTED. */
 	GIT_BLAME_TRACK_COPIES_ANY_COMMIT_COPIES = (1<<3),
-
+	/** Restrict the search of commits to those reachable following only the
+	 * first parents. */
 	GIT_BLAME_FIRST_PARENT = (1<<4),
 } git_blame_flag_t;
 
-- 
cgit v1.2.3


From c8893d1f00a7897c6fada3ecc21eabe5c1af9cb0 Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Mon, 24 Feb 2014 13:39:04 -0800
Subject: Use a portable cast

---
 src/diff_tform.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/diff_tform.c b/src/diff_tform.c
index aac78e931..97fbc2883 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -218,7 +218,7 @@ int git_diff_merge(git_diff *onto, const git_diff *from)
 int git_diff_find_similar__hashsig_for_file(
 	void **out, const git_diff_file *f, const char *path, void *p)
 {
-	git_hashsig_option_t opt = (git_hashsig_option_t)(long long)p;
+	git_hashsig_option_t opt = (git_hashsig_option_t)(intptr_t)p;
 	int error = 0;
 
 	GIT_UNUSED(f);
@@ -235,7 +235,7 @@ int git_diff_find_similar__hashsig_for_file(
 int git_diff_find_similar__hashsig_for_buf(
 	void **out, const git_diff_file *f, const char *buf, size_t len, void *p)
 {
-	git_hashsig_option_t opt = (git_hashsig_option_t)(long long)p;
+	git_hashsig_option_t opt = (git_hashsig_option_t)(intptr_t)p;
 	int error = 0;
 
 	GIT_UNUSED(f);
-- 
cgit v1.2.3


From 83634d38be2d0a1ac006d912216cd6787c2b1542 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@edwardthomson.com>
Date: Mon, 24 Feb 2014 17:43:10 -0800
Subject: Move system directory cache out of utils

---
 src/attr.c          |   8 +-
 src/config.c        |  10 +--
 src/config_file.c   |   4 +-
 src/fileops.c       | 220 ----------------------------------------------
 src/fileops.h       |  88 -------------------
 src/global.c        |   6 +-
 src/repository.c    |   3 +-
 src/settings.c      |  22 ++---
 src/sysdir.c        | 244 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/sysdir.h        | 101 ++++++++++++++++++++++
 tests/core/env.c    |  33 +++----
 tests/repo/config.c |   9 +-
 tests/repo/open.c   |   3 +-
 13 files changed, 396 insertions(+), 355 deletions(-)
 create mode 100644 src/sysdir.c
 create mode 100644 src/sysdir.h

diff --git a/src/attr.c b/src/attr.c
index 15ed5c9e0..d8a171d0f 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -1,6 +1,6 @@
 #include "common.h"
 #include "repository.h"
-#include "fileops.h"
+#include "sysdir.h"
 #include "config.h"
 #include "attr.h"
 #include "ignore.h"
@@ -589,7 +589,7 @@ static int collect_attr_files(
 	}
 
 	if ((flags & GIT_ATTR_CHECK_NO_SYSTEM) == 0) {
-		error = git_futils_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);
+		error = git_sysdir_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);
 		if (!error)
 			error = push_attr_file(repo, files, NULL, dir.ptr);
 		else if (error == GIT_ENOTFOUND) {
@@ -623,13 +623,13 @@ static int attr_cache__lookup_path(
 
 		/* expand leading ~/ as needed */
 		if (cfgval && cfgval[0] == '~' && cfgval[1] == '/' &&
-			!git_futils_find_global_file(&buf, &cfgval[2]))
+			!git_sysdir_find_global_file(&buf, &cfgval[2]))
 			*out = git_buf_detach(&buf);
 		else if (cfgval)
 			*out = git__strdup(cfgval);
 
 	}
-	else if (!git_futils_find_xdg_file(&buf, fallback))
+	else if (!git_sysdir_find_xdg_file(&buf, fallback))
 		*out = git_buf_detach(&buf);
 
 	git_buf_free(&buf);
diff --git a/src/config.c b/src/config.c
index 6aa71468a..ae093ed64 100644
--- a/src/config.c
+++ b/src/config.c
@@ -6,7 +6,7 @@
  */
 
 #include "common.h"
-#include "fileops.h"
+#include "sysdir.h"
 #include "config.h"
 #include "git2/config.h"
 #include "git2/sys/config.h"
@@ -937,17 +937,17 @@ void git_config_iterator_free(git_config_iterator *iter)
 
 int git_config_find_global(git_buf *path)
 {
-	return git_futils_find_global_file(path, GIT_CONFIG_FILENAME_GLOBAL);
+	return git_sysdir_find_global_file(path, GIT_CONFIG_FILENAME_GLOBAL);
 }
 
 int git_config_find_xdg(git_buf *path)
 {
-	return git_futils_find_xdg_file(path, GIT_CONFIG_FILENAME_XDG);
+	return git_sysdir_find_xdg_file(path, GIT_CONFIG_FILENAME_XDG);
 }
 
 int git_config_find_system(git_buf *path)
 {
-	return git_futils_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
+	return git_sysdir_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
 }
 
 int git_config__global_location(git_buf *buf)
@@ -956,7 +956,7 @@ int git_config__global_location(git_buf *buf)
 	const char *sep, *start;
 	size_t len;
 
-	if (git_futils_dirs_get(&paths, GIT_FUTILS_DIR_GLOBAL) < 0)
+	if (git_sysdir_get(&paths, GIT_SYSDIR_GLOBAL) < 0)
 		return -1;
 
 	/* no paths, so give up */
diff --git a/src/config_file.c b/src/config_file.c
index c7727c029..aedf2cb12 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -7,8 +7,8 @@
 
 #include "common.h"
 #include "config.h"
-#include "fileops.h"
 #include "filebuf.h"
+#include "sysdir.h"
 #include "buffer.h"
 #include "buf_text.h"
 #include "git2/config.h"
@@ -1003,7 +1003,7 @@ static int included_path(git_buf *out, const char *dir, const char *path)
 {
 	/* From the user's home */
 	if (path[0] == '~' && path[1] == '/')
-		return git_futils_find_global_file(out, &path[1]);
+		return git_sysdir_find_global_file(out, &path[1]);
 
 	return git_path_join_unrooted(out, path, dir, NULL);
 }
diff --git a/src/fileops.c b/src/fileops.c
index a60689f3f..5709499b0 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -558,226 +558,6 @@ int git_futils_rmdir_r(
 	return error;
 }
 
-
-static int git_futils_guess_system_dirs(git_buf *out)
-{
-#ifdef GIT_WIN32
-	return git_win32__find_system_dirs(out, L"etc\\");
-#else
-	return git_buf_sets(out, "/etc");
-#endif
-}
-
-static int git_futils_guess_global_dirs(git_buf *out)
-{
-#ifdef GIT_WIN32
-	return git_win32__find_global_dirs(out);
-#else
-	return git_buf_sets(out, getenv("HOME"));
-#endif
-}
-
-static int git_futils_guess_xdg_dirs(git_buf *out)
-{
-#ifdef GIT_WIN32
-	return git_win32__find_xdg_dirs(out);
-#else
-	const char *env = NULL;
-
-	if ((env = getenv("XDG_CONFIG_HOME")) != NULL)
-		return git_buf_joinpath(out, env, "git");
-	else if ((env = getenv("HOME")) != NULL)
-		return git_buf_joinpath(out, env, ".config/git");
-
-	git_buf_clear(out);
-	return 0;
-#endif
-}
-
-static int git_futils_guess_template_dirs(git_buf *out)
-{
-#ifdef GIT_WIN32
-	return git_win32__find_system_dirs(out, L"share\\git-core\\templates");
-#else
-	return git_buf_sets(out, "/usr/share/git-core/templates");
-#endif
-}
-
-typedef int (*git_futils_dirs_guess_cb)(git_buf *out);
-
-static git_buf git_futils__dirs[GIT_FUTILS_DIR__MAX] =
-	{ GIT_BUF_INIT, GIT_BUF_INIT, GIT_BUF_INIT, GIT_BUF_INIT };
-
-static git_futils_dirs_guess_cb git_futils__dir_guess[GIT_FUTILS_DIR__MAX] = {
-	git_futils_guess_system_dirs,
-	git_futils_guess_global_dirs,
-	git_futils_guess_xdg_dirs,
-	git_futils_guess_template_dirs,
-};
-
-static int git_futils__dirs_shutdown_set = 0;
-
-void git_futils_dirs_global_shutdown(void)
-{
-	int i;
-	for (i = 0; i < GIT_FUTILS_DIR__MAX; ++i)
-		git_buf_free(&git_futils__dirs[i]);
-}
-
-int git_futils_dirs_global_init(void)
-{
-	git_futils_dir_t i;
-	const git_buf *path;
-	int error = 0;
-
-	for (i = 0; !error && i < GIT_FUTILS_DIR__MAX; i++)
-		error = git_futils_dirs_get(&path, i);
-
-	return error;
-}
-
-static int git_futils_check_selector(git_futils_dir_t which)
-{
-	if (which < GIT_FUTILS_DIR__MAX)
-		return 0;
-	giterr_set(GITERR_INVALID, "config directory selector out of range");
-	return -1;
-}
-
-int git_futils_dirs_get(const git_buf **out, git_futils_dir_t which)
-{
-	assert(out);
-
-	*out = NULL;
-
-	GITERR_CHECK_ERROR(git_futils_check_selector(which));
-
-	if (!git_buf_len(&git_futils__dirs[which])) {
-		/* prepare shutdown if we're going to need it */
-		if (!git_futils__dirs_shutdown_set) {
-			git__on_shutdown(git_futils_dirs_global_shutdown);
-			git_futils__dirs_shutdown_set = 1;
-		}
-
-		GITERR_CHECK_ERROR(
-			git_futils__dir_guess[which](&git_futils__dirs[which]));
-	}
-
-	*out = &git_futils__dirs[which];
-	return 0;
-}
-
-int git_futils_dirs_get_str(char *out, size_t outlen, git_futils_dir_t which)
-{
-	const git_buf *path = NULL;
-
-	GITERR_CHECK_ERROR(git_futils_check_selector(which));
-	GITERR_CHECK_ERROR(git_futils_dirs_get(&path, which));
-
-	if (!out || path->size >= outlen) {
-		giterr_set(GITERR_NOMEMORY, "Buffer is too short for the path");
-		return GIT_EBUFS;
-	}
-
-	git_buf_copy_cstr(out, outlen, path);
-	return 0;
-}
-
-#define PATH_MAGIC "$PATH"
-
-int git_futils_dirs_set(git_futils_dir_t which, const char *search_path)
-{
-	const char *expand_path = NULL;
-	git_buf merge = GIT_BUF_INIT;
-
-	GITERR_CHECK_ERROR(git_futils_check_selector(which));
-
-	if (search_path != NULL)
-		expand_path = strstr(search_path, PATH_MAGIC);
-
-	/* init with default if not yet done and needed (ignoring error) */
-	if ((!search_path || expand_path) &&
-		!git_buf_len(&git_futils__dirs[which]))
-		git_futils__dir_guess[which](&git_futils__dirs[which]);
-
-	/* if $PATH is not referenced, then just set the path */
-	if (!expand_path)
-		return git_buf_sets(&git_futils__dirs[which], search_path);
-
-	/* otherwise set to join(before $PATH, old value, after $PATH) */
-	if (expand_path > search_path)
-		git_buf_set(&merge, search_path, expand_path - search_path);
-
-	if (git_buf_len(&git_futils__dirs[which]))
-		git_buf_join(&merge, GIT_PATH_LIST_SEPARATOR,
-			merge.ptr, git_futils__dirs[which].ptr);
-
-	expand_path += strlen(PATH_MAGIC);
-	if (*expand_path)
-		git_buf_join(&merge, GIT_PATH_LIST_SEPARATOR, merge.ptr, expand_path);
-
-	git_buf_swap(&git_futils__dirs[which], &merge);
-	git_buf_free(&merge);
-
-	return git_buf_oom(&git_futils__dirs[which]) ? -1 : 0;
-}
-
-static int git_futils_find_in_dirlist(
-	git_buf *path, const char *name, git_futils_dir_t which, const char *label)
-{
-	size_t len;
-	const char *scan, *next = NULL;
-	const git_buf *syspath;
-
-	GITERR_CHECK_ERROR(git_futils_dirs_get(&syspath, which));
-
-	for (scan = git_buf_cstr(syspath); scan; scan = next) {
-		for (next = strchr(scan, GIT_PATH_LIST_SEPARATOR);
-			 next && next > scan && next[-1] == '\\';
-			 next = strchr(next + 1, GIT_PATH_LIST_SEPARATOR))
-			/* find unescaped separator or end of string */;
-
-		len = next ? (size_t)(next++ - scan) : strlen(scan);
-		if (!len)
-			continue;
-
-		GITERR_CHECK_ERROR(git_buf_set(path, scan, len));
-		if (name)
-			GITERR_CHECK_ERROR(git_buf_joinpath(path, path->ptr, name));
-
-		if (git_path_exists(path->ptr))
-			return 0;
-	}
-
-	git_buf_clear(path);
-	giterr_set(GITERR_OS, "The %s file '%s' doesn't exist", label, name);
-	return GIT_ENOTFOUND;
-}
-
-int git_futils_find_system_file(git_buf *path, const char *filename)
-{
-	return git_futils_find_in_dirlist(
-		path, filename, GIT_FUTILS_DIR_SYSTEM, "system");
-}
-
-int git_futils_find_global_file(git_buf *path, const char *filename)
-{
-	return git_futils_find_in_dirlist(
-		path, filename, GIT_FUTILS_DIR_GLOBAL, "global");
-}
-
-int git_futils_find_xdg_file(git_buf *path, const char *filename)
-{
-	return git_futils_find_in_dirlist(
-		path, filename, GIT_FUTILS_DIR_XDG, "global/xdg");
-}
-
-int git_futils_find_template_dir(git_buf *path)
-{
-	return git_futils_find_in_dirlist(
-		path, NULL, GIT_FUTILS_DIR_TEMPLATE, "template");
-}
-
 int git_futils_fake_symlink(const char *old, const char *new)
 {
 	int retcode = GIT_ERROR;
diff --git a/src/fileops.h b/src/fileops.h
index 636c9b67d..6a65235de 100644
--- a/src/fileops.h
+++ b/src/fileops.h
@@ -267,89 +267,6 @@ extern int git_futils_mmap_ro_file(
  */
 extern void git_futils_mmap_free(git_map *map);
 
-/**
- * Find a "global" file (i.e. one in a user's home directory).
- *
- * @param path buffer to write the full path into
- * @param filename name of file to find in the home directory
- * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error
- */
-extern int git_futils_find_global_file(git_buf *path, const char *filename);
-
-/**
- * Find an "XDG" file (i.e. one in user's XDG config path).
- *
- * @param path buffer to write the full path into
- * @param filename name of file to find in the home directory
- * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error
- */
-extern int git_futils_find_xdg_file(git_buf *path, const char *filename);
-
-/**
- * Find a "system" file (i.e. one shared for all users of the system).
- *
- * @param path buffer to write the full path into
- * @param filename name of file to find in the home directory
- * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error
- */
-extern int git_futils_find_system_file(git_buf *path, const char *filename);
-
-/**
- * Find template directory.
- *
- * @param path buffer to write the full path into
- * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error
- */
-extern int git_futils_find_template_dir(git_buf *path);
-
-typedef enum {
-	GIT_FUTILS_DIR_SYSTEM = 0,
-	GIT_FUTILS_DIR_GLOBAL = 1,
-	GIT_FUTILS_DIR_XDG    = 2,
-	GIT_FUTILS_DIR_TEMPLATE = 3,
-	GIT_FUTILS_DIR__MAX   = 4,
-} git_futils_dir_t;
-
-/**
- * Configures global data for configuration file search paths.
- *
- * @return 0 on success, <0 on failure
- */
-extern int git_futils_dirs_global_init(void);
-
-/**
- * Get the search path for global/system/xdg files
- *
- * @param out pointer to git_buf containing search path
- * @param which which list of paths to return
- * @return 0 on success, <0 on failure
- */
-extern int git_futils_dirs_get(const git_buf **out, git_futils_dir_t which);
-
-/**
- * Get search path into a preallocated buffer
- *
- * @param out String buffer to write into
- * @param outlen Size of string buffer
- * @param which Which search path to return
- * @return 0 on success, GIT_EBUFS if out is too small, <0 on other failure
- */
-
-extern int git_futils_dirs_get_str(
-	char *out, size_t outlen, git_futils_dir_t which);
-
-/**
- * Set search paths for global/system/xdg files
- *
- * The first occurrence of the magic string "$PATH" in the new value will
- * be replaced with the old value of the search path.
- *
- * @param which Which search path to modify
- * @param paths New search path (separated by GIT_PATH_LIST_SEPARATOR)
- * @return 0 on success, <0 on failure (allocation error)
- */
-extern int git_futils_dirs_set(git_futils_dir_t which, const char *paths);
-
 /**
  * Create a "fake" symlink (text file containing the target path).
  *
@@ -399,9 +316,4 @@ extern int git_futils_filestamp_check(
 extern void git_futils_filestamp_set(
 	git_futils_filestamp *tgt, const git_futils_filestamp *src);
 
-/**
- * Free the configuration file search paths.
- */
-extern void git_futils_dirs_global_shutdown(void);
-
 #endif /* INCLUDE_fileops_h__ */
diff --git a/src/global.c b/src/global.c
index 7d39c6fa8..8c8f55a90 100644
--- a/src/global.c
+++ b/src/global.c
@@ -7,7 +7,7 @@
 #include "common.h"
 #include "global.h"
 #include "hash.h"
-#include "fileops.h"
+#include "sysdir.h"
 #include "git2/threads.h"
 #include "thread-utils.h"
 
@@ -86,7 +86,7 @@ static int synchronized_threads_init()
 
 	/* Initialize any other subsystems that have global state */
 	if ((error = git_hash_global_init()) >= 0)
-		error = git_futils_dirs_global_init();
+		error = git_sysdir_global_init();
 
 	win32_pthread_initialize();
 
@@ -169,7 +169,7 @@ static void init_once(void)
 
 	/* Initialize any other subsystems that have global state */
 	if ((init_error = git_hash_global_init()) >= 0)
-		init_error = git_futils_dirs_global_init();
+		init_error = git_sysdir_global_init();
 
 	GIT_MEMORY_BARRIER;
 }
diff --git a/src/repository.c b/src/repository.c
index 96ed30666..610736607 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -17,6 +17,7 @@
 #include "tag.h"
 #include "blob.h"
 #include "fileops.h"
+#include "sysdir.h"
 #include "filebuf.h"
 #include "index.h"
 #include "config.h"
@@ -1265,7 +1266,7 @@ static int repo_init_structure(
 		}
 
 		if (!tdir) {
-			if (!(error = git_futils_find_template_dir(&template_buf)))
+			if (!(error = git_sysdir_find_template_dir(&template_buf)))
 				tdir = template_buf.ptr;
 			default_template = true;
 		}
diff --git a/src/settings.c b/src/settings.c
index 748f76560..92fc31456 100644
--- a/src/settings.c
+++ b/src/settings.c
@@ -9,7 +9,7 @@
 
 #include <git2.h>
 #include "common.h"
-#include "fileops.h"
+#include "sysdir.h"
 #include "cache.h"
 
 void git_libgit2_version(int *major, int *minor, int *rev)
@@ -38,14 +38,14 @@ int git_libgit2_capabilities()
 extern size_t git_mwindow__window_size;
 extern size_t git_mwindow__mapped_limit;
 
-static int config_level_to_futils_dir(int config_level)
+static int config_level_to_sysdir(int config_level)
 {
 	int val = -1;
 
 	switch (config_level) {
-	case GIT_CONFIG_LEVEL_SYSTEM: val = GIT_FUTILS_DIR_SYSTEM; break;
-	case GIT_CONFIG_LEVEL_XDG:    val = GIT_FUTILS_DIR_XDG; break;
-	case GIT_CONFIG_LEVEL_GLOBAL: val = GIT_FUTILS_DIR_GLOBAL; break;
+	case GIT_CONFIG_LEVEL_SYSTEM: val = GIT_SYSDIR_SYSTEM; break;
+	case GIT_CONFIG_LEVEL_XDG:    val = GIT_SYSDIR_XDG; break;
+	case GIT_CONFIG_LEVEL_GLOBAL: val = GIT_SYSDIR_GLOBAL; break;
 	default:
 		giterr_set(
 			GITERR_INVALID, "Invalid config path selector %d", config_level);
@@ -79,17 +79,17 @@ int git_libgit2_opts(int key, ...)
 		break;
 
 	case GIT_OPT_GET_SEARCH_PATH:
-		if ((error = config_level_to_futils_dir(va_arg(ap, int))) >= 0) {
+		if ((error = config_level_to_sysdir(va_arg(ap, int))) >= 0) {
 			char *out = va_arg(ap, char *);
 			size_t outlen = va_arg(ap, size_t);
 
-			error = git_futils_dirs_get_str(out, outlen, error);
+			error = git_sysdir_get_str(out, outlen, error);
 		}
 		break;
 
 	case GIT_OPT_SET_SEARCH_PATH:
-		if ((error = config_level_to_futils_dir(va_arg(ap, int))) >= 0)
-			error = git_futils_dirs_set(error, va_arg(ap, const char *));
+		if ((error = config_level_to_sysdir(va_arg(ap, int))) >= 0)
+			error = git_sysdir_set(error, va_arg(ap, const char *));
 		break;
 
 	case GIT_OPT_SET_CACHE_OBJECT_LIMIT:
@@ -118,12 +118,12 @@ int git_libgit2_opts(int key, ...)
 			char *out = va_arg(ap, char *);
 			size_t outlen = va_arg(ap, size_t);
 
-			error = git_futils_dirs_get_str(out, outlen, GIT_FUTILS_DIR_TEMPLATE);
+			error = git_sysdir_get_str(out, outlen, GIT_SYSDIR_TEMPLATE);
 		}
 		break;
 
 	case GIT_OPT_SET_TEMPLATE_PATH:
-		error = git_futils_dirs_set(GIT_FUTILS_DIR_TEMPLATE, va_arg(ap, const char *));
+		error = git_sysdir_set(GIT_SYSDIR_TEMPLATE, va_arg(ap, const char *));
 		break;
 	}
 
diff --git a/src/sysdir.c b/src/sysdir.c
new file mode 100644
index 000000000..2e6304e35
--- /dev/null
+++ b/src/sysdir.c
@@ -0,0 +1,244 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+#include "sysdir.h"
+#include "global.h"
+#include "buffer.h"
+#include "path.h"
+#include <ctype.h>
+#if GIT_WIN32
+#include "win32/findfile.h"
+#endif
+
+static int git_sysdir_guess_system_dirs(git_buf *out)
+{
+#ifdef GIT_WIN32
+	return git_win32__find_system_dirs(out, L"etc\\");
+#else
+	return git_buf_sets(out, "/etc");
+#endif
+}
+
+static int git_sysdir_guess_global_dirs(git_buf *out)
+{
+#ifdef GIT_WIN32
+	return git_win32__find_global_dirs(out);
+#else
+	return git_buf_sets(out, getenv("HOME"));
+#endif
+}
+
+static int git_sysdir_guess_xdg_dirs(git_buf *out)
+{
+#ifdef GIT_WIN32
+	return git_win32__find_xdg_dirs(out);
+#else
+	const char *env = NULL;
+
+	if ((env = getenv("XDG_CONFIG_HOME")) != NULL)
+		return git_buf_joinpath(out, env, "git");
+	else if ((env = getenv("HOME")) != NULL)
+		return git_buf_joinpath(out, env, ".config/git");
+
+	git_buf_clear(out);
+	return 0;
+#endif
+}
+
+static int git_sysdir_guess_template_dirs(git_buf *out)
+{
+#ifdef GIT_WIN32
+	return git_win32__find_system_dirs(out, L"share\\git-core\\templates");
+#else
+	return git_buf_sets(out, "/usr/share/git-core/templates");
+#endif
+}
+
+typedef int (*git_sysdir_guess_cb)(git_buf *out);
+
+static git_buf git_sysdir__dirs[GIT_SYSDIR__MAX] =
+	{ GIT_BUF_INIT, GIT_BUF_INIT, GIT_BUF_INIT, GIT_BUF_INIT };
+
+static git_sysdir_guess_cb git_sysdir__dir_guess[GIT_SYSDIR__MAX] = {
+	git_sysdir_guess_system_dirs,
+	git_sysdir_guess_global_dirs,
+	git_sysdir_guess_xdg_dirs,
+	git_sysdir_guess_template_dirs,
+};
+
+static int git_sysdir__dirs_shutdown_set = 0;
+
+int git_sysdir_global_init(void)
+{
+	git_sysdir_t i;
+	const git_buf *path;
+	int error = 0;
+
+	for (i = 0; !error && i < GIT_SYSDIR__MAX; i++)
+		error = git_sysdir_get(&path, i);
+
+	return error;
+}
+
+void git_sysdir_global_shutdown(void)
+{
+	int i;
+	for (i = 0; i < GIT_SYSDIR__MAX; ++i)
+		git_buf_free(&git_sysdir__dirs[i]);
+}
+
+static int git_sysdir_check_selector(git_sysdir_t which)
+{
+	if (which < GIT_SYSDIR__MAX)
+		return 0;
+
+	giterr_set(GITERR_INVALID, "config directory selector out of range");
+	return -1;
+}
+
+
+int git_sysdir_get(const git_buf **out, git_sysdir_t which)
+{
+	assert(out);
+
+	*out = NULL;
+
+	GITERR_CHECK_ERROR(git_sysdir_check_selector(which));
+
+	if (!git_buf_len(&git_sysdir__dirs[which])) {
+		/* prepare shutdown if we're going to need it */
+		if (!git_sysdir__dirs_shutdown_set) {
+			git__on_shutdown(git_sysdir_global_shutdown);
+			git_sysdir__dirs_shutdown_set = 1;
+		}
+
+		GITERR_CHECK_ERROR(
+			git_sysdir__dir_guess[which](&git_sysdir__dirs[which]));
+	}
+
+	*out = &git_sysdir__dirs[which];
+	return 0;
+}
+
+int git_sysdir_get_str(
+	char *out,
+	size_t outlen,
+	git_sysdir_t which)
+{
+	const git_buf *path = NULL;
+
+	GITERR_CHECK_ERROR(git_sysdir_check_selector(which));
+	GITERR_CHECK_ERROR(git_sysdir_get(&path, which));
+
+	if (!out || path->size >= outlen) {
+		giterr_set(GITERR_NOMEMORY, "Buffer is too short for the path");
+		return GIT_EBUFS;
+	}
+
+	git_buf_copy_cstr(out, outlen, path);
+	return 0;
+}
+
+#define PATH_MAGIC "$PATH"
+
+int git_sysdir_set(git_sysdir_t which, const char *search_path)
+{
+	const char *expand_path = NULL;
+	git_buf merge = GIT_BUF_INIT;
+
+	GITERR_CHECK_ERROR(git_sysdir_check_selector(which));
+
+	if (search_path != NULL)
+		expand_path = strstr(search_path, PATH_MAGIC);
+
+	/* init with default if not yet done and needed (ignoring error) */
+	if ((!search_path || expand_path) &&
+		!git_buf_len(&git_sysdir__dirs[which]))
+		git_sysdir__dir_guess[which](&git_sysdir__dirs[which]);
+
+	/* if $PATH is not referenced, then just set the path */
+	if (!expand_path)
+		return git_buf_sets(&git_sysdir__dirs[which], search_path);
+
+	/* otherwise set to join(before $PATH, old value, after $PATH) */
+	if (expand_path > search_path)
+		git_buf_set(&merge, search_path, expand_path - search_path);
+
+	if (git_buf_len(&git_sysdir__dirs[which]))
+		git_buf_join(&merge, GIT_PATH_LIST_SEPARATOR,
+			merge.ptr, git_sysdir__dirs[which].ptr);
+
+	expand_path += strlen(PATH_MAGIC);
+	if (*expand_path)
+		git_buf_join(&merge, GIT_PATH_LIST_SEPARATOR, merge.ptr, expand_path);
+
+	git_buf_swap(&git_sysdir__dirs[which], &merge);
+	git_buf_free(&merge);
+
+	return git_buf_oom(&git_sysdir__dirs[which]) ? -1 : 0;
+}
+
+static int git_sysdir_find_in_dirlist(
+	git_buf *path,
+	const char *name,
+	git_sysdir_t which,
+	const char *label)
+{
+	size_t len;
+	const char *scan, *next = NULL;
+	const git_buf *syspath;
+
+	GITERR_CHECK_ERROR(git_sysdir_get(&syspath, which));
+
+	for (scan = git_buf_cstr(syspath); scan; scan = next) {
+		for (next = strchr(scan, GIT_PATH_LIST_SEPARATOR);
+			 next && next > scan && next[-1] == '\\';
+			 next = strchr(next + 1, GIT_PATH_LIST_SEPARATOR))
+			/* find unescaped separator or end of string */;
+
+		len = next ? (size_t)(next++ - scan) : strlen(scan);
+		if (!len)
+			continue;
+
+		GITERR_CHECK_ERROR(git_buf_set(path, scan, len));
+		if (name)
+			GITERR_CHECK_ERROR(git_buf_joinpath(path, path->ptr, name));
+
+		if (git_path_exists(path->ptr))
+			return 0;
+	}
+
+	git_buf_clear(path);
+	giterr_set(GITERR_OS, "The %s file '%s' doesn't exist", label, name);
+	return GIT_ENOTFOUND;
+}
+
+int git_sysdir_find_system_file(git_buf *path, const char *filename)
+{
+	return git_sysdir_find_in_dirlist(
+		path, filename, GIT_SYSDIR_SYSTEM, "system");
+}
+
+int git_sysdir_find_global_file(git_buf *path, const char *filename)
+{
+	return git_sysdir_find_in_dirlist(
+		path, filename, GIT_SYSDIR_GLOBAL, "global");
+}
+
+int git_sysdir_find_xdg_file(git_buf *path, const char *filename)
+{
+	return git_sysdir_find_in_dirlist(
+		path, filename, GIT_SYSDIR_XDG, "global/xdg");
+}
+
+int git_sysdir_find_template_dir(git_buf *path)
+{
+	return git_sysdir_find_in_dirlist(
+		path, NULL, GIT_SYSDIR_TEMPLATE, "template");
+}
+
diff --git a/src/sysdir.h b/src/sysdir.h
new file mode 100644
index 000000000..f1bbf0bae
--- /dev/null
+++ b/src/sysdir.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_sysdir_h__
+#define INCLUDE_sysdir_h__
+
+#include "common.h"
+#include "posix.h"
+#include "buffer.h"
+
+/**
+ * Find a "global" file (i.e. one in a user's home directory).
+ *
+ * @param path buffer to write the full path into
+ * @param filename name of file to find in the home directory
+ * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error
+ */
+extern int git_sysdir_find_global_file(git_buf *path, const char *filename);
+
+/**
+ * Find an "XDG" file (i.e. one in user's XDG config path).
+ *
+ * @param path buffer to write the full path into
+ * @param filename name of file to find in the home directory
+ * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error
+ */
+extern int git_sysdir_find_xdg_file(git_buf *path, const char *filename);
+
+/**
+ * Find a "system" file (i.e. one shared for all users of the system).
+ *
+ * @param path buffer to write the full path into
+ * @param filename name of file to find in the home directory
+ * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error
+ */
+extern int git_sysdir_find_system_file(git_buf *path, const char *filename);
+
+/**
+ * Find template directory.
+ *
+ * @param path buffer to write the full path into
+ * @return 0 if found, GIT_ENOTFOUND if not found, or -1 on other OS error
+ */
+extern int git_sysdir_find_template_dir(git_buf *path);
+
+typedef enum {
+	GIT_SYSDIR_SYSTEM = 0,
+	GIT_SYSDIR_GLOBAL = 1,
+	GIT_SYSDIR_XDG    = 2,
+	GIT_SYSDIR_TEMPLATE = 3,
+	GIT_SYSDIR__MAX   = 4,
+} git_sysdir_t;
+
+/**
+ * Configures global data for configuration file search paths.
+ *
+ * @return 0 on success, <0 on failure
+ */
+extern int git_sysdir_global_init(void);
+
+/**
+ * Get the search path for global/system/xdg files
+ *
+ * @param out pointer to git_buf containing search path
+ * @param which which list of paths to return
+ * @return 0 on success, <0 on failure
+ */
+extern int git_sysdir_get(const git_buf **out, git_sysdir_t which);
+
+/**
+ * Get search path into a preallocated buffer
+ *
+ * @param out String buffer to write into
+ * @param outlen Size of string buffer
+ * @param which Which search path to return
+ * @return 0 on success, GIT_EBUFS if out is too small, <0 on other failure
+ */
+
+extern int git_sysdir_get_str(char *out, size_t outlen, git_sysdir_t which);
+
+/**
+ * Set search paths for global/system/xdg files
+ *
+ * The first occurrence of the magic string "$PATH" in the new value will
+ * be replaced with the old value of the search path.
+ *
+ * @param which Which search path to modify
+ * @param paths New search path (separated by GIT_PATH_LIST_SEPARATOR)
+ * @return 0 on success, <0 on failure (allocation error)
+ */
+extern int git_sysdir_set(git_sysdir_t which, const char *paths);
+
+/**
+ * Free the configuration file search paths.
+ */
+extern void git_sysdir_global_shutdown(void);
+
+#endif /* INCLUDE_sysdir_h__ */
diff --git a/tests/core/env.c b/tests/core/env.c
index 0fa6472d7..a32f5ed3e 100644
--- a/tests/core/env.c
+++ b/tests/core/env.c
@@ -1,5 +1,6 @@
 #include "clar_libgit2.h"
 #include "fileops.h"
+#include "sysdir.h"
 #include "path.h"
 
 #ifdef GIT_WIN32
@@ -41,12 +42,12 @@ void test_core_env__initialize(void)
 
 static void reset_global_search_path(void)
 {
-	cl_git_pass(git_futils_dirs_set(GIT_FUTILS_DIR_GLOBAL, NULL));
+	cl_git_pass(git_sysdir_set(GIT_SYSDIR_GLOBAL, NULL));
 }
 
 static void reset_system_search_path(void)
 {
-	cl_git_pass(git_futils_dirs_set(GIT_FUTILS_DIR_SYSTEM, NULL));
+	cl_git_pass(git_sysdir_set(GIT_SYSDIR_SYSTEM, NULL));
 }
 
 void test_core_env__cleanup(void)
@@ -120,18 +121,18 @@ void test_core_env__0(void)
 		git_buf_rtruncate_at_char(&path, '/');
 
 		cl_assert_equal_i(
-			GIT_ENOTFOUND, git_futils_find_global_file(&found, testfile));
+			GIT_ENOTFOUND, git_sysdir_find_global_file(&found, testfile));
 
 		setenv_and_check("HOME", path.ptr);
 		reset_global_search_path();
 
-		cl_git_pass(git_futils_find_global_file(&found, testfile));
+		cl_git_pass(git_sysdir_find_global_file(&found, testfile));
 
 		cl_setenv("HOME", env_save[0]);
 		reset_global_search_path();
 
 		cl_assert_equal_i(
-			GIT_ENOTFOUND, git_futils_find_global_file(&found, testfile));
+			GIT_ENOTFOUND, git_sysdir_find_global_file(&found, testfile));
 
 #ifdef GIT_WIN32
 		setenv_and_check("HOMEDRIVE", NULL);
@@ -139,7 +140,7 @@ void test_core_env__0(void)
 		setenv_and_check("USERPROFILE", path.ptr);
 		reset_global_search_path();
 
-		cl_git_pass(git_futils_find_global_file(&found, testfile));
+		cl_git_pass(git_sysdir_find_global_file(&found, testfile));
 
 		{
 			int root = git_path_root(path.ptr);
@@ -150,7 +151,7 @@ void test_core_env__0(void)
 				reset_global_search_path();
 
 				cl_assert_equal_i(
-					GIT_ENOTFOUND, git_futils_find_global_file(&found, testfile));
+					GIT_ENOTFOUND, git_sysdir_find_global_file(&found, testfile));
 
 				old = path.ptr[root];
 				path.ptr[root] = '\0';
@@ -159,7 +160,7 @@ void test_core_env__0(void)
 				setenv_and_check("HOMEPATH", &path.ptr[root]);
 				reset_global_search_path();
 
-				cl_git_pass(git_futils_find_global_file(&found, testfile));
+				cl_git_pass(git_sysdir_find_global_file(&found, testfile));
 			}
 		}
 #endif
@@ -177,7 +178,7 @@ void test_core_env__1(void)
 	git_buf path = GIT_BUF_INIT;
 
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_futils_find_global_file(&path, "nonexistentfile"));
+		GIT_ENOTFOUND, git_sysdir_find_global_file(&path, "nonexistentfile"));
 
 	cl_git_pass(cl_setenv("HOME", "doesnotexist"));
 #ifdef GIT_WIN32
@@ -187,7 +188,7 @@ void test_core_env__1(void)
 	reset_global_search_path();
 
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_futils_find_global_file(&path, "nonexistentfile"));
+		GIT_ENOTFOUND, git_sysdir_find_global_file(&path, "nonexistentfile"));
 
 	cl_git_pass(cl_setenv("HOME", NULL));
 #ifdef GIT_WIN32
@@ -198,17 +199,17 @@ void test_core_env__1(void)
 	reset_system_search_path();
 
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_futils_find_global_file(&path, "nonexistentfile"));
+		GIT_ENOTFOUND, git_sysdir_find_global_file(&path, "nonexistentfile"));
 
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_futils_find_system_file(&path, "nonexistentfile"));
+		GIT_ENOTFOUND, git_sysdir_find_system_file(&path, "nonexistentfile"));
 
 #ifdef GIT_WIN32
 	cl_git_pass(cl_setenv("PROGRAMFILES", NULL));
 	reset_system_search_path();
 
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_futils_find_system_file(&path, "nonexistentfile"));
+		GIT_ENOTFOUND, git_sysdir_find_system_file(&path, "nonexistentfile"));
 #endif
 
 	git_buf_free(&path);
@@ -242,13 +243,13 @@ static void check_global_searchpath(
 		cl_assert_equal_s(out, path);
 
 	/* find file using new path */
-	cl_git_pass(git_futils_find_global_file(temp, file));
+	cl_git_pass(git_sysdir_find_global_file(temp, file));
 
 	/* reset path and confirm file not found */
 	cl_git_pass(git_libgit2_opts(
 		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, NULL));
 	cl_assert_equal_i(
-		GIT_ENOTFOUND, git_futils_find_global_file(temp, file));
+		GIT_ENOTFOUND, git_sysdir_find_global_file(temp, file));
 }
 
 void test_core_env__2(void)
@@ -285,7 +286,7 @@ void test_core_env__2(void)
 
 		/* default should be NOTFOUND */
 		cl_assert_equal_i(
-			GIT_ENOTFOUND, git_futils_find_global_file(&found, testfile));
+			GIT_ENOTFOUND, git_sysdir_find_global_file(&found, testfile));
 
 		/* try plain, append $PATH, and prepend $PATH */
 		check_global_searchpath(path.ptr,  0, testfile, &found);
diff --git a/tests/repo/config.c b/tests/repo/config.c
index e77acc8c5..2e7be37aa 100644
--- a/tests/repo/config.c
+++ b/tests/repo/config.c
@@ -1,4 +1,5 @@
 #include "clar_libgit2.h"
+#include "sysdir.h"
 #include "fileops.h"
 #include <ctype.h>
 
@@ -47,7 +48,7 @@ void test_repo_config__open_missing_global(void)
 	git_config_free(config);
 	git_repository_free(repo);
 
-	git_futils_dirs_global_shutdown();
+	git_sysdir_global_shutdown();
 }
 
 void test_repo_config__open_missing_global_with_separators(void)
@@ -76,7 +77,7 @@ void test_repo_config__open_missing_global_with_separators(void)
 	git_config_free(config);
 	git_repository_free(repo);
 
-	git_futils_dirs_global_shutdown();
+	git_sysdir_global_shutdown();
 }
 
 #include "repository.h"
@@ -105,7 +106,7 @@ void test_repo_config__read_no_configs(void)
 	cl_assert_equal_i(GIT_ABBREV_DEFAULT, val);
 	git_repository_free(repo);
 
-	git_futils_dirs_global_shutdown();
+	git_sysdir_global_shutdown();
 
 	/* with just system */
 
@@ -204,5 +205,5 @@ void test_repo_config__read_no_configs(void)
 	cl_assert(!git_path_exists("empty_standard_repo/.git/config"));
 	cl_assert(!git_path_exists("alternate/3/.gitconfig"));
 
-	git_futils_dirs_global_shutdown();
+	git_sysdir_global_shutdown();
 }
diff --git a/tests/repo/open.c b/tests/repo/open.c
index 7cfe041c2..f7420bd3a 100644
--- a/tests/repo/open.c
+++ b/tests/repo/open.c
@@ -1,5 +1,6 @@
 #include "clar_libgit2.h"
 #include "fileops.h"
+#include "sysdir.h"
 #include <ctype.h>
 
 void test_repo_open__cleanup(void)
@@ -323,7 +324,7 @@ void test_repo_open__no_config(void)
 	git_repository_free(repo);
 	cl_fixture_cleanup("empty_standard_repo");
 
-	git_futils_dirs_global_shutdown();
+	git_sysdir_global_shutdown();
 }
 
 void test_repo_open__force_bare(void)
-- 
cgit v1.2.3


From ab0af298da8c6d96870be06c2497640da9ec6647 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 24 Feb 2014 21:56:08 -0800
Subject: Include stdarg.h for the va_copy test

---
 src/cc-compat.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/cc-compat.h b/src/cc-compat.h
index 37f1ea81e..e73cb6de8 100644
--- a/src/cc-compat.h
+++ b/src/cc-compat.h
@@ -7,6 +7,8 @@
 #ifndef INCLUDE_compat_h__
 #define INCLUDE_compat_h__
 
+#include <stdarg.h>
+
 /*
  * See if our compiler is known to support flexible array members.
  */
-- 
cgit v1.2.3


From 4f46a98b6e419bd98765e18ce7fc64e3562dbd09 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 24 Feb 2014 23:32:25 -0800
Subject: Remove now-duplicated stdarg.h include

---
 src/buffer.c     | 1 -
 src/buffer.h     | 2 --
 src/commit.c     | 2 --
 src/errors.c     | 1 -
 src/filebuf.c    | 2 --
 src/object.c     | 2 --
 src/path.c       | 1 -
 src/repository.c | 1 -
 src/settings.c   | 2 --
 src/trace.h      | 2 --
 10 files changed, 16 deletions(-)

diff --git a/src/buffer.c b/src/buffer.c
index 318fee753..a83ca8792 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -7,7 +7,6 @@
 #include "buffer.h"
 #include "posix.h"
 #include "git2/buffer.h"
-#include <stdarg.h>
 #include <ctype.h>
 
 /* Used as default value for git_buf->ptr so that people can always
diff --git a/src/buffer.h b/src/buffer.h
index 564a4f561..4c852b3cb 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -7,8 +7,6 @@
 #ifndef INCLUDE_buffer_h__
 #define INCLUDE_buffer_h__
 
-#include <stdarg.h>
-
 #include "common.h"
 #include "git2/strarray.h"
 #include "git2/buffer.h"
diff --git a/src/commit.c b/src/commit.c
index de50e772e..2f5a5b51e 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -17,8 +17,6 @@
 #include "signature.h"
 #include "message.h"
 
-#include <stdarg.h>
-
 void git_commit__free(void *_commit)
 {
 	git_commit *commit = _commit;
diff --git a/src/errors.c b/src/errors.c
index a0b085923..393a7875f 100644
--- a/src/errors.c
+++ b/src/errors.c
@@ -8,7 +8,6 @@
 #include "global.h"
 #include "posix.h"
 #include "buffer.h"
-#include <stdarg.h>
 
 /********************************************
  * New error handling
diff --git a/src/filebuf.c b/src/filebuf.c
index 9c3dae811..d23bcc11c 100644
--- a/src/filebuf.c
+++ b/src/filebuf.c
@@ -4,8 +4,6 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
-#include <stdarg.h>
-
 #include "common.h"
 #include "filebuf.h"
 #include "fileops.h"
diff --git a/src/object.c b/src/object.c
index 3fc984b45..40cae184f 100644
--- a/src/object.c
+++ b/src/object.c
@@ -4,8 +4,6 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
-#include <stdarg.h>
-
 #include "git2/object.h"
 
 #include "common.h"
diff --git a/src/path.c b/src/path.c
index feb273915..89409eae4 100644
--- a/src/path.c
+++ b/src/path.c
@@ -12,7 +12,6 @@
 #else
 #include <dirent.h>
 #endif
-#include <stdarg.h>
 #include <stdio.h>
 #include <ctype.h>
 
diff --git a/src/repository.c b/src/repository.c
index 96ed30666..8b336c215 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -4,7 +4,6 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
-#include <stdarg.h>
 #include <ctype.h>
 
 #include "git2/object.h"
diff --git a/src/settings.c b/src/settings.c
index 748f76560..7c2a30377 100644
--- a/src/settings.c
+++ b/src/settings.c
@@ -5,8 +5,6 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
-#include <stdarg.h>
-
 #include <git2.h>
 #include "common.h"
 #include "fileops.h"
diff --git a/src/trace.h b/src/trace.h
index 77b1e03ef..4d4e3bf53 100644
--- a/src/trace.h
+++ b/src/trace.h
@@ -7,8 +7,6 @@
 #ifndef INCLUDE_trace_h__
 #define INCLUDE_trace_h__
 
-#include <stdarg.h>
-
 #include <git2/trace.h>
 #include "buffer.h"
 
-- 
cgit v1.2.3


From 300f44125a5abb00f6185babc9bb828aec556015 Mon Sep 17 00:00:00 2001
From: Miha <miha.ravselj@ib-caddy.si>
Date: Tue, 25 Feb 2014 11:56:11 +0100
Subject: - BUGFIX #2133 (@fourplusone) in smart_protocol.c - added MSVC cmake
 definitions to disable warnings - general.c is rewritten so it is ansi-c
 compatible and compiles ok on microsoft windows - some MSVC reported warning
 fixes

---
 CMakeLists.txt                  |  7 +++-
 examples/add.c                  |  2 +-
 examples/blame.c                |  3 +-
 examples/cat-file.c             |  2 +-
 examples/common.c               |  2 +-
 examples/general.c              | 82 ++++++++++++++++++++---------------------
 examples/network/clone.c        |  2 +-
 src/transports/smart_protocol.c |  4 ++
 src/transports/ssh.c            |  3 +-
 9 files changed, 57 insertions(+), 50 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d6b327503..27cf1a558 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -21,7 +21,8 @@ INCLUDE(CheckLibraryExists)
 
 # Build options
 #
-OPTION( SONAME				"Set the (SO)VERSION of the target"		ON  )
+OPTION( SONAME			
+	"Set the (SO)VERSION of the target"		ON  )
 OPTION( BUILD_SHARED_LIBS	"Build Shared Library (OFF for Static)"	ON  )
 OPTION( THREADSAFE			"Build libgit2 as threadsafe"			OFF )
 OPTION( BUILD_CLAR			"Build Tests using the Clar suite"		ON  )
@@ -57,6 +58,10 @@ IF(MSVC)
 	# By default, libgit2 is built with WinHTTP.  To use the built-in
 	# HTTP transport, invoke CMake with the "-DWINHTTP=OFF" argument.
 	OPTION( WINHTTP			"Use Win32 WinHTTP routines"	ON  )
+
+	ADD_DEFINITIONS(-D_SCL_SECURE_NO_WARNINGS)
+	ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
+	ADD_DEFINITIONS(-D_CRT_NONSTDC_NO_DEPRECATE)
 ENDIF()
 
 # This variable will contain the libraries we need to put into
diff --git a/examples/add.c b/examples/add.c
index 336596bde..0c6076e81 100644
--- a/examples/add.c
+++ b/examples/add.c
@@ -78,7 +78,7 @@ int print_matched_cb(const char *path, const char *matched_pathspec, void *paylo
 	git_status_t status;
 	(void)matched_pathspec;
 
-	if (git_status_file(&status, p.repo, path)) {
+	if (git_status_file((unsigned int*)(&status), p.repo, path)) {
 		return -1; //abort
 	}
 
diff --git a/examples/blame.c b/examples/blame.c
index 1f5db69a1..d7b843cc2 100644
--- a/examples/blame.c
+++ b/examples/blame.c
@@ -105,8 +105,9 @@ int main(int argc, char *argv[])
 		if (break_on_null_hunk && !hunk) break;
 
 		if (hunk) {
-			break_on_null_hunk = 1;
 			char sig[128] = {0};
+			break_on_null_hunk = 1;
+			
 
 			git_oid_tostr(oid, 10, &hunk->final_commit_id);
 			snprintf(sig, 30, "%s <%s>", hunk->final_signature->name, hunk->final_signature->email);
diff --git a/examples/cat-file.c b/examples/cat-file.c
index fa6add07b..52399fa8a 100644
--- a/examples/cat-file.c
+++ b/examples/cat-file.c
@@ -42,7 +42,7 @@ static void print_signature(const char *header, const git_signature *sig)
 static void show_blob(const git_blob *blob)
 {
 	/* ? Does this need crlf filtering? */
-	fwrite(git_blob_rawcontent(blob), git_blob_rawsize(blob), 1, stdout);
+	fwrite(git_blob_rawcontent(blob), (size_t)git_blob_rawsize(blob), 1, stdout);
 }
 
 /** Show each entry with its type, id and attributes */
diff --git a/examples/common.c b/examples/common.c
index 12dbccf59..a066c153c 100644
--- a/examples/common.c
+++ b/examples/common.c
@@ -156,7 +156,7 @@ int diff_output(
 	const git_diff_line *l,
 	void *p)
 {
-	FILE *fp = p;
+	FILE *fp = (FILE*)p;
 
 	(void)d; (void)h;
 
diff --git a/examples/general.c b/examples/general.c
index ae8756338..235055906 100644
--- a/examples/general.c
+++ b/examples/general.c
@@ -71,6 +71,43 @@ int main (int argc, char** argv)
   int error;
   const char *repo_path = (argc > 1) ? argv[1] : "/opt/libgit2-test/.git";
   git_repository *repo;
+  char* hex;
+  git_oid oid;
+  char out[41];
+  git_odb* odb;
+  git_odb_object *obj;
+  git_otype otype;
+  const unsigned char *data;
+  const char *str_type;
+  git_commit* commit;
+  const git_signature *author, *cmtter;
+  const char *message;
+  time_t ctime;
+  unsigned int parents, p;
+  git_oid tree_id, parent_id, commit_id;
+  git_tree *tree;
+  git_commit *parent;
+  git_tag *tag;
+  const char *tmessage, *tname;
+  git_otype ttype;
+  const git_tree_entry *entry;
+  git_object *objt;
+  size_t cnt;
+  git_blob *blob;
+  git_revwalk *walk;
+  git_commit *wcommit;
+  const git_signature *cauth;
+  const char *cmsg;
+  git_index *index;
+  unsigned int i, ecount;
+  git_strarray ref_list;
+  const char *refname;
+  git_reference *ref;
+  const char *email;
+  int32_t j;
+  git_config *cfg;
+  char config_path[256];
+
 
   error = git_repository_open(&repo, repo_path);
   check_error(error, "opening repository");
@@ -80,12 +117,11 @@ int main (int argc, char** argv)
   // For our first example, we will convert a 40 character hex value to the
   // 20 byte raw SHA1 value.
   printf("*Hex to Raw*\n");
-  char hex[] = "4a202b346bb0fb0db7eff3cffeb3c70babbd2045";
+  hex = "4a202b346bb0fb0db7eff3cffeb3c70babbd2045";
 
   // The `git_oid` is the structure that keeps the SHA value. We will use
   // this throughout the example for storing the value of the current SHA
   // key we're working with.
-  git_oid oid;
   git_oid_fromstr(&oid, hex);
 
   // Once we've converted the string into the oid value, we can get the raw
@@ -94,7 +130,6 @@ int main (int argc, char** argv)
   // Next we will convert the 20 byte raw SHA1 value to a human readable 40
   // char hex value.
   printf("\n*Raw to Hex*\n");
-  char out[41];
   out[40] = '\0';
 
   // If you have a oid, you can easily get the hex value of the SHA as well.
@@ -109,16 +144,11 @@ int main (int argc, char** argv)
   // repository.
   //
   // [odb]: http://libgit2.github.com/libgit2/#HEAD/group/odb
-  git_odb *odb;
   git_repository_odb(&odb, repo);
 
   // #### Raw Object Reading
 
   printf("\n*Raw Object Read*\n");
-  git_odb_object *obj;
-  git_otype otype;
-  const unsigned char *data;
-  const char *str_type;
 
   // We can read raw objects directly from the object database if we have
   // the oid (SHA) of the object.  This allows us to access objects without
@@ -177,17 +207,11 @@ int main (int argc, char** argv)
 
   printf("\n*Commit Parsing*\n");
 
-  git_commit *commit;
   git_oid_fromstr(&oid, "8496071c1b46c854b31185ea97743be6a8774479");
 
   error = git_commit_lookup(&commit, repo, &oid);
   check_error(error, "looking up commit");
 
-  const git_signature *author, *cmtter;
-  const char *message;
-  time_t ctime;
-  unsigned int parents, p;
-
   // Each of the properties of the commit object are accessible via methods,
   // including commonly needed variations, such as `git_commit_time` which
   // returns the author time and `git_commit_message` which gives you the
@@ -229,9 +253,6 @@ int main (int argc, char** argv)
   // [cd]: http://libgit2.github.com/libgit2/#HEAD/group/commit
 
   printf("\n*Commit Writing*\n");
-  git_oid tree_id, parent_id, commit_id;
-  git_tree *tree;
-  git_commit *parent;
 
   // Creating signatures for an authoring identity and time is simple.  You
   // will need to do this to specify who created a commit and when.  Default
@@ -277,9 +298,6 @@ int main (int argc, char** argv)
   //
   // [tm]: http://libgit2.github.com/libgit2/#HEAD/group/tag
   printf("\n*Tag Parsing*\n");
-  git_tag *tag;
-  const char *tmessage, *tname;
-  git_otype ttype;
 
   // We create an oid for the tag object if we know the SHA and look it up
   // the same way that we would a commit (or any other object).
@@ -310,16 +328,13 @@ int main (int argc, char** argv)
   // [tp]: http://libgit2.github.com/libgit2/#HEAD/group/tree
   printf("\n*Tree Parsing*\n");
 
-  const git_tree_entry *entry;
-  git_object *objt;
-
   // Create the oid and lookup the tree object just like the other objects.
   git_oid_fromstr(&oid, "2a741c18ac5ff082a7caaec6e74db3075a1906b5");
   git_tree_lookup(&tree, repo, &oid);
 
   // Getting the count of entries in the tree so you can iterate over them
   // if you want to.
-  size_t cnt = git_tree_entrycount(tree); // 3
+  cnt = git_tree_entrycount(tree); // 3
   printf("tree entries: %d\n", (int)cnt);
 
   entry = git_tree_entry_byindex(tree, 0);
@@ -351,7 +366,6 @@ int main (int argc, char** argv)
   // [ba]: http://libgit2.github.com/libgit2/#HEAD/group/blob
 
   printf("\n*Blob Parsing*\n");
-  git_blob *blob;
 
   git_oid_fromstr(&oid, "1385f264afb75a56a5bec74243be9b367ba4ca08");
   git_blob_lookup(&blob, repo, &oid);
@@ -376,8 +390,6 @@ int main (int argc, char** argv)
   // [rw]: http://libgit2.github.com/libgit2/#HEAD/group/revwalk
 
   printf("\n*Revwalking*\n");
-  git_revwalk *walk;
-  git_commit *wcommit;
 
   git_oid_fromstr(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644");
 
@@ -393,9 +405,6 @@ int main (int argc, char** argv)
   git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE);
   git_revwalk_push(walk, &oid);
 
-  const git_signature *cauth;
-  const char *cmsg;
-
   // Now that we have the starting point pushed onto the walker, we start
   // asking for ancestors. It will return them in the sorting order we asked
   // for as commit oids.  We can then lookup and parse the commited pointed
@@ -427,9 +436,6 @@ int main (int argc, char** argv)
 
   printf("\n*Index Walking*\n");
 
-  git_index *index;
-  unsigned int i, ecount;
-
   // You can either open the index from the standard location in an open
   // repository, as we're doing here, or you can open and manipulate any
   // index file with `git_index_open_bare()`. The index for the repository
@@ -465,12 +471,8 @@ int main (int argc, char** argv)
 
   // Here we will implement something like `git for-each-ref` simply listing
   // out all available references and the object SHA they resolve to.
-  git_strarray ref_list;
   git_reference_list(&ref_list, repo);
 
-  const char *refname;
-  git_reference *ref;
-
   // Now that we have the list of reference names, we can lookup each ref
   // one at a time and resolve them to the SHA, then print both values out.
   for (i = 0; i < ref_list.count; ++i) {
@@ -503,13 +505,7 @@ int main (int argc, char** argv)
 
   printf("\n*Config Listing*\n");
 
-  const char *email;
-  int32_t j;
-
-  git_config *cfg;
-
   // Open a config object so we can read global values from it.
-  char config_path[256];
   sprintf(config_path, "%s/config", repo_path);
   check_error(git_config_open_ondisk(&cfg, config_path), "opening config");
 
diff --git a/examples/network/clone.c b/examples/network/clone.c
index 4df47eb7f..a982c13c2 100644
--- a/examples/network/clone.c
+++ b/examples/network/clone.c
@@ -22,7 +22,7 @@ static void print_progress(const progress_data *pd)
 	int index_percent = (100*pd->fetch_progress.indexed_objects) / pd->fetch_progress.total_objects;
 	int checkout_percent = pd->total_steps > 0
 		? (100 * pd->completed_steps) / pd->total_steps
-		: 0.f;
+		: 0;
 	int kbytes = pd->fetch_progress.received_bytes / 1024;
 
 	if (pd->fetch_progress.received_objects == pd->fetch_progress.total_objects) {
diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index dd9b5e0ed..7e8fcdd92 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -579,6 +579,10 @@ int git_smart__download_pack(
 done:
 	if (writepack)
 		writepack->free(writepack);
+	if (progress_cb) {
+		t->packetsize_cb = NULL;
+		t->packetsize_payload = NULL;
+	}
 
 	return error;
 }
diff --git a/src/transports/ssh.c b/src/transports/ssh.c
index 37f17080a..bece0b45d 100644
--- a/src/transports/ssh.c
+++ b/src/transports/ssh.c
@@ -53,6 +53,7 @@ static void ssh_error(LIBSSH2_SESSION *session, const char *errmsg)
 static int gen_proto(git_buf *request, const char *cmd, const char *url)
 {
 	char *repo;
+	int len;
 
 	if (!git__prefixcmp(url, prefix_ssh)) {
 		url = url + strlen(prefix_ssh);
@@ -67,7 +68,7 @@ static int gen_proto(git_buf *request, const char *cmd, const char *url)
 		return -1;
 	}
 
-	int len = strlen(cmd) + 1 /* Space */ + 1 /* Quote */ + strlen(repo) + 1 /* Quote */ + 1;
+	len = strlen(cmd) + 1 /* Space */ + 1 /* Quote */ + strlen(repo) + 1 /* Quote */ + 1;
 
 	git_buf_grow(request, len);
 	git_buf_printf(request, "%s '%s'", cmd, repo);
-- 
cgit v1.2.3


From 3536c168c354906e2109f49a474f51117fc9b7db Mon Sep 17 00:00:00 2001
From: Miha <miha.ravselj@ib-caddy.si>
Date: Tue, 25 Feb 2014 14:57:47 +0100
Subject: - need_pack was not set to 0 when local fetch was already present
 causing  negotiate_fetch access violation

---
 src/fetch.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/fetch.c b/src/fetch.c
index 5bf2b93c1..c7d2c83a1 100644
--- a/src/fetch.c
+++ b/src/fetch.c
@@ -42,8 +42,10 @@ static int maybe_want(git_remote *remote, git_remote_head *head, git_odb *odb, g
 		return 0;
 
 	/* If we have the object, mark it so we don't ask for it */
-	if (git_odb_exists(odb, &head->oid))
+	if (git_odb_exists(odb, &head->oid)) {
 		head->local = 1;
+		remote->need_pack = 0;
+	}
 	else
 		remote->need_pack = 1;
 
-- 
cgit v1.2.3


From 0276f0f55bf24dc5e0f49612106c1091381033f9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Juan=20Rub=C3=A9n?= <juanruben.segovia@gmail.com>
Date: Wed, 26 Feb 2014 19:22:19 +0100
Subject: Reset num_parents to 1 only for merge commits

Also, correct test case to account for the boundary flag
---
 src/blame_git.c      | 2 +-
 tests/blame/simple.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/blame_git.c b/src/blame_git.c
index c275293c3..72afb852b 100644
--- a/src/blame_git.c
+++ b/src/blame_git.c
@@ -489,7 +489,7 @@ static void pass_blame(git_blame *blame, git_blame__origin *origin, uint32_t opt
 	if (!git_oid_cmp(git_commit_id(commit), &blame->options.oldest_commit))
 		/* Stop at oldest specified commit */
 		num_parents = 0;
-	else if (opt & GIT_BLAME_FIRST_PARENT)
+	else if (opt & GIT_BLAME_FIRST_PARENT && num_parents > 1)
 		/* Limit search to the first parent */
 		num_parents = 1;
 
diff --git a/tests/blame/simple.c b/tests/blame/simple.c
index 18b3457af..11ff4cd19 100644
--- a/tests/blame/simple.c
+++ b/tests/blame/simple.c
@@ -314,7 +314,7 @@ void test_blame_simple__can_restrict_to_first_parent_commits(void)
 	cl_git_pass(git_blame_file(&g_blame, g_repo, "b.txt", &opts));
 	cl_assert_equal_i(4, git_blame_get_hunk_count(g_blame));
 	check_blame_hunk_index(g_repo, g_blame, 0,  1, 4, 0, "da237394", "b.txt");
-	check_blame_hunk_index(g_repo, g_blame, 1,  5, 1, 0, "b99f7ac0", "b.txt");
+	check_blame_hunk_index(g_repo, g_blame, 1,  5, 1, 1, "b99f7ac0", "b.txt");
 	check_blame_hunk_index(g_repo, g_blame, 2,  6, 5, 0, "63d671eb", "b.txt");
 	check_blame_hunk_index(g_repo, g_blame, 3, 11, 5, 0, "bc7c5ac2", "b.txt");
 }
-- 
cgit v1.2.3


From f2abb72568949a0a751135a75748051a07a1b2d4 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 26 Feb 2014 12:39:48 -0800
Subject: Remove "ignore" state from the git.git-authors

---
 git.git-authors | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/git.git-authors b/git.git-authors
index 7c72c4bf6..9131a1fa1 100644
--- a/git.git-authors
+++ b/git.git-authors
@@ -28,9 +28,6 @@
 #   his/her consent on a patch-by-patch basis.
 # "???" means the person is a prominent contributor who has
 #   not yet made his/her standpoint clear.
-# "ign" means the authors consent is ignored for the purpose
-#   of libification. This is because the author has contributed
-#   to areas that aren't interesting for the library.
 #
 # Please try to keep the list alphabetically ordered. It will
 # help in case we get all 600-ish git.git authors on it.
@@ -61,7 +58,6 @@ ok	Linus Torvalds <torvalds@linux-foundation.org>
 ok	Lukas Sandström <lukass@etek.chalmers.se>
 ok	Matthieu Moy <Matthieu.Moy@imag.fr>
 ok	Michael Haggerty <mhagger@alum.mit.edu>
-ign	Mike McCormack <mike@codeweavers.com> (imap-send)
 ok	Nicolas Pitre <nico@fluxnic.net> <nico@cam.org>
 ok	Paolo Bonzini <bonzini@gnu.org>
 ok	Paul Kocher <paul@cryptography.com>
@@ -70,7 +66,6 @@ ok	Petr Onderka <gsvick@gmail.com>
 ok	Pierre Habouzit <madcoder@debian.org>
 ok	Pieter de Bie <pdebie@ai.rug.nl>
 ok	René Scharfe <rene.scharfe@lsrfire.ath.cx>
-ign	Robert Shearman <rob@codeweavers.com> (imap-send)
 ok	Sebastian Schuberth <sschuberth@gmail.com>
 ok	Shawn O. Pearce <spearce@spearce.org>
 ok	Steffen Prohaska <prohaska@zib.de>
-- 
cgit v1.2.3


From 486bc36689e1895a0c8aac5242defbed87a0ba52 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 26 Feb 2014 16:37:08 -0800
Subject: Add project list and update readme

---
 CONTRIBUTING.md | 21 +-------------
 PROJECTS.md     | 88 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 README.md       | 25 ++++++++--------
 3 files changed, 103 insertions(+), 31 deletions(-)
 create mode 100644 PROJECTS.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 06aa4c1dd..4efe28ed3 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -101,23 +101,4 @@ at the
 
 ## Starter Projects
 
-So, you want to start helping out with `libgit2`? That's fantastic? We
-welcome contributions and we promise we'll try to be nice.
-
-If you want to jump in, you can look at our issues list to see if there
-are any unresolved issues to jump in on.  Also, here is a list of some
-smaller project ideas that could help you become familiar with the code
-base and make a nice first step:
-
-* Look at the `examples/` programs, find an existing one that mirrors a
-  core Git command and add a missing command-line option.  There are many
-  gaps right now and this helps demonstrate how to use the library.
-* Pick a Git command that is not emulates in `examples/` and write a new
-  example that mirrors the behavior.  Examples don't have to be perfect
-  emulations, but should demonstrate how to use the libgit2 APIs to get
-  results that are similar to Git commands.  This lets you (and us) easily
-  exercise a particular facet of the API and measure compatability and
-  feature parity with core git.
-* Submit a PR to clarify documentation! While we do try to document all of
-  the APIs, your fresh eyes on the documentation will find areas that are
-  confusing much more easily.
+See our [projects list](https://github.com/libgit2/libgit2/blob/development/PROJECTS.md).
diff --git a/PROJECTS.md b/PROJECTS.md
new file mode 100644
index 000000000..34ba18ace
--- /dev/null
+++ b/PROJECTS.md
@@ -0,0 +1,88 @@
+Projects For LibGit2
+====================
+
+So, you want to start helping out with `libgit2`? That's fantastic! We
+welcome contributions and we promise we'll try to be nice.
+
+This is a list of libgit2 related projects that new contributors can take
+on.  It includes a number of good starter projects and well as some larger
+ideas that no one is actively working on.
+
+## Before You Start
+
+Please start by reading the README.md, CONTRIBUTING.md, and CONVENTIONS.md
+files before diving into one of these projects.  Those will explain our
+work flow and coding conventions to help ensure that your work will be
+easily integrated into libgit2.
+
+Next, work through the build instructions and make sure you can clone the
+repository, compile it, and run the tests successfully.  That will make
+sure that your development environment is set up correctly and you are
+ready to start on libgit2 development.
+
+## Starter Projects
+
+These are good small projects to get started with libgit2.
+
+* Look at the `examples/` programs, find an existing one that mirrors a
+  core Git command and add a missing command-line option.  There are many
+  gaps right now and this helps demonstrate how to use the library.  Here
+  are some specific ideas:
+    * Add the `--minimal` flag to `examples/diff.c` since the `libgit2`
+      diff API now has a flag to support it
+    * Add the `--patience` flag to `examples/diff.c` since it is also now
+      supported.
+    * Add the `--shortstat` flag to `examples/diff.c` based on the work
+      that was done to add `--numstat` already.
+    * Fix the `examples/diff.c` implementation of the `-B`
+      (a.k.a. `--break-rewrites`) command line option to actually look for
+      the optional `[<n>][/<m>]` configuration values. There is an
+      existing comment that reads `/* TODO: parse thresholds */`. The
+      trick to this one will be doing it in a manner that is clean and
+      simple, but still handles the various cases correctly (e.g. `-B/70%`
+      is apparently a legal setting).
+    * Implement the `--log-size` option for `examples/log.c`. I think all
+      the data is available, you would just need to add the code into the
+      `print_commit()` routine (along with a way of passing the option
+      into that function).
+    * For `examples/log.c`, implement any one of `--author=<...>`,
+      `--committer=<...>`, or `--grep=<...>` but just use simple string
+      match with `strstr()` instead of full regular expression
+      matching. (I.e. I'm suggesting implementing this as if
+      `--fixed-strings` was always turned on, because it will be a simpler
+      project.)
+    * As an extension to the matching idea for `examples/log.c`, add the
+      `-i` option to use `strcasestr()` for matches.
+    * For `examples/log.c`, implement the `--first-parent` option now that
+      libgit2 supports it in the revwalk API.
+* Pick a Git command that is not already emulated in `examples/` and write
+  a new example that mirrors the behavior.  Examples don't have to be
+  perfect emulations, but should demonstrate how to use the libgit2 APIs
+  to get results that are similar to Git commands.  This lets you (and us)
+  easily exercise a particular facet of the API and measure compatability
+  and feature parity with core git.
+* Submit a PR to clarify documentation! While we do try to document all of
+  the APIs, your fresh eyes on the documentation will find areas that are
+  confusing much more easily.
+
+If none of these appeal to you, take a look at our issues list to see if
+there are any unresolved issues you'd like to jump in on.
+
+## Larger Projects
+
+These are ideas for larger projects mostly taken from our backlog of
+[Issues](https://github.com/libgit2/libgit2/issues).  Please don't dive
+into one of these as a first project for libgit2 - we'd rather get to
+know you first by successfully shipping your work on one of the smaller
+projects above.
+
+* Port part of the Git test suite to run against the command line emulation
+  in examples/
+* Fix symlink support for files in the .git directory (i.e. don't overwrite
+  the symlinks when writing the file contents back out)
+* Implement a 'git describe' like API
+* Add hooks API to enumerate and manage hooks (not run them at this point)
+* Isolate logic of ignore evaluation into a standalone API
+* Upgrade internal libxdiff code to latest from core Git
+* Add a hashtable lookup for files in the index instead of binary search
+  every time
diff --git a/README.md b/README.md
index aa75bb093..8dd073430 100644
--- a/README.md
+++ b/README.md
@@ -4,9 +4,9 @@ libgit2 - the Git linkable library
 [![Build Status](https://secure.travis-ci.org/libgit2/libgit2.png?branch=development)](http://travis-ci.org/libgit2/libgit2)
 [![Coverity Scan Build Status](https://scan.coverity.com/projects/639/badge.svg)](https://scan.coverity.com/projects/639)
 
-`libgit2` is a portable, pure C implementation of the Git core methods provided as a
-re-entrant linkable library with a solid API, allowing you to write native
-speed custom Git applications in any language with bindings.
+`libgit2` is a portable, pure C implementation of the Git core methods
+provided as a re-entrant linkable library with a solid API, allowing you to
+write native speed custom Git applications in any language with bindings.
 
 `libgit2` is licensed under a **very permissive license** (GPLv2 with a special
 Linking Exception).  This basically means that you can link it (unmodified)
@@ -30,8 +30,9 @@ Additionally, the example code has been released to the public domain (see the
 What It Can Do
 ==============
 
-`libgit2` is already very usable and is being used in production for many applications including the GitHub.com site, in Plastic SCM
-and also powering Microsoft's Visual Studio tools for Git.  The library provides:
+`libgit2` is already very usable and is being used in production for many
+applications including the GitHub.com site, in Plastic SCM and also powering
+Microsoft's Visual Studio tools for Git.  The library provides:
 
 * SHA conversions, formatting and shortening
 * abstracted ODB backend system
@@ -199,14 +200,16 @@ we can add it to the list.
 How Can I Contribute?
 ==================================
 
-Check the [contribution guidelines](CONTRIBUTING.md).
-
+Check the [contribution guidelines](CONTRIBUTING.md) to understand our
+workflow, the libgit2 [coding conventions](CONVENTIONS.md), and out list of
+[good starting projects](PROJECTS.md).
 
 License
 ==================================
-`libgit2` is under GPL2 **with linking exemption**. This means you
-can link to and use the library from any program, proprietary or open source; paid
-or gratis.  However, you cannot modify libgit2 and distribute it without
+
+`libgit2` is under GPL2 **with linking exemption**. This means you can link to
+and use the library from any program, proprietary or open source; paid or
+gratis.  However, you cannot modify libgit2 and distribute it without
 supplying the source.
 
-See the COPYING file for the full license text.
+See the [COPYING file](COPYING) for the full license text.
-- 
cgit v1.2.3


From 59b1dbcd7acf6aa7dd6d81d0386ab15f46ce6ac7 Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Thu, 27 Feb 2014 23:56:25 +0800
Subject: Do not allow git_branch_create() to force update branch

---
 src/branch.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/branch.c b/src/branch.c
index 133d6f6d4..1ebaf8e24 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -58,6 +58,7 @@ int git_branch_create(
 	const git_signature *signature,
 	const char *log_message)
 {
+	int is_head = 0;
 	git_reference *branch = NULL;
 	git_buf canonical_branch_name = GIT_BUF_INIT,
 			  log_message_buf = GIT_BUF_INIT;
@@ -65,7 +66,19 @@ int git_branch_create(
 
 	assert(branch_name && commit && ref_out);
 	assert(git_object_owner((const git_object *)commit) == repository);
+	if (git_branch_lookup(&branch, repository, branch_name, GIT_BRANCH_LOCAL) == 0) {
+		if ((is_head = git_branch_is_head(branch)) < 0) {
+			error = is_head;
+			goto cleanup;
+		}
+	}
 
+	if (is_head && force) {
+		giterr_set(GITERR_REFERENCE, "Cannot force update branch '%s' as it is "
+			"the current HEAD of the repository.", git_reference_name(branch));
+		goto cleanup;
+	}
+	
 	if (git_buf_joinpath(&canonical_branch_name, GIT_REFS_HEADS_DIR, branch_name) < 0)
 		goto cleanup;
 
-- 
cgit v1.2.3


From d88399922f622baef91c6f4e4e67b2091653cb65 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 27 Feb 2014 14:01:16 -0800
Subject: Fix warnings and code style issues

---
 examples/diff.c | 18 +++++++++++-------
 1 file changed, 11 insertions(+), 7 deletions(-)

diff --git a/examples/diff.c b/examples/diff.c
index abb9b7103..de994ecab 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -269,19 +269,23 @@ static void diff_print_numstat(git_diff *diff)
 {
 	git_patch *patch;
 	const git_diff_delta *delta;
-	size_t i;
-	size_t ndeltas;
+	size_t d, ndeltas = git_diff_num_deltas(diff);
 	size_t nadditions, ndeletions;
-	ndeltas = git_diff_num_deltas(diff);	
-	for (i = 0; i < ndeltas; i++){
+
+	for (d = 0; d < ndeltas; d++){
 		check_lg2(
-			git_patch_from_diff(&patch, diff, i),
+			git_patch_from_diff(&patch, diff, d),
 			"generating patch from diff", NULL);
+
 		check_lg2(
 			git_patch_line_stats(NULL, &nadditions, &ndeletions, patch),
 			"generating the number of additions and deletions", NULL);
+
 		delta = git_patch_get_delta(patch);
-		printf("%u\t%u\t%s\n", nadditions, ndeletions, delta->new_file.path);
+
+		printf("%ld\t%ld\t%s\n",
+			   (long)nadditions, (long)ndeletions, delta->new_file.path);
+
+		git_patch_free(patch);
 	}
-	git_patch_free(patch);
 }
-- 
cgit v1.2.3


From 6789b7a75d1e24a7f4ce34628c6b4561517f0b73 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 27 Feb 2014 14:13:22 -0800
Subject: Add buffer to buffer diff and patch APIs

This adds `git_diff_buffers` and `git_patch_from_buffers`.  This
also includes a bunch of internal refactoring to increase the
shared code between these functions and the blob-to-blob and
blob-to-buffer APIs, as well as some higher level assert helpers
in the tests to also remove redundancy.
---
 include/git2/diff.h  |  33 +++++++
 include/git2/patch.h |  28 ++++++
 src/diff_file.c      |  49 ++++-------
 src/diff_file.h      |  20 +++--
 src/diff_patch.c     | 230 ++++++++++++++++++++++++------------------------
 tests/diff/blob.c    | 240 +++++++++++++++++++--------------------------------
 6 files changed, 289 insertions(+), 311 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index a3cdd8193..943e2ec4c 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -1013,6 +1013,39 @@ GIT_EXTERN(int) git_diff_blob_to_buffer(
 	git_diff_line_cb line_cb,
 	void *payload);
 
+/**
+ * Directly run a diff between two buffers.
+ *
+ * Even more than with `git_diff_blobs`, comparing two buffer lacks
+ * context, so the `git_diff_file` parameters to the callbacks will be
+ * faked a la the rules for `git_diff_blobs()`.
+ *
+ * @param old_buffer Raw data for old side of diff, or NULL for empty
+ * @param old_len Length of the raw data for old side of the diff
+ * @param old_as_path Treat old buffer as if it had this filename; can be NULL
+ * @param new_buffer Raw data for new side of diff, or NULL for empty
+ * @param new_len Length of raw data for new side of diff
+ * @param new_as_path Treat buffer as if it had this filename; can be NULL
+ * @param options Options for diff, or NULL for default options
+ * @param file_cb Callback for "file"; made once if there is a diff; can be NULL
+ * @param hunk_cb Callback for each hunk in diff; can be NULL
+ * @param line_cb Callback for each line in diff; can be NULL
+ * @param payload Payload passed to each callback function
+ * @return 0 on success, non-zero callback return value, or error code
+ */
+GIT_EXTERN(int) git_diff_buffers(
+	const void *old_buffer,
+	size_t old_len,
+	const char *old_as_path,
+	const void *new_buffer,
+	size_t new_len,
+	const char *new_as_path,
+	const git_diff_options *options,
+	git_diff_file_cb file_cb,
+	git_diff_hunk_cb hunk_cb,
+	git_diff_line_cb line_cb,
+	void *payload);
+
 
 GIT_END_DECL
 
diff --git a/include/git2/patch.h b/include/git2/patch.h
index 1eca29d4a..f5ec682c6 100644
--- a/include/git2/patch.h
+++ b/include/git2/patch.h
@@ -105,6 +105,34 @@ GIT_EXTERN(int) git_patch_from_blob_and_buffer(
 	const char *buffer_as_path,
 	const git_diff_options *opts);
 
+/**
+ * Directly generate a patch from the difference between two buffers.
+ *
+ * This is just like `git_diff_buffers()` except it generates a patch
+ * object for the difference instead of directly making callbacks.  You can
+ * use the standard `git_patch` accessor functions to read the patch
+ * data, and you must call `git_patch_free()` on the patch when done.
+ *
+ * @param out The generated patch; NULL on error
+ * @param old_buffer Raw data for old side of diff, or NULL for empty
+ * @param old_len Length of the raw data for old side of the diff
+ * @param old_as_path Treat old buffer as if it had this filename; can be NULL
+ * @param new_buffer Raw data for new side of diff, or NULL for empty
+ * @param new_len Length of raw data for new side of diff
+ * @param new_as_path Treat buffer as if it had this filename; can be NULL
+ * @param opts Options for diff, or NULL for default options
+ * @return 0 on success or error code < 0
+ */
+GIT_EXTERN(int) git_patch_from_buffers(
+	git_patch **out,
+	const void *old_buffer,
+	size_t old_len,
+	const char *old_as_path,
+	const char *new_buffer,
+	size_t new_len,
+	const char *new_as_path,
+	const git_diff_options *opts);
+
 /**
  * Free a git_patch object.
  */
diff --git a/src/diff_file.c b/src/diff_file.c
index fb5d674f7..7dabf8d6f 100644
--- a/src/diff_file.c
+++ b/src/diff_file.c
@@ -127,57 +127,38 @@ int git_diff_file_content__init_from_diff(
 	return diff_file_content_init_common(fc, &diff->opts);
 }
 
-int git_diff_file_content__init_from_blob(
+int git_diff_file_content__init_from_src(
 	git_diff_file_content *fc,
 	git_repository *repo,
 	const git_diff_options *opts,
-	const git_blob *blob,
+	const git_diff_file_content_src *src,
 	git_diff_file *as_file)
 {
 	memset(fc, 0, sizeof(*fc));
 	fc->repo = repo;
 	fc->file = as_file;
-	fc->blob = blob;
+	fc->blob = src->blob;
 
-	if (!blob) {
+	if (!src->blob && !src->buf) {
 		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
 	} else {
 		fc->flags |= GIT_DIFF_FLAG__LOADED;
 		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
-		fc->file->size = git_blob_rawsize(blob);
 		fc->file->mode = GIT_FILEMODE_BLOB;
-		git_oid_cpy(&fc->file->id, git_blob_id(blob));
 
-		fc->map.len  = (size_t)fc->file->size;
-		fc->map.data = (char *)git_blob_rawcontent(blob);
-	}
+		if (src->blob) {
+			fc->file->size = git_blob_rawsize(src->blob);
+			git_oid_cpy(&fc->file->id, git_blob_id(src->blob));
 
-	return diff_file_content_init_common(fc, opts);
-}
+			fc->map.len  = (size_t)fc->file->size;
+			fc->map.data = (char *)git_blob_rawcontent(src->blob);
+		} else {
+			fc->file->size = src->buflen;
+			git_odb_hash(&fc->file->id, src->buf, src->buflen, GIT_OBJ_BLOB);
 
-int git_diff_file_content__init_from_raw(
-	git_diff_file_content *fc,
-	git_repository *repo,
-	const git_diff_options *opts,
-	const char *buf,
-	size_t buflen,
-	git_diff_file *as_file)
-{
-	memset(fc, 0, sizeof(*fc));
-	fc->repo = repo;
-	fc->file = as_file;
-
-	if (!buf) {
-		fc->flags |= GIT_DIFF_FLAG__NO_DATA;
-	} else {
-		fc->flags |= GIT_DIFF_FLAG__LOADED;
-		fc->file->flags |= GIT_DIFF_FLAG_VALID_ID;
-		fc->file->size = buflen;
-		fc->file->mode = GIT_FILEMODE_BLOB;
-		git_odb_hash(&fc->file->id, buf, buflen, GIT_OBJ_BLOB);
-
-		fc->map.len  = buflen;
-		fc->map.data = (char *)buf;
+			fc->map.len  = src->buflen;
+			fc->map.data = (char *)src->buf;
+		}
 	}
 
 	return diff_file_content_init_common(fc, opts);
diff --git a/src/diff_file.h b/src/diff_file.h
index 84bf255aa..4d290ad43 100644
--- a/src/diff_file.h
+++ b/src/diff_file.h
@@ -31,19 +31,21 @@ extern int git_diff_file_content__init_from_diff(
 	size_t delta_index,
 	bool use_old);
 
-extern int git_diff_file_content__init_from_blob(
-	git_diff_file_content *fc,
-	git_repository *repo,
-	const git_diff_options *opts,
-	const git_blob *blob,
-	git_diff_file *as_file);
+typedef struct {
+	const git_blob *blob;
+	const void *buf;
+	size_t buflen;
+	const char *as_path;
+} git_diff_file_content_src;
+
+#define GIT_DIFF_FILE_CONTENT_SRC__BLOB(BLOB,PATH) { (BLOB),NULL,0,(PATH) }
+#define GIT_DIFF_FILE_CONTENT_SRC__BUF(BUF,LEN,PATH) { NULL,(BUF),(LEN),(PATH) }
 
-extern int git_diff_file_content__init_from_raw(
+extern int git_diff_file_content__init_from_src(
 	git_diff_file_content *fc,
 	git_repository *repo,
 	const git_diff_options *opts,
-	const char *buf,
-	size_t buflen,
+	const git_diff_file_content_src *src,
 	git_diff_file *as_file);
 
 /* this loads the blob/file-on-disk as needed */
diff --git a/src/diff_patch.c b/src/diff_patch.c
index ecae3a8ed..dd8b73938 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -5,6 +5,7 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 #include "common.h"
+#include "git2/blob.h"
 #include "diff.h"
 #include "diff_file.h"
 #include "diff_driver.h"
@@ -334,38 +335,45 @@ static int diff_single_generate(diff_patch_with_delta *pd, git_xdiff_output *xo)
 	return error;
 }
 
-static int diff_patch_from_blobs(
+static int diff_patch_from_sources(
 	diff_patch_with_delta *pd,
 	git_xdiff_output *xo,
-	const git_blob *old_blob,
-	const char *old_path,
-	const git_blob *new_blob,
-	const char *new_path,
+	git_diff_file_content_src *oldsrc,
+	git_diff_file_content_src *newsrc,
 	const git_diff_options *opts)
 {
 	int error = 0;
 	git_repository *repo =
-		new_blob ? git_object_owner((const git_object *)new_blob) :
-		old_blob ? git_object_owner((const git_object *)old_blob) : NULL;
+		oldsrc->blob ? git_blob_owner(oldsrc->blob) :
+		newsrc->blob ? git_blob_owner(newsrc->blob) : NULL;
+	git_diff_file *lfile = &pd->delta.old_file, *rfile = &pd->delta.new_file;
+	git_diff_file_content *ldata = &pd->patch.ofile, *rdata = &pd->patch.nfile;
 
 	GITERR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
 
 	if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
-		const git_blob *tmp_blob;
-		const char *tmp_path;
-		tmp_blob = old_blob; old_blob = new_blob; new_blob = tmp_blob;
-		tmp_path = old_path; old_path = new_path; new_path = tmp_path;
+		void *tmp = lfile; lfile = rfile; rfile = tmp;
+		tmp = ldata; ldata = rdata; rdata = tmp;
 	}
 
 	pd->patch.delta = &pd->delta;
 
-	pd->delta.old_file.path = old_path;
-	pd->delta.new_file.path = new_path;
+	if (!oldsrc->as_path) {
+		if (newsrc->as_path)
+			oldsrc->as_path = newsrc->as_path;
+		else
+			oldsrc->as_path = newsrc->as_path = "file";
+	}
+	else if (!newsrc->as_path)
+		newsrc->as_path = oldsrc->as_path;
+
+	lfile->path = oldsrc->as_path;
+	rfile->path = newsrc->as_path;
 
-	if ((error = git_diff_file_content__init_from_blob(
-			&pd->patch.ofile, repo, opts, old_blob, &pd->delta.old_file)) < 0 ||
-		(error = git_diff_file_content__init_from_blob(
-			&pd->patch.nfile, repo, opts, new_blob, &pd->delta.new_file)) < 0)
+	if ((error = git_diff_file_content__init_from_src(
+			ldata, repo, opts, oldsrc, lfile)) < 0 ||
+		(error = git_diff_file_content__init_from_src(
+			rdata, repo, opts, newsrc, rfile)) < 0)
 		return error;
 
 	return diff_single_generate(pd, xo);
@@ -400,11 +408,9 @@ static int diff_patch_with_delta_alloc(
 	return 0;
 }
 
-int git_diff_blobs(
-	const git_blob *old_blob,
-	const char *old_path,
-	const git_blob *new_blob,
-	const char *new_path,
+static int diff_from_sources(
+	git_diff_file_content_src *oldsrc,
+	git_diff_file_content_src *newsrc,
 	const git_diff_options *opts,
 	git_diff_file_cb file_cb,
 	git_diff_hunk_cb hunk_cb,
@@ -420,26 +426,19 @@ int git_diff_blobs(
 		&xo.output, opts, file_cb, hunk_cb, data_cb, payload);
 	git_xdiff_init(&xo, opts);
 
-	if (!old_path && new_path)
-		old_path = new_path;
-	else if (!new_path && old_path)
-		new_path = old_path;
-
 	memset(&pd, 0, sizeof(pd));
-	error = diff_patch_from_blobs(
-		&pd, &xo, old_blob, old_path, new_blob, new_path, opts);
+
+	error = diff_patch_from_sources(&pd, &xo, oldsrc, newsrc, opts);
 
 	git_patch_free(&pd.patch);
 
 	return error;
 }
 
-int git_patch_from_blobs(
+static int patch_from_sources(
 	git_patch **out,
-	const git_blob *old_blob,
-	const char *old_path,
-	const git_blob *new_blob,
-	const char *new_path,
+	git_diff_file_content_src *oldsrc,
+	git_diff_file_content_src *newsrc,
 	const git_diff_options *opts)
 {
 	int error = 0;
@@ -449,17 +448,15 @@ int git_patch_from_blobs(
 	assert(out);
 	*out = NULL;
 
-	if (diff_patch_with_delta_alloc(&pd, &old_path, &new_path) < 0)
-		return -1;
+	if ((error = diff_patch_with_delta_alloc(
+			&pd, &oldsrc->as_path, &newsrc->as_path)) < 0)
+		return error;
 
 	memset(&xo, 0, sizeof(xo));
 	diff_output_to_patch(&xo.output, &pd->patch);
 	git_xdiff_init(&xo, opts);
 
-	error = diff_patch_from_blobs(
-		pd, &xo, old_blob, old_path, new_blob, new_path, opts);
-
-	if (!error)
+	if (!(error = diff_patch_from_sources(pd, &xo, oldsrc, newsrc, opts)))
 		*out = (git_patch *)pd;
 	else
 		git_patch_free((git_patch *)pd);
@@ -467,46 +464,38 @@ int git_patch_from_blobs(
 	return error;
 }
 
-static int diff_patch_from_blob_and_buffer(
-	diff_patch_with_delta *pd,
-	git_xdiff_output *xo,
+int git_diff_blobs(
 	const git_blob *old_blob,
 	const char *old_path,
-	const char *buf,
-	size_t buflen,
-	const char *buf_path,
-	const git_diff_options *opts)
+	const git_blob *new_blob,
+	const char *new_path,
+	const git_diff_options *opts,
+	git_diff_file_cb file_cb,
+	git_diff_hunk_cb hunk_cb,
+	git_diff_line_cb data_cb,
+	void *payload)
 {
-	int error = 0;
-	git_repository *repo =
-		old_blob ? git_object_owner((const git_object *)old_blob) : NULL;
-
-	GITERR_CHECK_VERSION(opts, GIT_DIFF_OPTIONS_VERSION, "git_diff_options");
-
-	pd->patch.delta = &pd->delta;
-
-	if (opts && (opts->flags & GIT_DIFF_REVERSE) != 0) {
-		pd->delta.old_file.path = buf_path;
-		pd->delta.new_file.path = old_path;
-
-		if (!(error = git_diff_file_content__init_from_raw(
-				&pd->patch.ofile, repo, opts, buf, buflen, &pd->delta.old_file)))
-			error = git_diff_file_content__init_from_blob(
-				&pd->patch.nfile, repo, opts, old_blob, &pd->delta.new_file);
-	} else {
-		pd->delta.old_file.path = old_path;
-		pd->delta.new_file.path = buf_path;
-
-		if (!(error = git_diff_file_content__init_from_blob(
-				&pd->patch.ofile, repo, opts, old_blob, &pd->delta.old_file)))
-			error = git_diff_file_content__init_from_raw(
-				&pd->patch.nfile, repo, opts, buf, buflen, &pd->delta.new_file);
-	}
-
-	if (error < 0)
-		return error;
+	git_diff_file_content_src osrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BLOB(old_blob, old_path);
+	git_diff_file_content_src nsrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BLOB(new_blob, new_path);
+	return diff_from_sources(
+		&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
+}
 
-	return diff_single_generate(pd, xo);
+int git_patch_from_blobs(
+	git_patch **out,
+	const git_blob *old_blob,
+	const char *old_path,
+	const git_blob *new_blob,
+	const char *new_path,
+	const git_diff_options *opts)
+{
+	git_diff_file_content_src osrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BLOB(old_blob, old_path);
+	git_diff_file_content_src nsrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BLOB(new_blob, new_path);
+	return patch_from_sources(out, &osrc, &nsrc, opts);
 }
 
 int git_diff_blob_to_buffer(
@@ -521,27 +510,12 @@ int git_diff_blob_to_buffer(
 	git_diff_line_cb data_cb,
 	void *payload)
 {
-	int error = 0;
-	diff_patch_with_delta pd;
-	git_xdiff_output xo;
-
-	memset(&xo, 0, sizeof(xo));
-	diff_output_init(
-		&xo.output, opts, file_cb, hunk_cb, data_cb, payload);
-	git_xdiff_init(&xo, opts);
-
-	if (!old_path && buf_path)
-		old_path = buf_path;
-	else if (!buf_path && old_path)
-		buf_path = old_path;
-
-	memset(&pd, 0, sizeof(pd));
-	error = diff_patch_from_blob_and_buffer(
-		&pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
-
-	git_patch_free(&pd.patch);
-
-	return error;
+	git_diff_file_content_src osrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BLOB(old_blob, old_path);
+	git_diff_file_content_src nsrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BUF(buf, buflen, buf_path);
+	return diff_from_sources(
+		&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
 }
 
 int git_patch_from_blob_and_buffer(
@@ -553,29 +527,49 @@ int git_patch_from_blob_and_buffer(
 	const char *buf_path,
 	const git_diff_options *opts)
 {
-	int error = 0;
-	diff_patch_with_delta *pd;
-	git_xdiff_output xo;
-
-	assert(out);
-	*out = NULL;
-
-	if (diff_patch_with_delta_alloc(&pd, &old_path, &buf_path) < 0)
-		return -1;
-
-	memset(&xo, 0, sizeof(xo));
-	diff_output_to_patch(&xo.output, &pd->patch);
-	git_xdiff_init(&xo, opts);
-
-	error = diff_patch_from_blob_and_buffer(
-		pd, &xo, old_blob, old_path, buf, buflen, buf_path, opts);
+	git_diff_file_content_src osrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BLOB(old_blob, old_path);
+	git_diff_file_content_src nsrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BUF(buf, buflen, buf_path);
+	return patch_from_sources(out, &osrc, &nsrc, opts);
+}
 
-	if (!error)
-		*out = (git_patch *)pd;
-	else
-		git_patch_free((git_patch *)pd);
+int git_diff_buffers(
+	const void *old_buf,
+	size_t old_len,
+	const char *old_path,
+	const void *new_buf,
+	size_t new_len,
+	const char *new_path,
+	const git_diff_options *opts,
+	git_diff_file_cb file_cb,
+	git_diff_hunk_cb hunk_cb,
+	git_diff_line_cb data_cb,
+	void *payload)
+{
+	git_diff_file_content_src osrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BUF(old_buf, old_len, old_path);
+	git_diff_file_content_src nsrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BUF(new_buf, new_len, new_path);
+	return diff_from_sources(
+		&osrc, &nsrc, opts, file_cb, hunk_cb, data_cb, payload);
+}
 
-	return error;
+int git_patch_from_buffers(
+	git_patch **out,
+	const void *old_buf,
+	size_t old_len,
+	const char *old_path,
+	const char *new_buf,
+	size_t new_len,
+	const char *new_path,
+	const git_diff_options *opts)
+{
+	git_diff_file_content_src osrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BUF(old_buf, old_len, old_path);
+	git_diff_file_content_src nsrc =
+		GIT_DIFF_FILE_CONTENT_SRC__BUF(new_buf, new_len, new_path);
+	return patch_from_sources(out, &osrc, &nsrc, opts);
 }
 
 int git_patch_from_diff(
diff --git a/tests/diff/blob.c b/tests/diff/blob.c
index 74df3cf85..d1fff9c5b 100644
--- a/tests/diff/blob.c
+++ b/tests/diff/blob.c
@@ -51,6 +51,20 @@ void test_diff_blob__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
+static void assert_one_modified(
+	int hunks, int lines, int ctxt, int adds, int dels, diff_expects *exp)
+{
+	cl_assert_equal_i(1, exp->files);
+	cl_assert_equal_i(1, exp->file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(0, exp->files_binary);
+
+	cl_assert_equal_i(hunks, exp->hunks);
+	cl_assert_equal_i(lines, exp->lines);
+	cl_assert_equal_i(ctxt,  exp->line_ctxt);
+	cl_assert_equal_i(adds,  exp->line_adds);
+	cl_assert_equal_i(dels,  exp->line_dels);
+}
+
 void test_diff_blob__can_compare_text_blobs(void)
 {
 	git_blob *a, *b, *c;
@@ -71,79 +85,81 @@ void test_diff_blob__can_compare_text_blobs(void)
 	/* Doing the equivalent of a `git diff -U1` on these files */
 
 	/* diff on tests/resources/attr/root_test1 */
+	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		a, NULL, b, NULL, &opts,
 		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+	assert_one_modified(1, 6, 1, 5, 0, &expected);
 
-	cl_assert_equal_i(1, expected.files);
-	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(0, expected.files_binary);
-
-	cl_assert_equal_i(1, expected.hunks);
-	cl_assert_equal_i(6, expected.lines);
-	cl_assert_equal_i(1, expected.line_ctxt);
-	cl_assert_equal_i(5, expected.line_adds);
-	cl_assert_equal_i(0, expected.line_dels);
+	/* same diff but use direct buffers */
+	memset(&expected, 0, sizeof(expected));
+	cl_git_pass(git_diff_buffers(
+		git_blob_rawcontent(a), (size_t)git_blob_rawsize(a), NULL,
+		git_blob_rawcontent(b), (size_t)git_blob_rawsize(b), NULL, &opts,
+		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+	assert_one_modified(1, 6, 1, 5, 0, &expected);
 
 	/* diff on tests/resources/attr/root_test2 */
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		b, NULL, c, NULL, &opts,
 		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
-
-	cl_assert_equal_i(1, expected.files);
-	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(0, expected.files_binary);
-
-	cl_assert_equal_i(1, expected.hunks);
-	cl_assert_equal_i(15, expected.lines);
-	cl_assert_equal_i(3, expected.line_ctxt);
-	cl_assert_equal_i(9, expected.line_adds);
-	cl_assert_equal_i(3, expected.line_dels);
+	assert_one_modified(1, 15, 3, 9, 3, &expected);
 
 	/* diff on tests/resources/attr/root_test3 */
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		a, NULL, c, NULL, &opts,
 		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
-
-	cl_assert_equal_i(1, expected.files);
-	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(0, expected.files_binary);
-
-	cl_assert_equal_i(1, expected.hunks);
-	cl_assert_equal_i(13, expected.lines);
-	cl_assert_equal_i(0, expected.line_ctxt);
-	cl_assert_equal_i(12, expected.line_adds);
-	cl_assert_equal_i(1, expected.line_dels);
+	assert_one_modified(1, 13, 0, 12, 1, &expected);
 
 	memset(&expected, 0, sizeof(expected));
 	cl_git_pass(git_diff_blobs(
 		c, NULL, d, NULL, &opts,
 		diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
-
-	cl_assert_equal_i(1, expected.files);
-	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(0, expected.files_binary);
-
-	cl_assert_equal_i(2, expected.hunks);
-	cl_assert_equal_i(14, expected.lines);
-	cl_assert_equal_i(4, expected.line_ctxt);
-	cl_assert_equal_i(6, expected.line_adds);
-	cl_assert_equal_i(4, expected.line_dels);
+	assert_one_modified(2, 14, 4, 6, 4, &expected);
 
 	git_blob_free(a);
 	git_blob_free(b);
 	git_blob_free(c);
 }
 
+static void assert_patch_matches_blobs(
+	git_patch *p, git_blob *a, git_blob *b,
+	int hunks, int l0, int l1, int ctxt, int adds, int dels)
+{
+	const git_diff_delta *delta;
+	size_t tc, ta, td;
+
+	cl_assert(p != NULL);
+
+	delta = git_patch_get_delta(p);
+	cl_assert(delta != NULL);
+
+	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
+	cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.id));
+	cl_assert_equal_sz(git_blob_rawsize(a), delta->old_file.size);
+	cl_assert(git_oid_equal(git_blob_id(b), &delta->new_file.id));
+	cl_assert_equal_sz(git_blob_rawsize(b), delta->new_file.size);
+
+	cl_assert_equal_i(hunks, (int)git_patch_num_hunks(p));
+
+	if (hunks > 0)
+		cl_assert_equal_i(l0, git_patch_num_lines_in_hunk(p, 0));
+	if (hunks > 1)
+		cl_assert_equal_i(l1, git_patch_num_lines_in_hunk(p, 1));
+
+	cl_git_pass(git_patch_line_stats(&tc, &ta, &td, p));
+	cl_assert_equal_i(ctxt, (int)tc);
+	cl_assert_equal_i(adds, (int)ta);
+	cl_assert_equal_i(dels, (int)td);
+}
+
 void test_diff_blob__can_compare_text_blobs_with_patch(void)
 {
 	git_blob *a, *b, *c;
 	git_oid a_oid, b_oid, c_oid;
 	git_patch *p;
-	const git_diff_delta *delta;
-	size_t tc, ta, td;
 
 	/* tests/resources/attr/root_test1 */
 	cl_git_pass(git_oid_fromstrn(&a_oid, "45141a79", 8));
@@ -161,92 +177,22 @@ void test_diff_blob__can_compare_text_blobs_with_patch(void)
 
 	/* diff on tests/resources/attr/root_test1 */
 	cl_git_pass(git_patch_from_blobs(&p, a, NULL, b, NULL, &opts));
-
-	cl_assert(p != NULL);
-
-	delta = git_patch_get_delta(p);
-	cl_assert(delta != NULL);
-	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.id));
-	cl_assert_equal_sz(git_blob_rawsize(a), delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(b), &delta->new_file.id));
-	cl_assert_equal_sz(git_blob_rawsize(b), delta->new_file.size);
-
-	cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
-	cl_assert_equal_i(6, git_patch_num_lines_in_hunk(p, 0));
-
-	cl_git_pass(git_patch_line_stats(&tc, &ta, &td, p));
-	cl_assert_equal_i(1, (int)tc);
-	cl_assert_equal_i(5, (int)ta);
-	cl_assert_equal_i(0, (int)td);
-
+	assert_patch_matches_blobs(p, a, b, 1, 6, 0, 1, 5, 0);
 	git_patch_free(p);
 
 	/* diff on tests/resources/attr/root_test2 */
 	cl_git_pass(git_patch_from_blobs(&p, b, NULL, c, NULL, &opts));
-
-	cl_assert(p != NULL);
-
-	delta = git_patch_get_delta(p);
-	cl_assert(delta != NULL);
-	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(b), &delta->old_file.id));
-	cl_assert_equal_sz(git_blob_rawsize(b), delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(c), &delta->new_file.id));
-	cl_assert_equal_sz(git_blob_rawsize(c), delta->new_file.size);
-
-	cl_assert_equal_i(1, (int)git_patch_num_hunks(p));
-	cl_assert_equal_i(15, git_patch_num_lines_in_hunk(p, 0));
-
-	cl_git_pass(git_patch_line_stats(&tc, &ta, &td, p));
-	cl_assert_equal_i(3, (int)tc);
-	cl_assert_equal_i(9, (int)ta);
-	cl_assert_equal_i(3, (int)td);
-
+	assert_patch_matches_blobs(p, b, c, 1, 15, 0, 3, 9, 3);
 	git_patch_free(p);
 
 	/* diff on tests/resources/attr/root_test3 */
 	cl_git_pass(git_patch_from_blobs(&p, a, NULL, c, NULL, &opts));
-
-	cl_assert(p != NULL);
-
-	delta = git_patch_get_delta(p);
-	cl_assert(delta != NULL);
-	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(a), &delta->old_file.id));
-	cl_assert_equal_sz(git_blob_rawsize(a), delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(c), &delta->new_file.id));
-	cl_assert_equal_sz(git_blob_rawsize(c), delta->new_file.size);
-
-	cl_git_pass(git_patch_line_stats(&tc, &ta, &td, p));
-	cl_assert_equal_i(0, (int)tc);
-	cl_assert_equal_i(12, (int)ta);
-	cl_assert_equal_i(1, (int)td);
-
+	assert_patch_matches_blobs(p, a, c, 1, 13, 0, 0, 12, 1);
 	git_patch_free(p);
 
 	/* one more */
 	cl_git_pass(git_patch_from_blobs(&p, c, NULL, d, NULL, &opts));
-
-	cl_assert(p != NULL);
-
-	delta = git_patch_get_delta(p);
-	cl_assert(delta != NULL);
-	cl_assert_equal_i(GIT_DELTA_MODIFIED, delta->status);
-	cl_assert(git_oid_equal(git_blob_id(c), &delta->old_file.id));
-	cl_assert_equal_sz(git_blob_rawsize(c), delta->old_file.size);
-	cl_assert(git_oid_equal(git_blob_id(d), &delta->new_file.id));
-	cl_assert_equal_sz(git_blob_rawsize(d), delta->new_file.size);
-
-	cl_assert_equal_i(2, (int)git_patch_num_hunks(p));
-	cl_assert_equal_i(5, git_patch_num_lines_in_hunk(p, 0));
-	cl_assert_equal_i(9, git_patch_num_lines_in_hunk(p, 1));
-
-	cl_git_pass(git_patch_line_stats(&tc, &ta, &td, p));
-	cl_assert_equal_i(4, (int)tc);
-	cl_assert_equal_i(6, (int)ta);
-	cl_assert_equal_i(4, (int)td);
-
+	assert_patch_matches_blobs(p, c, d, 2, 5, 9, 4, 6, 4);
 	git_patch_free(p);
 
 	git_blob_free(a);
@@ -656,14 +602,7 @@ void test_diff_blob__can_compare_blob_to_buffer(void)
 
 	/* diff from blob a to content of b */
 	quick_diff_blob_to_str(a, NULL, b_content, 0, NULL);
-	cl_assert_equal_i(1, expected.files);
-	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(0, expected.files_binary);
-	cl_assert_equal_i(1, expected.hunks);
-	cl_assert_equal_i(6, expected.lines);
-	cl_assert_equal_i(1, expected.line_ctxt);
-	cl_assert_equal_i(5, expected.line_adds);
-	cl_assert_equal_i(0, expected.line_dels);
+	assert_one_modified(1, 6, 1, 5, 0, &expected);
 
 	/* diff from blob a to content of a */
 	opts.flags |= GIT_DIFF_INCLUDE_UNMODIFIED;
@@ -910,14 +849,7 @@ void test_diff_blob__using_path_and_attributes(void)
 	changed = "Hello from the root\nMore lines\nAnd more\nGo here\n";
 
 	quick_diff_blob_to_str(nonbin, NULL, changed, 0, NULL);
-	cl_assert_equal_i(1, expected.files);
-	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(0, expected.files_binary);
-	cl_assert_equal_i(1, expected.hunks);
-	cl_assert_equal_i(3, expected.lines);
-	cl_assert_equal_i(0, expected.line_ctxt);
-	cl_assert_equal_i(3, expected.line_adds);
-	cl_assert_equal_i(0, expected.line_dels);
+	assert_one_modified(1, 3, 0, 3, 0, &expected);
 
 	quick_diff_blob_to_str(nonbin, "foo/bar.binary", changed, 0, NULL);
 	cl_assert_equal_i(1, expected.files);
@@ -925,29 +857,12 @@ void test_diff_blob__using_path_and_attributes(void)
 	cl_assert_equal_i(1, expected.files_binary);
 	cl_assert_equal_i(0, expected.hunks);
 	cl_assert_equal_i(0, expected.lines);
-	cl_assert_equal_i(0, expected.line_ctxt);
-	cl_assert_equal_i(0, expected.line_adds);
-	cl_assert_equal_i(0, expected.line_dels);
 
 	quick_diff_blob_to_str(nonbin, "foo/bar.textary", changed, 0, NULL);
-	cl_assert_equal_i(1, expected.files);
-	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(0, expected.files_binary);
-	cl_assert_equal_i(1, expected.hunks);
-	cl_assert_equal_i(3, expected.lines);
-	cl_assert_equal_i(0, expected.line_ctxt);
-	cl_assert_equal_i(3, expected.line_adds);
-	cl_assert_equal_i(0, expected.line_dels);
+	assert_one_modified(1, 3, 0, 3, 0, &expected);
 
 	quick_diff_blob_to_str(nonbin, "foo/bar.alphary", changed, 0, NULL);
-	cl_assert_equal_i(1, expected.files);
-	cl_assert_equal_i(1, expected.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(0, expected.files_binary);
-	cl_assert_equal_i(1, expected.hunks);
-	cl_assert_equal_i(3, expected.lines);
-	cl_assert_equal_i(0, expected.line_ctxt);
-	cl_assert_equal_i(3, expected.line_adds);
-	cl_assert_equal_i(0, expected.line_dels);
+	assert_one_modified(1, 3, 0, 3, 0, &expected);
 
 	cl_git_pass(git_patch_from_blob_and_buffer(
 		&p, nonbin, "zzz.normal", changed, strlen(changed), NULL, &opts));
@@ -1066,3 +981,28 @@ void test_diff_blob__using_path_and_attributes(void)
 	git_blob_free(nonbin);
 	git_blob_free(bin);
 }
+
+void test_diff_blob__can_compare_buffer_to_buffer(void)
+{
+	const char *a = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\n";
+	const char *b = "a\nB\nc\nd\nE\nF\nh\nj\nk\n";
+
+	opts.interhunk_lines = 0;
+	opts.context_lines = 0;
+
+	memset(&expected, 0, sizeof(expected));
+
+	cl_git_pass(git_diff_buffers(
+		a, strlen(a), NULL, b, strlen(b), NULL,
+		&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+	assert_one_modified(4, 9, 0, 4, 5, &expected);
+
+	opts.flags ^= GIT_DIFF_REVERSE;
+
+	memset(&expected, 0, sizeof(expected));
+
+	cl_git_pass(git_diff_buffers(
+		a, strlen(a), NULL, b, strlen(b), NULL,
+		&opts, diff_file_cb, diff_hunk_cb, diff_line_cb, &expected));
+	assert_one_modified(4, 9, 0, 5, 4, &expected);
+}
-- 
cgit v1.2.3


From 1d08b72e4fbc474719baec127d7911cc116dec48 Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Sun, 2 Mar 2014 19:14:20 +0800
Subject: Add unit test to show git_branch_create() fails if attempt to force
 create current branch

---
 tests/refs/branches/create.c | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index abe5f5940..d4b0763da 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -66,6 +66,25 @@ void test_refs_branches_create__can_force_create_over_an_existing_branch(void)
 	cl_assert_equal_s("refs/heads/br2", git_reference_name(branch));
 }
 
+void test_refs_branches_create__cannot_force_create_over_current_branch(void)
+{
+	const git_oid *oid;
+	git_reference *branch2;
+	retrieve_known_commit(&target, repo);
+
+	cl_git_pass(git_branch_lookup(&branch2, repo, "master", GIT_BRANCH_LOCAL));
+	cl_assert_equal_s("refs/heads/master", git_reference_name(branch2));
+	cl_assert_equal_i(true, git_branch_is_head(branch2));
+	oid = git_reference_target(branch2);
+
+	cl_git_fail_with(-1, git_branch_create(&branch, repo, "master", target, 1, NULL, NULL));
+	branch = NULL;
+	cl_git_pass(git_branch_lookup(&branch, repo, "master", GIT_BRANCH_LOCAL));
+	cl_assert_equal_s("refs/heads/master", git_reference_name(branch));
+	cl_git_pass(git_oid_cmp(git_reference_target(branch), oid));
+	git_reference_free(branch2);
+}
+
 void test_refs_branches_create__creating_a_branch_with_an_invalid_name_returns_EINVALIDSPEC(void)
 {
 	retrieve_known_commit(&target, repo);
-- 
cgit v1.2.3


From 0330469f6d0ee51edba84df448359603b79ced55 Mon Sep 17 00:00:00 2001
From: Miha <miha.ravselj@ib-caddy.si>
Date: Mon, 3 Mar 2014 11:42:25 +0100
Subject: - general.c reverted to original( before pr state )

---
 examples/general.c | 82 ++++++++++++++++++++++++++++--------------------------
 1 file changed, 43 insertions(+), 39 deletions(-)

diff --git a/examples/general.c b/examples/general.c
index 235055906..ae8756338 100644
--- a/examples/general.c
+++ b/examples/general.c
@@ -71,43 +71,6 @@ int main (int argc, char** argv)
   int error;
   const char *repo_path = (argc > 1) ? argv[1] : "/opt/libgit2-test/.git";
   git_repository *repo;
-  char* hex;
-  git_oid oid;
-  char out[41];
-  git_odb* odb;
-  git_odb_object *obj;
-  git_otype otype;
-  const unsigned char *data;
-  const char *str_type;
-  git_commit* commit;
-  const git_signature *author, *cmtter;
-  const char *message;
-  time_t ctime;
-  unsigned int parents, p;
-  git_oid tree_id, parent_id, commit_id;
-  git_tree *tree;
-  git_commit *parent;
-  git_tag *tag;
-  const char *tmessage, *tname;
-  git_otype ttype;
-  const git_tree_entry *entry;
-  git_object *objt;
-  size_t cnt;
-  git_blob *blob;
-  git_revwalk *walk;
-  git_commit *wcommit;
-  const git_signature *cauth;
-  const char *cmsg;
-  git_index *index;
-  unsigned int i, ecount;
-  git_strarray ref_list;
-  const char *refname;
-  git_reference *ref;
-  const char *email;
-  int32_t j;
-  git_config *cfg;
-  char config_path[256];
-
 
   error = git_repository_open(&repo, repo_path);
   check_error(error, "opening repository");
@@ -117,11 +80,12 @@ int main (int argc, char** argv)
   // For our first example, we will convert a 40 character hex value to the
   // 20 byte raw SHA1 value.
   printf("*Hex to Raw*\n");
-  hex = "4a202b346bb0fb0db7eff3cffeb3c70babbd2045";
+  char hex[] = "4a202b346bb0fb0db7eff3cffeb3c70babbd2045";
 
   // The `git_oid` is the structure that keeps the SHA value. We will use
   // this throughout the example for storing the value of the current SHA
   // key we're working with.
+  git_oid oid;
   git_oid_fromstr(&oid, hex);
 
   // Once we've converted the string into the oid value, we can get the raw
@@ -130,6 +94,7 @@ int main (int argc, char** argv)
   // Next we will convert the 20 byte raw SHA1 value to a human readable 40
   // char hex value.
   printf("\n*Raw to Hex*\n");
+  char out[41];
   out[40] = '\0';
 
   // If you have a oid, you can easily get the hex value of the SHA as well.
@@ -144,11 +109,16 @@ int main (int argc, char** argv)
   // repository.
   //
   // [odb]: http://libgit2.github.com/libgit2/#HEAD/group/odb
+  git_odb *odb;
   git_repository_odb(&odb, repo);
 
   // #### Raw Object Reading
 
   printf("\n*Raw Object Read*\n");
+  git_odb_object *obj;
+  git_otype otype;
+  const unsigned char *data;
+  const char *str_type;
 
   // We can read raw objects directly from the object database if we have
   // the oid (SHA) of the object.  This allows us to access objects without
@@ -207,11 +177,17 @@ int main (int argc, char** argv)
 
   printf("\n*Commit Parsing*\n");
 
+  git_commit *commit;
   git_oid_fromstr(&oid, "8496071c1b46c854b31185ea97743be6a8774479");
 
   error = git_commit_lookup(&commit, repo, &oid);
   check_error(error, "looking up commit");
 
+  const git_signature *author, *cmtter;
+  const char *message;
+  time_t ctime;
+  unsigned int parents, p;
+
   // Each of the properties of the commit object are accessible via methods,
   // including commonly needed variations, such as `git_commit_time` which
   // returns the author time and `git_commit_message` which gives you the
@@ -253,6 +229,9 @@ int main (int argc, char** argv)
   // [cd]: http://libgit2.github.com/libgit2/#HEAD/group/commit
 
   printf("\n*Commit Writing*\n");
+  git_oid tree_id, parent_id, commit_id;
+  git_tree *tree;
+  git_commit *parent;
 
   // Creating signatures for an authoring identity and time is simple.  You
   // will need to do this to specify who created a commit and when.  Default
@@ -298,6 +277,9 @@ int main (int argc, char** argv)
   //
   // [tm]: http://libgit2.github.com/libgit2/#HEAD/group/tag
   printf("\n*Tag Parsing*\n");
+  git_tag *tag;
+  const char *tmessage, *tname;
+  git_otype ttype;
 
   // We create an oid for the tag object if we know the SHA and look it up
   // the same way that we would a commit (or any other object).
@@ -328,13 +310,16 @@ int main (int argc, char** argv)
   // [tp]: http://libgit2.github.com/libgit2/#HEAD/group/tree
   printf("\n*Tree Parsing*\n");
 
+  const git_tree_entry *entry;
+  git_object *objt;
+
   // Create the oid and lookup the tree object just like the other objects.
   git_oid_fromstr(&oid, "2a741c18ac5ff082a7caaec6e74db3075a1906b5");
   git_tree_lookup(&tree, repo, &oid);
 
   // Getting the count of entries in the tree so you can iterate over them
   // if you want to.
-  cnt = git_tree_entrycount(tree); // 3
+  size_t cnt = git_tree_entrycount(tree); // 3
   printf("tree entries: %d\n", (int)cnt);
 
   entry = git_tree_entry_byindex(tree, 0);
@@ -366,6 +351,7 @@ int main (int argc, char** argv)
   // [ba]: http://libgit2.github.com/libgit2/#HEAD/group/blob
 
   printf("\n*Blob Parsing*\n");
+  git_blob *blob;
 
   git_oid_fromstr(&oid, "1385f264afb75a56a5bec74243be9b367ba4ca08");
   git_blob_lookup(&blob, repo, &oid);
@@ -390,6 +376,8 @@ int main (int argc, char** argv)
   // [rw]: http://libgit2.github.com/libgit2/#HEAD/group/revwalk
 
   printf("\n*Revwalking*\n");
+  git_revwalk *walk;
+  git_commit *wcommit;
 
   git_oid_fromstr(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644");
 
@@ -405,6 +393,9 @@ int main (int argc, char** argv)
   git_revwalk_sorting(walk, GIT_SORT_TOPOLOGICAL | GIT_SORT_REVERSE);
   git_revwalk_push(walk, &oid);
 
+  const git_signature *cauth;
+  const char *cmsg;
+
   // Now that we have the starting point pushed onto the walker, we start
   // asking for ancestors. It will return them in the sorting order we asked
   // for as commit oids.  We can then lookup and parse the commited pointed
@@ -436,6 +427,9 @@ int main (int argc, char** argv)
 
   printf("\n*Index Walking*\n");
 
+  git_index *index;
+  unsigned int i, ecount;
+
   // You can either open the index from the standard location in an open
   // repository, as we're doing here, or you can open and manipulate any
   // index file with `git_index_open_bare()`. The index for the repository
@@ -471,8 +465,12 @@ int main (int argc, char** argv)
 
   // Here we will implement something like `git for-each-ref` simply listing
   // out all available references and the object SHA they resolve to.
+  git_strarray ref_list;
   git_reference_list(&ref_list, repo);
 
+  const char *refname;
+  git_reference *ref;
+
   // Now that we have the list of reference names, we can lookup each ref
   // one at a time and resolve them to the SHA, then print both values out.
   for (i = 0; i < ref_list.count; ++i) {
@@ -505,7 +503,13 @@ int main (int argc, char** argv)
 
   printf("\n*Config Listing*\n");
 
+  const char *email;
+  int32_t j;
+
+  git_config *cfg;
+
   // Open a config object so we can read global values from it.
+  char config_path[256];
   sprintf(config_path, "%s/config", repo_path);
   check_error(git_config_open_ondisk(&cfg, config_path), "opening config");
 
-- 
cgit v1.2.3


From 058956ce7f76c0955a8aea77831a22838ec3ede4 Mon Sep 17 00:00:00 2001
From: Miha <miha.ravselj@ib-caddy.si>
Date: Mon, 3 Mar 2014 11:47:06 +0100
Subject: - CMakeLists.txt small fix

---
 CMakeLists.txt | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 27cf1a558..4ecb81ced 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -21,8 +21,7 @@ INCLUDE(CheckLibraryExists)
 
 # Build options
 #
-OPTION( SONAME			
-	"Set the (SO)VERSION of the target"		ON  )
+OPTION( SONAME				"Set the (SO)VERSION of the target"		ON  )
 OPTION( BUILD_SHARED_LIBS	"Build Shared Library (OFF for Static)"	ON  )
 OPTION( THREADSAFE			"Build libgit2 as threadsafe"			OFF )
 OPTION( BUILD_CLAR			"Build Tests using the Clar suite"		ON  )
-- 
cgit v1.2.3


From 6874cafd84b70f6f83fdcf81e55f87c8d62bb07e Mon Sep 17 00:00:00 2001
From: Miha <miha.ravselj@ib-caddy.si>
Date: Mon, 3 Mar 2014 12:08:17 +0100
Subject: cmake examples change so that general.c is off by default

---
 CMakeLists.txt          | 2 +-
 examples/CMakeLists.txt | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4ecb81ced..cca2a120c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -58,7 +58,7 @@ IF(MSVC)
 	# HTTP transport, invoke CMake with the "-DWINHTTP=OFF" argument.
 	OPTION( WINHTTP			"Use Win32 WinHTTP routines"	ON  )
 
-	ADD_DEFINITIONS(-D_SCL_SECURE_NO_WARNINGS)
+	ADD_DEFINITIONS(-D_SCL_SECURE_NO_WARNINGS)
 	ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
 	ADD_DEFINITIONS(-D_CRT_NONSTDC_NO_DEPRECATE)
 ENDIF()
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 596be45ed..d3908e0ff 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -6,10 +6,14 @@ ELSE()
 	TARGET_LINK_LIBRARIES(cgit2 git2 pthread)
 ENDIF()
 
+OPTION( BUILD_EXAMPLES_GENERAL 		"Build general example"		OFF )
+
 FILE(GLOB SRC_EXAMPLE_APPS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.c)
 FOREACH(src_app ${SRC_EXAMPLE_APPS})
 	STRING(REPLACE ".c" "" app_name ${src_app})
-	IF(NOT ${app_name} STREQUAL "common")
+	IF(${app_name} STREQUAL "general" AND BUILD_EXAMPLES_GENERAL OR
+		NOT ${app_name} STREQUAL "general" AND NOT ${app_name} STREQUAL "common"
+	)
 		ADD_EXECUTABLE(${app_name} ${src_app} "common.c")
 		TARGET_LINK_LIBRARIES(${app_name} git2)
 	ENDIF()
-- 
cgit v1.2.3


From c9f5298b0e7a1c21da35618be33ae651cbcdbcef Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Mon, 3 Mar 2014 12:09:17 +0100
Subject: caps: Rename to features to avoid confusion

---
 include/git2/common.h | 21 +++++++++++++--------
 src/settings.c        |  8 ++++----
 tests/core/caps.c     | 31 -------------------------------
 tests/core/features.c | 31 +++++++++++++++++++++++++++++++
 4 files changed, 48 insertions(+), 43 deletions(-)
 delete mode 100644 tests/core/caps.c
 create mode 100644 tests/core/features.c

diff --git a/include/git2/common.h b/include/git2/common.h
index 492715447..49ffd01d6 100644
--- a/include/git2/common.h
+++ b/include/git2/common.h
@@ -94,29 +94,34 @@ GIT_BEGIN_DECL
 GIT_EXTERN(void) git_libgit2_version(int *major, int *minor, int *rev);
 
 /**
- * Combinations of these values describe the capabilities of libgit2.
+ * Combinations of these values describe the features with which libgit2
+ * was compiled
  */
 typedef enum {
-	GIT_CAP_THREADS			= ( 1 << 0 ),
-	GIT_CAP_HTTPS			= ( 1 << 1 ),
-	GIT_CAP_SSH				= ( 1 << 2 ),
+	GIT_HAS_THREADS	= (1 << 0),
+	GIT_HAS_HTTPS = (1 << 1),
+	GIT_HAS_SSH = (1 << 2),
 } git_cap_t;
 
 /**
  * Query compile time options for libgit2.
  *
- * @return A combination of GIT_CAP_* values.
+ * @return A combination of GIT_HAS_* values.
  *
- * - GIT_CAP_THREADS
+ * - GIT_HAS_THREADS
  *   Libgit2 was compiled with thread support. Note that thread support is
  *   still to be seen as a 'work in progress' - basic object lookups are
  *   believed to be threadsafe, but other operations may not be.
  *
- * - GIT_CAP_HTTPS
+ * - GIT_HAS_HTTPS
  *   Libgit2 supports the https:// protocol. This requires the openssl
  *   library to be found when compiling libgit2.
+ *
+ * - GIT_HAS_SSH
+ *   Libgit2 supports the SSH protocol for network operations. This requires
+ *   the openssh to be found when compiling libgit2
  */
-GIT_EXTERN(int) git_libgit2_capabilities(void);
+GIT_EXTERN(int) git_libgit2_features(void);
 
 
 typedef enum {
diff --git a/src/settings.c b/src/settings.c
index 3856735f7..644e71cca 100644
--- a/src/settings.c
+++ b/src/settings.c
@@ -17,17 +17,17 @@ void git_libgit2_version(int *major, int *minor, int *rev)
 	*rev = LIBGIT2_VER_REVISION;
 }
 
-int git_libgit2_capabilities()
+int git_libgit2_features()
 {
 	return 0
 #ifdef GIT_THREADS
-		| GIT_CAP_THREADS
+		| GIT_HAS_THREADS
 #endif
 #if defined(GIT_SSL) || defined(GIT_WINHTTP)
-		| GIT_CAP_HTTPS
+		| GIT_HAS_HTTPS
 #endif
 #if defined(GIT_SSH)
-		| GIT_CAP_SSH
+		| GIT_HAS_SSH
 #endif
 	;
 }
diff --git a/tests/core/caps.c b/tests/core/caps.c
deleted file mode 100644
index 68a518ed7..000000000
--- a/tests/core/caps.c
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "clar_libgit2.h"
-
-void test_core_caps__0(void)
-{
-	int major, minor, rev, caps;
-
-	git_libgit2_version(&major, &minor, &rev);
-	cl_assert_equal_i(LIBGIT2_VER_MAJOR, major);
-	cl_assert_equal_i(LIBGIT2_VER_MINOR, minor);
-	cl_assert_equal_i(LIBGIT2_VER_REVISION, rev);
-
-	caps = git_libgit2_capabilities();
-
-#ifdef GIT_THREADS
-	cl_assert((caps & GIT_CAP_THREADS) != 0);
-#else
-	cl_assert((caps & GIT_CAP_THREADS) == 0);
-#endif
-
-#if defined(GIT_SSL) || defined(GIT_WINHTTP)
-	cl_assert((caps & GIT_CAP_HTTPS) != 0);
-#else
-	cl_assert((caps & GIT_CAP_HTTPS) == 0);
-#endif
-
-#if defined(GIT_SSH)
-	cl_assert((caps & GIT_CAP_SSH) != 0);
-#else
-	cl_assert((caps & GIT_CAP_SSH) == 0);
-#endif
-}
diff --git a/tests/core/features.c b/tests/core/features.c
new file mode 100644
index 000000000..b8c9003ba
--- /dev/null
+++ b/tests/core/features.c
@@ -0,0 +1,31 @@
+#include "clar_libgit2.h"
+
+void test_core_features__0(void)
+{
+	int major, minor, rev, caps;
+
+	git_libgit2_version(&major, &minor, &rev);
+	cl_assert_equal_i(LIBGIT2_VER_MAJOR, major);
+	cl_assert_equal_i(LIBGIT2_VER_MINOR, minor);
+	cl_assert_equal_i(LIBGIT2_VER_REVISION, rev);
+
+	caps = git_libgit2_features();
+
+#ifdef GIT_THREADS
+	cl_assert((caps & GIT_HAS_THREADS) != 0);
+#else
+	cl_assert((caps & GIT_HAS_THREADS) == 0);
+#endif
+
+#if defined(GIT_SSL) || defined(GIT_WINHTTP)
+	cl_assert((caps & GIT_HAS_HTTPS) != 0);
+#else
+	cl_assert((caps & GIT_HAS_HTTPS) == 0);
+#endif
+
+#if defined(GIT_SSH)
+	cl_assert((caps & GIT_HAS_SSH) != 0);
+#else
+	cl_assert((caps & GIT_HAS_SSH) == 0);
+#endif
+}
-- 
cgit v1.2.3


From 2491c416ed84fb575506b0b58fb234ab2daa24fb Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Mon, 3 Mar 2014 12:13:17 +0100
Subject: caps: Rename the enum name too!

---
 include/git2/common.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/common.h b/include/git2/common.h
index 49ffd01d6..7effc8dba 100644
--- a/include/git2/common.h
+++ b/include/git2/common.h
@@ -101,7 +101,7 @@ typedef enum {
 	GIT_HAS_THREADS	= (1 << 0),
 	GIT_HAS_HTTPS = (1 << 1),
 	GIT_HAS_SSH = (1 << 2),
-} git_cap_t;
+} git_feature_t;
 
 /**
  * Query compile time options for libgit2.
-- 
cgit v1.2.3


From ebb3c506fd880a383ea66679865e16e24253cb3a Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Mon, 3 Mar 2014 12:40:25 +0100
Subject: features: Rename `_HAS_` to `_FEATURE_`

---
 include/git2/common.h | 14 +++++++-------
 src/settings.c        |  6 +++---
 tests/core/features.c | 12 ++++++------
 3 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/include/git2/common.h b/include/git2/common.h
index 7effc8dba..4b3e02e41 100644
--- a/include/git2/common.h
+++ b/include/git2/common.h
@@ -98,26 +98,26 @@ GIT_EXTERN(void) git_libgit2_version(int *major, int *minor, int *rev);
  * was compiled
  */
 typedef enum {
-	GIT_HAS_THREADS	= (1 << 0),
-	GIT_HAS_HTTPS = (1 << 1),
-	GIT_HAS_SSH = (1 << 2),
+	GIT_FEATURE_THREADS	= (1 << 0),
+	GIT_FEATURE_HTTPS = (1 << 1),
+	GIT_FEATURE_SSH = (1 << 2),
 } git_feature_t;
 
 /**
  * Query compile time options for libgit2.
  *
- * @return A combination of GIT_HAS_* values.
+ * @return A combination of GIT_FEATURE_* values.
  *
- * - GIT_HAS_THREADS
+ * - GIT_FEATURE_THREADS
  *   Libgit2 was compiled with thread support. Note that thread support is
  *   still to be seen as a 'work in progress' - basic object lookups are
  *   believed to be threadsafe, but other operations may not be.
  *
- * - GIT_HAS_HTTPS
+ * - GIT_FEATURE_HTTPS
  *   Libgit2 supports the https:// protocol. This requires the openssl
  *   library to be found when compiling libgit2.
  *
- * - GIT_HAS_SSH
+ * - GIT_FEATURE_SSH
  *   Libgit2 supports the SSH protocol for network operations. This requires
  *   the openssh to be found when compiling libgit2
  */
diff --git a/src/settings.c b/src/settings.c
index 644e71cca..9308f94ec 100644
--- a/src/settings.c
+++ b/src/settings.c
@@ -21,13 +21,13 @@ int git_libgit2_features()
 {
 	return 0
 #ifdef GIT_THREADS
-		| GIT_HAS_THREADS
+		| GIT_FEATURE_THREADS
 #endif
 #if defined(GIT_SSL) || defined(GIT_WINHTTP)
-		| GIT_HAS_HTTPS
+		| GIT_FEATURE_HTTPS
 #endif
 #if defined(GIT_SSH)
-		| GIT_HAS_SSH
+		| GIT_FEATURE_SSH
 #endif
 	;
 }
diff --git a/tests/core/features.c b/tests/core/features.c
index b8c9003ba..3ce02f4d6 100644
--- a/tests/core/features.c
+++ b/tests/core/features.c
@@ -12,20 +12,20 @@ void test_core_features__0(void)
 	caps = git_libgit2_features();
 
 #ifdef GIT_THREADS
-	cl_assert((caps & GIT_HAS_THREADS) != 0);
+	cl_assert((caps & GIT_FEATURE_THREADS) != 0);
 #else
-	cl_assert((caps & GIT_HAS_THREADS) == 0);
+	cl_assert((caps & GIT_FEATURE_THREADS) == 0);
 #endif
 
 #if defined(GIT_SSL) || defined(GIT_WINHTTP)
-	cl_assert((caps & GIT_HAS_HTTPS) != 0);
+	cl_assert((caps & GIT_FEATURE_HTTPS) != 0);
 #else
-	cl_assert((caps & GIT_HAS_HTTPS) == 0);
+	cl_assert((caps & GIT_FEATURE_HTTPS) == 0);
 #endif
 
 #if defined(GIT_SSH)
-	cl_assert((caps & GIT_HAS_SSH) != 0);
+	cl_assert((caps & GIT_FEATURE_SSH) != 0);
 #else
-	cl_assert((caps & GIT_HAS_SSH) == 0);
+	cl_assert((caps & GIT_FEATURE_SSH) == 0);
 #endif
 }
-- 
cgit v1.2.3


From 96484ecd9e133a08861aabd7391d48f470d64bd5 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@gmail.com>
Date: Mon, 3 Mar 2014 12:59:35 +0100
Subject: Fix the description for `GIT_FEATURE_SSH`.

---
 include/git2/common.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/common.h b/include/git2/common.h
index 4b3e02e41..1dca8e837 100644
--- a/include/git2/common.h
+++ b/include/git2/common.h
@@ -119,7 +119,7 @@ typedef enum {
  *
  * - GIT_FEATURE_SSH
  *   Libgit2 supports the SSH protocol for network operations. This requires
- *   the openssh to be found when compiling libgit2
+ *   the libssh2 library to be found when compiling libgit2
  */
 GIT_EXTERN(int) git_libgit2_features(void);
 
-- 
cgit v1.2.3


From b43f35fde2fa977870280d685b6e96418b82752e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Miha=20Rav=C5=A1elj?= <miha.ravselj@gmail.com>
Date: Mon, 3 Mar 2014 14:59:50 +0100
Subject: - examples CMakeLists.txt reverted to previous state

---
 examples/CMakeLists.txt | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index d3908e0ff..596be45ed 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -6,14 +6,10 @@ ELSE()
 	TARGET_LINK_LIBRARIES(cgit2 git2 pthread)
 ENDIF()
 
-OPTION( BUILD_EXAMPLES_GENERAL 		"Build general example"		OFF )
-
 FILE(GLOB SRC_EXAMPLE_APPS RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.c)
 FOREACH(src_app ${SRC_EXAMPLE_APPS})
 	STRING(REPLACE ".c" "" app_name ${src_app})
-	IF(${app_name} STREQUAL "general" AND BUILD_EXAMPLES_GENERAL OR
-		NOT ${app_name} STREQUAL "general" AND NOT ${app_name} STREQUAL "common"
-	)
+	IF(NOT ${app_name} STREQUAL "common")
 		ADD_EXECUTABLE(${app_name} ${src_app} "common.c")
 		TARGET_LINK_LIBRARIES(${app_name} git2)
 	ENDIF()
-- 
cgit v1.2.3


From d113791d8f5634b10a98eb265687b7aa79f1658e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Matthias=20Bartelme=C3=9F?= <mba@fourplusone.de>
Date: Sat, 1 Mar 2014 16:53:47 +0100
Subject: Added a test, that fails for #2133

---
 tests/online/fetch.c | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/tests/online/fetch.c b/tests/online/fetch.c
index cb84e846c..c54ec5673 100644
--- a/tests/online/fetch.c
+++ b/tests/online/fetch.c
@@ -81,6 +81,21 @@ void test_online_fetch__no_tags_http(void)
 	do_fetch("http://github.com/libgit2/TestGitRepository.git", GIT_REMOTE_DOWNLOAD_TAGS_NONE, 3);
 }
 
+void test_online_fetch__fetch_twice(void)
+{
+	git_remote *remote;
+	cl_git_pass(git_remote_create(&remote, _repo, "test", "git://github.com/libgit2/TestGitRepository.git"));
+    	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
+    	cl_git_pass(git_remote_download(remote));
+    	git_remote_disconnect(remote);
+    	
+    	git_remote_connect(remote, GIT_DIRECTION_FETCH);
+	cl_git_pass(git_remote_download(remote));
+	git_remote_disconnect(remote);
+	
+	git_remote_free(remote);
+}
+
 static int transferProgressCallback(const git_transfer_progress *stats, void *payload)
 {
 	bool *invoked = (bool *)payload;
-- 
cgit v1.2.3


From 4636ca9391974aa0c6251717cde94b5aea296b77 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Tue, 4 Mar 2014 12:22:27 +0200
Subject: Remove ignored files from the working directory if they were stashed

---
 src/stash.c        | 9 +++++++--
 tests/stash/save.c | 2 ++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/stash.c b/src/stash.c
index b1dd87b22..0c9101294 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -465,7 +465,8 @@ static int ensure_there_are_changes_to_stash(
 static int reset_index_and_workdir(
 	git_repository *repo,
 	git_commit *commit,
-	bool remove_untracked)
+	bool remove_untracked,
+	bool remove_ignored)
 {
 	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
 
@@ -474,6 +475,9 @@ static int reset_index_and_workdir(
 	if (remove_untracked)
 		opts.checkout_strategy |= GIT_CHECKOUT_REMOVE_UNTRACKED;
 
+	if (remove_ignored)
+		opts.checkout_strategy |= GIT_CHECKOUT_REMOVE_IGNORED;
+
 	return git_checkout_tree(repo, (git_object *)commit, &opts);
 }
 
@@ -532,7 +536,8 @@ int git_stash_save(
 	if ((error = reset_index_and_workdir(
 		repo,
 		((flags & GIT_STASH_KEEP_INDEX) != 0) ? i_commit : b_commit,
-		(flags & GIT_STASH_INCLUDE_UNTRACKED) != 0)) < 0)
+		(flags & GIT_STASH_INCLUDE_UNTRACKED) != 0,
+		(flags & GIT_STASH_INCLUDE_IGNORED) != 0)) < 0)
 		goto cleanup;
 
 cleanup:
diff --git a/tests/stash/save.c b/tests/stash/save.c
index b5a793eef..f06c1fb71 100644
--- a/tests/stash/save.c
+++ b/tests/stash/save.c
@@ -159,6 +159,8 @@ void test_stash_save__can_include_untracked_and_ignored_files(void)
 	assert_blob_oid("refs/stash^3:who", NULL);
 	assert_blob_oid("refs/stash^3:when", "b6ed15e81e2593d7bb6265eb4a991d29dc3e628b");
 	assert_blob_oid("refs/stash^3:just.ignore", "78925fb1236b98b37a35e9723033e627f97aa88b");
+
+	cl_assert(!git_path_exists("stash/just.ignore"));
 }
 
 #define MESSAGE "Look Ma! I'm on TV!"
-- 
cgit v1.2.3


From a14aa1e789aca48660466f37b2804b6a9d88e1c8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 4 Mar 2014 20:09:17 +0100
Subject: pack-objects: free memory safely

A few fixes have accumulated in this area which have made the freeing of
data a bit muddy. Make sure to free the data only when needed and once.

When we are going to write a delta to the packfile, we need to free the
data, otherwise leave it. The current version of the code mixes up the
checks for po->data and po->delta_data.
---
 src/pack-objects.c | 27 +++++++++++++++++----------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/src/pack-objects.c b/src/pack-objects.c
index 8b65ac26a..c881e6d99 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -288,18 +288,21 @@ static int write_object(
 	git_odb_object *obj = NULL;
 	git_otype type;
 	unsigned char hdr[10], *zbuf = NULL;
-	void *delta_data = NULL;
-	void *data;
+	void *data = NULL;
 	size_t hdr_len, zbuf_len = COMPRESS_BUFLEN, data_len;
 	int error;
 
+	/*
+	 * If we have a delta base, let's use the delta to save space.
+	 * Otherwise load the whole object. 'data' ends up pointing to
+	 * whatever data we want to put into the packfile.
+	 */
 	if (po->delta) {
 		if (po->delta_data)
-			delta_data = po->delta_data;
-		else if ((error = get_delta(&delta_data, pb->odb, po)) < 0)
+			data = po->delta_data;
+		else if ((error = get_delta(&data, pb->odb, po)) < 0)
 				goto done;
 
-		data = delta_data;
 		data_len = po->delta_size;
 		type = GIT_OBJ_REF_DELTA;
 	} else {
@@ -346,13 +349,17 @@ static int write_object(
 
 			zbuf_len = COMPRESS_BUFLEN; /* reuse buffer */
 		}
-
-		if (po->delta)
-			git__free(delta_data);
 	}
 
-	if (po->delta_data) {
-		git__free(po->delta_data);
+	/*
+	 * If po->delta is true, data is a delta and it is our
+	 * responsibility to free it (otherwise it's a git_object's
+	 * data). We set po->delta_data to NULL in case we got the
+	 * data from there instead of get_delta(). If we didn't,
+	 * there's no harm.
+	 */
+	if (po->delta) {
+		git__free(data);
 		po->delta_data = NULL;
 	}
 
-- 
cgit v1.2.3


From f5753999e4cac020c2dd3a4669fe9ba14df93cb5 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 4 Mar 2014 15:34:23 -0800
Subject: Add exists_prefix to ODB backend and ODB API

---
 include/git2/odb.h             | 13 ++++++++++
 include/git2/sys/odb_backend.h | 10 ++++----
 src/odb.c                      | 55 ++++++++++++++++++++++++++++++++++++++++++
 src/odb_loose.c                | 29 +++++++++++++++++++---
 src/odb_pack.c                 | 18 ++++++++++++++
 tests/odb/loose.c              |  4 +++
 tests/odb/mixed.c              | 19 ++++++++++++++-
 7 files changed, 138 insertions(+), 10 deletions(-)

diff --git a/include/git2/odb.h b/include/git2/odb.h
index 82df4d300..c71e30648 100644
--- a/include/git2/odb.h
+++ b/include/git2/odb.h
@@ -158,6 +158,19 @@ GIT_EXTERN(int) git_odb_read_header(size_t *len_out, git_otype *type_out, git_od
  */
 GIT_EXTERN(int) git_odb_exists(git_odb *db, const git_oid *id);
 
+/**
+ * Determine if objects can be found in the object database from a short OID.
+ *
+ * @param out The full OID of the found object if just one is found.
+ * @param db The database to be searched for the given object.
+ * @param short_id A prefix of the id of the object to read.
+ * @param len The length of the prefix.
+ * @return 0 if found, GIT_ENOTFOUND if not found, GIT_EAMBIGUOUS if multiple
+ *         matches were found, other value < 0 if there was a read error.
+ */
+GIT_EXTERN(int) git_odb_exists_prefix(
+	git_oid *out, git_odb *db, const git_oid *short_id, size_t len);
+
 /**
  * Refresh the object database to load newly added files.
  *
diff --git a/include/git2/sys/odb_backend.h b/include/git2/sys/odb_backend.h
index 8039a5b82..4917ba0f0 100644
--- a/include/git2/sys/odb_backend.h
+++ b/include/git2/sys/odb_backend.h
@@ -35,11 +35,8 @@ struct git_odb_backend {
 	int (* read)(
 		void **, size_t *, git_otype *, git_odb_backend *, const git_oid *);
 
-	/* To find a unique object given a prefix
-	 * of its oid.
-	 * The oid given must be so that the
-	 * remaining (GIT_OID_HEXSZ - len)*4 bits
-	 * are 0s.
+	/* To find a unique object given a prefix of its oid.  The oid given
+	 * must be so that the remaining (GIT_OID_HEXSZ - len)*4 bits are 0s.
 	 */
 	int (* read_prefix)(
 		git_oid *, void **, size_t *, git_otype *,
@@ -64,6 +61,9 @@ struct git_odb_backend {
 	int (* exists)(
 		git_odb_backend *, const git_oid *);
 
+	int (* exists_prefix)(
+		git_oid *, git_odb_backend *, const git_oid *, size_t);
+
 	/**
 	 * If the backend implements a refreshing mechanism, it should be exposed
 	 * through this endpoint. Each call to `git_odb_refresh()` will invoke it.
diff --git a/src/odb.c b/src/odb.c
index b413f83b4..d49ee30fd 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -635,6 +635,61 @@ int git_odb_exists(git_odb *db, const git_oid *id)
 	return (int)found;
 }
 
+int git_odb_exists_prefix(
+	git_oid *out, git_odb *db, const git_oid *short_id, size_t len)
+{
+	int error = GIT_ENOTFOUND, num_found = 0;
+	size_t i;
+	git_oid last_found = {{0}}, found;
+
+	assert(db && short_id);
+
+	if (len < GIT_OID_MINPREFIXLEN)
+		return git_odb__error_ambiguous("prefix length too short");
+	if (len > GIT_OID_HEXSZ)
+		len = GIT_OID_HEXSZ;
+
+	if (len == GIT_OID_HEXSZ) {
+		if (git_odb_exists(db, short_id)) {
+			if (out)
+				git_oid_cpy(out, short_id);
+			return 0;
+		} else {
+			return git_odb__error_notfound("no match for id prefix", short_id);
+		}
+	}
+
+	for (i = 0; i < db->backends.length; ++i) {
+		backend_internal *internal = git_vector_get(&db->backends, i);
+		git_odb_backend *b = internal->backend;
+
+		if (!b->exists_prefix)
+			continue;
+
+		error = b->exists_prefix(&found, b, short_id, len);
+		if (error == GIT_ENOTFOUND || error == GIT_PASSTHROUGH)
+			continue;
+		if (error)
+			return error;
+
+		/* make sure found item doesn't introduce ambiguity */
+		if (num_found) {
+			if (git_oid__cmp(&last_found, &found))
+				return git_odb__error_ambiguous("multiple matches for prefix");
+		} else {
+			git_oid_cpy(&last_found, &found);
+			num_found++;
+		}
+	}
+
+	if (!num_found)
+		return git_odb__error_notfound("no match for id prefix", short_id);
+	if (out)
+		git_oid_cpy(out, &last_found);
+
+	return error;
+}
+
 int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)
 {
 	int error;
diff --git a/src/odb_loose.c b/src/odb_loose.c
index fd4ffff1e..e0b6ed1f3 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -519,11 +519,11 @@ static int locate_object_short_oid(
 	loose_locate_object_state state;
 	int error;
 
-	/* prealloc memory for OBJ_DIR/xx/ */
-	if (git_buf_grow(object_location, dir_len + 5) < 0)
+	/* prealloc memory for OBJ_DIR/xx/xx..38x..xx */
+	if (git_buf_grow(object_location, dir_len + 3 + GIT_OID_HEXSZ) < 0)
 		return -1;
 
-	git_buf_sets(object_location, objects_dir);
+	git_buf_set(object_location, objects_dir, dir_len);
 	git_path_to_dir(object_location);
 
 	/* save adjusted position at end of dir so it can be restored later */
@@ -533,8 +533,9 @@ static int locate_object_short_oid(
 	git_oid_fmt((char *)state.short_oid, short_oid);
 
 	/* Explore OBJ_DIR/xx/ where xx is the beginning of hex formatted short oid */
-	if (git_buf_printf(object_location, "%.2s/", state.short_oid) < 0)
+	if (git_buf_put(object_location, (char *)state.short_oid, 3) < 0)
 		return -1;
+	object_location->ptr[object_location->size - 1] = '/';
 
 	/* Check that directory exists */
 	if (git_path_isdir(object_location->ptr) == false)
@@ -691,6 +692,25 @@ static int loose_backend__exists(git_odb_backend *backend, const git_oid *oid)
 	return !error;
 }
 
+static int loose_backend__exists_prefix(
+	git_oid *out, git_odb_backend *backend, const git_oid *short_id, size_t len)
+{
+	git_buf object_path = GIT_BUF_INIT;
+	int error;
+
+	assert(backend && out && short_id);
+
+	if (len < GIT_OID_MINPREFIXLEN)
+		return git_odb__error_ambiguous("prefix length too short");
+
+	error = locate_object_short_oid(
+		&object_path, out, (loose_backend *)backend, short_id, len);
+
+	git_buf_free(&object_path);
+
+	return error;
+}
+
 struct foreach_state {
 	size_t dir_len;
 	git_odb_foreach_cb cb;
@@ -939,6 +959,7 @@ int git_odb_backend_loose(
 	backend->parent.read_header = &loose_backend__read_header;
 	backend->parent.writestream = &loose_backend__stream;
 	backend->parent.exists = &loose_backend__exists;
+	backend->parent.exists_prefix = &loose_backend__exists_prefix;
 	backend->parent.foreach = &loose_backend__foreach;
 	backend->parent.free = &loose_backend__free;
 
diff --git a/src/odb_pack.c b/src/odb_pack.c
index 903b00d26..9ab683882 100644
--- a/src/odb_pack.c
+++ b/src/odb_pack.c
@@ -493,6 +493,23 @@ static int pack_backend__exists(git_odb_backend *backend, const git_oid *oid)
 	return pack_entry_find(&e, (struct pack_backend *)backend, oid) == 0;
 }
 
+static int pack_backend__exists_prefix(
+	git_oid *out, git_odb_backend *backend, const git_oid *short_id, size_t len)
+{
+	int error;
+	struct pack_backend *pb = (struct pack_backend *)backend;
+	struct git_pack_entry e = {0};
+
+	error = pack_entry_find_prefix(&e, pb, short_id, len);
+
+	if (error == GIT_ENOTFOUND && !(error = pack_backend__refresh(backend)))
+		error = pack_entry_find_prefix(&e, pb, short_id, len);
+
+	git_oid_cpy(out, &e.sha1);
+
+	return error;
+}
+
 static int pack_backend__foreach(git_odb_backend *_backend, git_odb_foreach_cb cb, void *data)
 {
 	int error;
@@ -612,6 +629,7 @@ static int pack_backend__alloc(struct pack_backend **out, size_t initial_size)
 	backend->parent.read_prefix = &pack_backend__read_prefix;
 	backend->parent.read_header = &pack_backend__read_header;
 	backend->parent.exists = &pack_backend__exists;
+	backend->parent.exists_prefix = &pack_backend__exists_prefix;
 	backend->parent.refresh = &pack_backend__refresh;
 	backend->parent.foreach = &pack_backend__foreach;
 	backend->parent.writepack = &pack_backend__writepack;
diff --git a/tests/odb/loose.c b/tests/odb/loose.c
index a85f1430d..ef7136e36 100644
--- a/tests/odb/loose.c
+++ b/tests/odb/loose.c
@@ -76,9 +76,13 @@ void test_odb_loose__exists(void)
 
     cl_assert(git_odb_exists(odb, &id));
 
+	cl_assert(git_odb_exists_prefix(&id2, odb, &id, 8));
+	cl_assert(git_oid_equal(&id, &id2));
+
 	/* Test for a non-existant object */
     cl_git_pass(git_oid_fromstr(&id2, "8b137891791fe96927ad78e64b0aad7bded08baa"));
     cl_assert(!git_odb_exists(odb, &id2));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_odb_exists_prefix(NULL, odb, &id2, 8));
 
 	git_odb_free(odb);
 }
diff --git a/tests/odb/mixed.c b/tests/odb/mixed.c
index 51970ceec..ceba4ec81 100644
--- a/tests/odb/mixed.c
+++ b/tests/odb/mixed.c
@@ -23,9 +23,14 @@ void test_odb_mixed__dup_oid(void) {
 	cl_git_pass(git_oid_fromstr(&oid, hex));
 	cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, GIT_OID_HEXSZ));
 	git_odb_object_free(obj);
+
+	cl_git_pass(git_odb_exists_prefix(NULL, _odb, &oid, GIT_OID_HEXSZ));
+
 	cl_git_pass(git_oid_fromstrn(&oid, short_hex, sizeof(short_hex) - 1));
 	cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, sizeof(short_hex) - 1));
 	git_odb_object_free(obj);
+
+	cl_git_pass(git_odb_exists_prefix(NULL, _odb, &oid, sizeof(short_hex) - 1));
 }
 
 /* some known sha collisions of file content:
@@ -37,7 +42,7 @@ void test_odb_mixed__dup_oid(void) {
 
 void test_odb_mixed__dup_oid_prefix_0(void) {
 	char hex[10];
-	git_oid oid;
+	git_oid oid, found;
 	git_odb_object *obj;
 
 	/* ambiguous in the same pack file */
@@ -46,10 +51,14 @@ void test_odb_mixed__dup_oid_prefix_0(void) {
 	cl_git_pass(git_oid_fromstrn(&oid, hex, strlen(hex)));
 	cl_assert_equal_i(
 		GIT_EAMBIGUOUS, git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
+	cl_assert_equal_i(
+		GIT_EAMBIGUOUS, git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
 
 	strncpy(hex, "dea509d09", sizeof(hex));
 	cl_git_pass(git_oid_fromstrn(&oid, hex, strlen(hex)));
 	cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
+	cl_git_pass(git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
+	cl_assert(git_oid_equal(&found, git_odb_object_id(obj)));
 	git_odb_object_free(obj);
 
 	strncpy(hex, "dea509d0b", sizeof(hex));
@@ -63,10 +72,14 @@ void test_odb_mixed__dup_oid_prefix_0(void) {
 	cl_git_pass(git_oid_fromstrn(&oid, hex, strlen(hex)));
 	cl_assert_equal_i(
 		GIT_EAMBIGUOUS, git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
+	cl_assert_equal_i(
+		GIT_EAMBIGUOUS, git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
 
 	strncpy(hex, "81b5bff5b", sizeof(hex));
 	cl_git_pass(git_oid_fromstrn(&oid, hex, strlen(hex)));
 	cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
+	cl_git_pass(git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
+	cl_assert(git_oid_equal(&found, git_odb_object_id(obj)));
 	git_odb_object_free(obj);
 
 	strncpy(hex, "81b5bff5f", sizeof(hex));
@@ -80,10 +93,14 @@ void test_odb_mixed__dup_oid_prefix_0(void) {
 	cl_git_pass(git_oid_fromstrn(&oid, hex, strlen(hex)));
 	cl_assert_equal_i(
 		GIT_EAMBIGUOUS, git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
+	cl_assert_equal_i(
+		GIT_EAMBIGUOUS, git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
 
 	strncpy(hex, "0ddeaded9", sizeof(hex));
 	cl_git_pass(git_oid_fromstrn(&oid, hex, strlen(hex)));
 	cl_git_pass(git_odb_read_prefix(&obj, _odb, &oid, strlen(hex)));
+	cl_git_pass(git_odb_exists_prefix(&found, _odb, &oid, strlen(hex)));
+	cl_assert(git_oid_equal(&found, git_odb_object_id(obj)));
 	git_odb_object_free(obj);
 
 	strncpy(hex, "0ddeadede", sizeof(hex));
-- 
cgit v1.2.3


From 13f7ecd7b9c5244441eeaae798c8657d1818ea7f Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 4 Mar 2014 16:23:28 -0800
Subject: Add git_object_short_id API to get short id string

This finds a short id string that will unambiguously select the
given object, starting with the core.abbrev length (usually 7)
and growing until it is no longer ambiguous.
---
 include/git2/object.h  | 10 ++++++++++
 src/object.c           | 43 +++++++++++++++++++++++++++++++++++++++++++
 tests/object/shortid.c | 44 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 97 insertions(+)
 create mode 100644 tests/object/shortid.c

diff --git a/include/git2/object.h b/include/git2/object.h
index c40631fa6..416feffbc 100644
--- a/include/git2/object.h
+++ b/include/git2/object.h
@@ -10,6 +10,7 @@
 #include "common.h"
 #include "types.h"
 #include "oid.h"
+#include "buffer.h"
 
 /**
  * @file git2/object.h
@@ -103,6 +104,15 @@ GIT_EXTERN(int) git_object_lookup_bypath(
  */
 GIT_EXTERN(const git_oid *) git_object_id(const git_object *obj);
 
+/**
+ * Get a short abbreviated OID string for the object
+ *
+ * @param out Buffer to write string into
+ * @param obj The object to get an ID for
+ * @return 0 on success, <0 for error
+ */
+GIT_EXTERN(int) git_object_short_id(git_buf *out, const git_object *obj);
+
 /**
  * Get the object type of an object
  *
diff --git a/src/object.c b/src/object.c
index 40cae184f..3847a0739 100644
--- a/src/object.c
+++ b/src/object.c
@@ -397,3 +397,46 @@ cleanup:
 	git_tree_free(tree);
 	return error;
 }
+
+int git_object_short_id(git_buf *out, const git_object *obj)
+{
+	git_repository *repo;
+	int len = GIT_ABBREV_DEFAULT, error;
+	git_oid id = {{0}};
+	git_odb *odb;
+
+	assert(out && obj);
+
+	git_buf_sanitize(out);
+	repo = git_object_owner(obj);
+
+	if ((error = git_repository__cvar(&len, repo, GIT_CVAR_ABBREV)) < 0)
+		return error;
+
+	if ((error = git_repository_odb(&odb, repo)) < 0)
+		return error;
+
+	while (len < GIT_OID_HEXSZ) {
+		/* set up short oid */
+		memcpy(&id.id, &obj->cached.oid.id, (len + 1) / 2);
+		if (len & 1)
+			id.id[len / 2] &= 0xf0;
+
+		error = git_odb_exists_prefix(NULL, odb, &id, len);
+		if (error != GIT_EAMBIGUOUS)
+			break;
+
+		giterr_clear();
+		len++;
+	}
+
+	if (!error && !(error = git_buf_grow(out, len + 1))) {
+		git_oid_tostr(out->ptr, len + 1, &id);
+		out->size = len;
+	}
+
+	git_odb_free(odb);
+
+	return error;
+}
+
diff --git a/tests/object/shortid.c b/tests/object/shortid.c
new file mode 100644
index 000000000..fa1dac09a
--- /dev/null
+++ b/tests/object/shortid.c
@@ -0,0 +1,44 @@
+#include "clar_libgit2.h"
+
+git_repository *_repo;
+
+void test_object_shortid__initialize(void)
+{
+	cl_git_pass(git_repository_open(&_repo, cl_fixture("duplicate.git")));
+}
+
+void test_object_shortid__cleanup(void)
+{
+	git_repository_free(_repo);
+	_repo = NULL;
+}
+
+void test_object_shortid__select(void)
+{
+	git_oid full;
+	git_object *obj;
+	git_buf shorty = {0};
+
+	git_oid_fromstr(&full, "ce013625030ba8dba906f756967f9e9ca394464a");
+	cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJ_ANY));
+	cl_git_pass(git_object_short_id(&shorty, obj));
+	cl_assert_equal_i(7, shorty.size);
+	cl_assert_equal_s("ce01362", shorty.ptr);
+	git_object_free(obj);
+
+	git_oid_fromstr(&full, "dea509d097ce692e167dfc6a48a7a280cc5e877e");
+	cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJ_ANY));
+	cl_git_pass(git_object_short_id(&shorty, obj));
+	cl_assert_equal_i(9, shorty.size);
+	cl_assert_equal_s("dea509d09", shorty.ptr);
+	git_object_free(obj);
+
+	git_oid_fromstr(&full, "dea509d0b3cb8ee0650f6ca210bc83f4678851ba");
+	cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJ_ANY));
+	cl_git_pass(git_object_short_id(&shorty, obj));
+	cl_assert_equal_i(9, shorty.size);
+	cl_assert_equal_s("dea509d0b", shorty.ptr);
+	git_object_free(obj);
+
+	git_buf_free(&shorty);
+}
-- 
cgit v1.2.3


From 0d3c8a9d9202f69ee0366f2eeab1765b18b49baa Mon Sep 17 00:00:00 2001
From: Brian Gesiak <modocache@gmail.com>
Date: Wed, 5 Mar 2014 13:06:31 +0900
Subject: examples/diff: Add minimal, patience diff options.

- Add minimal, patience diff options to diff example. libgit2
  `diff_xdiff.git_xdiff_init` already supports these flags, so
  no additional change is necessary.
- Remove minimal and patience flag addition from project list.
---
 PROJECTS.md     | 4 ----
 examples/diff.c | 4 ++++
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/PROJECTS.md b/PROJECTS.md
index 34ba18ace..050a51cfb 100644
--- a/PROJECTS.md
+++ b/PROJECTS.md
@@ -28,10 +28,6 @@ These are good small projects to get started with libgit2.
   core Git command and add a missing command-line option.  There are many
   gaps right now and this helps demonstrate how to use the library.  Here
   are some specific ideas:
-    * Add the `--minimal` flag to `examples/diff.c` since the `libgit2`
-      diff API now has a flag to support it
-    * Add the `--patience` flag to `examples/diff.c` since it is also now
-      supported.
     * Add the `--shortstat` flag to `examples/diff.c` based on the work
       that was done to add `--numstat` already.
     * Fix the `examples/diff.c` implementation of the `-B`
diff --git a/examples/diff.c b/examples/diff.c
index de994ecab..65c618882 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -234,6 +234,10 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 			o->diffopts.flags |= GIT_DIFF_INCLUDE_IGNORED;
 		else if (!strcmp(a, "--untracked"))
 			o->diffopts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
+		else if (!strcmp(a, "--patience"))
+			o->diffopts.flags |= GIT_DIFF_PATIENCE;
+		else if (!strcmp(a, "--minimal"))
+			o->diffopts.flags |= GIT_DIFF_MINIMAL;
 		else if (!strcmp(a, "--numstat"))
 			o->numstat = 1;
 		else if (match_uint16_arg(
-- 
cgit v1.2.3


From 06a8f5c3b26682cf80a672cbc5f75c09f336cafe Mon Sep 17 00:00:00 2001
From: Brian Lambert <brianlambert@gmail.com>
Date: Wed, 5 Mar 2014 00:00:41 -0500
Subject: Fixed missing error check on call to git_remote_download in
 git_remote_fetch. Moved error check to statement following
 git_remote_disconnect so that the disconnect happens regardless of the result
 of the download call.

---
 src/remote.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index f320f4a52..6f97d56a1 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -857,12 +857,15 @@ int git_remote_fetch(
 	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH)) != 0)
 		return error;
 
-	if ((error = git_remote_download(remote)) != 0)
-		return error;
+	error = git_remote_download(remote);
 
 	/* We don't need to be connected anymore */
 	git_remote_disconnect(remote);
 
+	/* If the download failed, return the error */
+	if (error != 0)
+		return error;
+
 	/* Default reflog message */
 	if (reflog_message)
 		git_buf_sets(&reflog_msg_buf, reflog_message);
-- 
cgit v1.2.3


From 45d2e8dc4687b5da6e872fbfa960ea7cff3b3867 Mon Sep 17 00:00:00 2001
From: Sun He <sunheehnus@gmail.com>
Date: Wed, 5 Mar 2014 20:13:34 +0800
Subject: Add the --shortstat flag to examples/diff.c

---
 PROJECTS.md     |  2 --
 examples/diff.c | 52 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 51 insertions(+), 3 deletions(-)

diff --git a/PROJECTS.md b/PROJECTS.md
index 34ba18ace..1e2b5db6f 100644
--- a/PROJECTS.md
+++ b/PROJECTS.md
@@ -32,8 +32,6 @@ These are good small projects to get started with libgit2.
       diff API now has a flag to support it
     * Add the `--patience` flag to `examples/diff.c` since it is also now
       supported.
-    * Add the `--shortstat` flag to `examples/diff.c` based on the work
-      that was done to add `--numstat` already.
     * Fix the `examples/diff.c` implementation of the `-B`
       (a.k.a. `--break-rewrites`) command line option to actually look for
       the optional `[<n>][/<m>]` configuration values. There is an
diff --git a/examples/diff.c b/examples/diff.c
index de994ecab..98480a76b 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -40,6 +40,7 @@ struct opts {
 	int color;
 	int cached;
 	int numstat;
+	int shortstat;
 	git_diff_format_t format;
 	const char *treeish1;
 	const char *treeish2;
@@ -51,6 +52,7 @@ static void parse_opts(struct opts *o, int argc, char *argv[]);
 static int color_printer(
 	const git_diff_delta*, const git_diff_hunk*, const git_diff_line*, void*);
 static void diff_print_numstat(git_diff *diff);
+static void diff_print_shortstat(git_diff *diff);
 
 int main(int argc, char *argv[])
 {
@@ -59,7 +61,7 @@ int main(int argc, char *argv[])
 	git_diff *diff;
 	struct opts o = {
 		GIT_DIFF_OPTIONS_INIT, GIT_DIFF_FIND_OPTIONS_INIT,
-		-1, 0, 0, GIT_DIFF_FORMAT_PATCH, NULL, NULL, "."
+		-1, 0, 0, 0, GIT_DIFF_FORMAT_PATCH, NULL, NULL, "."
 	};
 
 	git_threads_init();
@@ -121,6 +123,8 @@ int main(int argc, char *argv[])
 
 	if (o.numstat == 1)
 		diff_print_numstat(diff);
+	else if (o.shortstat == 1)
+		diff_print_shortstat(diff);
 	else {
 		if (o.color >= 0)
 			fputs(colors[0], stdout);
@@ -236,6 +240,8 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 			o->diffopts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
 		else if (!strcmp(a, "--numstat"))
 			o->numstat = 1;
+		else if (!strcmp(a, "--shortstat"))
+			o->shortstat = 1;
 		else if (match_uint16_arg(
 				&o->findopts.rename_threshold, &args, "-M") ||
 			match_uint16_arg(
@@ -289,3 +295,47 @@ static void diff_print_numstat(git_diff *diff)
 		git_patch_free(patch);
 	}
 }
+
+/** Display diff output with "--shortstat".*/
+static void diff_print_shortstat(git_diff *diff)
+{
+	git_patch *patch;
+	size_t d, ndeltas = git_diff_num_deltas(diff);
+	size_t nadditions, ndeletions;
+	long nadditions_sum, ndeletions_sum;
+
+	nadditions_sum = 0;
+	ndeletions_sum = 0;
+
+	for (d = 0; d < ndeltas; d++){
+		check_lg2(
+			git_patch_from_diff(&patch, diff, d),
+			"generating patch from diff", NULL);
+
+		check_lg2(
+			git_patch_line_stats(NULL, &nadditions, &ndeletions, patch),
+			"generating the number of additions and deletions", NULL);
+
+		nadditions_sum += nadditions;
+		ndeletions_sum += ndeletions;
+
+		git_patch_free(patch);
+	}
+
+	if (ndeltas) {
+
+	    printf(", %ld ", (long)ndeltas);
+	    printf("%s", 1==ndeltas ? "file changed" : "files changed");
+
+	    if(nadditions_sum) {
+		printf(", %ld ",nadditions_sum);
+		printf("%s", 1==nadditions_sum ? "insertion(+)" : "insertions(+)");
+	    }
+
+	    if(ndeletions_sum) {
+		printf(", %ld ",ndeletions_sum);
+		printf("%s", 1==ndeletions_sum ? "deletion(-)" : "deletions(-)");
+	    }
+	}
+	printf("\n");
+}
-- 
cgit v1.2.3


From 8384a50a2171f57cc1b8158777b124d2022db94e Mon Sep 17 00:00:00 2001
From: Sun He <sunheehnus@gmail.com>
Date: Wed, 5 Mar 2014 20:33:20 +0800
Subject: fix the output format of diff

---
 examples/diff.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/diff.c b/examples/diff.c
index 98480a76b..d87edcdaa 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -324,7 +324,7 @@ static void diff_print_shortstat(git_diff *diff)
 
 	if (ndeltas) {
 
-	    printf(", %ld ", (long)ndeltas);
+	    printf(" %ld ", (long)ndeltas);
 	    printf("%s", 1==ndeltas ? "file changed" : "files changed");
 
 	    if(nadditions_sum) {
@@ -336,6 +336,6 @@ static void diff_print_shortstat(git_diff *diff)
 		printf(", %ld ",ndeletions_sum);
 		printf("%s", 1==ndeletions_sum ? "deletion(-)" : "deletions(-)");
 	    }
+	    printf("\n");
 	}
-	printf("\n");
 }
-- 
cgit v1.2.3


From 4ae4a9bbd1c8b9464cc04c13508deca159491047 Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Mon, 3 Mar 2014 23:36:34 +0100
Subject: Fix typo

---
 include/git2/object.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/object.h b/include/git2/object.h
index c40631fa6..7a3e23906 100644
--- a/include/git2/object.h
+++ b/include/git2/object.h
@@ -143,7 +143,7 @@ GIT_EXTERN(git_repository *) git_object_owner(const git_object *obj);
 GIT_EXTERN(void) git_object_free(git_object *object);
 
 /**
- * Convert an object type to it's string representation.
+ * Convert an object type to its string representation.
  *
  * The result is a pointer to a string in static memory and
  * should not be free()'ed.
-- 
cgit v1.2.3


From a53b858417a8781d8e018a51ec66495964c54e1b Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Mon, 3 Mar 2014 23:56:43 +0100
Subject: Add tag example

---
 examples/.gitignore |   1 +
 examples/Makefile   |   2 +-
 examples/tag.c      | 314 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 316 insertions(+), 1 deletion(-)
 create mode 100644 examples/tag.c

diff --git a/examples/.gitignore b/examples/.gitignore
index 711493994..b652e28b5 100644
--- a/examples/.gitignore
+++ b/examples/.gitignore
@@ -8,4 +8,5 @@ init
 log
 rev-parse
 status
+tag
 *.dSYM
diff --git a/examples/Makefile b/examples/Makefile
index 2e7f68f82..e866b7fee 100644
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -3,7 +3,7 @@
 CC = gcc
 CFLAGS = -g -I../include -I../src -Wall -Wextra -Wmissing-prototypes -Wno-missing-field-initializers
 LFLAGS = -L../build -lgit2 -lz
-APPS = general showindex diff rev-list cat-file status log rev-parse init blame
+APPS = general showindex diff rev-list cat-file status log rev-parse init blame tag
 
 all: $(APPS)
 
diff --git a/examples/tag.c b/examples/tag.c
new file mode 100644
index 000000000..2d5a3d225
--- /dev/null
+++ b/examples/tag.c
@@ -0,0 +1,314 @@
+/*
+ * libgit2 "tag" example - shows how to list, create and delete tags
+ *
+ * Written by the libgit2 contributors
+ *
+ * To the extent possible under law, the author(s) have dedicated all copyright
+ * and related and neighboring rights to this software to the public domain
+ * worldwide. This software is distributed without any warranty.
+ *
+ * You should have received a copy of the CC0 Public Domain Dedication along
+ * with this software. If not, see
+ * <http://creativecommons.org/publicdomain/zero/1.0/>.
+ */
+
+#include "common.h"
+
+/**
+ * The following example partially reimplements the `git tag` command
+ * and some of its options.
+ *
+ * These commands should work:
+
+ * - Tag name listing (`tag`)
+ * - Filtered tag listing with messages (`tag -n3 -l "v0.1*"`)
+ * - Lightweight tag creation (`tag test v0.18.0`)
+ * - Tag creation (`tag -a -m "Test message" test v0.18.0`)
+ * - Tag deletion (`tag -d test`)
+ *
+ * The command line parsing logic is simplified and doesn't handle
+ * all of the use cases.
+ */
+
+/** tag_options represents the parsed command line options */
+typedef struct {
+	const char *message;
+	const char *pattern;
+	const char *tag_name;
+	const char *target;
+	int num_lines;
+	int force;
+} tag_options;
+
+/** tag_state represents the current program state for dragging around */
+typedef struct {
+	git_repository *repo;
+	tag_options *opts;
+} tag_state;
+
+/** An action to execute based on the command line arguments */
+typedef void (*tag_action)(tag_state *state);
+typedef struct args_info args_info;
+
+static void check(int result, const char *message)
+{
+	if (result) fatal(message, NULL);
+}
+
+/** Tag listing: Print individual message lines */
+static void print_list_lines(const char *message, const tag_state *state)
+{
+	const char *msg = message;
+	int num = state->opts->num_lines - 1;
+
+	if (!msg) return;
+
+	/** first line - headline */
+	while(*msg && *msg != '\n') printf("%c", *msg++);
+
+	/** skip over new lines */
+	while(*msg && *msg == '\n') msg++;
+
+	printf("\n");
+
+	/** print just headline? */
+	if (num == 0) return;
+	if (*msg && msg[1]) printf("\n");
+
+	/** print individual commit/tag lines */
+	while (*msg && num-- >= 2) {
+		printf("    ");
+
+		while (*msg && *msg != '\n') printf("%c", *msg++);
+
+		/** handle consecutive new lines */
+		if (*msg && *msg == '\n' && msg[1] == '\n') {
+			num--;
+			printf("\n");
+		}
+		while(*msg && *msg == '\n') msg++;
+
+		printf("\n");
+	}
+}
+
+/** Tag listing: Print an actual tag object */
+static void print_tag(git_tag *tag, const tag_state *state)
+{
+	printf("%-16s", git_tag_name(tag));
+
+	if (state->opts->num_lines) {
+		const char *msg = git_tag_message(tag);
+		print_list_lines(msg, state);
+	} else {
+		printf("\n");
+	}
+}
+
+/** Tag listing: Print a commit (target of a lightweight tag) */
+static void print_commit(git_commit *commit, const char *name,
+		const tag_state *state)
+{
+	printf("%-16s", name);
+
+	if (state->opts->num_lines) {
+		const char *msg = git_commit_message(commit);
+		print_list_lines(msg, state);
+	} else {
+		printf("\n");
+	}
+}
+
+/** Tag listing: Fallback, should not happen */
+static void print_name(const char *name)
+{
+	printf("%s\n", name);
+}
+
+/** Tag listing: Lookup tags based on ref name and dispatch to print */
+static int each_tag(const char *name, tag_state *state)
+{
+	git_repository *repo = state->repo;
+	git_object *obj;
+
+	check_lg2(git_revparse_single(&obj, repo, name),
+			"Failed to lookup rev", name);
+
+	switch (git_object_type(obj)) {
+		case GIT_OBJ_TAG:
+			print_tag((git_tag *) obj, state);
+			break;
+		case GIT_OBJ_COMMIT:
+			print_commit((git_commit *) obj, name, state);
+			break;
+		default:
+			print_name(name);
+	}
+
+	git_object_free(obj);
+	return 0;
+}
+
+static void action_list_tags(tag_state *state)
+{
+	const char *pattern = state->opts->pattern;
+	git_strarray tag_names = {0};
+	size_t i;
+
+	check_lg2(git_tag_list_match(&tag_names, pattern ? pattern : "*", state->repo),
+			"Unable to get list of tags", NULL);
+
+	for(i = 0; i < tag_names.count; i++) {
+		each_tag(tag_names.strings[i], state);
+	}
+
+	git_strarray_free(&tag_names);
+}
+
+static void action_delete_tag(tag_state *state)
+{
+	tag_options *opts = state->opts;
+	git_object *obj;
+	char oid[GIT_OID_HEXSZ + 1];
+
+	check(!opts->tag_name, "Name required");
+
+	check_lg2(git_revparse_single(&obj, state->repo, opts->tag_name),
+			"Failed to lookup rev", opts->tag_name);
+
+	check_lg2(git_tag_delete(state->repo, opts->tag_name),
+			"Unable to delete tag", opts->tag_name);
+
+	git_oid_tostr(oid, sizeof(oid), git_object_id(obj));
+
+	printf("Deleted tag '%s' (was %s)\n", opts->tag_name, oid);
+
+	git_object_free(obj);
+}
+
+static void action_create_lighweight_tag(tag_state *state)
+{
+	git_repository *repo = state->repo;
+	tag_options *opts = state->opts;
+	git_oid oid;
+	git_object *target;
+
+	check(!opts->tag_name, "Name required");
+
+	if (!opts->target) opts->target = "HEAD";
+
+	check(!opts->target, "Target required");
+
+	check_lg2(git_revparse_single(&target, repo, opts->target),
+			"Unable to resolve spec", opts->target);
+
+	check_lg2(git_tag_create_lightweight(&oid, repo, opts->tag_name,
+				target, opts->force), "Unable to create tag", NULL);
+
+	git_object_free(target);
+}
+
+static void action_create_tag(tag_state *state)
+{
+	git_repository *repo = state->repo;
+	tag_options *opts = state->opts;
+	git_signature *tagger;
+	git_oid oid;
+	git_object *target;
+
+	check(!opts->tag_name, "Name required");
+	check(!opts->message, "Message required");
+
+	if (!opts->target) opts->target = "HEAD";
+
+	check_lg2(git_revparse_single(&target, repo, opts->target),
+			"Unable to resolve spec", opts->target);
+
+	check_lg2(git_signature_default(&tagger, repo),
+			"Unable to create signature", NULL);
+
+	check_lg2(git_tag_create(&oid, repo, opts->tag_name,
+				target, tagger, opts->message, opts->force), "Unable to create tag", NULL);
+
+	git_object_free(target);
+	git_signature_free(tagger);
+}
+
+static void print_usage()
+{
+	fprintf(stderr, "usage: see `git help tag`\n");
+	exit(1);
+}
+
+/** Parse command line arguments and choose action to run when done */
+static void parse_options(tag_action *action, tag_options *opts, int argc, char **argv)
+{
+	args_info args = ARGS_INFO_INIT;
+	*action = &action_list_tags;
+
+	for (args.pos = 1; args.pos < argc; ++args.pos) {
+		const char *curr = argv[args.pos];
+
+		if (curr[0] != '-') {
+			if (!opts->tag_name)
+				opts->tag_name = curr;
+			else if (!opts->target)
+				opts->target = curr;
+			else
+				print_usage();
+
+			if (*action != &action_create_tag)
+				*action = &action_create_lighweight_tag;
+		} else if (!strcmp(curr, "-n")) {
+			opts->num_lines = 1;
+			*action = &action_list_tags;
+		} else if (!strcmp(curr, "-a")) {
+			*action = &action_create_tag;
+		} else if (!strcmp(curr, "-f")) {
+			opts->force = 1;
+		} else if (match_int_arg(&opts->num_lines, &args, "-n", 0)) {
+			*action = &action_list_tags;
+		} else if (match_str_arg(&opts->pattern, &args, "-l")) {
+			*action = &action_list_tags;
+		} else if (match_str_arg(&opts->tag_name, &args, "-d")) {
+			*action = &action_delete_tag;
+		} else if (match_str_arg(&opts->message, &args, "-m")) {
+			*action = &action_create_tag;
+		}
+	}
+}
+
+/** Initialize tag_options struct */
+static void tag_options_init(tag_options *opts)
+{
+	memset(opts, 0, sizeof(*opts));
+
+	opts->message   = NULL;
+	opts->pattern   = NULL;
+	opts->tag_name  = NULL;
+	opts->target    = NULL;
+	opts->num_lines = 0;
+	opts->force     = 0;
+}
+
+int main(int argc, char **argv)
+{
+	git_threads_init();
+
+	git_repository *repo;
+	check_lg2(git_repository_open_ext(&repo, ".", 0, NULL),
+			"Could not open repository", NULL);
+
+	tag_options opts;
+	tag_options_init(&opts);
+	tag_action action;
+	parse_options(&action, &opts, argc, argv);
+
+	tag_state state = {repo, &opts};
+	action(&state);
+
+	git_repository_free(repo);
+	git_threads_shutdown();
+
+	return 0;
+}
-- 
cgit v1.2.3


From feebe6150f33b9713505c76ff2f204997b9d8687 Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Wed, 5 Mar 2014 20:26:13 +0100
Subject: Move all variable declarations to the top of the block

---
 examples/tag.c | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/examples/tag.c b/examples/tag.c
index 2d5a3d225..4c689cc55 100644
--- a/examples/tag.c
+++ b/examples/tag.c
@@ -293,18 +293,21 @@ static void tag_options_init(tag_options *opts)
 
 int main(int argc, char **argv)
 {
+	git_repository *repo;
+	tag_options opts;
+	tag_action action;
+	tag_state state;
+
 	git_threads_init();
 
-	git_repository *repo;
 	check_lg2(git_repository_open_ext(&repo, ".", 0, NULL),
 			"Could not open repository", NULL);
 
-	tag_options opts;
 	tag_options_init(&opts);
-	tag_action action;
 	parse_options(&action, &opts, argc, argv);
 
-	tag_state state = {repo, &opts};
+	state.repo = repo;
+	state.opts = &opts;
 	action(&state);
 
 	git_repository_free(repo);
-- 
cgit v1.2.3


From 7bd2f401540e1e9c92183fd61aa9e2a4ef0ed051 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 5 Mar 2014 11:35:47 -0800
Subject: ODB writing fails gracefully when unsupported

If no ODB backends support writing, we should fail gracefully.
---
 src/odb.c                     | 18 ++++++++++++------
 tests/odb/backend/nobackend.c | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 53 insertions(+), 6 deletions(-)
 create mode 100644 tests/odb/backend/nobackend.c

diff --git a/src/odb.c b/src/odb.c
index b413f83b4..139949e31 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -862,7 +862,7 @@ int git_odb_open_wstream(
 {
 	size_t i, writes = 0;
 	int error = GIT_ERROR;
-	git_hash_ctx *ctx;
+	git_hash_ctx *ctx = NULL;
 
 	assert(stream && db);
 
@@ -883,22 +883,28 @@ int git_odb_open_wstream(
 		}
 	}
 
-	if (error == GIT_PASSTHROUGH)
-		error = 0;
-	if (error < 0 && !writes)
-		error = git_odb__error_unsupported_in_backend("write object");
+	if (error < 0) {
+		if (error == GIT_PASSTHROUGH)
+			error = 0;
+		else if (!writes)
+			error = git_odb__error_unsupported_in_backend("write object");
+
+		goto done;
+	}
 
 	ctx = git__malloc(sizeof(git_hash_ctx));
 	GITERR_CHECK_ALLOC(ctx);
 
+	if ((error = git_hash_ctx_init(ctx)) < 0)
+		goto done;
 
-	git_hash_ctx_init(ctx);
 	hash_header(ctx, size, type);
 	(*stream)->hash_ctx = ctx;
 
 	(*stream)->declared_size = size;
 	(*stream)->received_bytes = 0;
 
+done:
 	return error;
 }
 
diff --git a/tests/odb/backend/nobackend.c b/tests/odb/backend/nobackend.c
new file mode 100644
index 000000000..7ed5acced
--- /dev/null
+++ b/tests/odb/backend/nobackend.c
@@ -0,0 +1,41 @@
+#include "clar_libgit2.h"
+#include "repository.h"
+#include "git2/sys/repository.h"
+
+static git_repository *_repo;
+
+void test_odb_backend_nobackend__initialize(void)
+{
+	git_config *config;
+	git_odb *odb;
+	git_refdb *refdb;
+
+	cl_git_pass(git_repository_new(&_repo));
+	cl_git_pass(git_config_new(&config));
+	cl_git_pass(git_odb_new(&odb));
+	cl_git_pass(git_refdb_new(&refdb, _repo));
+
+	git_repository_set_config(_repo, config);
+	git_repository_set_odb(_repo, odb);
+	git_repository_set_refdb(_repo, refdb);
+}
+
+void test_odb_backend_nobackend__cleanup(void)
+{
+	git_repository_free(_repo);
+}
+
+void test_odb_backend_nobackend__write_fails_gracefully(void)
+{
+	git_oid id;
+	git_odb *odb;
+	const git_error *err;
+
+	git_repository_odb(&odb, _repo);
+	cl_git_fail(git_odb_write(&id, odb, "Hello world!\n", 13, GIT_OBJ_BLOB));
+
+	err = giterr_last();
+	cl_assert_equal_s(err->message, "Cannot write object - unsupported in the loaded odb backends");
+
+	git_odb_free(odb);
+}
-- 
cgit v1.2.3


From a213a7bfa82b7171b90c415cbdb44d469e747ece Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Mar 2014 20:32:53 +0100
Subject: refdb: catch a directory disappearing

If a directory disappears between the time we look up the entries of its
parent and the time when we go to look at it, we should ignore the error
and move forward.

This fixes #2046.
---
 src/path.c     |  3 +++
 src/refdb_fs.c | 12 ++++++++++--
 2 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/src/path.c b/src/path.c
index 89409eae4..fa800b74c 100644
--- a/src/path.c
+++ b/src/path.c
@@ -853,6 +853,9 @@ int git_path_direach(
 
 	if ((dir = opendir(path->ptr)) == NULL) {
 		giterr_set(GITERR_OS, "Failed to open directory '%s'", path->ptr);
+		if (errno == ENOENT)
+			return GIT_ENOTFOUND;
+
 		return -1;
 	}
 
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 43682f40e..3219b0519 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -272,9 +272,17 @@ static int _dirent_loose_load(void *payload, git_buf *full_path)
 	if (git__suffixcmp(full_path->ptr, ".lock") == 0)
 		return 0;
 
-	if (git_path_isdir(full_path->ptr))
-		return git_path_direach(
+	if (git_path_isdir(full_path->ptr)) {
+		int error = git_path_direach(
 			full_path, backend->direach_flags, _dirent_loose_load, backend);
+		/* Race with the filesystem, ignore it */
+		if (error == GIT_ENOTFOUND) {
+			giterr_clear();
+			return 0;
+		}
+
+		return error;
+	}
 
 	file_path = full_path->ptr + strlen(backend->path);
 
-- 
cgit v1.2.3


From 26875825df19d484c24921e355963e75dc0a4476 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 5 Mar 2014 13:06:22 -0800
Subject: Check short OID len in odb, not in backends

---
 src/odb.c       |  1 -
 src/odb_loose.c | 12 +++---------
 2 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/src/odb.c b/src/odb.c
index d49ee30fd..6f550ddce 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -800,7 +800,6 @@ int git_odb_read_prefix(
 
 	if (len < GIT_OID_MINPREFIXLEN)
 		return git_odb__error_ambiguous("prefix length too short");
-
 	if (len > GIT_OID_HEXSZ)
 		len = GIT_OID_HEXSZ;
 
diff --git a/src/odb_loose.c b/src/odb_loose.c
index e0b6ed1f3..7b46a6652 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -647,12 +647,9 @@ static int loose_backend__read_prefix(
 {
 	int error = 0;
 
-	assert(len <= GIT_OID_HEXSZ);
+	assert(len >= GIT_OID_MINPREFIXLEN && len <= GIT_OID_HEXSZ);
 
-	if (len < GIT_OID_MINPREFIXLEN)
-		error = git_odb__error_ambiguous("prefix length too short");
-
-	else if (len == GIT_OID_HEXSZ) {
+	if (len == GIT_OID_HEXSZ) {
 		/* We can fall back to regular read method */
 		error = loose_backend__read(buffer_p, len_p, type_p, backend, short_oid);
 		if (!error)
@@ -698,10 +695,7 @@ static int loose_backend__exists_prefix(
 	git_buf object_path = GIT_BUF_INIT;
 	int error;
 
-	assert(backend && out && short_id);
-
-	if (len < GIT_OID_MINPREFIXLEN)
-		return git_odb__error_ambiguous("prefix length too short");
+	assert(backend && out && short_id && len >= GIT_OID_MINPREFIXLEN);
 
 	error = locate_object_short_oid(
 		&object_path, out, (loose_backend *)backend, short_id, len);
-- 
cgit v1.2.3


From b9f819978c571cc806827e8b3ebc1a58a0755999 Mon Sep 17 00:00:00 2001
From: Matthew Bowen <matthew@mgbowen.com>
Date: Wed, 5 Mar 2014 21:49:23 -0500
Subject: Added function-based initializers for every options struct.

The basic structure of each function is courtesy of arrbee.
---
 include/git2/blame.h             |  13 +++++
 include/git2/checkout.h          |  13 +++++
 include/git2/clone.h             |  13 +++++
 include/git2/diff.h              |  26 +++++++++
 include/git2/merge.h             |  24 ++++++++
 include/git2/push.h              |  13 +++++
 include/git2/remote.h            |  13 +++++
 include/git2/repository.h        |  13 +++++
 include/git2/revert.h            |  13 +++++
 include/git2/status.h            |  13 +++++
 include/git2/sys/config.h        |  13 +++++
 include/git2/sys/odb_backend.h   |  13 +++++
 include/git2/sys/refdb_backend.h |  13 +++++
 include/git2/transport.h         |  13 +++++
 src/blame.c                      |  12 ++++
 src/checkout.c                   |  12 ++++
 src/clone.c                      |  12 ++++
 src/config.c                     |  12 ++++
 src/diff.c                       |  24 ++++++++
 src/merge.c                      |  24 ++++++++
 src/odb.c                        |  11 ++++
 src/push.c                       |  12 ++++
 src/refdb.c                      |  12 ++++
 src/remote.c                     |  12 ++++
 src/repository.c                 |  12 ++++
 src/revert.c                     |  12 ++++
 src/status.c                     |  11 ++++
 src/transport.c                  |  12 ++++
 tests/structinit/structinit.c    | 120 +++++++++++++++++++++++++++++++++++++++
 29 files changed, 516 insertions(+)
 create mode 100644 tests/structinit/structinit.c

diff --git a/include/git2/blame.h b/include/git2/blame.h
index 4ad51ee50..b7fa9aeda 100644
--- a/include/git2/blame.h
+++ b/include/git2/blame.h
@@ -82,6 +82,19 @@ typedef struct git_blame_options {
 #define GIT_BLAME_OPTIONS_VERSION 1
 #define GIT_BLAME_OPTIONS_INIT {GIT_BLAME_OPTIONS_VERSION}
 
+/**
+* Initializes a `git_blame_options` with default values. Equivalent to
+* creating an instance with GIT_BLAME_OPTIONS_INIT.
+*
+* @param opts the `git_blame_options` instance to initialize.
+* @param version the version of the struct; you should pass
+* `GIT_BLAME_OPTIONS_VERSION` here.
+* @return Zero on success; -1 on failure.
+*/
+GIT_EXTERN(int) git_blame_init_options(
+	git_blame_options* opts,
+	int version);
+
 /**
  * Structure that represents a blame hunk.
  *
diff --git a/include/git2/checkout.h b/include/git2/checkout.h
index 0faf4ab14..702e088d9 100644
--- a/include/git2/checkout.h
+++ b/include/git2/checkout.h
@@ -266,6 +266,19 @@ typedef struct git_checkout_opts {
 #define GIT_CHECKOUT_OPTS_VERSION 1
 #define GIT_CHECKOUT_OPTS_INIT {GIT_CHECKOUT_OPTS_VERSION}
 
+/**
+* Initializes a `git_checkout_opts` with default values. Equivalent to
+* creating an instance with GIT_CHECKOUT_OPTS_INIT.
+*
+* @param opts the `git_checkout_opts` instance to initialize.
+* @param version the version of the struct; you should pass
+* `GIT_CHECKOUT_OPTS_VERSION` here.
+* @return Zero on success; -1 on failure.
+*/
+GIT_EXTERN(int) git_checkout_init_opts(
+	git_checkout_opts* opts,
+	int version);
+
 /**
  * Updates files in the index and the working tree to match the content of
  * the commit pointed at by HEAD.
diff --git a/include/git2/clone.h b/include/git2/clone.h
index 3e885d103..98c6fb7d7 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -65,6 +65,19 @@ typedef struct git_clone_options {
 #define GIT_CLONE_OPTIONS_VERSION 1
 #define GIT_CLONE_OPTIONS_INIT {GIT_CLONE_OPTIONS_VERSION, {GIT_CHECKOUT_OPTS_VERSION, GIT_CHECKOUT_SAFE_CREATE}, GIT_REMOTE_CALLBACKS_INIT}
 
+/**
+* Initializes a `git_clone_options` with default values. Equivalent to
+* creating an instance with GIT_CLONE_OPTIONS_INIT.
+*
+* @param opts the `git_clone_options` instance to initialize.
+* @param version the version of the struct; you should pass
+* `GIT_CLONE_OPTIONS_VERSION` here.
+* @return Zero on success; -1 on failure.
+*/
+GIT_EXTERN(int) git_clone_init_options(
+	git_clone_options* opts,
+	int version);
+
 /**
  * Clone a remote repository.
  *
diff --git a/include/git2/diff.h b/include/git2/diff.h
index 943e2ec4c..f855f52ba 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -376,6 +376,19 @@ typedef struct {
 #define GIT_DIFF_OPTIONS_INIT \
 	{GIT_DIFF_OPTIONS_VERSION, 0, GIT_SUBMODULE_IGNORE_DEFAULT, {NULL,0}, NULL, NULL, 3}
 
+/**
+* Initializes a `git_diff_options` with default values. Equivalent to
+* creating an instance with GIT_DIFF_OPTIONS_INIT.
+*
+* @param opts the `git_diff_options` instance to initialize.
+* @param version the version of the struct; you should pass
+* `GIT_DIFF_OPTIONS_VERSION` here.
+* @return Zero on success; -1 on failure.
+*/
+GIT_EXTERN(int) git_diff_init_options(
+	git_diff_options* opts,
+	int version);
+
 /**
  * When iterating over a diff, callback that will be made per file.
  *
@@ -604,6 +617,19 @@ typedef struct {
 #define GIT_DIFF_FIND_OPTIONS_VERSION 1
 #define GIT_DIFF_FIND_OPTIONS_INIT {GIT_DIFF_FIND_OPTIONS_VERSION}
 
+/**
+* Initializes a `git_diff_find_options` with default values. Equivalent to
+* creating an instance with GIT_DIFF_FIND_OPTIONS_INIT.
+*
+* @param opts the `git_diff_find_options` instance to initialize.
+* @param version the version of the struct; you should pass
+* `GIT_DIFF_FIND_OPTIONS_VERSION` here.
+* @return Zero on success; -1 on failure.
+*/
+GIT_EXTERN(int) git_diff_find_init_options(
+	git_diff_find_options* opts,
+	int version);
+
 /** @name Diff Generator Functions
  *
  * These are the functions you would use to create (or destroy) a
diff --git a/include/git2/merge.h b/include/git2/merge.h
index b45d0fd5e..dc89a0482 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -104,6 +104,18 @@ typedef struct {
 #define GIT_MERGE_TREE_OPTS_VERSION 1
 #define GIT_MERGE_TREE_OPTS_INIT {GIT_MERGE_TREE_OPTS_VERSION}
 
+/**
+ * Initializes a `git_merge_tree_opts` with default values. Equivalent to
+ * creating an instance with GIT_MERGE_TREE_OPTS_INIT.
+ *
+ * @param opts the `git_merge_tree_opts` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_MERGE_TREE_OPTS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_merge_tree_init_opts(
+	git_merge_tree_opts* opts,
+	int version);
 
 /**
  * Option flags for `git_merge`.
@@ -144,6 +156,18 @@ typedef struct {
 #define GIT_MERGE_OPTS_VERSION 1
 #define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
 
+/**
+ * Initializes a `git_merge_opts` with default values. Equivalent to creating
+ * an instance with GIT_MERGE_OPTS_INIT.
+ *
+ * @param opts the `git_merge_opts` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_MERGE_OPTS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_merge_init_opts(
+	git_merge_opts* opts,
+	int version);
 
 /**
  * Find a merge base between two commits
diff --git a/include/git2/push.h b/include/git2/push.h
index 67702aca2..899d21e7f 100644
--- a/include/git2/push.h
+++ b/include/git2/push.h
@@ -39,6 +39,19 @@ typedef struct {
 #define GIT_PUSH_OPTIONS_VERSION 1
 #define GIT_PUSH_OPTIONS_INIT { GIT_PUSH_OPTIONS_VERSION }
 
+/**
+ * Initializes a `git_push_options` with default values. Equivalent to
+ * creating an instance with GIT_PUSH_OPTIONS_INIT.
+ *
+ * @param opts the `git_push_options` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_PUSH_OPTIONS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_push_init_options(
+	git_push_options* opts,
+	int version);
+
 /** Push network progress notification function */
 typedef int (*git_push_transfer_progress)(
 	unsigned int current,
diff --git a/include/git2/remote.h b/include/git2/remote.h
index 238b6fd4f..82a46acd1 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -494,6 +494,19 @@ struct git_remote_callbacks {
 #define GIT_REMOTE_CALLBACKS_VERSION 1
 #define GIT_REMOTE_CALLBACKS_INIT {GIT_REMOTE_CALLBACKS_VERSION}
 
+/**
+ * Initializes a `git_remote_callbacks` with default values. Equivalent to
+ * creating an instance with GIT_REMOTE_CALLBACKS_INIT.
+ *
+ * @param opts the `git_remote_callbacks` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_REMOTE_CALLBACKS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_remote_init_callbacks(
+	git_remote_callbacks* opts,
+	int version);
+
 /**
  * Set the callbacks for a remote
  *
diff --git a/include/git2/repository.h b/include/git2/repository.h
index bf12c7a69..4433e71a2 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -267,6 +267,19 @@ typedef struct {
 #define GIT_REPOSITORY_INIT_OPTIONS_VERSION 1
 #define GIT_REPOSITORY_INIT_OPTIONS_INIT {GIT_REPOSITORY_INIT_OPTIONS_VERSION}
 
+/**
+ * Initializes a `git_repository_init_options` with default values. Equivalent
+ * to creating an instance with GIT_REPOSITORY_INIT_OPTIONS_INIT.
+ *
+ * @param opts the `git_repository_init_options` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_REPOSITORY_INIT_OPTIONS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_repository_init_init_options(
+	git_repository_init_options* opts,
+	int version);
+
 /**
  * Create a new Git repository in the given folder with extended controls.
  *
diff --git a/include/git2/revert.h b/include/git2/revert.h
index 86a6e26cb..088bda94d 100644
--- a/include/git2/revert.h
+++ b/include/git2/revert.h
@@ -33,6 +33,19 @@ typedef struct {
 #define GIT_REVERT_OPTS_VERSION 1
 #define GIT_REVERT_OPTS_INIT {GIT_REVERT_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
 
+/**
+ * Initializes a `git_revert_opts` with default values. Equivalent to
+ * creating an instance with GIT_REVERT_OPTS_INIT.
+ *
+ * @param opts the `git_revert_opts` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_REVERT_OPTS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_revert_init_opts(
+	git_revert_opts* opts,
+	int version);
+
 /**
  * Reverts the given commit against the given "our" commit, producing an
  * index that reflects the result of the revert.
diff --git a/include/git2/status.h b/include/git2/status.h
index aa68c0da0..84918456a 100644
--- a/include/git2/status.h
+++ b/include/git2/status.h
@@ -174,6 +174,19 @@ typedef struct {
 #define GIT_STATUS_OPTIONS_VERSION 1
 #define GIT_STATUS_OPTIONS_INIT {GIT_STATUS_OPTIONS_VERSION}
 
+/**
+ * Initializes a `git_status_options` with default values. Equivalent to
+ * creating an instance with GIT_STATUS_OPTIONS_INIT.
+ *
+ * @param opts the `git_status_options` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_STATUS_OPTIONS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_status_init_options(
+	git_status_options* opts,
+	int version);
+
 /**
  * A status entry, providing the differences between the file as it exists
  * in HEAD and the index, and providing the differences between the index
diff --git a/include/git2/sys/config.h b/include/git2/sys/config.h
index 419ad7ea7..3df2ba327 100644
--- a/include/git2/sys/config.h
+++ b/include/git2/sys/config.h
@@ -69,6 +69,19 @@ struct git_config_backend {
 #define GIT_CONFIG_BACKEND_VERSION 1
 #define GIT_CONFIG_BACKEND_INIT {GIT_CONFIG_BACKEND_VERSION}
 
+/**
+ * Initializes a `git_config_backend` with default values. Equivalent to
+ * creating an instance with GIT_CONFIG_BACKEND_INIT.
+ *
+ * @param opts the `git_config_backend` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_CONFIG_BACKEND_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_config_init_backend(
+	git_config_backend* backend,
+	int version);
+
 /**
  * Add a generic config file instance to an existing config
  *
diff --git a/include/git2/sys/odb_backend.h b/include/git2/sys/odb_backend.h
index 4917ba0f0..81bb082e6 100644
--- a/include/git2/sys/odb_backend.h
+++ b/include/git2/sys/odb_backend.h
@@ -89,6 +89,19 @@ struct git_odb_backend {
 #define GIT_ODB_BACKEND_VERSION 1
 #define GIT_ODB_BACKEND_INIT {GIT_ODB_BACKEND_VERSION}
 
+/**
+ * Initializes a `git_odb_backend` with default values. Equivalent to
+ * creating an instance with GIT_ODB_BACKEND_INIT.
+ *
+ * @param opts the `git_odb_backend` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_ODB_BACKEND_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_odb_init_backend(
+	git_odb_backend* backend,
+	int version);
+
 GIT_EXTERN(void *) git_odb_backend_malloc(git_odb_backend *backend, size_t len);
 
 GIT_END_DECL
diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index aa5ef9ecc..dce142c77 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -158,6 +158,19 @@ struct git_refdb_backend {
 #define GIT_REFDB_BACKEND_VERSION 1
 #define GIT_REFDB_BACKEND_INIT {GIT_REFDB_BACKEND_VERSION}
 
+/**
+ * Initializes a `git_refdb_backend` with default values. Equivalent to
+ * creating an instance with GIT_REFDB_BACKEND_INIT.
+ *
+ * @param opts the `git_refdb_backend` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_REFDB_BACKEND_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_refdb_init_backend(
+	git_refdb_backend* backend,
+	int version);
+
 /**
  * Constructors for default filesystem-based refdb backend
  *
diff --git a/include/git2/transport.h b/include/git2/transport.h
index 039321088..f2b0c630d 100644
--- a/include/git2/transport.h
+++ b/include/git2/transport.h
@@ -279,6 +279,19 @@ struct git_transport {
 #define GIT_TRANSPORT_VERSION 1
 #define GIT_TRANSPORT_INIT {GIT_TRANSPORT_VERSION}
 
+/**
+ * Initializes a `git_transport` with default values. Equivalent to
+ * creating an instance with GIT_TRANSPORT_INIT.
+ *
+ * @param opts the `git_transport` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_TRANSPORT_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_transport_init(
+	git_transport* opts,
+	int version);
+
 /**
  * Function to use to create a transport from a URL. The transport database
  * is scanned to find a transport that implements the scheme of the URI (i.e.
diff --git a/src/blame.c b/src/blame.c
index 71bc460c6..01f88b729 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -476,3 +476,15 @@ int git_blame_buffer(
 	*out = blame;
 	return 0;
 }
+
+int git_blame_init_options(git_blame_options* opts, int version)
+{
+	if (version != GIT_BLAME_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_blame_options", version);
+		return -1;
+	} else {
+		git_blame_options o = GIT_BLAME_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/checkout.c b/src/checkout.c
index 72fe5368f..4ef8da076 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -2194,3 +2194,15 @@ int git_checkout_head(
 	assert(repo);
 	return git_checkout_tree(repo, NULL, opts);
 }
+
+int git_checkout_init_opts(git_checkout_opts* opts, int version)
+{
+	if (version != GIT_CHECKOUT_OPTS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_checkout_opts", version);
+		return -1;
+	} else {
+		git_checkout_opts o = GIT_CHECKOUT_OPTS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/clone.c b/src/clone.c
index bcc38678f..b5333bdb7 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -439,3 +439,15 @@ int git_clone(
 	*out = repo;
 	return error;
 }
+
+int git_clone_init_options(git_clone_options* opts, int version)
+{
+	if (version != GIT_CLONE_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_clone_options", version);
+		return -1;
+	} else {
+		git_clone_options o = GIT_CLONE_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/config.c b/src/config.c
index ae093ed64..1a205fe13 100644
--- a/src/config.c
+++ b/src/config.c
@@ -1245,3 +1245,15 @@ cleanup:
 
 	return error;
 }
+
+int git_config_init_backend(git_config_backend* backend, int version)
+{
+	if (version != GIT_CONFIG_BACKEND_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_config_backend", version);
+		return -1;
+	} else {
+		git_config_backend b = GIT_CONFIG_BACKEND_INIT;
+		memcpy(backend, &b, sizeof(b));
+		return 0;
+	}
+}
diff --git a/src/diff.c b/src/diff.c
index 151990ed6..dc7735f4f 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -1413,3 +1413,27 @@ int git_diff__paired_foreach(
 
 	return error;
 }
+
+int git_diff_init_options(git_diff_options* opts, int version)
+{
+	if (version != GIT_DIFF_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_options", version);
+		return -1;
+	} else {
+		git_diff_options o = GIT_DIFF_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
+
+int git_diff_find_init_options(git_diff_find_options* opts, int version)
+{
+	if (version != GIT_DIFF_FIND_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_find_options", version);
+		return -1;
+	} else {
+		git_diff_find_options o = GIT_DIFF_FIND_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/merge.c b/src/merge.c
index 12ff1c91c..124e8c3a7 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2744,3 +2744,27 @@ void git_merge_head_free(git_merge_head *head)
 
 	git__free(head);
 }
+
+int git_merge_init_opts(git_merge_opts* opts, int version)
+{
+	if (version != GIT_MERGE_OPTS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_opts", version);
+		return -1;
+	} else {
+		git_merge_opts o = GIT_MERGE_OPTS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
+
+int git_merge_tree_init_opts(git_merge_tree_opts* opts, int version)
+{
+	if (version != GIT_MERGE_TREE_OPTS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_tree_opts", version);
+		return -1;
+	} else {
+		git_merge_tree_opts o = GIT_MERGE_TREE_OPTS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/odb.c b/src/odb.c
index 30bba9603..085eda594 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -1113,3 +1113,14 @@ int git_odb__error_ambiguous(const char *message)
 	return GIT_EAMBIGUOUS;
 }
 
+int git_odb_init_backend(git_odb_backend* backend, int version)
+{
+	if (version != GIT_ODB_BACKEND_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_odb_backend", version);
+		return -1;
+	} else {
+		git_odb_backend b = GIT_ODB_BACKEND_INIT;
+		memcpy(backend, &b, sizeof(b));
+		return 0;
+	}
+}
diff --git a/src/push.c b/src/push.c
index c2947808e..521355621 100644
--- a/src/push.c
+++ b/src/push.c
@@ -705,3 +705,15 @@ void git_push_free(git_push *push)
 
 	git__free(push);
 }
+
+int git_push_init_options(git_push_options* opts, int version)
+{
+	if (version != GIT_PUSH_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_push_options", version);
+		return -1;
+	} else {
+		git_push_options o = GIT_PUSH_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/refdb.c b/src/refdb.c
index 984c3c7f6..3e7a592f8 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -235,3 +235,15 @@ int git_refdb_ensure_log(git_refdb *db, const char *refname)
 
 	return db->backend->ensure_log(db->backend, refname);
 }
+
+int git_refdb_init_backend(git_refdb_backend* backend, int version)
+{
+	if (version != GIT_REFDB_BACKEND_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_refdb_backend", version);
+		return -1;
+	} else {
+		git_refdb_backend b = GIT_REFDB_BACKEND_INIT;
+		memcpy(backend, &b, sizeof(b));
+		return 0;
+	}
+}
diff --git a/src/remote.c b/src/remote.c
index 6f97d56a1..caefc686e 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1731,3 +1731,15 @@ const git_refspec *git_remote_get_refspec(const git_remote *remote, size_t n)
 {
 	return git_vector_get(&remote->refspecs, n);
 }
+
+int git_remote_init_callbacks(git_remote_callbacks* opts, int version)
+{
+	if (version != GIT_REMOTE_CALLBACKS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_remote_callbacks", version);
+		return -1;
+	} else {
+		git_remote_callbacks o = GIT_REMOTE_CALLBACKS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/repository.c b/src/repository.c
index b94973c74..fccc16faa 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -2010,3 +2010,15 @@ int git_repository_is_shallow(git_repository *repo)
 		return error;
 	return st.st_size == 0 ? 0 : 1;
 }
+
+int git_repository_init_init_options(git_repository_init_options* opts, int version)
+{
+	if (version != GIT_REPOSITORY_INIT_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_repository_init_options", version);
+		return -1;
+	} else {
+		git_repository_init_options o = GIT_REPOSITORY_INIT_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/revert.c b/src/revert.c
index 4ba329907..a397a8eeb 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -218,3 +218,15 @@ done:
 
 	return error;
 }
+
+int git_revert_init_opts(git_revert_opts* opts, int version)
+{
+	if (version != GIT_REVERT_OPTS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_revert_opts", version);
+		return -1;
+	} else {
+		git_revert_opts o = GIT_REVERT_OPTS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/status.c b/src/status.c
index 3c95b347c..c4b990a84 100644
--- a/src/status.c
+++ b/src/status.c
@@ -495,3 +495,14 @@ int git_status_should_ignore(
 	return git_ignore_path_is_ignored(ignored, repo, path);
 }
 
+int git_status_init_options(git_status_options* opts, int version)
+{
+	if (version != GIT_STATUS_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_status_options", version);
+		return -1;
+	} else {
+		git_status_options o = GIT_STATUS_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/transport.c b/src/transport.c
index 2b0c6a185..dc074a503 100644
--- a/src/transport.c
+++ b/src/transport.c
@@ -217,3 +217,15 @@ int git_remote_supported_url(const char* url)
 
 	return fn != &git_transport_dummy;
 }
+
+int git_transport_init(git_transport* opts, int version)
+{
+	if (version != GIT_TRANSPORT_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_transport", version);
+		return -1;
+	} else {
+		git_transport o = GIT_TRANSPORT_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/tests/structinit/structinit.c b/tests/structinit/structinit.c
new file mode 100644
index 000000000..db7ee07fa
--- /dev/null
+++ b/tests/structinit/structinit.c
@@ -0,0 +1,120 @@
+#include "clar_libgit2.h"
+#include <git2/sys/config.h>
+#include <git2/sys/odb_backend.h>
+#include <git2/sys/refdb_backend.h>
+
+#define STRINGIFY(s) #s
+
+/* Checks two conditions for the specified structure:
+ *     1. That the initializers for the latest version produces the same
+ *        in-memory representation.
+ *     2. That the function-based initializer supports all versions from 1...n,
+ *        where n is the latest version (often represented by GIT_*_VERSION).
+ *
+ * Parameters:
+ *     structname: The name of the structure to test, e.g. git_blame_options.
+ *     structver: The latest version of the specified structure.
+ *     macroinit: The macro that initializes the latest version of the structure.
+ *     funcinitname: The function that initializes the structure. Must have the
+ *                   signature "int (structname* instance, int version)".
+ */
+#define CHECK_MACRO_FUNC_INIT_EQUAL(structname, structver, macroinit, funcinitname) \
+	structname structname##_macro_latest = macroinit; \
+	structname structname##_func_latest; \
+	cl_git_pass(funcinitname(&structname##_func_latest, structver)); \
+	cl_check_( \
+		memcmp(&structname##_macro_latest, &structname##_func_latest, \
+			sizeof(structname)) == 0, \
+		"Macro-based and function-based initializer for " STRINGIFY(structname) \
+			" are not equivalent."); \
+	\
+	int structname##_curr_ver = structver - 1; \
+	while (structname##_curr_ver > 0) \
+	{ \
+		structname macro; \
+		cl_git_pass(funcinitname(&macro, structname##_curr_ver)); \
+		structname##_curr_ver--; \
+	}
+
+void test_structinit_structinit__compare(void)
+{
+	/* blame */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_blame_options, GIT_BLAME_OPTIONS_VERSION, \
+		GIT_BLAME_OPTIONS_INIT, git_blame_init_options);
+
+	/* checkout */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_checkout_opts, GIT_CHECKOUT_OPTS_VERSION, \
+		GIT_CHECKOUT_OPTS_INIT, git_checkout_init_opts);
+
+	/* clone */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_clone_options, GIT_CLONE_OPTIONS_VERSION, \
+		GIT_CLONE_OPTIONS_INIT, git_clone_init_options);
+
+	/* diff */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_diff_options, GIT_DIFF_OPTIONS_VERSION, \
+		GIT_DIFF_OPTIONS_INIT, git_diff_init_options);
+
+	/* diff_find */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_diff_find_options, GIT_DIFF_FIND_OPTIONS_VERSION, \
+		GIT_DIFF_FIND_OPTIONS_INIT, git_diff_find_init_options);
+
+	/* merge_tree */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_merge_tree_opts, GIT_MERGE_TREE_OPTS_VERSION, \
+		GIT_MERGE_TREE_OPTS_INIT, git_merge_tree_init_opts);
+
+	/* merge */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_merge_opts, GIT_MERGE_OPTS_VERSION, \
+		GIT_MERGE_OPTS_INIT, git_merge_init_opts);
+
+	/* push */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_push_options, GIT_PUSH_OPTIONS_VERSION, \
+		GIT_PUSH_OPTIONS_INIT, git_push_init_options);
+
+	/* remote */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_remote_callbacks, GIT_REMOTE_CALLBACKS_VERSION, \
+		GIT_REMOTE_CALLBACKS_INIT, git_remote_init_callbacks);
+
+	/* repository_init */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_repository_init_options, GIT_REPOSITORY_INIT_OPTIONS_VERSION, \
+		GIT_REPOSITORY_INIT_OPTIONS_INIT, git_repository_init_init_options);
+
+	/* revert */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_revert_opts, GIT_REVERT_OPTS_VERSION, \
+		GIT_REVERT_OPTS_INIT, git_revert_init_opts);
+
+	/* status */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_status_options, GIT_STATUS_OPTIONS_VERSION, \
+		GIT_STATUS_OPTIONS_INIT, git_status_init_options);
+
+	/* transport */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_transport, GIT_TRANSPORT_VERSION, \
+		GIT_TRANSPORT_INIT, git_transport_init);
+
+	/* config_backend */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_config_backend, GIT_CONFIG_BACKEND_VERSION, \
+		GIT_CONFIG_BACKEND_INIT, git_config_init_backend);
+
+	/* odb_backend */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_odb_backend, GIT_ODB_BACKEND_VERSION, \
+		GIT_ODB_BACKEND_INIT, git_odb_init_backend);
+
+	/* refdb_backend */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_refdb_backend, GIT_REFDB_BACKEND_VERSION, \
+		GIT_REFDB_BACKEND_INIT, git_refdb_init_backend);
+}
-- 
cgit v1.2.3


From 2ab6d2cd47a9175faa8d9915751511d9490b03b9 Mon Sep 17 00:00:00 2001
From: Vicent Marti <vicent@github.com>
Date: Thu, 6 Mar 2014 16:08:17 +0100
Subject: Revert pull request #1997

---
 include/git2/merge.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 5e6c486fd..dc89a0482 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -154,7 +154,7 @@ typedef struct {
 } git_merge_opts;
 
 #define GIT_MERGE_OPTS_VERSION 1
-#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, (git_merge_flags_t)0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
+#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
 
 /**
  * Initializes a `git_merge_opts` with default values. Equivalent to creating
-- 
cgit v1.2.3


From 8e5247203720de7abd084996c00afd6fb6f6cc21 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 6 Mar 2014 16:40:34 +0100
Subject: tests: MSVC compat

MSVC doesn't like declaring variables in the middle of a block, so make
sure we only declare variables at the beginning of a block.
---
 tests/structinit/structinit.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/tests/structinit/structinit.c b/tests/structinit/structinit.c
index db7ee07fa..ce425be41 100644
--- a/tests/structinit/structinit.c
+++ b/tests/structinit/structinit.c
@@ -19,8 +19,10 @@
  *                   signature "int (structname* instance, int version)".
  */
 #define CHECK_MACRO_FUNC_INIT_EQUAL(structname, structver, macroinit, funcinitname) \
+do { \
 	structname structname##_macro_latest = macroinit; \
 	structname structname##_func_latest; \
+	int structname##_curr_ver = structver - 1; \
 	cl_git_pass(funcinitname(&structname##_func_latest, structver)); \
 	cl_check_( \
 		memcmp(&structname##_macro_latest, &structname##_func_latest, \
@@ -28,13 +30,13 @@
 		"Macro-based and function-based initializer for " STRINGIFY(structname) \
 			" are not equivalent."); \
 	\
-	int structname##_curr_ver = structver - 1; \
 	while (structname##_curr_ver > 0) \
 	{ \
 		structname macro; \
 		cl_git_pass(funcinitname(&macro, structname##_curr_ver)); \
 		structname##_curr_ver--; \
-	}
+	}\
+} while(0)
 
 void test_structinit_structinit__compare(void)
 {
-- 
cgit v1.2.3


From 6affd71f33f9a9693425d6f3599ba1f25226c34b Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Fri, 3 Jan 2014 17:38:34 -0800
Subject: git_checkout_opts -> git_checkout_options

---
 examples/network/clone.c       |  2 +-
 include/git2/checkout.h        | 28 ++++++++++++------------
 include/git2/clone.h           |  6 +++---
 include/git2/merge.h           |  4 ++--
 include/git2/revert.h          |  4 ++--
 src/checkout.c                 | 28 ++++++++++++------------
 src/checkout.h                 |  2 +-
 src/clone.c                    |  4 ++--
 src/reset.c                    |  2 +-
 src/stash.c                    |  2 +-
 tests/checkout/binaryunicode.c |  2 +-
 tests/checkout/conflict.c      | 34 ++++++++++++++---------------
 tests/checkout/crlf.c          | 49 +++++++++++++++++++++++++++++++-----------
 tests/checkout/head.c          |  2 +-
 tests/checkout/index.c         | 46 +++++++++++++++++++--------------------
 tests/checkout/tree.c          | 36 +++++++++++++++----------------
 tests/checkout/typechange.c    |  4 ++--
 tests/clone/nonetwork.c        |  2 +-
 tests/diff/rename.c            |  6 +++---
 tests/index/names.c            |  6 +++---
 tests/index/reuc.c             |  6 +++---
 tests/merge/merge_helpers.c    |  2 +-
 tests/merge/workdir/trivial.c  |  2 +-
 tests/online/clone.c           |  4 ++--
 tests/structinit/structinit.c  |  4 ++--
 25 files changed, 156 insertions(+), 131 deletions(-)

diff --git a/examples/network/clone.c b/examples/network/clone.c
index a982c13c2..182d1c35b 100644
--- a/examples/network/clone.c
+++ b/examples/network/clone.c
@@ -62,7 +62,7 @@ int do_clone(git_repository *repo, int argc, char **argv)
 	progress_data pd = {{0}};
 	git_repository *cloned_repo = NULL;
 	git_clone_options clone_opts = GIT_CLONE_OPTIONS_INIT;
-	git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	const char *url = argv[1];
 	const char *path = argv[2];
 	int error;
diff --git a/include/git2/checkout.h b/include/git2/checkout.h
index 702e088d9..69addb7d9 100644
--- a/include/git2/checkout.h
+++ b/include/git2/checkout.h
@@ -225,12 +225,12 @@ typedef void (*git_checkout_progress_cb)(
 /**
  * Checkout options structure
  *
- * Zero out for defaults.  Initialize with `GIT_CHECKOUT_OPTS_INIT` macro to
+ * Zero out for defaults.  Initialize with `GIT_CHECKOUT_OPTIONS_INIT` macro to
  * correctly set the `version` field.  E.g.
  *
- *		git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+ *		git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
  */
-typedef struct git_checkout_opts {
+typedef struct git_checkout_options {
 	unsigned int version;
 
 	unsigned int checkout_strategy; /** default will be a dry run */
@@ -261,22 +261,22 @@ typedef struct git_checkout_opts {
 	const char *ancestor_label; /** the name of the common ancestor side of conflicts */
 	const char *our_label; /** the name of the "our" side of conflicts */
 	const char *their_label; /** the name of the "their" side of conflicts */
-} git_checkout_opts;
+} git_checkout_options;
 
-#define GIT_CHECKOUT_OPTS_VERSION 1
-#define GIT_CHECKOUT_OPTS_INIT {GIT_CHECKOUT_OPTS_VERSION}
+#define GIT_CHECKOUT_OPTIONS_VERSION 1
+#define GIT_CHECKOUT_OPTIONS_INIT {GIT_CHECKOUT_OPTIONS_VERSION}
 
 /**
-* Initializes a `git_checkout_opts` with default values. Equivalent to
-* creating an instance with GIT_CHECKOUT_OPTS_INIT.
+* Initializes a `git_checkout_options` with default values. Equivalent to
+* creating an instance with GIT_CHECKOUT_OPTIONS_INIT.
 *
-* @param opts the `git_checkout_opts` instance to initialize.
+* @param opts the `git_checkout_options` instance to initialize.
 * @param version the version of the struct; you should pass
-* `GIT_CHECKOUT_OPTS_VERSION` here.
+* `GIT_CHECKOUT_OPTIONS_VERSION` here.
 * @return Zero on success; -1 on failure.
 */
 GIT_EXTERN(int) git_checkout_init_opts(
-	git_checkout_opts* opts,
+	git_checkout_options* opts,
 	int version);
 
 /**
@@ -291,7 +291,7 @@ GIT_EXTERN(int) git_checkout_init_opts(
  */
 GIT_EXTERN(int) git_checkout_head(
 	git_repository *repo,
-	const git_checkout_opts *opts);
+	const git_checkout_options *opts);
 
 /**
  * Updates files in the working tree to match the content of the index.
@@ -305,7 +305,7 @@ GIT_EXTERN(int) git_checkout_head(
 GIT_EXTERN(int) git_checkout_index(
 	git_repository *repo,
 	git_index *index,
-	const git_checkout_opts *opts);
+	const git_checkout_options *opts);
 
 /**
  * Updates files in the index and working tree to match the content of the
@@ -321,7 +321,7 @@ GIT_EXTERN(int) git_checkout_index(
 GIT_EXTERN(int) git_checkout_tree(
 	git_repository *repo,
 	const git_object *treeish,
-	const git_checkout_opts *opts);
+	const git_checkout_options *opts);
 
 /** @} */
 GIT_END_DECL
diff --git a/include/git2/clone.h b/include/git2/clone.h
index 98c6fb7d7..20be1a105 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -52,7 +52,7 @@ GIT_BEGIN_DECL
 typedef struct git_clone_options {
 	unsigned int version;
 
-	git_checkout_opts checkout_opts;
+	git_checkout_options checkout_opts;
 	git_remote_callbacks remote_callbacks;
 
 	int bare;
@@ -63,7 +63,7 @@ typedef struct git_clone_options {
 } git_clone_options;
 
 #define GIT_CLONE_OPTIONS_VERSION 1
-#define GIT_CLONE_OPTIONS_INIT {GIT_CLONE_OPTIONS_VERSION, {GIT_CHECKOUT_OPTS_VERSION, GIT_CHECKOUT_SAFE_CREATE}, GIT_REMOTE_CALLBACKS_INIT}
+#define GIT_CLONE_OPTIONS_INIT {GIT_CLONE_OPTIONS_VERSION, {GIT_CHECKOUT_OPTIONS_VERSION, GIT_CHECKOUT_SAFE_CREATE}, GIT_REMOTE_CALLBACKS_INIT}
 
 /**
 * Initializes a `git_clone_options` with default values. Equivalent to
@@ -120,7 +120,7 @@ GIT_EXTERN(int) git_clone(
 GIT_EXTERN(int) git_clone_into(
 	git_repository *repo,
 	git_remote *remote,
-	const git_checkout_opts *co_opts,
+	const git_checkout_options *co_opts,
 	const char *branch,
 	const git_signature *signature);
 
diff --git a/include/git2/merge.h b/include/git2/merge.h
index dc89a0482..3563f35d5 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -150,11 +150,11 @@ typedef struct {
 	git_merge_tree_opts merge_tree_opts;
 
 	/** Options for writing the merge result to the working directory. */
-	git_checkout_opts checkout_opts;
+	git_checkout_options checkout_opts;
 } git_merge_opts;
 
 #define GIT_MERGE_OPTS_VERSION 1
-#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
+#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
 
 /**
  * Initializes a `git_merge_opts` with default values. Equivalent to creating
diff --git a/include/git2/revert.h b/include/git2/revert.h
index 088bda94d..fcdf2a2ca 100644
--- a/include/git2/revert.h
+++ b/include/git2/revert.h
@@ -27,11 +27,11 @@ typedef struct {
 	unsigned int mainline;
 
 	git_merge_tree_opts merge_tree_opts;
-	git_checkout_opts checkout_opts;
+	git_checkout_options checkout_opts;
 } git_revert_opts;
 
 #define GIT_REVERT_OPTS_VERSION 1
-#define GIT_REVERT_OPTS_INIT {GIT_REVERT_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTS_INIT}
+#define GIT_REVERT_OPTS_INIT {GIT_REVERT_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
 
 /**
  * Initializes a `git_revert_opts` with default values. Equivalent to
diff --git a/src/checkout.c b/src/checkout.c
index 4ef8da076..5dd4ec71c 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -47,7 +47,7 @@ enum {
 typedef struct {
 	git_repository *repo;
 	git_diff *diff;
-	git_checkout_opts opts;
+	git_checkout_options opts;
 	bool opts_free_baseline;
 	char *pfx;
 	git_index *index;
@@ -1144,7 +1144,7 @@ static int blob_content_to_file(
 	const char *path,
 	const char * hint_path,
 	mode_t entry_filemode,
-	git_checkout_opts *opts)
+	git_checkout_options *opts)
 {
 	int error = 0;
 	mode_t file_mode = opts->file_mode ? opts->file_mode : entry_filemode;
@@ -1856,7 +1856,7 @@ static void checkout_data_clear(checkout_data *data)
 static int checkout_data_init(
 	checkout_data *data,
 	git_iterator *target,
-	const git_checkout_opts *proposed)
+	const git_checkout_options *proposed)
 {
 	int error = 0;
 	git_repository *repo = git_iterator_owner(target);
@@ -1875,12 +1875,12 @@ static int checkout_data_init(
 	data->repo = repo;
 
 	GITERR_CHECK_VERSION(
-		proposed, GIT_CHECKOUT_OPTS_VERSION, "git_checkout_opts");
+		proposed, GIT_CHECKOUT_OPTIONS_VERSION, "git_checkout_options");
 
 	if (!proposed)
-		GIT_INIT_STRUCTURE(&data->opts, GIT_CHECKOUT_OPTS_VERSION);
+		GIT_INIT_STRUCTURE(&data->opts, GIT_CHECKOUT_OPTIONS_VERSION);
 	else
-		memmove(&data->opts, proposed, sizeof(git_checkout_opts));
+		memmove(&data->opts, proposed, sizeof(git_checkout_options));
 
 	if (!data->opts.target_directory)
 		data->opts.target_directory = git_repository_workdir(repo);
@@ -2000,7 +2000,7 @@ cleanup:
 
 int git_checkout_iterator(
 	git_iterator *target,
-	const git_checkout_opts *opts)
+	const git_checkout_options *opts)
 {
 	int error = 0;
 	git_iterator *baseline = NULL, *workdir = NULL;
@@ -2106,7 +2106,7 @@ cleanup:
 int git_checkout_index(
 	git_repository *repo,
 	git_index *index,
-	const git_checkout_opts *opts)
+	const git_checkout_options *opts)
 {
 	int error;
 	git_iterator *index_i;
@@ -2141,7 +2141,7 @@ int git_checkout_index(
 int git_checkout_tree(
 	git_repository *repo,
 	const git_object *treeish,
-	const git_checkout_opts *opts)
+	const git_checkout_options *opts)
 {
 	int error;
 	git_tree *tree = NULL;
@@ -2189,19 +2189,19 @@ int git_checkout_tree(
 
 int git_checkout_head(
 	git_repository *repo,
-	const git_checkout_opts *opts)
+	const git_checkout_options *opts)
 {
 	assert(repo);
 	return git_checkout_tree(repo, NULL, opts);
 }
 
-int git_checkout_init_opts(git_checkout_opts* opts, int version)
+int git_checkout_init_opts(git_checkout_options* opts, int version)
 {
-	if (version != GIT_CHECKOUT_OPTS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_checkout_opts", version);
+	if (version != GIT_CHECKOUT_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_checkout_options", version);
 		return -1;
 	} else {
-		git_checkout_opts o = GIT_CHECKOUT_OPTS_INIT;
+		git_checkout_options o = GIT_CHECKOUT_OPTIONS_INIT;
 		memcpy(opts, &o, sizeof(o));
 		return 0;
 	}
diff --git a/src/checkout.h b/src/checkout.h
index 6d7186860..f1fe69628 100644
--- a/src/checkout.h
+++ b/src/checkout.h
@@ -19,6 +19,6 @@
  */
 extern int git_checkout_iterator(
 	git_iterator *target,
-	const git_checkout_opts *opts);
+	const git_checkout_options *opts);
 
 #endif
diff --git a/src/clone.c b/src/clone.c
index b5333bdb7..e19d02ba2 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -322,7 +322,7 @@ on_error:
 static bool should_checkout(
 	git_repository *repo,
 	bool is_bare,
-	const git_checkout_opts *opts)
+	const git_checkout_options *opts)
 {
 	if (is_bare)
 		return false;
@@ -336,7 +336,7 @@ static bool should_checkout(
 	return !git_repository_head_unborn(repo);
 }
 
-int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_opts *co_opts, const char *branch, const git_signature *signature)
+int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
 {
 	int error = 0, old_fetchhead;
 	git_strarray refspecs;
diff --git a/src/reset.c b/src/reset.c
index 07fd08863..45a686fcb 100644
--- a/src/reset.c
+++ b/src/reset.c
@@ -102,7 +102,7 @@ int git_reset(
 	git_index *index = NULL;
 	git_tree *tree = NULL;
 	int error = 0;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_buf log_message_buf = GIT_BUF_INIT;
 
 	assert(repo && target);
diff --git a/src/stash.c b/src/stash.c
index 0c9101294..d20e29b80 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -468,7 +468,7 @@ static int reset_index_and_workdir(
 	bool remove_untracked,
 	bool remove_ignored)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
diff --git a/tests/checkout/binaryunicode.c b/tests/checkout/binaryunicode.c
index 14ab9fdfa..1172816c7 100644
--- a/tests/checkout/binaryunicode.c
+++ b/tests/checkout/binaryunicode.c
@@ -21,7 +21,7 @@ static void execute_test(void)
 	git_oid oid, check;
 	git_commit *commit;
 	git_tree *tree;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_git_pass(git_reference_name_to_id(&oid, g_repo, "refs/heads/branch1"));
 	cl_git_pass(git_commit_lookup(&commit, g_repo, &oid));
diff --git a/tests/checkout/conflict.c b/tests/checkout/conflict.c
index 2fea511da..2cb7c224d 100644
--- a/tests/checkout/conflict.c
+++ b/tests/checkout/conflict.c
@@ -207,7 +207,7 @@ static void ensure_workdir_link(const char *path, const char *target)
 
 void test_checkout_conflict__ignored(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy |= GIT_CHECKOUT_SKIP_UNMERGED;
 
@@ -221,7 +221,7 @@ void test_checkout_conflict__ignored(void)
 
 void test_checkout_conflict__ours(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy |= GIT_CHECKOUT_USE_OURS;
 
@@ -234,7 +234,7 @@ void test_checkout_conflict__ours(void)
 
 void test_checkout_conflict__theirs(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy |= GIT_CHECKOUT_USE_THEIRS;
 
@@ -248,7 +248,7 @@ void test_checkout_conflict__theirs(void)
 
 void test_checkout_conflict__diff3(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	create_conflicting_index();
 
@@ -259,7 +259,7 @@ void test_checkout_conflict__diff3(void)
 
 void test_checkout_conflict__automerge(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, AUTOMERGEABLE_ANCESTOR_OID, 1, "automergeable.txt" },
@@ -277,7 +277,7 @@ void test_checkout_conflict__automerge(void)
 
 void test_checkout_conflict__directory_file(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, CONFLICTING_ANCESTOR_OID, 1, "df-1" },
@@ -316,7 +316,7 @@ void test_checkout_conflict__directory_file(void)
 
 void test_checkout_conflict__directory_file_with_custom_labels(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, CONFLICTING_ANCESTOR_OID, 1, "df-1" },
@@ -357,7 +357,7 @@ void test_checkout_conflict__directory_file_with_custom_labels(void)
 
 void test_checkout_conflict__link_file(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, CONFLICTING_ANCESTOR_OID, 1, "link-1" },
@@ -393,7 +393,7 @@ void test_checkout_conflict__link_file(void)
 
 void test_checkout_conflict__links(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0120000, LINK_ANCESTOR_OID, 1, "link-1" },
@@ -418,7 +418,7 @@ void test_checkout_conflict__links(void)
 
 void test_checkout_conflict__add_add(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, CONFLICTING_OURS_OID, 2, "conflicting.txt" },
@@ -438,7 +438,7 @@ void test_checkout_conflict__add_add(void)
 
 void test_checkout_conflict__mode_change(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, CONFLICTING_ANCESTOR_OID, 1, "executable-1" },
@@ -495,7 +495,7 @@ void test_checkout_conflict__mode_change(void)
 
 void test_checkout_conflict__renames(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, "68c6c84b091926c7d90aa6a79b2bc3bb6adccd8e", 0, "0a-no-change.txt" },
@@ -680,7 +680,7 @@ void test_checkout_conflict__renames(void)
 
 void test_checkout_conflict__rename_keep_ours(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, "68c6c84b091926c7d90aa6a79b2bc3bb6adccd8e", 0, "0a-no-change.txt" },
@@ -847,7 +847,7 @@ void test_checkout_conflict__rename_keep_ours(void)
 
 void test_checkout_conflict__name_mangled_file_exists_in_workdir(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, "b42712cfe99a1a500b2a51fe984e0b8a7702ba11", 1, "test-one-side-one.txt" },
@@ -987,7 +987,7 @@ void test_checkout_conflict__name_mangled_file_exists_in_workdir(void)
 
 void test_checkout_conflict__update_only(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct checkout_index_entry checkout_index_entries[] = {
 		{ 0100644, AUTOMERGEABLE_ANCESTOR_OID, 1, "automergeable.txt" },
@@ -1032,7 +1032,7 @@ void test_checkout_conflict__update_only(void)
 
 void test_checkout_conflict__path_filters(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	char *paths[] = { "conflicting-1.txt", "conflicting-3.txt" };
 	git_strarray patharray = {0};
 
@@ -1089,7 +1089,7 @@ static void collect_progress(
 
 void test_checkout_conflict__report_progress(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_vector paths = GIT_VECTOR_INIT;
 	char *path;
 	size_t i;
diff --git a/tests/checkout/crlf.c b/tests/checkout/crlf.c
index 0d78ee039..6b2c1b122 100644
--- a/tests/checkout/crlf.c
+++ b/tests/checkout/crlf.c
@@ -18,11 +18,24 @@ void test_checkout_crlf__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
+void test_checkout_crlf__detect_crlf_autocrlf_false(void)
+{
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
+	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", false);
+
+	git_checkout_head(g_repo, &opts);
+
+	check_file_contents("./crlf/all-lf", ALL_LF_TEXT_RAW);
+	check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
+}
+
 void test_checkout_crlf__autocrlf_false_index_size_is_unfiltered_size(void)
 {
 	git_index *index;
 	const git_index_entry *entry;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_repo_set_bool(g_repo, "core.autocrlf", false);
@@ -42,7 +55,7 @@ void test_checkout_crlf__autocrlf_false_index_size_is_unfiltered_size(void)
 
 void test_checkout_crlf__detect_crlf_autocrlf_true(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_repo_set_bool(g_repo, "core.autocrlf", true);
@@ -59,7 +72,7 @@ void test_checkout_crlf__detect_crlf_autocrlf_true(void)
 
 void test_checkout_crlf__more_lf_autocrlf_true(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_repo_set_bool(g_repo, "core.autocrlf", true);
@@ -74,7 +87,7 @@ void test_checkout_crlf__more_lf_autocrlf_true(void)
 
 void test_checkout_crlf__more_crlf_autocrlf_true(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_repo_set_bool(g_repo, "core.autocrlf", true);
@@ -87,11 +100,23 @@ void test_checkout_crlf__more_crlf_autocrlf_true(void)
 		check_file_contents("./crlf/more-crlf", MORE_CRLF_TEXT_AS_CRLF);
 }
 
+void test_checkout_crlf__all_crlf_autocrlf_true(void)
+{
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
+	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
+
+	cl_repo_set_bool(g_repo, "core.autocrlf", true);
+
+	git_checkout_head(g_repo, &opts);
+
+	check_file_contents("./crlf/all-crlf", ALL_CRLF_TEXT_RAW);
+}
+
 void test_checkout_crlf__autocrlf_true_index_size_is_filtered_size(void)
 {
 	git_index *index;
 	const git_index_entry *entry;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_repo_set_bool(g_repo, "core.autocrlf", true);
@@ -117,7 +142,7 @@ void test_checkout_crlf__with_ident(void)
 {
 	git_index *index;
 	git_blob *blob;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_git_mkfile("crlf/.gitattributes",
@@ -207,7 +232,7 @@ void test_checkout_crlf__with_ident(void)
 
 void test_checkout_crlf__autocrlf_false_no_attrs(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_repo_set_bool(g_repo, "core.autocrlf", false);
@@ -220,7 +245,7 @@ void test_checkout_crlf__autocrlf_false_no_attrs(void)
 
 void test_checkout_crlf__autocrlf_true_no_attrs(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_repo_set_bool(g_repo, "core.autocrlf", true);
@@ -238,7 +263,7 @@ void test_checkout_crlf__autocrlf_true_no_attrs(void)
 
 void test_checkout_crlf__autocrlf_input_no_attrs(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_repo_set_string(g_repo, "core.autocrlf", "input");
@@ -251,7 +276,7 @@ void test_checkout_crlf__autocrlf_input_no_attrs(void)
 
 void test_checkout_crlf__autocrlf_false_text_auto_attr(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
@@ -266,7 +291,7 @@ void test_checkout_crlf__autocrlf_false_text_auto_attr(void)
 
 void test_checkout_crlf__autocrlf_true_text_auto_attr(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
@@ -286,7 +311,7 @@ void test_checkout_crlf__autocrlf_true_text_auto_attr(void)
 
 void test_checkout_crlf__autocrlf_input_text_auto_attr(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 
 	cl_git_mkfile("./crlf/.gitattributes", "* text=auto\n");
diff --git a/tests/checkout/head.c b/tests/checkout/head.c
index a7a7e9071..07cc1d209 100644
--- a/tests/checkout/head.c
+++ b/tests/checkout/head.c
@@ -25,7 +25,7 @@ void test_checkout_head__unborn_head_returns_GIT_EUNBORNBRANCH(void)
 
 void test_checkout_head__with_index_only_tree(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_index *index;
 
 	/* let's start by getting things into a known state */
diff --git a/tests/checkout/index.c b/tests/checkout/index.c
index 57ce4313b..7f641b329 100644
--- a/tests/checkout/index.c
+++ b/tests/checkout/index.c
@@ -43,7 +43,7 @@ void test_checkout_index__cannot_checkout_a_bare_repository(void)
 
 void test_checkout_index__can_create_missing_files(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_assert_equal_i(false, git_path_isfile("./testrepo/README"));
 	cl_assert_equal_i(false, git_path_isfile("./testrepo/branch_file.txt"));
@@ -60,7 +60,7 @@ void test_checkout_index__can_create_missing_files(void)
 
 void test_checkout_index__can_remove_untracked_files(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	git_futils_mkdir("./testrepo/dir/subdir/subsubdir", NULL, 0755, GIT_MKDIR_PATH);
 	cl_git_mkfile("./testrepo/dir/one", "one\n");
@@ -78,7 +78,7 @@ void test_checkout_index__can_remove_untracked_files(void)
 
 void test_checkout_index__honor_the_specified_pathspecs(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	char *entries[] = { "*.txt" };
 
 	opts.paths.strings = entries;
@@ -99,7 +99,7 @@ void test_checkout_index__honor_the_specified_pathspecs(void)
 
 void test_checkout_index__honor_the_gitattributes_directives(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	const char *attributes =
 		"branch_file.txt text eol=crlf\n"
 		"new.txt text eol=lf\n";
@@ -119,7 +119,7 @@ void test_checkout_index__honor_the_gitattributes_directives(void)
 void test_checkout_index__honor_coreautocrlf_setting_set_to_true(void)
 {
 #ifdef GIT_WIN32
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	const char *expected_readme_text = "hey there\r\n";
 
 	cl_git_pass(p_unlink("./testrepo/.gitattributes"));
@@ -135,7 +135,7 @@ void test_checkout_index__honor_coreautocrlf_setting_set_to_true(void)
 
 void test_checkout_index__honor_coresymlinks_setting_set_to_true(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_repo_set_bool(g_repo, "core.symlinks", true);
 
@@ -161,7 +161,7 @@ void test_checkout_index__honor_coresymlinks_setting_set_to_true(void)
 
 void test_checkout_index__honor_coresymlinks_setting_set_to_false(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_repo_set_bool(g_repo, "core.symlinks", false);
 
@@ -174,7 +174,7 @@ void test_checkout_index__honor_coresymlinks_setting_set_to_false(void)
 
 void test_checkout_index__donot_overwrite_modified_file_by_default(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_git_mkfile("./testrepo/new.txt", "This isn't what's stored!");
 
@@ -190,7 +190,7 @@ void test_checkout_index__donot_overwrite_modified_file_by_default(void)
 
 void test_checkout_index__can_overwrite_modified_file(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_git_mkfile("./testrepo/new.txt", "This isn't what's stored!");
 
@@ -203,7 +203,7 @@ void test_checkout_index__can_overwrite_modified_file(void)
 
 void test_checkout_index__options_disable_filters(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_git_mkfile("./testrepo/.gitattributes", "*.txt text eol=crlf\n");
 
@@ -224,7 +224,7 @@ void test_checkout_index__options_disable_filters(void)
 
 void test_checkout_index__options_dir_modes(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	struct stat st;
 	git_oid oid;
 	git_commit *commit;
@@ -258,7 +258,7 @@ void test_checkout_index__options_dir_modes(void)
 
 void test_checkout_index__options_override_file_modes(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	struct stat st;
 
 	if (!cl_is_chmod_supported())
@@ -275,7 +275,7 @@ void test_checkout_index__options_override_file_modes(void)
 
 void test_checkout_index__options_open_flags(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_git_mkfile("./testrepo/new.txt", "hi\n");
 
@@ -315,7 +315,7 @@ static int test_checkout_notify_cb(
 
 void test_checkout_index__can_notify_of_skipped_files(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	struct notify_data data;
 
 	cl_git_mkfile("./testrepo/new.txt", "This isn't what's stored!");
@@ -360,7 +360,7 @@ static int dont_notify_cb(
 
 void test_checkout_index__wont_notify_of_expected_line_ending_changes(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_git_pass(p_unlink("./testrepo/.gitattributes"));
 	cl_repo_set_bool(g_repo, "core.autocrlf", true);
@@ -385,7 +385,7 @@ static void checkout_progress_counter(
 
 void test_checkout_index__calls_progress_callback(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	int calls = 0;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
@@ -398,7 +398,7 @@ void test_checkout_index__calls_progress_callback(void)
 
 void test_checkout_index__can_overcome_name_clashes(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_index *index;
 
 	cl_git_pass(git_repository_index(&index, g_repo));
@@ -440,7 +440,7 @@ void test_checkout_index__can_overcome_name_clashes(void)
 
 void test_checkout_index__validates_struct_version(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	const git_error *err;
 
 	opts.version = 1024;
@@ -459,7 +459,7 @@ void test_checkout_index__validates_struct_version(void)
 
 void test_checkout_index__can_update_prefixed_files(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_assert_equal_i(false, git_path_isfile("./testrepo/README"));
 	cl_assert_equal_i(false, git_path_isfile("./testrepo/branch_file.txt"));
@@ -502,7 +502,7 @@ void test_checkout_index__can_checkout_a_newly_initialized_repository(void)
 
 void test_checkout_index__issue_1397(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	test_checkout_index__cleanup();
 
@@ -519,7 +519,7 @@ void test_checkout_index__issue_1397(void)
 
 void test_checkout_index__target_directory(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	checkout_counts cts;
 	memset(&cts, 0, sizeof(cts));
 
@@ -551,7 +551,7 @@ void test_checkout_index__target_directory(void)
 
 void test_checkout_index__target_directory_from_bare(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_index *index;
 	git_object *head = NULL;
 	checkout_counts cts;
@@ -600,7 +600,7 @@ void test_checkout_index__target_directory_from_bare(void)
 void test_checkout_index__can_get_repo_from_index(void)
 {
 	git_index *index;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_assert_equal_i(false, git_path_isfile("./testrepo/README"));
 	cl_assert_equal_i(false, git_path_isfile("./testrepo/branch_file.txt"));
diff --git a/tests/checkout/tree.c b/tests/checkout/tree.c
index f433b2698..b61ef2dfc 100644
--- a/tests/checkout/tree.c
+++ b/tests/checkout/tree.c
@@ -7,14 +7,14 @@
 #include "fileops.h"
 
 static git_repository *g_repo;
-static git_checkout_opts g_opts;
+static git_checkout_options g_opts;
 static git_object *g_object;
 
 void test_checkout_tree__initialize(void)
 {
 	g_repo = cl_git_sandbox_init("testrepo");
 
-	GIT_INIT_STRUCTURE(&g_opts, GIT_CHECKOUT_OPTS_VERSION);
+	GIT_INIT_STRUCTURE(&g_opts, GIT_CHECKOUT_OPTIONS_VERSION);
 	g_opts.checkout_strategy = GIT_CHECKOUT_SAFE_CREATE;
 }
 
@@ -128,7 +128,7 @@ void test_checkout_tree__doesnt_write_unrequested_files_to_worktree(void)
 	git_oid chomped_oid;
 	git_commit* p_master_commit;
 	git_commit* p_chomped_commit;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	git_oid_fromstr(&master_oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
 	git_oid_fromstr(&chomped_oid, "e90810b8df3e80c413d903f631643c716887138d");
@@ -148,7 +148,7 @@ void test_checkout_tree__doesnt_write_unrequested_files_to_worktree(void)
 
 void test_checkout_tree__can_switch_branches(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid oid;
 	git_object *obj = NULL;
 
@@ -202,7 +202,7 @@ void test_checkout_tree__can_switch_branches(void)
 
 void test_checkout_tree__can_remove_untracked(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_REMOVE_UNTRACKED;
 
@@ -216,7 +216,7 @@ void test_checkout_tree__can_remove_untracked(void)
 
 void test_checkout_tree__can_remove_ignored(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	int ignored = 0;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_REMOVE_IGNORED;
@@ -239,7 +239,7 @@ static int checkout_tree_with_blob_ignored_in_workdir(int strategy, bool isdir)
 {
 	git_oid oid;
 	git_object *obj = NULL;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	int ignored = 0, error;
 
 	assert_on_branch(g_repo, "master");
@@ -344,7 +344,7 @@ void test_checkout_tree__can_overwrite_ignored_folder_by_default(void)
 
 void test_checkout_tree__can_update_only(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid oid;
 	git_object *obj = NULL;
 
@@ -554,7 +554,7 @@ void test_checkout_tree__checking_out_a_conflicting_content_change_returns_EMERG
 
 void test_checkout_tree__donot_update_deleted_file_by_default(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid old_id, new_id;
 	git_commit *old_commit = NULL, *new_commit = NULL;
 	git_index *index = NULL;
@@ -622,7 +622,7 @@ static int checkout_cancel_cb(
 void test_checkout_tree__can_cancel_checkout_from_notify(void)
 {
 	struct checkout_cancel_at ca;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid oid;
 	git_object *obj = NULL;
 
@@ -674,7 +674,7 @@ void test_checkout_tree__can_cancel_checkout_from_notify(void)
 void test_checkout_tree__can_checkout_with_last_workdir_item_missing(void)
 {
 	git_index *index = NULL;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid tree_id, commit_id;
 	git_tree *tree = NULL;
 	git_commit *commit = NULL;
@@ -710,7 +710,7 @@ void test_checkout_tree__can_checkout_with_last_workdir_item_missing(void)
 
 void test_checkout_tree__issue_1397(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	const char *partial_oid = "8a7ef04";
 	git_object *tree = NULL;
 
@@ -733,7 +733,7 @@ void test_checkout_tree__issue_1397(void)
 
 void test_checkout_tree__can_write_to_empty_dirs(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid oid;
 	git_object *obj = NULL;
 
@@ -759,7 +759,7 @@ void test_checkout_tree__can_write_to_empty_dirs(void)
 void test_checkout_tree__fails_when_dir_in_use(void)
 {
 #ifdef GIT_WIN32
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid oid;
 	git_object *obj = NULL;
 
@@ -792,7 +792,7 @@ void test_checkout_tree__fails_when_dir_in_use(void)
 void test_checkout_tree__can_continue_when_dir_in_use(void)
 {
 #ifdef GIT_WIN32
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid oid;
 	git_object *obj = NULL;
 
@@ -825,7 +825,7 @@ void test_checkout_tree__can_continue_when_dir_in_use(void)
 
 void test_checkout_tree__target_directory_from_bare(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid oid;
 	checkout_counts cts;
 	memset(&cts, 0, sizeof(cts));
@@ -910,7 +910,7 @@ static void create_conflict(void)
 
 void test_checkout_tree__fails_when_conflicts_exist_in_index(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_oid oid;
 	git_object *obj = NULL;
 
@@ -930,7 +930,7 @@ void test_checkout_tree__filemode_preserved_in_index(void)
 {
 	git_oid executable_oid;
 	git_commit *commit;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_index *index;
 	const git_index_entry *entry;
 
diff --git a/tests/checkout/typechange.c b/tests/checkout/typechange.c
index d88864cf3..7aa14b36d 100644
--- a/tests/checkout/typechange.c
+++ b/tests/checkout/typechange.c
@@ -107,7 +107,7 @@ void test_checkout_typechange__checkout_typechanges_safe(void)
 {
 	int i;
 	git_object *obj;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	for (i = 0; g_typechange_oids[i] != NULL; ++i) {
 		cl_git_pass(git_revparse_single(&obj, g_repo, g_typechange_oids[i]));
@@ -194,7 +194,7 @@ void test_checkout_typechange__checkout_with_conflicts(void)
 {
 	int i;
 	git_object *obj;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	notify_counts cts = {0};
 
 	opts.notify_flags =
diff --git a/tests/clone/nonetwork.c b/tests/clone/nonetwork.c
index f00d28b7a..68a277448 100644
--- a/tests/clone/nonetwork.c
+++ b/tests/clone/nonetwork.c
@@ -14,7 +14,7 @@ static git_remote* g_remote;
 
 void test_clone_nonetwork__initialize(void)
 {
-	git_checkout_opts dummy_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options dummy_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_remote_callbacks dummy_callbacks = GIT_REMOTE_CALLBACKS_INIT;
 
 	g_repo = NULL;
diff --git a/tests/diff/rename.c b/tests/diff/rename.c
index ca08d15f3..4bc3eb54c 100644
--- a/tests/diff/rename.c
+++ b/tests/diff/rename.c
@@ -929,7 +929,7 @@ void test_diff_rename__rejected_match_can_match_others(void)
 	git_reference *head, *selfsimilar;
 	git_index *index;
 	git_tree *tree;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_diff *diff;
 	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
 	git_diff_find_options findopts = GIT_DIFF_FIND_OPTIONS_INIT;
@@ -1016,7 +1016,7 @@ void test_diff_rename__rejected_match_can_match_others_two(void)
 	git_reference *head, *selfsimilar;
 	git_index *index;
 	git_tree *tree;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_diff *diff;
 	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
 	git_diff_find_options findopts = GIT_DIFF_FIND_OPTIONS_INIT;
@@ -1072,7 +1072,7 @@ void test_diff_rename__rejected_match_can_match_others_three(void)
 	git_reference *head, *selfsimilar;
 	git_index *index;
 	git_tree *tree;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_diff *diff;
 	git_diff_options diffopts = GIT_DIFF_OPTIONS_INIT;
 	git_diff_find_options findopts = GIT_DIFF_FIND_OPTIONS_INIT;
diff --git a/tests/index/names.c b/tests/index/names.c
index 4723449d9..52922e9f1 100644
--- a/tests/index/names.c
+++ b/tests/index/names.c
@@ -112,7 +112,7 @@ void test_index_names__cleaned_on_checkout_tree(void)
 {
 	git_oid oid;
 	git_object *obj;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;
 
@@ -127,7 +127,7 @@ void test_index_names__cleaned_on_checkout_tree(void)
 
 void test_index_names__cleaned_on_checkout_head(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;
 
@@ -138,7 +138,7 @@ void test_index_names__cleaned_on_checkout_head(void)
 
 void test_index_names__retained_on_checkout_index(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;
 
diff --git a/tests/index/reuc.c b/tests/index/reuc.c
index bf051c827..27240a30f 100644
--- a/tests/index/reuc.c
+++ b/tests/index/reuc.c
@@ -336,7 +336,7 @@ void test_index_reuc__cleaned_on_checkout_tree(void)
 {
 	git_oid oid;
 	git_object *obj;
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;
 
@@ -351,7 +351,7 @@ void test_index_reuc__cleaned_on_checkout_tree(void)
 
 void test_index_reuc__cleaned_on_checkout_head(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;
 
@@ -362,7 +362,7 @@ void test_index_reuc__cleaned_on_checkout_head(void)
 
 void test_index_reuc__retained_on_checkout_index(void)
 {
-	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_UPDATE_ONLY;
 
diff --git a/tests/merge/merge_helpers.c b/tests/merge/merge_helpers.c
index 8d6ef2dbe..14a30b288 100644
--- a/tests/merge/merge_helpers.c
+++ b/tests/merge/merge_helpers.c
@@ -83,7 +83,7 @@ int merge_branches(git_merge_result **result, git_repository *repo, const char *
 {
 	git_reference *head_ref, *theirs_ref;
 	git_merge_head *theirs_head;
-	git_checkout_opts head_checkout_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options head_checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	head_checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
diff --git a/tests/merge/workdir/trivial.c b/tests/merge/workdir/trivial.c
index a6bbbf095..8b0d32894 100644
--- a/tests/merge/workdir/trivial.c
+++ b/tests/merge/workdir/trivial.c
@@ -31,7 +31,7 @@ void test_merge_workdir_trivial__cleanup(void)
 static int merge_trivial(const char *ours, const char *theirs)
 {
 	git_buf branch_buf = GIT_BUF_INIT;
-	git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_reference *our_ref, *their_ref;
 	git_merge_head *their_heads[1];
 	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
diff --git a/tests/online/clone.c b/tests/online/clone.c
index fa2408a75..9919e8b06 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -18,7 +18,7 @@ static git_clone_options g_options;
 
 void test_online_clone__initialize(void)
 {
-	git_checkout_opts dummy_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options dummy_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_remote_callbacks dummy_callbacks = GIT_REMOTE_CALLBACKS_INIT;
 
 	g_repo = NULL;
@@ -130,7 +130,7 @@ void test_online_clone__clone_into(void)
 	git_buf path = GIT_BUF_INIT;
 	git_remote *remote;
 	git_reference *head;
-	git_checkout_opts checkout_opts = GIT_CHECKOUT_OPTS_INIT;
+	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
 
 	bool checkout_progress_cb_was_called = false,
diff --git a/tests/structinit/structinit.c b/tests/structinit/structinit.c
index ce425be41..ec4f43999 100644
--- a/tests/structinit/structinit.c
+++ b/tests/structinit/structinit.c
@@ -47,8 +47,8 @@ void test_structinit_structinit__compare(void)
 
 	/* checkout */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
-		git_checkout_opts, GIT_CHECKOUT_OPTS_VERSION, \
-		GIT_CHECKOUT_OPTS_INIT, git_checkout_init_opts);
+		git_checkout_options, GIT_CHECKOUT_OPTIONS_VERSION, \
+		GIT_CHECKOUT_OPTIONS_INIT, git_checkout_init_opts);
 
 	/* clone */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
-- 
cgit v1.2.3


From aa17c3c63c3e31155015572cf208d89def9fce0c Mon Sep 17 00:00:00 2001
From: Ben Straub <bs@github.com>
Date: Fri, 3 Jan 2014 17:42:09 -0800
Subject: git_revert_opts -> git_revert_options

---
 include/git2/revert.h         | 18 +++++++++---------
 src/revert.c                  | 24 ++++++++++++------------
 tests/revert/workdir.c        | 12 ++++++------
 tests/structinit/structinit.c |  4 ++--
 4 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/include/git2/revert.h b/include/git2/revert.h
index fcdf2a2ca..3f48c4e4b 100644
--- a/include/git2/revert.h
+++ b/include/git2/revert.h
@@ -28,22 +28,22 @@ typedef struct {
 
 	git_merge_tree_opts merge_tree_opts;
 	git_checkout_options checkout_opts;
-} git_revert_opts;
+} git_revert_options;
 
-#define GIT_REVERT_OPTS_VERSION 1
-#define GIT_REVERT_OPTS_INIT {GIT_REVERT_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
+#define GIT_REVERT_OPTIONS_VERSION 1
+#define GIT_REVERT_OPTIONS_INIT {GIT_REVERT_OPTIONS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
 
 /**
- * Initializes a `git_revert_opts` with default values. Equivalent to
- * creating an instance with GIT_REVERT_OPTS_INIT.
+ * Initializes a `git_revert_options` with default values. Equivalent to
+ * creating an instance with GIT_REVERT_OPTIONS_INIT.
  *
- * @param opts the `git_revert_opts` instance to initialize.
+ * @param opts the `git_revert_options` instance to initialize.
  * @param version the version of the struct; you should pass
- *        `GIT_REVERT_OPTS_VERSION` here.
+ *        `GIT_REVERT_OPTIONS_VERSION` here.
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_revert_init_opts(
-	git_revert_opts* opts,
+	git_revert_options* opts,
 	int version);
 
 /**
@@ -80,7 +80,7 @@ int git_revert_commit(
 GIT_EXTERN(int) git_revert(
 	git_repository *repo,
 	git_commit *commit,
-	const git_revert_opts *given_opts);
+	const git_revert_options *given_opts);
 
 /** @} */
 GIT_END_DECL
diff --git a/src/revert.c b/src/revert.c
index a397a8eeb..8e84463db 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -67,8 +67,8 @@ cleanup:
 
 static int revert_normalize_opts(
 	git_repository *repo,
-	git_revert_opts *opts,
-	const git_revert_opts *given,
+	git_revert_options *opts,
+	const git_revert_options *given,
 	const char *their_label)
 {
 	int error = 0;
@@ -78,10 +78,10 @@ static int revert_normalize_opts(
 	GIT_UNUSED(repo);
 
 	if (given != NULL)
-		memcpy(opts, given, sizeof(git_revert_opts));
+		memcpy(opts, given, sizeof(git_revert_options));
 	else {
-		git_revert_opts default_opts = GIT_REVERT_OPTS_INIT;
-		memcpy(opts, &default_opts, sizeof(git_revert_opts));
+		git_revert_options default_opts = GIT_REVERT_OPTIONS_INIT;
+		memcpy(opts, &default_opts, sizeof(git_revert_options));
 	}
 
 	if (!opts->checkout_opts.checkout_strategy)
@@ -166,9 +166,9 @@ done:
 int git_revert(
 	git_repository *repo,
 	git_commit *commit,
-	const git_revert_opts *given_opts)
+	const git_revert_options *given_opts)
 {
-	git_revert_opts opts;
+	git_revert_options opts;
 	git_reference *our_ref = NULL;
 	git_commit *our_commit = NULL;
 	char commit_oidstr[GIT_OID_HEXSZ + 1];
@@ -179,7 +179,7 @@ int git_revert(
 
 	assert(repo && commit);
 
-	GITERR_CHECK_VERSION(given_opts, GIT_REVERT_OPTS_VERSION, "git_revert_opts");
+	GITERR_CHECK_VERSION(given_opts, GIT_REVERT_OPTIONS_VERSION, "git_revert_options");
 
 	if ((error = git_repository__ensure_not_bare(repo, "revert")) < 0)
 		return error;
@@ -219,13 +219,13 @@ done:
 	return error;
 }
 
-int git_revert_init_opts(git_revert_opts* opts, int version)
+int git_revert_init_opts(git_revert_options* opts, int version)
 {
-	if (version != GIT_REVERT_OPTS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_revert_opts", version);
+	if (version != GIT_REVERT_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_revert_options", version);
 		return -1;
 	} else {
-		git_revert_opts o = GIT_REVERT_OPTS_INIT;
+		git_revert_options o = GIT_REVERT_OPTIONS_INIT;
 		memcpy(opts, &o, sizeof(o));
 		return 0;
 	}
diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
index 47abeb8f0..afbdffefa 100644
--- a/tests/revert/workdir.c
+++ b/tests/revert/workdir.c
@@ -347,7 +347,7 @@ void test_revert_workdir__conflict_use_ours(void)
 {
 	git_commit *head, *commit;
 	git_oid head_oid, revert_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+	git_revert_options opts = GIT_REVERT_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "caf99de3a49827117bb66721010eac461b06a80c", 0, "file1.txt" },
@@ -387,7 +387,7 @@ void test_revert_workdir__rename_1_of_2(void)
 {
 	git_commit *head, *commit;
 	git_oid head_oid, revert_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+	git_revert_options opts = GIT_REVERT_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "747726e021bc5f44b86de60e3032fd6f9f1b8383", 0, "file1.txt" },
@@ -421,7 +421,7 @@ void test_revert_workdir__rename(void)
 {
 	git_commit *head, *commit;
 	git_oid head_oid, revert_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+	git_revert_options opts = GIT_REVERT_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "55acf326a69f0aab7a974ec53ffa55a50bcac14e", 1, "file4.txt" },
@@ -480,7 +480,7 @@ void test_revert_workdir__nonmerge_fails_mainline_specified(void)
 {
 	git_reference *head;
 	git_commit *commit;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+	git_revert_options opts = GIT_REVERT_OPTIONS_INIT;
 
 	cl_git_pass(git_repository_head(&head, repo));
 	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
@@ -518,7 +518,7 @@ void test_revert_workdir__merge_first_parent(void)
 {
 	git_commit *head;
 	git_oid head_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+	git_revert_options opts = GIT_REVERT_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "296a6d3be1dff05c5d1f631d2459389fa7b619eb", 0, "file-mainline.txt" },
@@ -543,7 +543,7 @@ void test_revert_workdir__merge_second_parent(void)
 {
 	git_commit *head;
 	git_oid head_oid;
-	git_revert_opts opts = GIT_REVERT_OPTS_INIT;
+	git_revert_options opts = GIT_REVERT_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "33c6fd981c49a2abf2971482089350bfc5cda8ea", 0, "file-branch.txt" },
diff --git a/tests/structinit/structinit.c b/tests/structinit/structinit.c
index ec4f43999..1df970d49 100644
--- a/tests/structinit/structinit.c
+++ b/tests/structinit/structinit.c
@@ -92,8 +92,8 @@ void test_structinit_structinit__compare(void)
 
 	/* revert */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
-		git_revert_opts, GIT_REVERT_OPTS_VERSION, \
-		GIT_REVERT_OPTS_INIT, git_revert_init_opts);
+		git_revert_options, GIT_REVERT_OPTIONS_VERSION, \
+		GIT_REVERT_OPTIONS_INIT, git_revert_init_opts);
 
 	/* status */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
-- 
cgit v1.2.3


From 806571f3523d64be51e541705da580f28ea8f9a9 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 7 Mar 2014 00:28:18 -0800
Subject: Update clar to a0b00f0

---
 tests/clar.c | 23 +++++++++++++++++++++++
 tests/clar.h |  3 +++
 2 files changed, 26 insertions(+)

diff --git a/tests/clar.c b/tests/clar.c
index 6c7399a54..90aeb571d 100644
--- a/tests/clar.c
+++ b/tests/clar.c
@@ -65,7 +65,12 @@
 #	ifndef PRIxZ
 #		define PRIxZ "Ix"
 #	endif
+
+#	ifdef _MSC_VER
+	typedef struct stat STAT_T;
+#	else
 	typedef struct _stat STAT_T;
+#	endif
 #else
 #	include <sys/wait.h> /* waitpid(2) */
 #	include <unistd.h>
@@ -468,6 +473,24 @@ void clar__assert_equal(
 			}
 		}
 	}
+	else if(!strcmp("%.*s", fmt)) {
+		const char *s1 = va_arg(args, const char *);
+		const char *s2 = va_arg(args, const char *);
+		size_t len = va_arg(args, size_t);
+		is_equal = (!s1 || !s2) ? (s1 == s2) : !strncmp(s1, s2, len);
+
+		if (!is_equal) {
+			if (s1 && s2) {
+				size_t pos;
+				for (pos = 0; s1[pos] == s2[pos] && pos < len; ++pos)
+					/* find differing byte offset */;
+				p_snprintf(buf, sizeof(buf), "'%.*s' != '%.*s' (at byte %d)",
+					len, s1, len, s2, pos);
+			} else {
+				p_snprintf(buf, sizeof(buf), "'%.*s' != '%.*s'", len, s1, len, s2);
+			}
+		}
+	}
 	else if (!strcmp("%"PRIuZ, fmt) || !strcmp("%"PRIxZ, fmt)) {
 		size_t sz1 = va_arg(args, size_t), sz2 = va_arg(args, size_t);
 		is_equal = (sz1 == sz2);
diff --git a/tests/clar.h b/tests/clar.h
index e1f244eba..7f77f7502 100644
--- a/tests/clar.h
+++ b/tests/clar.h
@@ -60,6 +60,9 @@ void cl_fixture_cleanup(const char *fixture_name);
 #define cl_assert_equal_s(s1,s2) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%s", (s1), (s2))
 #define cl_assert_equal_s_(s1,s2,note) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%s", (s1), (s2))
 
+#define cl_assert_equal_strn(s1,s2,len) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%.*s", (s1), (s2), (size_t)(len))
+#define cl_assert_equal_strn_(s1,s2,len,note) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%.*s", (s1), (s2), (size_t)(len))
+
 #define cl_assert_equal_i(i1,i2) clar__assert_equal(__FILE__,__LINE__,#i1 " != " #i2, 1, "%d", (int)(i1), (int)(i2))
 #define cl_assert_equal_i_(i1,i2,note) clar__assert_equal(__FILE__,__LINE__,#i1 " != " #i2 " (" #note ")", 1, "%d", (i1), (i2))
 #define cl_assert_equal_i_fmt(i1,i2,fmt) clar__assert_equal(__FILE__,__LINE__,#i1 " != " #i2, 1, (fmt), (int)(i1), (int)(i2))
-- 
cgit v1.2.3


From 00258cc0b6d54f8c5802b41089d9c6b74ba2f919 Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Thu, 6 Mar 2014 22:10:17 +0100
Subject: git_oid_fromstrn: Simplify the implementation and fix memory access
 issues

---
 src/oid.c | 24 +++++++++---------------
 1 file changed, 9 insertions(+), 15 deletions(-)

diff --git a/src/oid.c b/src/oid.c
index f74c43fe2..b640cadd1 100644
--- a/src/oid.c
+++ b/src/oid.c
@@ -24,30 +24,24 @@ int git_oid_fromstrn(git_oid *out, const char *str, size_t length)
 	size_t p;
 	int v;
 
-	if (length > GIT_OID_HEXSZ)
-		return oid_error_invalid("too long");
+	assert(out && str);
 
-	for (p = 0; p < length - 1; p += 2) {
-		v = (git__fromhex(str[p + 0]) << 4)
-				| git__fromhex(str[p + 1]);
+	if (!length)
+		return oid_error_invalid("too short");
 
-		if (v < 0)
-			return oid_error_invalid("contains invalid characters");
+	if (length > GIT_OID_HEXSZ)
+		return oid_error_invalid("too long");
 
-		out->id[p / 2] = (unsigned char)v;
-	}
+	memset(out->id, 0, GIT_OID_RAWSZ);
 
-	if (length % 2) {
-		v = (git__fromhex(str[p + 0]) << 4);
+	for (p = 0; p < length; p++) {
+		v = git__fromhex(str[p]);
 		if (v < 0)
 			return oid_error_invalid("contains invalid characters");
 
-		out->id[p / 2] = (unsigned char)v;
-		p += 2;
+		out->id[p / 2] |= (unsigned char)(v << (p % 2 ? 0 : 4));
 	}
 
-	memset(out->id + p / 2, 0, (GIT_OID_HEXSZ - p) / 2);
-
 	return 0;
 }
 
-- 
cgit v1.2.3


From 79aa03020d1a2020b4189ad272ee603af34f0921 Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Thu, 6 Mar 2014 22:23:57 +0100
Subject: blame: Fix compare function's data types

Previously the hunk_byfinalline_search_cmp function was called with different
data types (size_t and uint32_t) for the key argument but expected only the
former resulting in an invalid memory access when passed the latter on a 64 bit
machine.

The following patch makes sure that the function is called and works with the
same type (size_t).
---
 src/blame.c | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/blame.c b/src/blame.c
index 01f88b729..e45c0ee1c 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -20,12 +20,15 @@
 
 static int hunk_byfinalline_search_cmp(const void *key, const void *entry)
 {
-	uint16_t lineno = (uint16_t)*(size_t*)key;
 	git_blame_hunk *hunk = (git_blame_hunk*)entry;
 
-	if (lineno < hunk->final_start_line_number)
+	size_t lineno = *(size_t*)key;
+	size_t lines_in_hunk = (size_t)hunk->lines_in_hunk;
+	size_t final_start_line_number = (size_t)hunk->final_start_line_number;
+
+	if (lineno < final_start_line_number)
 		return -1;
-	if (lineno >= hunk->final_start_line_number + hunk->lines_in_hunk)
+	if (lineno >= final_start_line_number + lines_in_hunk)
 		return 1;
 	return 0;
 }
@@ -95,7 +98,7 @@ static void shift_hunks_by(git_vector *v, size_t start_line, int shift_by)
 {
 	size_t i;
 
-	if (!git_vector_bsearch2( &i, v, hunk_byfinalline_search_cmp, &start_line)) {
+	if (!git_vector_bsearch2(&i, v, hunk_byfinalline_search_cmp, &start_line)) {
 		for (; i < v->length; i++) {
 			git_blame_hunk *hunk = (git_blame_hunk*)v->contents[i];
 			hunk->final_start_line_number += shift_by;
@@ -161,10 +164,10 @@ const git_blame_hunk *git_blame_get_hunk_byindex(git_blame *blame, uint32_t inde
 
 const git_blame_hunk *git_blame_get_hunk_byline(git_blame *blame, uint32_t lineno)
 {
-	size_t i;
+	size_t i, new_lineno = (size_t)lineno;
 	assert(blame);
 
-	if (!git_vector_bsearch2( &i, &blame->hunks, hunk_byfinalline_search_cmp, &lineno)) {
+	if (!git_vector_bsearch2(&i, &blame->hunks, hunk_byfinalline_search_cmp, &new_lineno)) {
 		return git_blame_get_hunk_byindex(blame, (uint32_t)i);
 	}
 
-- 
cgit v1.2.3


From 5187b609ba203b5a62e3e54c1a323cc0647deff9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 7 Mar 2014 14:58:43 +0100
Subject: local transport: catch double-opens

Combinations of connect + fetch can call local_open multiple
times. Detect this and skip the initialization stage.
---
 src/transports/local.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/transports/local.c b/src/transports/local.c
index 26ada48e6..f8d511ed6 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -194,6 +194,9 @@ static int local_connect(
 	GIT_UNUSED(cred_acquire_cb);
 	GIT_UNUSED(cred_acquire_payload);
 
+	if (t->connected)
+		return 0;
+
 	t->url = git__strdup(url);
 	GITERR_CHECK_ALLOC(t->url);
 	t->direction = direction;
-- 
cgit v1.2.3


From 7c1ee212b7fa1568a12a0a656b02cae01cb1cb6c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 7 Mar 2014 15:17:08 +0100
Subject: commit: simplify and correct refcounting in nth_gen_ancestor

We can make use of git_object_dup to use refcounting instead of pointer
comparison to make sure we don't free the caller's object.

This also lets us simplify the case for '~0' which is now just an
assignment instead of looking up the object we have at hand.
---
 src/commit.c | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/commit.c b/src/commit.c
index 2f5a5b51e..255debe82 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -455,19 +455,18 @@ int git_commit_nth_gen_ancestor(
 
 	assert(ancestor && commit);
 
-	current = (git_commit *)commit;
+	if (git_object_dup((git_object **) &current, (git_object *) commit) < 0)
+		return -1;
 
-	if (n == 0)
-		return git_commit_lookup(
-			ancestor,
-			commit->object.repo,
-			git_object_id((const git_object *)commit));
+	if (n == 0) {
+		*ancestor = current;
+		return 0;
+	}
 
 	while (n--) {
-		error = git_commit_parent(&parent, (git_commit *)current, 0);
+		error = git_commit_parent(&parent, current, 0);
 
-		if (current != commit)
-			git_commit_free(current);
+		git_commit_free(current);
 
 		if (error < 0)
 			return error;
-- 
cgit v1.2.3


From a07b169834a11f60a2baa98f9735c2dfe7e4a1ee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 7 Mar 2014 15:40:53 +0100
Subject: branch: fix leak when checking against HEAD

We look up a reference in order to figure out if it's the current
branch, which we need to free once we're done with the check.

As a bonus, only perform the check when we're passed the force flag, as
it's a useless check otherwise.
---
 src/branch.c | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/branch.c b/src/branch.c
index 1ebaf8e24..7c888729d 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -66,16 +66,22 @@ int git_branch_create(
 
 	assert(branch_name && commit && ref_out);
 	assert(git_object_owner((const git_object *)commit) == repository);
-	if (git_branch_lookup(&branch, repository, branch_name, GIT_BRANCH_LOCAL) == 0) {
-		if ((is_head = git_branch_is_head(branch)) < 0) {
-			error = is_head;
+
+	if (force && git_branch_lookup(&branch, repository, branch_name, GIT_BRANCH_LOCAL) == 0) {
+		error = git_branch_is_head(branch);
+		git_reference_free(branch);
+		branch = NULL;
+
+		if (error < 0)
 			goto cleanup;
-		}
+
+		is_head = error;
 	}
 
 	if (is_head && force) {
 		giterr_set(GITERR_REFERENCE, "Cannot force update branch '%s' as it is "
-			"the current HEAD of the repository.", git_reference_name(branch));
+			"the current HEAD of the repository.", branch_name);
+		error = -1;
 		goto cleanup;
 	}
 	
-- 
cgit v1.2.3


From ae32c54e5806cf8517beeb057cf640ed346508eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 5 Mar 2014 20:28:49 +0100
Subject: Plug a few leaks in the tests

---
 src/refdb_fs.c                | 5 ++++-
 src/reset.c                   | 1 +
 tests/clone/empty.c           | 2 ++
 tests/odb/backend/nobackend.c | 5 +++++
 tests/reset/hard.c            | 4 ++++
 tests/reset/mixed.c           | 6 ++++++
 6 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 3219b0519..8a26bec0b 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1343,7 +1343,10 @@ static int refdb_reflog_fs__ensure_log(git_refdb_backend *_backend, const char *
 	if ((error = retrieve_reflog_path(&path, repo, name)) < 0)
 		return error;
 
-	return create_new_reflog_file(git_buf_cstr(&path));
+	error = create_new_reflog_file(git_buf_cstr(&path));
+	git_buf_free(&path);
+
+	return error;
 }
 
 static int has_reflog(git_repository *repo, const char *name)
diff --git a/src/reset.c b/src/reset.c
index 07fd08863..2a78d312c 100644
--- a/src/reset.c
+++ b/src/reset.c
@@ -167,6 +167,7 @@ cleanup:
 	git_object_free(commit);
 	git_index_free(index);
 	git_tree_free(tree);
+	git_buf_free(&log_message_buf);
 
 	return error;
 }
diff --git a/tests/clone/empty.c b/tests/clone/empty.c
index 78aef7dae..8f6071096 100644
--- a/tests/clone/empty.c
+++ b/tests/clone/empty.c
@@ -53,11 +53,13 @@ void test_clone_empty__can_clone_an_empty_local_repo_barely(void)
 	cl_git_pass(git_branch_upstream_name(&buf, g_repo_cloned, local_name));
 
 	cl_assert_equal_s(expected_tracked_branch_name, buf.ptr);
+	git_buf_free(&buf);
 
 	/* ...and the name of the remote... */
 	cl_git_pass(git_branch_remote_name(&buf, g_repo_cloned, expected_tracked_branch_name));
 
 	cl_assert_equal_s(expected_remote_name, buf.ptr);
+	git_buf_free(&buf);
 
 	/* ...even when the remote HEAD is unborn as well */
 	cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&ref, g_repo_cloned,
diff --git a/tests/odb/backend/nobackend.c b/tests/odb/backend/nobackend.c
index 7ed5acced..783641e8f 100644
--- a/tests/odb/backend/nobackend.c
+++ b/tests/odb/backend/nobackend.c
@@ -18,6 +18,11 @@ void test_odb_backend_nobackend__initialize(void)
 	git_repository_set_config(_repo, config);
 	git_repository_set_odb(_repo, odb);
 	git_repository_set_refdb(_repo, refdb);
+
+	/* The set increases the refcount and we don't want them anymore */
+	git_config_free(config);
+	git_odb_free(odb);
+	git_refdb_free(refdb);
 }
 
 void test_odb_backend_nobackend__cleanup(void)
diff --git a/tests/reset/hard.c b/tests/reset/hard.c
index d4c7db45f..36120ee63 100644
--- a/tests/reset/hard.c
+++ b/tests/reset/hard.c
@@ -212,12 +212,16 @@ void test_reset_hard__reflog_is_correct(void)
 	reflog_check(repo, "HEAD", 3, "emeric.fermas@gmail.com", exp_msg);
 	reflog_check(repo, "refs/heads/master", 3, "emeric.fermas@gmail.com", exp_msg);
 
+	git_object_free(target);
+
 	/* Moved branch, expect default message */
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
 	reflog_check(repo, "HEAD", 3, "emeric.fermas@gmail.com", exp_msg);
 	reflog_check(repo, "refs/heads/master", 4, NULL, "reset: moving");
 
+	git_object_free(target);
+
 	/* Moved branch, expect custom message */
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, "message1"));
diff --git a/tests/reset/mixed.c b/tests/reset/mixed.c
index 25272a75c..5d8ff63b4 100644
--- a/tests/reset/mixed.c
+++ b/tests/reset/mixed.c
@@ -61,12 +61,18 @@ void test_reset_mixed__reflog_is_correct(void)
 	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
 	reflog_check(repo, "refs/heads/master", 9, "yoram.harmelin@gmail.com", exp_msg);
 
+	git_object_free(target);
+	target = NULL;
+
 	/* Moved branch, expect default message */
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
 	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
 	reflog_check(repo, "refs/heads/master", 10, NULL, "reset: moving");
 
+	git_object_free(target);
+	target = NULL;
+
 	/* Moved branch, expect custom message */
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, "message1"));
-- 
cgit v1.2.3


From dd954a3735b429c976459dbb3d26405c41de2352 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 7 Mar 2014 10:53:00 -0800
Subject: Update clar to e1990d6

---
 tests/clar.c | 4 ++--
 tests/clar.h | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/clar.c b/tests/clar.c
index 90aeb571d..535424130 100644
--- a/tests/clar.c
+++ b/tests/clar.c
@@ -476,12 +476,12 @@ void clar__assert_equal(
 	else if(!strcmp("%.*s", fmt)) {
 		const char *s1 = va_arg(args, const char *);
 		const char *s2 = va_arg(args, const char *);
-		size_t len = va_arg(args, size_t);
+		int len = va_arg(args, int);
 		is_equal = (!s1 || !s2) ? (s1 == s2) : !strncmp(s1, s2, len);
 
 		if (!is_equal) {
 			if (s1 && s2) {
-				size_t pos;
+				int pos;
 				for (pos = 0; s1[pos] == s2[pos] && pos < len; ++pos)
 					/* find differing byte offset */;
 				p_snprintf(buf, sizeof(buf), "'%.*s' != '%.*s' (at byte %d)",
diff --git a/tests/clar.h b/tests/clar.h
index 7f77f7502..87ff6d967 100644
--- a/tests/clar.h
+++ b/tests/clar.h
@@ -60,8 +60,8 @@ void cl_fixture_cleanup(const char *fixture_name);
 #define cl_assert_equal_s(s1,s2) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%s", (s1), (s2))
 #define cl_assert_equal_s_(s1,s2,note) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%s", (s1), (s2))
 
-#define cl_assert_equal_strn(s1,s2,len) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%.*s", (s1), (s2), (size_t)(len))
-#define cl_assert_equal_strn_(s1,s2,len,note) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%.*s", (s1), (s2), (size_t)(len))
+#define cl_assert_equal_strn(s1,s2,len) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2, 1, "%.*s", (s1), (s2), (int)(len))
+#define cl_assert_equal_strn_(s1,s2,len,note) clar__assert_equal(__FILE__,__LINE__,"String mismatch: " #s1 " != " #s2 " (" #note ")", 1, "%.*s", (s1), (s2), (int)(len))
 
 #define cl_assert_equal_i(i1,i2) clar__assert_equal(__FILE__,__LINE__,#i1 " != " #i2, 1, "%d", (int)(i1), (int)(i2))
 #define cl_assert_equal_i_(i1,i2,note) clar__assert_equal(__FILE__,__LINE__,#i1 " != " #i2 " (" #note ")", 1, "%d", (i1), (i2))
-- 
cgit v1.2.3


From 0782c89ed5043d4707436605afd32bb1d53d0240 Mon Sep 17 00:00:00 2001
From: Brendan Forster <brendan@github.com>
Date: Mon, 10 Mar 2014 14:40:07 +1100
Subject: corrected typo in error message

---
 src/index.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/index.c b/src/index.c
index 2de3dfebb..0d7d50668 100644
--- a/src/index.c
+++ b/src/index.c
@@ -532,7 +532,7 @@ int git_index_write(git_index *index)
 	if ((error = git_filebuf_open(
 		&file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS, GIT_INDEX_FILE_MODE)) < 0) {
 		if (error == GIT_ELOCKED)
-			giterr_set(GITERR_INDEX, "The index is locked. This might be due to a concurrrent or crashed process");
+			giterr_set(GITERR_INDEX, "The index is locked. This might be due to a concurrent or crashed process");
 
 		return error;
 	}
-- 
cgit v1.2.3


From 52fba18f4e73a0342b28428cc7d783423b6d19c0 Mon Sep 17 00:00:00 2001
From: Jan Melcher <info@yogularm.de>
Date: Mon, 10 Mar 2014 18:16:10 +0100
Subject: Add git_submodule_resolve_url()

---
 include/git2/submodule.h | 10 ++++++++++
 src/submodule.c          | 30 ++++++++++++++++++++----------
 2 files changed, 30 insertions(+), 10 deletions(-)

diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index d72432610..ac0abc0a4 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -271,6 +271,16 @@ GIT_EXTERN(const char *) git_submodule_path(git_submodule *submodule);
  */
 GIT_EXTERN(const char *) git_submodule_url(git_submodule *submodule);
 
+/**
+ * Resolve a submodule url relative to the given repository.
+ *
+ * @param out buffer to store the absolute submodule url in
+ * @param repository Pointer to repository object
+ * @param url Relative url
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *url);
+
 /**
 * Get the branch for the submodule.
 *
diff --git a/src/submodule.c b/src/submodule.c
index 2388bd144..2fe7f1dcb 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -229,16 +229,7 @@ int git_submodule_add_setup(
 	}
 
 	/* resolve parameters */
-
-	if (url[0] == '.' && (url[1] == '/' || (url[1] == '.' && url[2] == '/'))) {
-		if (!(error = lookup_head_remote(&real_url, repo)))
-			error = git_path_apply_relative(&real_url, url);
-	} else if (strchr(url, ':') != NULL || url[0] == '/') {
-		error = git_buf_sets(&real_url, url);
-	} else {
-		giterr_set(GITERR_SUBMODULE, "Invalid format for submodule URL");
-		error = -1;
-	}
+	error = git_submodule_resolve_url(&real_url, repo, url);
 	if (error)
 		goto cleanup;
 
@@ -533,6 +524,25 @@ const char *git_submodule_url(git_submodule *submodule)
 	return submodule->url;
 }
 
+int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *url)
+{
+	assert(url);
+
+	int error = 0;
+
+	if (url[0] == '.' && (url[1] == '/' || (url[1] == '.' && url[2] == '/'))) {
+		if (!(error = lookup_head_remote(out, repo)))
+			error = git_path_apply_relative(out, url);
+	} else if (strchr(url, ':') != NULL || url[0] == '/') {
+		error = git_buf_sets(out, url);
+	} else {
+		giterr_set(GITERR_SUBMODULE, "Invalid format for submodule URL");
+		error = -1;
+	}
+
+	return error;
+}
+
 const char *git_submodule_branch(git_submodule *submodule)
 {
 	assert(submodule);
-- 
cgit v1.2.3


From 9af14886a94ca4d08c7af1ba84b21cba40fce34c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 10 Mar 2014 18:20:47 +0100
Subject: MSVC is silly

---
 src/submodule.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index 2fe7f1dcb..9eaf77dae 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -526,10 +526,10 @@ const char *git_submodule_url(git_submodule *submodule)
 
 int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *url)
 {
-	assert(url);
-
 	int error = 0;
 
+	assert(url);
+
 	if (url[0] == '.' && (url[1] == '/' || (url[1] == '.' && url[2] == '/'))) {
 		if (!(error = lookup_head_remote(out, repo)))
 			error = git_path_apply_relative(out, url);
-- 
cgit v1.2.3


From 894990788771bef6ca20398e46b217817b8e0db8 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 10 Mar 2014 10:53:39 -0700
Subject: Fix a number of git_odb_exists_prefix bugs

The git_odb_exists_prefix API was not dealing correctly when a
later backend returned GIT_ENOTFOUND even if an earlier backend
had found the object.

Additionally, the unit tests were not properly exercising the API
and had a couple mistakes in checking the results.

Lastly, since the backends are not expected to behavior correctly
unless all bytes of the short id are zero except for the prefix,
this makes the ODB prefix APIs explicitly clear out the extra
bytes so the user doesn't have to be as careful.
---
 src/odb.c         | 24 +++++++++++++++++-------
 tests/odb/loose.c | 22 ++++++++++++----------
 2 files changed, 29 insertions(+), 17 deletions(-)

diff --git a/src/odb.c b/src/odb.c
index 085eda594..550951fd3 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -640,7 +640,7 @@ int git_odb_exists_prefix(
 {
 	int error = GIT_ENOTFOUND, num_found = 0;
 	size_t i;
-	git_oid last_found = {{0}}, found;
+	git_oid key = {{0}}, last_found = {{0}}, found;
 
 	assert(db && short_id);
 
@@ -659,6 +659,11 @@ int git_odb_exists_prefix(
 		}
 	}
 
+	/* just copy valid part of short_id */
+	memcpy(&key.id, short_id->id, (len + 1) / 2);
+	if (len & 1)
+		key.id[len / 2] &= 0xF0;
+
 	for (i = 0; i < db->backends.length; ++i) {
 		backend_internal *internal = git_vector_get(&db->backends, i);
 		git_odb_backend *b = internal->backend;
@@ -666,7 +671,7 @@ int git_odb_exists_prefix(
 		if (!b->exists_prefix)
 			continue;
 
-		error = b->exists_prefix(&found, b, short_id, len);
+		error = b->exists_prefix(&found, b, &key, len);
 		if (error == GIT_ENOTFOUND || error == GIT_PASSTHROUGH)
 			continue;
 		if (error)
@@ -683,11 +688,11 @@ int git_odb_exists_prefix(
 	}
 
 	if (!num_found)
-		return git_odb__error_notfound("no match for id prefix", short_id);
+		return git_odb__error_notfound("no match for id prefix", &key);
 	if (out)
 		git_oid_cpy(out, &last_found);
 
-	return error;
+	return 0;
 }
 
 int git_odb_read_header(size_t *len_p, git_otype *type_p, git_odb *db, const git_oid *id)
@@ -790,7 +795,7 @@ int git_odb_read_prefix(
 {
 	size_t i;
 	int error = GIT_ENOTFOUND;
-	git_oid found_full_oid = {{0}};
+	git_oid key = {{0}}, found_full_oid = {{0}};
 	git_rawobj raw;
 	void *data = NULL;
 	bool found = false;
@@ -809,13 +814,18 @@ int git_odb_read_prefix(
 			return 0;
 	}
 
+	/* just copy valid part of short_id */
+	memcpy(&key.id, short_id->id, (len + 1) / 2);
+	if (len & 1)
+		key.id[len / 2] &= 0xF0;
+
 	for (i = 0; i < db->backends.length; ++i) {
 		backend_internal *internal = git_vector_get(&db->backends, i);
 		git_odb_backend *b = internal->backend;
 
 		if (b->read_prefix != NULL) {
 			git_oid full_oid;
-			error = b->read_prefix(&full_oid, &raw.data, &raw.len, &raw.type, b, short_id, len);
+			error = b->read_prefix(&full_oid, &raw.data, &raw.len, &raw.type, b, &key, len);
 			if (error == GIT_ENOTFOUND || error == GIT_PASSTHROUGH)
 				continue;
 
@@ -836,7 +846,7 @@ int git_odb_read_prefix(
 	}
 
 	if (!found)
-		return git_odb__error_notfound("no match for prefix", short_id);
+		return git_odb__error_notfound("no match for prefix", &key);
 
 	if ((object = odb_object__alloc(&found_full_oid, &raw)) == NULL)
 		return -1;
diff --git a/tests/odb/loose.c b/tests/odb/loose.c
index ef7136e36..c91927c4a 100644
--- a/tests/odb/loose.c
+++ b/tests/odb/loose.c
@@ -66,23 +66,25 @@ void test_odb_loose__cleanup(void)
 
 void test_odb_loose__exists(void)
 {
-    git_oid id, id2;
+	git_oid id, id2;
 	git_odb *odb;
 
-    write_object_files(&one);
+	write_object_files(&one);
 	cl_git_pass(git_odb_open(&odb, "test-objects"));
 
-    cl_git_pass(git_oid_fromstr(&id, one.id));
+	cl_git_pass(git_oid_fromstr(&id, one.id));
+	cl_assert(git_odb_exists(odb, &id));
 
-    cl_assert(git_odb_exists(odb, &id));
+	cl_git_pass(git_oid_fromstrp(&id, "8b137891"));
+	cl_git_pass(git_odb_exists_prefix(&id2, odb, &id, 8));
+	cl_assert_equal_i(0, git_oid_streq(&id2, one.id));
 
-	cl_assert(git_odb_exists_prefix(&id2, odb, &id, 8));
-	cl_assert(git_oid_equal(&id, &id2));
+	/* Test for a missing object */
+	cl_git_pass(git_oid_fromstr(&id, "8b137891791fe96927ad78e64b0aad7bded08baa"));
+	cl_assert(!git_odb_exists(odb, &id));
 
-	/* Test for a non-existant object */
-    cl_git_pass(git_oid_fromstr(&id2, "8b137891791fe96927ad78e64b0aad7bded08baa"));
-    cl_assert(!git_odb_exists(odb, &id2));
-	cl_assert_equal_i(GIT_ENOTFOUND, git_odb_exists_prefix(NULL, odb, &id2, 8));
+	cl_git_pass(git_oid_fromstrp(&id, "8b13789a"));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_odb_exists_prefix(&id2, odb, &id, 8));
 
 	git_odb_free(odb);
 }
-- 
cgit v1.2.3


From eb46fb2ba965f4e25946090dd172fcc3b20d93ee Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Sat, 8 Mar 2014 00:49:18 +0100
Subject: Add failing test for git_object_short_id

---
 tests/object/shortid.c                                     |   7 +++++++
 .../objects/03/8d718da6a1ebbc6a7780a96ed75a70cc2ad6e2      | Bin 0 -> 23 bytes
 2 files changed, 7 insertions(+)
 create mode 100644 tests/resources/duplicate.git/objects/03/8d718da6a1ebbc6a7780a96ed75a70cc2ad6e2

diff --git a/tests/object/shortid.c b/tests/object/shortid.c
index fa1dac09a..d854cb78e 100644
--- a/tests/object/shortid.c
+++ b/tests/object/shortid.c
@@ -26,6 +26,13 @@ void test_object_shortid__select(void)
 	cl_assert_equal_s("ce01362", shorty.ptr);
 	git_object_free(obj);
 
+	git_oid_fromstr(&full, "038d718da6a1ebbc6a7780a96ed75a70cc2ad6e2");
+	cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJ_ANY));
+	cl_git_pass(git_object_short_id(&shorty, obj));
+	cl_assert_equal_i(7, shorty.size);
+	cl_assert_equal_s("038d718", shorty.ptr);
+	git_object_free(obj);
+
 	git_oid_fromstr(&full, "dea509d097ce692e167dfc6a48a7a280cc5e877e");
 	cl_git_pass(git_object_lookup(&obj, _repo, &full, GIT_OBJ_ANY));
 	cl_git_pass(git_object_short_id(&shorty, obj));
diff --git a/tests/resources/duplicate.git/objects/03/8d718da6a1ebbc6a7780a96ed75a70cc2ad6e2 b/tests/resources/duplicate.git/objects/03/8d718da6a1ebbc6a7780a96ed75a70cc2ad6e2
new file mode 100644
index 000000000..7350d98a2
Binary files /dev/null and b/tests/resources/duplicate.git/objects/03/8d718da6a1ebbc6a7780a96ed75a70cc2ad6e2 differ
-- 
cgit v1.2.3


From 5302a88538c870028f2623b099c66c800f5cfe68 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 12 Mar 2014 11:21:55 -0700
Subject: Fix pqueue sort boundary condition bug

If the pqueue comparison fn returned just 0 or 1 (think "a<b")
then the sort order of returned items could be wrong because there
was a "< 0" that really needed to be "<= 0".  Yikes!!!
---
 src/pqueue.c          |  2 +-
 tests/core/pqueue.c   | 31 +++++++++++++++++++++++++++
 tests/revwalk/basic.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 91 insertions(+), 1 deletion(-)

diff --git a/src/pqueue.c b/src/pqueue.c
index 172cf43d5..54a60ca04 100644
--- a/src/pqueue.c
+++ b/src/pqueue.c
@@ -68,7 +68,7 @@ static void pqueue_down(git_pqueue *pq, size_t el)
 			kid_el += 1;
 		}
 
-		if (pq->_cmp(parent, kid) < 0)
+		if (pq->_cmp(parent, kid) <= 0)
 			break;
 
 		pq->contents[el] = kid;
diff --git a/tests/core/pqueue.c b/tests/core/pqueue.c
index d91dbb0cd..bcd4eea9f 100644
--- a/tests/core/pqueue.c
+++ b/tests/core/pqueue.c
@@ -95,3 +95,34 @@ void test_core_pqueue__max_heap_size(void)
 	git_pqueue_free(&pq);
 
 }
+
+static int cmp_ints_like_commit_time(const void *a, const void *b)
+{
+	return *((const int *)a) < *((const int *)b);
+}
+
+void test_core_pqueue__interleaved_pushes_and_pops(void)
+{
+	git_pqueue pq;
+	int i, j, *val;
+	static int commands[] =
+		{ 6, 9, 8, 0, 5, 0, 7, 0, 4, 3, 0, 0, 0, 4, 0, 2, 0, 1, 0, 0, -1 };
+	static int expected[] =
+		{ 9, 8, 7, 6, 5, 4, 4, 3, 2, 1, -1 };
+
+	cl_git_pass(git_pqueue_init(&pq, 0, 10, cmp_ints_like_commit_time));
+
+	for (i = 0, j = 0; commands[i] >= 0; ++i) {
+		if (!commands[i]) {
+			cl_assert((val = git_pqueue_pop(&pq)) != NULL);
+			cl_assert_equal_i(expected[j], *val);
+			++j;
+		} else {
+			cl_git_pass(git_pqueue_insert(&pq, &commands[i]));
+		}
+	}
+
+	cl_assert_equal_i(0, git_pqueue_size(&pq));
+	git_pqueue_free(&pq);
+}
+
diff --git a/tests/revwalk/basic.c b/tests/revwalk/basic.c
index 9fe8a350b..7e08c1840 100644
--- a/tests/revwalk/basic.c
+++ b/tests/revwalk/basic.c
@@ -290,3 +290,62 @@ void test_revwalk_basic__push_all(void)
 	/* git rev-list --count --all #=> 15 */
 	cl_assert_equal_i(15, i);
 }
+
+/*
+* $ git rev-list br2 master e908
+* a65fedf39aefe402d3bb6e24df4d4f5fe4547750
+* e90810b8df3e80c413d903f631643c716887138d
+* 6dcf9bf7541ee10456529833502442f385010c3d
+* a4a7dce85cf63874e984719f4fdd239f5145052f
+* be3563ae3f795b2b4353bcce3a527ad0a4f7f644
+* c47800c7266a2be04c571c04d5a6614691ea99bd
+* 9fd738e8f7967c078dceed8190330fc8648ee56a
+* 4a202b346bb0fb0db7eff3cffeb3c70babbd2045
+* 5b5b025afb0b4c913b4c338a42934a3863bf3644
+* 8496071c1b46c854b31185ea97743be6a8774479
+*/
+
+void test_revwalk_basic__mimic_git_rev_list(void)
+{
+   git_oid oid;
+
+   revwalk_basic_setup_walk(NULL);
+   git_revwalk_sorting(_walk, GIT_SORT_TIME);
+
+   cl_git_pass(git_revwalk_push_ref(_walk, "refs/heads/br2"));
+   cl_git_pass(git_revwalk_push_ref(_walk, "refs/heads/master"));
+   cl_git_pass(git_oid_fromstr(&oid, "e90810b8df3e80c413d903f631643c716887138d"));
+   cl_git_pass(git_revwalk_push(_walk, &oid));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "e90810b8df3e80c413d903f631643c716887138d"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "6dcf9bf7541ee10456529833502442f385010c3d"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "a4a7dce85cf63874e984719f4fdd239f5145052f"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "c47800c7266a2be04c571c04d5a6614691ea99bd"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "9fd738e8f7967c078dceed8190330fc8648ee56a"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644"));
+
+   cl_git_pass(git_revwalk_next(&oid, _walk));
+   cl_assert(!git_oid_streq(&oid, "8496071c1b46c854b31185ea97743be6a8774479"));
+
+   cl_git_fail_with(git_revwalk_next(&oid, _walk), GIT_ITEROVER);
+}
-- 
cgit v1.2.3


From 2b40390f226ac8ba516fdf0d893e0b5a29857dc7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 13 Mar 2014 15:54:53 +0100
Subject: refs: fix copy-paste doc error

---
 include/git2/refs.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index a4e44c543..65449e69e 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -416,7 +416,7 @@ GIT_EXTERN(int) git_reference_delete(git_reference *ref);
  * looking at its old value.
  *
  * @param ref The reference to remove
- * @return 0, GIT_EMODIFIED or an error code
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_remove(git_repository *repo, const char *name);
 
-- 
cgit v1.2.3


From 853b1407c0325f6690eab92746d1f53c78b0da49 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 17 Mar 2014 16:10:33 +0100
Subject: branch: constness fixes

---
 include/git2/branch.h | 2 +-
 include/git2/refs.h   | 2 +-
 src/branch.c          | 2 +-
 src/refs.c            | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/git2/branch.h b/include/git2/branch.h
index 46aef3206..d2762019b 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -238,7 +238,7 @@ GIT_EXTERN(int) git_branch_upstream_name(
  * error code otherwise.
  */
 GIT_EXTERN(int) git_branch_is_head(
-	git_reference *branch);
+	const git_reference *branch);
 
 /**
  * Return the name of remote that the remote tracking branch belongs to.
diff --git a/include/git2/refs.h b/include/git2/refs.h
index 65449e69e..1bbb4ca46 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -586,7 +586,7 @@ GIT_EXTERN(int) git_reference_ensure_log(git_repository *repo, const char *refna
  * @return 1 when the reference lives in the refs/heads
  * namespace; 0 otherwise.
  */
-GIT_EXTERN(int) git_reference_is_branch(git_reference *ref);
+GIT_EXTERN(int) git_reference_is_branch(const git_reference *ref);
 
 /**
  * Check if a reference is a remote tracking branch
diff --git a/src/branch.c b/src/branch.c
index 7c888729d..df665a469 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -588,7 +588,7 @@ on_error:
 }
 
 int git_branch_is_head(
-		git_reference *branch)
+		const git_reference *branch)
 {
 	git_reference *head;
 	bool is_same = false;
diff --git a/src/refs.c b/src/refs.c
index e63796c94..8b6e09a33 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -1137,7 +1137,7 @@ int git_reference__is_branch(const char *ref_name)
 	return git__prefixcmp(ref_name, GIT_REFS_HEADS_DIR) == 0;
 }
 
-int git_reference_is_branch(git_reference *ref)
+int git_reference_is_branch(const git_reference *ref)
 {
 	assert(ref);
 	return git_reference__is_branch(ref->name);
-- 
cgit v1.2.3


From cb562c3fb305b7fa2ddc46983a6107f7b8340293 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 17 Mar 2014 17:36:51 +0100
Subject: repo: remove test which deletes HEAD

This is not something anybody would ever do; removing HEAD makes the
.git/ directory no longer be a repository, so we wouldn't be expected to
handle such a situation.
---
 tests/repo/head.c | 21 ---------------------
 1 file changed, 21 deletions(-)

diff --git a/tests/repo/head.c b/tests/repo/head.c
index c5965fac6..459ab8b40 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -270,24 +270,3 @@ void test_repo_head__setting_head_updates_reflog(void)
 	git_object_free(tag);
 	git_signature_free(sig);
 }
-
-void test_repo_head__setting_creates_head_ref(void)
-{
-	git_reference *head;
-	git_reflog *log;
-	const git_reflog_entry *entry;
-
-	cl_git_pass(git_reference_lookup(&head, repo, "HEAD"));
-	cl_git_pass(git_reference_delete(head));
-	cl_git_pass(git_reflog_delete(repo, "HEAD"));
-
-	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", NULL, "create HEAD"));
-
-	cl_git_pass(git_reflog_read(&log, repo, "HEAD"));
-	cl_assert_equal_i(1, git_reflog_entrycount(log));
-	entry = git_reflog_entry_byindex(log, 0);
-	cl_assert_equal_s("create HEAD", git_reflog_entry_message(entry));
-
-	git_reflog_free(log);
-	git_reference_free(head);
-}
-- 
cgit v1.2.3


From 4b7e1b9e927eec2359f178a260335109d4222e2b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 15 Jan 2014 13:19:48 +0100
Subject: refs: append to the HEAD reflog when updating the current branch

When we update the current branch, we must also append to HEAD's reflog
to keep them in sync.

This is a bit of a hack, but as git.git says, it covers 100% of
default cases.
---
 src/refdb_fs.c             | 105 ++++++++++++++++++++++++++++++++++++---------
 tests/refs/reflog/reflog.c |  23 ++++++++++
 tests/repo/head.c          |   3 +-
 tests/reset/hard.c         |  10 +++--
 tests/reset/mixed.c        |  10 +++--
 5 files changed, 120 insertions(+), 31 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 8a26bec0b..f494afa71 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -21,6 +21,7 @@
 #include <git2/tag.h>
 #include <git2/object.h>
 #include <git2/refdb.h>
+#include <git2/branch.h>
 #include <git2/sys/refdb_backend.h>
 #include <git2/sys/refs.h>
 #include <git2/sys/reflog.h>
@@ -920,7 +921,7 @@ fail:
 	return -1;
 }
 
-static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_signature *author, const char *message);
+static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *author, const char *message);
 static int has_reflog(git_repository *repo, const char *name);
 
 /* We only write if it's under heads/, remotes/ or notes/ or if it already has a log */
@@ -974,6 +975,40 @@ out:
 	return error;
 }
 
+/*
+ * The git.git comment regarding this, for your viewing pleasure:
+ *
+ * Special hack: If a branch is updated directly and HEAD
+ * points to it (may happen on the remote side of a push
+ * for example) then logically the HEAD reflog should be
+ * updated too.
+ * A generic solution implies reverse symref information,
+ * but finding all symrefs pointing to the given branch
+ * would be rather costly for this rare event (the direct
+ * update of a branch) to be worth it.  So let's cheat and
+ * check with HEAD only which should cover 99% of all usage
+ * scenarios (even 100% of the default ones).
+ */
+static int maybe_append_head(refdb_fs_backend *backend, const git_reference *ref, const git_signature *who, const char *message)
+{
+	int error;
+	git_oid old_id;
+	git_reference *head;
+
+	error = git_reference_name_to_id(&old_id, backend->repo, ref->name);
+	if (!git_branch_is_head(ref))
+		return 0;
+
+	if ((error = git_reference_lookup(&head, backend->repo, "HEAD")) < 0)
+		return error;
+
+	error = reflog_append(backend, head, &old_id, git_reference_target(ref), who, message);
+
+	git_reference_free(head);
+	return error;
+}
+
+
 static int refdb_fs_backend__write(
 	git_refdb_backend *_backend,
 	const git_reference *ref,
@@ -1006,10 +1041,11 @@ static int refdb_fs_backend__write(
 		goto on_error;
 	}
 
-	if (should_write_reflog(backend->repo, ref->name) &&
-	    (error = reflog_append(backend, ref, who, message)) < 0) {
-		git_filebuf_cleanup(&file);
-		return error;
+	if (should_write_reflog(backend->repo, ref->name)) {
+		if ((error = reflog_append(backend, ref, NULL, NULL, who, message)) < 0)
+			goto on_error;
+		if ((error = maybe_append_head(backend, ref, who, message)) < 0)
+			goto on_error;
 	}
 
 	return loose_commit(&file, ref);
@@ -1128,7 +1164,7 @@ static int refdb_fs_backend__rename(
 	/* Try to rename the refog; it's ok if the old doesn't exist */
 	error = refdb_reflog_fs__rename(_backend, old_name, new_name);
 	if (((error == 0) || (error == GIT_ENOTFOUND)) &&
-	    ((error = reflog_append(backend, new, who, message)) < 0)) {
+	    ((error = reflog_append(backend, new, NULL, NULL, who, message)) < 0)) {
 		git_reference_free(new);
 		git_filebuf_cleanup(&file);
 		return error;
@@ -1517,34 +1553,61 @@ success:
 }
 
 /* Append to the reflog, must be called under reference lock */
-static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_signature *who, const char *message)
+static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *who, const char *message)
 {
-	int error;
-	git_oid old_id, new_id = {{0}};
+	int error, is_symbolic, was_symbolic = 0;
+	git_oid old_id = {{0}}, new_id = {{0}};
 	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
 	git_repository *repo = backend->repo;
+	git_reference *current_ref = NULL;
 
-	/* Creation of a symbolic reference doesn't get a reflog entry, except for
-	 * HEAD. git_repository_set_head and friends go through here. */
-	if (ref->type == GIT_REF_SYMBOLIC &&
-	    0 != strcmp(ref->name, GIT_HEAD_FILE))
+	is_symbolic = ref->type == GIT_REF_SYMBOLIC;
+
+	/* "normal" symbolic updates do not write */
+	if (is_symbolic &&
+	    strcmp(ref->name, GIT_HEAD_FILE) &&
+	    !(old && new))
 		return 0;
 
-	error = git_reference_name_to_id(&old_id, repo, ref->name);
-	if (error == GIT_ENOTFOUND) {
-		memset(&old_id, 0, sizeof(git_oid));
-		error = 0;
-	}
-	if (error < 0)
+	error = git_reference_lookup(&current_ref, repo, ref->name);
+	if (error < 0 && error != GIT_ENOTFOUND)
 		return error;
 
-	if (git_reference_symbolic_target(ref) != NULL) {
+	if (current_ref)
+		was_symbolic = current_ref->type == GIT_REF_SYMBOLIC;
+
+	/* From here on is_symoblic also means that it's HEAD */
+
+	if (old) {
+		git_oid_cpy(&old_id, old);
+	} else if (!was_symbolic) {
+		error = git_reference_name_to_id(&old_id, repo, ref->name);
+		if (error == GIT_ENOTFOUND) {
+			memset(&old_id, 0, sizeof(git_oid));
+			error = 0;
+		}
+
+		if (error < 0)
+			return error;
+	}
+
+	if (is_symbolic) {
 		error = git_reference_name_to_id(&new_id, repo, git_reference_symbolic_target(ref));
 		if (error != 0 && error != GIT_ENOTFOUND)
 			goto cleanup;
+		/* detaching HEAD does not create an entry */
+		if (error == GIT_ENOTFOUND) {
+			error = 0;
+			goto cleanup;
+		}
+
 		giterr_clear();
 	}
-	else if (git_reference_target(ref) != NULL)
+
+
+	if (new)
+		git_oid_cpy(&new_id, new);
+	else if (!is_symbolic)
 		git_oid_cpy(&new_id, git_reference_target(ref));
 
 	if ((error = serialize_reflog_entry(&buf, &old_id, &new_id, who, message)) < 0)
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index 3f7d7d777..149e98273 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -214,3 +214,26 @@ void test_refs_reflog_reflog__write_when_explicitly_active(void)
 	git_reference_free(ref);
 	assert_has_reflog(true, "refs/tags/foo");
 }
+
+void test_refs_reflog_reflog__append_to_HEAD_when_changing_current_branch(void)
+{
+	size_t nlogs, nlogs_after;
+	git_reference *ref;
+	git_reflog *log;
+	git_oid id;
+
+	cl_git_pass(git_reflog_read(&log, g_repo, "HEAD"));
+	nlogs = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	/* Move it back */
+	git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/master", &id, 1, NULL, NULL));
+	git_reference_free(ref);
+
+	cl_git_pass(git_reflog_read(&log, g_repo, "HEAD"));
+	nlogs_after = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_assert_equal_i(nlogs_after, nlogs + 1);
+}
diff --git a/tests/repo/head.c b/tests/repo/head.c
index 459ab8b40..d88fd90d1 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -262,8 +262,7 @@ void test_repo_head__setting_head_updates_reflog(void)
 	cl_git_pass(git_repository_set_head_detached(repo, git_object_id(tag), sig, "message3"));
 	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", sig, "message4"));
 
-	test_reflog(repo, 3, NULL, "refs/heads/haacked", "foo@example.com", "message1");
-	test_reflog(repo, 2, "refs/heads/haacked", NULL, "foo@example.com", "message2");
+	test_reflog(repo, 2, NULL, "refs/heads/haacked", "foo@example.com", "message1");
 	test_reflog(repo, 1, NULL, "tags/test^{commit}", "foo@example.com", "message3");
 	test_reflog(repo, 0, "tags/test^{commit}", "refs/heads/haacked", "foo@example.com", "message4");
 
diff --git a/tests/reset/hard.c b/tests/reset/hard.c
index 36120ee63..c6bf7a8ac 100644
--- a/tests/reset/hard.c
+++ b/tests/reset/hard.c
@@ -215,16 +215,18 @@ void test_reset_hard__reflog_is_correct(void)
 	git_object_free(target);
 
 	/* Moved branch, expect default message */
+	exp_msg = "reset: moving";
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, NULL));
-	reflog_check(repo, "HEAD", 3, "emeric.fermas@gmail.com", exp_msg);
-	reflog_check(repo, "refs/heads/master", 4, NULL, "reset: moving");
+	reflog_check(repo, "HEAD", 4, NULL, exp_msg);
+	reflog_check(repo, "refs/heads/master", 4, NULL, exp_msg);
 
 	git_object_free(target);
 
 	/* Moved branch, expect custom message */
+	exp_msg = "message1";
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_HARD, NULL, "message1"));
-	reflog_check(repo, "HEAD", 3, "emeric.fermas@gmail.com", exp_msg);
-	reflog_check(repo, "refs/heads/master", 5, NULL, "message1");
+	reflog_check(repo, "HEAD", 5, NULL, exp_msg);
+	reflog_check(repo, "refs/heads/master", 5, NULL, exp_msg);
 }
diff --git a/tests/reset/mixed.c b/tests/reset/mixed.c
index 5d8ff63b4..55b8a2f88 100644
--- a/tests/reset/mixed.c
+++ b/tests/reset/mixed.c
@@ -65,17 +65,19 @@ void test_reset_mixed__reflog_is_correct(void)
 	target = NULL;
 
 	/* Moved branch, expect default message */
+	exp_msg = "reset: moving";
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, NULL));
-	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
-	reflog_check(repo, "refs/heads/master", 10, NULL, "reset: moving");
+	reflog_check(repo, "HEAD", 10, NULL, exp_msg);
+	reflog_check(repo, "refs/heads/master", 10, NULL, exp_msg);
 
 	git_object_free(target);
 	target = NULL;
 
 	/* Moved branch, expect custom message */
+	exp_msg = "message1";
 	cl_git_pass(git_revparse_single(&target, repo, "HEAD~^{commit}"));
 	cl_git_pass(git_reset(repo, target, GIT_RESET_MIXED, NULL, "message1"));
-	reflog_check(repo, "HEAD", 9, "yoram.harmelin@gmail.com", exp_msg);
-	reflog_check(repo, "refs/heads/master", 11, NULL, "message1");
+	reflog_check(repo, "HEAD", 11, NULL, exp_msg);
+	reflog_check(repo, "refs/heads/master", 11, NULL, exp_msg);
 }
-- 
cgit v1.2.3


From 5c8096c53c569a2dcc0e032705a77590885be0e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 17 Mar 2014 19:44:07 +0100
Subject: Add a few projects to the list

---
 PROJECTS.md | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/PROJECTS.md b/PROJECTS.md
index d97c3329a..9472fb43c 100644
--- a/PROJECTS.md
+++ b/PROJECTS.md
@@ -58,6 +58,9 @@ These are good small projects to get started with libgit2.
 * Submit a PR to clarify documentation! While we do try to document all of
   the APIs, your fresh eyes on the documentation will find areas that are
   confusing much more easily.
+* Add support for the symref protocol extension, so we don't guess
+  what the remote's default branch is
+  [#2006](https://github.com/libgit2/libgit2/issues/2006)
 
 If none of these appeal to you, take a look at our issues list to see if
 there are any unresolved issues you'd like to jump in on.
@@ -80,3 +83,9 @@ projects above.
 * Upgrade internal libxdiff code to latest from core Git
 * Add a hashtable lookup for files in the index instead of binary search
   every time
+* Make the index write the cache out to disk (with tests to gain
+  confidence that the caching invalidation works correctly)
+* Have the tree builder use a hash table when building instead of a
+  list.
+* Move the tagopt mechanism to the newer git 1.9 interpretation of
+  --tags [#2120](https://github.com/libgit2/libgit2/issues/2120)
-- 
cgit v1.2.3


From 1392418ea800bbd05dd4b38c5d5995df5bd3e177 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Tue, 18 Mar 2014 09:04:33 -0400
Subject: Seamless support for NTLM/Kerberos auth on Windows

---
 include/git2/transport.h |   3 +-
 src/transports/winhttp.c | 121 +++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 104 insertions(+), 20 deletions(-)

diff --git a/include/git2/transport.h b/include/git2/transport.h
index f2b0c630d..1f4d03eea 100644
--- a/include/git2/transport.h
+++ b/include/git2/transport.h
@@ -185,7 +185,8 @@ GIT_EXTERN(int) git_cred_default_new(git_cred **out);
  *                          remote url, or NULL if not included.
  * - allowed_types: A bitmask stating which cred types are OK to return.
  * - payload: The payload provided when specifying this callback.
- * - returns 0 for success or non-zero to indicate an error
+ * - returns 0 for success, < 0 to indicate an error, > 0 to indicate
+ *       no credential was acquired
  */
 typedef int (*git_cred_acquire_cb)(
 	git_cred **cred,
diff --git a/src/transports/winhttp.c b/src/transports/winhttp.c
index e47e19cca..7ad2a1636 100644
--- a/src/transports/winhttp.c
+++ b/src/transports/winhttp.c
@@ -21,6 +21,10 @@
 
 #include <strsafe.h>
 
+/* For IInternetSecurityManager zone check */
+#include <objbase.h>
+#include <urlmon.h>
+
 /* For UuidCreate */
 #pragma comment(lib, "rpcrt4")
 
@@ -141,12 +145,12 @@ on_error:
 
 static int apply_default_credentials(HINTERNET request)
 {
-	/* If we are explicitly asked to deliver default credentials, turn set
-	 * the security level to low which will guarantee they are delivered.
-	 * The default is "medium" which applies to the intranet and sounds
-	 * like it would correspond to Internet Explorer security zones, but
-	 * in fact does not.
-	 */
+	/* Either the caller explicitly requested that default credentials be passed,
+	 * or our fallback credential callback was invoked and checked that the target
+	 * URI was in the appropriate Internet Explorer security zone. By setting this
+	 * flag, we guarantee that the credentials are delivered by WinHTTP. The default
+	 * is "medium" which applies to the intranet and sounds like it would correspond
+	 * to Internet Explorer security zones, but in fact does not. */
 	DWORD data = WINHTTP_AUTOLOGON_SECURITY_LEVEL_LOW;
 
 	if (!WinHttpSetOption(request, WINHTTP_OPTION_AUTOLOGON_POLICY, &data, sizeof(DWORD)))
@@ -155,6 +159,71 @@ static int apply_default_credentials(HINTERNET request)
 	return 0;
 }
 
+static int fallback_cred_acquire_cb(
+	git_cred **cred,
+	const char *url,
+	const char *username_from_url,
+	unsigned int allowed_types,
+	void *payload)
+{
+	int error = 1;
+
+	/* If the target URI supports integrated Windows authentication
+	 * as an authentication mechanism */
+	if (GIT_CREDTYPE_DEFAULT & allowed_types) {
+		LPWSTR wide_url;
+		DWORD wide_len;
+
+		/* Convert URL to wide characters */
+		wide_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, url, -1, NULL, 0);
+
+		if (!wide_len) {
+			giterr_set(GITERR_OS, "Failed to measure string for wide conversion");
+			return -1;
+		}
+
+		wide_url = git__malloc(wide_len * sizeof(WCHAR));
+		GITERR_CHECK_ALLOC(wide_url);
+
+		if (!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, url, -1, wide_url, wide_len)) {
+			giterr_set(GITERR_OS, "Failed to convert string to wide form");
+			git__free(wide_url);
+			return -1;
+		}
+
+		if (SUCCEEDED(CoInitializeEx(NULL, COINIT_MULTITHREADED))) {
+			IInternetSecurityManager* pISM;
+
+			/* And if the target URI is in the My Computer, Intranet, or Trusted zones */
+			if (SUCCEEDED(CoCreateInstance(&CLSID_InternetSecurityManager, NULL,
+				CLSCTX_ALL, &IID_IInternetSecurityManager, (void **)&pISM))) {
+				DWORD dwZone;
+
+				if (SUCCEEDED(pISM->lpVtbl->MapUrlToZone(pISM, wide_url, &dwZone, 0)) &&
+					(URLZONE_LOCAL_MACHINE == dwZone ||
+					URLZONE_INTRANET == dwZone ||
+					URLZONE_TRUSTED == dwZone)) {
+					git_cred *existing = *cred;
+
+					if (existing)
+						existing->free(existing);
+
+					/* Then use default Windows credentials to authenticate this request */
+					error = git_cred_default_new(cred);
+				}
+
+				pISM->lpVtbl->Release(pISM);
+			}
+
+			CoUninitialize();
+		}
+
+		git__free(wide_url);
+	}
+
+	return error;
+}
+
 static int winhttp_stream_connect(winhttp_stream *s)
 {
 	winhttp_subtransport *t = OWNING_SUBTRANSPORT(s);
@@ -657,8 +726,7 @@ replay:
 		}
 
 		/* Handle authentication failures */
-		if (HTTP_STATUS_DENIED == status_code &&
-			get_verb == s->verb && t->owner->cred_acquire_cb) {
+		if (HTTP_STATUS_DENIED == status_code && get_verb == s->verb) {
 			int allowed_types;
 
 			if (parse_unauthorized_response(s->request, &allowed_types, &t->auth_mechanism) < 0)
@@ -666,21 +734,36 @@ replay:
 
 			if (allowed_types &&
 				(!t->cred || 0 == (t->cred->credtype & allowed_types))) {
+				int cred_error = 1;
 
-				int error = t->owner->cred_acquire_cb(
-					&t->cred, t->owner->url, t->connection_data.user,
-					allowed_types, t->owner->cred_acquire_payload);
-				if (error < 0)
-					return error;
+				/* Start with the user-supplied credential callback, if present */
+				if (t->owner->cred_acquire_cb) {
+					cred_error = t->owner->cred_acquire_cb(&t->cred, t->owner->url,
+						t->connection_data.user, allowed_types,	t->owner->cred_acquire_payload);
 
-				assert(t->cred);
+					if (cred_error < 0)
+						return cred_error;
+				}
 
-				WinHttpCloseHandle(s->request);
-				s->request = NULL;
-				s->sent_request = 0;
+				/* Invoke the fallback credentials acquisition callback if necessary */
+				if (cred_error > 0) {
+					cred_error = fallback_cred_acquire_cb(&t->cred, t->owner->url,
+						t->connection_data.user, allowed_types, NULL);
 
-				/* Successfully acquired a credential */
-				goto replay;
+					if (cred_error < 0)
+						return cred_error;
+				}
+
+				if (!cred_error) {
+					assert(t->cred);
+
+					WinHttpCloseHandle(s->request);
+					s->request = NULL;
+					s->sent_request = 0;
+
+					/* Successfully acquired a credential */
+					goto replay;
+				}
 			}
 		}
 
-- 
cgit v1.2.3


From 0aee025befc82efe3b8a92692ebe852ac56171dd Mon Sep 17 00:00:00 2001
From: Aimeast <lixd3389@gmail.com>
Date: Tue, 18 Mar 2014 22:31:14 +0800
Subject: Implement git_merge_base_octopus

---
 include/git2/merge.h      | 17 ++++++++++++-
 src/merge.c               | 25 ++++++++++++++++++
 tests/revwalk/mergebase.c | 65 ++++++++++++++++++++++++++++++++++++++++++++++-
 3 files changed, 105 insertions(+), 2 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 3563f35d5..cfec32f4d 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -191,7 +191,7 @@ GIT_EXTERN(int) git_merge_base(
  * @param repo the repository where the commits exist
  * @param length The number of commits in the provided `input_array`
  * @param input_array oids of the commits
- * @return 0 on success, GIT_ENOTFOUND if not found or error code
+ * @return Zero on success; GIT_ENOTFOUND or -1 on failure.
  */
 GIT_EXTERN(int) git_merge_base_many(
 	git_oid *out,
@@ -199,6 +199,21 @@ GIT_EXTERN(int) git_merge_base_many(
 	size_t length,
 	const git_oid input_array[]);
 
+/**
+ * Find a merge base in preparation for an octopus merge
+ *
+ * @param out the OID of a merge base considering all the commits
+ * @param repo the repository where the commits exist
+ * @param length The number of commits in the provided `input_array`
+ * @param input_array oids of the commits
+ * @return Zero on success; GIT_ENOTFOUND or -1 on failure.
+ */
+GIT_EXTERN(int) git_merge_base_octopus(
+	git_oid *out,
+	git_repository *repo,
+	size_t length,
+	const git_oid input_array[]);
+
 /**
  * Creates a `git_merge_head` from the given reference.  The resulting
  * git_merge_head must be freed with `git_merge_head_free`.
diff --git a/src/merge.c b/src/merge.c
index 124e8c3a7..0b11c0da3 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -114,6 +114,31 @@ cleanup:
 	return error;
 }
 
+int git_merge_base_octopus(git_oid *out, git_repository *repo, size_t length, const git_oid input_array[])
+{
+	git_oid result;
+	unsigned int i;
+	int error = -1;
+
+	assert(out && repo && input_array);
+
+	if (length < 2) {
+		giterr_set(GITERR_INVALID, "At least two commits are required to find an ancestor. Provided 'length' was %u.", length);
+		return -1;
+	}
+
+	result = input_array[0];
+	for (i = 1; i < length; i++) {
+		error = git_merge_base(&result, repo, &result, &input_array[i]);
+		if (error < 0)
+			return error;
+	}
+
+	*out = result;
+
+	return 0;
+}
+
 int git_merge_base(git_oid *out, git_repository *repo, const git_oid *one, const git_oid *two)
 {
 	git_revwalk *walk;
diff --git a/tests/revwalk/mergebase.c b/tests/revwalk/mergebase.c
index 2d01647fd..97663502c 100644
--- a/tests/revwalk/mergebase.c
+++ b/tests/revwalk/mergebase.c
@@ -189,7 +189,6 @@ void test_revwalk_mergebase__many_no_common_ancestor_returns_ENOTFOUND(void)
 	assert_mergebase_many(NULL, 3, "e90810", "41bc8c", "a65fed");
 	assert_mergebase_many(NULL, 3, "e90810", "a65fed", "41bc8c");
 	assert_mergebase_many(NULL, 3, "a65fed", "e90810", "41bc8c");
-	assert_mergebase_many(NULL, 3, "a65fed", "e90810", "41bc8c");
 	assert_mergebase_many(NULL, 3, "a65fed", "41bc8c", "e90810");
 
 	assert_mergebase_many(NULL, 3, "e90810", "763d71", "a65fed");
@@ -209,6 +208,70 @@ void test_revwalk_mergebase__many_merge_branch(void)
 	assert_mergebase_many("5b5b025afb0b4c913b4c338a42934a3863bf3644", 5, "5b5b02", "763d71", "a4a7dc", "a65fed", "41bc8c");
 }
 
+static void assert_mergebase_octopus(const char *expected_sha, int count, ...)
+{
+	va_list ap;
+	int i;
+	git_oid *oids;
+	git_oid oid, expected;
+	char *partial_oid;
+	git_object *object;
+
+	oids = git__malloc(count * sizeof(git_oid));
+	cl_assert(oids != NULL);
+
+	memset(oids, 0x0, count * sizeof(git_oid));
+
+	va_start(ap, count);
+
+	for (i = 0; i < count; ++i) {
+		partial_oid = va_arg(ap, char *);
+		cl_git_pass(git_oid_fromstrn(&oid, partial_oid, strlen(partial_oid)));
+
+		cl_git_pass(git_object_lookup_prefix(&object, _repo, &oid, strlen(partial_oid), GIT_OBJ_COMMIT));
+		git_oid_cpy(&oids[i], git_object_id(object));
+		git_object_free(object);
+	}
+
+	va_end(ap);
+
+	if (expected_sha == NULL)
+		cl_assert_equal_i(GIT_ENOTFOUND, git_merge_base_octopus(&oid, _repo, count, oids));
+	else {
+		cl_git_pass(git_merge_base_octopus(&oid, _repo, count, oids));
+		cl_git_pass(git_oid_fromstr(&expected, expected_sha));
+
+		cl_assert(git_oid_cmp(&expected, &oid) == 0);
+	}
+
+	git__free(oids);
+}
+
+void test_revwalk_mergebase__octopus_no_common_ancestor_returns_ENOTFOUND(void)
+{
+	assert_mergebase_octopus(NULL, 3, "41bc8c", "e90810", "a65fed");
+	assert_mergebase_octopus(NULL, 3, "e90810", "41bc8c", "a65fed");
+	assert_mergebase_octopus(NULL, 3, "e90810", "a65fed", "41bc8c");
+	assert_mergebase_octopus(NULL, 3, "a65fed", "e90810", "41bc8c");
+	assert_mergebase_octopus(NULL, 3, "a65fed", "41bc8c", "e90810");
+
+	assert_mergebase_octopus(NULL, 3, "e90810", "763d71", "a65fed");
+
+	assert_mergebase_octopus(NULL, 3, "763d71", "e90810", "a65fed");
+	assert_mergebase_octopus(NULL, 3, "763d71", "a65fed", "e90810");
+
+	assert_mergebase_octopus(NULL, 5, "5b5b02", "763d71", "a4a7dc", "a65fed", "41bc8c");
+}
+
+void test_revwalk_mergebase__octopus_merge_branch(void)
+{
+	assert_mergebase_octopus("8496071c1b46c854b31185ea97743be6a8774479", 3, "a65fed", "763d71", "849607");
+
+	assert_mergebase_octopus("8496071c1b46c854b31185ea97743be6a8774479", 3, "a65fed", "763d71", "849607");
+	assert_mergebase_octopus("8496071c1b46c854b31185ea97743be6a8774479", 3, "a65fed", "849607", "763d71");
+	assert_mergebase_octopus("8496071c1b46c854b31185ea97743be6a8774479", 3, "849607", "a65fed", "763d71");
+}
+
 /*
  * testrepo.git $ git log --graph --all
  * * commit 763d71aadf09a7951596c9746c024e7eece7c7af
-- 
cgit v1.2.3


From bac95e6e1e99b1e364c5ebd39887a8e24bc1ad9d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 18 Mar 2014 19:41:03 +0100
Subject: reflog: more comprehensive HEAD tests

The existing ones lack checking zeroed ids when switching back from an
unborn branch as well as what happens when detaching.

The reflog appending function mistakenly wrote zeros when dealing with a
detached HEAD. This explicitly checks for those situations and fixes
them.
---
 src/refdb_fs.c    |  8 +++----
 tests/repo/head.c | 72 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 76 insertions(+), 4 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index f494afa71..0c3011083 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1555,7 +1555,7 @@ success:
 /* Append to the reflog, must be called under reference lock */
 static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *who, const char *message)
 {
-	int error, is_symbolic, was_symbolic = 0;
+	int error, is_symbolic, currently_exists;
 	git_oid old_id = {{0}}, new_id = {{0}};
 	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
 	git_repository *repo = backend->repo;
@@ -1573,14 +1573,14 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	if (error < 0 && error != GIT_ENOTFOUND)
 		return error;
 
-	if (current_ref)
-		was_symbolic = current_ref->type == GIT_REF_SYMBOLIC;
+	currently_exists = !!current_ref;
 
+	git_reference_free(current_ref);
 	/* From here on is_symoblic also means that it's HEAD */
 
 	if (old) {
 		git_oid_cpy(&old_id, old);
-	} else if (!was_symbolic) {
+	} else if (currently_exists) {
 		error = git_reference_name_to_id(&old_id, repo, ref->name);
 		if (error == GIT_ENOTFOUND) {
 			memset(&old_id, 0, sizeof(git_oid));
diff --git a/tests/repo/head.c b/tests/repo/head.c
index d88fd90d1..a246e6086 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -269,3 +269,75 @@ void test_repo_head__setting_head_updates_reflog(void)
 	git_object_free(tag);
 	git_signature_free(sig);
 }
+
+static void assert_head_reflog(git_repository *repo, size_t idx,
+			       const char *old_id, const char *new_id, const char *message)
+{
+	git_reflog *log;
+	const git_reflog_entry *entry;
+	char id_str[GIT_OID_HEXSZ + 1] = {0};
+
+	cl_git_pass(git_reflog_read(&log, repo, GIT_HEAD_FILE));
+	entry = git_reflog_entry_byindex(log, idx);
+
+	git_oid_fmt(id_str, git_reflog_entry_id_old(entry));
+	cl_assert_equal_s(old_id, id_str);
+
+	git_oid_fmt(id_str, git_reflog_entry_id_new(entry));
+	cl_assert_equal_s(new_id, id_str);
+
+	cl_assert_equal_s(message, git_reflog_entry_message(entry));
+
+	git_reflog_free(log);
+}
+
+void test_repo_head__detaching_writes_reflog(void)
+{
+	git_signature *sig;
+	git_oid id;
+	const char *msg;
+
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
+
+	msg = "message1";
+	git_oid_fromstr(&id, "e90810b8df3e80c413d903f631643c716887138d");
+	cl_git_pass(git_repository_set_head_detached(repo, &id, sig, msg));
+	assert_head_reflog(repo, 0, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750",
+			   "e90810b8df3e80c413d903f631643c716887138d", msg);
+
+	msg = "message2";
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", sig, msg));
+	assert_head_reflog(repo, 0, "e90810b8df3e80c413d903f631643c716887138d",
+			   "258f0e2a959a364e40ed6603d5d44fbb24765b10", msg);
+
+	git_signature_free(sig);
+}
+
+void test_repo_head__orphan_branch_does_not_count(void)
+{
+	git_signature *sig;
+	git_oid id;
+	const char *msg;
+
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
+
+	/* Have something known */
+	msg = "message1";
+	git_oid_fromstr(&id, "e90810b8df3e80c413d903f631643c716887138d");
+	cl_git_pass(git_repository_set_head_detached(repo, &id, sig, msg));
+	assert_head_reflog(repo, 0, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750",
+			   "e90810b8df3e80c413d903f631643c716887138d", msg);
+
+	/* Switching to an orphan branch does not write tot he reflog */
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/orphan", sig, "ignored message"));
+	assert_head_reflog(repo, 0, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750",
+			   "e90810b8df3e80c413d903f631643c716887138d", msg);
+
+	/* And coming back, we set the source to zero */
+	msg = "message2";
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", sig, msg));
+	assert_head_reflog(repo, 0, "0000000000000000000000000000000000000000",
+			   "258f0e2a959a364e40ed6603d5d44fbb24765b10", msg);
+
+	git_signature_free(sig);
+}
-- 
cgit v1.2.3


From 1afe1400433f010734ae4c43bf35dcc94edcc9de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 18 Mar 2014 22:16:58 +0100
Subject: refdb: don't update when there's no need

If the caller wants to update a ref to point to the same target as it
currently has, we should return early and avoid writing to the reflog.
---
 src/refdb_fs.c             | 17 +++++++++++++++++
 tests/refs/reflog/reflog.c | 24 ++++++++++++++++++++++++
 tests/repo/head.c          | 27 +++++++++++++++++++++++++++
 3 files changed, 68 insertions(+)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 0c3011083..4bcc5fac3 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1021,6 +1021,8 @@ static int refdb_fs_backend__write(
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
 	int error = 0, cmp = 0;
+	const char *new_target = NULL;
+	const git_oid *new_id = NULL;
 
 	assert(backend);
 
@@ -1041,6 +1043,21 @@ static int refdb_fs_backend__write(
 		goto on_error;
 	}
 
+	if (ref->type == GIT_REF_SYMBOLIC)
+		new_target = ref->target.symbolic;
+	else
+		new_id = &ref->target.oid;
+
+	error = cmp_old_ref(&cmp, _backend, ref->name, new_id, new_target);
+	if (error < 0 && error != GIT_ENOTFOUND)
+		goto on_error;
+
+	/* Don't update if we have the same value */
+	if (!error && !cmp) {
+		error = 0;
+		goto on_error; /* not really error */
+	}
+
 	if (should_write_reflog(backend->repo, ref->name)) {
 		if ((error = reflog_append(backend, ref, NULL, NULL, who, message)) < 0)
 			goto on_error;
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index 149e98273..a50d40aac 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -237,3 +237,27 @@ void test_refs_reflog_reflog__append_to_HEAD_when_changing_current_branch(void)
 
 	cl_assert_equal_i(nlogs_after, nlogs + 1);
 }
+
+void test_refs_reflog_reflog__do_not_append_when_no_update(void)
+{
+	size_t nlogs, nlogs_after;
+	git_reference *ref, *ref2;
+	git_reflog *log;
+
+	cl_git_pass(git_reflog_read(&log, g_repo, "HEAD"));
+	nlogs = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_git_pass(git_reference_lookup(&ref, g_repo, "refs/heads/master"));
+	cl_git_pass(git_reference_create(&ref2, g_repo, "refs/heads/master",
+					 git_reference_target(ref), 1, NULL, NULL));
+
+	git_reference_free(ref);
+	git_reference_free(ref2);
+
+	cl_git_pass(git_reflog_read(&log, g_repo, "HEAD"));
+	nlogs_after = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_assert_equal_i(nlogs_after, nlogs);
+}
diff --git a/tests/repo/head.c b/tests/repo/head.c
index a246e6086..130ed8588 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -341,3 +341,30 @@ void test_repo_head__orphan_branch_does_not_count(void)
 
 	git_signature_free(sig);
 }
+
+void test_repo_head__set_to_current_target(void)
+{
+	git_signature *sig;
+	const char *msg;
+	git_reflog *log;
+	size_t nentries, nentries_after;
+
+	cl_git_pass(git_reflog_read(&log, repo, GIT_HEAD_FILE));
+	nentries = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
+
+	msg = "message 1";
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", sig, msg));
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/haacked", sig, msg));
+
+	cl_git_pass(git_reflog_read(&log, repo, GIT_HEAD_FILE));
+	nentries_after = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_assert_equal_i(nentries + 1, nentries_after);
+
+	git_signature_free(sig);
+
+}
-- 
cgit v1.2.3


From afc57eb48fc69d3e4808648c090aa6f91f9b29aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 19 Mar 2014 06:59:09 +0100
Subject: reflog: simplify the append logic

Remove some duplicated logic.
---
 src/refdb_fs.c | 29 +++++++----------------------
 1 file changed, 7 insertions(+), 22 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 4bcc5fac3..f2edf0c56 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1572,11 +1572,10 @@ success:
 /* Append to the reflog, must be called under reference lock */
 static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, const git_oid *old, const git_oid *new, const git_signature *who, const char *message)
 {
-	int error, is_symbolic, currently_exists;
+	int error, is_symbolic;
 	git_oid old_id = {{0}}, new_id = {{0}};
 	git_buf buf = GIT_BUF_INIT, path = GIT_BUF_INIT;
 	git_repository *repo = backend->repo;
-	git_reference *current_ref = NULL;
 
 	is_symbolic = ref->type == GIT_REF_SYMBOLIC;
 
@@ -1586,37 +1585,23 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 	    !(old && new))
 		return 0;
 
-	error = git_reference_lookup(&current_ref, repo, ref->name);
-	if (error < 0 && error != GIT_ENOTFOUND)
-		return error;
-
-	currently_exists = !!current_ref;
-
-	git_reference_free(current_ref);
 	/* From here on is_symoblic also means that it's HEAD */
 
 	if (old) {
 		git_oid_cpy(&old_id, old);
-	} else if (currently_exists) {
+	} else {
 		error = git_reference_name_to_id(&old_id, repo, ref->name);
-		if (error == GIT_ENOTFOUND) {
-			memset(&old_id, 0, sizeof(git_oid));
-			error = 0;
-		}
-
-		if (error < 0)
+		if (error < 0 && error != GIT_ENOTFOUND)
 			return error;
 	}
 
 	if (is_symbolic) {
 		error = git_reference_name_to_id(&new_id, repo, git_reference_symbolic_target(ref));
-		if (error != 0 && error != GIT_ENOTFOUND)
-			goto cleanup;
+		if (error < 0 && error != GIT_ENOTFOUND)
+			return error;
 		/* detaching HEAD does not create an entry */
-		if (error == GIT_ENOTFOUND) {
-			error = 0;
-			goto cleanup;
-		}
+		if (error == GIT_ENOTFOUND)
+			return 0;
 
 		giterr_clear();
 	}
-- 
cgit v1.2.3


From 6aaae94a7060834a68f3fd24d8006dbfe769e04a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 19 Mar 2014 16:30:37 +0100
Subject: reflog: handle the birth of a branch

The reflog append function was overzealous in its checking. When passed
an old and new ids, it should not do any checking, but just serialize
the data to a reflog entry.
---
 src/refdb_fs.c    | 42 ++++++++++++++++++++++++------------------
 tests/repo/head.c | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 72 insertions(+), 18 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index f2edf0c56..905113226 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -992,18 +992,24 @@ out:
 static int maybe_append_head(refdb_fs_backend *backend, const git_reference *ref, const git_signature *who, const char *message)
 {
 	int error;
-	git_oid old_id;
+	git_oid old_id = {{0}};
 	git_reference *head;
 
-	error = git_reference_name_to_id(&old_id, backend->repo, ref->name);
-	if (!git_branch_is_head(ref))
-		return 0;
+	/* if we can't resolve, we use {0}*40 as old id */
+	git_reference_name_to_id(&old_id, backend->repo, ref->name);
 
 	if ((error = git_reference_lookup(&head, backend->repo, "HEAD")) < 0)
 		return error;
 
+	if (git_reference_type(head) == GIT_REF_OID)
+		goto cleanup;
+
+	if (strcmp(git_reference_symbolic_target(head), ref->name))
+		goto cleanup;
+
 	error = reflog_append(backend, head, &old_id, git_reference_target(ref), who, message);
 
+cleanup:
 	git_reference_free(head);
 	return error;
 }
@@ -1595,23 +1601,23 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 			return error;
 	}
 
-	if (is_symbolic) {
-		error = git_reference_name_to_id(&new_id, repo, git_reference_symbolic_target(ref));
-		if (error < 0 && error != GIT_ENOTFOUND)
-			return error;
-		/* detaching HEAD does not create an entry */
-		if (error == GIT_ENOTFOUND)
-			return 0;
+	if (new) {
+		git_oid_cpy(&new_id, new);
+	} else {
+		if (!is_symbolic) {
+			git_oid_cpy(&new_id, git_reference_target(ref));
+		} else {
+			error = git_reference_name_to_id(&new_id, repo, git_reference_symbolic_target(ref));
+			if (error < 0 && error != GIT_ENOTFOUND)
+				return error;
+			/* detaching HEAD does not create an entry */
+			if (error == GIT_ENOTFOUND)
+				return 0;
 
-		giterr_clear();
+			giterr_clear();
+		}
 	}
 
-
-	if (new)
-		git_oid_cpy(&new_id, new);
-	else if (!is_symbolic)
-		git_oid_cpy(&new_id, git_reference_target(ref));
-
 	if ((error = serialize_reflog_entry(&buf, &old_id, &new_id, who, message)) < 0)
 		goto cleanup;
 
diff --git a/tests/repo/head.c b/tests/repo/head.c
index 130ed8588..d68a5a61e 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -368,3 +368,51 @@ void test_repo_head__set_to_current_target(void)
 	git_signature_free(sig);
 
 }
+
+void test_repo_head__branch_birth(void)
+{
+	git_signature *sig;
+	git_oid id;
+	git_tree *tree;
+	git_reference *ref;
+	const char *msg;
+	git_reflog *log;
+	size_t nentries, nentries_after;
+
+	cl_git_pass(git_reflog_read(&log, repo, GIT_HEAD_FILE));
+	nentries = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
+
+	cl_git_pass(git_repository_head(&ref, repo));
+	cl_git_pass(git_reference_peel((git_object **) &tree, ref, GIT_OBJ_TREE));
+	git_reference_free(ref);
+
+	msg = "message 1";
+	cl_git_pass(git_repository_set_head(repo, "refs/heads/orphan", sig, msg));
+
+	cl_git_pass(git_reflog_read(&log, repo, GIT_HEAD_FILE));
+	nentries_after = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_assert_equal_i(nentries, nentries_after);
+
+	msg = "message 2";
+	cl_git_pass(git_commit_create(&id, repo, "HEAD", sig, sig, NULL, msg, tree, 0, NULL));
+
+	git_tree_free(tree);
+
+	cl_git_pass(git_reflog_read(&log, repo, "refs/heads/orphan"));
+	cl_assert_equal_i(1, git_reflog_entrycount(log));
+	git_reflog_free(log);
+
+	cl_git_pass(git_reflog_read(&log, repo, GIT_HEAD_FILE));
+	nentries_after = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_assert_equal_i(nentries + 1, nentries_after);
+
+	git_signature_free(sig);
+
+}
-- 
cgit v1.2.3


From 99797c96cd57a616ada009a2359390c605d33929 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 19 Mar 2014 18:14:35 +0100
Subject: reflog: handle symref chains

Given HEAD -> master -> foo, when updating foo's reflog we should also
update HEAD's, as it's considered the current branch.
---
 src/refdb_fs.c    | 36 +++++++++++++++++++++++++++++++++---
 tests/repo/head.c | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 84 insertions(+), 3 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 905113226..25316fe46 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -993,23 +993,53 @@ static int maybe_append_head(refdb_fs_backend *backend, const git_reference *ref
 {
 	int error;
 	git_oid old_id = {{0}};
-	git_reference *head;
+	git_reference *tmp = NULL, *head = NULL, *peeled = NULL;
+	const char *name;
+
+	if (ref->type == GIT_REF_SYMBOLIC)
+		return 0;
 
 	/* if we can't resolve, we use {0}*40 as old id */
 	git_reference_name_to_id(&old_id, backend->repo, ref->name);
 
-	if ((error = git_reference_lookup(&head, backend->repo, "HEAD")) < 0)
+	if ((error = git_reference_lookup(&head, backend->repo, GIT_HEAD_FILE)) < 0)
 		return error;
 
 	if (git_reference_type(head) == GIT_REF_OID)
 		goto cleanup;
 
-	if (strcmp(git_reference_symbolic_target(head), ref->name))
+	if ((error = git_reference_lookup(&tmp, backend->repo, GIT_HEAD_FILE)) < 0)
+		goto cleanup;
+
+	/* Go down the symref chain until we find the branch */
+	while (git_reference_type(tmp) == GIT_REF_SYMBOLIC) {
+		error = git_reference_lookup(&peeled, backend->repo, git_reference_symbolic_target(tmp));
+		if (error < 0)
+			break;
+
+		git_reference_free(tmp);
+		tmp = peeled;
+	}
+
+	if (error == GIT_ENOTFOUND) {
+		error = 0;
+		name = git_reference_symbolic_target(tmp);
+	} else if (error < 0) {
+		goto cleanup;
+	} else {
+		name = git_reference_name(tmp);
+	}
+
+	if (error < 0)
+		goto cleanup;
+
+	if (strcmp(name, ref->name))
 		goto cleanup;
 
 	error = reflog_append(backend, head, &old_id, git_reference_target(ref), who, message);
 
 cleanup:
+	git_reference_free(tmp);
 	git_reference_free(head);
 	return error;
 }
diff --git a/tests/repo/head.c b/tests/repo/head.c
index d68a5a61e..79892a3ea 100644
--- a/tests/repo/head.c
+++ b/tests/repo/head.c
@@ -416,3 +416,54 @@ void test_repo_head__branch_birth(void)
 	git_signature_free(sig);
 
 }
+
+static size_t entrycount(git_repository *repo, const char *name)
+{
+	git_reflog *log;
+	size_t ret;
+
+	cl_git_pass(git_reflog_read(&log, repo, name));
+	ret = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	return ret;
+}
+
+void test_repo_head__symref_chain(void)
+{
+	git_signature *sig;
+	git_oid id;
+	git_tree *tree;
+	git_reference *ref;
+	const char *msg;
+	size_t nentries, nentries_master;
+
+	nentries = entrycount(repo, GIT_HEAD_FILE);
+
+	cl_git_pass(git_signature_now(&sig, "me", "foo@example.com"));
+
+	cl_git_pass(git_repository_head(&ref, repo));
+	cl_git_pass(git_reference_peel((git_object **) &tree, ref, GIT_OBJ_TREE));
+	git_reference_free(ref);
+
+	nentries_master = entrycount(repo, "refs/heads/master");
+
+	msg = "message 1";
+	cl_git_pass(git_reference_symbolic_create(&ref, repo, "refs/heads/master", "refs/heads/foo", 1, sig, msg));
+	git_reference_free(ref);
+
+	cl_assert_equal_i(0, entrycount(repo, "refs/heads/foo"));
+	cl_assert_equal_i(nentries, entrycount(repo, GIT_HEAD_FILE));
+	cl_assert_equal_i(nentries_master, entrycount(repo, "refs/heads/master"));
+
+	msg = "message 2";
+	cl_git_pass(git_commit_create(&id, repo, "HEAD", sig, sig, NULL, msg, tree, 0, NULL));
+	git_tree_free(tree);
+
+	cl_assert_equal_i(1, entrycount(repo, "refs/heads/foo"));
+	cl_assert_equal_i(nentries +1, entrycount(repo, GIT_HEAD_FILE));
+	cl_assert_equal_i(nentries_master, entrycount(repo, "refs/heads/master"));
+
+	git_signature_free(sig);
+
+}
-- 
cgit v1.2.3


From 05d47768caf6fec51fa85cb6275c9ba8324aead6 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@edwardthomson.com>
Date: Mon, 10 Mar 2014 22:30:41 -0800
Subject: Introduce git_merge_file for consumers

---
 include/git2/merge.h          | 169 +++++++++++++++++++++++++++
 src/checkout.c                |  43 +++----
 src/index.c                   |   8 +-
 src/index.h                   |   2 +
 src/merge.c                   |  55 ++++++---
 src/merge_file.c              | 263 +++++++++++++++++++++++++++++-------------
 src/merge_file.h              |  78 -------------
 tests/merge/files.c           | 175 ++++++++++++++++++++++++++++
 tests/merge/merge_helpers.h   |  43 +++++++
 tests/merge/trees/automerge.c |  22 ----
 tests/merge/trees/commits.c   |  11 --
 tests/merge/workdir/simple.c  |  41 -------
 tests/structinit/structinit.c |  10 ++
 13 files changed, 640 insertions(+), 280 deletions(-)
 create mode 100644 tests/merge/files.c

diff --git a/include/git2/merge.h b/include/git2/merge.h
index cfec32f4d..38e3408cc 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -22,6 +22,43 @@
  */
 GIT_BEGIN_DECL
 
+/**
+ * The file inputs to `git_merge_file`.  Callers should populate the
+ * `git_merge_file_input` structure with descriptions of the files in
+ * each side of the conflict for use in producing the merge file.
+ */
+typedef struct {
+	unsigned int version;
+
+	/** Pointer to the contents of the file. */
+	const char *ptr;
+
+	/** Size of the contents pointed to in `ptr`. */
+	size_t size;
+
+	/** File name of the conflicted file, or `NULL` to not merge the path. */
+	const char *path;
+
+	/** File mode of the conflicted file, or `0` to not merge the mode. */
+	unsigned int mode;
+} git_merge_file_input;
+
+#define GIT_MERGE_FILE_INPUT_VERSION 1
+#define GIT_MERGE_FILE_INPUT_INIT {GIT_MERGE_FILE_INPUT_VERSION}
+
+/**
+ * Initializes a `git_merge_file_input` with default values. Equivalent to
+ * creating an instance with GIT_MERGE_FILE_INPUT_INIT.
+ *
+ * @param opts the `git_merge_file_input` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_MERGE_FILE_INPUT_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_merge_file_init_input(
+	git_merge_file_input *opts,
+	int version);
+
 /**
  * Flags for `git_merge_tree` options.  A combination of these flags can be
  * passed in via the `flags` value in the `git_merge_tree_opts`.
@@ -71,6 +108,86 @@ typedef enum {
 	GIT_MERGE_FILE_FAVOR_UNION = 3,
 } git_merge_file_favor_t;
 
+typedef enum {
+	/* Defaults */
+	GIT_MERGE_FILE_DEFAULT = 0,
+
+	/* Create standard conflicted merge files */
+	GIT_MERGE_FILE_STYLE_MERGE = (1 << 0),
+
+	/* Create diff3-style files */
+	GIT_MERGE_FILE_STYLE_DIFF3 = (1 << 1),
+
+	/* Condense non-alphanumeric regions for simplified diff file */
+	GIT_MERGE_FILE_SIMPLIFY_ALNUM = (1 << 2),
+} git_merge_file_flags_t;
+
+typedef struct {
+	unsigned int version;
+
+	/**
+	 * Label for the ancestor file side of the conflict which will be prepended
+	 * to labels in diff3-format merge files.
+	 */
+	const char *ancestor_label;
+
+	/**
+	 * Label for our file side of the conflict which will be prepended
+	 * to labels in merge files.
+	 */
+	const char *our_label;
+
+	/**
+	 * Label for their file side of the conflict which will be prepended
+	 * to labels in merge files.
+	 */
+	const char *their_label;
+
+	/** The file to favor in region conflicts. */
+	git_merge_file_favor_t favor;
+
+	/** Merge file flags. */
+	git_merge_file_flags_t flags;
+} git_merge_file_options;
+
+#define GIT_MERGE_FILE_OPTIONS_VERSION 1
+#define GIT_MERGE_FILE_OPTIONS_INIT {GIT_MERGE_FILE_OPTIONS_VERSION}
+
+/**
+ * Initializes a `git_merge_file_options` with default values. Equivalent to
+ * creating an instance with GIT_MERGE_FILE_OPTIONS_INIT.
+ *
+ * @param opts the `git_merge_file_options` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_MERGE_FILE_OPTIONS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_merge_file_init_options(
+	git_merge_file_options *opts,
+	int version);
+
+typedef struct {
+	/**
+	 * True if the output was automerged, false if the output contains
+	 * conflict markers.
+	 */
+	unsigned int automergeable;
+
+	/**
+	 * The path that the resultant merge file should use, or NULL if a
+	 * filename conflict would occur.
+	 */
+	char *path;
+
+	/** The mode that the resultant merge file should use.  */
+	unsigned int mode;
+
+	/** The contents of the merge. */
+	unsigned char *ptr;
+
+	/** The length of the merge contents. */
+	size_t len;
+} git_merge_file_result;
 
 typedef struct {
 	unsigned int version;
@@ -268,6 +385,58 @@ GIT_EXTERN(int) git_merge_head_from_id(
 GIT_EXTERN(void) git_merge_head_free(
 	git_merge_head *head);
 
+/**
+ * Merge two files as they exist in the in-memory data structures, using
+ * the given common ancestor as the baseline, producing a
+ * `git_merge_file_result` that reflects the merge result.  The
+ * `git_merge_file_result` must be freed with `git_merge_file_result_free`.
+ *
+ * Note that this function does not reference a repository and any
+ * configuration must be passed as `git_merge_file_options`.
+ *
+ * @param out The git_merge_file_result to be filled in
+ * @param ancestor The contents of the ancestor file
+ * @param ours The contents of the file in "our" side
+ * @param theirs The contents of the file in "their" side
+ * @param opts The merge file options or `NULL` for defaults
+ * @return 0 on success or error code
+ */
+GIT_EXTERN(int) git_merge_file(
+	git_merge_file_result *out,
+	const git_merge_file_input *ancestor,
+	const git_merge_file_input *ours,
+	const git_merge_file_input *theirs,
+	const git_merge_file_options *opts);
+
+/**
+ * Merge two files as they exist in the index, using the given common
+ * ancestor as the baseline, producing a `git_merge_file_result` that
+ * reflects the merge result.  The `git_merge_file_result` must be freed with
+ * `git_merge_file_result_free`.
+ *
+ * @param out The git_merge_file_result to be filled in
+ * @param repo The repository
+ * @param ancestor The index entry for the ancestor file (stage level 1)
+ * @param our_path The index entry for our file (stage level 2)
+ * @param their_path The index entry for their file (stage level 3)
+ * @param opts The merge file options or NULL
+ * @return 0 on success or error code
+ */
+GIT_EXTERN(int) git_merge_file_from_index(
+	git_merge_file_result *out,
+	git_repository *repo,
+	const git_index_entry *ancestor,
+	const git_index_entry *ours,
+	const git_index_entry *theirs,
+	const git_merge_file_options *opts);
+
+/**
+ * Frees a `git_merge_file_result`.
+ *
+ * @param result The result to free or `NULL`
+ */
+GIT_EXTERN(void) git_merge_file_result_free(git_merge_file_result *result);
+
 /**
  * Merge two trees, producing a `git_index` that reflects the result of
  * the merge.  The index may be written as-is to the working directory
diff --git a/src/checkout.c b/src/checkout.c
index 5dd4ec71c..f882f3593 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -1681,29 +1681,20 @@ static int checkout_write_merge(
 {
 	git_buf our_label = GIT_BUF_INIT, their_label = GIT_BUF_INIT,
 		path_suffixed = GIT_BUF_INIT, path_workdir = GIT_BUF_INIT;
-	git_merge_file_options merge_file_opts = GIT_MERGE_FILE_OPTIONS_INIT;
-	git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT,
-		ours = GIT_MERGE_FILE_INPUT_INIT,
-		theirs = GIT_MERGE_FILE_INPUT_INIT;
-	git_merge_file_result result = GIT_MERGE_FILE_RESULT_INIT;
+	git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
+	git_merge_file_result result = {0};
 	git_filebuf output = GIT_FILEBUF_INIT;
 	int error = 0;
 
 	if (data->opts.checkout_strategy & GIT_CHECKOUT_CONFLICT_STYLE_DIFF3)
-		merge_file_opts.style = GIT_MERGE_FILE_STYLE_DIFF3;
-
-	if ((conflict->ancestor &&
-		(error = git_merge_file_input_from_index_entry(
-		&ancestor, data->repo, conflict->ancestor)) < 0) ||
-		(error = git_merge_file_input_from_index_entry(
-		&ours, data->repo, conflict->ours)) < 0 ||
-		(error = git_merge_file_input_from_index_entry(
-		&theirs, data->repo, conflict->theirs)) < 0)
-		goto done;
+		opts.flags |= GIT_MERGE_FILE_STYLE_DIFF3;
 
-	ancestor.label = data->opts.ancestor_label ? data->opts.ancestor_label : "ancestor";
-	ours.label = data->opts.our_label ? data->opts.our_label : "ours";
-	theirs.label = data->opts.their_label ? data->opts.their_label : "theirs";
+	opts.ancestor_label = data->opts.ancestor_label ?
+		data->opts.ancestor_label : "ancestor";
+	opts.our_label = data->opts.our_label ?
+		data->opts.our_label : "ours";
+	opts.their_label = data->opts.their_label ?
+		data->opts.their_label : "theirs";
 
 	/* If all the paths are identical, decorate the diff3 file with the branch
 	 * names.  Otherwise, append branch_name:path.
@@ -1712,16 +1703,17 @@ static int checkout_write_merge(
 		strcmp(conflict->ours->path, conflict->theirs->path) != 0) {
 
 		if ((error = conflict_entry_name(
-			&our_label, ours.label, conflict->ours->path)) < 0 ||
+			&our_label, opts.our_label, conflict->ours->path)) < 0 ||
 			(error = conflict_entry_name(
-			&their_label, theirs.label, conflict->theirs->path)) < 0)
+			&their_label, opts.their_label, conflict->theirs->path)) < 0)
 			goto done;
 
-		ours.label = git_buf_cstr(&our_label);
-		theirs.label = git_buf_cstr(&their_label);
+		opts.our_label = git_buf_cstr(&our_label);
+		opts.their_label = git_buf_cstr(&their_label);
 	}
 
-	if ((error = git_merge_files(&result, &ancestor, &ours, &theirs, &merge_file_opts)) < 0)
+	if ((error = git_merge_file_from_index(&result, data->repo,
+		conflict->ancestor, conflict->ours, conflict->theirs, &opts)) < 0)
 		goto done;
 
 	if (result.path == NULL || result.mode == 0) {
@@ -1739,7 +1731,7 @@ static int checkout_write_merge(
 
 	if ((error = git_futils_mkpath2file(path_workdir.ptr, 0755)) < 0 ||
 		(error = git_filebuf_open(&output, path_workdir.ptr, GIT_FILEBUF_DO_NOT_BUFFER, result.mode)) < 0 ||
-		(error = git_filebuf_write(&output, result.data, result.len)) < 0 ||
+		(error = git_filebuf_write(&output, result.ptr, result.len)) < 0 ||
 		(error = git_filebuf_commit(&output)) < 0)
 		goto done;
 
@@ -1747,9 +1739,6 @@ done:
 	git_buf_free(&our_label);
 	git_buf_free(&their_label);
 
-	git_merge_file_input_free(&ancestor);
-	git_merge_file_input_free(&ours);
-	git_merge_file_input_free(&theirs);
 	git_merge_file_result_free(&result);
 	git_buf_free(&path_workdir);
 	git_buf_free(&path_suffixed);
diff --git a/src/index.c b/src/index.c
index 0d7d50668..ea0815e4c 100644
--- a/src/index.c
+++ b/src/index.c
@@ -300,7 +300,7 @@ static void index_entry_free(git_index_entry *entry)
 	git__free(entry);
 }
 
-static unsigned int index_create_mode(unsigned int mode)
+unsigned int git_index__create_mode(unsigned int mode)
 {
 	if (S_ISLNK(mode))
 		return S_IFLNK;
@@ -320,9 +320,9 @@ static unsigned int index_merge_mode(
 
 	if (index->distrust_filemode && S_ISREG(mode))
 		return (existing && S_ISREG(existing->mode)) ?
-			existing->mode : index_create_mode(0666);
+			existing->mode : git_index__create_mode(0666);
 
-	return index_create_mode(mode);
+	return git_index__create_mode(mode);
 }
 
 void git_index__set_ignore_case(git_index *index, bool ignore_case)
@@ -619,7 +619,7 @@ void git_index_entry__init_from_stat(
 	entry->dev  = st->st_rdev;
 	entry->ino  = st->st_ino;
 	entry->mode = (!trust_mode && S_ISREG(st->st_mode)) ?
-		index_create_mode(0666) : index_create_mode(st->st_mode);
+		git_index__create_mode(0666) : git_index__create_mode(st->st_mode);
 	entry->uid  = st->st_uid;
 	entry->gid  = st->st_gid;
 	entry->file_size = st->st_size;
diff --git a/src/index.h b/src/index.h
index f88d110f7..259a3149f 100644
--- a/src/index.h
+++ b/src/index.h
@@ -60,4 +60,6 @@ extern int git_index__find(
 
 extern void git_index__set_ignore_case(git_index *index, bool ignore_case);
 
+extern unsigned int git_index__create_mode(unsigned int mode);
+
 #endif
diff --git a/src/merge.c b/src/merge.c
index 0b11c0da3..8a33edb13 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -539,11 +539,9 @@ static int merge_conflict_resolve_automerge(
 	const git_merge_diff *conflict,
 	unsigned int merge_file_favor)
 {
-	git_merge_file_options merge_file_opts = GIT_MERGE_FILE_OPTIONS_INIT;
-	git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT,
-		ours = GIT_MERGE_FILE_INPUT_INIT,
-		theirs = GIT_MERGE_FILE_INPUT_INIT;
-	git_merge_file_result result = GIT_MERGE_FILE_RESULT_INIT;
+	const git_index_entry *ancestor = NULL, *ours = NULL, *theirs = NULL;
+	git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
+	git_merge_file_result result = {0};
 	git_index_entry *index_entry;
 	git_odb *odb = NULL;
 	git_oid automerge_oid;
@@ -553,7 +551,9 @@ static int merge_conflict_resolve_automerge(
 
 	*resolved = 0;
 
-	merge_file_opts.favor = merge_file_favor;
+	if (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry) ||
+		!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry))
+		return 0;
 
 	/* Reject D/F conflicts */
 	if (conflict->type == GIT_MERGE_DIFF_DIRECTORY_FILE)
@@ -584,13 +584,19 @@ static int merge_conflict_resolve_automerge(
 	if (conflict->binary)
 		return 0;
 
+	ancestor = GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->ancestor_entry) ?
+		&conflict->ancestor_entry : NULL;
+	ours = GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry) ?
+		&conflict->our_entry : NULL;
+	theirs = GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry) ?
+		&conflict->their_entry : NULL;
+
+	opts.favor = merge_file_favor;
+
 	if ((error = git_repository_odb(&odb, diff_list->repo)) < 0 ||
-		(error = git_merge_file_input_from_index_entry(&ancestor, diff_list->repo, &conflict->ancestor_entry)) < 0 ||
-		(error = git_merge_file_input_from_index_entry(&ours, diff_list->repo, &conflict->our_entry)) < 0 ||
-		(error = git_merge_file_input_from_index_entry(&theirs, diff_list->repo, &conflict->their_entry)) < 0 ||
-		(error = git_merge_files(&result, &ancestor, &ours, &theirs, &merge_file_opts)) < 0 ||
+		(error = git_merge_file_from_index(&result, diff_list->repo, ancestor, ours, theirs, &opts)) < 0 ||
 		!result.automergeable ||
-		(error = git_odb_write(&automerge_oid, odb, result.data, result.len, GIT_OBJ_BLOB)) < 0)
+		(error = git_odb_write(&automerge_oid, odb, result.ptr, result.len, GIT_OBJ_BLOB)) < 0)
 		goto done;
 
 	if ((index_entry = git_pool_malloc(&diff_list->pool, sizeof(git_index_entry))) == NULL)
@@ -609,9 +615,6 @@ static int merge_conflict_resolve_automerge(
 	*resolved = 1;
 
 done:
-	git_merge_file_input_free(&ancestor);
-	git_merge_file_input_free(&ours);
-	git_merge_file_input_free(&theirs);
 	git_merge_file_result_free(&result);
 	git_odb_free(odb);
 
@@ -2793,3 +2796,27 @@ int git_merge_tree_init_opts(git_merge_tree_opts* opts, int version)
 		return 0;
 	}
 }
+
+int git_merge_file_init_input(git_merge_file_input *input, int version)
+{
+	if (version != GIT_MERGE_FILE_INPUT_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_file_input", version);
+		return -1;
+	} else {
+		git_merge_file_input i = GIT_MERGE_FILE_INPUT_INIT;
+		memcpy(input, &i, sizeof(i));
+		return 0;
+	}
+}
+
+int git_merge_file_init_options(git_merge_file_options *opts, int version)
+{
+	if (version != GIT_MERGE_FILE_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_file_options", version);
+		return -1;
+	} else {
+		git_merge_file_options o = GIT_MERGE_FILE_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/merge_file.c b/src/merge_file.c
index 986fbf9fe..fc45cbfbf 100644
--- a/src/merge_file.c
+++ b/src/merge_file.c
@@ -8,6 +8,9 @@
 #include "common.h"
 #include "repository.h"
 #include "merge_file.h"
+#include "posix.h"
+#include "fileops.h"
+#include "index.h"
 
 #include "git2/repository.h"
 #include "git2/object.h"
@@ -22,17 +25,17 @@ GIT_INLINE(const char *) merge_file_best_path(
 	const git_merge_file_input *ours,
 	const git_merge_file_input *theirs)
 {
-	if (!GIT_MERGE_FILE_SIDE_EXISTS(ancestor)) {
-		if (strcmp(ours->path, theirs->path) == 0)
+	if (!ancestor) {
+		if (ours && theirs && strcmp(ours->path, theirs->path) == 0)
 			return ours->path;
 
 		return NULL;
 	}
 
-	if (strcmp(ancestor->path, ours->path) == 0)
-		return theirs->path;
-	else if(strcmp(ancestor->path, theirs->path) == 0)
-		return ours->path;
+	if (ours && strcmp(ancestor->path, ours->path) == 0)
+		return theirs ? theirs->path : NULL;
+	else if(theirs && strcmp(ancestor->path, theirs->path) == 0)
+		return ours ? ours->path : NULL;
 
 	return NULL;
 }
@@ -47,136 +50,230 @@ GIT_INLINE(int) merge_file_best_mode(
 	 * assume executable.  Otherwise, if any mode changed from the ancestor,
 	 * use that one.
 	 */
-	if (!GIT_MERGE_FILE_SIDE_EXISTS(ancestor)) {
-		if (ours->mode == GIT_FILEMODE_BLOB_EXECUTABLE ||
-			theirs->mode == GIT_FILEMODE_BLOB_EXECUTABLE)
+	if (!ancestor) {
+		if ((ours && ours->mode == GIT_FILEMODE_BLOB_EXECUTABLE) ||
+			(theirs && theirs->mode == GIT_FILEMODE_BLOB_EXECUTABLE))
 			return GIT_FILEMODE_BLOB_EXECUTABLE;
 
 		return GIT_FILEMODE_BLOB;
-	}
+	} else if (ours && theirs) {
+		if (ancestor->mode == ours->mode)
+			return theirs->mode;
 
-	if (ancestor->mode == ours->mode)
-		return theirs->mode;
-	else if(ancestor->mode == theirs->mode)
 		return ours->mode;
+	}
 
 	return 0;
 }
 
-int git_merge_file_input_from_index_entry(
-	git_merge_file_input *input,
-	git_repository *repo,
+int git_merge_file__input_from_index(
+	git_merge_file_input *input_out,
+	git_odb_object **odb_object_out,
+	git_odb *odb,
 	const git_index_entry *entry)
 {
-	git_odb *odb = NULL;
 	int error = 0;
 
-	assert(input && repo && entry);
-
-	if (entry->mode == 0)
-		return 0;
+	assert(input_out && odb_object_out && odb && entry);
 
-	if ((error = git_repository_odb(&odb, repo)) < 0 ||
-		(error = git_odb_read(&input->odb_object, odb, &entry->id)) < 0)
+	if ((error = git_odb_read(odb_object_out, odb, &entry->id)) < 0)
 		goto done;
 
-	input->mode = entry->mode;
-	input->path = git__strdup(entry->path);
-	input->mmfile.size = git_odb_object_size(input->odb_object);
-	input->mmfile.ptr = (char *)git_odb_object_data(input->odb_object);
-
-	if (input->label == NULL)
-		input->label = entry->path;
+	input_out->path = entry->path;
+	input_out->mode = entry->mode;
+	input_out->ptr = (char *)git_odb_object_data(*odb_object_out);
+	input_out->size = git_odb_object_size(*odb_object_out);
 
 done:
-	git_odb_free(odb);
-
 	return error;
 }
 
-int git_merge_file_input_from_diff_file(
-	git_merge_file_input *input,
-	git_repository *repo,
-	const git_diff_file *file)
+static void merge_file_normalize_opts(
+	git_merge_file_options *out,
+	const git_merge_file_options *given_opts)
 {
-	git_odb *odb = NULL;
-	int error = 0;
-
-	assert(input && repo && file);
-
-	if (file->mode == 0)
-		return 0;
-
-	if ((error = git_repository_odb(&odb, repo)) < 0 ||
-		(error = git_odb_read(&input->odb_object, odb, &file->id)) < 0)
-		goto done;
-
-	input->mode = file->mode;
-	input->path = git__strdup(file->path);
-	input->mmfile.size = git_odb_object_size(input->odb_object);
-	input->mmfile.ptr = (char *)git_odb_object_data(input->odb_object);
-
-	if (input->label == NULL)
-		input->label = file->path;
-
-done:
-	git_odb_free(odb);
-
-	return error;
+	if (given_opts)
+		memcpy(out, given_opts, sizeof(git_merge_file_options));
+	else {
+		git_merge_file_options default_opts = GIT_MERGE_FILE_OPTIONS_INIT;
+		memcpy(out, &default_opts, sizeof(git_merge_file_options));
+	}
 }
 
-int git_merge_files(
+static int git_merge_file__from_inputs(
 	git_merge_file_result *out,
-	git_merge_file_input *ancestor,
-	git_merge_file_input *ours,
-	git_merge_file_input *theirs,
-	git_merge_file_options *opts)
+	const git_merge_file_input *ancestor,
+	const git_merge_file_input *ours,
+	const git_merge_file_input *theirs,
+	const git_merge_file_options *given_opts)
 {
 	xmparam_t xmparam;
+	mmfile_t ancestor_mmfile = {0}, our_mmfile = {0}, their_mmfile = {0};
 	mmbuffer_t mmbuffer;
+	git_merge_file_options options = GIT_MERGE_FILE_OPTIONS_INIT;
+	const char *path;
 	int xdl_result;
 	int error = 0;
 
-	assert(out && ancestor && ours && theirs);
-
 	memset(out, 0x0, sizeof(git_merge_file_result));
 
-	if (!GIT_MERGE_FILE_SIDE_EXISTS(ours) || !GIT_MERGE_FILE_SIDE_EXISTS(theirs))
-		return 0;
+	merge_file_normalize_opts(&options, given_opts);		
 
 	memset(&xmparam, 0x0, sizeof(xmparam_t));
-	xmparam.ancestor = ancestor->label;
-	xmparam.file1 = ours->label;
-	xmparam.file2 = theirs->label;
 
-	out->path = merge_file_best_path(ancestor, ours, theirs);
-	out->mode = merge_file_best_mode(ancestor, ours, theirs);
+	if (ancestor) {
+		xmparam.ancestor = (options.ancestor_label) ?
+			options.ancestor_label : ancestor->path;
+		ancestor_mmfile.ptr = (char *)ancestor->ptr;
+		ancestor_mmfile.size = ancestor->size;
+	}
 
-	if (opts && opts->favor == GIT_MERGE_FILE_FAVOR_OURS)
+	xmparam.file1 = (options.our_label) ?
+		options.our_label : ours->path;
+	our_mmfile.ptr = (char *)ours->ptr;
+	our_mmfile.size = ours->size;
+
+	xmparam.file2 = (options.their_label) ?
+		options.their_label : theirs->path;
+	their_mmfile.ptr = (char *)theirs->ptr;
+	their_mmfile.size = theirs->size;
+
+	if (options.favor == GIT_MERGE_FILE_FAVOR_OURS)
 		xmparam.favor = XDL_MERGE_FAVOR_OURS;
-	else if (opts && opts->favor == GIT_MERGE_FILE_FAVOR_THEIRS)
+	else if (options.favor == GIT_MERGE_FILE_FAVOR_THEIRS)
 		xmparam.favor = XDL_MERGE_FAVOR_THEIRS;
-	else if (opts && opts->favor == GIT_MERGE_FILE_FAVOR_UNION)
+	else if (options.favor == GIT_MERGE_FILE_FAVOR_UNION)
 		xmparam.favor = XDL_MERGE_FAVOR_UNION;
 
-	xmparam.level = 
-		(opts && (opts->flags & GIT_MERGE_FILE_SIMPLIFY_ALNUM)) ?
+	xmparam.level = (options.flags & GIT_MERGE_FILE_SIMPLIFY_ALNUM) ?
 		XDL_MERGE_ZEALOUS_ALNUM : XDL_MERGE_ZEALOUS;
 
-	if (opts && opts->style == GIT_MERGE_FILE_STYLE_DIFF3)
+	if (options.flags & GIT_MERGE_FILE_STYLE_DIFF3)
 		xmparam.style = XDL_MERGE_DIFF3;
 
-	if ((xdl_result = xdl_merge(&ancestor->mmfile, &ours->mmfile,
-		&theirs->mmfile, &xmparam, &mmbuffer)) < 0) {
+	if ((xdl_result = xdl_merge(&ancestor_mmfile, &our_mmfile,
+		&their_mmfile, &xmparam, &mmbuffer)) < 0) {
 		giterr_set(GITERR_MERGE, "Failed to merge files.");
 		error = -1;
 		goto done;
 	}
 
+	if ((path = merge_file_best_path(ancestor, ours, theirs)) != NULL &&
+		(out->path = strdup(path)) == NULL) {
+		error = -1;
+		goto done;
+	}
+
 	out->automergeable = (xdl_result == 0);
-	out->data = (unsigned char *)mmbuffer.ptr;
+	out->ptr = (unsigned char *)mmbuffer.ptr;
 	out->len = mmbuffer.size;
+	out->mode = merge_file_best_mode(ancestor, ours, theirs);
 
 done:
+	if (error < 0)
+		git_merge_file_result_free(out);
+
 	return error;
 }
+
+static git_merge_file_input *git_merge_file__normalize_inputs(
+	git_merge_file_input *out,
+	const git_merge_file_input *given)
+{
+	memcpy(out, given, sizeof(git_merge_file_input));
+
+	if (!out->path)
+		out->path = "file.txt";
+
+	if (!out->mode)
+		out->mode = 0100644;
+
+	return out;
+}
+
+int git_merge_file(
+	git_merge_file_result *out,
+	const git_merge_file_input *ancestor,
+	const git_merge_file_input *ours,
+	const git_merge_file_input *theirs,
+	const git_merge_file_options *options)
+{
+	git_merge_file_input inputs[3] = { {0} };
+
+	assert(out && ours && theirs);
+
+	memset(out, 0x0, sizeof(git_merge_file_result));
+
+	if (ancestor)
+		ancestor = git_merge_file__normalize_inputs(&inputs[0], ancestor);
+
+	ours = git_merge_file__normalize_inputs(&inputs[1], ours);
+	theirs = git_merge_file__normalize_inputs(&inputs[2], theirs);
+
+	return git_merge_file__from_inputs(out, ancestor, ours, theirs, options);
+}
+
+int git_merge_file_from_index(
+	git_merge_file_result *out,
+	git_repository *repo,
+	const git_index_entry *ancestor,
+	const git_index_entry *ours,
+	const git_index_entry *theirs,
+	const git_merge_file_options *options)
+{
+	git_merge_file_input inputs[3] = { {0} },
+		*ancestor_input = NULL, *our_input = NULL, *their_input = NULL;
+	git_odb *odb = NULL;
+	git_odb_object *odb_object[3] = { 0 };
+	int error = 0;
+
+	assert(out && repo && ours && theirs);
+
+	memset(out, 0x0, sizeof(git_merge_file_result));
+
+	if ((error = git_repository_odb(&odb, repo)) < 0)
+		goto done;
+
+	if (ancestor) {
+		if ((error = git_merge_file__input_from_index(
+			&inputs[0], &odb_object[0], odb, ancestor)) < 0)
+			goto done;
+
+		ancestor_input = &inputs[0];
+	}
+
+	if ((error = git_merge_file__input_from_index(
+		&inputs[1], &odb_object[1], odb, ours)) < 0)
+		goto done;
+
+	our_input = &inputs[1];
+
+	if ((error = git_merge_file__input_from_index(
+		&inputs[2], &odb_object[2], odb, theirs)) < 0)
+		goto done;
+
+	their_input = &inputs[2];
+
+	if ((error = git_merge_file__from_inputs(out,
+		ancestor_input, our_input, their_input, options)) < 0)
+		goto done;
+
+done:
+	git_odb_object_free(odb_object[0]);
+	git_odb_object_free(odb_object[1]);
+	git_odb_object_free(odb_object[2]);
+	git_odb_free(odb);
+
+	return error;
+}
+
+void git_merge_file_result_free(git_merge_file_result *result)
+{
+	if (result == NULL)
+		return;
+
+	git__free(result->path);
+
+	/* xdiff uses malloc() not git_malloc, so we use free(), not git_free() */
+	free(result->ptr);
+}
diff --git a/src/merge_file.h b/src/merge_file.h
index 332be490b..263391ee3 100644
--- a/src/merge_file.h
+++ b/src/merge_file.h
@@ -11,82 +11,4 @@
 
 #include "git2/merge.h"
 
-typedef struct {
-	const char *label;
-	char *path;
-	unsigned int mode;
-	mmfile_t mmfile;
-
-	git_odb_object *odb_object;
-} git_merge_file_input;
-
-#define GIT_MERGE_FILE_INPUT_INIT	{0}
-
-typedef struct {
-	bool automergeable;
-
-	const char *path;
-	int mode;
-
-	unsigned char *data;
-	size_t len;
-} git_merge_file_result;
-
-#define GIT_MERGE_FILE_RESULT_INIT	{0}
-
-typedef enum {
-	/* Condense non-alphanumeric regions for simplified diff file */
-	GIT_MERGE_FILE_SIMPLIFY_ALNUM = (1 << 0),
-} git_merge_file_flags_t;
-
-typedef enum {
-	/* Create standard conflicted merge files */
-	GIT_MERGE_FILE_STYLE_MERGE = 0,
-
-	/* Create diff3-style files */
-	GIT_MERGE_FILE_STYLE_DIFF3 = 1,
-} git_merge_file_style_t;
-
-typedef struct {
-	git_merge_file_favor_t favor;
-	git_merge_file_flags_t flags;
-	git_merge_file_style_t style;
-} git_merge_file_options;
-
-#define GIT_MERGE_FILE_OPTIONS_INIT	{0}
-
-int git_merge_file_input_from_index_entry(
-	git_merge_file_input *input,
-	git_repository *repo,
-	const git_index_entry *entry);
-
-int git_merge_file_input_from_diff_file(
-	git_merge_file_input *input,
-	git_repository *repo,
-	const git_diff_file *file);
-
-int git_merge_files(
-	git_merge_file_result *out,
-	git_merge_file_input *ancestor,
-	git_merge_file_input *ours,
-	git_merge_file_input *theirs,
-	git_merge_file_options *opts);
-
-GIT_INLINE(void) git_merge_file_input_free(git_merge_file_input *input)
-{
-	assert(input);
-	git__free(input->path);
-	git_odb_object_free(input->odb_object);
-}
-
-GIT_INLINE(void) git_merge_file_result_free(git_merge_file_result *filediff)
-{
-	if (filediff == NULL)
-		return;
-
-	/* xdiff uses malloc() not git_malloc, so we use free(), not git_free() */
-	if (filediff->data != NULL)
-		free(filediff->data);
-}
-
 #endif
diff --git a/tests/merge/files.c b/tests/merge/files.c
new file mode 100644
index 000000000..c377471e2
--- /dev/null
+++ b/tests/merge/files.c
@@ -0,0 +1,175 @@
+#include "clar_libgit2.h"
+#include "git2/repository.h"
+#include "git2/merge.h"
+#include "buffer.h"
+#include "merge.h"
+#include "merge_helpers.h"
+#include "refs.h"
+#include "fileops.h"
+
+#define TEST_REPO_PATH "merge-resolve"
+#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
+
+static git_repository *repo;
+static git_index *repo_index;
+
+// Fixture setup and teardown
+void test_merge_files__initialize(void)
+{
+	git_config *cfg;
+
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+	git_repository_index(&repo_index, repo);
+
+	/* Ensure that the user's merge.conflictstyle doesn't interfere */
+	cl_git_pass(git_repository_config(&cfg, repo));
+	cl_git_pass(git_config_set_string(cfg, "merge.conflictstyle", "merge"));
+	git_config_free(cfg);
+}
+
+void test_merge_files__cleanup(void)
+{
+	git_index_free(repo_index);
+	cl_git_sandbox_cleanup();
+}
+
+void test_merge_files__automerge_from_bufs(void)
+{
+	git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT,
+		ours = GIT_MERGE_FILE_INPUT_INIT,
+		theirs = GIT_MERGE_FILE_INPUT_INIT;
+	git_merge_file_result result = {0};
+	const char *expected = "Zero\n1\n2\n3\n4\n5\n6\n7\n8\n9\nTen\n";
+
+	ancestor.ptr = "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n";
+	ancestor.size = strlen(ancestor.ptr);
+	ancestor.path = "testfile.txt";
+	ancestor.mode = 0100755;
+
+	ours.ptr = "Zero\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n";
+	ours.size = strlen(ours.ptr);
+	ours.path = "testfile.txt";
+	ours.mode = 0100755;
+
+	theirs.ptr = "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\nTen\n";
+	theirs.size = strlen(theirs.ptr);
+	theirs.path = "testfile.txt";
+	theirs.mode = 0100755;
+
+	cl_git_pass(git_merge_file(&result, &ancestor, &ours, &theirs, 0));
+
+	cl_assert_equal_i(1, result.automergeable);
+
+	cl_assert_equal_s("testfile.txt", result.path);
+	cl_assert_equal_i(0100755, result.mode);
+
+	cl_assert_equal_i(strlen(expected), result.len);
+	cl_assert_equal_strn(expected, result.ptr, result.len);
+
+	git_merge_file_result_free(&result);
+}
+
+void test_merge_files__automerge_use_best_path_and_mode(void)
+{
+	git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT,
+		ours = GIT_MERGE_FILE_INPUT_INIT,
+		theirs = GIT_MERGE_FILE_INPUT_INIT;
+	git_merge_file_result result = {0};
+	const char *expected = "Zero\n1\n2\n3\n4\n5\n6\n7\n8\n9\nTen\n";
+
+	ancestor.ptr = "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n";
+	ancestor.size = strlen(ancestor.ptr);
+	ancestor.path = "testfile.txt";
+	ancestor.mode = 0100755;
+
+	ours.ptr = "Zero\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n";
+	ours.size = strlen(ours.ptr);
+	ours.path = "testfile.txt";
+	ours.mode = 0100644;
+
+	theirs.ptr = "0\n1\n2\n3\n4\n5\n6\n7\n8\n9\nTen\n";
+	theirs.size = strlen(theirs.ptr);
+	theirs.path = "theirs.txt";
+	theirs.mode = 0100755;
+
+	cl_git_pass(git_merge_file(&result, &ancestor, &ours, &theirs, 0));
+
+	cl_assert_equal_i(1, result.automergeable);
+
+	cl_assert_equal_s("theirs.txt", result.path);
+	cl_assert_equal_i(0100644, result.mode);
+
+	cl_assert_equal_i(strlen(expected), result.len);
+	cl_assert_equal_strn(expected, result.ptr, result.len);
+
+	git_merge_file_result_free(&result);
+}
+
+void test_merge_files__conflict_from_bufs(void)
+{
+	git_merge_file_input ancestor = GIT_MERGE_FILE_INPUT_INIT,
+		ours = GIT_MERGE_FILE_INPUT_INIT,
+		theirs = GIT_MERGE_FILE_INPUT_INIT;
+	git_merge_file_result result = {0};
+
+	const char *expected = "<<<<<<< testfile.txt\nAloha!\nOurs.\n=======\nHi!\nTheirs.\n>>>>>>> theirs.txt\n";
+	size_t expected_len = strlen(expected);
+
+	ancestor.ptr = "Hello!\nAncestor!\n";
+	ancestor.size = strlen(ancestor.ptr);
+	ancestor.path = "testfile.txt";
+	ancestor.mode = 0100755;
+
+	ours.ptr =  "Aloha!\nOurs.\n";
+	ours.size = strlen(ours.ptr);
+	ours.path = "testfile.txt";
+	ours.mode = 0100644;
+
+	theirs.ptr = "Hi!\nTheirs.\n";
+	theirs.size = strlen(theirs.ptr);
+	theirs.path = "theirs.txt";
+	theirs.mode = 0100755;
+
+	cl_git_pass(git_merge_file(&result, &ancestor, &ours, &theirs, NULL));
+
+	cl_assert_equal_i(0, result.automergeable);
+
+	cl_assert_equal_s("theirs.txt", result.path);
+	cl_assert_equal_i(0100644, result.mode);
+
+	cl_assert_equal_i(expected_len, result.len);
+	cl_assert_equal_strn(expected, result.ptr, expected_len);
+
+	git_merge_file_result_free(&result);
+}
+
+void test_merge_files__automerge_from_index(void)
+{
+	git_merge_file_result result = {0};
+	git_index_entry ancestor, ours, theirs;
+
+	git_oid_fromstr(&ancestor.id, "6212c31dab5e482247d7977e4f0dd3601decf13b");
+	ancestor.path = "automergeable.txt";
+	ancestor.mode = 0100644;
+
+	git_oid_fromstr(&ours.id, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf");
+	ours.path = "automergeable.txt";
+	ours.mode = 0100755;
+
+	git_oid_fromstr(&theirs.id, "058541fc37114bfc1dddf6bd6bffc7fae5c2e6fe");
+	theirs.path = "newname.txt";
+	theirs.mode = 0100644;
+
+	cl_git_pass(git_merge_file_from_index(&result, repo,
+		&ancestor, &ours, &theirs, 0));
+
+	cl_assert_equal_i(1, result.automergeable);
+
+	cl_assert_equal_s("newname.txt", result.path);
+	cl_assert_equal_i(0100755, result.mode);
+
+	cl_assert_equal_i(strlen(AUTOMERGEABLE_MERGED_FILE), result.len);
+	cl_assert_equal_strn(AUTOMERGEABLE_MERGED_FILE, result.ptr, result.len);
+
+	git_merge_file_result_free(&result);
+}
diff --git a/tests/merge/merge_helpers.h b/tests/merge/merge_helpers.h
index 3f53abc7c..63d1cb7a9 100644
--- a/tests/merge/merge_helpers.h
+++ b/tests/merge/merge_helpers.h
@@ -4,6 +4,49 @@
 #include "merge.h"
 #include "git2/merge.h"
 
+#define AUTOMERGEABLE_MERGED_FILE \
+	"this file is changed in master\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is automergeable\n" \
+	"this file is changed in branch\n"
+
+#define AUTOMERGEABLE_MERGED_FILE_CRLF \
+	"this file is changed in master\r\n" \
+	"this file is automergeable\r\n" \
+	"this file is automergeable\r\n" \
+	"this file is automergeable\r\n" \
+	"this file is automergeable\r\n" \
+	"this file is automergeable\r\n" \
+	"this file is automergeable\r\n" \
+	"this file is automergeable\r\n" \
+	"this file is changed in branch\r\n"
+
+#define CONFLICTING_MERGE_FILE \
+	"<<<<<<< HEAD\n" \
+	"this file is changed in master and branch\n" \
+	"=======\n" \
+	"this file is changed in branch and master\n" \
+	">>>>>>> 7cb63eed597130ba4abb87b3e544b85021905520\n"
+
+#define CONFLICTING_DIFF3_FILE \
+	"<<<<<<< HEAD\n" \
+	"this file is changed in master and branch\n" \
+	"||||||| initial\n" \
+	"this file is a conflict\n" \
+	"=======\n" \
+	"this file is changed in branch and master\n" \
+	">>>>>>> 7cb63eed597130ba4abb87b3e544b85021905520\n"
+
+#define CONFLICTING_UNION_FILE \
+	"this file is changed in master and branch\n" \
+	"this file is changed in branch and master\n"
+
+
 struct merge_index_entry {
 	uint16_t mode;
 	char oid_str[41];
diff --git a/tests/merge/trees/automerge.c b/tests/merge/trees/automerge.c
index bd710e6d8..79069d81d 100644
--- a/tests/merge/trees/automerge.c
+++ b/tests/merge/trees/automerge.c
@@ -54,28 +54,6 @@ static git_repository *repo;
 	  "", \
 	  "5c3b68a71fc4fa5d362fd3875e53137c6a5ab7a5" }
 
-#define AUTOMERGEABLE_MERGED_FILE \
-	"this file is changed in master\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is changed in branch\n"
-
-#define AUTOMERGEABLE_MERGED_FILE_CRLF \
-	"this file is changed in master\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is changed in branch\r\n"
-
 // Fixture setup and teardown
 void test_merge_trees_automerge__initialize(void)
 {
diff --git a/tests/merge/trees/commits.c b/tests/merge/trees/commits.c
index eeb30dae5..08caf804f 100644
--- a/tests/merge/trees/commits.c
+++ b/tests/merge/trees/commits.c
@@ -8,17 +8,6 @@ static git_repository *repo;
 
 #define TEST_REPO_PATH "merge-resolve"
 
-#define AUTOMERGEABLE_MERGED_FILE \
-	"this file is changed in master\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is changed in branch\n"
-
 void test_merge_trees_commits__initialize(void)
 {
 	repo = cl_git_sandbox_init(TEST_REPO_PATH);
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index a9a63651c..07c60c5fa 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -71,47 +71,6 @@ static git_index *repo_index;
 	  "", \
 	  "5c3b68a71fc4fa5d362fd3875e53137c6a5ab7a5" }
 
-#define AUTOMERGEABLE_MERGED_FILE \
-	"this file is changed in master\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is automergeable\n" \
-	"this file is changed in branch\n"
-
-#define AUTOMERGEABLE_MERGED_FILE_CRLF \
-	"this file is changed in master\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is automergeable\r\n" \
-	"this file is changed in branch\r\n"
-
-#define CONFLICTING_MERGE_FILE \
-	"<<<<<<< HEAD\n" \
-	"this file is changed in master and branch\n" \
-	"=======\n" \
-	"this file is changed in branch and master\n" \
-	">>>>>>> 7cb63eed597130ba4abb87b3e544b85021905520\n"
-
-#define CONFLICTING_DIFF3_FILE \
-	"<<<<<<< HEAD\n" \
-	"this file is changed in master and branch\n" \
-	"||||||| initial\n" \
-	"this file is a conflict\n" \
-	"=======\n" \
-	"this file is changed in branch and master\n" \
-	">>>>>>> 7cb63eed597130ba4abb87b3e544b85021905520\n"
-
-#define CONFLICTING_UNION_FILE \
-	"this file is changed in master and branch\n" \
-	"this file is changed in branch and master\n"
 
 // Fixture setup and teardown
 void test_merge_workdir_simple__initialize(void)
diff --git a/tests/structinit/structinit.c b/tests/structinit/structinit.c
index 1df970d49..61fe8c786 100644
--- a/tests/structinit/structinit.c
+++ b/tests/structinit/structinit.c
@@ -65,6 +65,16 @@ void test_structinit_structinit__compare(void)
 		git_diff_find_options, GIT_DIFF_FIND_OPTIONS_VERSION, \
 		GIT_DIFF_FIND_OPTIONS_INIT, git_diff_find_init_options);
 
+	/* merge_file_input */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_merge_file_input, GIT_MERGE_FILE_INPUT_VERSION, \
+		GIT_MERGE_FILE_INPUT_INIT, git_merge_file_init_input);
+
+	/* merge_file */
+	CHECK_MACRO_FUNC_INIT_EQUAL( \
+		git_merge_file_options, GIT_MERGE_FILE_OPTIONS_VERSION, \
+		GIT_MERGE_FILE_OPTIONS_INIT, git_merge_file_init_options);
+
 	/* merge_tree */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
 		git_merge_tree_opts, GIT_MERGE_TREE_OPTS_VERSION, \
-- 
cgit v1.2.3


From ccb308273a8662a9692849115a929bd1a74a15f7 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 11 Mar 2014 17:19:35 -0700
Subject: Add `git_merge_status` to provide info about an upcoming merge

---
 include/git2/merge.h                               |  40 ++++++
 src/merge.c                                        |  83 ++++++++++--
 tests/merge/workdir/fastforward.c                  | 148 ---------------------
 tests/merge/workdir/status.c                       |  89 +++++++++++++
 .../merge-resolve/.gitted/refs/heads/previous      |   1 +
 5 files changed, 204 insertions(+), 157 deletions(-)
 delete mode 100644 tests/merge/workdir/fastforward.c
 create mode 100644 tests/merge/workdir/status.c
 create mode 100644 tests/resources/merge-resolve/.gitted/refs/heads/previous

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 38e3408cc..1d30a5a16 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -234,6 +234,46 @@ GIT_EXTERN(int) git_merge_tree_init_opts(
 	git_merge_tree_opts* opts,
 	int version);
 
+/**
+ * The results of `git_merge_status` indicate the state of a merge scenario.
+ */
+typedef enum {
+	/**
+	 * A "normal" merge; both HEAD and the given merge input have diverged
+	 * from their common ancestor.  The divergent commits must be merged.
+	 */
+	GIT_MERGE_STATUS_NORMAL = 0,
+
+	/**
+	 * The repository is already up-to-date and no merge needs to be
+	 * performed.  The given merge input already exists as a parent of HEAD.
+	 */
+	GIT_MERGE_STATUS_UP_TO_DATE = (1 << 0),
+
+	/**
+	 * The given merge input is a fast-forward from HEAD and no merge
+	 * needs to be performed.  Instead, the client can check out the
+	 * given merge input.
+	 */
+	GIT_MERGE_STATUS_FASTFORWARD = (1 << 1),
+} git_merge_status_t;
+
+/**
+ * Determine the status of the merge between the given branch(es) and the
+ * HEAD of the repository.
+ *
+ * @param status_out status enumeration that the result is written into
+ * @param repo the repository to merge
+ * @param their_heads the heads to merge into
+ * @param their_heads_len the number of heads to merge
+ * @return 0 on success or error code
+ */
+GIT_EXTERN(int) git_merge_status(
+	git_merge_status_t *status_out,
+	git_repository *repo,
+	const git_merge_head **their_heads,
+	size_t their_heads_len);
+
 /**
  * Option flags for `git_merge`.
  */
diff --git a/src/merge.c b/src/merge.c
index 8a33edb13..cdc1921ce 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2497,6 +2497,79 @@ static int merge_state_cleanup(git_repository *repo)
 	return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
 }
 
+static int merge_heads(
+	git_merge_head **ancestor_head_out,
+	git_merge_head **our_head_out,
+	git_repository *repo,
+	const git_merge_head **their_heads,
+	size_t their_heads_len)
+{
+	git_merge_head *ancestor_head = NULL, *our_head = NULL;
+	git_reference *our_ref = NULL;
+	int error = 0;
+
+	*ancestor_head_out = NULL;
+	*our_head_out = NULL;
+
+	if ((error = git_repository__ensure_not_bare(repo, "merge")) < 0)
+		goto done;
+
+	if ((error = git_reference_lookup(&our_ref, repo, GIT_HEAD_FILE)) < 0 ||
+		(error = git_merge_head_from_ref(&our_head, repo, our_ref)) < 0)
+		goto done;
+
+	if ((error = merge_ancestor_head(&ancestor_head, repo, our_head, their_heads, their_heads_len)) < 0) {
+		if (error != GIT_ENOTFOUND)
+			goto done;
+
+		giterr_clear();
+		error = 0;
+	}
+
+	*ancestor_head_out = ancestor_head;
+	*our_head_out = our_head;
+
+done:
+	if (error < 0) {
+		git_merge_head_free(ancestor_head);
+		git_merge_head_free(our_head);
+	}
+
+	git_reference_free(our_ref);
+
+	return error;
+}
+
+int git_merge_status(
+	git_merge_status_t *out,
+	git_repository *repo,
+	const git_merge_head **their_heads,
+	size_t their_heads_len)
+{
+	git_merge_head *ancestor_head = NULL, *our_head = NULL;
+	int error;
+
+	assert(out && repo && their_heads);
+
+	*out = GIT_MERGE_STATUS_NORMAL;
+
+	if ((error = merge_heads(&ancestor_head, &our_head, repo, their_heads, their_heads_len)) < 0)
+		goto done;
+
+	if (their_heads_len == 1 && ancestor_head != NULL) {
+		/* We're up-to-date if we're trying to merge our own common ancestor. */
+		if (git_oid_equal(&ancestor_head->oid, &their_heads[0]->oid))
+			*out = GIT_MERGE_STATUS_UP_TO_DATE;
+
+		/* We're fastforwardable if we're our own common ancestor. */
+		else if (git_oid_equal(&ancestor_head->oid, &our_head->oid))
+			*out = GIT_MERGE_STATUS_FASTFORWARD;
+	}
+
+done:
+	return error;
+}
+
 int git_merge(
 	git_merge_result **out,
 	git_repository *repo,
@@ -2530,15 +2603,7 @@ int git_merge(
 	their_trees = git__calloc(their_heads_len, sizeof(git_tree *));
 	GITERR_CHECK_ALLOC(their_trees);
 
-	if ((error = git_repository__ensure_not_bare(repo, "merge")) < 0)
-		goto on_error;
-
-	if ((error = git_reference_lookup(&our_ref, repo, GIT_HEAD_FILE)) < 0 ||
-		(error = git_merge_head_from_ref(&our_head, repo, our_ref)) < 0)
-		goto on_error;
-
-	if ((error = merge_ancestor_head(&ancestor_head, repo, our_head, their_heads, their_heads_len)) < 0 &&
-		error != GIT_ENOTFOUND)
+	if ((error = merge_heads(&ancestor_head, &our_head, repo, their_heads, their_heads_len)) < 0)
 		goto on_error;
 
 	if ((error = merge_normalize_opts(repo, &opts, given_opts, ancestor_head, our_head, their_heads_len, their_heads)) < 0)
diff --git a/tests/merge/workdir/fastforward.c b/tests/merge/workdir/fastforward.c
deleted file mode 100644
index d6b31481f..000000000
--- a/tests/merge/workdir/fastforward.c
+++ /dev/null
@@ -1,148 +0,0 @@
-#include "clar_libgit2.h"
-#include "git2/repository.h"
-#include "git2/merge.h"
-#include "git2/sys/index.h"
-#include "merge.h"
-#include "../merge_helpers.h"
-#include "refs.h"
-
-static git_repository *repo;
-static git_index *repo_index;
-
-#define TEST_REPO_PATH "merge-resolve"
-#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
-
-#define THEIRS_FASTFORWARD_BRANCH	"ff_branch"
-#define THEIRS_FASTFORWARD_ID		"fd89f8cffb663ac89095a0f9764902e93ceaca6a"
-
-#define THEIRS_NOFASTFORWARD_BRANCH	"branch"
-#define THEIRS_NOFASTFORWARD_ID	"7cb63eed597130ba4abb87b3e544b85021905520"
-
-
-// Fixture setup and teardown
-void test_merge_workdir_fastforward__initialize(void)
-{
-	repo = cl_git_sandbox_init(TEST_REPO_PATH);
-	git_repository_index(&repo_index, repo);
-}
-
-void test_merge_workdir_fastforward__cleanup(void)
-{
-	git_index_free(repo_index);
-	cl_git_sandbox_cleanup();
-}
-
-static git_merge_result *merge_fastforward_branch(int flags)
-{
-	git_reference *their_ref;
-	git_merge_head *their_heads[1];
-	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
-
-	opts.merge_flags = flags;
-
-	cl_git_pass(git_reference_lookup(&their_ref, repo, GIT_REFS_HEADS_DIR THEIRS_FASTFORWARD_BRANCH));
-	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, their_ref));
-
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
-
-	git_merge_head_free(their_heads[0]);
-	git_reference_free(their_ref);
-
-	return result;
-}
-
-void test_merge_workdir_fastforward__fastforward(void)
-{
-	git_merge_result *result;
-	git_oid expected, ff_oid;
-
-	cl_git_pass(git_oid_fromstr(&expected, THEIRS_FASTFORWARD_ID));
-
-	cl_assert(result = merge_fastforward_branch(0));
-	cl_assert(git_merge_result_is_fastforward(result));
-	cl_git_pass(git_merge_result_fastforward_id(&ff_oid, result));
-	cl_assert(git_oid_cmp(&ff_oid, &expected) == 0);
-
-	git_merge_result_free(result);
-}
-
-void test_merge_workdir_fastforward__fastforward_only(void)
-{
-	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
-	git_reference *their_ref;
-	git_merge_head *their_head;
-	int error;
-
-	opts.merge_flags = GIT_MERGE_FASTFORWARD_ONLY;
-
-	cl_git_pass(git_reference_lookup(&their_ref, repo, GIT_REFS_HEADS_DIR THEIRS_NOFASTFORWARD_BRANCH));
-	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
-
-	cl_git_fail((error = git_merge(&result, repo, (const git_merge_head **)&their_head, 1, &opts)));
-	cl_assert(error == GIT_ENONFASTFORWARD);
-
-	git_merge_head_free(their_head);
-	git_reference_free(their_ref);
-}
-
-void test_merge_workdir_fastforward__no_fastforward(void)
-{
-	git_merge_result *result;
-
-	struct merge_index_entry merge_index_entries[] = {
-		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0, "added-in-master.txt" },
-		{ 0100644, "ee3fa1b8c00aff7fe02065fdb50864bb0d932ccf", 0, "automergeable.txt" },
-		{ 0100644, "ab6c44a2e84492ad4b41bb6bac87353e9d02ac8b", 0, "changed-in-branch.txt" },
-		{ 0100644, "bd9cb4cd0a770cb9adcb5fce212142ef40ea1c35", 0, "changed-in-master.txt" },
-		{ 0100644, "4e886e602529caa9ab11d71f86634bd1b6e0de10", 0, "conflicting.txt" },
-		{ 0100644, "364bbe4ce80c7bd31e6307dce77d46e3e1759fb3", 0, "new-in-ff.txt" },
-		{ 0100644, "dfe3f22baa1f6fce5447901c3086bae368de6bdd", 0, "removed-in-branch.txt" },
-		{ 0100644, "c8f06f2e3bb2964174677e91f0abead0e43c9e5d", 0, "unchanged.txt" },
-	};
-
-	cl_assert(result = merge_fastforward_branch(GIT_MERGE_NO_FASTFORWARD));
-	cl_assert(!git_merge_result_is_fastforward(result));
-
-	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
-	cl_assert(git_index_reuc_entrycount(repo_index) == 0);
-
-	git_merge_result_free(result);
-}
-
-void test_merge_workdir_fastforward__uptodate(void)
-{
-	git_reference *their_ref;
-	git_merge_head *their_heads[1];
-	git_merge_result *result;
-
-	cl_git_pass(git_reference_lookup(&their_ref, repo, GIT_HEAD_FILE));
-	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, their_ref));
-
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, NULL));
-
-	cl_assert(git_merge_result_is_uptodate(result));
-
-	git_merge_head_free(their_heads[0]);
-	git_reference_free(their_ref);
-	git_merge_result_free(result);
-}
-
-void test_merge_workdir_fastforward__uptodate_merging_prev_commit(void)
-{
-	git_oid their_oid;
-	git_merge_head *their_heads[1];
-	git_merge_result *result;
-
-	cl_git_pass(git_oid_fromstr(&their_oid, "c607fc30883e335def28cd686b51f6cfa02b06ec"));
-	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oid));
-
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, NULL));
-
-	cl_assert(git_merge_result_is_uptodate(result));
-
-	git_merge_head_free(their_heads[0]);
-	git_merge_result_free(result);
-}
-
diff --git a/tests/merge/workdir/status.c b/tests/merge/workdir/status.c
new file mode 100644
index 000000000..589299eff
--- /dev/null
+++ b/tests/merge/workdir/status.c
@@ -0,0 +1,89 @@
+#include "clar_libgit2.h"
+#include "git2/repository.h"
+#include "git2/merge.h"
+#include "git2/sys/index.h"
+#include "merge.h"
+#include "../merge_helpers.h"
+#include "refs.h"
+
+static git_repository *repo;
+static git_index *repo_index;
+
+#define TEST_REPO_PATH "merge-resolve"
+#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
+
+#define UPTODATE_BRANCH			"master"
+#define PREVIOUS_BRANCH			"previous"
+
+#define FASTFORWARD_BRANCH		"ff_branch"
+#define FASTFORWARD_ID			"fd89f8cffb663ac89095a0f9764902e93ceaca6a"
+
+#define NOFASTFORWARD_BRANCH	"branch"
+#define NOFASTFORWARD_ID		"7cb63eed597130ba4abb87b3e544b85021905520"
+
+
+// Fixture setup and teardown
+void test_merge_workdir_status__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+	git_repository_index(&repo_index, repo);
+}
+
+void test_merge_workdir_status__cleanup(void)
+{
+	git_index_free(repo_index);
+	cl_git_sandbox_cleanup();
+}
+
+static git_status_t status_from_branch(const char *branchname)
+{
+	git_buf refname = GIT_BUF_INIT;
+	git_reference *their_ref;
+	git_merge_head *their_heads[1];
+	git_status_t status;
+
+	git_buf_printf(&refname, "%s%s", GIT_REFS_HEADS_DIR, branchname);
+
+	cl_git_pass(git_reference_lookup(&their_ref, repo, git_buf_cstr(&refname)));
+	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, their_ref));
+
+	cl_git_pass(git_merge_status(&status, repo, their_heads, 1));
+
+	git_buf_free(&refname);
+	git_merge_head_free(their_heads[0]);
+	git_reference_free(their_ref);
+
+	return status;
+}
+
+void test_merge_workdir_status__fastforward(void)
+{
+	git_merge_status_t status;
+
+	status = status_from_branch(FASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_STATUS_FASTFORWARD, status);
+}
+
+void test_merge_workdir_status__no_fastforward(void)
+{
+	git_merge_status_t status;
+
+	status = status_from_branch(NOFASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_STATUS_NORMAL, status);
+}
+
+void test_merge_workdir_status__uptodate(void)
+{
+	git_merge_status_t status;
+
+	status = status_from_branch(UPTODATE_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_STATUS_UP_TO_DATE, status);
+}
+
+void test_merge_workdir_status__uptodate_merging_prev_commit(void)
+{
+	git_merge_status_t status;
+
+	status = status_from_branch(PREVIOUS_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_STATUS_UP_TO_DATE, status);
+}
diff --git a/tests/resources/merge-resolve/.gitted/refs/heads/previous b/tests/resources/merge-resolve/.gitted/refs/heads/previous
new file mode 100644
index 000000000..7bc1a8d15
--- /dev/null
+++ b/tests/resources/merge-resolve/.gitted/refs/heads/previous
@@ -0,0 +1 @@
+c607fc30883e335def28cd686b51f6cfa02b06ec
-- 
cgit v1.2.3


From 1c0b6a38bacb54de300d936338d4adb04a9b311f Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 11 Mar 2014 17:58:10 -0700
Subject: Remove fastforward / uptodate from `git_merge`

---
 include/git2/merge.h        |  28 +---------
 src/merge.c                 | 105 ++++++++-----------------------------
 src/merge.h                 |   5 +-
 tests/merge/workdir/setup.c | 124 +++++++++++++++++---------------------------
 4 files changed, 73 insertions(+), 189 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 1d30a5a16..e20025b7a 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -274,35 +274,9 @@ GIT_EXTERN(int) git_merge_status(
 	const git_merge_head **their_heads,
 	size_t their_heads_len);
 
-/**
- * Option flags for `git_merge`.
- */
-typedef enum {
-	/**
-	 * The default behavior is to allow fast-forwards, returning
-	 * immediately with the commit ID to fast-forward to.
-	 */
-	GIT_MERGE_DEFAULT = 0,
-
-	/**
-	 * Do not fast-forward; perform a merge and prepare a merge result even
-	 * if the inputs are eligible for fast-forwarding.
-	 */
-	GIT_MERGE_NO_FASTFORWARD = 1,
-
-	/**
-	 * Ensure that the inputs are eligible for fast-forwarding, error if
-	 * a merge needs to be performed.
-	 */
-	GIT_MERGE_FASTFORWARD_ONLY = 2,
-} git_merge_flags_t;
-
 typedef struct {
 	unsigned int version;
 
-	/** Options for handling the commit-level merge. */
-	git_merge_flags_t merge_flags;
-
 	/** Options for handling the merges of individual files. */
 	git_merge_tree_opts merge_tree_opts;
 
@@ -311,7 +285,7 @@ typedef struct {
 } git_merge_opts;
 
 #define GIT_MERGE_OPTS_VERSION 1
-#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
+#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
 
 /**
  * Initializes a `git_merge_opts` with default values. Equivalent to creating
diff --git a/src/merge.c b/src/merge.c
index cdc1921ce..b7f043aca 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -1774,31 +1774,20 @@ cleanup:
 	return error;
 }
 
-static int write_merge_mode(git_repository *repo, unsigned int flags)
+static int write_merge_mode(git_repository *repo)
 {
 	git_filebuf file = GIT_FILEBUF_INIT;
 	git_buf file_path = GIT_BUF_INIT;
 	int error = 0;
 
-	/* For future expansion */
-	GIT_UNUSED(flags);
-
 	assert(repo);
 
 	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_MERGE_MODE_FILE)) < 0 ||
 		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_MERGE_FILE_MODE)) < 0)
 		goto cleanup;
 
-	/*
-	 * no-ff is the only thing allowed here at present.  One would
-	 * presume they would be space-delimited when there are more, but
-	 * this needs to be revisited.
-	 */
-
-	if (flags & GIT_MERGE_NO_FASTFORWARD) {
-		if ((error = git_filebuf_write(&file, "no-ff", 5)) < 0)
-			goto cleanup;
-	}
+	if ((error = git_filebuf_write(&file, "no-ff", 5)) < 0)
+		goto cleanup;
 
 	error = git_filebuf_commit(&file);
 
@@ -2114,6 +2103,25 @@ cleanup:
 	return error;
 }
 
+int git_merge__setup(
+	git_repository *repo,
+	const git_merge_head *our_head,
+	const git_merge_head *heads[],
+	size_t heads_len)
+{
+	int error = 0;
+
+	assert (repo && our_head && heads);
+
+	if ((error = write_orig_head(repo, our_head)) == 0 &&
+		(error = write_merge_head(repo, heads, heads_len)) == 0 &&
+		(error = write_merge_mode(repo)) == 0) {
+		error = write_merge_msg(repo, heads, heads_len);
+	}
+
+	return error;
+}
+
 /* Merge branches */
 
 static int merge_ancestor_head(
@@ -2147,37 +2155,6 @@ on_error:
 	return error;
 }
 
-GIT_INLINE(bool) merge_check_uptodate(
-	git_merge_result *result,
-	const git_merge_head *ancestor_head,
-	const git_merge_head *their_head)
-{
-	if (git_oid_cmp(&ancestor_head->oid, &their_head->oid) == 0) {
-		result->is_uptodate = 1;
-		return true;
-	}
-
-	return false;
-}
-
-GIT_INLINE(bool) merge_check_fastforward(
-	git_merge_result *result,
-	const git_merge_head *ancestor_head,
-	const git_merge_head *our_head,
-	const git_merge_head *their_head,
-	unsigned int flags)
-{
-	if ((flags & GIT_MERGE_NO_FASTFORWARD) == 0 &&
-		git_oid_cmp(&ancestor_head->oid, &our_head->oid) == 0) {
-		result->is_fastforward = 1;
-		git_oid_cpy(&result->fastforward_oid, &their_head->oid);
-
-		return true;
-	}
-
-	return false;
-}
-
 const char *merge_their_label(const char *branchname)
 {
 	const char *slash;
@@ -2609,24 +2586,8 @@ int git_merge(
 	if ((error = merge_normalize_opts(repo, &opts, given_opts, ancestor_head, our_head, their_heads_len, their_heads)) < 0)
 		goto on_error;
 
-	if (their_heads_len == 1 &&
-		ancestor_head != NULL &&
-		(merge_check_uptodate(result, ancestor_head, their_heads[0]) ||
-		merge_check_fastforward(result, ancestor_head, our_head, their_heads[0], opts.merge_flags))) {
-		*out = result;
-		goto done;
-	}
-
-	/* If FASTFORWARD_ONLY is specified, fail. */
-	if ((opts.merge_flags & GIT_MERGE_FASTFORWARD_ONLY) ==
-		GIT_MERGE_FASTFORWARD_ONLY) {
-		giterr_set(GITERR_MERGE, "Not a fast-forward.");
-		error = GIT_ENONFASTFORWARD;
-		goto on_error;
-	}
-
 	/* Write the merge files to the repository. */
-	if ((error = git_merge__setup(repo, our_head, their_heads, their_heads_len, opts.merge_flags)) < 0)
+	if ((error = git_merge__setup(repo, our_head, their_heads, their_heads_len)) < 0)
 		goto on_error;
 
 	if (ancestor_head != NULL &&
@@ -2679,26 +2640,6 @@ done:
 	return error;
 }
 
-int git_merge__setup(
-	git_repository *repo,
-	const git_merge_head *our_head,
-	const git_merge_head *heads[],
-	size_t heads_len,
-	unsigned int flags)
-{
-	int error = 0;
-
-	assert (repo && our_head && heads);
-
-	if ((error = write_orig_head(repo, our_head)) == 0 &&
-		(error = write_merge_head(repo, heads, heads_len)) == 0 &&
-		(error = write_merge_mode(repo, flags)) == 0) {
-		error = write_merge_msg(repo, heads, heads_len);
-	}
-
-	return error;
-}
-
 /* Merge result data */
 
 int git_merge_result_is_uptodate(git_merge_result *merge_result)
diff --git a/src/merge.h b/src/merge.h
index dda023528..1bd202096 100644
--- a/src/merge.h
+++ b/src/merge.h
@@ -156,9 +156,8 @@ void git_merge_diff_list__free(git_merge_diff_list *diff_list);
 int git_merge__setup(
 	git_repository *repo,
 	const git_merge_head *our_head,
-	const git_merge_head *their_heads[],
-	size_t their_heads_len,
-	unsigned int flags);
+	const git_merge_head *heads[],
+	size_t heads_len);
 
 int git_merge__indexes(git_repository *repo, git_index *index_new);
 
diff --git a/tests/merge/workdir/setup.c b/tests/merge/workdir/setup.c
index 05f994ecd..d23e4547a 100644
--- a/tests/merge/workdir/setup.c
+++ b/tests/merge/workdir/setup.c
@@ -71,7 +71,7 @@ static void write_file_contents(const char *filename, const char *output)
 	git_buf_free(&file_path_buf);
 }
 
-/* git merge octo1 */
+/* git merge --no-ff octo1 */
 void test_merge_workdir_setup__one_branch(void)
 {
 	git_oid our_oid;
@@ -84,33 +84,7 @@ void test_merge_workdir_setup__one_branch(void)
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
 	
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1, 0));
-
-	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n"));
-	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
-	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branch '" OCTO1_BRANCH "'\n"));
-
-	git_reference_free(octo1_ref);
-	
-	git_merge_head_free(our_head);
-	git_merge_head_free(their_heads[0]);
-}
-
-/* git merge --no-ff octo1 */
-void test_merge_workdir_setup__no_fastforward(void)
-{
-	git_oid our_oid;
-	git_reference *octo1_ref;
-	git_merge_head *our_head, *their_heads[1];
-
-	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
-	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
-
-	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
-	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
-
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1, GIT_MERGE_NO_FASTFORWARD));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
@@ -118,12 +92,12 @@ void test_merge_workdir_setup__no_fastforward(void)
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branch '" OCTO1_BRANCH "'\n"));
 
 	git_reference_free(octo1_ref);
-
+	
 	git_merge_head_free(our_head);
 	git_merge_head_free(their_heads[0]);
 }
 
-/* git merge  16f825815cfd20a07a75c71554e82d8eede0b061 */
+/* git merge --no-ff 16f825815cfd20a07a75c71554e82d8eede0b061 */
 void test_merge_workdir_setup__one_oid(void)
 {
 	git_oid our_oid;
@@ -136,11 +110,11 @@ void test_merge_workdir_setup__one_oid(void)
 	cl_git_pass(git_oid_fromstr(&octo1_oid, OCTO1_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &octo1_oid));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge commit '" OCTO1_OID "'\n"));
 
 	git_merge_head_free(our_head);
@@ -164,11 +138,11 @@ void test_merge_workdir_setup__two_branches(void)
 	cl_git_pass(git_reference_lookup(&octo2_ref, repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[1], repo, octo2_ref));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2));
 	
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branches '" OCTO1_BRANCH "' and '" OCTO2_BRANCH "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -200,11 +174,11 @@ void test_merge_workdir_setup__three_branches(void)
 	cl_git_pass(git_reference_lookup(&octo3_ref, repo, GIT_REFS_HEADS_DIR OCTO3_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[2], repo, octo3_ref));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branches '" OCTO1_BRANCH "', '" OCTO2_BRANCH "' and '" OCTO3_BRANCH "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -238,11 +212,11 @@ void test_merge_workdir_setup__three_oids(void)
 	cl_git_pass(git_oid_fromstr(&octo3_oid, OCTO3_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[2], repo, &octo3_oid));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge commit '" OCTO1_OID "'; commit '" OCTO2_OID "'; commit '" OCTO3_OID "'\n"));
 	
 	git_merge_head_free(our_head);
@@ -268,11 +242,11 @@ void test_merge_workdir_setup__branches_and_oids_1(void)
 	cl_git_pass(git_oid_fromstr(&octo2_oid, OCTO2_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[1], repo, &octo2_oid));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branch '" OCTO1_BRANCH "'; commit '" OCTO2_OID "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -307,11 +281,11 @@ void test_merge_workdir_setup__branches_and_oids_2(void)
 	cl_git_pass(git_oid_fromstr(&octo4_oid, OCTO4_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[3], repo, &octo4_oid));
 	
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n" OCTO4_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branches '" OCTO1_BRANCH "' and '" OCTO3_BRANCH "'; commit '" OCTO2_OID "'; commit '" OCTO4_OID "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -349,11 +323,11 @@ void test_merge_workdir_setup__branches_and_oids_3(void)
 	cl_git_pass(git_reference_lookup(&octo4_ref, repo, GIT_REFS_HEADS_DIR OCTO4_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[3], repo, octo4_ref));
 	
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n" OCTO4_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge commit '" OCTO1_OID "'; branches '" OCTO2_BRANCH "' and '" OCTO4_BRANCH "'; commit '" OCTO3_OID "'\n"));
 	
 	git_reference_free(octo2_ref);
@@ -395,11 +369,11 @@ void test_merge_workdir_setup__branches_and_oids_4(void)
 	cl_git_pass(git_reference_lookup(&octo5_ref, repo, GIT_REFS_HEADS_DIR OCTO5_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[4], repo, octo5_ref));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 5, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 5));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n" OCTO4_OID "\n" OCTO5_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge commit '" OCTO1_OID "'; branches '" OCTO2_BRANCH "', '" OCTO4_BRANCH "' and '" OCTO5_BRANCH "'; commit '" OCTO3_OID "'\n"));
 	
 	git_reference_free(octo2_ref);
@@ -435,11 +409,11 @@ void test_merge_workdir_setup__three_same_branches(void)
 	cl_git_pass(git_reference_lookup(&octo1_3_ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[2], repo, octo1_3_ref));
 	
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO1_OID "\n" OCTO1_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branches '" OCTO1_BRANCH "', '" OCTO1_BRANCH "' and '" OCTO1_BRANCH "'\n"));
 	
 	git_reference_free(octo1_1_ref);
@@ -473,11 +447,11 @@ void test_merge_workdir_setup__three_same_oids(void)
 	cl_git_pass(git_oid_fromstr(&octo1_3_oid, OCTO1_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[2], repo, &octo1_3_oid));
 	
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3));
 	
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO1_OID "\n" OCTO1_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge commit '" OCTO1_OID "'; commit '" OCTO1_OID "'; commit '" OCTO1_OID "'\n"));
 	
 	git_merge_head_free(our_head);
@@ -544,11 +518,11 @@ void test_merge_workdir_setup__remote_tracking_one_branch(void)
 	cl_git_pass(git_reference_lookup(&octo1_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO1_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
 	
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge remote-tracking branch 'refs/remotes/origin/" OCTO1_BRANCH "'\n"));
 
 	git_reference_free(octo1_ref);
@@ -577,11 +551,11 @@ void test_merge_workdir_setup__remote_tracking_two_branches(void)
 	cl_git_pass(git_reference_lookup(&octo2_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[1], repo, octo2_ref));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2));
 	
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge remote-tracking branches 'refs/remotes/origin/" OCTO1_BRANCH "' and 'refs/remotes/origin/" OCTO2_BRANCH "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -617,11 +591,11 @@ void test_merge_workdir_setup__remote_tracking_three_branches(void)
 	cl_git_pass(git_reference_lookup(&octo3_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO3_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[2], repo, octo3_ref));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge remote-tracking branches 'refs/remotes/origin/" OCTO1_BRANCH "', 'refs/remotes/origin/" OCTO2_BRANCH "' and 'refs/remotes/origin/" OCTO3_BRANCH "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -653,11 +627,11 @@ void test_merge_workdir_setup__normal_branch_and_remote_tracking_branch(void)
 	cl_git_pass(git_reference_lookup(&octo2_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[1], repo, octo2_ref));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2));
 	
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branch '" OCTO1_BRANCH "', remote-tracking branch 'refs/remotes/origin/" OCTO2_BRANCH "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -687,11 +661,11 @@ void test_merge_workdir_setup__remote_tracking_branch_and_normal_branch(void)
 	cl_git_pass(git_reference_lookup(&octo2_ref, repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[1], repo, octo2_ref));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2));
 	
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branch '" OCTO2_BRANCH "', remote-tracking branch 'refs/remotes/origin/" OCTO1_BRANCH "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -730,11 +704,11 @@ void test_merge_workdir_setup__two_remote_tracking_branch_and_two_normal_branche
 	cl_git_pass(git_reference_lookup(&octo4_ref, repo, GIT_REFS_REMOTES_DIR "origin/" OCTO4_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[3], repo, octo4_ref));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4));
 	
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n" OCTO4_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branches '" OCTO1_BRANCH "' and '" OCTO3_BRANCH "', remote-tracking branches 'refs/remotes/origin/" OCTO2_BRANCH "' and 'refs/remotes/origin/" OCTO4_BRANCH "'\n"));
 	
 	git_reference_free(octo1_ref);
@@ -762,11 +736,11 @@ void test_merge_workdir_setup__pull_one(void)
 	cl_git_pass(git_oid_fromstr(&octo1_1_oid, OCTO1_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &octo1_1_oid));
 	
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 1));
 	
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branch 'octo1' of http://remote.url/repo.git\n"));
 	
 	git_merge_head_free(our_head);
@@ -790,11 +764,11 @@ void test_merge_workdir_setup__pull_two(void)
 	cl_git_pass(git_oid_fromstr(&octo2_oid, OCTO2_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[1], repo, GIT_REFS_HEADS_DIR OCTO2_BRANCH, "http://remote.url/repo.git", &octo2_oid));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 2));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branches '" OCTO1_BRANCH "' and '" OCTO2_BRANCH "' of http://remote.url/repo.git\n"));
 	
 	git_merge_head_free(our_head);
@@ -823,11 +797,11 @@ void test_merge_workdir_setup__pull_three(void)
 	cl_git_pass(git_oid_fromstr(&octo3_oid, OCTO3_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[2], repo, GIT_REFS_HEADS_DIR OCTO3_BRANCH, "http://remote.url/repo.git", &octo3_oid));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branches '" OCTO1_BRANCH "', '" OCTO2_BRANCH "' and '" OCTO3_BRANCH "' of http://remote.url/repo.git\n"));
 	
 	git_merge_head_free(our_head);
@@ -856,11 +830,11 @@ void test_merge_workdir_setup__three_remotes(void)
 	cl_git_pass(git_oid_fromstr(&octo3_oid, OCTO3_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[2], repo, GIT_REFS_HEADS_DIR OCTO3_BRANCH, "http://remote.third/repo.git", &octo3_oid));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 3));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branch '" OCTO1_BRANCH "' of http://remote.first/repo.git, branch '" OCTO2_BRANCH "' of http://remote.second/repo.git, branch '" OCTO3_BRANCH "' of http://remote.third/repo.git\n"));
 	
 	git_merge_head_free(our_head);
@@ -893,11 +867,11 @@ void test_merge_workdir_setup__two_remotes(void)
 	cl_git_pass(git_oid_fromstr(&octo4_oid, OCTO4_OID));
 	cl_git_pass(git_merge_head_from_fetchhead(&their_heads[3], repo, GIT_REFS_HEADS_DIR OCTO4_BRANCH, "http://remote.second/repo.git", &octo4_oid));
 
-	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4, 0));
+	cl_git_pass(git_merge__setup(repo, our_head, (const git_merge_head **)their_heads, 4));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n" OCTO2_OID "\n" OCTO3_OID "\n" OCTO4_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
-	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, ""));
+	cl_assert(test_file_contents(GIT_MERGE_MODE_FILE, "no-ff"));
 	cl_assert(test_file_contents(GIT_MERGE_MSG_FILE, "Merge branches '" OCTO1_BRANCH "' and '" OCTO3_BRANCH "' of http://remote.first/repo.git, branches '" OCTO2_BRANCH "' and '" OCTO4_BRANCH "' of http://remote.second/repo.git\n"));
 	
 	git_merge_head_free(our_head);
@@ -996,10 +970,8 @@ void test_merge_workdir_setup__retained_after_success(void)
 	git_oid our_oid;
 	git_reference *octo1_ref;
 	git_merge_head *our_head, *their_heads[1];
-	git_merge_result *result;
 	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
-
-	opts.merge_flags |= GIT_MERGE_NO_FASTFORWARD;
+	git_merge_result *result;
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
 	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
@@ -1030,8 +1002,6 @@ void test_merge_workdir_setup__removed_after_failure(void)
 	git_merge_result *result;
 	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
 
-	opts.merge_flags |= GIT_MERGE_NO_FASTFORWARD;
-
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
 	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
 
-- 
cgit v1.2.3


From 02105a27f01509ce4e641487cae040662ee477a2 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 11 Mar 2014 18:40:38 -0700
Subject: Change signature of `git_merge` to take merge and checkout opts

---
 include/git2/merge.h             | 32 +++-----------------
 src/merge.c                      | 64 ++++++++++++++++------------------------
 tests/merge/merge_helpers.c      |  6 ++--
 tests/merge/merge_helpers.h      |  3 +-
 tests/merge/workdir/dirty.c      |  9 +++---
 tests/merge/workdir/renames.c    | 27 +++++++++--------
 tests/merge/workdir/setup.c      |  6 ++--
 tests/merge/workdir/simple.c     | 30 +++++++++----------
 tests/merge/workdir/submodules.c |  6 ++--
 tests/merge/workdir/trivial.c    |  3 +-
 tests/structinit/structinit.c    |  5 ----
 11 files changed, 75 insertions(+), 116 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index e20025b7a..15bed2a2a 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -274,32 +274,6 @@ GIT_EXTERN(int) git_merge_status(
 	const git_merge_head **their_heads,
 	size_t their_heads_len);
 
-typedef struct {
-	unsigned int version;
-
-	/** Options for handling the merges of individual files. */
-	git_merge_tree_opts merge_tree_opts;
-
-	/** Options for writing the merge result to the working directory. */
-	git_checkout_options checkout_opts;
-} git_merge_opts;
-
-#define GIT_MERGE_OPTS_VERSION 1
-#define GIT_MERGE_OPTS_INIT {GIT_MERGE_OPTS_VERSION, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
-
-/**
- * Initializes a `git_merge_opts` with default values. Equivalent to creating
- * an instance with GIT_MERGE_OPTS_INIT.
- *
- * @param opts the `git_merge_opts` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_MERGE_OPTS_VERSION` here.
- * @return Zero on success; -1 on failure.
- */
-GIT_EXTERN(int) git_merge_init_opts(
-	git_merge_opts* opts,
-	int version);
-
 /**
  * Find a merge base between two commits
  *
@@ -522,7 +496,8 @@ GIT_EXTERN(int) git_merge_commits(
  * @param repo the repository to merge
  * @param merge_heads the heads to merge into
  * @param merge_heads_len the number of heads to merge
- * @param opts merge options
+ * @param checkout_opts merge options
+ * @param checkout_opts checkout options
  * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge(
@@ -530,7 +505,8 @@ GIT_EXTERN(int) git_merge(
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len,
-	const git_merge_opts *opts);
+	const git_merge_tree_opts *merge_opts,
+	const git_checkout_options *checkout_opts);
 
 /**
  * Returns true if a merge is "up-to-date", meaning that the commit(s) 
diff --git a/src/merge.c b/src/merge.c
index b7f043aca..12e4a3b64 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2168,10 +2168,10 @@ const char *merge_their_label(const char *branchname)
 	return slash+1;
 }
 
-static int merge_normalize_opts(
+static int merge_normalize_checkout_opts(
 	git_repository *repo,
-	git_merge_opts *opts,
-	const git_merge_opts *given,
+	git_checkout_options *checkout_opts,
+	const git_checkout_options *given_checkout_opts,
 	const git_merge_head *ancestor_head,
 	const git_merge_head *our_head,
 	size_t their_heads_len,
@@ -2183,38 +2183,38 @@ static int merge_normalize_opts(
 
 	GIT_UNUSED(repo);
 
-	if (given != NULL)
-		memcpy(opts, given, sizeof(git_merge_opts));
+	if (given_checkout_opts != NULL)
+		memcpy(checkout_opts, given_checkout_opts, sizeof(git_checkout_options));
 	else {
-		git_merge_opts default_opts = GIT_MERGE_OPTS_INIT;
-		memcpy(opts, &default_opts, sizeof(git_merge_opts));
+		git_checkout_options default_checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
+		memcpy(checkout_opts, &default_checkout_opts, sizeof(git_checkout_options));
 	}
 
-	if (!opts->checkout_opts.checkout_strategy)
-		opts->checkout_opts.checkout_strategy = default_checkout_strategy;
+	if (!checkout_opts->checkout_strategy)
+		checkout_opts->checkout_strategy = default_checkout_strategy;
 
 	/* TODO: for multiple ancestors in merge-recursive, this is "merged common ancestors" */
-	if (!opts->checkout_opts.ancestor_label) {
+	if (!checkout_opts->ancestor_label) {
 		if (ancestor_head && ancestor_head->commit)
-			opts->checkout_opts.ancestor_label = git_commit_summary(ancestor_head->commit);
+			checkout_opts->ancestor_label = git_commit_summary(ancestor_head->commit);
 		else
-			opts->checkout_opts.ancestor_label = "ancestor";
+			checkout_opts->ancestor_label = "ancestor";
 	}
 
-	if (!opts->checkout_opts.our_label) {
+	if (!checkout_opts->our_label) {
 		if (our_head && our_head->ref_name)
-			opts->checkout_opts.our_label = our_head->ref_name;
+			checkout_opts->our_label = our_head->ref_name;
 		else
-			opts->checkout_opts.our_label = "ours";
+			checkout_opts->our_label = "ours";
 	}
 
-	if (!opts->checkout_opts.their_label) {
+	if (!checkout_opts->their_label) {
 		if (their_heads_len == 1 && their_heads[0]->ref_name)
-			opts->checkout_opts.their_label = merge_their_label(their_heads[0]->ref_name);
+			checkout_opts->their_label = merge_their_label(their_heads[0]->ref_name);
 		else if (their_heads_len == 1)
-			opts->checkout_opts.their_label = their_heads[0]->oid_str;
+			checkout_opts->their_label = their_heads[0]->oid_str;
 		else
-			opts->checkout_opts.their_label = "theirs";
+			checkout_opts->their_label = "theirs";
 	}
 
 	return error;
@@ -2552,11 +2552,12 @@ int git_merge(
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len,
-	const git_merge_opts *given_opts)
+	const git_merge_tree_opts *merge_opts,
+	const git_checkout_options *given_checkout_opts)
 {
 	git_merge_result *result;
-	git_merge_opts opts;
 	git_reference *our_ref = NULL;
+	git_checkout_options checkout_opts;
 	git_merge_head *ancestor_head = NULL, *our_head = NULL;
 	git_tree *ancestor_tree = NULL, *our_tree = NULL, **their_trees = NULL;
 	git_index *index_new = NULL, *index_repo = NULL;
@@ -2567,8 +2568,6 @@ int git_merge(
 
 	*out = NULL;
 
-	GITERR_CHECK_VERSION(given_opts, GIT_MERGE_OPTS_VERSION, "git_merge_opts");
-
 	if (their_heads_len != 1) {
 		giterr_set(GITERR_MERGE, "Can only merge a single branch");
 		return -1;
@@ -2583,7 +2582,8 @@ int git_merge(
 	if ((error = merge_heads(&ancestor_head, &our_head, repo, their_heads, their_heads_len)) < 0)
 		goto on_error;
 
-	if ((error = merge_normalize_opts(repo, &opts, given_opts, ancestor_head, our_head, their_heads_len, their_heads)) < 0)
+	if ((error = merge_normalize_checkout_opts(repo, &checkout_opts, given_checkout_opts,
+		ancestor_head, our_head, their_heads_len, their_heads)) < 0)
 		goto on_error;
 
 	/* Write the merge files to the repository. */
@@ -2604,10 +2604,10 @@ int git_merge(
 
 	/* TODO: recursive, octopus, etc... */
 
-	if ((error = git_merge_trees(&index_new, repo, ancestor_tree, our_tree, their_trees[0], &opts.merge_tree_opts)) < 0 ||
+	if ((error = git_merge_trees(&index_new, repo, ancestor_tree, our_tree, their_trees[0], merge_opts)) < 0 ||
 		(error = git_merge__indexes(repo, index_new)) < 0 ||
 		(error = git_repository_index(&index_repo, repo)) < 0 ||
-		(error = git_checkout_index(repo, index_repo, &opts.checkout_opts)) < 0)
+		(error = git_checkout_index(repo, index_repo, &checkout_opts)) < 0)
 		goto on_error;
 
 	result->index = index_new;
@@ -2779,18 +2779,6 @@ void git_merge_head_free(git_merge_head *head)
 	git__free(head);
 }
 
-int git_merge_init_opts(git_merge_opts* opts, int version)
-{
-	if (version != GIT_MERGE_OPTS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_opts", version);
-		return -1;
-	} else {
-		git_merge_opts o = GIT_MERGE_OPTS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
-}
-
 int git_merge_tree_init_opts(git_merge_tree_opts* opts, int version)
 {
 	if (version != GIT_MERGE_TREE_OPTS_VERSION) {
diff --git a/tests/merge/merge_helpers.c b/tests/merge/merge_helpers.c
index 14a30b288..e3c2b9e4a 100644
--- a/tests/merge/merge_helpers.c
+++ b/tests/merge/merge_helpers.c
@@ -79,7 +79,9 @@ int merge_commits_from_branches(
 	return 0;
 }
 
-int merge_branches(git_merge_result **result, git_repository *repo, const char *ours_branch, const char *theirs_branch, git_merge_opts *opts)
+int merge_branches(git_merge_result **result, git_repository *repo,
+	const char *ours_branch, const char *theirs_branch,
+	git_merge_tree_opts *merge_opts, git_checkout_options *checkout_opts)
 {
 	git_reference *head_ref, *theirs_ref;
 	git_merge_head *theirs_head;
@@ -93,7 +95,7 @@ int merge_branches(git_merge_result **result, git_repository *repo, const char *
 	cl_git_pass(git_reference_lookup(&theirs_ref, repo, theirs_branch));
 	cl_git_pass(git_merge_head_from_ref(&theirs_head, repo, theirs_ref));
 
-	cl_git_pass(git_merge(result, repo, (const git_merge_head **)&theirs_head, 1, opts));
+	cl_git_pass(git_merge(result, repo, (const git_merge_head **)&theirs_head, 1, merge_opts, checkout_opts));
 
 	git_reference_free(head_ref);
 	git_reference_free(theirs_ref);
diff --git a/tests/merge/merge_helpers.h b/tests/merge/merge_helpers.h
index 63d1cb7a9..e5dc34b06 100644
--- a/tests/merge/merge_helpers.h
+++ b/tests/merge/merge_helpers.h
@@ -93,7 +93,8 @@ int merge_commits_from_branches(
 	git_merge_tree_opts *opts);
 
 int merge_branches(git_merge_result **result, git_repository *repo,
-	const char *ours_branch, const char *theirs_branch, git_merge_opts *opts);
+	const char *ours_branch, const char *theirs_branch,
+	git_merge_tree_opts *merge_opts, git_checkout_options *checkout_opts);
 
 int merge_test_diff_list(git_merge_diff_list *diff_list, const struct merge_index_entry expected[], size_t expected_len);
 
diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
index a77f9b205..61b83a648 100644
--- a/tests/merge/workdir/dirty.c
+++ b/tests/merge/workdir/dirty.c
@@ -90,15 +90,16 @@ static int merge_branch(git_merge_result **result, int merge_file_favor, int che
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	int error;
 
 	cl_git_pass(git_oid_fromstr(&their_oids[0], MERGE_BRANCH_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.file_favor = merge_file_favor;
-	opts.checkout_opts.checkout_strategy = checkout_strategy;
-	error = git_merge(result, repo, (const git_merge_head **)their_heads, 1, &opts);
+	merge_opts.file_favor = merge_file_favor;
+	checkout_opts.checkout_strategy = checkout_strategy;
+	error = git_merge(result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, &checkout_opts);
 
 	git_merge_head_free(their_heads[0]);
 
diff --git a/tests/merge/workdir/renames.c b/tests/merge/workdir/renames.c
index 27747720e..14308efe0 100644
--- a/tests/merge/workdir/renames.c
+++ b/tests/merge/workdir/renames.c
@@ -35,7 +35,7 @@ void test_merge_workdir_renames__cleanup(void)
 void test_merge_workdir_renames__renames(void)
 {
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "68c6c84b091926c7d90aa6a79b2bc3bb6adccd8e", 0, "0a-no-change.txt" },
@@ -64,10 +64,10 @@ void test_merge_workdir_renames__renames(void)
 		{ 0100644, "b69fe837e4cecfd4c9a40cdca7c138468687df07", 0, "7-both-renamed.txt~rename_conflict_theirs" },
 	};
 
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
+	merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	merge_opts.rename_threshold = 50;
 
-	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &opts));
+	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, NULL));
 	cl_assert(merge_test_workdir(repo, merge_index_entries, 24));
 
 	git_merge_result_free(result);
@@ -77,7 +77,8 @@ void test_merge_workdir_renames__ours(void)
 {
 	git_index *index;
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "68c6c84b091926c7d90aa6a79b2bc3bb6adccd8e", 0, "0a-no-change.txt" },
@@ -102,11 +103,11 @@ void test_merge_workdir_renames__ours(void)
 		{ 0100644, "b42712cfe99a1a500b2a51fe984e0b8a7702ba11", 0, "7-both-renamed.txt" },
 	};
 
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
-	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+	merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	merge_opts.rename_threshold = 50;
+	checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
 
-	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &opts));
+	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, &checkout_opts));
 	cl_git_pass(git_repository_index(&index, repo));
 	cl_git_pass(git_index_write(index));
 	cl_assert(merge_test_workdir(repo, merge_index_entries, 20));
@@ -118,7 +119,7 @@ void test_merge_workdir_renames__ours(void)
 void test_merge_workdir_renames__similar(void)
 {
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
 
 	/*
 	 * Note: this differs slightly from the core git merge result - there, 4a is
@@ -152,10 +153,10 @@ void test_merge_workdir_renames__similar(void)
 		{ 0100644, "b69fe837e4cecfd4c9a40cdca7c138468687df07", 0, "7-both-renamed.txt~rename_conflict_theirs" },
 	};
 
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
+	merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	merge_opts.rename_threshold = 50;
 
-	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &opts));
+	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, NULL));
 	cl_assert(merge_test_workdir(repo, merge_index_entries, 24));
 
 	git_merge_result_free(result);
diff --git a/tests/merge/workdir/setup.c b/tests/merge/workdir/setup.c
index d23e4547a..708599555 100644
--- a/tests/merge/workdir/setup.c
+++ b/tests/merge/workdir/setup.c
@@ -970,7 +970,6 @@ void test_merge_workdir_setup__retained_after_success(void)
 	git_oid our_oid;
 	git_reference *octo1_ref;
 	git_merge_head *our_head, *their_heads[1];
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
 	git_merge_result *result;
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
@@ -980,7 +979,7 @@ void test_merge_workdir_setup__retained_after_success(void)
 
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_heads[0], 1, &opts));
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_heads[0], 1, NULL, NULL));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
@@ -1000,7 +999,6 @@ void test_merge_workdir_setup__removed_after_failure(void)
 	git_reference *octo1_ref;
 	git_merge_head *our_head, *their_heads[1];
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
 	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
@@ -1012,7 +1010,7 @@ void test_merge_workdir_setup__removed_after_failure(void)
 		"Conflicting file!\n\nMerge will fail!\n");
 
 	cl_git_fail(git_merge(
-		&result, repo, (const git_merge_head **)&their_heads[0], 1, &opts));
+		&result, repo, (const git_merge_head **)&their_heads[0], 1, NULL, NULL));
 
 	cl_assert(!git_path_exists("merge-resolve/" GIT_MERGE_HEAD_FILE));
 	cl_assert(!git_path_exists("merge-resolve/" GIT_ORIG_HEAD_FILE));
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 07c60c5fa..e60b2db18 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -97,14 +97,15 @@ static git_merge_result *merge_simple_branch(int merge_file_favor, int checkout_
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_SIMPLE_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.file_favor = merge_file_favor;
-	opts.checkout_opts.checkout_strategy = checkout_strategy;
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
+	merge_opts.file_favor = merge_file_favor;
+	checkout_opts.checkout_strategy = checkout_strategy;
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, &checkout_opts));
 
 	git_merge_head_free(their_heads[0]);
 
@@ -522,7 +523,7 @@ void test_merge_workdir_simple__directory_file(void)
 	git_oid their_oids[1], head_commit_id;
 	git_merge_head *their_heads[1];
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
 	git_commit *head_commit;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -556,8 +557,8 @@ void test_merge_workdir_simple__directory_file(void)
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_DIRECTORY_FILE));
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.file_favor = 0;
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
+	merge_opts.file_favor = 0;
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 20));
 
@@ -572,7 +573,7 @@ void test_merge_workdir_simple__unrelated(void)
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0, "added-in-master.txt" },
@@ -589,8 +590,8 @@ void test_merge_workdir_simple__unrelated(void)
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_UNRELATED_PARENT));
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.file_favor = 0;
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
+	merge_opts.file_favor = 0;
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 9));
 
@@ -603,7 +604,7 @@ void test_merge_workdir_simple__unrelated_with_conflicts(void)
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
+	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0, "added-in-master.txt" },
@@ -622,8 +623,8 @@ void test_merge_workdir_simple__unrelated_with_conflicts(void)
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_UNRELATED_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
-	opts.merge_tree_opts.file_favor = 0;
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
+	merge_opts.file_favor = 0;
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 11));
 
@@ -638,7 +639,6 @@ void test_merge_workdir_simple__binary(void)
 	git_merge_head *their_head;
 	git_merge_result *result;
 	const git_index_entry *binary_entry;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "1c51d885170f57a0c4e8c69ff6363d91a5b51f85", 1, "binary" },
@@ -654,7 +654,7 @@ void test_merge_workdir_simple__binary(void)
 
 	cl_git_pass(git_merge_head_from_id(&their_head, repo, &their_oid));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, &opts));
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
 
diff --git a/tests/merge/workdir/submodules.c b/tests/merge/workdir/submodules.c
index 42451bde7..296f30de5 100644
--- a/tests/merge/workdir/submodules.c
+++ b/tests/merge/workdir/submodules.c
@@ -32,7 +32,6 @@ void test_merge_workdir_submodules__automerge(void)
 	git_commit *our_commit;
 	git_merge_head *their_head;
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
 	git_index *index;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -51,7 +50,7 @@ void test_merge_workdir_submodules__automerge(void)
 	cl_git_pass(git_reference_lookup(&their_ref, repo, "refs/heads/" SUBMODULE_OTHER_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, &opts));
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
 
 	cl_git_pass(git_repository_index(&index, repo));
 	cl_assert(merge_test_index(index, merge_index_entries, 6));
@@ -70,7 +69,6 @@ void test_merge_workdir_submodules__take_changed(void)
 	git_commit *our_commit;
 	git_merge_head *their_head;
 	git_merge_result *result;
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
 	git_index *index;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -87,7 +85,7 @@ void test_merge_workdir_submodules__take_changed(void)
 	cl_git_pass(git_reference_lookup(&their_ref, repo, "refs/heads/" SUBMODULE_OTHER2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, &opts));
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
 
 	cl_git_pass(git_repository_index(&index, repo));
 	cl_assert(merge_test_index(index, merge_index_entries, 4));
diff --git a/tests/merge/workdir/trivial.c b/tests/merge/workdir/trivial.c
index 8b0d32894..ffbb56cab 100644
--- a/tests/merge/workdir/trivial.c
+++ b/tests/merge/workdir/trivial.c
@@ -34,7 +34,6 @@ static int merge_trivial(const char *ours, const char *theirs)
 	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_reference *our_ref, *their_ref;
 	git_merge_head *their_heads[1];
-	git_merge_opts opts = GIT_MERGE_OPTS_INIT;
 	git_merge_result *result;
 
 	checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE;
@@ -49,7 +48,7 @@ static int merge_trivial(const char *ours, const char *theirs)
 	cl_git_pass(git_reference_lookup(&their_ref, repo, branch_buf.ptr));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, their_ref));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &opts));
+	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, NULL, NULL));
 
 	git_buf_free(&branch_buf);
 	git_reference_free(our_ref);
diff --git a/tests/structinit/structinit.c b/tests/structinit/structinit.c
index 61fe8c786..fc44898cc 100644
--- a/tests/structinit/structinit.c
+++ b/tests/structinit/structinit.c
@@ -80,11 +80,6 @@ void test_structinit_structinit__compare(void)
 		git_merge_tree_opts, GIT_MERGE_TREE_OPTS_VERSION, \
 		GIT_MERGE_TREE_OPTS_INIT, git_merge_tree_init_opts);
 
-	/* merge */
-	CHECK_MACRO_FUNC_INIT_EQUAL( \
-		git_merge_opts, GIT_MERGE_OPTS_VERSION, \
-		GIT_MERGE_OPTS_INIT, git_merge_init_opts);
-
 	/* push */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
 		git_push_options, GIT_PUSH_OPTIONS_VERSION, \
-- 
cgit v1.2.3


From 5aa2ac6de1622308884fd542f7b29e6810a0e98e Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 11 Mar 2014 22:47:39 -0700
Subject: Update git_merge_tree_opts to git_merge_options

---
 include/git2/merge.h          | 26 +++++++++++------------
 include/git2/revert.h         |  6 +++---
 src/merge.c                   | 48 +++++++++++++++++++++----------------------
 src/merge.h                   |  2 +-
 src/revert.c                  |  6 +++---
 tests/merge/merge_helpers.c   |  6 +++---
 tests/merge/merge_helpers.h   |  6 +++---
 tests/merge/trees/automerge.c |  8 ++++----
 tests/merge/trees/commits.c   |  6 +++---
 tests/merge/trees/renames.c   |  4 ++--
 tests/merge/trees/treediff.c  |  2 +-
 tests/merge/trees/trivial.c   |  2 +-
 tests/merge/workdir/dirty.c   |  2 +-
 tests/merge/workdir/renames.c |  6 +++---
 tests/merge/workdir/simple.c  |  8 ++++----
 tests/revert/workdir.c        |  8 ++++----
 tests/structinit/structinit.c |  4 ++--
 17 files changed, 75 insertions(+), 75 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 15bed2a2a..7065cbcb3 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -216,22 +216,22 @@ typedef struct {
 
 	/** Flags for handling conflicting content. */
 	git_merge_file_favor_t file_favor;
-} git_merge_tree_opts;
+} git_merge_options;
 
-#define GIT_MERGE_TREE_OPTS_VERSION 1
-#define GIT_MERGE_TREE_OPTS_INIT {GIT_MERGE_TREE_OPTS_VERSION}
+#define GIT_MERGE_OPTIONS_VERSION 1
+#define GIT_MERGE_OPTIONS_INIT {GIT_MERGE_OPTIONS_VERSION}
 
 /**
- * Initializes a `git_merge_tree_opts` with default values. Equivalent to
- * creating an instance with GIT_MERGE_TREE_OPTS_INIT.
+ * Initializes a `git_merge_options` with default values. Equivalent to
+ * creating an instance with GIT_MERGE_OPTIONS_INIT.
  *
- * @param opts the `git_merge_tree_opts` instance to initialize.
+ * @param opts the `git_merge_options` instance to initialize.
  * @param version the version of the struct; you should pass
- *        `GIT_MERGE_TREE_OPTS_VERSION` here.
+ *        `GIT_MERGE_OPTIONS_VERSION` here.
  * @return Zero on success; -1 on failure.
  */
-GIT_EXTERN(int) git_merge_tree_init_opts(
-	git_merge_tree_opts* opts,
+GIT_EXTERN(int) git_merge_init_options(
+	git_merge_options *opts,
 	int version);
 
 /**
@@ -447,7 +447,7 @@ GIT_EXTERN(int) git_merge_trees(
 	const git_tree *ancestor_tree,
 	const git_tree *our_tree,
 	const git_tree *their_tree,
-	const git_merge_tree_opts *opts);
+	const git_merge_options *opts);
 
 /**
  * Merge two commits, producing a `git_index` that reflects the result of
@@ -469,7 +469,7 @@ GIT_EXTERN(int) git_merge_commits(
 	git_repository *repo,
 	const git_commit *our_commit,
 	const git_commit *their_commit,
-	const git_merge_tree_opts *opts);
+	const git_merge_options *opts);
 
 /**
  * Merges the given commit(s) into HEAD and either returns immediately
@@ -496,7 +496,7 @@ GIT_EXTERN(int) git_merge_commits(
  * @param repo the repository to merge
  * @param merge_heads the heads to merge into
  * @param merge_heads_len the number of heads to merge
- * @param checkout_opts merge options
+ * @param merge_opts merge options
  * @param checkout_opts checkout options
  * @return 0 on success or error code
  */
@@ -505,7 +505,7 @@ GIT_EXTERN(int) git_merge(
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len,
-	const git_merge_tree_opts *merge_opts,
+	const git_merge_options *merge_opts,
 	const git_checkout_options *checkout_opts);
 
 /**
diff --git a/include/git2/revert.h b/include/git2/revert.h
index 3f48c4e4b..3a6beb6b8 100644
--- a/include/git2/revert.h
+++ b/include/git2/revert.h
@@ -26,12 +26,12 @@ typedef struct {
 	/** For merge commits, the "mainline" is treated as the parent. */
 	unsigned int mainline;
 
-	git_merge_tree_opts merge_tree_opts;
+	git_merge_options merge_opts;
 	git_checkout_options checkout_opts;
 } git_revert_options;
 
 #define GIT_REVERT_OPTIONS_VERSION 1
-#define GIT_REVERT_OPTIONS_INIT {GIT_REVERT_OPTIONS_VERSION, 0, GIT_MERGE_TREE_OPTS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
+#define GIT_REVERT_OPTIONS_INIT {GIT_REVERT_OPTIONS_VERSION, 0, GIT_MERGE_OPTIONS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
 
 /**
  * Initializes a `git_revert_options` with default values. Equivalent to
@@ -66,7 +66,7 @@ int git_revert_commit(
 	git_commit *revert_commit,
 	git_commit *our_commit,
 	unsigned int mainline,
-	const git_merge_tree_opts *merge_tree_opts);
+	const git_merge_options *merge_options);
 
 /**
  * Reverts the given commit, producing changes in the working directory.
diff --git a/src/merge.c b/src/merge.c
index 12e4a3b64..589cf43de 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -664,7 +664,7 @@ static int index_entry_similarity_exact(
 	git_index_entry *b,
 	size_t b_idx,
 	void **cache,
-	const git_merge_tree_opts *opts)
+	const git_merge_options *opts)
 {
 	GIT_UNUSED(repo);
 	GIT_UNUSED(a_idx);
@@ -682,7 +682,7 @@ static int index_entry_similarity_calc(
 	void **out,
 	git_repository *repo,
 	git_index_entry *entry,
-	const git_merge_tree_opts *opts)
+	const git_merge_options *opts)
 {
 	git_blob *blob;
 	git_diff_file diff_file = {{{0}}};
@@ -722,7 +722,7 @@ static int index_entry_similarity_inexact(
 	git_index_entry *b,
 	size_t b_idx,
 	void **cache,
-	const git_merge_tree_opts *opts)
+	const git_merge_options *opts)
 {
 	int score = 0;
 	int error = 0;
@@ -759,9 +759,9 @@ static int merge_diff_mark_similarity(
 	git_merge_diff_list *diff_list,
 	struct merge_diff_similarity *similarity_ours,
 	struct merge_diff_similarity *similarity_theirs,
-	int (*similarity_fn)(git_repository *, git_index_entry *, size_t, git_index_entry *, size_t, void **, const git_merge_tree_opts *),
+	int (*similarity_fn)(git_repository *, git_index_entry *, size_t, git_index_entry *, size_t, void **, const git_merge_options *),
 	void **cache,
-	const git_merge_tree_opts *opts)
+	const git_merge_options *opts)
 {
 	size_t i, j;
 	git_merge_diff *conflict_src, *conflict_tgt;
@@ -862,7 +862,7 @@ static void merge_diff_mark_rename_conflict(
 	bool theirs_renamed,
 	size_t theirs_source_idx,
 	git_merge_diff *target,
-	const git_merge_tree_opts *opts)
+	const git_merge_options *opts)
 {
 	git_merge_diff *ours_source = NULL, *theirs_source = NULL;
 
@@ -932,7 +932,7 @@ static void merge_diff_list_coalesce_renames(
 	git_merge_diff_list *diff_list,
 	struct merge_diff_similarity *similarity_ours,
 	struct merge_diff_similarity *similarity_theirs,
-	const git_merge_tree_opts *opts)
+	const git_merge_options *opts)
 {
 	size_t i;
 	bool ours_renamed = 0, theirs_renamed = 0;
@@ -1022,7 +1022,7 @@ static void merge_diff_list_count_candidates(
 int git_merge_diff_list__find_renames(
 	git_repository *repo,
 	git_merge_diff_list *diff_list,
-	const git_merge_tree_opts *opts)
+	const git_merge_options *opts)
 {
 	struct merge_diff_similarity *similarity_ours, *similarity_theirs;
 	void **cache = NULL;
@@ -1450,10 +1450,10 @@ void git_merge_diff_list__free(git_merge_diff_list *diff_list)
 	git__free(diff_list);
 }
 
-static int merge_tree_normalize_opts(
+static int merge_normalize_opts(
 	git_repository *repo,
-	git_merge_tree_opts *opts,
-	const git_merge_tree_opts *given)
+	git_merge_options *opts,
+	const git_merge_options *given)
 {
 	git_config *cfg = NULL;
 	int error = 0;
@@ -1464,9 +1464,9 @@ static int merge_tree_normalize_opts(
 		return error;
 
 	if (given != NULL)
-		memcpy(opts, given, sizeof(git_merge_tree_opts));
+		memcpy(opts, given, sizeof(git_merge_options));
 	else {
-		git_merge_tree_opts init = GIT_MERGE_TREE_OPTS_INIT;
+		git_merge_options init = GIT_MERGE_OPTIONS_INIT;
 		memcpy(opts, &init, sizeof(init));
 
 		opts->flags = GIT_MERGE_TREE_FIND_RENAMES;
@@ -1634,10 +1634,10 @@ int git_merge_trees(
 	const git_tree *ancestor_tree,
 	const git_tree *our_tree,
 	const git_tree *their_tree,
-	const git_merge_tree_opts *given_opts)
+	const git_merge_options *given_opts)
 {
 	git_merge_diff_list *diff_list;
-	git_merge_tree_opts opts;
+	git_merge_options opts;
 	git_merge_diff *conflict;
 	git_vector changes;
 	size_t i;
@@ -1647,9 +1647,9 @@ int git_merge_trees(
 
 	*out = NULL;
 
-	GITERR_CHECK_VERSION(given_opts, GIT_MERGE_TREE_OPTS_VERSION, "git_merge_tree_opts");
+	GITERR_CHECK_VERSION(given_opts, GIT_MERGE_OPTIONS_VERSION, "git_merge_options");
 
-	if ((error = merge_tree_normalize_opts(repo, &opts, given_opts)) < 0)
+	if ((error = merge_normalize_opts(repo, &opts, given_opts)) < 0)
 		return error;
 
 	diff_list = git_merge_diff_list__alloc(repo);
@@ -1688,7 +1688,7 @@ int git_merge_commits(
 	git_repository *repo,
 	const git_commit *our_commit,
 	const git_commit *their_commit,
-	const git_merge_tree_opts *opts)
+	const git_merge_options *opts)
 {
 	git_oid ancestor_oid;
 	git_commit *ancestor_commit = NULL;
@@ -2552,7 +2552,7 @@ int git_merge(
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len,
-	const git_merge_tree_opts *merge_opts,
+	const git_merge_options *merge_opts,
 	const git_checkout_options *given_checkout_opts)
 {
 	git_merge_result *result;
@@ -2779,14 +2779,14 @@ void git_merge_head_free(git_merge_head *head)
 	git__free(head);
 }
 
-int git_merge_tree_init_opts(git_merge_tree_opts* opts, int version)
+int git_merge_init_options(git_merge_options *opts, int version)
 {
-	if (version != GIT_MERGE_TREE_OPTS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_tree_opts", version);
+	if (version != GIT_MERGE_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_options", version);
 		return -1;
 	} else {
-		git_merge_tree_opts o = GIT_MERGE_TREE_OPTS_INIT;
-		memcpy(opts, &o, sizeof(o));
+		git_merge_options default_opts = GIT_MERGE_OPTIONS_INIT;
+		memcpy(opts, &default_opts, sizeof(git_merge_options));
 		return 0;
 	}
 }
diff --git a/src/merge.h b/src/merge.h
index 1bd202096..44c808dfa 100644
--- a/src/merge.h
+++ b/src/merge.h
@@ -147,7 +147,7 @@ int git_merge_diff_list__find_differences(git_merge_diff_list *merge_diff_list,
 	const git_tree *ours_tree,
 	const git_tree *theirs_tree);
 
-int git_merge_diff_list__find_renames(git_repository *repo, git_merge_diff_list *merge_diff_list, const git_merge_tree_opts *opts);
+int git_merge_diff_list__find_renames(git_repository *repo, git_merge_diff_list *merge_diff_list, const git_merge_options *opts);
 
 void git_merge_diff_list__free(git_merge_diff_list *diff_list);
 
diff --git a/src/revert.c b/src/revert.c
index 8e84463db..4039ec34c 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -121,7 +121,7 @@ int git_revert_commit(
 	git_commit *revert_commit,
 	git_commit *our_commit,
 	unsigned int mainline,
-	const git_merge_tree_opts *merge_tree_opts)
+	const git_merge_options *merge_opts)
 {
 	git_commit *parent_commit = NULL;
 	git_tree *parent_tree = NULL, *our_tree = NULL, *revert_tree = NULL;
@@ -152,7 +152,7 @@ int git_revert_commit(
 		(error = git_commit_tree(&our_tree, our_commit)) < 0)
 		goto done;
 
-	error = git_merge_trees(out, repo, revert_tree, our_tree, parent_tree, merge_tree_opts);
+	error = git_merge_trees(out, repo, revert_tree, our_tree, parent_tree, merge_opts);
 
 done:
 	git_tree_free(parent_tree);
@@ -198,7 +198,7 @@ int git_revert(
 		(error = write_merge_msg(repo, commit_oidstr, commit_msg)) < 0 ||
 		(error = git_repository_head(&our_ref, repo)) < 0 ||
 		(error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJ_COMMIT)) < 0 ||
-		(error = git_revert_commit(&index_new, repo, commit, our_commit, opts.mainline, &opts.merge_tree_opts)) < 0 ||
+		(error = git_revert_commit(&index_new, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 ||
 		(error = git_merge__indexes(repo, index_new)) < 0 ||
 		(error = git_repository_index(&index_repo, repo)) < 0 ||
 		(error = git_checkout_index(repo, index_repo, &opts.checkout_opts)) < 0)
diff --git a/tests/merge/merge_helpers.c b/tests/merge/merge_helpers.c
index e3c2b9e4a..53a0e7b4d 100644
--- a/tests/merge/merge_helpers.c
+++ b/tests/merge/merge_helpers.c
@@ -10,7 +10,7 @@
 int merge_trees_from_branches(
 	git_index **index, git_repository *repo,
 	const char *ours_name, const char *theirs_name,
-	git_merge_tree_opts *opts)
+	git_merge_options *opts)
 {
 	git_commit *our_commit, *their_commit, *ancestor_commit = NULL;
 	git_tree *our_tree, *their_tree, *ancestor_tree = NULL;
@@ -55,7 +55,7 @@ int merge_trees_from_branches(
 int merge_commits_from_branches(
 	git_index **index, git_repository *repo,
 	const char *ours_name, const char *theirs_name,
-	git_merge_tree_opts *opts)
+	git_merge_options *opts)
 {
 	git_commit *our_commit, *their_commit;
 	git_oid our_oid, their_oid;
@@ -81,7 +81,7 @@ int merge_commits_from_branches(
 
 int merge_branches(git_merge_result **result, git_repository *repo,
 	const char *ours_branch, const char *theirs_branch,
-	git_merge_tree_opts *merge_opts, git_checkout_options *checkout_opts)
+	git_merge_options *merge_opts, git_checkout_options *checkout_opts)
 {
 	git_reference *head_ref, *theirs_ref;
 	git_merge_head *theirs_head;
diff --git a/tests/merge/merge_helpers.h b/tests/merge/merge_helpers.h
index e5dc34b06..71f84467d 100644
--- a/tests/merge/merge_helpers.h
+++ b/tests/merge/merge_helpers.h
@@ -85,16 +85,16 @@ struct merge_index_conflict_data {
 int merge_trees_from_branches(
 	git_index **index, git_repository *repo,
 	const char *ours_name, const char *theirs_name,
-	git_merge_tree_opts *opts);
+	git_merge_options *opts);
 
 int merge_commits_from_branches(
 	git_index **index, git_repository *repo,
 	const char *ours_name, const char *theirs_name,
-	git_merge_tree_opts *opts);
+	git_merge_options *opts);
 
 int merge_branches(git_merge_result **result, git_repository *repo,
 	const char *ours_branch, const char *theirs_branch,
-	git_merge_tree_opts *merge_opts, git_checkout_options *checkout_opts);
+	git_merge_options *merge_opts, git_checkout_options *checkout_opts);
 
 int merge_test_diff_list(git_merge_diff_list *diff_list, const struct merge_index_entry expected[], size_t expected_len);
 
diff --git a/tests/merge/trees/automerge.c b/tests/merge/trees/automerge.c
index 79069d81d..c18881d7c 100644
--- a/tests/merge/trees/automerge.c
+++ b/tests/merge/trees/automerge.c
@@ -69,7 +69,7 @@ void test_merge_trees_automerge__automerge(void)
 {
 	git_index *index;
 	const git_index_entry *entry;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 	git_blob *blob;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -109,7 +109,7 @@ void test_merge_trees_automerge__automerge(void)
 void test_merge_trees_automerge__favor_ours(void)
 {
 	git_index *index;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		ADDED_IN_MASTER_INDEX_ENTRY,
@@ -140,7 +140,7 @@ void test_merge_trees_automerge__favor_ours(void)
 void test_merge_trees_automerge__favor_theirs(void)
 {
 	git_index *index;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		ADDED_IN_MASTER_INDEX_ENTRY,
@@ -171,7 +171,7 @@ void test_merge_trees_automerge__favor_theirs(void)
 void test_merge_trees_automerge__unrelated(void)
 {
 	git_index *index;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0, "added-in-master.txt" },
diff --git a/tests/merge/trees/commits.c b/tests/merge/trees/commits.c
index 08caf804f..c4e470997 100644
--- a/tests/merge/trees/commits.c
+++ b/tests/merge/trees/commits.c
@@ -22,7 +22,7 @@ void test_merge_trees_commits__automerge(void)
 {
 	git_index *index;
 	const git_index_entry *entry;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 	git_blob *blob;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -71,7 +71,7 @@ void test_merge_trees_commits__automerge(void)
 void test_merge_trees_commits__no_ancestor(void)
 {
 	git_index *index;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0, "added-in-master.txt" },
@@ -98,7 +98,7 @@ void test_merge_trees_commits__no_ancestor(void)
 void test_merge_trees_commits__df_conflict(void)
 {
 	git_index *index;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "49130a28ef567af9a6a6104c38773fedfa5f9742", 2, "dir-10" },
diff --git a/tests/merge/trees/renames.c b/tests/merge/trees/renames.c
index 427b6bd8f..d7721c894 100644
--- a/tests/merge/trees/renames.c
+++ b/tests/merge/trees/renames.c
@@ -27,7 +27,7 @@ void test_merge_trees_renames__cleanup(void)
 void test_merge_trees_renames__index(void)
 {
 	git_index *index;
-	git_merge_tree_opts *opts = NULL;
+	git_merge_options *opts = NULL;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "68c6c84b091926c7d90aa6a79b2bc3bb6adccd8e", 0, "0a-no-change.txt" },
@@ -205,7 +205,7 @@ void test_merge_trees_renames__index(void)
 void test_merge_trees_renames__no_rename_index(void)
 {
 	git_index *index;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "68c6c84b091926c7d90aa6a79b2bc3bb6adccd8e", 0, "0a-no-change.txt" },
diff --git a/tests/merge/trees/treediff.c b/tests/merge/trees/treediff.c
index 357859df3..2298a302b 100644
--- a/tests/merge/trees/treediff.c
+++ b/tests/merge/trees/treediff.c
@@ -44,7 +44,7 @@ static void test_find_differences(
     git_oid ancestor_oid, ours_oid, theirs_oid;
     git_tree *ancestor_tree, *ours_tree, *theirs_tree;
 
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 	opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
 	opts.target_limit = 1000;
 	opts.rename_threshold = 50;
diff --git a/tests/merge/trees/trivial.c b/tests/merge/trees/trivial.c
index 377b24742..62a4574b8 100644
--- a/tests/merge/trees/trivial.c
+++ b/tests/merge/trees/trivial.c
@@ -31,7 +31,7 @@ static int merge_trivial(git_index **index, const char *ours, const char *theirs
 	git_tree *our_tree, *their_tree, *ancestor_tree;
 	git_oid our_oid, their_oid, ancestor_oid;
 	git_buf branch_buf = GIT_BUF_INIT;
-	git_merge_tree_opts opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
 
 	git_buf_printf(&branch_buf, "%s%s", GIT_REFS_HEADS_DIR, ours);
 	cl_git_pass(git_reference_name_to_id(&our_oid, repo, branch_buf.ptr));
diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
index 61b83a648..99d0d5433 100644
--- a/tests/merge/workdir/dirty.c
+++ b/tests/merge/workdir/dirty.c
@@ -90,7 +90,7 @@ static int merge_branch(git_merge_result **result, int merge_file_favor, int che
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
-	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	int error;
 
diff --git a/tests/merge/workdir/renames.c b/tests/merge/workdir/renames.c
index 14308efe0..915a9d9da 100644
--- a/tests/merge/workdir/renames.c
+++ b/tests/merge/workdir/renames.c
@@ -35,7 +35,7 @@ void test_merge_workdir_renames__cleanup(void)
 void test_merge_workdir_renames__renames(void)
 {
 	git_merge_result *result;
-	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "68c6c84b091926c7d90aa6a79b2bc3bb6adccd8e", 0, "0a-no-change.txt" },
@@ -77,7 +77,7 @@ void test_merge_workdir_renames__ours(void)
 {
 	git_index *index;
 	git_merge_result *result;
-	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -119,7 +119,7 @@ void test_merge_workdir_renames__ours(void)
 void test_merge_workdir_renames__similar(void)
 {
 	git_merge_result *result;
-	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 
 	/*
 	 * Note: this differs slightly from the core git merge result - there, 4a is
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index e60b2db18..05278321f 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -97,7 +97,7 @@ static git_merge_result *merge_simple_branch(int merge_file_favor, int checkout_
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
 	git_merge_result *result;
-	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 
 	cl_git_pass(git_oid_fromstr(&their_oids[0], THEIRS_SIMPLE_OID));
@@ -523,7 +523,7 @@ void test_merge_workdir_simple__directory_file(void)
 	git_oid their_oids[1], head_commit_id;
 	git_merge_head *their_heads[1];
 	git_merge_result *result;
-	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 	git_commit *head_commit;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -573,7 +573,7 @@ void test_merge_workdir_simple__unrelated(void)
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
 	git_merge_result *result;
-	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0, "added-in-master.txt" },
@@ -604,7 +604,7 @@ void test_merge_workdir_simple__unrelated_with_conflicts(void)
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
 	git_merge_result *result;
-	git_merge_tree_opts merge_opts = GIT_MERGE_TREE_OPTS_INIT;
+	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "233c0919c998ed110a4b6ff36f353aec8b713487", 0, "added-in-master.txt" },
diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
index afbdffefa..694f24710 100644
--- a/tests/revert/workdir.c
+++ b/tests/revert/workdir.c
@@ -398,8 +398,8 @@ void test_revert_workdir__rename_1_of_2(void)
 		{ 0100644, "0f5bfcf58c558d865da6be0281d7795993646cee", 2, "file6.txt" },
 	};
 
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
+	opts.merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_opts.rename_threshold = 50;
 
 	git_oid_fromstr(&head_oid, "cef56612d71a6af8d8015691e4865f7fece905b5");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
@@ -432,8 +432,8 @@ void test_revert_workdir__rename(void)
 		{ "file4.txt", "file5.txt", "" },
 	};
 
-	opts.merge_tree_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
-	opts.merge_tree_opts.rename_threshold = 50;
+	opts.merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_opts.rename_threshold = 50;
 
 	git_oid_fromstr(&head_oid, "55568c8de5322ff9a95d72747a239cdb64a19965");
 	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
diff --git a/tests/structinit/structinit.c b/tests/structinit/structinit.c
index fc44898cc..2942099dd 100644
--- a/tests/structinit/structinit.c
+++ b/tests/structinit/structinit.c
@@ -77,8 +77,8 @@ void test_structinit_structinit__compare(void)
 
 	/* merge_tree */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
-		git_merge_tree_opts, GIT_MERGE_TREE_OPTS_VERSION, \
-		GIT_MERGE_TREE_OPTS_INIT, git_merge_tree_init_opts);
+		git_merge_options, GIT_MERGE_OPTIONS_VERSION, \
+		GIT_MERGE_OPTIONS_INIT, git_merge_init_options);
 
 	/* push */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
-- 
cgit v1.2.3


From d9fdee6e4cb87e4531d9ddba92b44e5323e794da Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 12 Mar 2014 09:43:53 -0700
Subject: Remove `git_merge_result` as it's now unnecessary

---
 include/git2/merge.h             | 64 ++----------------------------
 src/merge.c                      | 48 +----------------------
 src/merge.h                      | 10 -----
 tests/merge/merge_helpers.c      |  4 +-
 tests/merge/merge_helpers.h      |  2 +-
 tests/merge/workdir/dirty.c      | 31 ++++-----------
 tests/merge/workdir/renames.c    | 14 ++-----
 tests/merge/workdir/setup.c      |  8 +---
 tests/merge/workdir/simple.c     | 85 ++++++++--------------------------------
 tests/merge/workdir/submodules.c |  8 +---
 tests/merge/workdir/trivial.c    |  4 +-
 11 files changed, 39 insertions(+), 239 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 7065cbcb3..a4432eef3 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -472,27 +472,11 @@ GIT_EXTERN(int) git_merge_commits(
 	const git_merge_options *opts);
 
 /**
- * Merges the given commit(s) into HEAD and either returns immediately
- * if there was no merge to perform (the specified commits have already
- * been merged or would produce a fast-forward) or performs the merge
- * and writes the results into the working directory.
+ * Merges the given commit(s) into HEAD, writing the results into the working
+ * directory.  Any changes are staged for commit and any conflicts are written
+ * to the index.  Callers should inspect the repository's index after this
+ * completes, resolve any conflicts and prepare a commit.
  *
- * Callers should inspect the `git_merge_result`:
- *
- * If `git_merge_result_is_uptodate` is true, there is no work to perform.
- *
- * If `git_merge_result_is_fastforward` is true, the caller should update
- * any necessary references to the commit ID returned by
- * `git_merge_result_fastforward_id` and check that out in order to complete
- * the fast-forward.
- * 
- * Otherwise, callers should inspect the resulting index, resolve any
- * conflicts and prepare a commit.
- *
- * The resultant `git_merge_result` should be free with
- * `git_merge_result_free`.
- *
- * @param out the results of the merge
  * @param repo the repository to merge
  * @param merge_heads the heads to merge into
  * @param merge_heads_len the number of heads to merge
@@ -501,52 +485,12 @@ GIT_EXTERN(int) git_merge_commits(
  * @return 0 on success or error code
  */
 GIT_EXTERN(int) git_merge(
-	git_merge_result **out,
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len,
 	const git_merge_options *merge_opts,
 	const git_checkout_options *checkout_opts);
 
-/**
- * Returns true if a merge is "up-to-date", meaning that the commit(s) 
- * that were provided to `git_merge` are already included in `HEAD`
- * and there is no work to do.
- *
- * @return true if the merge is up-to-date, false otherwise
- */
-GIT_EXTERN(int) git_merge_result_is_uptodate(git_merge_result *merge_result);
-
-/**
- * Returns true if a merge is eligible to be "fast-forwarded", meaning that
- * the commit that was provided to `git_merge` need not be merged, it can
- * simply be checked out, because the current `HEAD` is the merge base of
- * itself and the given commit.  To perform the fast-forward, the caller
- * should check out the results of `git_merge_result_fastforward_id`.
- * 
- * This will never be true if `GIT_MERGE_NO_FASTFORWARD` is supplied as
- * a merge option.
- *
- * @return true if the merge is fast-forwardable, false otherwise
- */
-GIT_EXTERN(int) git_merge_result_is_fastforward(git_merge_result *merge_result);
-
-/**
- * Gets the fast-forward OID if the merge was a fastforward.
- *
- * @param out pointer to populate with the OID of the fast-forward
- * @param merge_result the results of the merge
- * @return 0 on success or error code
- */
-GIT_EXTERN(int) git_merge_result_fastforward_id(git_oid *out, git_merge_result *merge_result);
-
-/**
- * Frees a `git_merge_result`.
- *
- * @param result merge result to free
- */
-GIT_EXTERN(void) git_merge_result_free(git_merge_result *merge_result);
-
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/src/merge.c b/src/merge.c
index 589cf43de..66b8be684 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2548,14 +2548,12 @@ done:
 }
 
 int git_merge(
-	git_merge_result **out,
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len,
 	const git_merge_options *merge_opts,
 	const git_checkout_options *given_checkout_opts)
 {
-	git_merge_result *result;
 	git_reference *our_ref = NULL;
 	git_checkout_options checkout_opts;
 	git_merge_head *ancestor_head = NULL, *our_head = NULL;
@@ -2564,18 +2562,13 @@ int git_merge(
 	size_t i;
 	int error = 0;
 
-	assert(out && repo && their_heads);
-
-	*out = NULL;
+	assert(repo && their_heads);
 
 	if (their_heads_len != 1) {
 		giterr_set(GITERR_MERGE, "Can only merge a single branch");
 		return -1;
 	}
 
-	result = git__calloc(1, sizeof(git_merge_result));
-	GITERR_CHECK_ALLOC(result);
-
 	their_trees = git__calloc(their_heads_len, sizeof(git_tree *));
 	GITERR_CHECK_ALLOC(their_trees);
 
@@ -2610,16 +2603,12 @@ int git_merge(
 		(error = git_checkout_index(repo, index_repo, &checkout_opts)) < 0)
 		goto on_error;
 
-	result->index = index_new;
-
-	*out = result;
 	goto done;
 
 on_error:
 	merge_state_cleanup(repo);
 
 	git_index_free(index_new);
-	git__free(result);
 
 done:
 	git_index_free(index_repo);
@@ -2640,41 +2629,6 @@ done:
 	return error;
 }
 
-/* Merge result data */
-
-int git_merge_result_is_uptodate(git_merge_result *merge_result)
-{
-	assert(merge_result);
-
-	return merge_result->is_uptodate;
-}
-
-int git_merge_result_is_fastforward(git_merge_result *merge_result)
-{
-	assert(merge_result);
-
-	return merge_result->is_fastforward;
-}
-
-int git_merge_result_fastforward_id(git_oid *out, git_merge_result *merge_result)
-{
-	assert(out && merge_result);
-
-	git_oid_cpy(out, &merge_result->fastforward_oid);
-	return 0;
-}
-
-void git_merge_result_free(git_merge_result *merge_result)
-{
-	if (merge_result == NULL)
-		return;
-
-	git_index_free(merge_result->index);
-	merge_result->index = NULL;
-
-	git__free(merge_result);
-}
-
 /* Merge heads are the input to merge */
 
 static int merge_head_init(
diff --git a/src/merge.h b/src/merge.h
index 44c808dfa..2362da04d 100644
--- a/src/merge.h
+++ b/src/merge.h
@@ -120,16 +120,6 @@ struct git_merge_head {
 	git_commit *commit;
 };
 
-/** Internal structure for merge results */
-struct git_merge_result {
-	bool is_uptodate;
-
-	bool is_fastforward;
-	git_oid fastforward_oid;
-
-	git_index *index;
-};
-
 int git_merge__bases_many(
 	git_commit_list **out,
 	git_revwalk *walk,
diff --git a/tests/merge/merge_helpers.c b/tests/merge/merge_helpers.c
index 53a0e7b4d..154985f11 100644
--- a/tests/merge/merge_helpers.c
+++ b/tests/merge/merge_helpers.c
@@ -79,7 +79,7 @@ int merge_commits_from_branches(
 	return 0;
 }
 
-int merge_branches(git_merge_result **result, git_repository *repo,
+int merge_branches(git_repository *repo,
 	const char *ours_branch, const char *theirs_branch,
 	git_merge_options *merge_opts, git_checkout_options *checkout_opts)
 {
@@ -95,7 +95,7 @@ int merge_branches(git_merge_result **result, git_repository *repo,
 	cl_git_pass(git_reference_lookup(&theirs_ref, repo, theirs_branch));
 	cl_git_pass(git_merge_head_from_ref(&theirs_head, repo, theirs_ref));
 
-	cl_git_pass(git_merge(result, repo, (const git_merge_head **)&theirs_head, 1, merge_opts, checkout_opts));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)&theirs_head, 1, merge_opts, checkout_opts));
 
 	git_reference_free(head_ref);
 	git_reference_free(theirs_ref);
diff --git a/tests/merge/merge_helpers.h b/tests/merge/merge_helpers.h
index 71f84467d..fddf8fab1 100644
--- a/tests/merge/merge_helpers.h
+++ b/tests/merge/merge_helpers.h
@@ -92,7 +92,7 @@ int merge_commits_from_branches(
 	const char *ours_name, const char *theirs_name,
 	git_merge_options *opts);
 
-int merge_branches(git_merge_result **result, git_repository *repo,
+int merge_branches(git_repository *repo,
 	const char *ours_branch, const char *theirs_branch,
 	git_merge_options *merge_opts, git_checkout_options *checkout_opts);
 
diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
index 99d0d5433..1d596c51a 100644
--- a/tests/merge/workdir/dirty.c
+++ b/tests/merge/workdir/dirty.c
@@ -86,7 +86,7 @@ static void set_core_autocrlf_to(git_repository *repo, bool value)
 	git_config_free(cfg);
 }
 
-static int merge_branch(git_merge_result **result, int merge_file_favor, int checkout_strategy)
+static int merge_branch(int merge_file_favor, int checkout_strategy)
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
@@ -99,7 +99,7 @@ static int merge_branch(git_merge_result **result, int merge_file_favor, int che
 
 	merge_opts.file_favor = merge_file_favor;
 	checkout_opts.checkout_strategy = checkout_strategy;
-	error = git_merge(result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, &checkout_opts);
+	error = git_merge(repo, (const git_merge_head **)their_heads, 1, &merge_opts, &checkout_opts);
 
 	git_merge_head_free(their_heads[0]);
 
@@ -177,7 +177,6 @@ static void stage_content(char *content[])
 {
 	git_reference *head;
 	git_object *head_object;
-	git_merge_result *result = NULL;
 	git_buf path = GIT_BUF_INIT;
 	char *filename, *text;
 	size_t i;
@@ -198,7 +197,6 @@ static void stage_content(char *content[])
 		cl_git_pass(git_index_add_bypath(repo_index, filename));
 	}
 
-	git_merge_result_free(result);
 	git_object_free(head_object);
 	git_reference_free(head);
 	git_buf_free(&path);
@@ -208,7 +206,6 @@ static int merge_dirty_files(char *dirty_files[])
 {
 	git_reference *head;
 	git_object *head_object;
-	git_merge_result *result = NULL;
 	int error;
 
 	cl_git_pass(git_repository_head(&head, repo));
@@ -217,9 +214,8 @@ static int merge_dirty_files(char *dirty_files[])
 
 	write_files(dirty_files);
 
-	error = merge_branch(&result, 0, 0);
+	error = merge_branch(0, 0);
 
-	git_merge_result_free(result);
 	git_object_free(head_object);
 	git_reference_free(head);
 
@@ -230,7 +226,6 @@ static int merge_differently_filtered_files(char *files[])
 {
 	git_reference *head;
 	git_object *head_object;
-	git_merge_result *result = NULL;
 	int error;
 
 	cl_git_pass(git_repository_head(&head, repo));
@@ -242,9 +237,8 @@ static int merge_differently_filtered_files(char *files[])
 
 	cl_git_pass(git_index_write(repo_index));
 
-	error = merge_branch(&result, 0, 0);
+	error = merge_branch(0, 0);
 
-	git_merge_result_free(result);
 	git_object_free(head_object);
 	git_reference_free(head);
 
@@ -252,17 +246,9 @@ static int merge_differently_filtered_files(char *files[])
 }
 
 static int merge_staged_files(char *staged_files[])
-{
-	git_merge_result *result = NULL;
-	int error;
-	
+{	
 	stage_random_files(staged_files);
-
-	error = merge_branch(&result, 0, 0);
-
-	git_merge_result_free(result);
-
-	return error;
+	return merge_branch(0, 0);
 }
 
 void test_merge_workdir_dirty__unaffected_dirty_files_allowed(void)
@@ -297,7 +283,6 @@ void test_merge_workdir_dirty__staged_files_in_index_disallowed(void)
 
 void test_merge_workdir_dirty__identical_staged_files_allowed(void)
 {
-	git_merge_result *result;
 	char **content;
 	size_t i;
 
@@ -307,9 +292,7 @@ void test_merge_workdir_dirty__identical_staged_files_allowed(void)
 		stage_content(content);
 
 		git_index_write(repo_index);
-		cl_git_pass(merge_branch(&result, 0, 0));
-
-		git_merge_result_free(result);
+		cl_git_pass(merge_branch(0, 0));
 	}
 }
 
diff --git a/tests/merge/workdir/renames.c b/tests/merge/workdir/renames.c
index 915a9d9da..807a88f4c 100644
--- a/tests/merge/workdir/renames.c
+++ b/tests/merge/workdir/renames.c
@@ -34,7 +34,6 @@ void test_merge_workdir_renames__cleanup(void)
 
 void test_merge_workdir_renames__renames(void)
 {
-	git_merge_result *result;
 	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -67,16 +66,13 @@ void test_merge_workdir_renames__renames(void)
 	merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
 	merge_opts.rename_threshold = 50;
 
-	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, NULL));
+	cl_git_pass(merge_branches(repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, NULL));
 	cl_assert(merge_test_workdir(repo, merge_index_entries, 24));
-
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_renames__ours(void)
 {
 	git_index *index;
-	git_merge_result *result;
 	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 
@@ -107,18 +103,16 @@ void test_merge_workdir_renames__ours(void)
 	merge_opts.rename_threshold = 50;
 	checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
 
-	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, &checkout_opts));
+	cl_git_pass(merge_branches(repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, &checkout_opts));
 	cl_git_pass(git_repository_index(&index, repo));
 	cl_git_pass(git_index_write(index));
 	cl_assert(merge_test_workdir(repo, merge_index_entries, 20));
 
-	git_merge_result_free(result);
 	git_index_free(index);
 }
 
 void test_merge_workdir_renames__similar(void)
 {
-	git_merge_result *result;
 	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 
 	/*
@@ -156,9 +150,7 @@ void test_merge_workdir_renames__similar(void)
 	merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
 	merge_opts.rename_threshold = 50;
 
-	cl_git_pass(merge_branches(&result, repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, NULL));
+	cl_git_pass(merge_branches(repo, GIT_REFS_HEADS_DIR BRANCH_RENAME_OURS, GIT_REFS_HEADS_DIR BRANCH_RENAME_THEIRS, &merge_opts, NULL));
 	cl_assert(merge_test_workdir(repo, merge_index_entries, 24));
-
-	git_merge_result_free(result);
 }
 
diff --git a/tests/merge/workdir/setup.c b/tests/merge/workdir/setup.c
index 708599555..49b38b246 100644
--- a/tests/merge/workdir/setup.c
+++ b/tests/merge/workdir/setup.c
@@ -970,7 +970,6 @@ void test_merge_workdir_setup__retained_after_success(void)
 	git_oid our_oid;
 	git_reference *octo1_ref;
 	git_merge_head *our_head, *their_heads[1];
-	git_merge_result *result;
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
 	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
@@ -979,7 +978,7 @@ void test_merge_workdir_setup__retained_after_success(void)
 
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, octo1_ref));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_heads[0], 1, NULL, NULL));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)&their_heads[0], 1, NULL, NULL));
 
 	cl_assert(test_file_contents(GIT_MERGE_HEAD_FILE, OCTO1_OID "\n"));
 	cl_assert(test_file_contents(GIT_ORIG_HEAD_FILE, ORIG_HEAD "\n"));
@@ -990,7 +989,6 @@ void test_merge_workdir_setup__retained_after_success(void)
 
 	git_merge_head_free(our_head);
 	git_merge_head_free(their_heads[0]);
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_setup__removed_after_failure(void)
@@ -998,7 +996,6 @@ void test_merge_workdir_setup__removed_after_failure(void)
 	git_oid our_oid;
 	git_reference *octo1_ref;
 	git_merge_head *our_head, *their_heads[1];
-	git_merge_result *result;
 
 	cl_git_pass(git_oid_fromstr(&our_oid, ORIG_HEAD));
 	cl_git_pass(git_merge_head_from_id(&our_head, repo, &our_oid));
@@ -1010,7 +1007,7 @@ void test_merge_workdir_setup__removed_after_failure(void)
 		"Conflicting file!\n\nMerge will fail!\n");
 
 	cl_git_fail(git_merge(
-		&result, repo, (const git_merge_head **)&their_heads[0], 1, NULL, NULL));
+		repo, (const git_merge_head **)&their_heads[0], 1, NULL, NULL));
 
 	cl_assert(!git_path_exists("merge-resolve/" GIT_MERGE_HEAD_FILE));
 	cl_assert(!git_path_exists("merge-resolve/" GIT_ORIG_HEAD_FILE));
@@ -1021,5 +1018,4 @@ void test_merge_workdir_setup__removed_after_failure(void)
 
 	git_merge_head_free(our_head);
 	git_merge_head_free(their_heads[0]);
-	git_merge_result_free(result);
 }
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 05278321f..032e97f8d 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -92,11 +92,10 @@ void test_merge_workdir_simple__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-static git_merge_result *merge_simple_branch(int merge_file_favor, int checkout_strategy)
+static void merge_simple_branch(int merge_file_favor, int checkout_strategy)
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
-	git_merge_result *result;
 	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 
@@ -105,11 +104,9 @@ static git_merge_result *merge_simple_branch(int merge_file_favor, int checkout_
 
 	merge_opts.file_favor = merge_file_favor;
 	checkout_opts.checkout_strategy = checkout_strategy;
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, &checkout_opts));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)their_heads, 1, &merge_opts, &checkout_opts));
 
 	git_merge_head_free(their_heads[0]);
-
-	return result;
 }
 
 static void set_core_autocrlf_to(git_repository *repo, bool value)
@@ -126,7 +123,6 @@ void test_merge_workdir_simple__automerge(void)
 {
 	git_index *index;
 	const git_index_entry *entry;
-	git_merge_result *result;
 	git_buf automergeable_buf = GIT_BUF_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -151,8 +147,7 @@ void test_merge_workdir_simple__automerge(void)
 
 	set_core_autocrlf_to(repo, false);
 
-	cl_assert(result = merge_simple_branch(0, 0));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(0, 0);
 
 	cl_git_pass(git_futils_readbuffer(&automergeable_buf,
 		TEST_REPO_PATH "/automergeable.txt"));
@@ -162,8 +157,6 @@ void test_merge_workdir_simple__automerge(void)
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
 
-	git_merge_result_free(result);
-
 	git_repository_index(&index, repo);
 
 	cl_assert((entry = git_index_get_bypath(index, "automergeable.txt", 0)) != NULL);
@@ -177,8 +170,6 @@ void test_merge_workdir_simple__automerge_crlf(void)
 #ifdef GIT_WIN32
 	git_index *index;
 	const git_index_entry *entry;
-
-	git_merge_result *result;
 	git_buf automergeable_buf = GIT_BUF_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -202,8 +193,7 @@ void test_merge_workdir_simple__automerge_crlf(void)
 
 	set_core_autocrlf_to(repo, true);
 
-	cl_assert(result = merge_simple_branch(0, 0));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(0, 0);
 
 	cl_git_pass(git_futils_readbuffer(&automergeable_buf,
 		TEST_REPO_PATH "/automergeable.txt"));
@@ -213,8 +203,6 @@ void test_merge_workdir_simple__automerge_crlf(void)
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
 
-	git_merge_result_free(result);
-
 	git_repository_index(&index, repo);
 
 	cl_assert((entry = git_index_get_bypath(index, "automergeable.txt", 0)) != NULL);
@@ -226,7 +214,6 @@ void test_merge_workdir_simple__automerge_crlf(void)
 
 void test_merge_workdir_simple__mergefile(void)
 {
-	git_merge_result *result;
 	git_buf conflicting_buf = GIT_BUF_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -248,8 +235,7 @@ void test_merge_workdir_simple__mergefile(void)
 		REMOVED_IN_MASTER_REUC_ENTRY
 	};
 
-	cl_assert(result = merge_simple_branch(0, 0));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(0, 0);
 
 	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
 		TEST_REPO_PATH "/conflicting.txt"));
@@ -258,13 +244,10 @@ void test_merge_workdir_simple__mergefile(void)
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
-
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__diff3(void)
 {
-	git_merge_result *result;
 	git_buf conflicting_buf = GIT_BUF_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -286,8 +269,7 @@ void test_merge_workdir_simple__diff3(void)
 		REMOVED_IN_MASTER_REUC_ENTRY
 	};
 
-	cl_assert(result = merge_simple_branch(0, GIT_CHECKOUT_CONFLICT_STYLE_DIFF3));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(0, GIT_CHECKOUT_CONFLICT_STYLE_DIFF3);
 
 	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
 		TEST_REPO_PATH "/conflicting.txt"));
@@ -296,13 +278,10 @@ void test_merge_workdir_simple__diff3(void)
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
-
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__union(void)
 {
-	git_merge_result *result;
 	git_buf conflicting_buf = GIT_BUF_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -325,8 +304,7 @@ void test_merge_workdir_simple__union(void)
 
 	set_core_autocrlf_to(repo, false);
 
-	cl_assert(result = merge_simple_branch(GIT_MERGE_FILE_FAVOR_UNION, 0));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(GIT_MERGE_FILE_FAVOR_UNION, 0);
 
 	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
 		TEST_REPO_PATH "/conflicting.txt"));
@@ -335,13 +313,10 @@ void test_merge_workdir_simple__union(void)
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 4));
-
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__diff3_from_config(void)
 {
-	git_merge_result *result;
 	git_config *config;
 	git_buf conflicting_buf = GIT_BUF_INIT;
 
@@ -367,8 +342,7 @@ void test_merge_workdir_simple__diff3_from_config(void)
 	cl_git_pass(git_repository_config(&config, repo));
 	cl_git_pass(git_config_set_string(config, "merge.conflictstyle", "diff3"));
 
-	cl_assert(result = merge_simple_branch(0, 0));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(0, 0);
 
 	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
 		TEST_REPO_PATH "/conflicting.txt"));
@@ -378,13 +352,11 @@ void test_merge_workdir_simple__diff3_from_config(void)
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
 
-	git_merge_result_free(result);
 	git_config_free(config);
 }
 
 void test_merge_workdir_simple__merge_overrides_config(void)
 {
-	git_merge_result *result;
 	git_config *config;
 	git_buf conflicting_buf = GIT_BUF_INIT;
 
@@ -410,8 +382,7 @@ void test_merge_workdir_simple__merge_overrides_config(void)
 	cl_git_pass(git_repository_config(&config, repo));
 	cl_git_pass(git_config_set_string(config, "merge.conflictstyle", "diff3"));
 
-	cl_assert(result = merge_simple_branch(0, GIT_CHECKOUT_CONFLICT_STYLE_MERGE));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(0, GIT_CHECKOUT_CONFLICT_STYLE_MERGE);
 
 	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
 		TEST_REPO_PATH "/conflicting.txt"));
@@ -421,14 +392,11 @@ void test_merge_workdir_simple__merge_overrides_config(void)
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
 
-	git_merge_result_free(result);
 	git_config_free(config);
 }
 
 void test_merge_workdir_simple__checkout_ours(void)
 {
-	git_merge_result *result;
-
 	struct merge_index_entry merge_index_entries[] = {
 		ADDED_IN_MASTER_INDEX_ENTRY,
 		AUTOMERGEABLE_INDEX_ENTRY,
@@ -448,21 +416,16 @@ void test_merge_workdir_simple__checkout_ours(void)
 		REMOVED_IN_MASTER_REUC_ENTRY
 	};
 
-	cl_assert(result = merge_simple_branch(0, GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(0, GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS);
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
 
 	cl_assert(git_path_exists(TEST_REPO_PATH "/conflicting.txt"));
-
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__favor_ours(void)
 {
-	git_merge_result *result;
-
 	struct merge_index_entry merge_index_entries[] = {
 		ADDED_IN_MASTER_INDEX_ENTRY,
 		AUTOMERGEABLE_INDEX_ENTRY,
@@ -479,19 +442,14 @@ void test_merge_workdir_simple__favor_ours(void)
 		REMOVED_IN_MASTER_REUC_ENTRY,
 	};
 
-	cl_assert(result = merge_simple_branch(GIT_MERGE_FILE_FAVOR_OURS, 0));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(GIT_MERGE_FILE_FAVOR_OURS, 0);
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 4));
-
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__favor_theirs(void)
 {
-	git_merge_result *result;
-
 	struct merge_index_entry merge_index_entries[] = {
 		ADDED_IN_MASTER_INDEX_ENTRY,
 		AUTOMERGEABLE_INDEX_ENTRY,
@@ -508,13 +466,10 @@ void test_merge_workdir_simple__favor_theirs(void)
 		REMOVED_IN_MASTER_REUC_ENTRY,
 	};
 
-	cl_assert(result = merge_simple_branch(GIT_MERGE_FILE_FAVOR_THEIRS, 0));
-	cl_assert(!git_merge_result_is_fastforward(result));
+	merge_simple_branch(GIT_MERGE_FILE_FAVOR_THEIRS, 0);
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 6));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 4));
-
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__directory_file(void)
@@ -522,7 +477,6 @@ void test_merge_workdir_simple__directory_file(void)
 	git_reference *head;
 	git_oid their_oids[1], head_commit_id;
 	git_merge_head *their_heads[1];
-	git_merge_result *result;
 	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 	git_commit *head_commit;
 
@@ -558,21 +512,19 @@ void test_merge_workdir_simple__directory_file(void)
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
 	merge_opts.file_favor = 0;
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 20));
 
 	git_reference_free(head);
 	git_commit_free(head_commit);
 	git_merge_head_free(their_heads[0]);
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__unrelated(void)
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
-	git_merge_result *result;
 	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -591,19 +543,17 @@ void test_merge_workdir_simple__unrelated(void)
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
 	merge_opts.file_favor = 0;
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 9));
 
 	git_merge_head_free(their_heads[0]);
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__unrelated_with_conflicts(void)
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
-	git_merge_result *result;
 	git_merge_options merge_opts = GIT_MERGE_OPTIONS_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -624,12 +574,11 @@ void test_merge_workdir_simple__unrelated_with_conflicts(void)
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
 	merge_opts.file_favor = 0;
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)their_heads, 1, &merge_opts, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 11));
 
 	git_merge_head_free(their_heads[0]);
-	git_merge_result_free(result);
 }
 
 void test_merge_workdir_simple__binary(void)
@@ -637,7 +586,6 @@ void test_merge_workdir_simple__binary(void)
 	git_oid our_oid, their_oid, our_file_oid;
 	git_commit *our_commit;
 	git_merge_head *their_head;
-	git_merge_result *result;
 	const git_index_entry *binary_entry;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -654,7 +602,7 @@ void test_merge_workdir_simple__binary(void)
 
 	cl_git_pass(git_merge_head_from_id(&their_head, repo, &their_oid));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
 
@@ -665,6 +613,5 @@ void test_merge_workdir_simple__binary(void)
 	cl_assert(git_oid_cmp(&binary_entry->id, &our_file_oid) == 0);
 
 	git_merge_head_free(their_head);
-	git_merge_result_free(result);
 	git_commit_free(our_commit);
 }
diff --git a/tests/merge/workdir/submodules.c b/tests/merge/workdir/submodules.c
index 296f30de5..e093e77ab 100644
--- a/tests/merge/workdir/submodules.c
+++ b/tests/merge/workdir/submodules.c
@@ -31,7 +31,6 @@ void test_merge_workdir_submodules__automerge(void)
 	git_reference *our_ref, *their_ref;
 	git_commit *our_commit;
 	git_merge_head *their_head;
-	git_merge_result *result;
 	git_index *index;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -50,13 +49,12 @@ void test_merge_workdir_submodules__automerge(void)
 	cl_git_pass(git_reference_lookup(&their_ref, repo, "refs/heads/" SUBMODULE_OTHER_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
 
 	cl_git_pass(git_repository_index(&index, repo));
 	cl_assert(merge_test_index(index, merge_index_entries, 6));
 
 	git_index_free(index);
-	git_merge_result_free(result);
 	git_merge_head_free(their_head);
 	git_commit_free(our_commit);
 	git_reference_free(their_ref);
@@ -68,7 +66,6 @@ void test_merge_workdir_submodules__take_changed(void)
 	git_reference *our_ref, *their_ref;
 	git_commit *our_commit;
 	git_merge_head *their_head;
-	git_merge_result *result;
 	git_index *index;
 
 	struct merge_index_entry merge_index_entries[] = {
@@ -85,13 +82,12 @@ void test_merge_workdir_submodules__take_changed(void)
 	cl_git_pass(git_reference_lookup(&their_ref, repo, "refs/heads/" SUBMODULE_OTHER2_BRANCH));
 	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)&their_head, 1, NULL, NULL));
 
 	cl_git_pass(git_repository_index(&index, repo));
 	cl_assert(merge_test_index(index, merge_index_entries, 4));
 
 	git_index_free(index);
-	git_merge_result_free(result);
 	git_merge_head_free(their_head);
 	git_commit_free(our_commit);
 	git_reference_free(their_ref);
diff --git a/tests/merge/workdir/trivial.c b/tests/merge/workdir/trivial.c
index ffbb56cab..cc82d990c 100644
--- a/tests/merge/workdir/trivial.c
+++ b/tests/merge/workdir/trivial.c
@@ -34,7 +34,6 @@ static int merge_trivial(const char *ours, const char *theirs)
 	git_checkout_options checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_reference *our_ref, *their_ref;
 	git_merge_head *their_heads[1];
-	git_merge_result *result;
 
 	checkout_opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
@@ -48,13 +47,12 @@ static int merge_trivial(const char *ours, const char *theirs)
 	cl_git_pass(git_reference_lookup(&their_ref, repo, branch_buf.ptr));
 	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, their_ref));
 
-	cl_git_pass(git_merge(&result, repo, (const git_merge_head **)their_heads, 1, NULL, NULL));
+	cl_git_pass(git_merge(repo, (const git_merge_head **)their_heads, 1, NULL, NULL));
 
 	git_buf_free(&branch_buf);
 	git_reference_free(our_ref);
 	git_reference_free(their_ref);
 	git_merge_head_free(their_heads[0]);
-	git_merge_result_free(result);
 
 	return 0;
 }
-- 
cgit v1.2.3


From 97f3462ae699fae370cfa410ed58eb869ae6b276 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 18 Mar 2014 13:14:09 -0700
Subject: git_merge_status -> git_merge_analysis

---
 include/git2/merge.h           | 23 ++++++-----
 src/merge.c                    | 10 ++---
 tests/merge/workdir/analysis.c | 90 ++++++++++++++++++++++++++++++++++++++++++
 tests/merge/workdir/status.c   | 89 -----------------------------------------
 4 files changed, 108 insertions(+), 104 deletions(-)
 create mode 100644 tests/merge/workdir/analysis.c
 delete mode 100644 tests/merge/workdir/status.c

diff --git a/include/git2/merge.h b/include/git2/merge.h
index a4432eef3..2cb8df36c 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -235,41 +235,44 @@ GIT_EXTERN(int) git_merge_init_options(
 	int version);
 
 /**
- * The results of `git_merge_status` indicate the state of a merge scenario.
+ * The results of `git_merge_analysis` indicate the merge opportunities.
  */
 typedef enum {
+	/** No merge is possible.  (Unused.) */
+	GIT_MERGE_ANALYSIS_NONE = 0,
+
 	/**
 	 * A "normal" merge; both HEAD and the given merge input have diverged
 	 * from their common ancestor.  The divergent commits must be merged.
 	 */
-	GIT_MERGE_STATUS_NORMAL = 0,
+	GIT_MERGE_ANALYSIS_NORMAL = (1 << 0),
 
 	/**
 	 * The repository is already up-to-date and no merge needs to be
 	 * performed.  The given merge input already exists as a parent of HEAD.
 	 */
-	GIT_MERGE_STATUS_UP_TO_DATE = (1 << 0),
+	GIT_MERGE_ANALYSIS_UP_TO_DATE = (1 << 1),
 
 	/**
 	 * The given merge input is a fast-forward from HEAD and no merge
 	 * needs to be performed.  Instead, the client can check out the
 	 * given merge input.
 	 */
-	GIT_MERGE_STATUS_FASTFORWARD = (1 << 1),
-} git_merge_status_t;
+	GIT_MERGE_ANALYSIS_FASTFORWARD = (1 << 2),
+} git_merge_analysis_t;
 
 /**
- * Determine the status of the merge between the given branch(es) and the
- * HEAD of the repository.
+ * Analyzes the given branch(es) and determines the opportunities for
+ * merging them into the HEAD of the repository.
  *
- * @param status_out status enumeration that the result is written into
+ * @param analysis_out analysis enumeration that the result is written into
  * @param repo the repository to merge
  * @param their_heads the heads to merge into
  * @param their_heads_len the number of heads to merge
  * @return 0 on success or error code
  */
-GIT_EXTERN(int) git_merge_status(
-	git_merge_status_t *status_out,
+GIT_EXTERN(int) git_merge_analysis(
+	git_merge_analysis_t *analysis_out,
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len);
diff --git a/src/merge.c b/src/merge.c
index 66b8be684..6b416a3ef 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2517,8 +2517,8 @@ done:
 	return error;
 }
 
-int git_merge_status(
-	git_merge_status_t *out,
+int git_merge_analysis(
+	git_merge_analysis_t *out,
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len)
@@ -2528,7 +2528,7 @@ int git_merge_status(
 
 	assert(out && repo && their_heads);
 
-	*out = GIT_MERGE_STATUS_NORMAL;
+	*out = GIT_MERGE_ANALYSIS_NORMAL;
 
 	if ((error = merge_heads(&ancestor_head, &our_head, repo, their_heads, their_heads_len)) < 0)
 		goto done;
@@ -2536,11 +2536,11 @@ int git_merge_status(
 	if (their_heads_len == 1 && ancestor_head != NULL) {
 		/* We're up-to-date if we're trying to merge our own common ancestor. */
 		if (git_oid_equal(&ancestor_head->oid, &their_heads[0]->oid))
-			*out = GIT_MERGE_STATUS_UP_TO_DATE;
+			*out = GIT_MERGE_ANALYSIS_UP_TO_DATE;
 
 		/* We're fastforwardable if we're our own common ancestor. */
 		else if (git_oid_equal(&ancestor_head->oid, &our_head->oid))
-			*out = GIT_MERGE_STATUS_FASTFORWARD;
+			*out = GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_NORMAL;
 	}
 
 done:
diff --git a/tests/merge/workdir/analysis.c b/tests/merge/workdir/analysis.c
new file mode 100644
index 000000000..6a4b86d26
--- /dev/null
+++ b/tests/merge/workdir/analysis.c
@@ -0,0 +1,90 @@
+#include "clar_libgit2.h"
+#include "git2/repository.h"
+#include "git2/merge.h"
+#include "git2/sys/index.h"
+#include "merge.h"
+#include "../merge_helpers.h"
+#include "refs.h"
+
+static git_repository *repo;
+static git_index *repo_index;
+
+#define TEST_REPO_PATH "merge-resolve"
+#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
+
+#define UPTODATE_BRANCH			"master"
+#define PREVIOUS_BRANCH			"previous"
+
+#define FASTFORWARD_BRANCH		"ff_branch"
+#define FASTFORWARD_ID			"fd89f8cffb663ac89095a0f9764902e93ceaca6a"
+
+#define NOFASTFORWARD_BRANCH	"branch"
+#define NOFASTFORWARD_ID		"7cb63eed597130ba4abb87b3e544b85021905520"
+
+
+// Fixture setup and teardown
+void test_merge_workdir_analysis__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+	git_repository_index(&repo_index, repo);
+}
+
+void test_merge_workdir_analysis__cleanup(void)
+{
+	git_index_free(repo_index);
+	cl_git_sandbox_cleanup();
+}
+
+static git_merge_analysis_t analysis_from_branch(const char *branchname)
+{
+	git_buf refname = GIT_BUF_INIT;
+	git_reference *their_ref;
+	git_merge_head *their_heads[1];
+	git_merge_analysis_t analysis;
+
+	git_buf_printf(&refname, "%s%s", GIT_REFS_HEADS_DIR, branchname);
+
+	cl_git_pass(git_reference_lookup(&their_ref, repo, git_buf_cstr(&refname)));
+	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, their_ref));
+
+	cl_git_pass(git_merge_analysis(&analysis, repo, their_heads, 1));
+
+	git_buf_free(&refname);
+	git_merge_head_free(their_heads[0]);
+	git_reference_free(their_ref);
+
+	return analysis;
+}
+
+void test_merge_workdir_analysis__fastforward(void)
+{
+	git_merge_analysis_t analysis;
+
+	analysis = analysis_from_branch(FASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (analysis & GIT_MERGE_ANALYSIS_NORMAL));
+}
+
+void test_merge_workdir_analysis__no_fastforward(void)
+{
+	git_merge_analysis_t analysis;
+
+	analysis = analysis_from_branch(NOFASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, analysis);
+}
+
+void test_merge_workdir_analysis__uptodate(void)
+{
+	git_merge_analysis_t analysis;
+
+	analysis = analysis_from_branch(UPTODATE_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, analysis);
+}
+
+void test_merge_workdir_analysis__uptodate_merging_prev_commit(void)
+{
+	git_merge_analysis_t analysis;
+
+	analysis = analysis_from_branch(PREVIOUS_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, analysis);
+}
diff --git a/tests/merge/workdir/status.c b/tests/merge/workdir/status.c
deleted file mode 100644
index 589299eff..000000000
--- a/tests/merge/workdir/status.c
+++ /dev/null
@@ -1,89 +0,0 @@
-#include "clar_libgit2.h"
-#include "git2/repository.h"
-#include "git2/merge.h"
-#include "git2/sys/index.h"
-#include "merge.h"
-#include "../merge_helpers.h"
-#include "refs.h"
-
-static git_repository *repo;
-static git_index *repo_index;
-
-#define TEST_REPO_PATH "merge-resolve"
-#define TEST_INDEX_PATH TEST_REPO_PATH "/.git/index"
-
-#define UPTODATE_BRANCH			"master"
-#define PREVIOUS_BRANCH			"previous"
-
-#define FASTFORWARD_BRANCH		"ff_branch"
-#define FASTFORWARD_ID			"fd89f8cffb663ac89095a0f9764902e93ceaca6a"
-
-#define NOFASTFORWARD_BRANCH	"branch"
-#define NOFASTFORWARD_ID		"7cb63eed597130ba4abb87b3e544b85021905520"
-
-
-// Fixture setup and teardown
-void test_merge_workdir_status__initialize(void)
-{
-	repo = cl_git_sandbox_init(TEST_REPO_PATH);
-	git_repository_index(&repo_index, repo);
-}
-
-void test_merge_workdir_status__cleanup(void)
-{
-	git_index_free(repo_index);
-	cl_git_sandbox_cleanup();
-}
-
-static git_status_t status_from_branch(const char *branchname)
-{
-	git_buf refname = GIT_BUF_INIT;
-	git_reference *their_ref;
-	git_merge_head *their_heads[1];
-	git_status_t status;
-
-	git_buf_printf(&refname, "%s%s", GIT_REFS_HEADS_DIR, branchname);
-
-	cl_git_pass(git_reference_lookup(&their_ref, repo, git_buf_cstr(&refname)));
-	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, their_ref));
-
-	cl_git_pass(git_merge_status(&status, repo, their_heads, 1));
-
-	git_buf_free(&refname);
-	git_merge_head_free(their_heads[0]);
-	git_reference_free(their_ref);
-
-	return status;
-}
-
-void test_merge_workdir_status__fastforward(void)
-{
-	git_merge_status_t status;
-
-	status = status_from_branch(FASTFORWARD_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_STATUS_FASTFORWARD, status);
-}
-
-void test_merge_workdir_status__no_fastforward(void)
-{
-	git_merge_status_t status;
-
-	status = status_from_branch(NOFASTFORWARD_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_STATUS_NORMAL, status);
-}
-
-void test_merge_workdir_status__uptodate(void)
-{
-	git_merge_status_t status;
-
-	status = status_from_branch(UPTODATE_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_STATUS_UP_TO_DATE, status);
-}
-
-void test_merge_workdir_status__uptodate_merging_prev_commit(void)
-{
-	git_merge_status_t status;
-
-	status = status_from_branch(PREVIOUS_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_STATUS_UP_TO_DATE, status);
-}
-- 
cgit v1.2.3


From ac584fcfd3e15b0a0200ee609bf964414936c710 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 18 Mar 2014 16:04:51 -0700
Subject: Introduce GIT_MERGE_ANALYSIS_UNBORN

---
 include/git2/merge.h           |  7 +++++++
 src/merge.c                    | 35 +++++++++++++++++++++++++----------
 tests/merge/workdir/analysis.c | 24 ++++++++++++++++++++----
 3 files changed, 52 insertions(+), 14 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 2cb8df36c..491f831f8 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -259,6 +259,13 @@ typedef enum {
 	 * given merge input.
 	 */
 	GIT_MERGE_ANALYSIS_FASTFORWARD = (1 << 2),
+
+	/**
+	 * The HEAD of the current repository is "unborn" and does not point to
+	 * a valid commit.  No merge can be performed, but the caller may wish
+	 * to simply set HEAD to the target commit(s).
+	 */
+	GIT_MERGE_ANALYSIS_UNBORN = (1 << 3),
 } git_merge_analysis_t;
 
 /**
diff --git a/src/merge.c b/src/merge.c
index 6b416a3ef..852043cd7 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2524,26 +2524,41 @@ int git_merge_analysis(
 	size_t their_heads_len)
 {
 	git_merge_head *ancestor_head = NULL, *our_head = NULL;
-	int error;
+	int error = 0;
 
 	assert(out && repo && their_heads);
 
-	*out = GIT_MERGE_ANALYSIS_NORMAL;
+	*out = GIT_MERGE_ANALYSIS_NONE;
+
+	if (git_repository_head_unborn(repo)) {
+		*out = GIT_MERGE_ANALYSIS_UNBORN;
+		goto done;
+	}
+
+	if (their_heads_len != 1) {
+		giterr_set(GITERR_MERGE, "Can only merge a single branch");
+		error = -1;
+		goto done;
+	}
 
 	if ((error = merge_heads(&ancestor_head, &our_head, repo, their_heads, their_heads_len)) < 0)
 		goto done;
 
-	if (their_heads_len == 1 && ancestor_head != NULL) {
-		/* We're up-to-date if we're trying to merge our own common ancestor. */
-		if (git_oid_equal(&ancestor_head->oid, &their_heads[0]->oid))
-			*out = GIT_MERGE_ANALYSIS_UP_TO_DATE;
+	/* We're up-to-date if we're trying to merge our own common ancestor. */
+	if (ancestor_head && git_oid_equal(&ancestor_head->oid, &their_heads[0]->oid))
+		*out = GIT_MERGE_ANALYSIS_UP_TO_DATE;
 
-		/* We're fastforwardable if we're our own common ancestor. */
-		else if (git_oid_equal(&ancestor_head->oid, &our_head->oid))
-			*out = GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_NORMAL;
-	}
+	/* We're fastforwardable if we're our own common ancestor. */
+	else if (ancestor_head && git_oid_equal(&ancestor_head->oid, &our_head->oid))
+		*out = GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_NORMAL;
+
+	/* Otherwise, just a normal merge is possible. */
+	else
+		*out = GIT_MERGE_ANALYSIS_NORMAL;
 
 done:
+	git_merge_head_free(ancestor_head);
+	git_merge_head_free(our_head);
 	return error;
 }
 
diff --git a/tests/merge/workdir/analysis.c b/tests/merge/workdir/analysis.c
index 6a4b86d26..86b50b718 100644
--- a/tests/merge/workdir/analysis.c
+++ b/tests/merge/workdir/analysis.c
@@ -5,6 +5,7 @@
 #include "merge.h"
 #include "../merge_helpers.h"
 #include "refs.h"
+#include "posix.h"
 
 static git_repository *repo;
 static git_index *repo_index;
@@ -39,18 +40,18 @@ static git_merge_analysis_t analysis_from_branch(const char *branchname)
 {
 	git_buf refname = GIT_BUF_INIT;
 	git_reference *their_ref;
-	git_merge_head *their_heads[1];
+	git_merge_head *their_head;
 	git_merge_analysis_t analysis;
 
 	git_buf_printf(&refname, "%s%s", GIT_REFS_HEADS_DIR, branchname);
 
 	cl_git_pass(git_reference_lookup(&their_ref, repo, git_buf_cstr(&refname)));
-	cl_git_pass(git_merge_head_from_ref(&their_heads[0], repo, their_ref));
+	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
 
-	cl_git_pass(git_merge_analysis(&analysis, repo, their_heads, 1));
+	cl_git_pass(git_merge_analysis(&analysis, repo, (const git_merge_head **)&their_head, 1));
 
 	git_buf_free(&refname);
-	git_merge_head_free(their_heads[0]);
+	git_merge_head_free(their_head);
 	git_reference_free(their_ref);
 
 	return analysis;
@@ -88,3 +89,18 @@ void test_merge_workdir_analysis__uptodate_merging_prev_commit(void)
 	analysis = analysis_from_branch(PREVIOUS_BRANCH);
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, analysis);
 }
+
+void test_merge_workdir_analysis__unborn(void)
+{
+	git_merge_analysis_t analysis;
+	git_buf master = GIT_BUF_INIT;
+
+	git_buf_joinpath(&master, git_repository_path(repo), "refs/heads/master");
+	p_unlink(git_buf_cstr(&master));
+
+	analysis = analysis_from_branch(NOFASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UNBORN, analysis);
+
+	git_buf_free(&master);
+}
+
-- 
cgit v1.2.3


From 58c2b1c4218a2f90ee2745687f2e17670bde0b1b Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Thu, 20 Mar 2014 09:35:22 -0700
Subject: UNBORN implies FAST_FORWARD

---
 include/git2/merge.h           | 4 ++--
 src/merge.c                    | 2 +-
 tests/merge/workdir/analysis.c | 3 ++-
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 491f831f8..21159d832 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -248,8 +248,8 @@ typedef enum {
 	GIT_MERGE_ANALYSIS_NORMAL = (1 << 0),
 
 	/**
-	 * The repository is already up-to-date and no merge needs to be
-	 * performed.  The given merge input already exists as a parent of HEAD.
+	 * All given merge inputs are reachable from HEAD, meaning the
+	 * repository is up-to-date and no merge needs to be performed.
 	 */
 	GIT_MERGE_ANALYSIS_UP_TO_DATE = (1 << 1),
 
diff --git a/src/merge.c b/src/merge.c
index 852043cd7..1be351577 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2531,7 +2531,7 @@ int git_merge_analysis(
 	*out = GIT_MERGE_ANALYSIS_NONE;
 
 	if (git_repository_head_unborn(repo)) {
-		*out = GIT_MERGE_ANALYSIS_UNBORN;
+		*out = GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_UNBORN;
 		goto done;
 	}
 
diff --git a/tests/merge/workdir/analysis.c b/tests/merge/workdir/analysis.c
index 86b50b718..0e937857f 100644
--- a/tests/merge/workdir/analysis.c
+++ b/tests/merge/workdir/analysis.c
@@ -99,7 +99,8 @@ void test_merge_workdir_analysis__unborn(void)
 	p_unlink(git_buf_cstr(&master));
 
 	analysis = analysis_from_branch(NOFASTFORWARD_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UNBORN, analysis);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UNBORN, (analysis & GIT_MERGE_ANALYSIS_UNBORN));
 
 	git_buf_free(&master);
 }
-- 
cgit v1.2.3


From 83504371127a1003c4060ef60e0ebf08423f1ade Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 19 Mar 2014 22:27:23 +0100
Subject: reflog: follow core.logallrefupdates

On bare by default, or when core.logallrefupdates is false, we must not
write the reflog.
---
 src/refdb_fs.c             | 41 +++++++++++++++++++-------
 tests/refs/reflog/reflog.c | 73 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 104 insertions(+), 10 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 25316fe46..9b10ef1c4 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -925,16 +925,34 @@ static int reflog_append(refdb_fs_backend *backend, const git_reference *ref, co
 static int has_reflog(git_repository *repo, const char *name);
 
 /* We only write if it's under heads/, remotes/ or notes/ or if it already has a log */
-static bool should_write_reflog(git_repository *repo, const char *name)
+static int should_write_reflog(int *write, git_repository *repo, const char *name)
 {
-	if (has_reflog(repo, name))
-		return 1;
+	git_config *config;
+	int error, logall, is_bare;
 
-	if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR) ||
-	    !git__strcmp(name, GIT_HEAD_FILE) ||
-	    !git__prefixcmp(name, GIT_REFS_REMOTES_DIR) ||
-	    !git__prefixcmp(name, GIT_REFS_NOTES_DIR))
-		return 1;
+	/* Defaults to the oppsite of being bare */
+	is_bare = git_repository_is_bare(repo);
+	logall = !is_bare;
+
+	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
+		return error;
+
+	error = git_config_get_bool(&logall, config, "core.logallrefupdates");
+	if (error < 0 && error != GIT_ENOTFOUND)
+		return error;
+
+	if (!logall) {
+		*write = 0;
+	} else if (has_reflog(repo, name)) {
+		*write = 1;
+	} else if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR) ||
+		   !git__strcmp(name, GIT_HEAD_FILE) ||
+		   !git__prefixcmp(name, GIT_REFS_REMOTES_DIR) ||
+		   !git__prefixcmp(name, GIT_REFS_NOTES_DIR)) {
+		*write = 1;
+	} else {
+		*write = 0;
+	}
 
 	return 0;
 }
@@ -1056,7 +1074,7 @@ static int refdb_fs_backend__write(
 {
 	refdb_fs_backend *backend = (refdb_fs_backend *)_backend;
 	git_filebuf file = GIT_FILEBUF_INIT;
-	int error = 0, cmp = 0;
+	int error = 0, cmp = 0, should_write;
 	const char *new_target = NULL;
 	const git_oid *new_id = NULL;
 
@@ -1094,7 +1112,10 @@ static int refdb_fs_backend__write(
 		goto on_error; /* not really error */
 	}
 
-	if (should_write_reflog(backend->repo, ref->name)) {
+	if ((error = should_write_reflog(&should_write, backend->repo, ref->name)) < 0)
+		goto on_error;
+
+	if (should_write) {
 		if ((error = reflog_append(backend, ref, NULL, NULL, who, message)) < 0)
 			goto on_error;
 		if ((error = maybe_append_head(backend, ref, who, message)) < 0)
diff --git a/tests/refs/reflog/reflog.c b/tests/refs/reflog/reflog.c
index a50d40aac..792b0f05d 100644
--- a/tests/refs/reflog/reflog.c
+++ b/tests/refs/reflog/reflog.c
@@ -261,3 +261,76 @@ void test_refs_reflog_reflog__do_not_append_when_no_update(void)
 
 	cl_assert_equal_i(nlogs_after, nlogs);
 }
+
+static void assert_no_reflog_update(void)
+{
+	size_t nlogs, nlogs_after;
+	size_t nlogs_master, nlogs_master_after;
+	git_reference *ref;
+	git_reflog *log;
+	git_oid id;
+
+	cl_git_pass(git_reflog_read(&log, g_repo, "HEAD"));
+	nlogs = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_git_pass(git_reflog_read(&log, g_repo, "refs/heads/master"));
+	nlogs_master = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	/* Move it back */
+	git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
+	cl_git_pass(git_reference_create(&ref, g_repo, "refs/heads/master", &id, 1, NULL, NULL));
+	git_reference_free(ref);
+
+	cl_git_pass(git_reflog_read(&log, g_repo, "HEAD"));
+	nlogs_after = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_assert_equal_i(nlogs_after, nlogs);
+
+	cl_git_pass(git_reflog_read(&log, g_repo, "refs/heads/master"));
+	nlogs_master_after = git_reflog_entrycount(log);
+	git_reflog_free(log);
+
+	cl_assert_equal_i(nlogs_after, nlogs);
+	cl_assert_equal_i(nlogs_master_after, nlogs_master);
+
+}
+
+void test_refs_reflog_reflog__logallrefupdates_bare_set_false(void)
+{
+	git_config *config;
+
+	cl_git_pass(git_repository_config(&config, g_repo));
+	cl_git_pass(git_config_set_bool(config, "core.logallrefupdates", false));
+	git_config_free(config);
+
+	assert_no_reflog_update();
+}
+
+void test_refs_reflog_reflog__logallrefupdates_bare_unset(void)
+{
+	git_config *config;
+
+	cl_git_pass(git_repository_config(&config, g_repo));
+	cl_git_pass(git_config_delete_entry(config, "core.logallrefupdates"));
+	git_config_free(config);
+
+	assert_no_reflog_update();
+}
+
+void test_refs_reflog_reflog__logallrefupdates_nonbare_set_false(void)
+{
+	git_config *config;
+
+	cl_git_sandbox_cleanup();
+	g_repo = cl_git_sandbox_init("testrepo");
+
+
+	cl_git_pass(git_repository_config(&config, g_repo));
+	cl_git_pass(git_config_set_bool(config, "core.logallrefupdates", false));
+	git_config_free(config);
+
+	assert_no_reflog_update();
+}
-- 
cgit v1.2.3


From 1c35165993c7aac42421354614e216ea8ad3f353 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 20 Mar 2014 09:55:47 +0100
Subject: reflog: remove some dead code

---
 src/refdb_fs.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 9b10ef1c4..9120a3e87 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1048,9 +1048,6 @@ static int maybe_append_head(refdb_fs_backend *backend, const git_reference *ref
 		name = git_reference_name(tmp);
 	}
 
-	if (error < 0)
-		goto cleanup;
-
 	if (strcmp(name, ref->name))
 		goto cleanup;
 
-- 
cgit v1.2.3


From 704b55cce33aa8665c558347c104041d3ec6e2f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 20 Mar 2014 20:24:11 +0100
Subject: revwalk: don't try to find merge bases when there can be none

As a way to speed up the cases where we need to hide some commits, we
find out what the merge bases are so we know to stop marking commits as
uninteresting and avoid walking down a potentially very large amount of
commits which we will never see. There are however two oversights in
current code.

The merge-base finding algorithm fails to recognize that if it is only
given one commit, there can be no merge base. It instead walks down the
whole ancestor chain needlessly. Make it return an empty list
immediately in this situation.

The revwalk does not know whether the user has asked to hide any commits
at all. In situation where the user pushes multiple commits but doesn't
hide any, the above fix wouldn't do the trick. Keep track of whether the
user wants to hide any commits and only run the merge-base finding
algorithm when it's needed.
---
 src/merge.c   |  6 ++++++
 src/revwalk.c | 18 ++++++++++++++----
 src/revwalk.h |  3 ++-
 3 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/src/merge.c b/src/merge.c
index 0b11c0da3..66952c074 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -205,6 +205,12 @@ int git_merge__bases_many(git_commit_list **out, git_revwalk *walk, git_commit_l
 	git_commit_list *result = NULL, *tmp = NULL;
 	git_pqueue list;
 
+	/* If there's only the one commit, there can be no merge bases */
+	if (twos->length == 0) {
+		*out = NULL;
+		return 0;
+	}
+
 	/* if the commit is repeated, we have a our merge base already */
 	git_vector_foreach(twos, i, two) {
 		if (one == two)
diff --git a/src/revwalk.c b/src/revwalk.c
index 753911246..f037ee692 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -141,6 +141,9 @@ static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting,
 	if (commit == NULL)
 		return -1; /* error already reported by failed lookup */
 
+	if (uninteresting)
+		walk->did_hide = 1;
+
 	commit->uninteresting = uninteresting;
 	if (walk->one == NULL && !uninteresting) {
 		walk->one = commit;
@@ -390,11 +393,18 @@ static int prepare_walk(git_revwalk *walk)
 		return GIT_ITEROVER;
 	}
 
-	/* first figure out what the merge bases are */
-	if (git_merge__bases_many(&bases, walk, walk->one, &walk->twos) < 0)
-		return -1;
+	/*
+	 * If the user asked to hide commits, we need to figure out
+	 * what the merge bases are so we can know when we can stop
+	 * marking parents uninteresting.
+	 */
+	if (walk->did_hide) {
+		if (git_merge__bases_many(&bases, walk, walk->one, &walk->twos) < 0)
+			return -1;
+
+		git_commit_list_free(&bases);
+	}
 
-	git_commit_list_free(&bases);
 	if (process_commit(walk, walk->one, walk->one->uninteresting) < 0)
 		return -1;
 
diff --git a/src/revwalk.h b/src/revwalk.h
index 8c821d098..a0ce1ae86 100644
--- a/src/revwalk.h
+++ b/src/revwalk.h
@@ -32,7 +32,8 @@ struct git_revwalk {
 	int (*enqueue)(git_revwalk *, git_commit_list_node *);
 
 	unsigned walking:1,
-		first_parent: 1;
+		first_parent: 1,
+		did_hide: 1;
 	unsigned int sorting;
 
 	/* merge base calculation */
-- 
cgit v1.2.3


From 31a14982a099461a9d8a44ea773b1fef69a781a6 Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Fri, 21 Mar 2014 17:36:34 +0800
Subject: Fix wrong assertion

Fixes issue #2196
---
 src/odb.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/odb.c b/src/odb.c
index 085eda594..df2171961 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -445,7 +445,7 @@ int git_odb_get_backend(git_odb_backend **out, git_odb *odb, size_t pos)
 {
 	backend_internal *internal;
 
-	assert(odb && odb);
+	assert(out && odb);
 	internal = git_vector_get(&odb->backends, pos);
 
 	if (internal && internal->backend) {
-- 
cgit v1.2.3


From 42dee8ecd78a10c91056ac80fdf0c67a4df57337 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 23 Mar 2014 13:34:33 +0100
Subject: settings: use git_buf for returning strings

This survived the last round of culling, as the signature is only in the
comments.
---
 include/git2/common.h |  9 ++++-----
 src/settings.c        | 20 ++++++++++++++------
 tests/core/env.c      | 10 ++++++----
 3 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/include/git2/common.h b/include/git2/common.h
index 1dca8e837..a357d98ca 100644
--- a/include/git2/common.h
+++ b/include/git2/common.h
@@ -161,12 +161,12 @@ typedef enum {
  *		>Set the maximum amount of memory that can be mapped at any time
  *		by the library
  *
- *	* opts(GIT_OPT_GET_SEARCH_PATH, int level, char *out, size_t len)
+ *	* opts(GIT_OPT_GET_SEARCH_PATH, int level, git_buf *buf)
  *
  *		> Get the search path for a given level of config data.  "level" must
  *		> be one of `GIT_CONFIG_LEVEL_SYSTEM`, `GIT_CONFIG_LEVEL_GLOBAL`, or
  *		> `GIT_CONFIG_LEVEL_XDG`.  The search path is written to the `out`
- *		> buffer up to size `len`.  Returns GIT_EBUFS if buffer is too small.
+ *		> buffer.
  *
  *	* opts(GIT_OPT_SET_SEARCH_PATH, int level, const char *path)
  *
@@ -210,11 +210,10 @@ typedef enum {
  *		> Get the current bytes in cache and the maximum that would be
  *		> allowed in the cache.
  *
- *	* opts(GIT_OPT_GET_TEMPLATE_PATH, char *out, size_t len)
+ *	* opts(GIT_OPT_GET_TEMPLATE_PATH, git_buf *out)
  *
  *		> Get the default template path.
- *		> The path is written to the `out`
- *		> buffer up to size `len`.  Returns GIT_EBUFS if buffer is too small.
+ *		> The path is written to the `out` buffer.
  *
  *	* opts(GIT_OPT_SET_TEMPLATE_PATH, const char *path)
  *
diff --git a/src/settings.c b/src/settings.c
index 9308f94ec..1a21ea024 100644
--- a/src/settings.c
+++ b/src/settings.c
@@ -78,10 +78,14 @@ int git_libgit2_opts(int key, ...)
 
 	case GIT_OPT_GET_SEARCH_PATH:
 		if ((error = config_level_to_sysdir(va_arg(ap, int))) >= 0) {
-			char *out = va_arg(ap, char *);
-			size_t outlen = va_arg(ap, size_t);
+			git_buf *out = va_arg(ap, git_buf *);
+			const git_buf *tmp;
 
-			error = git_sysdir_get_str(out, outlen, error);
+			git_buf_sanitize(out);
+			if ((error = git_sysdir_get(&tmp, error)) < 0)
+				break;
+
+			error = git_buf_sets(out, tmp->ptr);
 		}
 		break;
 
@@ -113,10 +117,14 @@ int git_libgit2_opts(int key, ...)
 
 	case GIT_OPT_GET_TEMPLATE_PATH:
 		{
-			char *out = va_arg(ap, char *);
-			size_t outlen = va_arg(ap, size_t);
+			git_buf *out = va_arg(ap, git_buf *);
+			const git_buf *tmp;
+
+			git_buf_sanitize(out);
+			if ((error = git_sysdir_get(&tmp, GIT_SYSDIR_TEMPLATE)) < 0)
+				break;
 
-			error = git_sysdir_get_str(out, outlen, GIT_SYSDIR_TEMPLATE);
+			error = git_buf_sets(out, tmp->ptr);
 		}
 		break;
 
diff --git a/tests/core/env.c b/tests/core/env.c
index a32f5ed3e..4383d9695 100644
--- a/tests/core/env.c
+++ b/tests/core/env.c
@@ -218,7 +218,7 @@ void test_core_env__1(void)
 static void check_global_searchpath(
 	const char *path, int position, const char *file, git_buf *temp)
 {
-	char out[GIT_PATH_MAX];
+	git_buf out = GIT_BUF_INIT;
 
 	/* build and set new path */
 	if (position < 0)
@@ -233,12 +233,12 @@ static void check_global_searchpath(
 
 	/* get path and make sure $PATH expansion worked */
 	cl_git_pass(git_libgit2_opts(
-		GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, out, sizeof(out)));
+		GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &out));
 
 	if (position < 0)
-		cl_assert(git__prefixcmp(out, path) == 0);
+		cl_assert(git__prefixcmp(out.ptr, path) == 0);
 	else if (position > 0)
-		cl_assert(git__suffixcmp(out, path) == 0);
+		cl_assert(git__suffixcmp(out.ptr, path) == 0);
 	else
 		cl_assert_equal_s(out, path);
 
@@ -250,6 +250,8 @@ static void check_global_searchpath(
 		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, NULL));
 	cl_assert_equal_i(
 		GIT_ENOTFOUND, git_sysdir_find_global_file(temp, file));
+
+	git_buf_free(&out);
 }
 
 void test_core_env__2(void)
-- 
cgit v1.2.3


From 6057c4a038d575ff02cdfce8ad93dfb541e90b2d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 23 Mar 2014 15:48:13 +0100
Subject: opts: bits are not bytes

The default cache size is 256 megabytes, not megabits as claimed in the
docs.
---
 include/git2/common.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/common.h b/include/git2/common.h
index a357d98ca..32237efed 100644
--- a/include/git2/common.h
+++ b/include/git2/common.h
@@ -195,7 +195,7 @@ typedef enum {
  *		> across all repositories before libgit2 starts evicting objects
  *		> from the cache.  This is a soft limit, in that the library might
  *		> briefly exceed it, but will start aggressively evicting objects
- *		> from cache when that happens.  The default cache size is 256Mb.
+ *		> from cache when that happens.  The default cache size is 256MB.
  *
  *	* opts(GIT_OPT_ENABLE_CACHING, int enabled)
  *
-- 
cgit v1.2.3


From fdc54eb2fb4cf9759552eb3be137100627e0585b Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 24 Mar 2014 10:56:11 -0700
Subject: env test needs to deref git_buf's ptr

---
 tests/core/env.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/core/env.c b/tests/core/env.c
index 4383d9695..b01ad1c24 100644
--- a/tests/core/env.c
+++ b/tests/core/env.c
@@ -240,7 +240,7 @@ static void check_global_searchpath(
 	else if (position > 0)
 		cl_assert(git__suffixcmp(out.ptr, path) == 0);
 	else
-		cl_assert_equal_s(out, path);
+		cl_assert_equal_s(out.ptr, path);
 
 	/* find file using new path */
 	cl_git_pass(git_sysdir_find_global_file(temp, file));
-- 
cgit v1.2.3


From 892aa808e2e879562c45f3d0886668f86265f1cf Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Mon, 10 Mar 2014 12:00:33 -0700
Subject: Callback to hide commits in revision walker.

---
 include/git2/revwalk.h | 24 ++++++++++++++++++++++++
 src/revwalk.c          | 28 ++++++++++++++++++++++++++++
 src/revwalk.h          |  4 ++++
 3 files changed, 56 insertions(+)

diff --git a/include/git2/revwalk.h b/include/git2/revwalk.h
index aef0b5fa6..7ab082752 100644
--- a/include/git2/revwalk.h
+++ b/include/git2/revwalk.h
@@ -261,6 +261,30 @@ GIT_EXTERN(void) git_revwalk_free(git_revwalk *walk);
  */
 GIT_EXTERN(git_repository *) git_revwalk_repository(git_revwalk *walk);
 
+/**
+* This is a callback function that user can provide to hide a
+* commit and its parents. If the callback function returns true,
+* then this commit and its parents will be hidden.
+*
+* @param commit_id oid of Commit
+* @param payload User-specified pointer to data to be passed as data payload
+*/
+typedef int(*git_revwalk_hide_cb)(
+	const git_oid *commit_id,
+	void *payload);
+
+/**
+* Adds a callback function to hide a commit
+*
+* @param walk the revision walker
+* @param hide_cb  callback function to hide a commit and its parents
+* @param payload  data payload to be passed to callback function
+*/
+GIT_EXTERN(int) git_revwalk_add_hide_cb(
+	git_revwalk *walk,
+	git_revwalk_hide_cb hide_cb,
+	void *payload);
+
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/src/revwalk.c b/src/revwalk.c
index f037ee692..4e2e0330a 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -81,6 +81,11 @@ static int process_commit(git_revwalk *walk, git_commit_list_node *commit, int h
 {
 	int error;
 
+	if (!hide && walk->hide_cb)
+	{
+		hide = walk->hide_cb(&commit->oid, walk->hide_cb_payload);
+	}
+
 	if (hide && mark_uninteresting(commit) < 0)
 		return -1;
 
@@ -575,3 +580,26 @@ void git_revwalk_reset(git_revwalk *walk)
 	git_vector_clear(&walk->twos);
 }
 
+int git_revwalk_add_hide_cb(
+	git_revwalk *walk,
+	git_revwalk_hide_cb hide_cb,
+	void *payload)
+{
+	assert(walk);
+
+	if (walk->walking)
+		git_revwalk_reset(walk);
+
+	if (walk->hide_cb)
+	{
+		/* There is already a callback added */
+		giterr_set(GITERR_INVALID, "There is already a callback added to hide commits in revision walker.");
+		return -1;
+	}
+
+	walk->hide_cb = hide_cb;
+	walk->hide_cb_payload = payload;
+
+	return 0;
+}
+
diff --git a/src/revwalk.h b/src/revwalk.h
index a0ce1ae86..a0654f3e5 100644
--- a/src/revwalk.h
+++ b/src/revwalk.h
@@ -39,6 +39,10 @@ struct git_revwalk {
 	/* merge base calculation */
 	git_commit_list_node *one;
 	git_vector twos;
+
+	/* hide callback */
+	git_revwalk_hide_cb hide_cb;
+	void *hide_cb_payload;
 };
 
 git_commit_list_node *git_revwalk__commit_lookup(git_revwalk *walk, const git_oid *oid);
-- 
cgit v1.2.3


From 3a666071d92562d028e2fba3ff12c49f3155c7f2 Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Mon, 10 Mar 2014 15:38:01 -0700
Subject: Unit Tests for hide_cb in revwalk

---
 include/git2/revwalk.h |   4 +-
 tests/revwalk/hidecb.c | 199 +++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 201 insertions(+), 2 deletions(-)
 create mode 100644 tests/revwalk/hidecb.c

diff --git a/include/git2/revwalk.h b/include/git2/revwalk.h
index 7ab082752..af425c04d 100644
--- a/include/git2/revwalk.h
+++ b/include/git2/revwalk.h
@@ -263,7 +263,7 @@ GIT_EXTERN(git_repository *) git_revwalk_repository(git_revwalk *walk);
 
 /**
 * This is a callback function that user can provide to hide a
-* commit and its parents. If the callback function returns true,
+* commit and its parents. If the callback function returns non-zero value,
 * then this commit and its parents will be hidden.
 *
 * @param commit_id oid of Commit
@@ -274,7 +274,7 @@ typedef int(*git_revwalk_hide_cb)(
 	void *payload);
 
 /**
-* Adds a callback function to hide a commit
+* Adds a callback function to hide a commit and its parents
 *
 * @param walk the revision walker
 * @param hide_cb  callback function to hide a commit and its parents
diff --git a/tests/revwalk/hidecb.c b/tests/revwalk/hidecb.c
new file mode 100644
index 000000000..b6747588e
--- /dev/null
+++ b/tests/revwalk/hidecb.c
@@ -0,0 +1,199 @@
+#include "clar_libgit2.h"
+/*
+*   a4a7dce [0] Merge branch 'master' into br2
+|\
+| * 9fd738e [1] a fourth commit
+| * 4a202b3 [2] a third commit
+* | c47800c [3] branch commit one
+|/
+* 5b5b025 [5] another commit
+* 8496071 [4] testing
+*/
+static const char *commit_head = "a4a7dce85cf63874e984719f4fdd239f5145052f";
+
+static const char *commit_strs[] = {
+	"a4a7dce85cf63874e984719f4fdd239f5145052f", /* 0 */
+	"9fd738e8f7967c078dceed8190330fc8648ee56a", /* 1 */
+	"4a202b346bb0fb0db7eff3cffeb3c70babbd2045", /* 2 */
+	"c47800c7266a2be04c571c04d5a6614691ea99bd", /* 3 */
+	"8496071c1b46c854b31185ea97743be6a8774479", /* 4 */
+	"5b5b025afb0b4c913b4c338a42934a3863bf3644", /* 5 */
+};
+
+#define commit_count 6
+
+static git_oid commit_ids[commit_count];
+static git_oid _head_id;
+static git_repository *_repo;
+
+
+void test_revwalk_hidecb__initialize(void)
+{
+	int i;
+
+	cl_git_pass(git_repository_open(&_repo, cl_fixture("testrepo.git")));
+	cl_git_pass(git_oid_fromstr(&_head_id, commit_head));
+
+	for (i = 0; i < commit_count; i++)
+	{
+		cl_git_pass(git_oid_fromstr(&commit_ids[i], commit_strs[i]));
+	}
+
+}
+
+void test_revwalk_hidecb__cleanup(void)
+{
+	git_repository_free(_repo);
+	_repo = NULL;
+}
+
+/* Hide all commits */
+static int hide_every_commit_cb(const git_oid *commit_id, void *data)
+{
+	return 1;
+}
+
+/* Do not hide anything */
+static int hide_none_cb(const git_oid *commit_id, void *data)
+{
+	return 0;
+}
+
+/* Hide some commits */
+static int hide_commit_cb(const git_oid *commit_id, void *data)
+{
+	if (0 == git_oid_cmp(commit_id, &commit_ids[3]))
+		return 1;
+	else
+		return 0;
+
+}
+
+/* In payload data, pointer to a commit id is passed */
+static int hide_commit_use_payload_cb(const git_oid *commit_id, void *data)
+{
+	git_oid *hide_commit_id = data;
+	if (0 == git_oid_cmp(commit_id, hide_commit_id))
+		return 1;
+	else
+		return 0;
+}
+
+void test_revwalk_hidecb__hide_all_cb(void)
+{
+	git_revwalk *walk;
+	git_oid id;
+
+	cl_git_pass(git_revwalk_new(&walk, _repo));
+	cl_git_pass(git_revwalk_add_hide_cb(walk, hide_every_commit_cb, NULL));
+	cl_git_pass(git_revwalk_push(walk, &_head_id));
+
+	/* First call to git_revwalk_next should return GIT_ITEROVER */
+	cl_assert_equal_i(GIT_ITEROVER, git_revwalk_next(&id, walk));
+
+	git_revwalk_free(walk);
+}
+
+
+void test_revwalk_hidecb__hide_none_cb(void)
+{
+	git_revwalk *walk;
+	int i, error;
+	git_oid id;
+
+	cl_git_pass(git_revwalk_new(&walk, _repo));
+	cl_git_pass(git_revwalk_add_hide_cb(walk, hide_none_cb, NULL));
+	cl_git_pass(git_revwalk_push(walk, &_head_id));
+
+	/* It should return all 6 commits */
+	i = 0;
+	while ((error = git_revwalk_next(&id, walk)) == 0)
+		i++;
+
+	cl_assert_equal_i(i, 6);
+	cl_assert_equal_i(error, GIT_ITEROVER);
+
+	git_revwalk_free(walk);
+}
+
+void test_revwalk_hidecb__add_hide_cb_multiple_times(void)
+{
+	git_revwalk *walk;
+
+	cl_git_pass(git_revwalk_new(&walk, _repo));
+	cl_git_pass(git_revwalk_add_hide_cb(walk, hide_every_commit_cb, NULL));
+	cl_git_fail(git_revwalk_add_hide_cb(walk, hide_every_commit_cb, NULL));
+
+	git_revwalk_free(walk);
+}
+
+void test_revwalk_hidecb__add_hide_cb_during_walking(void)
+{
+	git_revwalk *walk;
+	git_oid id;
+	int error;
+
+	cl_git_pass(git_revwalk_new(&walk, _repo));
+	cl_git_pass(git_revwalk_push(walk, &_head_id));
+
+	/* Start walking without adding hide callback */
+	cl_git_pass(git_revwalk_next(&id, walk));
+
+	/* Now add hide callback */
+	cl_git_pass(git_revwalk_add_hide_cb(walk, hide_none_cb, NULL));
+
+	/* walk should be reset */
+	error = git_revwalk_next(&id, walk);
+	cl_assert_equal_i(error, GIT_ITEROVER);
+
+	git_revwalk_free(walk);
+}
+
+void test_revwalk_hidecb__hide_some_commits(void)
+{
+	git_revwalk *walk;
+	git_oid id;
+	int i, error;
+
+	cl_git_pass(git_revwalk_new(&walk, _repo));
+	cl_git_pass(git_revwalk_push(walk, &_head_id));
+
+	/* Add hide callback */
+	cl_git_pass(git_revwalk_add_hide_cb(walk, hide_commit_cb, NULL));
+
+	i = 0;
+	while ((error = git_revwalk_next(&id, walk)) == 0) {
+		cl_assert_equal_i(git_oid_cmp(&id, &commit_ids[i]), 0);
+		i++;
+	}
+
+	cl_assert_equal_i(i, 3);
+	cl_assert_equal_i(error, GIT_ITEROVER);
+
+	git_revwalk_free(walk);
+}
+
+void test_revwalk_hidecb__test_payload(void)
+{
+	git_revwalk *walk;
+	git_oid id;
+	int i, error;
+
+	cl_git_pass(git_revwalk_new(&walk, _repo));
+	cl_git_pass(git_revwalk_push(walk, &_head_id));
+
+	/* Add hide callback, pass id of parent of initial commit as payload data */
+	cl_git_pass(git_revwalk_add_hide_cb(walk, hide_commit_use_payload_cb, &commit_ids[5]));
+
+	i = 0;
+	while ((error = git_revwalk_next(&id, walk)) == 0) {
+		cl_assert_equal_i(git_oid_cmp(&id, &commit_ids[i]), 0);
+		i++;
+	}
+
+	/* walker should return four commits */
+	cl_assert_equal_i(i, 4);
+	cl_assert_equal_i(error, GIT_ITEROVER);
+
+	git_revwalk_free(walk);
+}
-- 
cgit v1.2.3


From 46e4d82d6f3e1630cacbd89af39ef3d2e9f20d09 Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Mon, 10 Mar 2014 16:21:56 -0700
Subject: Remove unused push_cb_data

---
 src/revwalk.c | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/revwalk.c b/src/revwalk.c
index 4e2e0330a..edde661e6 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -183,11 +183,6 @@ static int push_ref(git_revwalk *walk, const char *refname, int hide, int from_g
 	return push_commit(walk, &oid, hide, from_glob);
 }
 
-struct push_cb_data {
-	git_revwalk *walk;
-	int hide;
-};
-
 static int push_glob(git_revwalk *walk, const char *glob, int hide)
 {
 	int error = 0;
-- 
cgit v1.2.3


From 7ca1584b4771703bd9f9c3ad4335f6155b05450a Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Tue, 11 Mar 2014 11:49:19 -0700
Subject: Conforming to libgit2 coding style.

---
 .gitignore             | 1 +
 CMakeLists.txt         | 2 +-
 src/revwalk.c          | 5 +----
 tests/revwalk/hidecb.c | 5 ++---
 4 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/.gitignore b/.gitignore
index d4e0454fa..a28d73866 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,6 +14,7 @@
 .lock-wafbuild
 .waf*
 build/
+buildx64/
 build-amiga/
 tests/tmp/
 msvc/Debug/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cca2a120c..be3b53a8f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -221,7 +221,7 @@ IF (MSVC)
 
 	# /GF - String pooling
 	# /MP - Parallel build
-	SET(CMAKE_C_FLAGS "/GF /MP /nologo ${CMAKE_C_FLAGS}")
+	SET(CMAKE_C_FLAGS "/GF /MP /wd4244 /wd4267 /nologo ${CMAKE_C_FLAGS}")
 
 	IF (STDCALL)
 		# /Gz - stdcall calling convention
diff --git a/src/revwalk.c b/src/revwalk.c
index edde661e6..f0109360b 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -82,9 +82,7 @@ static int process_commit(git_revwalk *walk, git_commit_list_node *commit, int h
 	int error;
 
 	if (!hide && walk->hide_cb)
-	{
 		hide = walk->hide_cb(&commit->oid, walk->hide_cb_payload);
-	}
 
 	if (hide && mark_uninteresting(commit) < 0)
 		return -1;
@@ -585,8 +583,7 @@ int git_revwalk_add_hide_cb(
 	if (walk->walking)
 		git_revwalk_reset(walk);
 
-	if (walk->hide_cb)
-	{
+	if (walk->hide_cb) {
 		/* There is already a callback added */
 		giterr_set(GITERR_INVALID, "There is already a callback added to hide commits in revision walker.");
 		return -1;
diff --git a/tests/revwalk/hidecb.c b/tests/revwalk/hidecb.c
index b6747588e..4c43f613b 100644
--- a/tests/revwalk/hidecb.c
+++ b/tests/revwalk/hidecb.c
@@ -35,9 +35,7 @@ void test_revwalk_hidecb__initialize(void)
 	cl_git_pass(git_oid_fromstr(&_head_id, commit_head));
 
 	for (i = 0; i < commit_count; i++)
-	{
 		cl_git_pass(git_oid_fromstr(&commit_ids[i], commit_strs[i]));
-	}
 
 }
 
@@ -73,7 +71,7 @@ static int hide_commit_cb(const git_oid *commit_id, void *data)
 static int hide_commit_use_payload_cb(const git_oid *commit_id, void *data)
 {
 	git_oid *hide_commit_id = data;
-	if (0 == git_oid_cmp(commit_id, hide_commit_id))
+	if (git_oid_cmp(commit_id, hide_commit_id) == 0)
 		return 1;
 	else
 		return 0;
@@ -197,3 +195,4 @@ void test_revwalk_hidecb__test_payload(void)
 
 	git_revwalk_free(walk);
 }
+
-- 
cgit v1.2.3


From 169fb81d8780532ffe575b5dfbf29a1027dfe25d Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Tue, 11 Mar 2014 11:56:26 -0700
Subject: Undoing local change done for building on x64

---
 .gitignore     | 1 -
 CMakeLists.txt | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index a28d73866..d4e0454fa 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,7 +14,6 @@
 .lock-wafbuild
 .waf*
 build/
-buildx64/
 build-amiga/
 tests/tmp/
 msvc/Debug/
diff --git a/CMakeLists.txt b/CMakeLists.txt
index be3b53a8f..cca2a120c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -221,7 +221,7 @@ IF (MSVC)
 
 	# /GF - String pooling
 	# /MP - Parallel build
-	SET(CMAKE_C_FLAGS "/GF /MP /wd4244 /wd4267 /nologo ${CMAKE_C_FLAGS}")
+	SET(CMAKE_C_FLAGS "/GF /MP /nologo ${CMAKE_C_FLAGS}")
 
 	IF (STDCALL)
 		# /Gz - stdcall calling convention
-- 
cgit v1.2.3


From 892b7c9fef3aa48574b784e48a8747e77e83865b Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Tue, 11 Mar 2014 12:13:29 -0700
Subject: Correcting format of comments in header file

---
 include/git2/revwalk.h | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/include/git2/revwalk.h b/include/git2/revwalk.h
index af425c04d..1bd6186f3 100644
--- a/include/git2/revwalk.h
+++ b/include/git2/revwalk.h
@@ -262,24 +262,24 @@ GIT_EXTERN(void) git_revwalk_free(git_revwalk *walk);
 GIT_EXTERN(git_repository *) git_revwalk_repository(git_revwalk *walk);
 
 /**
-* This is a callback function that user can provide to hide a
-* commit and its parents. If the callback function returns non-zero value,
-* then this commit and its parents will be hidden.
-*
-* @param commit_id oid of Commit
-* @param payload User-specified pointer to data to be passed as data payload
-*/
+ * This is a callback function that user can provide to hide a
+ * commit and its parents. If the callback function returns non-zero value,
+ * then this commit and its parents will be hidden.
+ *
+ * @param commit_id oid of Commit
+ * @param payload User-specified pointer to data to be passed as data payload
+ */
 typedef int(*git_revwalk_hide_cb)(
 	const git_oid *commit_id,
 	void *payload);
 
 /**
-* Adds a callback function to hide a commit and its parents
-*
-* @param walk the revision walker
-* @param hide_cb  callback function to hide a commit and its parents
-* @param payload  data payload to be passed to callback function
-*/
+ * Adds a callback function to hide a commit and its parents
+ *
+ * @param walk the revision walker
+ * @param hide_cb  callback function to hide a commit and its parents
+ * @param payload  data payload to be passed to callback function
+ */
 GIT_EXTERN(int) git_revwalk_add_hide_cb(
 	git_revwalk *walk,
 	git_revwalk_hide_cb hide_cb,
-- 
cgit v1.2.3


From 34ffe22344d32d1574dc33d3c3d20556fdb152a7 Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Mon, 24 Mar 2014 11:02:02 -0700
Subject: Modified test for revwalk_hidecb

---
 tests/revwalk/hidecb.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/revwalk/hidecb.c b/tests/revwalk/hidecb.c
index 4c43f613b..c13a17747 100644
--- a/tests/revwalk/hidecb.c
+++ b/tests/revwalk/hidecb.c
@@ -60,7 +60,7 @@ static int hide_none_cb(const git_oid *commit_id, void *data)
 /* Hide some commits */
 static int hide_commit_cb(const git_oid *commit_id, void *data)
 {
-	if (0 == git_oid_cmp(commit_id, &commit_ids[3]))
+	if (0 == git_oid_cmp(commit_id, &commit_ids[5]))
 		return 1;
 	else
 		return 0;
@@ -165,7 +165,7 @@ void test_revwalk_hidecb__hide_some_commits(void)
 		i++;
 	}
 
-	cl_assert_equal_i(i, 3);
+	cl_assert_equal_i(i, 4);
 	cl_assert_equal_i(error, GIT_ITEROVER);
 
 	git_revwalk_free(walk);
-- 
cgit v1.2.3


From a15c7802c86cf995fa658ef0624c46d352ce9a81 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 25 Mar 2014 09:14:48 -0700
Subject: Make submodules externally refcounted

`git_submodule` objects were already refcounted internally in case
the submodule name was different from the path at which it was
stored.  This makes that refcounting externally used as well, so
`git_submodule_lookup` and `git_submodule_add_setup` return an
object that requires a `git_submodule_free` when done.
---
 examples/status.c                   |  25 ++--
 include/git2/submodule.h            |  44 ++++--
 src/checkout.c                      |  26 ++--
 src/diff.c                          |  31 ++--
 src/diff_file.c                     |  14 +-
 src/submodule.c                     | 106 +++++++++-----
 src/submodule.h                     |   3 -
 tests/diff/submodules.c             |  10 +-
 tests/stash/submodules.c            |   3 +
 tests/status/submodules.c           |   2 +
 tests/submodule/lookup.c            |  95 +++++--------
 tests/submodule/modify.c            |  22 ++-
 tests/submodule/status.c            | 275 ++++++++++++++----------------------
 tests/submodule/submodule_helpers.c |  29 ++++
 tests/submodule/submodule_helpers.h |   5 +
 15 files changed, 356 insertions(+), 334 deletions(-)

diff --git a/examples/status.c b/examples/status.c
index 3adfe0d5d..feba77f84 100644
--- a/examples/status.c
+++ b/examples/status.c
@@ -363,18 +363,21 @@ static void print_short(git_repository *repo, git_status_list *status)
 			unsigned int smstatus = 0;
 
 			if (!git_submodule_lookup(
-					&sm, repo, s->index_to_workdir->new_file.path) &&
-				!git_submodule_status(&smstatus, sm))
-			{
-				if (smstatus & GIT_SUBMODULE_STATUS_WD_MODIFIED)
-					extra = " (new commits)";
-				else if (smstatus & GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED)
-					extra = " (modified content)";
-				else if (smstatus & GIT_SUBMODULE_STATUS_WD_WD_MODIFIED)
-					extra = " (modified content)";
-				else if (smstatus & GIT_SUBMODULE_STATUS_WD_UNTRACKED)
-					extra = " (untracked content)";
+					&sm, repo, s->index_to_workdir->new_file.path)) {
+
+				if (!git_submodule_status(&smstatus, sm)) {
+					if (smstatus & GIT_SUBMODULE_STATUS_WD_MODIFIED)
+						extra = " (new commits)";
+					else if (smstatus & GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED)
+						extra = " (modified content)";
+					else if (smstatus & GIT_SUBMODULE_STATUS_WD_WD_MODIFIED)
+						extra = " (modified content)";
+					else if (smstatus & GIT_SUBMODULE_STATUS_WD_UNTRACKED)
+						extra = " (untracked content)";
+				}
 			}
+
+			git_submodule_free(sm);
 		}
 
 		/**
diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index ac0abc0a4..789f2c045 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -123,21 +123,27 @@ typedef enum {
  *   There may or may not be anything else at that path, but nothing that
  *   looks like a submodule.  In this case, this returns GIT_ENOTFOUND.
  *
- * The submodule object is owned by the containing repo and will be freed
- * when the repo is freed.  The caller need not free the submodule.
+ * You must call `git_submodule_free` when done with the submodule.
  *
- * @param submodule Pointer to submodule description object pointer..
- * @param repo The repository.
- * @param name The name of the submodule.  Trailing slashes will be ignored.
+ * @param out Output ptr to submodule; pass NULL to just get return code
+ * @param repo The parent repository
+ * @param name The name of or path to the submodule; trailing slashes okay
  * @return 0 on success, GIT_ENOTFOUND if submodule does not exist,
- *         GIT_EEXISTS if submodule exists in working directory only, -1 on
- *         other errors.
+ *         GIT_EEXISTS if submodule exists in working directory only,
+ *         -1 on other errors.
  */
 GIT_EXTERN(int) git_submodule_lookup(
-	git_submodule **submodule,
+	git_submodule **out,
 	git_repository *repo,
 	const char *name);
 
+/**
+ * Release a submodule
+ *
+ * @param submodule Submodule object
+ */
+GIT_EXTERN(void) git_submodule_free(git_submodule *submodule);
+
 /**
  * Iterate over all tracked submodules of a repository.
  *
@@ -175,9 +181,11 @@ GIT_EXTERN(int) git_submodule_foreach(
  * `git_submodule_add_finalize()` to wrap up adding the new submodule and
  * .gitmodules to the index to be ready to commit.
  *
- * @param submodule The newly created submodule ready to open for clone
- * @param repo Superproject repository to contain the new submodule
- * @param url URL for the submodules remote
+ * You must call `git_submodule_free` on the submodule object when done.
+ *
+ * @param out The newly created submodule ready to open for clone
+ * @param repo The repository in which you want to create the submodule
+ * @param url URL for the submodule's remote
  * @param path Path at which the submodule should be created
  * @param use_gitlink Should workdir contain a gitlink to the repo in
  *        .git/modules vs. repo directly in workdir.
@@ -185,7 +193,7 @@ GIT_EXTERN(int) git_submodule_foreach(
  *         -1 on other errors.
  */
 GIT_EXTERN(int) git_submodule_add_setup(
-	git_submodule **submodule,
+	git_submodule **out,
 	git_repository *repo,
 	const char *url,
 	const char *path,
@@ -493,15 +501,23 @@ GIT_EXTERN(int) git_submodule_open(
  *
  * Call this to reread cached submodule information for this submodule if
  * you have reason to believe that it has changed.
+ *
+ * @param submodule The submodule to reload
+ * @param force Force reload even if the data doesn't seem out of date
+ * @return 0 on success, <0 on error
  */
-GIT_EXTERN(int) git_submodule_reload(git_submodule *submodule);
+GIT_EXTERN(int) git_submodule_reload(git_submodule *submodule, int force);
 
 /**
  * Reread all submodule info.
  *
  * Call this to reload all cached submodule information for the repo.
+ *
+ * @param repo The repository to reload submodule data for
+ * @param force Force full reload even if the data doesn't seem out of date
+ * @return 0 on success, <0 on error
  */
-GIT_EXTERN(int) git_submodule_reload_all(git_repository *repo);
+GIT_EXTERN(int) git_submodule_reload_all(git_repository *repo, int force);
 
 /**
  * Get the status for a submodule.
diff --git a/src/checkout.c b/src/checkout.c
index f882f3593..da9e5a12d 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -147,19 +147,23 @@ static bool checkout_is_workdir_modified(
 		git_submodule *sm;
 		unsigned int sm_status = 0;
 		const git_oid *sm_oid = NULL;
+		bool rval = false;
 
-		if (git_submodule_lookup(&sm, data->repo, wditem->path) < 0 ||
-			git_submodule_status(&sm_status, sm) < 0)
-			return true;
-
-		if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))
+		if (git_submodule_lookup(&sm, data->repo, wditem->path) < 0) {
+			giterr_clear();
 			return true;
+		}
 
-		sm_oid = git_submodule_wd_id(sm);
-		if (!sm_oid)
-			return false;
+		if (git_submodule_status(&sm_status, sm) < 0 ||
+			GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))
+			rval = true;
+		else if ((sm_oid = git_submodule_wd_id(sm)) == NULL)
+			rval = false;
+		else
+			rval = (git_oid__cmp(&baseitem->id, sm_oid) != 0);
 
-		return (git_oid__cmp(&baseitem->id, sm_oid) != 0);
+		git_submodule_free(sm);
+		return rval;
 	}
 
 	/* Look at the cache to decide if the workdir is modified.  If not,
@@ -1510,7 +1514,7 @@ static int checkout_create_submodules(
 
 	/* initial reload of submodules if .gitmodules was changed */
 	if (data->reload_submodules &&
-		(error = git_submodule_reload_all(data->repo)) < 0)
+		(error = git_submodule_reload_all(data->repo, 1)) < 0)
 		return error;
 
 	git_vector_foreach(&data->diff->deltas, i, delta) {
@@ -1534,7 +1538,7 @@ static int checkout_create_submodules(
 	}
 
 	/* final reload once submodules have been updated */
-	return git_submodule_reload_all(data->repo);
+	return git_submodule_reload_all(data->repo, 1);
 }
 
 static int checkout_lookup_head_tree(git_tree **out, git_repository *repo)
diff --git a/src/diff.c b/src/diff.c
index dc7735f4f..25c5937e6 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -528,12 +528,15 @@ int git_diff__oid_for_file(
 	/* calculate OID for file if possible */
 	if (S_ISGITLINK(mode)) {
 		git_submodule *sm;
-		const git_oid *sm_oid;
 
-		if (!git_submodule_lookup(&sm, repo, path) &&
-			(sm_oid = git_submodule_wd_id(sm)) != NULL)
-			git_oid_cpy(oid, sm_oid);
-		else {
+		memset(oid, 0, sizeof(*oid));
+
+		if (!git_submodule_lookup(&sm, repo, path)) {
+			const git_oid *sm_oid = git_submodule_wd_id(sm);
+			if (sm_oid)
+				git_oid_cpy(oid, sm_oid);
+			git_submodule_free(sm);
+		} else {
 			/* if submodule lookup failed probably just in an intermediate
 			 * state where some init hasn't happened, so ignore the error
 			 */
@@ -615,24 +618,24 @@ static int maybe_modified_submodule(
 	}
 
 	if (ign <= 0 && git_submodule_ignore(sub) == GIT_SUBMODULE_IGNORE_ALL)
-		return 0;
-
-	if ((error = git_submodule__status(
+		/* ignore it */;
+	else if ((error = git_submodule__status(
 			&sm_status, NULL, NULL, found_oid, sub, ign)) < 0)
-		return error;
+		/* return error below */;
 
 	/* check IS_WD_UNMODIFIED because this case is only used
 	 * when the new side of the diff is the working directory
 	 */
-	if (!GIT_SUBMODULE_STATUS_IS_WD_UNMODIFIED(sm_status))
+	else if (!GIT_SUBMODULE_STATUS_IS_WD_UNMODIFIED(sm_status))
 		*status = GIT_DELTA_MODIFIED;
 
 	/* now that we have a HEAD OID, check if HEAD moved */
-	if ((sm_status & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&
+	else if ((sm_status & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&
 		!git_oid_equal(&info->oitem->id, found_oid))
 		*status = GIT_DELTA_MODIFIED;
 
-	return 0;
+	git_submodule_free(sub);
+	return error;
 }
 
 static int maybe_modified(
@@ -960,10 +963,8 @@ static int handle_unmatched_new_item(
 		delta_type = GIT_DELTA_ADDED;
 
 	else if (nitem->mode == GIT_FILEMODE_COMMIT) {
-		git_submodule *sm;
-
 		/* ignore things that are not actual submodules */
-		if (git_submodule_lookup(&sm, info->repo, nitem->path) != 0) {
+		if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {
 			giterr_clear();
 			delta_type = GIT_DELTA_IGNORED;
 		}
diff --git a/src/diff_file.c b/src/diff_file.c
index 7dabf8d6f..2f3f797c5 100644
--- a/src/diff_file.c
+++ b/src/diff_file.c
@@ -177,11 +177,17 @@ static int diff_file_content_commit_to_str(
 		unsigned int sm_status = 0;
 		const git_oid *sm_head;
 
-		if ((error = git_submodule_lookup(&sm, fc->repo, fc->file->path)) < 0 ||
-			(error = git_submodule_status(&sm_status, sm)) < 0) {
+		if ((error = git_submodule_lookup(&sm, fc->repo, fc->file->path)) < 0) {
 			/* GIT_EEXISTS means a "submodule" that has not been git added */
-			if (error == GIT_EEXISTS)
+			if (error == GIT_EEXISTS) {
+				giterr_clear();
 				error = 0;
+			}
+			return error;
+		}
+
+		if ((error = git_submodule_status(&sm_status, sm)) < 0) {
+			git_submodule_free(sm);
 			return error;
 		}
 
@@ -196,6 +202,8 @@ static int diff_file_content_commit_to_str(
 
 		if (GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))
 			status = "-dirty";
+
+		git_submodule_free(sm);
 	}
 
 	git_oid_tostr(oid, sizeof(oid), &fc->file->id);
diff --git a/src/submodule.c b/src/submodule.c
index 9eaf77dae..291311658 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -99,27 +99,55 @@ static int submodule_config_key_trunc_puts(git_buf *key, const char *suffix)
 	return git_buf_puts(key, suffix);
 }
 
+/* lookup submodule or return ENOTFOUND if it doesn't exist */
+static int submodule_lookup(
+	git_submodule **out,
+	git_strmap *cache,
+	const char *name,
+	const char *alternate)
+{
+	khiter_t pos;
+
+	/* lock cache */
+
+	pos = git_strmap_lookup_index(cache, name);
+
+	if (!git_strmap_valid_index(cache, pos) && alternate)
+		pos = git_strmap_lookup_index(cache, alternate);
+
+	if (!git_strmap_valid_index(cache, pos)) {
+		/* unlock cache */
+		return GIT_ENOTFOUND; /* don't set error - caller will cope */
+	}
+
+	if (out != NULL) {
+		git_submodule *sm = git_strmap_value_at(cache, pos);
+		GIT_REFCOUNT_INC(sm);
+		*out = sm;
+	}
+
+	/* unlock cache */
+
+	return 0;
+}
+
 /*
  * PUBLIC APIS
  */
 
 int git_submodule_lookup(
-	git_submodule **sm_ptr, /* NULL if user only wants to test existence */
+	git_submodule **out, /* NULL if user only wants to test existence */
 	git_repository *repo,
-	const char *name)       /* trailing slash is allowed */
+	const char *name)    /* trailing slash is allowed */
 {
 	int error;
-	khiter_t pos;
 
 	assert(repo && name);
 
 	if ((error = load_submodule_config(repo)) < 0)
 		return error;
 
-	pos = git_strmap_lookup_index(repo->submodules, name);
-
-	if (!git_strmap_valid_index(repo->submodules, pos)) {
-		error = GIT_ENOTFOUND;
+	if ((error = submodule_lookup(out, repo->submodules, name, NULL)) < 0) {
 
 		/* check if a plausible submodule exists at path */
 		if (git_repository_workdir(repo)) {
@@ -137,14 +165,9 @@ int git_submodule_lookup(
 		giterr_set(GITERR_SUBMODULE, (error == GIT_ENOTFOUND) ?
 			"No submodule named '%s'" :
 			"Submodule '%s' has not been added yet", name);
-
-		return error;
 	}
 
-	if (sm_ptr)
-		*sm_ptr = git_strmap_value_at(repo->submodules, pos);
-
-	return 0;
+	return error;
 }
 
 int git_submodule_foreach(
@@ -203,7 +226,7 @@ void git_submodule_config_free(git_repository *repo)
 }
 
 int git_submodule_add_setup(
-	git_submodule **submodule,
+	git_submodule **out,
 	git_repository *repo,
 	const char *url,
 	const char *path,
@@ -211,7 +234,7 @@ int git_submodule_add_setup(
 {
 	int error = 0;
 	git_config_backend *mods = NULL;
-	git_submodule *sm;
+	git_submodule *sm = NULL;
 	git_buf name = GIT_BUF_INIT, real_url = GIT_BUF_INIT;
 	git_repository_init_options initopt = GIT_REPOSITORY_INIT_OPTIONS_INIT;
 	git_repository *subrepo = NULL;
@@ -223,6 +246,7 @@ int git_submodule_add_setup(
 	if (git_submodule_lookup(&sm, repo, path) < 0)
 		giterr_clear();
 	else {
+		git_submodule_free(sm);
 		giterr_set(GITERR_SUBMODULE,
 			"Attempt to add a submodule that already exists");
 		return GIT_EEXISTS;
@@ -307,12 +331,16 @@ int git_submodule_add_setup(
 	/* add submodule to hash and "reload" it */
 
 	if (!(error = submodule_get(&sm, repo, path, NULL)) &&
-		!(error = git_submodule_reload(sm)))
+		!(error = git_submodule_reload(sm, false)))
 		error = git_submodule_init(sm, false);
 
 cleanup:
-	if (submodule != NULL)
-		*submodule = !error ? sm : NULL;
+	if (error && sm) {
+		git_submodule_free(sm);
+		sm = NULL;
+	}
+	if (out != NULL)
+		*out = sm;
 
 	if (mods != NULL)
 		git_config_file_free(mods);
@@ -775,8 +803,9 @@ int git_submodule_open(git_repository **subrepo, git_submodule *sm)
 	return git_submodule__open(subrepo, sm, false);
 }
 
-int git_submodule_reload_all(git_repository *repo)
+int git_submodule_reload_all(git_repository *repo, int force)
 {
+	GIT_UNUSED(force);
 	assert(repo);
 	git_submodule_config_free(repo);
 	return load_submodule_config(repo);
@@ -855,11 +884,13 @@ static int submodule_update_head(git_submodule *submodule)
 	return 0;
 }
 
-int git_submodule_reload(git_submodule *submodule)
+int git_submodule_reload(git_submodule *submodule, int force)
 {
 	int error = 0;
 	git_config_backend *mods;
 
+	GIT_UNUSED(force);
+
 	assert(submodule);
 
 	/* refresh index data */
@@ -1042,17 +1073,15 @@ void git_submodule_free(git_submodule *sm)
 }
 
 static int submodule_get(
-	git_submodule **sm_ptr,
+	git_submodule **out,
 	git_repository *repo,
 	const char *name,
 	const char *alternate)
 {
+	int error = 0;
 	git_strmap *smcfg = repo->submodules;
 	khiter_t pos;
 	git_submodule *sm;
-	int error;
-
-	assert(repo && name);
 
 	pos = git_strmap_lookup_index(smcfg, name);
 
@@ -1068,22 +1097,28 @@ static int submodule_get(
 		 */
 		pos = kh_put(str, smcfg, sm->name, &error);
 
-		if (error < 0) {
-			git_submodule_free(sm);
-			sm = NULL;
-		} else if (error == 0) {
+		if (error < 0)
+			goto done;
+		else if (error == 0) {
 			git_submodule_free(sm);
 			sm = git_strmap_value_at(smcfg, pos);
 		} else {
+			error = 0;
 			git_strmap_set_value_at(smcfg, pos, sm);
 		}
 	} else {
 		sm = git_strmap_value_at(smcfg, pos);
 	}
 
-	*sm_ptr = sm;
+done:
+	if (error < 0)
+		git_submodule_free(sm);
+	else if (out) {
+		GIT_REFCOUNT_INC(sm);
+		*out = sm;
+	}
 
-	return (sm != NULL) ? 0 : -1;
+	return error;
 }
 
 static int submodule_config_error(const char *property, const char *value)
@@ -1143,7 +1178,7 @@ static int submodule_load_from_config(
 	const char *namestart, *property, *alternate = NULL;
 	const char *key = entry->name, *value = entry->value, *path;
 	git_buf name = GIT_BUF_INIT;
-	git_submodule *sm;
+	git_submodule *sm = NULL;
 	int error = 0;
 
 	if (git__prefixcmp(key, "submodule.") != 0)
@@ -1242,6 +1277,7 @@ static int submodule_load_from_config(
 	/* ignore other unknown submodule properties */
 
 done:
+	git_submodule_free(sm); /* offset refcount inc from submodule_get() */
 	git_buf_free(&name);
 	return error;
 }
@@ -1293,8 +1329,10 @@ static int load_submodule_config_from_index(
 			else
 				sm->flags |= GIT_SUBMODULE_STATUS__INDEX_NOT_SUBMODULE;
 		} else if (S_ISGITLINK(entry->mode)) {
-			if (!submodule_get(&sm, repo, entry->path, NULL))
+			if (!submodule_get(&sm, repo, entry->path, NULL)) {
 				submodule_update_from_index_entry(sm, entry);
+				git_submodule_free(sm);
+			}
 		} else if (strcmp(entry->path, GIT_MODULES_FILE) == 0)
 			git_oid_cpy(gitmodules_oid, &entry->id);
 	}
@@ -1339,9 +1377,11 @@ static int load_submodule_config_from_head(
 			else
 				sm->flags |= GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE;
 		} else if (S_ISGITLINK(entry->mode)) {
-			if (!submodule_get(&sm, repo, entry->path, NULL))
+			if (!submodule_get(&sm, repo, entry->path, NULL)) {
 				submodule_update_from_head_data(
 					sm, entry->mode, &entry->id);
+				git_submodule_free(sm);
+			}
 		} else if (strcmp(entry->path, GIT_MODULES_FILE) == 0 &&
 				   git_oid_iszero(gitmodules_oid)) {
 			git_oid_cpy(gitmodules_oid, &entry->id);
diff --git a/src/submodule.h b/src/submodule.h
index 5e532e1ae..de7f7b581 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -128,9 +128,6 @@ extern int git_submodule_open_bare(
 	git_repository **repo,
 	git_submodule *submodule);
 
-/* Release reference to submodule object - not currently for external use */
-extern void git_submodule_free(git_submodule *sm);
-
 extern int git_submodule_parse_ignore(
 	git_submodule_ignore_t *out, const char *value);
 extern int git_submodule_parse_update(
diff --git a/tests/diff/submodules.c b/tests/diff/submodules.c
index da96ba9c5..62e07e0c6 100644
--- a/tests/diff/submodules.c
+++ b/tests/diff/submodules.c
@@ -123,7 +123,7 @@ void test_diff_submodules__dirty_submodule_2(void)
 
 	g_repo = setup_fixture_submodules();
 
-	cl_git_pass(git_submodule_reload_all(g_repo));
+	cl_git_pass(git_submodule_reload_all(g_repo, 1));
 
 	opts.flags = GIT_DIFF_INCLUDE_UNTRACKED |
 		GIT_DIFF_SHOW_UNTRACKED_CONTENT |
@@ -157,7 +157,7 @@ void test_diff_submodules__dirty_submodule_2(void)
 
 	git_diff_free(diff);
 
-	cl_git_pass(git_submodule_reload_all(g_repo));
+	cl_git_pass(git_submodule_reload_all(g_repo, 1));
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	check_diff_patches(diff, expected_dirty);
@@ -281,7 +281,9 @@ void test_diff_submodules__invalid_cache(void)
 	check_diff_patches(diff, expected_dirty);
 	git_diff_free(diff);
 
-	cl_git_pass(git_submodule_reload_all(g_repo));
+	git_submodule_free(sm);
+
+	cl_git_pass(git_submodule_reload_all(g_repo, 1));
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, smpath));
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
@@ -334,6 +336,8 @@ void test_diff_submodules__invalid_cache(void)
 
 	p_unlink("submod2/sm_changed_head/new_around_here");
 
+	git_submodule_free(sm);
+
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	check_diff_patches(diff, expected_moved);
 	git_diff_free(diff);
diff --git a/tests/stash/submodules.c b/tests/stash/submodules.c
index 137c4408c..8cadca0f2 100644
--- a/tests/stash/submodules.c
+++ b/tests/stash/submodules.c
@@ -19,6 +19,9 @@ void test_stash_submodules__initialize(void)
 
 void test_stash_submodules__cleanup(void)
 {
+	git_submodule_free(sm);
+	sm = NULL;
+
 	git_signature_free(signature);
 	signature = NULL;
 }
diff --git a/tests/status/submodules.c b/tests/status/submodules.c
index 80ff162fd..8575f9f2d 100644
--- a/tests/status/submodules.c
+++ b/tests/status/submodules.c
@@ -29,6 +29,7 @@ void test_status_submodules__api(void)
 	cl_assert(sm != NULL);
 	cl_assert_equal_s("testrepo", git_submodule_name(sm));
 	cl_assert_equal_s("testrepo", git_submodule_path(sm));
+	git_submodule_free(sm);
 }
 
 void test_status_submodules__0(void)
@@ -136,6 +137,7 @@ void test_status_submodules__moved_head(void)
 
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, "testrepo"));
 	cl_git_pass(git_submodule_open(&smrepo, sm));
+	git_submodule_free(sm);
 
 	/* move submodule HEAD to c47800c7266a2be04c571c04d5a6614691ea99bd */
 	cl_git_pass(
diff --git a/tests/submodule/lookup.c b/tests/submodule/lookup.c
index ac3fa0415..cc29b11b2 100644
--- a/tests/submodule/lookup.c
+++ b/tests/submodule/lookup.c
@@ -12,31 +12,25 @@ void test_submodule_lookup__initialize(void)
 
 void test_submodule_lookup__simple_lookup(void)
 {
-	git_submodule *sm;
-
-	/* lookup existing */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_assert(sm);
+	assert_submodule_exists(g_repo, "sm_unchanged");
 
 	/* lookup pending change in .gitmodules that is not in HEAD */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
-	cl_assert(sm);
+	assert_submodule_exists(g_repo, "sm_added_and_uncommited");
 
-	/* lookup pending change in .gitmodules that is neither in HEAD nor index */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_gitmodules_only"));
-	cl_assert(sm);
+	/* lookup pending change in .gitmodules that is not in HEAD nor index */
+	assert_submodule_exists(g_repo, "sm_gitmodules_only");
 
 	/* lookup git repo subdir that is not added as submodule */
-	cl_assert(git_submodule_lookup(&sm, g_repo, "not-submodule") == GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
 
 	/* lookup existing directory that is not a submodule */
-	cl_assert(git_submodule_lookup(&sm, g_repo, "just_a_dir") == GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
 
 	/* lookup existing file that is not a submodule */
-	cl_assert(git_submodule_lookup(&sm, g_repo, "just_a_file") == GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "just_a_file", GIT_ENOTFOUND);
 
 	/* lookup non-existent item */
-	cl_assert(git_submodule_lookup(&sm, g_repo, "no_such_file") == GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "no_such_file", GIT_ENOTFOUND);
 }
 
 void test_submodule_lookup__accessors(void)
@@ -57,6 +51,9 @@ void test_submodule_lookup__accessors(void)
 	cl_assert(git_submodule_ignore(sm) == GIT_SUBMODULE_IGNORE_NONE);
 	cl_assert(git_submodule_update(sm) == GIT_SUBMODULE_UPDATE_CHECKOUT);
 
+	git_submodule_free(sm);
+
+
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
 	cl_assert_equal_s("sm_changed_head", git_submodule_name(sm));
 
@@ -65,6 +62,9 @@ void test_submodule_lookup__accessors(void)
 	cl_assert(git_oid_streq(git_submodule_wd_id(sm),
 		"3d9386c507f6b093471a3e324085657a3c2b4247") == 0);
 
+	git_submodule_free(sm);
+
+
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
 	cl_assert_equal_s("sm_added_and_uncommited", git_submodule_name(sm));
 
@@ -72,6 +72,9 @@ void test_submodule_lookup__accessors(void)
 	cl_assert(git_submodule_head_id(sm) == NULL);
 	cl_assert(git_oid_streq(git_submodule_wd_id(sm), oid) == 0);
 
+	git_submodule_free(sm);
+
+
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_missing_commits"));
 	cl_assert_equal_s("sm_missing_commits", git_submodule_name(sm));
 
@@ -79,6 +82,8 @@ void test_submodule_lookup__accessors(void)
 	cl_assert(git_oid_streq(git_submodule_head_id(sm), oid) == 0);
 	cl_assert(git_oid_streq(git_submodule_wd_id(sm),
 		"5e4963595a9774b90524d35a807169049de8ccad") == 0);
+
+	git_submodule_free(sm);
 }
 
 typedef struct {
@@ -104,69 +109,35 @@ void test_submodule_lookup__foreach(void)
 void test_submodule_lookup__lookup_even_with_unborn_head(void)
 {
 	git_reference *head;
-	git_submodule *sm;
 
 	/* put us on an unborn branch */
 	cl_git_pass(git_reference_symbolic_create(
 		&head, g_repo, "HEAD", "refs/heads/garbage", 1, NULL, NULL));
 	git_reference_free(head);
 
-	/* lookup existing */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_assert(sm);
-
-	/* lookup pending change in .gitmodules that is not in HEAD */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
-	cl_assert(sm);
-
-	/* lookup pending change in .gitmodules that is neither in HEAD nor index */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_gitmodules_only"));
-	cl_assert(sm);
-
-	/* lookup git repo subdir that is not added as submodule */
-	cl_assert_equal_i(GIT_EEXISTS, git_submodule_lookup(&sm, g_repo, "not-submodule"));
-
-	/* lookup existing directory that is not a submodule */
-	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(&sm, g_repo, "just_a_dir"));
-
-	/* lookup existing file that is not a submodule */
-	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(&sm, g_repo, "just_a_file"));
-
-	/* lookup non-existent item */
-	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(&sm, g_repo, "no_such_file"));
+	assert_submodule_exists(g_repo, "sm_unchanged");
+	assert_submodule_exists(g_repo, "sm_added_and_uncommited");
+	assert_submodule_exists(g_repo, "sm_gitmodules_only");
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "just_a_file", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "no_such_file", GIT_ENOTFOUND);
 }
 
 void test_submodule_lookup__lookup_even_with_missing_index(void)
 {
 	git_index *idx;
-	git_submodule *sm;
 
 	/* give the repo an empty index */
 	cl_git_pass(git_index_new(&idx));
 	git_repository_set_index(g_repo, idx);
 	git_index_free(idx);
 
-	/* lookup existing */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_assert(sm);
-
-	/* lookup pending change in .gitmodules that is not in HEAD */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
-	cl_assert(sm);
-
-	/* lookup pending change in .gitmodules that is neither in HEAD nor index */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_gitmodules_only"));
-	cl_assert(sm);
-
-	/* lookup git repo subdir that is not added as submodule */
-	cl_assert_equal_i(GIT_EEXISTS, git_submodule_lookup(&sm, g_repo, "not-submodule"));
-
-	/* lookup existing directory that is not a submodule */
-	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(&sm, g_repo, "just_a_dir"));
-
-	/* lookup existing file that is not a submodule */
-	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(&sm, g_repo, "just_a_file"));
-
-	/* lookup non-existent item */
-	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(&sm, g_repo, "no_such_file"));
+	assert_submodule_exists(g_repo, "sm_unchanged");
+	assert_submodule_exists(g_repo, "sm_added_and_uncommited");
+	assert_submodule_exists(g_repo, "sm_gitmodules_only");
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "just_a_file", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "no_such_file", GIT_ENOTFOUND);
 }
diff --git a/tests/submodule/modify.c b/tests/submodule/modify.c
index e3e4d8aed..1aaa56388 100644
--- a/tests/submodule/modify.c
+++ b/tests/submodule/modify.c
@@ -21,15 +21,16 @@ void test_submodule_modify__add(void)
 	const char *s;
 
 	/* re-add existing submodule */
-	cl_assert(
-		git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1) ==
-		GIT_EEXISTS );
+	cl_assert_equal_i(
+		GIT_EEXISTS,
+		git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1));
 
 	/* add a submodule using a gitlink */
 
 	cl_git_pass(
 		git_submodule_add_setup(&sm, g_repo, SM_LIBGIT2_URL, SM_LIBGIT2, 1)
 		);
+	git_submodule_free(sm);
 
 	cl_assert(git_path_isfile("submod2/" SM_LIBGIT2 "/.git"));
 
@@ -48,6 +49,7 @@ void test_submodule_modify__add(void)
 	cl_git_pass(
 		git_submodule_add_setup(&sm, g_repo, SM_LIBGIT2_URL, SM_LIBGIT2B, 0)
 		);
+	git_submodule_free(sm);
 
 	cl_assert(git_path_isdir("submod2/" SM_LIBGIT2B "/.git"));
 	cl_assert(git_path_isfile("submod2/" SM_LIBGIT2B "/.git/HEAD"));
@@ -95,7 +97,7 @@ void test_submodule_modify__init(void)
 	/* call init and see that settings are copied */
 	cl_git_pass(git_submodule_foreach(g_repo, init_one_submodule, NULL));
 
-	git_submodule_reload_all(g_repo);
+	git_submodule_reload_all(g_repo, 1);
 
 	/* confirm submodule data in config */
 	cl_git_pass(git_repository_config(&cfg, g_repo));
@@ -159,6 +161,10 @@ void test_submodule_modify__sync(void)
 	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM3".url"));
 	cl_assert_equal_s(git_submodule_url(sm3), str);
 	git_config_free(cfg);
+
+	git_submodule_free(sm1);
+	git_submodule_free(sm2);
+	git_submodule_free(sm3);
 }
 
 void test_submodule_modify__edit_and_save(void)
@@ -231,7 +237,7 @@ void test_submodule_modify__edit_and_save(void)
 	cl_assert_equal_i(GIT_SUBMODULE_RECURSE_YES, git_submodule_fetch_recurse_submodules(sm1));
 
 	/* call reload and check that the new values are loaded */
-	cl_git_pass(git_submodule_reload(sm1));
+	cl_git_pass(git_submodule_reload(sm1, 0));
 
 	cl_assert_equal_s(SM_LIBGIT2_URL, git_submodule_url(sm1));
 	cl_assert_equal_i(
@@ -253,16 +259,18 @@ void test_submodule_modify__edit_and_save(void)
 		GIT_SUBMODULE_RECURSE_NO, git_submodule_fetch_recurse_submodules(sm2));
 
 	/* set fetchRecurseSubmodules on-demand */
-	cl_git_pass(git_submodule_reload(sm1));
+	cl_git_pass(git_submodule_reload(sm1, 0));
 	git_submodule_set_fetch_recurse_submodules(sm1, GIT_SUBMODULE_RECURSE_ONDEMAND);
 	cl_assert_equal_i(
 		GIT_SUBMODULE_RECURSE_ONDEMAND, git_submodule_fetch_recurse_submodules(sm1));
 	/* call save */
 	cl_git_pass(git_submodule_save(sm1));
-	cl_git_pass(git_submodule_reload(sm1));
+	cl_git_pass(git_submodule_reload(sm1, 0));
 	cl_assert_equal_i(
 		GIT_SUBMODULE_RECURSE_ONDEMAND, git_submodule_fetch_recurse_submodules(sm1));
 
+	git_submodule_free(sm1);
+	git_submodule_free(sm2);
 	git_repository_free(r2);
 	git__free(old_url);
 }
diff --git a/tests/submodule/status.c b/tests/submodule/status.c
index f5111c84f..4fa7114a4 100644
--- a/tests/submodule/status.c
+++ b/tests/submodule/status.c
@@ -18,19 +18,43 @@ void test_submodule_status__cleanup(void)
 
 void test_submodule_status__unchanged(void)
 {
-	unsigned int status, expected;
-	git_submodule *sm;
-
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_status(&status, sm));
-	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
-
-	expected = GIT_SUBMODULE_STATUS_IN_HEAD |
+	unsigned int status = get_submodule_status(g_repo, "sm_unchanged");
+	unsigned int expected =
+		GIT_SUBMODULE_STATUS_IN_HEAD |
 		GIT_SUBMODULE_STATUS_IN_INDEX |
 		GIT_SUBMODULE_STATUS_IN_CONFIG |
 		GIT_SUBMODULE_STATUS_IN_WD;
 
-	cl_assert(status == expected);
+	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
+	cl_assert(expected == status);
+}
+
+static void rm_submodule(const char *name)
+{
+	git_buf path = GIT_BUF_INIT;
+	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), name));
+	cl_git_pass(git_futils_rmdir_r(path.ptr, NULL, GIT_RMDIR_REMOVE_FILES));
+	git_buf_free(&path);
+}
+
+static void add_submodule_to_index(const char *name)
+{
+	git_submodule *sm;
+	cl_git_pass(git_submodule_lookup(&sm, g_repo, name));
+	cl_git_pass(git_submodule_add_to_index(sm, true));
+	git_submodule_free(sm);
+}
+
+static void rm_submodule_from_index(const char *name)
+{
+	git_index *index;
+	size_t pos;
+
+	cl_git_pass(git_repository_index(&index, g_repo));
+	cl_assert(!git_index_find(&pos, index, name));
+	cl_git_pass(git_index_remove(index, name, 0));
+	cl_git_pass(git_index_write(index));
+	git_index_free(index);
 }
 
 /* 4 values of GIT_SUBMODULE_IGNORE to check */
@@ -38,81 +62,49 @@ void test_submodule_status__unchanged(void)
 void test_submodule_status__ignore_none(void)
 {
 	unsigned int status;
-	git_submodule *sm;
-	git_buf path = GIT_BUF_INIT;
 
-	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "sm_unchanged"));
-	cl_git_pass(git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_REMOVE_FILES));
+	rm_submodule("sm_unchanged");
 
-	cl_assert_equal_i(GIT_ENOTFOUND,
-		git_submodule_lookup(&sm, g_repo, "just_a_dir"));
-	cl_assert_equal_i(GIT_EEXISTS,
-		git_submodule_lookup(&sm, g_repo, "not-submodule"));
-	cl_assert_equal_i(GIT_EEXISTS,
-		git_submodule_lookup(&sm, g_repo, "not"));
+	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "not", GIT_EEXISTS);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_index"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_index");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_file"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_file");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_WD_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_untracked_file"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_untracked_file");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_UNTRACKED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_missing_commits"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_missing_commits");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_added_and_uncommited");
 	cl_assert((status & GIT_SUBMODULE_STATUS_INDEX_ADDED) != 0);
 
 	/* removed sm_unchanged for deleted workdir */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_DELETED) != 0);
 
 	/* now mkdir sm_unchanged to test uninitialized */
-	cl_git_pass(git_futils_mkdir(git_buf_cstr(&path), NULL, 0755, 0));
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_reload(sm));
-	cl_git_pass(git_submodule_status(&status, sm));
+	cl_git_pass(git_futils_mkdir("sm_unchanged", "submod2", 0755, 0));
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_UNINITIALIZED) != 0);
 
 	/* update sm_changed_head in index */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_add_to_index(sm, true));
-	/* reload is not needed because add_to_index updates the submodule data */
-	cl_git_pass(git_submodule_status(&status, sm));
+	add_submodule_to_index("sm_changed_head");
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert((status & GIT_SUBMODULE_STATUS_INDEX_MODIFIED) != 0);
 
 	/* remove sm_changed_head from index */
-	{
-		git_index *index;
-		size_t pos;
-
-		cl_git_pass(git_repository_index(&index, g_repo));
-		cl_assert(!git_index_find(&pos, index, "sm_changed_head"));
-		cl_git_pass(git_index_remove(index, "sm_changed_head", 0));
-		cl_git_pass(git_index_write(index));
-
-		git_index_free(index);
-	}
-
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_reload(sm));
-	cl_git_pass(git_submodule_status(&status, sm));
+	rm_submodule_from_index("sm_changed_head");
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert((status & GIT_SUBMODULE_STATUS_INDEX_DELETED) != 0);
-
-	git_buf_free(&path);
 }
 
 static int set_sm_ignore(git_submodule *sm, const char *name, void *payload)
@@ -126,191 +118,136 @@ static int set_sm_ignore(git_submodule *sm, const char *name, void *payload)
 void test_submodule_status__ignore_untracked(void)
 {
 	unsigned int status;
-	git_submodule *sm;
-	git_buf path = GIT_BUF_INIT;
 	git_submodule_ignore_t ign = GIT_SUBMODULE_IGNORE_UNTRACKED;
 
-	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "sm_unchanged"));
-	cl_git_pass(git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_REMOVE_FILES));
-
+	rm_submodule("sm_unchanged");
 	cl_git_pass(git_submodule_foreach(g_repo, set_sm_ignore, &ign));
 
-	cl_git_fail(git_submodule_lookup(&sm, g_repo, "not-submodule"));
+	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "not", GIT_EEXISTS);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_index"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_index");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_INDEX_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_file"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_file");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_WD_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_untracked_file"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_untracked_file");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_missing_commits"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_missing_commits");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_added_and_uncommited");
 	cl_assert((status & GIT_SUBMODULE_STATUS_INDEX_ADDED) != 0);
 
 	/* removed sm_unchanged for deleted workdir */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_DELETED) != 0);
 
 	/* now mkdir sm_unchanged to test uninitialized */
-	cl_git_pass(git_futils_mkdir(git_buf_cstr(&path), NULL, 0755, 0));
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_reload(sm));
-	cl_git_pass(git_submodule_status(&status, sm));
+	cl_git_pass(git_futils_mkdir("sm_unchanged", "submod2", 0755, 0));
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_UNINITIALIZED) != 0);
 
 	/* update sm_changed_head in index */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_add_to_index(sm, true));
-	/* reload is not needed because add_to_index updates the submodule data */
-	cl_git_pass(git_submodule_status(&status, sm));
+	add_submodule_to_index("sm_changed_head");
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert((status & GIT_SUBMODULE_STATUS_INDEX_MODIFIED) != 0);
-
-	git_buf_free(&path);
 }
 
 void test_submodule_status__ignore_dirty(void)
 {
 	unsigned int status;
-	git_submodule *sm;
-	git_buf path = GIT_BUF_INIT;
 	git_submodule_ignore_t ign = GIT_SUBMODULE_IGNORE_DIRTY;
 
-	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "sm_unchanged"));
-	cl_git_pass(git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_REMOVE_FILES));
-
+	rm_submodule("sm_unchanged");
 	cl_git_pass(git_submodule_foreach(g_repo, set_sm_ignore, &ign));
 
-	cl_assert_equal_i(GIT_ENOTFOUND,
-		git_submodule_lookup(&sm, g_repo, "just_a_dir"));
-	cl_assert_equal_i(GIT_EEXISTS,
-		git_submodule_lookup(&sm, g_repo, "not-submodule"));
-	cl_assert_equal_i(GIT_EEXISTS,
-		git_submodule_lookup(&sm, g_repo, "not"));
+	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "not", GIT_EEXISTS);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_index"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_index");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_file"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_file");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_untracked_file"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_untracked_file");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_missing_commits"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_missing_commits");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_MODIFIED) != 0);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_added_and_uncommited");
 	cl_assert((status & GIT_SUBMODULE_STATUS_INDEX_ADDED) != 0);
 
 	/* removed sm_unchanged for deleted workdir */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_DELETED) != 0);
 
 	/* now mkdir sm_unchanged to test uninitialized */
-	cl_git_pass(git_futils_mkdir(git_buf_cstr(&path), NULL, 0755, 0));
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_reload(sm));
-	cl_git_pass(git_submodule_status(&status, sm));
+	cl_git_pass(git_futils_mkdir("sm_unchanged", "submod2", 0755, 0));
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert((status & GIT_SUBMODULE_STATUS_WD_UNINITIALIZED) != 0);
 
 	/* update sm_changed_head in index */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_add_to_index(sm, true));
-	/* reload is not needed because add_to_index updates the submodule data */
-	cl_git_pass(git_submodule_status(&status, sm));
+	add_submodule_to_index("sm_changed_head");
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert((status & GIT_SUBMODULE_STATUS_INDEX_MODIFIED) != 0);
-
-	git_buf_free(&path);
 }
 
 void test_submodule_status__ignore_all(void)
 {
 	unsigned int status;
-	git_submodule *sm;
-	git_buf path = GIT_BUF_INIT;
 	git_submodule_ignore_t ign = GIT_SUBMODULE_IGNORE_ALL;
 
-	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "sm_unchanged"));
-	cl_git_pass(git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_REMOVE_FILES));
-
+	rm_submodule("sm_unchanged");
 	cl_git_pass(git_submodule_foreach(g_repo, set_sm_ignore, &ign));
 
-	cl_assert_equal_i(GIT_ENOTFOUND,
-		git_submodule_lookup(&sm, g_repo, "just_a_dir"));
-	cl_assert_equal_i(GIT_EEXISTS,
-		git_submodule_lookup(&sm, g_repo, "not-submodule"));
-	cl_assert_equal_i(GIT_EEXISTS,
-		git_submodule_lookup(&sm, g_repo, "not"));
+	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "not", GIT_EEXISTS);
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_index"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_index");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_file"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_file");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_untracked_file"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_changed_untracked_file");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_missing_commits"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_missing_commits");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_added_and_uncommited"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_added_and_uncommited");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
 	/* removed sm_unchanged for deleted workdir */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
 	/* now mkdir sm_unchanged to test uninitialized */
-	cl_git_pass(git_futils_mkdir(git_buf_cstr(&path), NULL, 0755, 0));
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_reload(sm));
-	cl_git_pass(git_submodule_status(&status, sm));
+	cl_git_pass(git_futils_mkdir("sm_unchanged", "submod2", 0755, 0));
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
 	/* update sm_changed_head in index */
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_changed_head"));
-	cl_git_pass(git_submodule_add_to_index(sm, true));
-	/* reload is not needed because add_to_index updates the submodule data */
-	cl_git_pass(git_submodule_status(&status, sm));
+	add_submodule_to_index("sm_changed_head");
+	status = get_submodule_status(g_repo, "sm_changed_head");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
-
-	git_buf_free(&path);
 }
 
 typedef struct {
@@ -397,29 +334,23 @@ void test_submodule_status__iterator(void)
 
 void test_submodule_status__untracked_dirs_containing_ignored_files(void)
 {
-	git_buf path = GIT_BUF_INIT;
 	unsigned int status, expected;
-	git_submodule *sm;
-
-	cl_git_pass(git_buf_joinpath(&path, git_repository_path(g_repo), "modules/sm_unchanged/info/exclude"));
-	cl_git_append2file(git_buf_cstr(&path), "\n*.ignored\n");
 
-	cl_git_pass(git_buf_joinpath(&path, git_repository_workdir(g_repo), "sm_unchanged/directory"));
-	cl_git_pass(git_futils_mkdir(git_buf_cstr(&path), NULL, 0755, 0));
-	cl_git_pass(git_buf_joinpath(&path, git_buf_cstr(&path), "i_am.ignored"));
-	cl_git_mkfile(git_buf_cstr(&path), "ignored this file, please\n");
+	cl_git_append2file(
+		"submod2/.git/modules/sm_unchanged/info/exclude", "\n*.ignored\n");
 
-	cl_git_pass(git_submodule_lookup(&sm, g_repo, "sm_unchanged"));
-	cl_git_pass(git_submodule_status(&status, sm));
+	cl_git_pass(
+		git_futils_mkdir("sm_unchanged/directory", "submod2", 0755, 0));
+	cl_git_mkfile(
+		"submod2/sm_unchanged/directory/i_am.ignored",
+		"ignore this file, please\n");
 
+	status = get_submodule_status(g_repo, "sm_unchanged");
 	cl_assert(GIT_SUBMODULE_STATUS_IS_UNMODIFIED(status));
 
 	expected = GIT_SUBMODULE_STATUS_IN_HEAD |
 		GIT_SUBMODULE_STATUS_IN_INDEX |
 		GIT_SUBMODULE_STATUS_IN_CONFIG |
 		GIT_SUBMODULE_STATUS_IN_WD;
-
 	cl_assert(status == expected);
-
-	git_buf_free(&path);
 }
diff --git a/tests/submodule/submodule_helpers.c b/tests/submodule/submodule_helpers.c
index d5750675c..546f0913a 100644
--- a/tests/submodule/submodule_helpers.c
+++ b/tests/submodule/submodule_helpers.c
@@ -125,3 +125,32 @@ git_repository *setup_fixture_submod2(void)
 
 	return repo;
 }
+
+void assert_submodule_exists(git_repository *repo, const char *name)
+{
+	git_submodule *sm;
+	cl_git_pass(git_submodule_lookup(&sm, repo, name));
+	cl_assert(sm);
+	git_submodule_free(sm);
+}
+
+void refute_submodule_exists(
+	git_repository *repo, const char *name, int expected_error)
+{
+	git_submodule *sm;
+	cl_assert_equal_i(
+		expected_error, git_submodule_lookup(&sm, repo, name));
+}
+
+unsigned int get_submodule_status(git_repository *repo, const char *name)
+{
+	git_submodule *sm = NULL;
+	unsigned int status = 0;
+
+	cl_git_pass(git_submodule_lookup(&sm, repo, name));
+	cl_assert(sm);
+	cl_git_pass(git_submodule_status(&status, sm));
+	git_submodule_free(sm);
+
+	return status;
+}
diff --git a/tests/submodule/submodule_helpers.h b/tests/submodule/submodule_helpers.h
index 610c40720..ec5510e3c 100644
--- a/tests/submodule/submodule_helpers.h
+++ b/tests/submodule/submodule_helpers.h
@@ -3,3 +3,8 @@ extern void rewrite_gitmodules(const char *workdir);
 /* these will automatically set a cleanup callback */
 extern git_repository *setup_fixture_submodules(void);
 extern git_repository *setup_fixture_submod2(void);
+
+extern unsigned int get_submodule_status(git_repository *, const char *);
+
+extern void assert_submodule_exists(git_repository *, const char *);
+extern void refute_submodule_exists(git_repository *, const char *, int err);
-- 
cgit v1.2.3


From d3bc95fd664095a0c8dfcdf99f62741b1ecd6ffc Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 25 Mar 2014 12:37:05 -0700
Subject: Update behavior for untracked sub-repos

When a directory containing a .git directory (or even just a plain
gitlink) was found, libgit2 was going out of its way to treat it
specially.  This seemed like it was necessary because the diff
code was not originally emulating Git's behavior for untracked
directories correctly (i.e. scanning for ignored vs untracked items
inside).  Now that libgit2 diff mimics Git's untracked directory
behavior, the special handling for contained Git repos is actually
incorrect and this commit rips it out.
---
 src/iterator.c           |  4 +--
 src/path.c               | 11 ++-------
 tests/diff/iterator.c    |  4 +--
 tests/diff/submodules.c  | 64 +++++++++++++++++++++++++++++++++++++++++++++++-
 tests/diff/workdir.c     |  6 ++---
 tests/submodule/status.c | 16 +++++++-----
 6 files changed, 82 insertions(+), 23 deletions(-)

diff --git a/src/iterator.c b/src/iterator.c
index 401b5de93..e9ec65250 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -1313,8 +1313,8 @@ static int workdir_iterator__update_entry(fs_iterator *fi)
 	if (error < 0)
 		giterr_clear();
 
-	/* mark submodule (or any dir with .git) as GITLINK and remove slash */
-	if (!error || error == GIT_EEXISTS) {
+	/* mark submodule as GITLINK and remove slash */
+	if (!error) {
 		fi->entry.mode = S_IFGITLINK;
 		fi->entry.path[strlen(fi->entry.path) - 1] = '\0';
 	}
diff --git a/src/path.c b/src/path.c
index fa800b74c..1dccf90da 100644
--- a/src/path.c
+++ b/src/path.c
@@ -1051,15 +1051,8 @@ int git_path_dirload_with_stat(
 		}
 
 		if (S_ISDIR(ps->st.st_mode)) {
-			if ((error = git_buf_joinpath(&full, full.ptr, ".git")) < 0)
-				break;
-
-			if (p_access(full.ptr, F_OK) == 0) {
-				ps->st.st_mode = GIT_FILEMODE_COMMIT;
-			} else {
-				ps->path[ps->path_len++] = '/';
-				ps->path[ps->path_len] = '\0';
-			}
+			ps->path[ps->path_len++] = '/';
+			ps->path[ps->path_len] = '\0';
 		}
 	}
 
diff --git a/tests/diff/iterator.c b/tests/diff/iterator.c
index 92e6f723b..891d8a6e5 100644
--- a/tests/diff/iterator.c
+++ b/tests/diff/iterator.c
@@ -737,13 +737,13 @@ void test_diff_iterator__workdir_builtin_ignores(void)
 		{ "root_test2", false },
 		{ "root_test3", false },
 		{ "root_test4.txt", false },
-		{ "sub", false },
+		{ "sub/", false },
 		{ "sub/.gitattributes", false },
 		{ "sub/abc", false },
 		{ "sub/dir/", true },
 		{ "sub/file", false },
 		{ "sub/ign/", true },
-		{ "sub/sub", false },
+		{ "sub/sub/", false },
 		{ "sub/sub/.gitattributes", false },
 		{ "sub/sub/dir", false }, /* file is not actually a dir */
 		{ "sub/sub/file", false },
diff --git a/tests/diff/submodules.c b/tests/diff/submodules.c
index da96ba9c5..314cf1fad 100644
--- a/tests/diff/submodules.c
+++ b/tests/diff/submodules.c
@@ -1,6 +1,7 @@
 #include "clar_libgit2.h"
 #include "repository.h"
 #include "posix.h"
+#include "diff_helpers.h"
 #include "../submodule/submodule_helpers.h"
 
 static git_repository *g_repo = NULL;
@@ -11,6 +12,7 @@ void test_diff_submodules__initialize(void)
 
 void test_diff_submodules__cleanup(void)
 {
+	cl_git_sandbox_cleanup();
 }
 
 #define get_buf_ptr(buf) ((buf)->asize ? (buf)->ptr : NULL)
@@ -34,6 +36,10 @@ static void check_diff_patches_at_line(
 
 		if (expected[d] && !strcmp(expected[d], "<SKIP>"))
 			continue;
+		if (expected[d] && !strcmp(expected[d], "<UNTRACKED>")) {
+			cl_assert_at_line(delta->status == GIT_DELTA_UNTRACKED, file, line);
+			continue;
+		}
 		if (expected[d] && !strcmp(expected[d], "<END>")) {
 			cl_git_pass(git_patch_to_buf(&buf, patch));
 			cl_assert_at_line(!strcmp(expected[d], "<END>"), file, line);
@@ -115,7 +121,9 @@ void test_diff_submodules__dirty_submodule_2(void)
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	git_diff *diff = NULL, *diff2 = NULL;
 	char *smpath = "testrepo";
-	static const char *expected_none[] = { "<END>" };
+	static const char *expected_none[] = {
+		"<END>"
+	};
 	static const char *expected_dirty[] = {
 		"diff --git a/testrepo b/testrepo\nindex a65fedf..a65fedf 160000\n--- a/testrepo\n+++ b/testrepo\n@@ -1 +1 @@\n-Subproject commit a65fedf39aefe402d3bb6e24df4d4f5fe4547750\n+Subproject commit a65fedf39aefe402d3bb6e24df4d4f5fe4547750-dirty\n", /* testrepo.git */
 		"<END>"
@@ -170,6 +178,8 @@ void test_diff_submodules__submod2_index_to_wd(void)
 	git_diff *diff = NULL;
 	static const char *expected[] = {
 		"<SKIP>", /* .gitmodules */
+		"<UNTRACKED>", /* not-submodule */
+		"<UNTRACKED>", /* not */
 		"diff --git a/sm_changed_file b/sm_changed_file\nindex 4800958..4800958 160000\n--- a/sm_changed_file\n+++ b/sm_changed_file\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0-dirty\n", /* sm_changed_file */
 		"diff --git a/sm_changed_head b/sm_changed_head\nindex 4800958..3d9386c 160000\n--- a/sm_changed_head\n+++ b/sm_changed_head\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 3d9386c507f6b093471a3e324085657a3c2b4247\n", /* sm_changed_head */
 		"diff --git a/sm_changed_index b/sm_changed_index\nindex 4800958..4800958 160000\n--- a/sm_changed_index\n+++ b/sm_changed_index\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0-dirty\n", /* sm_changed_index */
@@ -349,6 +359,8 @@ void test_diff_submodules__diff_ignore_options(void)
 	git_config *cfg;
 	static const char *expected_normal[] = {
 		"<SKIP>", /* .gitmodules */
+		"<UNTRACKED>", /* not-submodule */
+		"<UNTRACKED>", /* not */
 		"diff --git a/sm_changed_file b/sm_changed_file\nindex 4800958..4800958 160000\n--- a/sm_changed_file\n+++ b/sm_changed_file\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0-dirty\n", /* sm_changed_file */
 		"diff --git a/sm_changed_head b/sm_changed_head\nindex 4800958..3d9386c 160000\n--- a/sm_changed_head\n+++ b/sm_changed_head\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 3d9386c507f6b093471a3e324085657a3c2b4247\n", /* sm_changed_head */
 		"diff --git a/sm_changed_index b/sm_changed_index\nindex 4800958..4800958 160000\n--- a/sm_changed_index\n+++ b/sm_changed_index\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0-dirty\n", /* sm_changed_index */
@@ -358,10 +370,14 @@ void test_diff_submodules__diff_ignore_options(void)
 	};
 	static const char *expected_ignore_all[] = {
 		"<SKIP>", /* .gitmodules */
+		"<UNTRACKED>", /* not-submodule */
+		"<UNTRACKED>", /* not */
 		"<END>"
 	};
 	static const char *expected_ignore_dirty[] = {
 		"<SKIP>", /* .gitmodules */
+		"<UNTRACKED>", /* not-submodule */
+		"<UNTRACKED>", /* not */
 		"diff --git a/sm_changed_head b/sm_changed_head\nindex 4800958..3d9386c 160000\n--- a/sm_changed_head\n+++ b/sm_changed_head\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 3d9386c507f6b093471a3e324085657a3c2b4247\n", /* sm_changed_head */
 		"diff --git a/sm_missing_commits b/sm_missing_commits\nindex 4800958..5e49635 160000\n--- a/sm_missing_commits\n+++ b/sm_missing_commits\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 5e4963595a9774b90524d35a807169049de8ccad\n", /* sm_missing_commits */
 		"<END>"
@@ -423,3 +439,49 @@ void test_diff_submodules__diff_ignore_options(void)
 
 	git_config_free(cfg);
 }
+
+void test_diff_submodules__skips_empty_includes_used(void)
+{
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_diff *diff = NULL;
+	diff_expects exp;
+	git_repository *r2;
+
+	/* A side effect of of Git's handling of untracked directories and
+	 * auto-ignoring of ".git" entries is that a newly initialized Git
+	 * repo inside another repo will be skipped by diff, but one that
+	 * actually has a commit it in will show as an untracked directory.
+	 * Let's make sure that works.
+	 */
+
+	g_repo = cl_git_sandbox_init("empty_standard_repo");
+
+	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
+
+	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_foreach(
+		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(0, exp.files);
+	git_diff_free(diff);
+
+	cl_git_pass(git_repository_init(&r2, "empty_standard_repo/subrepo", 0));
+
+	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_foreach(
+		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(1, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
+	git_diff_free(diff);
+
+	cl_git_mkfile("empty_standard_repo/subrepo/README.txt", "hello\n");
+
+	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+	memset(&exp, 0, sizeof(exp));
+	cl_git_pass(git_diff_foreach(
+		diff, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+	cl_assert_equal_i(1, exp.files);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_UNTRACKED]);
+	git_diff_free(diff);
+}
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 449dc6363..6128e820e 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -881,7 +881,7 @@ void test_diff_workdir__submodules(void)
 	 * only significant difference is that those Added items will show up
 	 * as Untracked items in the pure libgit2 diff.
 	 *
-	 * Then add in the two extra ignored items "not" and "not-submodule"
+	 * Then add in the two extra untracked items "not" and "not-submodule"
 	 * to get the 12 files reported here.
 	 */
 
@@ -890,8 +890,8 @@ void test_diff_workdir__submodules(void)
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
 	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_DELETED]);
 	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_MODIFIED]);
-	cl_assert_equal_i(2, exp.file_status[GIT_DELTA_IGNORED]);
-	cl_assert_equal_i(8, exp.file_status[GIT_DELTA_UNTRACKED]);
+	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_IGNORED]);
+	cl_assert_equal_i(10, exp.file_status[GIT_DELTA_UNTRACKED]);
 
 	/* the following numbers match "git diff 873585" exactly */
 
diff --git a/tests/submodule/status.c b/tests/submodule/status.c
index f5111c84f..324592301 100644
--- a/tests/submodule/status.c
+++ b/tests/submodule/status.c
@@ -324,7 +324,7 @@ static int confirm_submodule_status(
 {
 	submodule_expectations *exp = payload;
 
-	while (git__suffixcmp(exp->paths[exp->counter], "/") == 0)
+	while (exp->statuses[exp->counter] < 0)
 		exp->counter++;
 
 	cl_assert_equal_i(exp->statuses[exp->counter], (int)status_flags);
@@ -345,8 +345,10 @@ void test_submodule_status__iterator(void)
 		"just_a_dir/",
 		"just_a_dir/contents",
 		"just_a_file",
-		"not",
-		"not-submodule",
+		"not-submodule/",
+		"not-submodule/README.txt",
+		"not/",
+		"not/README.txt",
 		"README.txt",
 		"sm_added_and_uncommited",
 		"sm_changed_file",
@@ -359,11 +361,13 @@ void test_submodule_status__iterator(void)
 	};
 	static int expected_flags[] = {
 		GIT_STATUS_INDEX_MODIFIED | GIT_STATUS_WT_MODIFIED, /* ".gitmodules" */
-		0,					    /* "just_a_dir/" will be skipped */
+		-1,					    /* "just_a_dir/" will be skipped */
 		GIT_STATUS_CURRENT,     /* "just_a_dir/contents" */
 		GIT_STATUS_CURRENT,	    /* "just_a_file" */
-		GIT_STATUS_IGNORED,	    /* "not" (contains .git) */
-		GIT_STATUS_IGNORED,     /* "not-submodule" (contains .git) */
+		GIT_STATUS_WT_NEW,      /* "not-submodule/" untracked item */
+		-1,                     /* "not-submodule/README.txt" */
+		GIT_STATUS_WT_NEW,      /* "not/" untracked item */
+		-1,                     /* "not/README.txt" */
 		GIT_STATUS_CURRENT,     /* "README.txt */
 		GIT_STATUS_INDEX_NEW,   /* "sm_added_and_uncommited" */
 		GIT_STATUS_WT_MODIFIED, /* "sm_changed_file" */
-- 
cgit v1.2.3


From 591e82952a2835c3d411ee5abec78be3b0816861 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 25 Mar 2014 16:52:01 -0700
Subject: Fix submodule leaks and invalid references

This cleans up some places I missed that could hold onto submodule
references and cleans up the way in which the repository cache is
both reloaded and released so that existing submodule references
aren't destroyed inappropriately.
---
 src/checkout.c  |  14 ++++---
 src/diff_file.c |   3 +-
 src/submodule.c | 113 ++++++++++++++++++++++++++++++++++++++++++++------------
 src/submodule.h |   5 +++
 4 files changed, 105 insertions(+), 30 deletions(-)

diff --git a/src/checkout.c b/src/checkout.c
index da9e5a12d..468c8dc6e 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -328,12 +328,17 @@ static bool submodule_is_config_only(
 {
 	git_submodule *sm = NULL;
 	unsigned int sm_loc = 0;
+	bool rval = false;
 
-	if (git_submodule_lookup(&sm, data->repo, path) < 0 ||
-		git_submodule_location(&sm_loc, sm) < 0 ||
-		sm_loc == GIT_SUBMODULE_STATUS_IN_CONFIG)
+	if (git_submodule_lookup(&sm, data->repo, path) < 0)
 		return true;
 
+	if (git_submodule_location(&sm_loc, sm) < 0 ||
+		sm_loc == GIT_SUBMODULE_STATUS_IN_CONFIG)
+		rval = true;
+
+	git_submodule_free(sm);
+
 	return false;
 }
 
@@ -1262,7 +1267,6 @@ static int checkout_submodule(
 	const git_diff_file *file)
 {
 	int error = 0;
-	git_submodule *sm;
 
 	/* Until submodules are supported, UPDATE_ONLY means do nothing here */
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0)
@@ -1273,7 +1277,7 @@ static int checkout_submodule(
 			data->opts.dir_mode, GIT_MKDIR_PATH)) < 0)
 		return error;
 
-	if ((error = git_submodule_lookup(&sm, data->repo, file->path)) < 0) {
+	if ((error = git_submodule_lookup(NULL, data->repo, file->path)) < 0) {
 		/* I've observed repos with submodules in the tree that do not
 		 * have a .gitmodules - core Git just makes an empty directory
 		 */
diff --git a/src/diff_file.c b/src/diff_file.c
index 2f3f797c5..b9f92df3f 100644
--- a/src/diff_file.c
+++ b/src/diff_file.c
@@ -320,7 +320,8 @@ static int diff_file_content_load_workdir_file(
 
 		error = git_filter_list_apply_to_data(&out, fl, &raw);
 
-		git_buf_free(&raw);
+		if (out.ptr != raw.ptr)
+			git_buf_free(&raw);
 
 		if (!error) {
 			fc->map.len  = out.size;
diff --git a/src/submodule.c b/src/submodule.c
index 291311658..769b092a0 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -77,12 +77,12 @@ __KHASH_IMPL(
 	str, static kh_inline, const char *, void *, 1,
 	str_hash_no_trailing_slash, str_equal_no_trailing_slash);
 
-static int load_submodule_config(git_repository *repo);
+static int load_submodule_config(git_repository *repo, bool reload);
 static git_config_backend *open_gitmodules(git_repository *, bool, const git_oid *);
 static int lookup_head_remote(git_buf *url, git_repository *repo);
 static int submodule_get(git_submodule **, git_repository *, const char *, const char *);
 static int submodule_load_from_config(const git_config_entry *, void *);
-static int submodule_load_from_wd_lite(git_submodule *, const char *, void *);
+static int submodule_load_from_wd_lite(git_submodule *);
 static int submodule_update_config(git_submodule *, const char *, const char *, bool, bool);
 static void submodule_get_index_status(unsigned int *, git_submodule *);
 static void submodule_get_wd_status(unsigned int *, git_submodule *, git_repository *, git_submodule_ignore_t);
@@ -144,7 +144,7 @@ int git_submodule_lookup(
 
 	assert(repo && name);
 
-	if ((error = load_submodule_config(repo)) < 0)
+	if ((error = load_submodule_config(repo, false)) < 0)
 		return error;
 
 	if ((error = submodule_lookup(out, repo->submodules, name, NULL)) < 0) {
@@ -182,7 +182,7 @@ int git_submodule_foreach(
 
 	assert(repo && callback);
 
-	if ((error = load_submodule_config(repo)) < 0)
+	if ((error = load_submodule_config(repo, true)) < 0)
 		return error;
 
 	git_strmap_foreach_value(repo->submodules, sm, {
@@ -221,7 +221,10 @@ void git_submodule_config_free(git_repository *repo)
 	if (smcfg == NULL)
 		return;
 
-	git_strmap_foreach_value(smcfg, sm, { git_submodule_free(sm); });
+	git_strmap_foreach_value(smcfg, sm, {
+		sm->repo = NULL; /* disconnect from repo */;
+		git_submodule_free(sm);
+	});
 	git_strmap_free(smcfg);
 }
 
@@ -803,12 +806,60 @@ int git_submodule_open(git_repository **subrepo, git_submodule *sm)
 	return git_submodule__open(subrepo, sm, false);
 }
 
+static void submodule_cache_remove_item(
+	git_strmap *cache,
+	const char *name,
+	git_submodule *expected,
+	bool free_after_remove)
+{
+	khiter_t pos;
+	git_submodule *found;
+
+	if (!cache)
+		return;
+
+	pos = git_strmap_lookup_index(cache, name);
+
+	if (!git_strmap_valid_index(cache, pos))
+		return;
+
+	found = git_strmap_value_at(cache, pos);
+
+	if (expected && found != expected)
+		return;
+
+	git_strmap_set_value_at(cache, pos, NULL);
+	git_strmap_delete_at(cache, pos);
+
+	if (free_after_remove)
+		git_submodule_free(found);
+}
+
 int git_submodule_reload_all(git_repository *repo, int force)
 {
+	int error = 0;
+	git_submodule *sm;
+
 	GIT_UNUSED(force);
 	assert(repo);
-	git_submodule_config_free(repo);
-	return load_submodule_config(repo);
+
+	if (repo->submodules)
+		git_strmap_foreach_value(repo->submodules, sm, { sm->flags = 0; });
+
+	error = load_submodule_config(repo, true);
+
+	git_strmap_foreach_value(repo->submodules, sm, {
+		git_strmap *cache = repo->submodules;
+
+		if ((sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS) == 0) {
+			submodule_cache_remove_item(cache, sm->name, sm, true);
+
+			if (sm->path != sm->name)
+				submodule_cache_remove_item(cache, sm->path, sm, true);
+		}
+	});
+
+	return error;
 }
 
 static void submodule_update_from_index_entry(
@@ -884,6 +935,7 @@ static int submodule_update_head(git_submodule *submodule)
 	return 0;
 }
 
+
 int git_submodule_reload(git_submodule *submodule, int force)
 {
 	int error = 0;
@@ -901,6 +953,10 @@ int git_submodule_reload(git_submodule *submodule, int force)
 	if ((error = submodule_update_head(submodule)) < 0)
 		return error;
 
+	/* done if bare */
+	if (git_repository_is_bare(submodule->repo))
+		return error;
+
 	/* refresh config data */
 	mods = open_gitmodules(submodule->repo, false, NULL);
 	if (mods != NULL) {
@@ -924,11 +980,9 @@ int git_submodule_reload(git_submodule *submodule, int force)
 	}
 
 	/* refresh wd data */
-	submodule->flags = submodule->flags &
-		~(GIT_SUBMODULE_STATUS_IN_WD | GIT_SUBMODULE_STATUS__WD_OID_VALID);
+	submodule->flags &= ~GIT_SUBMODULE_STATUS__ALL_WD_FLAGS;
 
-	return submodule_load_from_wd_lite(
-		submodule, submodule->path, submodule->repo);
+	return submodule_load_from_wd_lite(submodule);
 }
 
 static void submodule_copy_oid_maybe(
@@ -1057,6 +1111,13 @@ static void submodule_release(git_submodule *sm)
 	if (!sm)
 		return;
 
+	if (sm->repo) {
+		git_strmap *cache = sm->repo->submodules;
+		submodule_cache_remove_item(cache, sm->name, sm, false);
+		if (sm->path != sm->name)
+			submodule_cache_remove_item(cache, sm->path, sm, false);
+	}
+
 	if (sm->path != sm->name)
 		git__free(sm->path);
 	git__free(sm->name);
@@ -1265,8 +1326,8 @@ static int submodule_load_from_config(
 		sm->update_default = sm->update;
 	}
 	else if (strcasecmp(property, "fetchRecurseSubmodules") == 0) {
-		if (git_submodule_parse_recurse(&sm->fetch_recurse, value) < 0)
-			return -1;
+		if ((error = git_submodule_parse_recurse(&sm->fetch_recurse, value)) < 0)
+			goto done;
 		sm->fetch_recurse_default = sm->fetch_recurse;
 	}
 	else if (strcasecmp(property, "ignore") == 0) {
@@ -1282,16 +1343,10 @@ done:
 	return error;
 }
 
-static int submodule_load_from_wd_lite(
-	git_submodule *sm, const char *name, void *payload)
+static int submodule_load_from_wd_lite(git_submodule *sm)
 {
 	git_buf path = GIT_BUF_INIT;
 
-	GIT_UNUSED(name); GIT_UNUSED(payload);
-
-	if (git_repository_is_bare(sm->repo))
-		return 0;
-
 	if (git_buf_joinpath(&path, git_repository_workdir(sm->repo), sm->path) < 0)
 		return -1;
 
@@ -1435,13 +1490,13 @@ static git_config_backend *open_gitmodules(
 	return mods;
 }
 
-static int load_submodule_config(git_repository *repo)
+static int load_submodule_config(git_repository *repo, bool reload)
 {
 	int error;
 	git_oid gitmodules_oid;
 	git_config_backend *mods = NULL;
 
-	if (repo->submodules)
+	if (!reload && repo->submodules)
 		return 0;
 
 	memset(&gitmodules_oid, 0, sizeof(gitmodules_oid));
@@ -1454,6 +1509,8 @@ static int load_submodule_config(git_repository *repo)
 		GITERR_CHECK_ALLOC(repo->submodules);
 	}
 
+	/* TODO: only do the following if the sources appear modified */
+
 	/* add submodule information from index */
 
 	if ((error = load_submodule_config_from_index(repo, &gitmodules_oid)) < 0)
@@ -1473,8 +1530,16 @@ static int load_submodule_config(git_repository *repo)
 
 	/* shallow scan submodules in work tree */
 
-	if (!git_repository_is_bare(repo))
-		error = git_submodule_foreach(repo, submodule_load_from_wd_lite, NULL);
+	if (!git_repository_is_bare(repo)) {
+		git_submodule *sm;
+
+		git_strmap_foreach_value(repo->submodules, sm, {
+			sm->flags &= ~GIT_SUBMODULE_STATUS__ALL_WD_FLAGS;
+		});
+		git_strmap_foreach_value(repo->submodules, sm, {
+			submodule_load_from_wd_lite(sm);
+		});
+	}
 
 cleanup:
 	if (mods != NULL)
diff --git a/src/submodule.h b/src/submodule.h
index de7f7b581..053cb61e0 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -111,6 +111,11 @@ enum {
 	GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES = (1u << 27),
 };
 
+#define GIT_SUBMODULE_STATUS__ALL_WD_FLAGS \
+	(GIT_SUBMODULE_STATUS_IN_WD | \
+	 GIT_SUBMODULE_STATUS__WD_OID_VALID | \
+	 GIT_SUBMODULE_STATUS__WD_FLAGS)
+
 #define GIT_SUBMODULE_STATUS__CLEAR_INTERNAL(S) \
 	((S) & ~(0xFFFFFFFFu << 20))
 
-- 
cgit v1.2.3


From f2f2d97f1e5264c061177a1c64fa6b3420a95188 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 24 Mar 2014 17:48:54 -0700
Subject: Test for giterr_capture

---
 tests/core/errors.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/tests/core/errors.c b/tests/core/errors.c
index 512a4134d..366d8f16a 100644
--- a/tests/core/errors.c
+++ b/tests/core/errors.c
@@ -85,3 +85,27 @@ void test_core_errors__new_school(void)
 
 	giterr_clear();
 }
+
+void test_core_errors__restore(void)
+{
+	git_error_state err_state = {0};
+
+	giterr_clear();
+	cl_assert(giterr_last() == NULL);
+
+	cl_assert_equal_i(0, giterr_capture(&err_state, 0));
+
+	memset(&err_state, 0x0, sizeof(git_error_state));
+
+	giterr_set(42, "Foo: %s", "bar");
+	cl_assert_equal_i(-1, giterr_capture(&err_state, -1));
+
+	cl_assert(giterr_last() == NULL);
+
+	giterr_set(99, "Bar: %s", "foo");
+
+	giterr_restore(&err_state);
+
+	cl_assert_equal_i(42, giterr_last()->klass);
+	cl_assert_equal_s("Foo: bar", giterr_last()->message);
+}
-- 
cgit v1.2.3


From 1df8ad01d746ef56c563f82a4f4037957ddc19d8 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Thu, 6 Mar 2014 16:00:52 -0800
Subject: clone: don't overwrite original error message

---
 src/clone.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/clone.c b/src/clone.c
index e19d02ba2..62f103561 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -430,10 +430,15 @@ int git_clone(
 	}
 
 	if (error != 0) {
+		git_error_state last_error = {0};
+		giterr_capture(&last_error, error);
+
 		git_repository_free(repo);
 		repo = NULL;
 
 		(void)git_futils_rmdir_r(local_path, NULL, rmdir_flags);
+
+		giterr_restore(&last_error);
 	}
 
 	*out = repo;
-- 
cgit v1.2.3


From 6105d597072cea0d1a89ee184826c2c98bf5d772 Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Wed, 26 Mar 2014 18:17:08 +0100
Subject: In-memory packing backend

---
 include/git2/pack.h        |  11 +++
 include/git2/sys/mempack.h |  85 +++++++++++++++++++++
 src/odb_mempack.c          | 182 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 278 insertions(+)
 create mode 100644 include/git2/sys/mempack.h
 create mode 100644 src/odb_mempack.c

diff --git a/include/git2/pack.h b/include/git2/pack.h
index 11bb559d8..29c926c65 100644
--- a/include/git2/pack.h
+++ b/include/git2/pack.h
@@ -114,6 +114,17 @@ GIT_EXTERN(int) git_packbuilder_insert_tree(git_packbuilder *pb, const git_oid *
  */
 GIT_EXTERN(int) git_packbuilder_insert_commit(git_packbuilder *pb, const git_oid *id);
 
+/**
+ * Write the contents of the packfile to an in-memory buffer
+ *
+ * The contents of the buffer will become a valid packfile, even though there
+ * will be no attached index
+ *
+ * @param buf Buffer where to write the packfile
+ * @param pb The packbuilder
+ */
+GIT_EXTERN(int) git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb);
+
 /**
  * Write the new pack and corresponding index file to path.
  *
diff --git a/include/git2/sys/mempack.h b/include/git2/sys/mempack.h
new file mode 100644
index 000000000..d3bc87b4d
--- /dev/null
+++ b/include/git2/sys/mempack.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_sys_git_odb_mempack_h__
+#define INCLUDE_sys_git_odb_mempack_h__
+
+#include "git2/common.h"
+#include "git2/types.h"
+#include "git2/oid.h"
+#include "git2/odb.h"
+
+/**
+ * @file git2/sys/mempack.h
+ * @brief Custom ODB backend that permits packing objects in-memory
+ * @defgroup git_backend Git custom backend APIs
+ * @ingroup Git
+ * @{
+ */
+GIT_BEGIN_DECL
+
+/**
+ *	Instantiate a new mempack backend.
+ *
+ *	The backend must be added to an existing ODB with the highest
+ *	priority.
+ *
+ *		git_mempack_new(&mempacker);
+ *		git_repository_odb(&odb, repository);
+ *		git_odb_add_backend(odb, mempacker, 999);
+ *
+ *	Once the backend has been loaded, all writes to the ODB will
+ *	instead be queued in memory, and can be finalized with
+ *	`git_mempack_dump`.
+ *
+ *	Subsequent reads will also be served from the in-memory store
+ *	to ensure consistency, until the memory store is dumped.
+ *
+ *	@param out Poiter where to store the ODB backend
+ *	@return 0 on success; error code otherwise
+ */
+int git_mempack_new(git_odb_backend **out);
+
+/**
+ *	Dump all the queued in-memory writes to a packfile.
+ *
+ *	The contents of the packfile will be stored in the given buffer.
+ *	It is the caller's responsability to ensure that the generated
+ *	packfile is available to the repository (e.g. by writing it
+ *	to disk, or doing something crazy like distributing it across
+ *	several copies of the repository over a network).
+ *
+ *	Once the generated packfile is available to the repository,
+ *	call `git_mempack_reset` to cleanup the memory store.
+ *
+ *	Calling `git_mempack_reset` before the packfile has been
+ *	written to disk will result in an inconsistent repository
+ *	(the objects in the memory store won't be accessible).
+ *
+ *	@param pack Buffer where to store the raw packfile
+ *	@param repo The active repository where the backend is loaded
+ *	@param backend The mempack backend
+ *	@return 0 on success; error code otherwise
+ */
+int git_mempack_dump(git_buf *pack, git_repository *repo, git_odb_backend *backend);
+
+/**
+ *	Reset the memory packer by clearing all the queued objects.
+ *
+ *	This assumes that `git_mempack_dump` has been called before to
+ *	store all the queued objects into a single packfile.
+ *
+ *	Alternatively, call `reset` without a previous dump to "undo"
+ *	all the recently written objects, giving transaction-like
+ *	semantics to the Git repository.
+ *
+ *	@param backend The mempack backend
+ */
+void git_mempack_reset(git_odb_backend *backend);
+
+GIT_END_DECL
+
+#endif
diff --git a/src/odb_mempack.c b/src/odb_mempack.c
new file mode 100644
index 000000000..d9b3a1824
--- /dev/null
+++ b/src/odb_mempack.c
@@ -0,0 +1,182 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+#include "git2/object.h"
+#include "git2/sys/odb_backend.h"
+#include "fileops.h"
+#include "hash.h"
+#include "odb.h"
+#include "array.h"
+#include "oidmap.h"
+
+#include "git2/odb_backend.h"
+#include "git2/types.h"
+#include "git2/pack.h"
+
+GIT__USE_OIDMAP;
+
+struct memobject {
+	git_oid oid;
+	size_t len;
+	git_otype type;
+	char data[];
+};
+
+struct memory_packer_db {
+	git_odb_backend parent;
+	git_oidmap *objects;
+	git_array_t(struct memobject *) commits;
+};
+
+static int impl__write(git_odb_backend *_backend, const git_oid *oid, const void *data, size_t len, git_otype type)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
+	struct memobject *obj = NULL; 
+	khiter_t pos;
+	int rval;
+
+	pos = kh_put(oid, db->objects, oid, &rval);
+	if (rval < 0)
+		return -1;
+
+	if (rval == 0)
+		return 0;
+
+	obj = git__malloc(sizeof(struct memobject) + len);
+	GITERR_CHECK_ALLOC(obj);
+
+	memcpy(obj->data, data, len);
+	git_oid_cpy(&obj->oid, oid);
+	obj->len = len;
+	obj->type = type;
+
+	kh_key(db->objects, pos) = &obj->oid;
+	kh_val(db->objects, pos) = obj;
+
+	if (type == GIT_OBJ_COMMIT) {
+		struct memobject **store = git_array_alloc(db->commits);
+		GITERR_CHECK_ALLOC(store);
+		*store = obj;
+	}
+
+	return 0;
+}
+
+static int impl__exists(git_odb_backend *backend, const git_oid *oid)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)backend;
+	khiter_t pos;
+
+	pos = kh_get(oid, db->objects, oid);
+	if (pos != kh_end(db->objects))
+		return 1;
+
+	return 0;
+}
+
+static int impl__read(void **buffer_p, size_t *len_p, git_otype *type_p, git_odb_backend *backend, const git_oid *oid)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)backend;
+	struct memobject *obj = NULL;
+	khiter_t pos;
+
+	pos = kh_get(oid, db->objects, oid);
+	if (pos == kh_end(db->objects))
+		return GIT_ENOTFOUND;
+
+	obj = kh_val(db->objects, pos);
+
+	*len_p = obj->len;
+	*type_p = obj->type;
+	*buffer_p = git__malloc(obj->len);
+	GITERR_CHECK_ALLOC(*buffer_p);
+
+	memcpy(*buffer_p, obj->data, obj->len);
+	return 0;
+}
+
+static int impl__read_header(size_t *len_p, git_otype *type_p, git_odb_backend *backend, const git_oid *oid)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)backend;
+	struct memobject *obj = NULL;
+	khiter_t pos;
+
+	pos = kh_get(oid, db->objects, oid);
+	if (pos == kh_end(db->objects))
+		return GIT_ENOTFOUND;
+
+	obj = kh_val(db->objects, pos);
+
+	*len_p = obj->len;
+	*type_p = obj->type;
+	return 0;
+}
+
+int git_mempack_dump(git_buf *pack, git_repository *repo, git_odb_backend *_backend)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
+	git_packbuilder *packbuilder;
+	uint32_t i;
+	int err = -1;
+
+	if (git_packbuilder_new(&packbuilder, repo) < 0)
+		return -1;
+
+	for (i = 0; i < db->commits.size; ++i) {
+		struct memobject *commit = db->commits.ptr[i];
+
+		err = git_packbuilder_insert_commit(packbuilder, &commit->oid);
+		if (err < 0)
+			goto cleanup;
+	}
+
+	err = git_packbuilder_write_buf(pack, packbuilder);
+
+cleanup:
+	git_packbuilder_free(packbuilder);
+	return err;
+}
+
+void git_mempack_reset(git_odb_backend *_backend)
+{
+	struct memory_packer_db *db = (struct memory_packer_db *)_backend;
+	struct memobject *object = NULL;
+
+	kh_foreach_value(db->objects, object, {
+		git__free(object);
+	});
+
+	git_array_clear(db->commits);
+}
+
+static void impl__free(git_odb_backend *_backend)
+{
+	git_mempack_reset(_backend);
+	git__free(_backend);
+}
+
+int git_mempack_new(git_odb_backend **out)
+{
+	struct memory_packer_db *db;
+
+	assert(out);
+
+	db = git__calloc(1, sizeof(struct memory_packer_db));
+	GITERR_CHECK_ALLOC(db);
+
+	db->objects = git_oidmap_alloc();
+
+	db->parent.read = &impl__read;
+	db->parent.write = &impl__write;
+	db->parent.read_header = &impl__read_header;
+	db->parent.exists = &impl__exists;
+	db->parent.free = &impl__free;
+
+	*out = (git_odb_backend *)db;
+	return 0;
+}
-- 
cgit v1.2.3


From 2b848e47c1491fe0b6e987400b1a466c0f18861a Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@edwardthomson.com>
Date: Wed, 26 Mar 2014 12:33:37 -0500
Subject: Decorate unused params as unused in revwalk::hidecb tests

---
 tests/revwalk/hidecb.c | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/tests/revwalk/hidecb.c b/tests/revwalk/hidecb.c
index c13a17747..26ff183fa 100644
--- a/tests/revwalk/hidecb.c
+++ b/tests/revwalk/hidecb.c
@@ -48,18 +48,27 @@ void test_revwalk_hidecb__cleanup(void)
 /* Hide all commits */
 static int hide_every_commit_cb(const git_oid *commit_id, void *data)
 {
+	GIT_UNUSED(commit_id);
+	GIT_UNUSED(data);
+
 	return 1;
 }
 
 /* Do not hide anything */
 static int hide_none_cb(const git_oid *commit_id, void *data)
 {
+	GIT_UNUSED(commit_id);
+	GIT_UNUSED(data);
+
 	return 0;
 }
 
 /* Hide some commits */
 static int hide_commit_cb(const git_oid *commit_id, void *data)
 {
+	GIT_UNUSED(commit_id);
+	GIT_UNUSED(data);
+
 	if (0 == git_oid_cmp(commit_id, &commit_ids[5]))
 		return 1;
 	else
-- 
cgit v1.2.3


From 9cb99e8b853bb3d9ddec3748494a0ac34550849b Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@edwardthomson.com>
Date: Wed, 26 Mar 2014 12:43:41 -0500
Subject: Free temporary merge index

---
 src/merge.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/merge.c b/src/merge.c
index 42fbd79c9..24b7d37ce 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2629,9 +2629,8 @@ int git_merge(
 on_error:
 	merge_state_cleanup(repo);
 
-	git_index_free(index_new);
-
 done:
+	git_index_free(index_new);
 	git_index_free(index_repo);
 
 	git_tree_free(ancestor_tree);
-- 
cgit v1.2.3


From 22df47cbc52107db25368cf0a09d63cc8dddafdb Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 26 Mar 2014 14:38:26 -0700
Subject: Fix segfault if gitmodules is invalid

The reload_all call could end up dereferencing a NULL pointer if
there was an error while attempting to load the submodules config
data (i.e. invalid content in the gitmodules file).  This fixes it.
---
 include/git2/submodule.h |  6 +--
 src/submodule.c          |  5 ++-
 tests/submodule/nosubs.c | 95 ++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 101 insertions(+), 5 deletions(-)
 create mode 100644 tests/submodule/nosubs.c

diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index 789f2c045..28e235725 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -115,8 +115,8 @@ typedef enum {
  *
  * - The submodule is not mentioned in the HEAD, the index, and the config,
  *   but does "exist" in the working directory (i.e. there is a subdirectory
- *   that is a valid self-contained git repo).  In this case, this function
- *   returns GIT_EEXISTS to indicate the the submodule exists but not in a
+ *   that appears to be a Git repository).  In this case, this function
+ *   returns GIT_EEXISTS to indicate a sub-repository exists but not in a
  *   state where a git_submodule can be instantiated.
  * - The submodule is not mentioned in the HEAD, index, or config and the
  *   working directory doesn't contain a value git repo at that path.
@@ -129,7 +129,7 @@ typedef enum {
  * @param repo The parent repository
  * @param name The name of or path to the submodule; trailing slashes okay
  * @return 0 on success, GIT_ENOTFOUND if submodule does not exist,
- *         GIT_EEXISTS if submodule exists in working directory only,
+ *         GIT_EEXISTS if a repository is found in working directory only,
  *         -1 on other errors.
  */
 GIT_EXTERN(int) git_submodule_lookup(
diff --git a/src/submodule.c b/src/submodule.c
index 769b092a0..54ffc6103 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -156,7 +156,7 @@ int git_submodule_lookup(
 			if (git_buf_joinpath(&path, git_repository_workdir(repo), name) < 0)
 				return -1;
 
-			if (git_path_contains_dir(&path, DOT_GIT))
+			if (git_path_contains(&path, DOT_GIT))
 				error = GIT_EEXISTS;
 
 			git_buf_free(&path);
@@ -846,7 +846,8 @@ int git_submodule_reload_all(git_repository *repo, int force)
 	if (repo->submodules)
 		git_strmap_foreach_value(repo->submodules, sm, { sm->flags = 0; });
 
-	error = load_submodule_config(repo, true);
+	if ((error = load_submodule_config(repo, true)) < 0)
+		return error;
 
 	git_strmap_foreach_value(repo->submodules, sm, {
 		git_strmap *cache = repo->submodules;
diff --git a/tests/submodule/nosubs.c b/tests/submodule/nosubs.c
new file mode 100644
index 000000000..5ef4f42ab
--- /dev/null
+++ b/tests/submodule/nosubs.c
@@ -0,0 +1,95 @@
+/* test the submodule APIs on repositories where there are no submodules */
+
+#include "clar_libgit2.h"
+#include "posix.h"
+
+void test_submodule_nosubs__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_submodule_nosubs__lookup(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+	git_submodule *sm = NULL;
+
+	p_mkdir("status/subrepo", 0777);
+	cl_git_mkfile("status/subrepo/.git", "gitdir: ../.git");
+
+	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(&sm, repo, "subdir"));
+
+	cl_assert_equal_i(GIT_EEXISTS, git_submodule_lookup(&sm, repo, "subrepo"));
+
+	cl_git_pass(git_submodule_reload_all(repo, 0));
+
+	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(&sm, repo, "subdir"));
+
+	cl_assert_equal_i(GIT_EEXISTS, git_submodule_lookup(&sm, repo, "subrepo"));
+}
+
+void test_submodule_nosubs__immediate_reload(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+	cl_git_pass(git_submodule_reload_all(repo, 0));
+}
+
+static int fake_submod_cb(git_submodule *sm, const char *n, void *p)
+{
+	GIT_UNUSED(sm); GIT_UNUSED(n); GIT_UNUSED(p);
+	return 0;
+}
+
+void test_submodule_nosubs__foreach(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+	cl_git_pass(git_submodule_foreach(repo, fake_submod_cb, NULL));
+}
+
+void test_submodule_nosubs__add(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+	git_submodule *sm, *sm2;
+
+	cl_git_pass(git_submodule_add_setup(&sm, repo, "https://github.com/libgit2/libgit2.git", "submodules/libgit2", 1));
+
+	cl_git_pass(git_submodule_lookup(&sm2, repo, "submodules/libgit2"));
+	git_submodule_free(sm2);
+
+	cl_git_pass(git_submodule_foreach(repo, fake_submod_cb, NULL));
+	cl_git_pass(git_submodule_reload_all(repo, 0));
+
+	git_submodule_free(sm);
+}
+
+void test_submodule_nosubs__reload_add_reload(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+	git_submodule *sm;
+
+	cl_git_pass(git_submodule_reload_all(repo, 0));
+
+	cl_git_pass(git_submodule_add_setup(&sm, repo, "https://github.com/libgit2/libgit2.git", "submodules/libgit2", 1));
+
+	cl_git_pass(git_submodule_reload_all(repo, 0));
+
+	cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm));
+	git_submodule_free(sm);
+
+	cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2"));
+	cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm));
+	git_submodule_free(sm);
+}
+
+void test_submodule_nosubs__bad_gitmodules(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+
+	cl_git_mkfile("status/.gitmodules", "[submodule \"foobar\"]\tpath=blargle\n\turl=\n\tbranch=\n\tupdate=flooble\n\n");
+	cl_git_fail(git_submodule_reload_all(repo, 0));
+
+	cl_git_rewritefile("status/.gitmodules", "[submodule \"foobar\"]\tpath=blargle\n\turl=\n\tbranch=\n\tupdate=rebase\n\n");
+	cl_git_pass(git_submodule_reload_all(repo, 0));
+
+	cl_git_pass(git_submodule_lookup(NULL, repo, "foobar"));
+	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(NULL, repo, "subdir"));
+}
-- 
cgit v1.2.3


From 380f864a10aeadd30bd88138906d4fab577221de Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 26 Mar 2014 16:06:21 -0700
Subject: Fix error when submodule path and name differ

When a submodule was inserted with a different path and name, the
return value from khash greater than zero was allowed to propagate
back out to the caller when it should really be zeroed.  This led
to a possible crash when reloading submodules if that was the
first time that submodule data was loaded.
---
 src/submodule.c          |  7 +++++--
 tests/submodule/lookup.c | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index 54ffc6103..b07c9d917 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -1279,14 +1279,17 @@ static int submodule_load_from_config(
 		}
 	}
 
+	/* Found a alternate key for the submodule */
 	if (alternate) {
 		void *old_sm = NULL;
 		git_strmap_insert2(smcfg, alternate, sm, old_sm, error);
 
 		if (error < 0)
 			goto done;
-		if (error >= 0)
-			GIT_REFCOUNT_INC(sm); /* inserted under a new key */
+		if (error > 0)
+			error = 0;
+
+		GIT_REFCOUNT_INC(sm); /* increase refcount for new key */
 
 		/* if we replaced an old module under this key, release the old one */
 		if (old_sm && ((git_submodule *)old_sm) != sm) {
diff --git a/tests/submodule/lookup.c b/tests/submodule/lookup.c
index cc29b11b2..36bde4f6e 100644
--- a/tests/submodule/lookup.c
+++ b/tests/submodule/lookup.c
@@ -141,3 +141,36 @@ void test_submodule_lookup__lookup_even_with_missing_index(void)
 	refute_submodule_exists(g_repo, "just_a_file", GIT_ENOTFOUND);
 	refute_submodule_exists(g_repo, "no_such_file", GIT_ENOTFOUND);
 }
+
+void test_submodule_lookup__just_added(void)
+{
+	git_submodule *sm;
+
+	cl_git_pass(git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_just_added", 1));
+	git_submodule_free(sm);
+	assert_submodule_exists(g_repo, "sm_just_added");
+
+	cl_git_pass(git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_just_added_2", 1));
+	assert_submodule_exists(g_repo, "sm_just_added_2");
+	git_submodule_free(sm);
+
+	cl_git_append2file("submod2/.gitmodules", "\n[submodule \"mismatch_name\"]\n\tpath = mismatch_path\n\turl = https://example.com/example.git\n\n");
+
+	cl_git_pass(git_submodule_reload_all(g_repo, 1));
+
+	assert_submodule_exists(g_repo, "mismatch_name");
+	assert_submodule_exists(g_repo, "mismatch_path");
+
+	assert_submodule_exists(g_repo, "sm_just_added");
+	assert_submodule_exists(g_repo, "sm_just_added_2");
+
+	/* all the regular ones should still be working right, too */
+
+	assert_submodule_exists(g_repo, "sm_unchanged");
+	assert_submodule_exists(g_repo, "sm_added_and_uncommited");
+	assert_submodule_exists(g_repo, "sm_gitmodules_only");
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "just_a_file", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "no_such_file", GIT_ENOTFOUND);
+}
-- 
cgit v1.2.3


From 2873a862fd1899909424b60b44fa0680851a60f6 Mon Sep 17 00:00:00 2001
From: Jan Melcher <info@yogularm.de>
Date: Thu, 27 Mar 2014 12:42:44 +0100
Subject: Retry renaming files on Access Denied errors

When a file is open for reading (without shared-delete permission), and
then a different thread/process called p_rename, that would fail, even
if the file was only open for reading for a few milliseconds. This
change lets p_rename wait up to 50ms for the file to be closed by the
reader. Applies only to win32.

This is especially important for git_filebuf_commit, because writes
should not fail if the file is read simultaneously.

Fixes #2207
---
 src/win32/posix_w32.c | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c
index 18f717b0f..6f2931880 100644
--- a/src/win32/posix_w32.c
+++ b/src/win32/posix_w32.c
@@ -467,10 +467,31 @@ int p_rename(const char *from, const char *to)
 {
 	git_win32_path wfrom;
 	git_win32_path wto;
+	int rename_tries;
+	int rename_succeeded;
+	int error;
 
 	git_win32_path_from_c(wfrom, from);
 	git_win32_path_from_c(wto, to);
-	return MoveFileExW(wfrom, wto, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) ? 0 : -1;
+	
+	/* wait up to 50ms if file is locked by another thread or process */
+	rename_tries = 0;
+	rename_succeeded = 0;
+	while (rename_tries < 10) {
+		if (MoveFileExW(wfrom, wto, MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED) != 0) {
+			rename_succeeded = 1;
+			break;
+		}
+		
+		error = GetLastError();
+		if (error == ERROR_SHARING_VIOLATION || error == ERROR_ACCESS_DENIED) {
+			Sleep(5);
+			rename_tries++;
+		} else
+			break;
+	}
+	
+	return rename_succeeded ? 0 : -1;
 }
 
 int p_recv(GIT_SOCKET socket, void *buffer, size_t length, int flags)
-- 
cgit v1.2.3


From add8db06f91f1dc9acc7f20f8229f746041de2c8 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 27 Mar 2014 15:28:29 -0700
Subject: Fix use-after-free in submodule reload

If the first call to release a no-longer-existent submodule freed
the object, the check if a second is needed would dereference the
data that was just freed.
---
 src/submodule.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index b07c9d917..0a3762fab 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -852,10 +852,13 @@ int git_submodule_reload_all(git_repository *repo, int force)
 	git_strmap_foreach_value(repo->submodules, sm, {
 		git_strmap *cache = repo->submodules;
 
-		if ((sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS) == 0) {
-			submodule_cache_remove_item(cache, sm->name, sm, true);
+		if (sm && (sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS) == 0) {
+			/* we must check path != name before first remove, in case
+			 * that call frees the submodule */
+			bool free_as_path = (sm->path != sm->name);
 
-			if (sm->path != sm->name)
+			submodule_cache_remove_item(cache, sm->name, sm, true);
+			if (free_as_path)
 				submodule_cache_remove_item(cache, sm->path, sm, true);
 		}
 	});
-- 
cgit v1.2.3


From acdc7cff2e31223aa91d9421b9b4edc53ca87869 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 27 Mar 2014 15:29:17 -0700
Subject: Fix memory leak of submodule branch name

---
 src/submodule.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/submodule.c b/src/submodule.c
index 0a3762fab..e1500b847 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -1126,6 +1126,7 @@ static void submodule_release(git_submodule *sm)
 		git__free(sm->path);
 	git__free(sm->name);
 	git__free(sm->url);
+	git__free(sm->branch);
 	git__memzero(sm, sizeof(*sm));
 	git__free(sm);
 }
-- 
cgit v1.2.3


From dae8ba6e0968d3ace5ac3c2878fb2072f1db43ba Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 27 Mar 2014 15:29:32 -0700
Subject: Fix memory leak of test repository object

---
 tests/diff/submodules.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/diff/submodules.c b/tests/diff/submodules.c
index 80dfcaa3f..ead5c71b6 100644
--- a/tests/diff/submodules.c
+++ b/tests/diff/submodules.c
@@ -449,7 +449,6 @@ void test_diff_submodules__skips_empty_includes_used(void)
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	git_diff *diff = NULL;
 	diff_expects exp;
-	git_repository *r2;
 
 	/* A side effect of of Git's handling of untracked directories and
 	 * auto-ignoring of ".git" entries is that a newly initialized Git
@@ -469,7 +468,11 @@ void test_diff_submodules__skips_empty_includes_used(void)
 	cl_assert_equal_i(0, exp.files);
 	git_diff_free(diff);
 
-	cl_git_pass(git_repository_init(&r2, "empty_standard_repo/subrepo", 0));
+	{
+		git_repository *r2;
+		cl_git_pass(git_repository_init(&r2, "empty_standard_repo/subrepo", 0));
+		git_repository_free(r2);
+	}
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	memset(&exp, 0, sizeof(exp));
-- 
cgit v1.2.3


From 10be94e9dc79b79842587dc4ef395d2033c9aae4 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 28 Mar 2014 10:09:13 -0700
Subject: Update clar to 587f88a

---
 tests/clar.c         | 27 ++++++++++++++++++++++++---
 tests/clar.h         |  6 ++++++
 tests/clar/sandbox.h |  5 +++++
 3 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/tests/clar.c b/tests/clar.c
index 535424130..8e538f56a 100644
--- a/tests/clar.c
+++ b/tests/clar.c
@@ -353,8 +353,8 @@ clar_parse_args(int argc, char **argv)
 	}
 }
 
-int
-clar_test(int argc, char **argv)
+void
+clar_test_init(int argc, char **argv)
 {
 	clar_print_init(
 		(int)_clar_callback_count,
@@ -369,13 +369,23 @@ clar_test(int argc, char **argv)
 
 	if (argc > 1)
 		clar_parse_args(argc, argv);
+}
 
+int
+clar_test_run()
+{
 	if (!_clar.suites_ran) {
 		size_t i;
 		for (i = 0; i < _clar_suite_count; ++i)
 			clar_run_suite(&_clar_suites[i], NULL);
 	}
 
+	return _clar.total_errors;
+}
+
+void
+clar_test_shutdown()
+{
 	clar_print_shutdown(
 		_clar.tests_ran,
 		(int)_clar_suite_count,
@@ -383,7 +393,18 @@ clar_test(int argc, char **argv)
 	);
 
 	clar_unsandbox();
-	return _clar.total_errors;
+}
+
+int
+clar_test(int argc, char **argv)
+{
+	int errors;
+
+	clar_test_init(argc, argv);
+	errors = clar_test_run();
+	clar_test_shutdown();
+
+	return errors;
 }
 
 void clar__fail(
diff --git a/tests/clar.h b/tests/clar.h
index 87ff6d967..81263051d 100644
--- a/tests/clar.h
+++ b/tests/clar.h
@@ -9,8 +9,14 @@
 
 #include <stdlib.h>
 
+void clar_test_init(int argc, char *argv[]);
+int clar_test_run(void);
+void clar_test_shutdown(void);
+
 int clar_test(int argc, char *argv[]);
 
+const char *clar_sandbox_path(void);
+
 void cl_set_cleanup(void (*cleanup)(void *), void *opaque);
 void cl_fs_cleanup(void);
 
diff --git a/tests/clar/sandbox.h b/tests/clar/sandbox.h
index ee7564148..a44e29116 100644
--- a/tests/clar/sandbox.h
+++ b/tests/clar/sandbox.h
@@ -127,3 +127,8 @@ static int clar_sandbox(void)
 	return 0;
 }
 
+const char *clar_sandbox_path(void)
+{
+	return _clar_path;
+}
+
-- 
cgit v1.2.3


From e0d61c7b1caa011ab6a7777535823fe18c50e13c Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 28 Mar 2014 10:10:59 -0700
Subject: Sandbox configuration during test runs

---
 tests/main.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/tests/main.c b/tests/main.c
index 6b498939d..ffbbcbf48 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -6,12 +6,21 @@ int __cdecl main(int argc, char *argv[])
 int main(int argc, char *argv[])
 #endif
 {
+	const char *sandbox_path;
 	int res;
 
+	clar_test_init(argc, argv);
+
 	git_threads_init();
 
+	sandbox_path = clar_sandbox_path();
+	git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, sandbox_path);
+	git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, sandbox_path);
+
 	/* Run the test suite */
-	res = clar_test(argc, argv);
+	res = clar_test_run();
+
+	clar_test_shutdown();
 
 	giterr_clear();
 	git_threads_shutdown();
-- 
cgit v1.2.3


From ed38bff16cb7a948d8059d8658d4fbf0b227f895 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 28 Mar 2014 17:54:43 -0700
Subject: Update clar to 4b75388

---
 tests/clar.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/clar.c b/tests/clar.c
index 8e538f56a..2f81a1923 100644
--- a/tests/clar.c
+++ b/tests/clar.c
@@ -106,6 +106,9 @@ struct clar_error {
 };
 
 static struct {
+	int argc;
+	char **argv;
+
 	const char *active_test;
 	const char *active_suite;
 
@@ -367,13 +370,16 @@ clar_test_init(int argc, char **argv)
 		exit(-1);
 	}
 
-	if (argc > 1)
-		clar_parse_args(argc, argv);
+	_clar.argc = argc;
+	_clar.argv = argv;
 }
 
 int
 clar_test_run()
 {
+	if (_clar.argc > 1)
+		clar_parse_args(_clar.argc, _clar.argv);
+
 	if (!_clar.suites_ran) {
 		size_t i;
 		for (i = 0; i < _clar_suite_count; ++i)
-- 
cgit v1.2.3


From 31143b365550e16fae8e092ad35bc91eb63c66eb Mon Sep 17 00:00:00 2001
From: Etienne Samson <tiennou7@gmail.com>
Date: Sun, 30 Mar 2014 18:08:32 +0200
Subject: Don't reset need_pack

While looping over multiple heads, an up-to-date head will clobber the `remote->need_pack` setting, preventing the rest of the machinery from building and downloading a pack-file, breaking fetches.
---
 src/fetch.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/fetch.c b/src/fetch.c
index c7d2c83a1..9ff95d935 100644
--- a/src/fetch.c
+++ b/src/fetch.c
@@ -44,7 +44,6 @@ static int maybe_want(git_remote *remote, git_remote_head *head, git_odb *odb, g
 	/* If we have the object, mark it so we don't ask for it */
 	if (git_odb_exists(odb, &head->oid)) {
 		head->local = 1;
-		remote->need_pack = 0;
 	}
 	else
 		remote->need_pack = 1;
@@ -107,6 +106,8 @@ int git_fetch_negotiate(git_remote *remote)
 {
 	git_transport *t = remote->transport;
 
+    remote->need_pack = 0;
+
 	if (filter_wants(remote) < 0) {
 		giterr_set(GITERR_NET, "Failed to filter the reference list for wants");
 		return -1;
-- 
cgit v1.2.3


From 976634c4672f3e1144b8f11c6c984157a28f5d98 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Sun, 30 Mar 2014 19:56:18 -0700
Subject: Introduce git_merge_head_id

---
 include/git2/merge.h        |  9 +++++++++
 src/merge.c                 |  8 ++++++++
 tests/merge/workdir/setup.c | 27 +++++++++++++++++++++++++++
 3 files changed, 44 insertions(+)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 21159d832..939f20214 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -375,6 +375,15 @@ GIT_EXTERN(int) git_merge_head_from_id(
 	git_repository *repo,
 	const git_oid *id);
 
+/**
+ * Gets the commit ID that the given `git_merge_head` refers to.
+ *
+ * @param id pointer to commit id to be filled in
+ * @param head the given merge head
+ */
+GIT_EXTERN(const git_oid *) git_merge_head_id(
+	const git_merge_head *head);
+
 /**
  * Frees a `git_merge_head`.
  *
diff --git a/src/merge.c b/src/merge.c
index 24b7d37ce..f9ed7b0a3 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2736,6 +2736,14 @@ int git_merge_head_from_fetchhead(
 	return merge_head_init(out, repo, branch_name, remote_url, oid);
 }
 
+const git_oid *git_merge_head_id(
+	const git_merge_head *head)
+{
+	assert(head);
+
+	return &head->oid;
+}
+
 void git_merge_head_free(git_merge_head *head)
 {
 	if (head == NULL)
diff --git a/tests/merge/workdir/setup.c b/tests/merge/workdir/setup.c
index 49b38b246..a0028ec6d 100644
--- a/tests/merge/workdir/setup.c
+++ b/tests/merge/workdir/setup.c
@@ -881,6 +881,33 @@ void test_merge_workdir_setup__two_remotes(void)
 	git_merge_head_free(their_heads[3]);
 }
 
+void test_merge_workdir_setup__id_from_head(void)
+{
+	git_oid expected_id;
+	const git_oid *id;
+	git_reference *ref;
+	git_merge_head *heads[3];
+
+	cl_git_pass(git_oid_fromstr(&expected_id, OCTO1_OID));
+	cl_git_pass(git_merge_head_from_fetchhead(&heads[0], repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH, "http://remote.url/repo.git", &expected_id));
+	id = git_merge_head_id(heads[0]);
+	cl_assert_equal_i(1, git_oid_equal(id, &expected_id));
+
+	cl_git_pass(git_merge_head_from_id(&heads[1], repo, &expected_id));
+	id = git_merge_head_id(heads[1]);
+	cl_assert_equal_i(1, git_oid_equal(id, &expected_id));
+
+	cl_git_pass(git_reference_lookup(&ref, repo, GIT_REFS_HEADS_DIR OCTO1_BRANCH));
+	cl_git_pass(git_merge_head_from_ref(&heads[2], repo, ref));
+	id = git_merge_head_id(heads[2]);
+	cl_assert_equal_i(1, git_oid_equal(id, &expected_id));
+
+	git_reference_free(ref);
+	git_merge_head_free(heads[0]);
+	git_merge_head_free(heads[1]);
+	git_merge_head_free(heads[2]);
+}
+
 struct merge_head_cb_data {
 	const char **oid_str;
 	unsigned int len;
-- 
cgit v1.2.3


From 7f930ded88b2adda94423a618e268700494dc5c0 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 31 Mar 2014 09:38:06 -0700
Subject: Const up members of git_merge_file_result

---
 include/git2/merge.h | 4 ++--
 src/merge_file.c     | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 939f20214..769df5a8d 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -177,13 +177,13 @@ typedef struct {
 	 * The path that the resultant merge file should use, or NULL if a
 	 * filename conflict would occur.
 	 */
-	char *path;
+	const char *path;
 
 	/** The mode that the resultant merge file should use.  */
 	unsigned int mode;
 
 	/** The contents of the merge. */
-	unsigned char *ptr;
+	const char *ptr;
 
 	/** The length of the merge contents. */
 	size_t len;
diff --git a/src/merge_file.c b/src/merge_file.c
index fc45cbfbf..ab9ca4168 100644
--- a/src/merge_file.c
+++ b/src/merge_file.c
@@ -272,8 +272,8 @@ void git_merge_file_result_free(git_merge_file_result *result)
 	if (result == NULL)
 		return;
 
-	git__free(result->path);
+	git__free((char *)result->path);
 
 	/* xdiff uses malloc() not git_malloc, so we use free(), not git_free() */
-	free(result->ptr);
+	free((char *)result->ptr);
 }
-- 
cgit v1.2.3


From 945c92a5cf1f73d56d0d2f06776f3181ed5b5548 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 31 Mar 2014 12:26:46 -0700
Subject: Add faster git_submodule__is_submodule check

---
 src/submodule.c | 15 +++++++++++++++
 src/submodule.h |  3 +++
 2 files changed, 18 insertions(+)

diff --git a/src/submodule.c b/src/submodule.c
index e1500b847..fdcc2251a 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -135,6 +135,21 @@ static int submodule_lookup(
  * PUBLIC APIS
  */
 
+bool git_submodule__is_submodule(git_repository *repo, const char *name)
+{
+	git_strmap *map;
+
+	if (load_submodule_config(repo, false) < 0) {
+		giterr_clear();
+		return false;
+	}
+
+	if (!(map = repo->submodules))
+		return false;
+
+	return git_strmap_valid_index(map, git_strmap_lookup_index(map, name));
+}
+
 int git_submodule_lookup(
 	git_submodule **out, /* NULL if user only wants to test existence */
 	git_repository *repo,
diff --git a/src/submodule.h b/src/submodule.h
index 053cb61e0..8199eb1da 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -119,6 +119,9 @@ enum {
 #define GIT_SUBMODULE_STATUS__CLEAR_INTERNAL(S) \
 	((S) & ~(0xFFFFFFFFu << 20))
 
+/* Internal submodule check does not attempt to refresh cached data */
+bool git_submodule__is_submodule(git_repository *repo, const char *name);
+
 /* Internal status fn returns status and optionally the various OIDs */
 extern int git_submodule__status(
 	unsigned int *out_status,
-- 
cgit v1.2.3


From c856f8c503a59ab6c8cc974d467aa2fcf509fd9b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 31 Mar 2014 12:27:05 -0700
Subject: Fix submodule sorting in workdir iterator

With the changes to how git_path_dirload_with_stat handles things
that look like submodules, submodules could end up sorted in the
wrong order with the workdir iterator.  This moves the submodule
check earlier in the iterator processing of a new directory so
that the submodule name updates will happen immediately and the
sort order will be correct.
---
 src/iterator.c | 41 +++++++++++++++++++++++++----------------
 1 file changed, 25 insertions(+), 16 deletions(-)

diff --git a/src/iterator.c b/src/iterator.c
index e9ec65250..1276903a7 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -1275,14 +1275,38 @@ GIT_INLINE(bool) workdir_path_is_dotgit(const git_buf *path)
 
 static int workdir_iterator__enter_dir(fs_iterator *fi)
 {
+	fs_iterator_frame *ff = fi->stack;
+	size_t pos;
+	git_path_with_stat *entry;
+	bool found_submodules = false;
+
 	/* only push new ignores if this is not top level directory */
-	if (fi->stack->next != NULL) {
+	if (ff->next != NULL) {
 		workdir_iterator *wi = (workdir_iterator *)fi;
 		ssize_t slash_pos = git_buf_rfind_next(&fi->path, '/');
 
 		(void)git_ignore__push_dir(&wi->ignores, &fi->path.ptr[slash_pos + 1]);
 	}
 
+	/* convert submodules to GITLINK and remove trailing slashes */
+	git_vector_foreach(&ff->entries, pos, entry) {
+		if (S_ISDIR(entry->st.st_mode) &&
+			git_submodule__is_submodule(fi->base.repo, entry->path))
+		{
+			entry->st.st_mode = GIT_FILEMODE_COMMIT;
+			entry->path_len--;
+			entry->path[entry->path_len] = '\0';
+			found_submodules = true;
+		}
+	}
+
+	/* if we renamed submodules, re-sort and re-seek to start */
+	if (found_submodules) {
+		git_vector_set_sorted(&ff->entries, 0);
+		git_vector_sort(&ff->entries);
+		fs_iterator__seek_frame_start(fi, ff);
+	}
+
 	return 0;
 }
 
@@ -1295,7 +1319,6 @@ static int workdir_iterator__leave_dir(fs_iterator *fi)
 
 static int workdir_iterator__update_entry(fs_iterator *fi)
 {
-	int error = 0;
 	workdir_iterator *wi = (workdir_iterator *)fi;
 
 	/* skip over .git entries */
@@ -1305,20 +1328,6 @@ static int workdir_iterator__update_entry(fs_iterator *fi)
 	/* reset is_ignored since we haven't checked yet */
 	wi->is_ignored = -1;
 
-	/* check if apparent tree entries are actually submodules */
-	if (fi->entry.mode != GIT_FILEMODE_TREE)
-		return 0;
-
-	error = git_submodule_lookup(NULL, fi->base.repo, fi->entry.path);
-	if (error < 0)
-		giterr_clear();
-
-	/* mark submodule as GITLINK and remove slash */
-	if (!error) {
-		fi->entry.mode = S_IFGITLINK;
-		fi->entry.path[strlen(fi->entry.path) - 1] = '\0';
-	}
-
 	return 0;
 }
 
-- 
cgit v1.2.3


From 7dcd42a55f5fdc61e8e8de472ec54ccc0613e23c Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 31 Mar 2014 13:31:01 -0700
Subject: Cleanups

---
 src/iterator.c   | 2 +-
 src/merge_file.c | 4 ++--
 src/submodule.h  | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/iterator.c b/src/iterator.c
index 1276903a7..a7a44914c 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -10,7 +10,7 @@
 #include "index.h"
 #include "ignore.h"
 #include "buffer.h"
-#include "git2/submodule.h"
+#include "submodule.h"
 #include <ctype.h>
 
 #define ITERATOR_SET_CB(P,NAME_LC) do { \
diff --git a/src/merge_file.c b/src/merge_file.c
index ab9ca4168..ff0364432 100644
--- a/src/merge_file.c
+++ b/src/merge_file.c
@@ -117,7 +117,7 @@ static int git_merge_file__from_inputs(
 
 	memset(out, 0x0, sizeof(git_merge_file_result));
 
-	merge_file_normalize_opts(&options, given_opts);		
+	merge_file_normalize_opts(&options, given_opts);
 
 	memset(&xmparam, 0x0, sizeof(xmparam_t));
 
@@ -165,7 +165,7 @@ static int git_merge_file__from_inputs(
 	}
 
 	out->automergeable = (xdl_result == 0);
-	out->ptr = (unsigned char *)mmbuffer.ptr;
+	out->ptr = (const char *)mmbuffer.ptr;
 	out->len = mmbuffer.size;
 	out->mode = merge_file_best_mode(ancestor, ours, theirs);
 
diff --git a/src/submodule.h b/src/submodule.h
index 8199eb1da..1c41897e3 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -120,7 +120,7 @@ enum {
 	((S) & ~(0xFFFFFFFFu << 20))
 
 /* Internal submodule check does not attempt to refresh cached data */
-bool git_submodule__is_submodule(git_repository *repo, const char *name);
+extern bool git_submodule__is_submodule(git_repository *repo, const char *name);
 
 /* Internal status fn returns status and optionally the various OIDs */
 extern int git_submodule__status(
-- 
cgit v1.2.3


From b76b5d34275fe33192358d4eaa1ae98e31efc2a1 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 31 Mar 2014 13:33:11 -0700
Subject: Improve test of submodule name sorting

---
 tests/diff/submodules.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/diff/submodules.c b/tests/diff/submodules.c
index ead5c71b6..2881f74be 100644
--- a/tests/diff/submodules.c
+++ b/tests/diff/submodules.c
@@ -182,6 +182,8 @@ void test_diff_submodules__submod2_index_to_wd(void)
 		"<UNTRACKED>", /* not */
 		"diff --git a/sm_changed_file b/sm_changed_file\nindex 4800958..4800958 160000\n--- a/sm_changed_file\n+++ b/sm_changed_file\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0-dirty\n", /* sm_changed_file */
 		"diff --git a/sm_changed_head b/sm_changed_head\nindex 4800958..3d9386c 160000\n--- a/sm_changed_head\n+++ b/sm_changed_head\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 3d9386c507f6b093471a3e324085657a3c2b4247\n", /* sm_changed_head */
+		"<UNTRACKED>", /* sm_changed_head- */
+		"<UNTRACKED>", /* sm_changed_head_ */
 		"diff --git a/sm_changed_index b/sm_changed_index\nindex 4800958..4800958 160000\n--- a/sm_changed_index\n+++ b/sm_changed_index\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0-dirty\n", /* sm_changed_index */
 		"diff --git a/sm_changed_untracked_file b/sm_changed_untracked_file\nindex 4800958..4800958 160000\n--- a/sm_changed_untracked_file\n+++ b/sm_changed_untracked_file\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0-dirty\n", /* sm_changed_untracked_file */
 		"diff --git a/sm_missing_commits b/sm_missing_commits\nindex 4800958..5e49635 160000\n--- a/sm_missing_commits\n+++ b/sm_missing_commits\n@@ -1 +1 @@\n-Subproject commit 480095882d281ed676fe5b863569520e54a7d5c0\n+Subproject commit 5e4963595a9774b90524d35a807169049de8ccad\n", /* sm_missing_commits */
@@ -190,6 +192,10 @@ void test_diff_submodules__submod2_index_to_wd(void)
 
 	g_repo = setup_fixture_submod2();
 
+	/* bracket existing submodule with similarly named items */
+	cl_git_mkfile("submod2/sm_changed_head-", "hello");
+	cl_git_mkfile("submod2/sm_changed_head_", "hello");
+
 	opts.flags = GIT_DIFF_INCLUDE_UNTRACKED;
 	opts.old_prefix = "a"; opts.new_prefix = "b";
 
-- 
cgit v1.2.3


From 3bc3d797611fccdf7a15cafafbb965b37fbb03f1 Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Mon, 31 Mar 2014 15:15:32 -0700
Subject: No need to find merge base.

---
 src/revwalk.c         | 52 +++++++++++----------------------
 src/revwalk.h         |  3 +-
 tests/revwalk/basic.c | 79 ++++++++++++++++++++++++++++++++++++++++++++++++---
 3 files changed, 93 insertions(+), 41 deletions(-)

diff --git a/src/revwalk.c b/src/revwalk.c
index f0109360b..7aedd1f44 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -39,8 +39,9 @@ git_commit_list_node *git_revwalk__commit_lookup(
 	return commit;
 }
 
-static int mark_uninteresting(git_commit_list_node *commit)
+static int mark_uninteresting(git_revwalk *walk, git_commit_list_node *commit)
 {
+	int error;
 	unsigned short i;
 	git_array_t(git_commit_list_node *) pending = GIT_ARRAY_INIT;
 	git_commit_list_node **tmp;
@@ -53,12 +54,8 @@ static int mark_uninteresting(git_commit_list_node *commit)
 	do {
 		commit->uninteresting = 1;
 
-		/* This means we've reached a merge base, so there's no need to walk any more */
-		if ((commit->flags & (RESULT | STALE)) == RESULT) {
-			tmp = git_array_pop(pending);
-			commit = tmp ? *tmp : NULL;
-			continue;
-		}
+		if ((error = git_commit_list_parse(walk, commit)) < 0)
+			return error;
 
 		for (i = 0; i < commit->out_degree; ++i)
 			if (!commit->parents[i]->uninteresting) {
@@ -84,7 +81,7 @@ static int process_commit(git_revwalk *walk, git_commit_list_node *commit, int h
 	if (!hide && walk->hide_cb)
 		hide = walk->hide_cb(&commit->oid, walk->hide_cb_payload);
 
-	if (hide && mark_uninteresting(commit) < 0)
+	if (hide && mark_uninteresting(walk, commit) < 0)
 		return -1;
 
 	if (commit->seen)
@@ -95,7 +92,10 @@ static int process_commit(git_revwalk *walk, git_commit_list_node *commit, int h
 	if ((error = git_commit_list_parse(walk, commit)) < 0)
 		return error;
 
-	return walk->enqueue(walk, commit);
+	if (!hide)
+		return walk->enqueue(walk, commit);
+
+	return 0;
 }
 
 static int process_commit_parents(git_revwalk *walk, git_commit_list_node *commit)
@@ -144,9 +144,6 @@ static int push_commit(git_revwalk *walk, const git_oid *oid, int uninteresting,
 	if (commit == NULL)
 		return -1; /* error already reported by failed lookup */
 
-	if (uninteresting)
-		walk->did_hide = 1;
-
 	commit->uninteresting = uninteresting;
 	if (walk->one == NULL && !uninteresting) {
 		walk->one = commit;
@@ -298,15 +295,14 @@ static int revwalk_next_timesort(git_commit_list_node **object_out, git_revwalk
 	int error;
 	git_commit_list_node *next;
 
-	while ((next = git_pqueue_pop(&walk->iterator_time)) != NULL) {
-		if ((error = process_commit_parents(walk, next)) < 0)
-			return error;
-
+	while ((next = git_pqueue_pop(&walk->iterator_time)) != NULL)
 		if (!next->uninteresting) {
+			if ((error = process_commit_parents(walk, next)) < 0)
+				return error;
+
 			*object_out = next;
 			return 0;
 		}
-	}
 
 	giterr_clear();
 	return GIT_ITEROVER;
@@ -317,15 +313,14 @@ static int revwalk_next_unsorted(git_commit_list_node **object_out, git_revwalk
 	int error;
 	git_commit_list_node *next;
 
-	while ((next = git_commit_list_pop(&walk->iterator_rand)) != NULL) {
-		if ((error = process_commit_parents(walk, next)) < 0)
-			return error;
-
+	while ((next = git_commit_list_pop(&walk->iterator_rand)) != NULL)
 		if (!next->uninteresting) {
+			if ((error = process_commit_parents(walk, next)) < 0)
+				return error;
+
 			*object_out = next;
 			return 0;
 		}
-	}
 
 	giterr_clear();
 	return GIT_ITEROVER;
@@ -380,7 +375,6 @@ static int prepare_walk(git_revwalk *walk)
 	int error;
 	unsigned int i;
 	git_commit_list_node *next, *two;
-	git_commit_list *bases = NULL;
 
 	/*
 	 * If walk->one is NULL, there were no positive references,
@@ -391,18 +385,6 @@ static int prepare_walk(git_revwalk *walk)
 		return GIT_ITEROVER;
 	}
 
-	/*
-	 * If the user asked to hide commits, we need to figure out
-	 * what the merge bases are so we can know when we can stop
-	 * marking parents uninteresting.
-	 */
-	if (walk->did_hide) {
-		if (git_merge__bases_many(&bases, walk, walk->one, &walk->twos) < 0)
-			return -1;
-
-		git_commit_list_free(&bases);
-	}
-
 	if (process_commit(walk, walk->one, walk->one->uninteresting) < 0)
 		return -1;
 
diff --git a/src/revwalk.h b/src/revwalk.h
index a0654f3e5..d81f97c01 100644
--- a/src/revwalk.h
+++ b/src/revwalk.h
@@ -32,8 +32,7 @@ struct git_revwalk {
 	int (*enqueue)(git_revwalk *, git_commit_list_node *);
 
 	unsigned walking:1,
-		first_parent: 1,
-		did_hide: 1;
+		first_parent: 1;
 	unsigned int sorting;
 
 	/* merge base calculation */
diff --git a/tests/revwalk/basic.c b/tests/revwalk/basic.c
index 7e08c1840..b015db18b 100644
--- a/tests/revwalk/basic.c
+++ b/tests/revwalk/basic.c
@@ -160,7 +160,7 @@ void test_revwalk_basic__glob_heads(void)
 	}
 
 	/* git log --branches --oneline | wc -l => 14 */
-	cl_assert(i == 14);
+	cl_assert_equal_i(i, 14);
 }
 
 void test_revwalk_basic__glob_heads_with_invalid(void)
@@ -194,7 +194,7 @@ void test_revwalk_basic__push_head(void)
 	}
 
 	/* git log HEAD --oneline | wc -l => 7 */
-	cl_assert(i == 7);
+	cl_assert_equal_i(i, 7);
 }
 
 void test_revwalk_basic__push_head_hide_ref(void)
@@ -212,7 +212,7 @@ void test_revwalk_basic__push_head_hide_ref(void)
 	}
 
 	/* git log HEAD --oneline --not refs/heads/packed-test | wc -l => 4 */
-	cl_assert(i == 4);
+	cl_assert_equal_i(i, 4);
 }
 
 void test_revwalk_basic__push_head_hide_ref_nobase(void)
@@ -230,7 +230,78 @@ void test_revwalk_basic__push_head_hide_ref_nobase(void)
 	}
 
 	/* git log HEAD --oneline --not refs/heads/packed | wc -l => 7 */
-	cl_assert(i == 7);
+	cl_assert_equal_i(i, 7);
+}
+
+/*
+* $ git rev-list HEAD 5b5b02 ^refs/heads/packed-test
+* a65fedf39aefe402d3bb6e24df4d4f5fe4547750
+* be3563ae3f795b2b4353bcce3a527ad0a4f7f644
+* c47800c7266a2be04c571c04d5a6614691ea99bd
+* 9fd738e8f7967c078dceed8190330fc8648ee56a
+
+* $ git log HEAD 5b5b02 --oneline --not refs/heads/packed-test | wc -l => 4
+* a65fedf
+* be3563a Merge branch 'br2'
+* c47800c branch commit one
+* 9fd738e a fourth commit
+*/
+void test_revwalk_basic__multiple_push_1(void)
+{
+	int i = 0;
+	git_oid oid;
+
+	revwalk_basic_setup_walk(NULL);
+
+	cl_git_pass(git_revwalk_push_head(_walk));
+
+	cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed-test"));
+
+	cl_git_pass(git_oid_fromstr(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644"));
+	cl_git_pass(git_revwalk_push(_walk, &oid));
+
+	while (git_revwalk_next(&oid, _walk) == 0)
+		i++;
+
+	cl_assert_equal_i(i, 4);
+}
+
+/*
+* Difference between test_revwalk_basic__multiple_push_1 and 
+* test_revwalk_basic__multiple_push_2 is in the order reference
+* refs/heads/packed-test and commit 5b5b02 are pushed. 
+* revwalk should return same commits in both the tests.
+
+* $ git rev-list 5b5b02 HEAD ^refs/heads/packed-test
+* a65fedf39aefe402d3bb6e24df4d4f5fe4547750
+* be3563ae3f795b2b4353bcce3a527ad0a4f7f644
+* c47800c7266a2be04c571c04d5a6614691ea99bd
+* 9fd738e8f7967c078dceed8190330fc8648ee56a
+
+* $ git log 5b5b02 HEAD --oneline --not refs/heads/packed-test | wc -l => 4
+* a65fedf
+* be3563a Merge branch 'br2'
+* c47800c branch commit one
+* 9fd738e a fourth commit
+*/
+void test_revwalk_basic__multiple_push_2(void)
+{
+	int i = 0;
+	git_oid oid;
+
+	revwalk_basic_setup_walk(NULL);
+
+	cl_git_pass(git_oid_fromstr(&oid, "5b5b025afb0b4c913b4c338a42934a3863bf3644"));
+	cl_git_pass(git_revwalk_push(_walk, &oid));
+
+	cl_git_pass(git_revwalk_hide_ref(_walk, "refs/heads/packed-test"));
+
+	cl_git_pass(git_revwalk_push_head(_walk));
+
+	while (git_revwalk_next(&oid, _walk) == 0)
+		i++;
+
+	cl_assert_equal_i(i, 4);
 }
 
 void test_revwalk_basic__disallow_non_commit(void)
-- 
cgit v1.2.3


From 6ad59ef1d461180a51a59d5809dcfd01e2d8cfd9 Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Tue, 1 Apr 2014 12:16:40 +0200
Subject: examples: Use git_object_short_id

---
 examples/tag.c | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/examples/tag.c b/examples/tag.c
index 4c689cc55..ebb8e37b2 100644
--- a/examples/tag.c
+++ b/examples/tag.c
@@ -169,20 +169,22 @@ static void action_delete_tag(tag_state *state)
 {
 	tag_options *opts = state->opts;
 	git_object *obj;
-	char oid[GIT_OID_HEXSZ + 1];
+	git_buf abbrev_oid = {0};
 
 	check(!opts->tag_name, "Name required");
 
 	check_lg2(git_revparse_single(&obj, state->repo, opts->tag_name),
 			"Failed to lookup rev", opts->tag_name);
 
+	check_lg2(git_object_short_id(&abbrev_oid, obj),
+			"Unable to get abbreviated OID", opts->tag_name);
+
 	check_lg2(git_tag_delete(state->repo, opts->tag_name),
 			"Unable to delete tag", opts->tag_name);
 
-	git_oid_tostr(oid, sizeof(oid), git_object_id(obj));
-
-	printf("Deleted tag '%s' (was %s)\n", opts->tag_name, oid);
+	printf("Deleted tag '%s' (was %s)\n", opts->tag_name, abbrev_oid.ptr);
 
+	git_buf_free(&abbrev_oid);
 	git_object_free(obj);
 }
 
-- 
cgit v1.2.3


From fd536d29c127648abb2ce5f6f619135ce69b9800 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 26 Mar 2014 11:15:57 +0100
Subject: remote: rename inmemory to anonymous and swap url and fetch order

The order in this function is the opposite to what
create_with_fetchspec() has, so change this one, as url-then-refspec is
what git does.

As we need to break compilation and the swap doesn't do that, let's take
this opportunity to rename in-memory remotes to anonymous as that's
really what sets them apart.
---
 examples/network/fetch.c       |  2 +-
 examples/network/ls-remote.c   |  2 +-
 include/git2/remote.h          | 14 +++++++-------
 src/remote.c                   |  8 ++++----
 tests/network/remote/local.c   |  8 ++++----
 tests/network/remote/remotes.c |  8 ++++----
 tests/network/remote/rename.c  |  2 +-
 7 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/examples/network/fetch.c b/examples/network/fetch.c
index ad16f2793..fdd82a1f7 100644
--- a/examples/network/fetch.c
+++ b/examples/network/fetch.c
@@ -91,7 +91,7 @@ int fetch(git_repository *repo, int argc, char **argv)
 	// Figure out whether it's a named remote or a URL
 	printf("Fetching %s for repo %p\n", argv[1], repo);
 	if (git_remote_load(&remote, repo, argv[1]) < 0) {
-		if (git_remote_create_inmemory(&remote, repo, NULL, argv[1]) < 0)
+		if (git_remote_create_anonymous(&remote, repo, argv[1], NULL) < 0)
 			return -1;
 	}
 
diff --git a/examples/network/ls-remote.c b/examples/network/ls-remote.c
index 1e08b293e..a5c14cea8 100644
--- a/examples/network/ls-remote.c
+++ b/examples/network/ls-remote.c
@@ -15,7 +15,7 @@ static int use_remote(git_repository *repo, char *name)
 	// Find the remote by name
 	error = git_remote_load(&remote, repo, name);
 	if (error < 0) {
-		error = git_remote_create_inmemory(&remote, repo, NULL, name);
+		error = git_remote_create_anonymous(&remote, repo, name, NULL);
 		if (error < 0)
 			goto cleanup;
 	}
diff --git a/include/git2/remote.h b/include/git2/remote.h
index 82a46acd1..d57321f03 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -62,10 +62,10 @@ GIT_EXTERN(int) git_remote_create_with_fetchspec(
 		const char *fetch);
 
 /**
- * Create a remote in memory
+ * Create an anonymous remote
  *
- * Create a remote with the given refspec in memory. You can use
- * this when you have a URL instead of a remote's name.  Note that in-memory
+ * Create a remote with the given url and refspec in memory. You can use
+ * this when you have a URL instead of a remote's name.  Note that anonymous
  * remotes cannot be converted to persisted remotes.
  *
  * The name, when provided, will be checked for validity.
@@ -73,15 +73,15 @@ GIT_EXTERN(int) git_remote_create_with_fetchspec(
  *
  * @param out pointer to the new remote object
  * @param repo the associated repository
- * @param fetch the fetch refspec to use for this remote.
  * @param url the remote repository's URL
+ * @param fetch the fetch refspec to use for this remote.
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_remote_create_inmemory(
+GIT_EXTERN(int) git_remote_create_anonymous(
 		git_remote **out,
 		git_repository *repo,
-		const char *fetch,
-		const char *url);
+		const char *url,
+		const char *fetch);
 
 /**
  * Get the information for a particular remote
diff --git a/src/remote.c b/src/remote.c
index caefc686e..62ee90375 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -236,7 +236,7 @@ on_error:
 	return -1;
 }
 
-int git_remote_create_inmemory(git_remote **out, git_repository *repo, const char *fetch, const char *url)
+int git_remote_create_anonymous(git_remote **out, git_repository *repo, const char *url, const char *fetch)
 {
 	int error;
 	git_remote *remote;
@@ -502,7 +502,7 @@ int git_remote_save(const git_remote *remote)
 	assert(remote);
 
 	if (!remote->name) {
-		giterr_set(GITERR_INVALID, "Can't save an in-memory remote.");
+		giterr_set(GITERR_INVALID, "Can't save an anonymous remote.");
 		return GIT_EINVALIDSPEC;
 	}
 
@@ -1433,7 +1433,7 @@ static int rename_fetch_refspecs(
 		if (spec->push)
 			continue;
 
-		/* Every refspec is a problem refspec for an in-memory remote, OR */
+		/* Every refspec is a problem refspec for an anonymous remote, OR */
 		/* Does the dst part of the refspec follow the expected format? */
 		if (!remote->name ||
 			strcmp(git_buf_cstr(&base), spec->string)) {
@@ -1481,7 +1481,7 @@ int git_remote_rename(
 	assert(remote && new_name);
 
 	if (!remote->name) {
-		giterr_set(GITERR_INVALID, "Can't rename an in-memory remote.");
+		giterr_set(GITERR_INVALID, "Can't rename an anonymous remote.");
 		return GIT_EINVALIDSPEC;
 	}
 
diff --git a/tests/network/remote/local.c b/tests/network/remote/local.c
index 589e6ac9b..75f767980 100644
--- a/tests/network/remote/local.c
+++ b/tests/network/remote/local.c
@@ -30,7 +30,7 @@ static void connect_to_local_repository(const char *local_repository)
 {
 	git_buf_sets(&file_path_buf, cl_git_path_url(local_repository));
 
-	cl_git_pass(git_remote_create_inmemory(&remote, repo, NULL, git_buf_cstr(&file_path_buf)));
+	cl_git_pass(git_remote_create_anonymous(&remote, repo, git_buf_cstr(&file_path_buf), NULL));
 	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
 }
 
@@ -182,7 +182,7 @@ void test_network_remote_local__push_to_bare_remote(void)
 	}
 
 	/* Connect to the bare repo */
-	cl_git_pass(git_remote_create_inmemory(&localremote, repo, NULL, "./localbare.git"));
+	cl_git_pass(git_remote_create_anonymous(&localremote, repo, "./localbare.git", NULL));
 	cl_git_pass(git_remote_connect(localremote, GIT_DIRECTION_PUSH));
 
 	/* Try to push */
@@ -222,7 +222,7 @@ void test_network_remote_local__push_to_bare_remote_with_file_url(void)
 	url = cl_git_path_url("./localbare.git");
 
 	/* Connect to the bare repo */
-	cl_git_pass(git_remote_create_inmemory(&localremote, repo, NULL, url));
+	cl_git_pass(git_remote_create_anonymous(&localremote, repo, url, NULL));
 	cl_git_pass(git_remote_connect(localremote, GIT_DIRECTION_PUSH));
 
 	/* Try to push */
@@ -259,7 +259,7 @@ void test_network_remote_local__push_to_non_bare_remote(void)
 	}
 
 	/* Connect to the bare repo */
-	cl_git_pass(git_remote_create_inmemory(&localremote, repo, NULL, "./localnonbare"));
+	cl_git_pass(git_remote_create_anonymous(&localremote, repo, "./localnonbare", NULL));
 	cl_git_pass(git_remote_connect(localremote, GIT_DIRECTION_PUSH));
 
 	/* Try to push */
diff --git a/tests/network/remote/remotes.c b/tests/network/remote/remotes.c
index fe40d1085..306ccaee5 100644
--- a/tests/network/remote/remotes.c
+++ b/tests/network/remote/remotes.c
@@ -66,7 +66,7 @@ void test_network_remote_remotes__error_when_no_push_available(void)
 	git_transport *t;
 	git_push *p;
 
-	cl_git_pass(git_remote_create_inmemory(&r, _repo, NULL, cl_fixture("testrepo.git")));
+	cl_git_pass(git_remote_create_anonymous(&r, _repo, cl_fixture("testrepo.git"), NULL));
 
 	cl_git_pass(git_transport_local(&t,r,NULL));
 
@@ -343,7 +343,7 @@ void test_network_remote_remotes__cannot_save_an_inmemory_remote(void)
 {
 	git_remote *remote;
 
-	cl_git_pass(git_remote_create_inmemory(&remote, _repo, NULL, "git://github.com/libgit2/libgit2"));
+	cl_git_pass(git_remote_create_anonymous(&remote, _repo, "git://github.com/libgit2/libgit2", NULL));
 
 	cl_assert_equal_p(NULL, git_remote_name(remote));
 
@@ -436,7 +436,7 @@ void test_network_remote_remotes__check_structure_version(void)
 
 	git_remote_free(_remote);
 	_remote = NULL;
-	cl_git_pass(git_remote_create_inmemory(&_remote, _repo, NULL, "test-protocol://localhost"));
+	cl_git_pass(git_remote_create_anonymous(&_remote, _repo, "test-protocol://localhost", NULL));
 
 	transport.version = 0;
 	cl_git_fail(git_remote_set_transport(_remote, &transport));
@@ -503,7 +503,7 @@ void test_network_remote_remotes__query_refspecs(void)
 	git_strarray array;
 	int i;
 
-	cl_git_pass(git_remote_create_inmemory(&remote, _repo, NULL, "git://github.com/libgit2/libgit2"));
+	cl_git_pass(git_remote_create_anonymous(&remote, _repo, "git://github.com/libgit2/libgit2", NULL));
 
 	for (i = 0; i < 3; i++) {
 		cl_git_pass(git_remote_add_fetch(remote, fetch_refspecs[i]));
diff --git a/tests/network/remote/rename.c b/tests/network/remote/rename.c
index ed98ee811..4d8628425 100644
--- a/tests/network/remote/rename.c
+++ b/tests/network/remote/rename.c
@@ -167,7 +167,7 @@ void test_network_remote_rename__cannot_rename_an_inmemory_remote(void)
 {
 	git_remote *remote;
 
-	cl_git_pass(git_remote_create_inmemory(&remote, _repo, NULL, "file:///blah"));
+	cl_git_pass(git_remote_create_anonymous(&remote, _repo, "file:///blah", NULL));
 	cl_git_fail(git_remote_rename(remote, "newname", NULL, NULL));
 
 	git_remote_free(remote);
-- 
cgit v1.2.3


From 9e1ed9f2c0e5345eebbefdb6708fad274f37bdcd Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Tue, 1 Apr 2014 23:01:40 +0800
Subject: Add CFLAGS -Wdeclaration-after-statement

This warns local variables declarations after statement, which helps not to break MSVC
---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index cca2a120c..23c5af1fc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -287,7 +287,7 @@ IF (MSVC)
    # Precompiled headers
 
 ELSE ()
-	SET(CMAKE_C_FLAGS "-D_GNU_SOURCE -Wall -Wextra -Wno-missing-field-initializers -Wstrict-aliasing=2 -Wstrict-prototypes ${CMAKE_C_FLAGS}")
+	SET(CMAKE_C_FLAGS "-D_GNU_SOURCE -Wall -Wextra -Wno-missing-field-initializers -Wstrict-aliasing=2 -Wstrict-prototypes -Wdeclaration-after-statement ${CMAKE_C_FLAGS}")
 
 	IF (WIN32 AND NOT CYGWIN)
 		SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG")
-- 
cgit v1.2.3


From 18234b14ad55157581ca26ec763afc1af3ec6e76 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 21 Feb 2014 09:14:16 -0800
Subject: Add efficient git_buf join3 API

There are a few places where we need to join three strings to
assemble a path.  This adds a simple join3 function to avoid the
comparatively expensive join_n (which calls strlen on each string
twice).
---
 src/buffer.c        | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/buffer.h        |  4 ++++
 src/refdb_fs.c      |  2 +-
 src/submodule.c     |  9 +++++----
 tests/core/buffer.c | 32 ++++++++++++++++++++++++++++++++
 5 files changed, 95 insertions(+), 5 deletions(-)

diff --git a/src/buffer.c b/src/buffer.c
index a83ca8792..83960e912 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -467,6 +467,59 @@ int git_buf_join(
 	return 0;
 }
 
+int git_buf_join3(
+	git_buf *buf,
+	char separator,
+	const char *str_a,
+	const char *str_b,
+	const char *str_c)
+{
+	size_t len_a = strlen(str_a), len_b = strlen(str_b), len_c = strlen(str_c);
+	int sep_a = 0, sep_b = 0;
+	char *tgt;
+
+	/* for this function, disallow pointers into the existing buffer */
+	assert(str_a < buf->ptr || str_a >= buf->ptr + buf->size);
+	assert(str_b < buf->ptr || str_b >= buf->ptr + buf->size);
+	assert(str_c < buf->ptr || str_c >= buf->ptr + buf->size);
+
+	if (separator) {
+		if (len_a > 0) {
+			while (*str_b == separator) { str_b++; len_b--; }
+			sep_a = (str_a[len_a - 1] != separator);
+		}
+		if (len_a > 0 || len_b > 0)
+			while (*str_c == separator) { str_c++; len_c--; }
+		if (len_b > 0)
+			sep_b = (str_b[len_b - 1] != separator);
+	}
+
+	if (git_buf_grow(buf, len_a + sep_a + len_b + sep_b + len_c + 1) < 0)
+		return -1;
+
+	tgt = buf->ptr;
+
+	if (len_a) {
+		memcpy(tgt, str_a, len_a);
+		tgt += len_a;
+	}
+	if (sep_a)
+		*tgt++ = separator;
+	if (len_b) {
+		memcpy(tgt, str_b, len_b);
+		tgt += len_b;
+	}
+	if (sep_b)
+		*tgt++ = separator;
+	if (len_c)
+		memcpy(tgt, str_c, len_c);
+
+	buf->size = len_a + sep_a + len_b + sep_b + len_c;
+	buf->ptr[buf->size] = '\0';
+
+	return 0;
+}
+
 void git_buf_rtrim(git_buf *buf)
 {
 	while (buf->size > 0) {
diff --git a/src/buffer.h b/src/buffer.h
index 4c852b3cb..dba594d97 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -98,8 +98,12 @@ void git_buf_truncate(git_buf *buf, size_t len);
 void git_buf_shorten(git_buf *buf, size_t amount);
 void git_buf_rtruncate_at_char(git_buf *path, char separator);
 
+/** General join with separator */
 int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...);
+/** Fast join of two strings - first may legally point into `buf` data */
 int git_buf_join(git_buf *buf, char separator, const char *str_a, const char *str_b);
+/** Fast join of three strings - cannot reference `buf` data */
+int git_buf_join3(git_buf *buf, char separator, const char *str_a, const char *str_b, const char *str_c);
 
 /**
  * Join two strings as paths, inserting a slash between as needed.
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 9120a3e87..2550b7e26 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -1432,7 +1432,7 @@ static int create_new_reflog_file(const char *filepath)
 
 GIT_INLINE(int) retrieve_reflog_path(git_buf *path, git_repository *repo, const char *name)
 {
-	return git_buf_join_n(path, '/', 3, repo->path_repository, GIT_REFLOG_DIR, name);
+	return git_buf_join3(path, '/', repo->path_repository, GIT_REFLOG_DIR, name);
 }
 
 static int refdb_reflog_fs__ensure_log(git_refdb_backend *_backend, const char *name)
diff --git a/src/submodule.c b/src/submodule.c
index fdcc2251a..a0ce5317f 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -168,10 +168,11 @@ int git_submodule_lookup(
 		if (git_repository_workdir(repo)) {
 			git_buf path = GIT_BUF_INIT;
 
-			if (git_buf_joinpath(&path, git_repository_workdir(repo), name) < 0)
+			if (git_buf_join3(&path,
+					'/', git_repository_workdir(repo), name, DOT_GIT) < 0)
 				return -1;
 
-			if (git_path_contains(&path, DOT_GIT))
+			if (git_path_exists(path.ptr))
 				error = GIT_EEXISTS;
 
 			git_buf_free(&path);
@@ -328,8 +329,8 @@ int git_submodule_add_setup(
 	else if (use_gitlink) {
 		git_buf repodir = GIT_BUF_INIT;
 
-		error = git_buf_join_n(
-			&repodir, '/', 3, git_repository_path(repo), "modules", path);
+		error = git_buf_join3(
+			&repodir, '/', git_repository_path(repo), "modules", path);
 		if (error < 0)
 			goto cleanup;
 
diff --git a/tests/core/buffer.c b/tests/core/buffer.c
index 0e7dd3d70..eb1d95a95 100644
--- a/tests/core/buffer.c
+++ b/tests/core/buffer.c
@@ -599,6 +599,38 @@ void test_core_buffer__10(void)
 	git_buf_free(&a);
 }
 
+void test_core_buffer__join3(void)
+{
+	git_buf a = GIT_BUF_INIT;
+
+	cl_git_pass(git_buf_join3(&a, '/', "test", "string", "join"));
+	cl_assert_equal_s("test/string/join", a.ptr);
+	cl_git_pass(git_buf_join3(&a, '/', "test/", "string", "join"));
+	cl_assert_equal_s("test/string/join", a.ptr);
+	cl_git_pass(git_buf_join3(&a, '/', "test/", "/string", "join"));
+	cl_assert_equal_s("test/string/join", a.ptr);
+	cl_git_pass(git_buf_join3(&a, '/', "test/", "/string/", "join"));
+	cl_assert_equal_s("test/string/join", a.ptr);
+	cl_git_pass(git_buf_join3(&a, '/', "test/", "/string/", "/join"));
+	cl_assert_equal_s("test/string/join", a.ptr);
+
+	cl_git_pass(git_buf_join3(&a, '/', "", "string", "join"));
+	cl_assert_equal_s("string/join", a.ptr);
+	cl_git_pass(git_buf_join3(&a, '/', "", "string/", "join"));
+	cl_assert_equal_s("string/join", a.ptr);
+	cl_git_pass(git_buf_join3(&a, '/', "", "string/", "/join"));
+	cl_assert_equal_s("string/join", a.ptr);
+
+	cl_git_pass(git_buf_join3(&a, '/', "string", "", "join"));
+	cl_assert_equal_s("string/join", a.ptr);
+	cl_git_pass(git_buf_join3(&a, '/', "string/", "", "join"));
+	cl_assert_equal_s("string/join", a.ptr);
+	cl_git_pass(git_buf_join3(&a, '/', "string/", "", "/join"));
+	cl_assert_equal_s("string/join", a.ptr);
+
+	git_buf_free(&a);
+}
+
 void test_core_buffer__11(void)
 {
 	git_buf a = GIT_BUF_INIT;
-- 
cgit v1.2.3


From 8286300a1e2d24dfe184316c0f9798f2c69d0ef4 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 18 Dec 2013 11:48:57 -0800
Subject: Fix git_submodule_sync and add new config helper

This fixes `git_submodule_sync` to correctly update the remote URL
of the default branch of the submodule along with the URL in the
parent repository config (i.e. match core Git's behavior).

Also move some useful helper logic from the submodule code into
a shared config API `git_config__update_entry` that can either set
or delete an entry with constraints like not overwriting or not
creating a new entry.  I used that helper to update a couple other
places in the code.
---
 src/config.c    |  30 ++++++++++++
 src/config.h    |   8 ++++
 src/remote.c    |  86 ++++++++++++++---------------------
 src/submodule.c | 138 +++++++++++++++++++++++++++++++-------------------------
 4 files changed, 149 insertions(+), 113 deletions(-)

diff --git a/src/config.c b/src/config.c
index 1a205fe13..b3168f735 100644
--- a/src/config.c
+++ b/src/config.c
@@ -615,6 +615,36 @@ int git_config_set_string(git_config *cfg, const char *name, const char *value)
 	return error;
 }
 
+int git_config__update_entry(
+	git_config *config,
+	const char *key,
+	const char *value,
+	bool overwrite_existing,
+	bool only_if_existing)
+{
+	int error = 0;
+	const git_config_entry *ce = NULL;
+
+	if ((error = git_config__lookup_entry(&ce, config, key, false)) < 0)
+		return error;
+
+	if (!ce && only_if_existing) /* entry doesn't exist */
+		return 0;
+	if (ce && !overwrite_existing) /* entry would be overwritten */
+		return 0;
+	if (value && ce && ce->value && !strcmp(ce->value, value)) /* no change */
+		return 0;
+	if (!value && (!ce || !ce->value)) /* asked to delete absent entry */
+		return 0;
+
+	if (!value)
+		error = git_config_delete_entry(config, key);
+	else
+		error = git_config_set_string(config, key, value);
+
+	return error;
+}
+
 /***********
  * Getters
  ***********/
diff --git a/src/config.h b/src/config.h
index 03d910616..00b6063e7 100644
--- a/src/config.h
+++ b/src/config.h
@@ -53,6 +53,14 @@ extern int git_config__lookup_entry(
 	const char *key,
 	bool no_errors);
 
+/* internal only: update and/or delete entry string with constraints */
+extern int git_config__update_entry(
+	git_config *cfg,
+	const char *key,
+	const char *value,
+	bool overwrite_existing,
+	bool only_if_existing);
+
 /*
  * Lookup functions that cannot fail.  These functions look up a config
  * value and return a fallback value if the value is missing or if any
diff --git a/src/remote.c b/src/remote.c
index 62ee90375..53ff79707 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -495,9 +495,10 @@ cleanup:
 int git_remote_save(const git_remote *remote)
 {
 	int error;
-	git_config *config;
+	git_config *cfg;
 	const char *tagopt = NULL;
 	git_buf buf = GIT_BUF_INIT;
+	const git_config_entry *existing;
 
 	assert(remote);
 
@@ -509,43 +510,31 @@ int git_remote_save(const git_remote *remote)
 	if ((error = ensure_remote_name_is_valid(remote->name)) < 0)
 		return error;
 
-	if (git_repository_config__weakptr(&config, remote->repo) < 0)
-		return -1;
+	if ((error = git_repository_config__weakptr(&cfg, remote->repo)) < 0)
+		return error;
 
-	if (git_buf_printf(&buf, "remote.%s.url", remote->name) < 0)
-		return -1;
+	if ((error = git_buf_printf(&buf, "remote.%s.url", remote->name)) < 0)
+		return error;
 
-	if (git_config_set_string(config, git_buf_cstr(&buf), remote->url) < 0) {
-		git_buf_free(&buf);
-		return -1;
-	}
+	/* after this point, buffer is allocated so end with cleanup */
+
+	if ((error = git_config_set_string(
+			cfg, git_buf_cstr(&buf), remote->url)) < 0)
+		goto cleanup;
 
 	git_buf_clear(&buf);
-	if (git_buf_printf(&buf, "remote.%s.pushurl", remote->name) < 0)
-		return -1;
+	if ((error = git_buf_printf(&buf, "remote.%s.pushurl", remote->name)) < 0)
+		goto cleanup;
 
-	if (remote->pushurl) {
-		if (git_config_set_string(config, git_buf_cstr(&buf), remote->pushurl) < 0) {
-			git_buf_free(&buf);
-			return -1;
-		}
-	} else {
-		int error = git_config_delete_entry(config, git_buf_cstr(&buf));
-		if (error == GIT_ENOTFOUND) {
-			error = 0;
-			giterr_clear();
-		}
-		if (error < 0) {
-			git_buf_free(&buf);
-			return error;
-		}
-	}
+	if ((error = git_config__update_entry(
+			cfg, git_buf_cstr(&buf), remote->pushurl, true, false)) < 0)
+		goto cleanup;
 
-	if (update_config_refspec(remote, config, GIT_DIRECTION_FETCH) < 0)
-		goto on_error;
+	if ((error = update_config_refspec(remote, cfg, GIT_DIRECTION_FETCH)) < 0)
+		goto cleanup;
 
-	if (update_config_refspec(remote, config, GIT_DIRECTION_PUSH) < 0)
-		goto on_error;
+	if ((error = update_config_refspec(remote, cfg, GIT_DIRECTION_PUSH)) < 0)
+		goto cleanup;
 
 	/*
 	 * What action to take depends on the old and new values. This
@@ -561,31 +550,26 @@ int git_remote_save(const git_remote *remote)
 	 */
 
 	git_buf_clear(&buf);
-	if (git_buf_printf(&buf, "remote.%s.tagopt", remote->name) < 0)
-		goto on_error;
-
-	error = git_config_get_string(&tagopt, config, git_buf_cstr(&buf));
-	if (error < 0 && error != GIT_ENOTFOUND)
-		goto on_error;
+	if ((error = git_buf_printf(&buf, "remote.%s.tagopt", remote->name)) < 0)
+		goto cleanup;
 
-	if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_ALL) {
-		if (git_config_set_string(config, git_buf_cstr(&buf), "--tags") < 0)
-			goto on_error;
-	} else if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_NONE) {
-		if (git_config_set_string(config, git_buf_cstr(&buf), "--no-tags") < 0)
-			goto on_error;
-	} else if (tagopt) {
-		if (git_config_delete_entry(config, git_buf_cstr(&buf)) < 0)
-			goto on_error;
-	}
+	if ((error = git_config__lookup_entry(
+			&existing, cfg, git_buf_cstr(&buf), false)) < 0)
+		goto cleanup;
 
-	git_buf_free(&buf);
+	if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_ALL)
+		tagopt = "--tags";
+	else if (remote->download_tags == GIT_REMOTE_DOWNLOAD_TAGS_NONE)
+		tagopt = "--no-tags";
+	else if (existing != NULL)
+		tagopt = NULL;
 
-	return 0;
+	error = git_config__update_entry(
+		cfg, git_buf_cstr(&buf), tagopt, true, false);
 
-on_error:
+cleanup:
 	git_buf_free(&buf);
-	return -1;
+	return error;
 }
 
 const char *git_remote_name(const git_remote *remote)
diff --git a/src/submodule.c b/src/submodule.c
index a0ce5317f..dc0ea435e 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -83,7 +83,6 @@ static int lookup_head_remote(git_buf *url, git_repository *repo);
 static int submodule_get(git_submodule **, git_repository *, const char *, const char *);
 static int submodule_load_from_config(const git_config_entry *, void *);
 static int submodule_load_from_wd_lite(git_submodule *);
-static int submodule_update_config(git_submodule *, const char *, const char *, bool, bool);
 static void submodule_get_index_status(unsigned int *, git_submodule *);
 static void submodule_get_wd_status(unsigned int *, git_submodule *, git_repository *, git_submodule_ignore_t);
 
@@ -716,46 +715,105 @@ git_submodule_recurse_t git_submodule_set_fetch_recurse_submodules(
 	return old;
 }
 
-int git_submodule_init(git_submodule *submodule, int overwrite)
+int git_submodule_init(git_submodule *sm, int overwrite)
 {
 	int error;
 	const char *val;
+	git_buf key = GIT_BUF_INIT;
+	git_config *cfg = NULL;
 
-	/* write "submodule.NAME.url" */
-
-	if (!submodule->url) {
+	if (!sm->url) {
 		giterr_set(GITERR_SUBMODULE,
-			"No URL configured for submodule '%s'", submodule->name);
+			"No URL configured for submodule '%s'", sm->name);
 		return -1;
 	}
 
-	error = submodule_update_config(
-		submodule, "url", submodule->url, overwrite != 0, false);
-	if (error < 0)
+	if ((error = git_repository_config(&cfg, sm->repo)) < 0)
 		return error;
 
+	/* write "submodule.NAME.url" */
+
+	if ((error = git_buf_printf(&key, "submodule.%s.url", sm->name)) < 0 ||
+		(error = git_config__update_entry(
+			cfg, key.ptr, sm->url, overwrite != 0, false)) < 0)
+		goto cleanup;
+
 	/* write "submodule.NAME.update" if not default */
 
-	val = (submodule->update == GIT_SUBMODULE_UPDATE_CHECKOUT) ?
-		NULL : git_submodule_update_to_str(submodule->update);
-	error = submodule_update_config(
-		submodule, "update", val, (overwrite != 0), false);
+	val = (sm->update == GIT_SUBMODULE_UPDATE_CHECKOUT) ?
+		NULL : git_submodule_update_to_str(sm->update);
+
+	if ((error = git_buf_printf(&key, "submodule.%s.update", sm->name)) < 0 ||
+		(error = git_config__update_entry(
+			cfg, key.ptr, val, overwrite != 0, false)) < 0)
+		goto cleanup;
+
+	/* success */
+
+cleanup:
+	git_config_free(cfg);
+	git_buf_free(&key);
 
 	return error;
 }
 
-int git_submodule_sync(git_submodule *submodule)
+int git_submodule_sync(git_submodule *sm)
 {
-	if (!submodule->url) {
+	int error = 0;
+	git_config *cfg = NULL;
+	git_buf key = GIT_BUF_INIT;
+
+	if (!sm->url) {
 		giterr_set(GITERR_SUBMODULE,
-			"No URL configured for submodule '%s'", submodule->name);
+			"No URL configured for submodule '%s'", sm->name);
 		return -1;
 	}
 
 	/* copy URL over to config only if it already exists */
 
-	return submodule_update_config(
-		submodule, "url", submodule->url, true, true);
+	if (!(error = git_repository_config__weakptr(&cfg, sm->repo)) &&
+		!(error = git_buf_printf(&key, "submodule.%s.url", sm->name)))
+		error = git_config__update_entry(cfg, key.ptr, sm->url, true, true);
+
+	/* if submodule exists in the working directory, update remote url */
+
+	if (!error && (sm->flags & GIT_SUBMODULE_STATUS_IN_WD) != 0) {
+		git_repository *smrepo = NULL;
+		git_reference *smhead = NULL;
+		const char *remote = "origin";
+
+		if ((error = git_submodule_open(&smrepo, sm)) < 0 ||
+			(error = git_repository_head(&smhead, smrepo)) < 0 ||
+			(error = git_repository_config__weakptr(&cfg, smrepo)) < 0)
+			goto smcleanup;
+
+		/* get remote for default branch and set remote.<name>.url */
+
+		if (git_reference_type(smhead) == GIT_REF_SYMBOLIC) {
+			const char *bname = git_reference_shorthand(smhead);
+			const git_config_entry *ce;
+
+			git_buf_clear(&key);
+			if ((error = git_buf_printf(&key, "branch.%s.remote", bname)) < 0 ||
+				(error = git_config__lookup_entry(&ce, cfg, key.ptr, 0)) < 0)
+				goto smcleanup;
+
+			if (ce && ce->value)
+				remote = ce->value;
+		}
+
+		git_buf_clear(&key);
+		if (!(error = git_buf_printf(&key, "remote.%s.url", remote)))
+			error = git_config__update_entry(cfg, key.ptr, sm->url, true, true);
+
+smcleanup:
+		git_reference_free(smhead);
+		git_repository_free(smrepo);
+	}
+
+	git_buf_free(&key);
+
+	return error;
 }
 
 static int git_submodule__open(
@@ -1640,50 +1698,6 @@ cleanup:
 	return error;
 }
 
-static int submodule_update_config(
-	git_submodule *submodule,
-	const char *attr,
-	const char *value,
-	bool overwrite,
-	bool only_existing)
-{
-	int error;
-	git_config *config;
-	git_buf key = GIT_BUF_INIT;
-	const git_config_entry *ce = NULL;
-
-	assert(submodule);
-
-	error = git_repository_config__weakptr(&config, submodule->repo);
-	if (error < 0)
-		return error;
-
-	error = git_buf_printf(&key, "submodule.%s.%s", submodule->name, attr);
-	if (error < 0)
-		goto cleanup;
-
-	if ((error = git_config__lookup_entry(&ce, config, key.ptr, false)) < 0)
-		goto cleanup;
-
-	if (!ce && only_existing)
-		goto cleanup;
-	if (ce && !overwrite)
-		goto cleanup;
-	if (value && ce && ce->value && !strcmp(ce->value, value))
-		goto cleanup;
-	if (!value && (!ce || !ce->value))
-		goto cleanup;
-
-	if (!value)
-		error = git_config_delete_entry(config, key.ptr);
-	else
-		error = git_config_set_string(config, key.ptr, value);
-
-cleanup:
-	git_buf_free(&key);
-	return error;
-}
-
 static void submodule_get_index_status(unsigned int *status, git_submodule *sm)
 {
 	const git_oid *head_oid  = git_submodule_head_id(sm);
-- 
cgit v1.2.3


From e402d2f134ff6ac76726bedd37ac4f1c0aa5e9ab Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 24 Mar 2014 11:25:59 -0700
Subject: Submodule sync refactoring

Turns out there was already a helper to do what I wanted to do,
so I just made it so that I could use it for sync and switched to
that instead.
---
 src/path.h      |  8 ++++++
 src/submodule.c | 88 +++++++++++++++++++++++++++------------------------------
 2 files changed, 49 insertions(+), 47 deletions(-)

diff --git a/src/path.h b/src/path.h
index f26175d15..2367d707b 100644
--- a/src/path.h
+++ b/src/path.h
@@ -119,6 +119,14 @@ GIT_INLINE(void) git_path_mkposix(char *path)
 #	define git_path_mkposix(p) /* blank */
 #endif
 
+/**
+ * Check if string is a relative path (i.e. starts with "./" or "../")
+ */
+GIT_INLINE(int) git_path_is_relative(const char *p)
+{
+	return (p[0] == '.' && (p[1] == '/' || (p[1] == '.' && p[2] == '/')));
+}
+
 extern int git__percent_decode(git_buf *decoded_out, const char *input);
 
 /**
diff --git a/src/submodule.c b/src/submodule.c
index dc0ea435e..69791ef58 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -79,6 +79,7 @@ __KHASH_IMPL(
 
 static int load_submodule_config(git_repository *repo, bool reload);
 static git_config_backend *open_gitmodules(git_repository *, bool, const git_oid *);
+static int lookup_head_remote_key(git_buf *key, git_repository *repo);
 static int lookup_head_remote(git_buf *url, git_repository *repo);
 static int submodule_get(git_submodule **, git_repository *, const char *, const char *);
 static int submodule_load_from_config(const git_config_entry *, void *);
@@ -271,8 +272,7 @@ int git_submodule_add_setup(
 	}
 
 	/* resolve parameters */
-	error = git_submodule_resolve_url(&real_url, repo, url);
-	if (error)
+	if ((error = git_submodule_resolve_url(&real_url, repo, url)) < 0)
 		goto cleanup;
 
 	/* validate and normalize path */
@@ -576,7 +576,7 @@ int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *ur
 
 	assert(url);
 
-	if (url[0] == '.' && (url[1] == '/' || (url[1] == '.' && url[2] == '/'))) {
+	if (git_path_is_relative(url)) {
 		if (!(error = lookup_head_remote(out, repo)))
 			error = git_path_apply_relative(out, url);
 	} else if (strchr(url, ':') != NULL || url[0] == '/') {
@@ -762,6 +762,7 @@ int git_submodule_sync(git_submodule *sm)
 	int error = 0;
 	git_config *cfg = NULL;
 	git_buf key = GIT_BUF_INIT;
+	git_repository *smrepo = NULL;
 
 	if (!sm->url) {
 		giterr_set(GITERR_SUBMODULE,
@@ -777,37 +778,17 @@ int git_submodule_sync(git_submodule *sm)
 
 	/* if submodule exists in the working directory, update remote url */
 
-	if (!error && (sm->flags & GIT_SUBMODULE_STATUS_IN_WD) != 0) {
-		git_repository *smrepo = NULL;
-		git_reference *smhead = NULL;
-		const char *remote = "origin";
-
-		if ((error = git_submodule_open(&smrepo, sm)) < 0 ||
-			(error = git_repository_head(&smhead, smrepo)) < 0 ||
-			(error = git_repository_config__weakptr(&cfg, smrepo)) < 0)
-			goto smcleanup;
-
-		/* get remote for default branch and set remote.<name>.url */
-
-		if (git_reference_type(smhead) == GIT_REF_SYMBOLIC) {
-			const char *bname = git_reference_shorthand(smhead);
-			const git_config_entry *ce;
-
-			git_buf_clear(&key);
-			if ((error = git_buf_printf(&key, "branch.%s.remote", bname)) < 0 ||
-				(error = git_config__lookup_entry(&ce, cfg, key.ptr, 0)) < 0)
-				goto smcleanup;
-
-			if (ce && ce->value)
-				remote = ce->value;
+	if (!error &&
+		(sm->flags & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&
+		!(error = git_submodule_open(&smrepo, sm)))
+	{
+		if ((error = lookup_head_remote_key(&key, smrepo)) < 0) {
+			giterr_clear();
+			git_buf_sets(&key, "branch.origin.remote");
 		}
 
-		git_buf_clear(&key);
-		if (!(error = git_buf_printf(&key, "remote.%s.url", remote)))
-			error = git_config__update_entry(cfg, key.ptr, sm->url, true, true);
+		error = git_config__update_entry(cfg, key.ptr, sm->url, true, true);
 
-smcleanup:
-		git_reference_free(smhead);
 		git_repository_free(smrepo);
 	}
 
@@ -1633,27 +1614,27 @@ cleanup:
 	return error;
 }
 
-static int lookup_head_remote(git_buf *url, git_repository *repo)
+static int lookup_head_remote_key(git_buf *key, git_repository *repo)
 {
 	int error;
 	git_config *cfg;
 	git_reference *head = NULL, *remote = NULL;
 	const char *tgt, *scan;
-	git_buf key = GIT_BUF_INIT;
 
 	/* 1. resolve HEAD -> refs/heads/BRANCH
 	 * 2. lookup config branch.BRANCH.remote -> ORIGIN
-	 * 3. lookup remote.ORIGIN.url
+	 * 3. return remote.ORIGIN.url
 	 */
 
+	git_buf_clear(key);
+
 	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
 		return error;
 
 	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0) {
 		giterr_set(GITERR_SUBMODULE,
 			"Cannot resolve relative URL when HEAD cannot be resolved");
-		error = GIT_ENOTFOUND;
-		goto cleanup;
+		return GIT_ENOTFOUND;
 	}
 
 	if (git_reference_type(head) != GIT_REF_SYMBOLIC) {
@@ -1669,7 +1650,8 @@ static int lookup_head_remote(git_buf *url, git_repository *repo)
 	/* remote should refer to something like refs/remotes/ORIGIN/BRANCH */
 
 	if (git_reference_type(remote) != GIT_REF_SYMBOLIC ||
-		git__prefixcmp(git_reference_symbolic_target(remote), GIT_REFS_REMOTES_DIR) != 0)
+		git__prefixcmp(
+			git_reference_symbolic_target(remote), GIT_REFS_REMOTES_DIR) != 0)
 	{
 		giterr_set(GITERR_SUBMODULE,
 			"Cannot resolve relative URL when HEAD is not symbolic");
@@ -1677,27 +1659,39 @@ static int lookup_head_remote(git_buf *url, git_repository *repo)
 		goto cleanup;
 	}
 
-	scan = tgt = git_reference_symbolic_target(remote) + strlen(GIT_REFS_REMOTES_DIR);
+	scan = tgt = git_reference_symbolic_target(remote) +
+		strlen(GIT_REFS_REMOTES_DIR);
 	while (*scan && (*scan != '/' || (scan > tgt && scan[-1] != '\\')))
 		scan++; /* find non-escaped slash to end ORIGIN name */
 
-	error = git_buf_printf(&key, "remote.%.*s.url", (int)(scan - tgt), tgt);
-	if (error < 0)
-		goto cleanup;
-
-	if ((error = git_config_get_string(&tgt, cfg, key.ptr)) < 0)
-		goto cleanup;
-
-	error = git_buf_sets(url, tgt);
+	error = git_buf_printf(key, "remote.%.*s.url", (int)(scan - tgt), tgt);
 
 cleanup:
-	git_buf_free(&key);
+	if (error < 0)
+		git_buf_clear(key);
+
 	git_reference_free(head);
 	git_reference_free(remote);
 
 	return error;
 }
 
+static int lookup_head_remote(git_buf *url, git_repository *repo)
+{
+	int error;
+	git_config *cfg;
+	const char *tgt;
+	git_buf key = GIT_BUF_INIT;
+
+	if (!(error = lookup_head_remote_key(&key, repo)) &&
+		!(error = git_repository_config__weakptr(&cfg, repo)) &&
+		!(error = git_config_get_string(&tgt, cfg, key.ptr)))
+		error = git_buf_sets(url, tgt);
+
+	git_buf_free(&key);
+	return error;
+}
+
 static void submodule_get_index_status(unsigned int *status, git_submodule *sm)
 {
 	const git_oid *head_oid  = git_submodule_head_id(sm);
-- 
cgit v1.2.3


From d543d59cf0d90264aa84ac49b7f21c6a603d5d3a Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 28 Mar 2014 10:42:38 -0700
Subject: Add some funny options for debugging status

This allows you to use a --repeat option to run status over and
over and see how the output changes as you make local directory
changes without reopening the git_repository object each time.

Also, adds a flag to explicitly list the submodules before status.
---
 examples/status.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 50 insertions(+), 9 deletions(-)

diff --git a/examples/status.c b/examples/status.c
index feba77f84..5f619a055 100644
--- a/examples/status.c
+++ b/examples/status.c
@@ -13,6 +13,7 @@
  */
 
 #include "common.h"
+#include <unistd.h>
 
 /**
  * This example demonstrates the use of the libgit2 status APIs,
@@ -44,19 +45,22 @@ enum {
 #define MAX_PATHSPEC 8
 
 struct opts {
-    git_status_options statusopt;
-    char *repodir;
-    char *pathspec[MAX_PATHSPEC];
-    int npaths;
-    int format;
-    int zterm;
-    int showbranch;
+	git_status_options statusopt;
+	char *repodir;
+	char *pathspec[MAX_PATHSPEC];
+	int npaths;
+	int format;
+	int zterm;
+	int showbranch;
+	int showsubmod;
+	int repeat;
 };
 
 static void parse_opts(struct opts *o, int argc, char *argv[]);
 static void show_branch(git_repository *repo, int format);
 static void print_long(git_status_list *status);
 static void print_short(git_repository *repo, git_status_list *status);
+static int print_submod(git_submodule *sm, const char *name, void *payload);
 
 int main(int argc, char *argv[])
 {
@@ -84,6 +88,10 @@ int main(int argc, char *argv[])
 		fatal("Cannot report status on bare repository",
 			git_repository_path(repo));
 
+show_status:
+	if (o.repeat)
+		printf("\033[H\033[2J");
+
 	/**
 	 * Run status on the repository
 	 *
@@ -98,17 +106,29 @@ int main(int argc, char *argv[])
 	 * about what results are presented.
 	 */
 	check_lg2(git_status_list_new(&status, repo, &o.statusopt),
-		  "Could not get status", NULL);
+		"Could not get status", NULL);
 
 	if (o.showbranch)
 		show_branch(repo, o.format);
 
+	if (o.showsubmod) {
+		int submod_count = 0;
+		check_lg2(git_submodule_foreach(repo, print_submod, &submod_count),
+			"Cannot iterate submodules", o.repodir);
+	}
+
 	if (o.format == FORMAT_LONG)
 		print_long(status);
 	else
 		print_short(repo, status);
 
 	git_status_list_free(status);
+
+	if (o.repeat) {
+		sleep(o.repeat);
+		goto show_status;
+	}
+
 	git_repository_free(repo);
 	git_threads_shutdown();
 
@@ -381,7 +401,7 @@ static void print_short(git_repository *repo, git_status_list *status)
 		}
 
 		/**
-		 * Now that we have all the information, it's time to format the output.
+		 * Now that we have all the information, format the output.
 		 */
 
 		if (s->head_to_index) {
@@ -417,6 +437,21 @@ static void print_short(git_repository *repo, git_status_list *status)
 	}
 }
 
+static int print_submod(git_submodule *sm, const char *name, void *payload)
+{
+	int *count = payload;
+	(void)name;
+
+	if (*count == 0)
+		printf("# Submodules\n");
+	(*count)++;
+
+	printf("# - submodule '%s' at %s\n",
+		git_submodule_name(sm), git_submodule_path(sm));
+
+	return 0;
+}
+
 /**
  * Parse options that git's status command supports.
  */
@@ -462,6 +497,12 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 			o->statusopt.flags |= GIT_STATUS_OPT_EXCLUDE_SUBMODULES;
 		else if (!strncmp(a, "--git-dir=", strlen("--git-dir=")))
 			o->repodir = a + strlen("--git-dir=");
+		else if (!strcmp(a, "--repeat"))
+			o->repeat = 10;
+		else if (match_int_arg(&o->repeat, &args, "--repeat", 0))
+			/* okay */;
+		else if (!strcmp(a, "--list-submodules"))
+			o->showsubmod = 1;
 		else
 			check_lg2(-1, "Unsupported option", a);
 	}
-- 
cgit v1.2.3


From 69b6ffc4c53d578800274993b5222fa5a7699f21 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 28 Mar 2014 14:02:21 -0700
Subject: Make a real submodule cache object

This takes the old submodule cache which was just a git_strmap
and makes a real git_submodule_cache object that can contain other
things like a lock and timestamp-ish data to control refreshing of
submodule info.
---
 src/repository.c |   2 +-
 src/repository.h |   9 +-
 src/submodule.c  | 345 ++++++++++++++++++++++++++++++++++---------------------
 src/submodule.h  |  29 +++++
 4 files changed, 243 insertions(+), 142 deletions(-)

diff --git a/src/repository.c b/src/repository.c
index fccc16faa..49d1bc63e 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -93,6 +93,7 @@ void git_repository__cleanup(git_repository *repo)
 
 	git_cache_clear(&repo->objects);
 	git_attr_cache_flush(repo);
+	git_submodule_cache_free(repo);
 
 	set_config(repo, NULL);
 	set_index(repo, NULL);
@@ -108,7 +109,6 @@ void git_repository_free(git_repository *repo)
 	git_repository__cleanup(repo);
 
 	git_cache_free(&repo->objects);
-	git_submodule_config_free(repo);
 
 	git_diff_driver_registry_free(repo->diff_drivers);
 	repo->diff_drivers = NULL;
diff --git a/src/repository.h b/src/repository.h
index 4e79714f1..99923b63b 100644
--- a/src/repository.h
+++ b/src/repository.h
@@ -19,7 +19,7 @@
 #include "buffer.h"
 #include "object.h"
 #include "attrcache.h"
-#include "strmap.h"
+#include "submodule.h"
 #include "diff_driver.h"
 
 #define DOT_GIT ".git"
@@ -105,10 +105,10 @@ struct git_repository {
 	git_refdb *_refdb;
 	git_config *_config;
 	git_index *_index;
+	git_submodule_cache *_submodules;
 
 	git_cache objects;
 	git_attr_cache attrcache;
-	git_strmap *submodules;
 	git_diff_driver_registry *diff_drivers;
 
 	char *path_repository;
@@ -149,11 +149,6 @@ int git_repository_index__weakptr(git_index **out, git_repository *repo);
 int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar);
 void git_repository__cvar_cache_clear(git_repository *repo);
 
-/*
- * Submodule cache
- */
-extern void git_submodule_config_free(git_repository *repo);
-
 GIT_INLINE(int) git_repository__ensure_not_bare(
 	git_repository *repo,
 	const char *operation_name)
diff --git a/src/submodule.c b/src/submodule.c
index 69791ef58..94bed8a6f 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -77,11 +77,13 @@ __KHASH_IMPL(
 	str, static kh_inline, const char *, void *, 1,
 	str_hash_no_trailing_slash, str_equal_no_trailing_slash);
 
-static int load_submodule_config(git_repository *repo, bool reload);
-static git_config_backend *open_gitmodules(git_repository *, bool, const git_oid *);
+static int submodule_cache_init(git_repository *repo, bool refresh);
+static void submodule_cache_free(git_submodule_cache *cache);
+
+static git_config_backend *open_gitmodules(git_submodule_cache *, bool);
 static int lookup_head_remote_key(git_buf *key, git_repository *repo);
 static int lookup_head_remote(git_buf *url, git_repository *repo);
-static int submodule_get(git_submodule **, git_repository *, const char *, const char *);
+static int submodule_get(git_submodule **, git_submodule_cache *, const char *, const char *);
 static int submodule_load_from_config(const git_config_entry *, void *);
 static int submodule_load_from_wd_lite(git_submodule *);
 static void submodule_get_index_status(unsigned int *, git_submodule *);
@@ -102,7 +104,7 @@ static int submodule_config_key_trunc_puts(git_buf *key, const char *suffix)
 /* lookup submodule or return ENOTFOUND if it doesn't exist */
 static int submodule_lookup(
 	git_submodule **out,
-	git_strmap *cache,
+	git_submodule_cache *cache,
 	const char *name,
 	const char *alternate)
 {
@@ -110,18 +112,18 @@ static int submodule_lookup(
 
 	/* lock cache */
 
-	pos = git_strmap_lookup_index(cache, name);
+	pos = git_strmap_lookup_index(cache->submodules, name);
 
-	if (!git_strmap_valid_index(cache, pos) && alternate)
-		pos = git_strmap_lookup_index(cache, alternate);
+	if (!git_strmap_valid_index(cache->submodules, pos) && alternate)
+		pos = git_strmap_lookup_index(cache->submodules, alternate);
 
-	if (!git_strmap_valid_index(cache, pos)) {
+	if (!git_strmap_valid_index(cache->submodules, pos)) {
 		/* unlock cache */
 		return GIT_ENOTFOUND; /* don't set error - caller will cope */
 	}
 
 	if (out != NULL) {
-		git_submodule *sm = git_strmap_value_at(cache, pos);
+		git_submodule *sm = git_strmap_value_at(cache->submodules, pos);
 		GIT_REFCOUNT_INC(sm);
 		*out = sm;
 	}
@@ -139,17 +141,45 @@ bool git_submodule__is_submodule(git_repository *repo, const char *name)
 {
 	git_strmap *map;
 
-	if (load_submodule_config(repo, false) < 0) {
+	if (submodule_cache_init(repo, false) < 0) {
 		giterr_clear();
 		return false;
 	}
 
-	if (!(map = repo->submodules))
+	if (!repo->_submodules || !(map = repo->_submodules->submodules))
 		return false;
 
 	return git_strmap_valid_index(map, git_strmap_lookup_index(map, name));
 }
 
+static void submodule_set_lookup_error(int error, const char *name)
+{
+	if (!error)
+		return;
+
+	giterr_set(GITERR_SUBMODULE, (error == GIT_ENOTFOUND) ?
+		"No submodule named '%s'" :
+		"Submodule '%s' has not been added yet", name);
+}
+
+int git_submodule__lookup(
+	git_submodule **out, /* NULL if user only wants to test existence */
+	git_repository *repo,
+	const char *name)    /* trailing slash is allowed */
+{
+	int error;
+
+	assert(repo && name);
+
+	if ((error = submodule_cache_init(repo, false)) < 0)
+		return error;
+
+	if ((error = submodule_lookup(out, repo->_submodules, name, NULL)) < 0)
+		submodule_set_lookup_error(error, name);
+
+	return error;
+}
+
 int git_submodule_lookup(
 	git_submodule **out, /* NULL if user only wants to test existence */
 	git_repository *repo,
@@ -159,10 +189,10 @@ int git_submodule_lookup(
 
 	assert(repo && name);
 
-	if ((error = load_submodule_config(repo, false)) < 0)
+	if ((error = submodule_cache_init(repo, true)) < 0)
 		return error;
 
-	if ((error = submodule_lookup(out, repo->submodules, name, NULL)) < 0) {
+	if ((error = submodule_lookup(out, repo->_submodules, name, NULL)) < 0) {
 
 		/* check if a plausible submodule exists at path */
 		if (git_repository_workdir(repo)) {
@@ -178,9 +208,7 @@ int git_submodule_lookup(
 			git_buf_free(&path);
 		}
 
-		giterr_set(GITERR_SUBMODULE, (error == GIT_ENOTFOUND) ?
-			"No submodule named '%s'" :
-			"Submodule '%s' has not been added yet", name);
+		submodule_set_lookup_error(error, name);
 	}
 
 	return error;
@@ -198,10 +226,10 @@ int git_submodule_foreach(
 
 	assert(repo && callback);
 
-	if ((error = load_submodule_config(repo, true)) < 0)
+	if ((error = submodule_cache_init(repo, true)) < 0)
 		return error;
 
-	git_strmap_foreach_value(repo->submodules, sm, {
+	git_strmap_foreach_value(repo->_submodules->submodules, sm, {
 		/* Usually the following will not come into play - it just prevents
 		 * us from issuing a callback twice for a submodule where the name
 		 * and path are not the same.
@@ -224,24 +252,14 @@ int git_submodule_foreach(
 	return error;
 }
 
-void git_submodule_config_free(git_repository *repo)
+void git_submodule_cache_free(git_repository *repo)
 {
-	git_strmap *smcfg;
-	git_submodule *sm;
+	git_submodule_cache *cache;
 
 	assert(repo);
 
-	smcfg = repo->submodules;
-	repo->submodules = NULL;
-
-	if (smcfg == NULL)
-		return;
-
-	git_strmap_foreach_value(smcfg, sm, {
-		sm->repo = NULL; /* disconnect from repo */;
-		git_submodule_free(sm);
-	});
-	git_strmap_free(smcfg);
+	if ((cache = git__swap(repo->_submodules, NULL)) != NULL)
+		submodule_cache_free(cache);
 }
 
 int git_submodule_add_setup(
@@ -262,12 +280,11 @@ int git_submodule_add_setup(
 
 	/* see if there is already an entry for this submodule */
 
-	if (git_submodule_lookup(&sm, repo, path) < 0)
+	if (git_submodule_lookup(NULL, repo, path) < 0)
 		giterr_clear();
 	else {
-		git_submodule_free(sm);
 		giterr_set(GITERR_SUBMODULE,
-			"Attempt to add a submodule that already exists");
+			"Attempt to add submodule '%s' that already exists", path);
 		return GIT_EEXISTS;
 	}
 
@@ -288,7 +305,7 @@ int git_submodule_add_setup(
 
 	/* update .gitmodules */
 
-	if ((mods = open_gitmodules(repo, true, NULL)) == NULL) {
+	if ((mods = open_gitmodules(repo->_submodules, true)) == NULL) {
 		giterr_set(GITERR_SUBMODULE,
 			"Adding submodules to a bare repository is not supported (for now)");
 		return -1;
@@ -348,7 +365,7 @@ int git_submodule_add_setup(
 
 	/* add submodule to hash and "reload" it */
 
-	if (!(error = submodule_get(&sm, repo, path, NULL)) &&
+	if (!(error = submodule_get(&sm, repo->_submodules, path, NULL)) &&
 		!(error = git_submodule_reload(sm, false)))
 		error = git_submodule_init(sm, false);
 
@@ -489,7 +506,7 @@ int git_submodule_save(git_submodule *submodule)
 
 	assert(submodule);
 
-	mods = open_gitmodules(submodule->repo, true, NULL);
+	mods = open_gitmodules(submodule->repo->_submodules, true);
 	if (!mods) {
 		giterr_set(GITERR_SUBMODULE,
 			"Adding submodules to a bare repository is not supported (for now)");
@@ -862,7 +879,7 @@ int git_submodule_open(git_repository **subrepo, git_submodule *sm)
 }
 
 static void submodule_cache_remove_item(
-	git_strmap *cache,
+	git_strmap *map,
 	const char *name,
 	git_submodule *expected,
 	bool free_after_remove)
@@ -870,21 +887,21 @@ static void submodule_cache_remove_item(
 	khiter_t pos;
 	git_submodule *found;
 
-	if (!cache)
+	if (!map)
 		return;
 
-	pos = git_strmap_lookup_index(cache, name);
+	pos = git_strmap_lookup_index(map, name);
 
-	if (!git_strmap_valid_index(cache, pos))
+	if (!git_strmap_valid_index(map, pos))
 		return;
 
-	found = git_strmap_value_at(cache, pos);
+	found = git_strmap_value_at(map, pos);
 
 	if (expected && found != expected)
 		return;
 
-	git_strmap_set_value_at(cache, pos, NULL);
-	git_strmap_delete_at(cache, pos);
+	git_strmap_set_value_at(map, pos, NULL);
+	git_strmap_delete_at(map, pos);
 
 	if (free_after_remove)
 		git_submodule_free(found);
@@ -894,27 +911,31 @@ int git_submodule_reload_all(git_repository *repo, int force)
 {
 	int error = 0;
 	git_submodule *sm;
+	git_strmap *map;
 
 	GIT_UNUSED(force);
 	assert(repo);
 
-	if (repo->submodules)
-		git_strmap_foreach_value(repo->submodules, sm, { sm->flags = 0; });
+	if (repo->_submodules) {
+		map = repo->_submodules->submodules;
+		git_strmap_foreach_value(map, sm, { sm->flags = 0; });
+	}
 
-	if ((error = load_submodule_config(repo, true)) < 0)
+	if ((error = submodule_cache_init(repo, true)) < 0)
 		return error;
 
-	git_strmap_foreach_value(repo->submodules, sm, {
-		git_strmap *cache = repo->submodules;
+	if (!repo->_submodules || !(map = repo->_submodules->submodules))
+		return error;
 
+	git_strmap_foreach_value(map, sm, {
 		if (sm && (sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS) == 0) {
 			/* we must check path != name before first remove, in case
 			 * that call frees the submodule */
 			bool free_as_path = (sm->path != sm->name);
 
-			submodule_cache_remove_item(cache, sm->name, sm, true);
+			submodule_cache_remove_item(map, sm->name, sm, true);
 			if (free_as_path)
-				submodule_cache_remove_item(cache, sm->path, sm, true);
+				submodule_cache_remove_item(map, sm->path, sm, true);
 		}
 	});
 
@@ -995,41 +1016,44 @@ static int submodule_update_head(git_submodule *submodule)
 }
 
 
-int git_submodule_reload(git_submodule *submodule, int force)
+int git_submodule_reload(git_submodule *sm, int force)
 {
 	int error = 0;
 	git_config_backend *mods;
+	git_submodule_cache *cache;
 
 	GIT_UNUSED(force);
 
-	assert(submodule);
+	assert(sm);
+
+	cache = sm->repo->_submodules;
 
 	/* refresh index data */
-	if ((error = submodule_update_index(submodule)) < 0)
+	if ((error = submodule_update_index(sm)) < 0)
 		return error;
 
 	/* refresh HEAD tree data */
-	if ((error = submodule_update_head(submodule)) < 0)
+	if ((error = submodule_update_head(sm)) < 0)
 		return error;
 
 	/* done if bare */
-	if (git_repository_is_bare(submodule->repo))
+	if (git_repository_is_bare(sm->repo))
 		return error;
 
 	/* refresh config data */
-	mods = open_gitmodules(submodule->repo, false, NULL);
+	mods = open_gitmodules(cache, false);
 	if (mods != NULL) {
 		git_buf path = GIT_BUF_INIT;
 
 		git_buf_sets(&path, "submodule\\.");
-		git_buf_text_puts_escape_regex(&path, submodule->name);
+		git_buf_text_puts_escape_regex(&path, sm->name);
 		git_buf_puts(&path, ".*");
 
 		if (git_buf_oom(&path))
 			error = -1;
 		else
 			error = git_config_file_foreach_match(
-				mods, path.ptr, submodule_load_from_config, submodule->repo);
+				mods, path.ptr, submodule_load_from_config, cache);
 
 		git_buf_free(&path);
 		git_config_file_free(mods);
@@ -1039,9 +1063,9 @@ int git_submodule_reload(git_submodule *submodule, int force)
 	}
 
 	/* refresh wd data */
-	submodule->flags &= ~GIT_SUBMODULE_STATUS__ALL_WD_FLAGS;
+	sm->flags &= ~GIT_SUBMODULE_STATUS__ALL_WD_FLAGS;
 
-	return submodule_load_from_wd_lite(submodule);
+	return submodule_load_from_wd_lite(sm);
 }
 
 static void submodule_copy_oid_maybe(
@@ -1135,34 +1159,35 @@ int git_submodule_location(unsigned int *location, git_submodule *sm)
  * INTERNAL FUNCTIONS
  */
 
-static git_submodule *submodule_alloc(git_repository *repo, const char *name)
+static int submodule_alloc(
+	git_submodule **out, git_submodule_cache *cache, const char *name)
 {
 	size_t namelen;
 	git_submodule *sm;
 
 	if (!name || !(namelen = strlen(name))) {
 		giterr_set(GITERR_SUBMODULE, "Invalid submodule name");
-		return NULL;
+		return -1;
 	}
 
 	sm = git__calloc(1, sizeof(git_submodule));
-	if (sm == NULL)
-		return NULL;
+	GITERR_CHECK_ALLOC(sm);
 
 	sm->name = sm->path = git__strdup(name);
 	if (!sm->name) {
 		git__free(sm);
-		return NULL;
+		return -1;
 	}
 
 	GIT_REFCOUNT_INC(sm);
 	sm->ignore = sm->ignore_default = GIT_SUBMODULE_IGNORE_NONE;
 	sm->update = sm->update_default = GIT_SUBMODULE_UPDATE_CHECKOUT;
 	sm->fetch_recurse = sm->fetch_recurse_default = GIT_SUBMODULE_RECURSE_NO;
-	sm->repo   = repo;
+	sm->repo   = cache->repo;
 	sm->branch = NULL;
 
-	return sm;
+	*out = sm;
+	return 0;
 }
 
 static void submodule_release(git_submodule *sm)
@@ -1170,11 +1195,15 @@ static void submodule_release(git_submodule *sm)
 	if (!sm)
 		return;
 
-	if (sm->repo) {
-		git_strmap *cache = sm->repo->submodules;
-		submodule_cache_remove_item(cache, sm->name, sm, false);
-		if (sm->path != sm->name)
-			submodule_cache_remove_item(cache, sm->path, sm, false);
+	if (sm->repo && sm->repo->_submodules) {
+		git_strmap *map = sm->repo->_submodules->submodules;
+		bool free_as_path = (sm->path != sm->name);
+
+		sm->repo = NULL;
+
+		submodule_cache_remove_item(map, sm->name, sm, false);
+		if (free_as_path)
+			submodule_cache_remove_item(map, sm->path, sm, false);
 	}
 
 	if (sm->path != sm->name)
@@ -1195,40 +1224,39 @@ void git_submodule_free(git_submodule *sm)
 
 static int submodule_get(
 	git_submodule **out,
-	git_repository *repo,
+	git_submodule_cache *cache,
 	const char *name,
 	const char *alternate)
 {
 	int error = 0;
-	git_strmap *smcfg = repo->submodules;
 	khiter_t pos;
 	git_submodule *sm;
 
-	pos = git_strmap_lookup_index(smcfg, name);
+	pos = git_strmap_lookup_index(cache->submodules, name);
 
-	if (!git_strmap_valid_index(smcfg, pos) && alternate)
-		pos = git_strmap_lookup_index(smcfg, alternate);
+	if (!git_strmap_valid_index(cache->submodules, pos) && alternate)
+		pos = git_strmap_lookup_index(cache->submodules, alternate);
 
-	if (!git_strmap_valid_index(smcfg, pos)) {
-		sm = submodule_alloc(repo, name);
-		GITERR_CHECK_ALLOC(sm);
+	if (!git_strmap_valid_index(cache->submodules, pos)) {
+		if ((error = submodule_alloc(&sm, cache, name)) < 0)
+			return error;
 
 		/* insert value at name - if another thread beats us to it, then use
 		 * their record and release our own.
 		 */
-		pos = kh_put(str, smcfg, sm->name, &error);
+		pos = kh_put(str, cache->submodules, sm->name, &error);
 
 		if (error < 0)
 			goto done;
 		else if (error == 0) {
 			git_submodule_free(sm);
-			sm = git_strmap_value_at(smcfg, pos);
+			sm = git_strmap_value_at(cache->submodules, pos);
 		} else {
 			error = 0;
-			git_strmap_set_value_at(smcfg, pos, sm);
+			git_strmap_set_value_at(cache->submodules, pos, sm);
 		}
 	} else {
-		sm = git_strmap_value_at(smcfg, pos);
+		sm = git_strmap_value_at(cache->submodules, pos);
 	}
 
 done:
@@ -1294,8 +1322,7 @@ int git_submodule_parse_recurse(git_submodule_recurse_t *out, const char *value)
 static int submodule_load_from_config(
 	const git_config_entry *entry, void *payload)
 {
-	git_repository *repo = payload;
-	git_strmap *smcfg = repo->submodules;
+	git_submodule_cache *cache = payload;
 	const char *namestart, *property, *alternate = NULL;
 	const char *key = entry->name, *value = entry->value, *path;
 	git_buf name = GIT_BUF_INIT;
@@ -1315,7 +1342,7 @@ static int submodule_load_from_config(
 	path = !strcasecmp(property, "path") ? value : NULL;
 
 	if ((error = git_buf_set(&name, namestart, property - namestart - 1)) < 0 ||
-		(error = submodule_get(&sm, repo, name.ptr, path)) < 0)
+		(error = submodule_get(&sm, cache, name.ptr, path)) < 0)
 		goto done;
 
 	sm->flags |= GIT_SUBMODULE_STATUS_IN_CONFIG;
@@ -1341,7 +1368,7 @@ static int submodule_load_from_config(
 	/* Found a alternate key for the submodule */
 	if (alternate) {
 		void *old_sm = NULL;
-		git_strmap_insert2(smcfg, alternate, sm, old_sm, error);
+		git_strmap_insert2(cache->submodules, alternate, sm, old_sm, error);
 
 		if (error < 0)
 			goto done;
@@ -1423,36 +1450,35 @@ static int submodule_load_from_wd_lite(git_submodule *sm)
 	return 0;
 }
 
-static int load_submodule_config_from_index(
-	git_repository *repo, git_oid *gitmodules_oid)
+static int submodule_cache_refresh_from_index(git_submodule_cache *cache)
 {
 	int error;
 	git_index *index;
 	git_iterator *i;
 	const git_index_entry *entry;
 
-	if ((error = git_repository_index__weakptr(&index, repo)) < 0 ||
+	if ((error = git_repository_index__weakptr(&index, cache->repo)) < 0 ||
 		(error = git_iterator_for_index(&i, index, 0, NULL, NULL)) < 0)
 		return error;
 
 	while (!(error = git_iterator_advance(&entry, i))) {
-		khiter_t pos = git_strmap_lookup_index(repo->submodules, entry->path);
+		khiter_t pos = git_strmap_lookup_index(cache->submodules, entry->path);
 		git_submodule *sm;
 
-		if (git_strmap_valid_index(repo->submodules, pos)) {
-			sm = git_strmap_value_at(repo->submodules, pos);
+		if (git_strmap_valid_index(cache->submodules, pos)) {
+			sm = git_strmap_value_at(cache->submodules, pos);
 
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_index_entry(sm, entry);
 			else
 				sm->flags |= GIT_SUBMODULE_STATUS__INDEX_NOT_SUBMODULE;
 		} else if (S_ISGITLINK(entry->mode)) {
-			if (!submodule_get(&sm, repo, entry->path, NULL)) {
+			if (!submodule_get(&sm, cache, entry->path, NULL)) {
 				submodule_update_from_index_entry(sm, entry);
 				git_submodule_free(sm);
 			}
 		} else if (strcmp(entry->path, GIT_MODULES_FILE) == 0)
-			git_oid_cpy(gitmodules_oid, &entry->id);
+			git_oid_cpy(&cache->gitmodules_id, &entry->id);
 	}
 
 	if (error == GIT_ITEROVER)
@@ -1463,8 +1489,7 @@ static int load_submodule_config_from_index(
 	return error;
 }
 
-static int load_submodule_config_from_head(
-	git_repository *repo, git_oid *gitmodules_oid)
+static int submodule_cache_refresh_from_head(git_submodule_cache *cache)
 {
 	int error;
 	git_tree *head;
@@ -1472,7 +1497,7 @@ static int load_submodule_config_from_head(
 	const git_index_entry *entry;
 
 	/* if we can't look up current head, then there's no submodule in it */
-	if (git_repository_head_tree(&head, repo) < 0) {
+	if (git_repository_head_tree(&head, cache->repo) < 0) {
 		giterr_clear();
 		return 0;
 	}
@@ -1483,11 +1508,11 @@ static int load_submodule_config_from_head(
 	}
 
 	while (!(error = git_iterator_advance(&entry, i))) {
-		khiter_t pos = git_strmap_lookup_index(repo->submodules, entry->path);
+		khiter_t pos = git_strmap_lookup_index(cache->submodules, entry->path);
 		git_submodule *sm;
 
-		if (git_strmap_valid_index(repo->submodules, pos)) {
-			sm = git_strmap_value_at(repo->submodules, pos);
+		if (git_strmap_valid_index(cache->submodules, pos)) {
+			sm = git_strmap_value_at(cache->submodules, pos);
 
 			if (S_ISGITLINK(entry->mode))
 				submodule_update_from_head_data(
@@ -1495,14 +1520,14 @@ static int load_submodule_config_from_head(
 			else
 				sm->flags |= GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE;
 		} else if (S_ISGITLINK(entry->mode)) {
-			if (!submodule_get(&sm, repo, entry->path, NULL)) {
+			if (!submodule_get(&sm, cache, entry->path, NULL)) {
 				submodule_update_from_head_data(
 					sm, entry->mode, &entry->id);
 				git_submodule_free(sm);
 			}
 		} else if (strcmp(entry->path, GIT_MODULES_FILE) == 0 &&
-				   git_oid_iszero(gitmodules_oid)) {
-			git_oid_cpy(gitmodules_oid, &entry->id);
+				   git_oid_iszero(&cache->gitmodules_id)) {
+			git_oid_cpy(&cache->gitmodules_id, &entry->id);
 		}
 	}
 
@@ -1516,11 +1541,10 @@ static int load_submodule_config_from_head(
 }
 
 static git_config_backend *open_gitmodules(
-	git_repository *repo,
-	bool okay_to_create,
-	const git_oid *gitmodules_oid)
+	git_submodule_cache *cache,
+	bool okay_to_create)
 {
-	const char *workdir = git_repository_workdir(repo);
+	const char *workdir = git_repository_workdir(cache->repo);
 	git_buf path = GIT_BUF_INIT;
 	git_config_backend *mods = NULL;
 
@@ -1540,7 +1564,7 @@ static git_config_backend *open_gitmodules(
 		}
 	}
 
-	if (!mods && gitmodules_oid && !git_oid_iszero(gitmodules_oid)) {
+	if (!mods && !git_oid_iszero(&cache->gitmodules_id)) {
 		/* TODO: Retrieve .gitmodules content from ODB */
 
 		/* Should we actually do this?  Core git does not, but it means you
@@ -1553,53 +1577,86 @@ static git_config_backend *open_gitmodules(
 	return mods;
 }
 
-static int load_submodule_config(git_repository *repo, bool reload)
+static void submodule_cache_free(git_submodule_cache *cache)
 {
-	int error;
-	git_oid gitmodules_oid;
-	git_config_backend *mods = NULL;
+	git_submodule *sm;
 
-	if (!reload && repo->submodules)
-		return 0;
+	if (!cache)
+		return;
 
-	memset(&gitmodules_oid, 0, sizeof(gitmodules_oid));
+	git_strmap_foreach_value(cache->submodules, sm, {
+		sm->repo = NULL; /* disconnect from repo */
+		git_submodule_free(sm);
+	});
+	git_strmap_free(cache->submodules);
 
-	/* Submodule data is kept in a hashtable keyed by both name and path.
-	 * These are usually the same, but that is not guaranteed.
-	 */
-	if (!repo->submodules) {
-		repo->submodules = git_strmap_alloc();
-		GITERR_CHECK_ALLOC(repo->submodules);
+	git_buf_free(&cache->gitmodules_path);
+	git_mutex_free(&cache->lock);
+	git__free(cache);
+}
+
+static int submodule_cache_alloc(
+	git_submodule_cache **out, git_repository *repo)
+{
+	git_submodule_cache *cache = git__calloc(1, sizeof(git_submodule_cache));
+	GITERR_CHECK_ALLOC(cache);
+
+	if (git_mutex_init(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to initialize submodule cache lock");
+		git__free(cache);
+		return -1;
+	}
+
+	cache->submodules = git_strmap_alloc();
+	if (!cache->submodules) {
+		submodule_cache_free(cache);
+		return -1;
 	}
 
+	cache->repo = repo;
+	git_buf_init(&cache->gitmodules_path, 0);
+
+	*out = cache;
+	return 0;
+}
+
+static int submodule_cache_refresh(git_submodule_cache *cache, bool force)
+{
+	int error;
+	git_config_backend *mods = NULL;
+
+	GIT_UNUSED(force);
+
 	/* TODO: only do the following if the sources appear modified */
 
+	memset(&cache->gitmodules_id, 0, sizeof(cache->gitmodules_id));
+
 	/* add submodule information from index */
 
-	if ((error = load_submodule_config_from_index(repo, &gitmodules_oid)) < 0)
+	if ((error = submodule_cache_refresh_from_index(cache)) < 0)
 		goto cleanup;
 
 	/* add submodule information from HEAD */
 
-	if ((error = load_submodule_config_from_head(repo, &gitmodules_oid)) < 0)
+	if ((error = submodule_cache_refresh_from_head(cache)) < 0)
 		goto cleanup;
 
 	/* add submodule information from .gitmodules */
 
-	if ((mods = open_gitmodules(repo, false, &gitmodules_oid)) != NULL &&
+	if ((mods = open_gitmodules(cache, false)) != NULL &&
 		(error = git_config_file_foreach(
-			mods, submodule_load_from_config, repo)) < 0)
+			mods, submodule_load_from_config, cache)) < 0)
 		goto cleanup;
 
 	/* shallow scan submodules in work tree */
 
-	if (!git_repository_is_bare(repo)) {
+	if (!git_repository_is_bare(cache->repo)) {
 		git_submodule *sm;
 
-		git_strmap_foreach_value(repo->submodules, sm, {
+		git_strmap_foreach_value(cache->submodules, sm, {
 			sm->flags &= ~GIT_SUBMODULE_STATUS__ALL_WD_FLAGS;
 		});
-		git_strmap_foreach_value(repo->submodules, sm, {
+		git_strmap_foreach_value(cache->submodules, sm, {
 			submodule_load_from_wd_lite(sm);
 		});
 	}
@@ -1608,8 +1665,28 @@ cleanup:
 	if (mods != NULL)
 		git_config_file_free(mods);
 
-	if (error)
-		git_submodule_config_free(repo);
+	/* TODO: if we got an error, mark submodule config as invalid? */
+
+	return error;
+}
+
+static int submodule_cache_init(git_repository *repo, bool refresh)
+{
+	int error = 0;
+	git_submodule_cache *cache = NULL;
+
+	/* if submodules already exist, just refresh as requested */
+	if (repo->_submodules)
+		return refresh ? submodule_cache_refresh(repo->_submodules, false) : 0;
+
+	/* otherwise create a new cache, load it, and atomically swap it in */
+	if (!(error = submodule_cache_alloc(&cache, repo)) &&
+		!(error = submodule_cache_refresh(cache, true)))
+		cache = git__compare_and_swap(&repo->_submodules, NULL, cache);
+
+	/* might have raced with another thread to set cache, so free if needed */
+	if (cache)
+		submodule_cache_free(cache);
 
 	return error;
 }
diff --git a/src/submodule.h b/src/submodule.h
index 1c41897e3..4b9828a9c 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -99,6 +99,30 @@ struct git_submodule {
 	git_oid wd_oid;
 };
 
+/**
+ * The git_submodule_cache stores known submodules along with timestamps,
+ * etc. about when they were loaded
+ */
+typedef struct {
+	git_repository *repo;
+	git_strmap *submodules;
+	git_mutex  lock;
+
+	/* cache invalidation data */
+	git_oid head_id;
+	git_futils_filestamp index_stamp;
+	git_buf gitmodules_path;
+	git_futils_filestamp gitmodules_stamp;
+	git_oid gitmodules_id;
+	git_futils_filestamp config_stamp;
+} git_submodule_cache;
+
+/* Force revalidation of submodule data cache (alloc as needed) */
+extern int git_submodule_cache_refresh(git_repository *repo);
+
+/* Release all submodules */
+extern void git_submodule_cache_free(git_repository *repo);
+
 /* Additional flags on top of public GIT_SUBMODULE_STATUS values */
 enum {
 	GIT_SUBMODULE_STATUS__WD_SCANNED          = (1u << 20),
@@ -122,6 +146,10 @@ enum {
 /* Internal submodule check does not attempt to refresh cached data */
 extern bool git_submodule__is_submodule(git_repository *repo, const char *name);
 
+/* Internal lookup does not attempt to refresh cached data */
+extern int git_submodule__lookup(
+	git_submodule **out, git_repository *repo, const char *path);
+
 /* Internal status fn returns status and optionally the various OIDs */
 extern int git_submodule__status(
 	unsigned int *out_status,
@@ -143,5 +171,6 @@ extern int git_submodule_parse_update(
 
 extern const char *git_submodule_ignore_to_str(git_submodule_ignore_t);
 extern const char *git_submodule_update_to_str(git_submodule_update_t);
+extern const char *git_submodule_recurse_to_str(git_submodule_recurse_t);
 
 #endif
-- 
cgit v1.2.3


From db0e7878d386e40080d4004e483e4845b15f8bd7 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 28 Mar 2014 16:50:49 -0700
Subject: Make submodule refresh a bit smarter

This makes submodule cache refresh actually look at the timestamps
from the data sources for submodules and reload as needed if they
have changed since the last refresh.
---
 src/config_file.h |   3 +-
 src/index.c       |  10 ++++
 src/index.h       |   7 +++
 src/submodule.c   | 153 ++++++++++++++++++++++++++++++++++--------------------
 src/submodule.h   |   6 ---
 5 files changed, 115 insertions(+), 64 deletions(-)

diff --git a/src/config_file.h b/src/config_file.h
index d4a1a4061..fcccbd5cc 100644
--- a/src/config_file.h
+++ b/src/config_file.h
@@ -16,7 +16,8 @@ GIT_INLINE(int) git_config_file_open(git_config_backend *cfg, unsigned int level
 
 GIT_INLINE(void) git_config_file_free(git_config_backend *cfg)
 {
-	cfg->free(cfg);
+	if (cfg)
+		cfg->free(cfg);
 }
 
 GIT_INLINE(int) git_config_file_get_string(
diff --git a/src/index.c b/src/index.c
index ea0815e4c..6cc8ea1a3 100644
--- a/src/index.c
+++ b/src/index.c
@@ -517,6 +517,16 @@ int git_index_read(git_index *index, int force)
 	return error;
 }
 
+int git_index__changed_relative_to(
+	git_index *index, const git_futils_filestamp *fs)
+{
+	/* attempt to update index (ignoring errors) */
+	if (git_index_read(index, false) < 0)
+		giterr_clear();
+
+	return (memcmp(&index->stamp, fs, sizeof(index->stamp)) == 0);
+}
+
 int git_index_write(git_index *index)
 {
 	git_filebuf file = GIT_FILEBUF_INIT;
diff --git a/src/index.h b/src/index.h
index 259a3149f..17f04f0ad 100644
--- a/src/index.h
+++ b/src/index.h
@@ -62,4 +62,11 @@ extern void git_index__set_ignore_case(git_index *index, bool ignore_case);
 
 extern unsigned int git_index__create_mode(unsigned int mode);
 
+GIT_INLINE(const git_futils_filestamp *) git_index__filestamp(git_index *index)
+{
+   return &index->stamp;
+}
+
+extern int git_index__changed_relative_to(git_index *index, const git_futils_filestamp *fs);
+
 #endif
diff --git a/src/submodule.c b/src/submodule.c
index 94bed8a6f..5588a4f69 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -133,6 +133,18 @@ static int submodule_lookup(
 	return 0;
 }
 
+/* clear a set of flags on all submodules */
+static void submodule_cache_clear_flags(
+	git_submodule_cache *cache, uint32_t mask)
+{
+	git_submodule *sm;
+	uint32_t inverted_mask = ~mask;
+
+	git_strmap_foreach_value(cache->submodules, sm, {
+		sm->flags &= inverted_mask;
+	});
+}
+
 /*
  * PUBLIC APIS
  */
@@ -377,8 +389,7 @@ cleanup:
 	if (out != NULL)
 		*out = sm;
 
-	if (mods != NULL)
-		git_config_file_free(mods);
+	git_config_file_free(mods);
 	git_repository_free(subrepo);
 	git_buf_free(&real_url);
 	git_buf_free(&name);
@@ -556,8 +567,7 @@ int git_submodule_save(git_submodule *submodule)
 	submodule->flags |= GIT_SUBMODULE_STATUS_IN_CONFIG;
 
 cleanup:
-	if (mods != NULL)
-		git_config_file_free(mods);
+	git_config_file_free(mods);
 	git_buf_free(&key);
 
 	return error;
@@ -916,10 +926,8 @@ int git_submodule_reload_all(git_repository *repo, int force)
 	GIT_UNUSED(force);
 	assert(repo);
 
-	if (repo->_submodules) {
-		map = repo->_submodules->submodules;
-		git_strmap_foreach_value(map, sm, { sm->flags = 0; });
-	}
+	if (repo->_submodules)
+		submodule_cache_clear_flags(repo->_submodules, 0xFFFFFFFFu);
 
 	if ((error = submodule_cache_init(repo, true)) < 0)
 		return error;
@@ -1063,7 +1071,9 @@ int git_submodule_reload(git_submodule *sm, int force)
 	}
 
 	/* refresh wd data */
-	sm->flags &= ~GIT_SUBMODULE_STATUS__ALL_WD_FLAGS;
+	sm->flags &=
+		~(GIT_SUBMODULE_STATUS_IN_WD | GIT_SUBMODULE_STATUS__WD_OID_VALID |
+		  GIT_SUBMODULE_STATUS__WD_FLAGS);
 
 	return submodule_load_from_wd_lite(sm);
 }
@@ -1450,15 +1460,14 @@ static int submodule_load_from_wd_lite(git_submodule *sm)
 	return 0;
 }
 
-static int submodule_cache_refresh_from_index(git_submodule_cache *cache)
+static int submodule_cache_refresh_from_index(
+	git_submodule_cache *cache, git_index *idx)
 {
 	int error;
-	git_index *index;
 	git_iterator *i;
 	const git_index_entry *entry;
 
-	if ((error = git_repository_index__weakptr(&index, cache->repo)) < 0 ||
-		(error = git_iterator_for_index(&i, index, 0, NULL, NULL)) < 0)
+	if ((error = git_iterator_for_index(&i, idx, 0, NULL, NULL)) < 0)
 		return error;
 
 	while (!(error = git_iterator_advance(&entry, i))) {
@@ -1477,8 +1486,7 @@ static int submodule_cache_refresh_from_index(git_submodule_cache *cache)
 				submodule_update_from_index_entry(sm, entry);
 				git_submodule_free(sm);
 			}
-		} else if (strcmp(entry->path, GIT_MODULES_FILE) == 0)
-			git_oid_cpy(&cache->gitmodules_id, &entry->id);
+		}
 	}
 
 	if (error == GIT_ITEROVER)
@@ -1489,23 +1497,15 @@ static int submodule_cache_refresh_from_index(git_submodule_cache *cache)
 	return error;
 }
 
-static int submodule_cache_refresh_from_head(git_submodule_cache *cache)
+static int submodule_cache_refresh_from_head(
+	git_submodule_cache *cache, git_tree *head)
 {
 	int error;
-	git_tree *head;
 	git_iterator *i;
 	const git_index_entry *entry;
 
-	/* if we can't look up current head, then there's no submodule in it */
-	if (git_repository_head_tree(&head, cache->repo) < 0) {
-		giterr_clear();
-		return 0;
-	}
-
-	if ((error = git_iterator_for_tree(&i, head, 0, NULL, NULL)) < 0) {
-		git_tree_free(head);
+	if ((error = git_iterator_for_tree(&i, head, 0, NULL, NULL)) < 0)
 		return error;
-	}
 
 	while (!(error = git_iterator_advance(&entry, i))) {
 		khiter_t pos = git_strmap_lookup_index(cache->submodules, entry->path);
@@ -1515,8 +1515,7 @@ static int submodule_cache_refresh_from_head(git_submodule_cache *cache)
 			sm = git_strmap_value_at(cache->submodules, pos);
 
 			if (S_ISGITLINK(entry->mode))
-				submodule_update_from_head_data(
-					sm, entry->mode, &entry->id);
+				submodule_update_from_head_data(sm, entry->mode, &entry->id);
 			else
 				sm->flags |= GIT_SUBMODULE_STATUS__HEAD_NOT_SUBMODULE;
 		} else if (S_ISGITLINK(entry->mode)) {
@@ -1525,9 +1524,6 @@ static int submodule_cache_refresh_from_head(git_submodule_cache *cache)
 					sm, entry->mode, &entry->id);
 				git_submodule_free(sm);
 			}
-		} else if (strcmp(entry->path, GIT_MODULES_FILE) == 0 &&
-				   git_oid_iszero(&cache->gitmodules_id)) {
-			git_oid_cpy(&cache->gitmodules_id, &entry->id);
 		}
 	}
 
@@ -1535,7 +1531,6 @@ static int submodule_cache_refresh_from_head(git_submodule_cache *cache)
 		error = 0;
 
 	git_iterator_free(i);
-	git_tree_free(head);
 
 	return error;
 }
@@ -1564,14 +1559,6 @@ static git_config_backend *open_gitmodules(
 		}
 	}
 
-	if (!mods && !git_oid_iszero(&cache->gitmodules_id)) {
-		/* TODO: Retrieve .gitmodules content from ODB */
-
-		/* Should we actually do this?  Core git does not, but it means you
-		 * can't really get much information about submodules on bare repos.
-		 */
-	}
-
 	git_buf_free(&path);
 
 	return mods;
@@ -1622,51 +1609,103 @@ static int submodule_cache_alloc(
 
 static int submodule_cache_refresh(git_submodule_cache *cache, bool force)
 {
-	int error;
+	int error = 0, updates = 0, changed;
 	git_config_backend *mods = NULL;
+	const char *wd;
+	git_index *idx = NULL;
+	git_tree *head = NULL;
+	git_buf path = GIT_BUF_INIT;
 
-	GIT_UNUSED(force);
+	if (git_mutex_lock(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to acquire lock on submodule cache");
+		return -1;
+	}
 
 	/* TODO: only do the following if the sources appear modified */
 
-	memset(&cache->gitmodules_id, 0, sizeof(cache->gitmodules_id));
-
 	/* add submodule information from index */
 
-	if ((error = submodule_cache_refresh_from_index(cache)) < 0)
-		goto cleanup;
+	if (!git_repository_index(&idx, cache->repo)) {
+		if (force || git_index__changed_relative_to(idx, &cache->index_stamp)) {
+			if ((error = submodule_cache_refresh_from_index(cache, idx)) < 0)
+				goto cleanup;
+
+			updates += 1;
+			git_futils_filestamp_set(
+				&cache->index_stamp, git_index__filestamp(idx));
+		}
+	} else {
+		giterr_clear();
+
+		submodule_cache_clear_flags(
+			cache, GIT_SUBMODULE_STATUS_IN_INDEX |
+			GIT_SUBMODULE_STATUS__INDEX_FLAGS |
+			GIT_SUBMODULE_STATUS__INDEX_OID_VALID);
+	}
 
 	/* add submodule information from HEAD */
 
-	if ((error = submodule_cache_refresh_from_head(cache)) < 0)
-		goto cleanup;
+	if (!git_repository_head_tree(&head, cache->repo)) {
+		if (force || !git_oid_equal(&cache->head_id, git_tree_id(head))) {
+			if ((error = submodule_cache_refresh_from_head(cache, head)) < 0)
+				goto cleanup;
+
+			updates += 1;
+			git_oid_cpy(&cache->head_id, git_tree_id(head));
+		}
+	} else {
+		giterr_clear();
+
+		submodule_cache_clear_flags(
+			cache, GIT_SUBMODULE_STATUS_IN_HEAD |
+			GIT_SUBMODULE_STATUS__HEAD_OID_VALID);
+	}
 
 	/* add submodule information from .gitmodules */
 
-	if ((mods = open_gitmodules(cache, false)) != NULL &&
-		(error = git_config_file_foreach(
-			mods, submodule_load_from_config, cache)) < 0)
+	wd = git_repository_workdir(cache->repo);
+
+	if (wd && (error = git_buf_joinpath(&path, wd, GIT_MODULES_FILE)) < 0)
 		goto cleanup;
 
+	changed = git_futils_filestamp_check(&cache->gitmodules_stamp, path.ptr);
+	if (changed < 0) {
+		giterr_clear();
+		submodule_cache_clear_flags(cache, GIT_SUBMODULE_STATUS_IN_CONFIG);
+	} else if (changed > 0 && (mods = open_gitmodules(cache, false)) != NULL) {
+		if ((error = git_config_file_foreach(
+				mods, submodule_load_from_config, cache)) < 0)
+			goto cleanup;
+		updates += 1;
+	}
+
 	/* shallow scan submodules in work tree */
 
-	if (!git_repository_is_bare(cache->repo)) {
+	if (wd && updates > 0) {
 		git_submodule *sm;
 
-		git_strmap_foreach_value(cache->submodules, sm, {
-			sm->flags &= ~GIT_SUBMODULE_STATUS__ALL_WD_FLAGS;
-		});
+		submodule_cache_clear_flags(
+			cache, GIT_SUBMODULE_STATUS_IN_WD |
+			GIT_SUBMODULE_STATUS__WD_SCANNED |
+			GIT_SUBMODULE_STATUS__WD_FLAGS |
+			GIT_SUBMODULE_STATUS__WD_OID_VALID);
+
 		git_strmap_foreach_value(cache->submodules, sm, {
 			submodule_load_from_wd_lite(sm);
 		});
 	}
 
 cleanup:
-	if (mods != NULL)
-		git_config_file_free(mods);
+	git_config_file_free(mods);
 
 	/* TODO: if we got an error, mark submodule config as invalid? */
 
+	git_mutex_unlock(&cache->lock);
+
+	git_index_free(idx);
+	git_tree_free(head);
+	git_buf_free(&path);
+
 	return error;
 }
 
diff --git a/src/submodule.h b/src/submodule.h
index 4b9828a9c..a6182beca 100644
--- a/src/submodule.h
+++ b/src/submodule.h
@@ -113,7 +113,6 @@ typedef struct {
 	git_futils_filestamp index_stamp;
 	git_buf gitmodules_path;
 	git_futils_filestamp gitmodules_stamp;
-	git_oid gitmodules_id;
 	git_futils_filestamp config_stamp;
 } git_submodule_cache;
 
@@ -135,11 +134,6 @@ enum {
 	GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES = (1u << 27),
 };
 
-#define GIT_SUBMODULE_STATUS__ALL_WD_FLAGS \
-	(GIT_SUBMODULE_STATUS_IN_WD | \
-	 GIT_SUBMODULE_STATUS__WD_OID_VALID | \
-	 GIT_SUBMODULE_STATUS__WD_FLAGS)
-
 #define GIT_SUBMODULE_STATUS__CLEAR_INTERNAL(S) \
 	((S) & ~(0xFFFFFFFFu << 20))
 
-- 
cgit v1.2.3


From a4ccd2b00199306889585b23845368455ff348f4 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Sat, 29 Mar 2014 15:23:01 -0700
Subject: Use enums instead of bools for submodule options

When forcing cache flushes or reload, etc., it is easier to keep
track of intent using enums instead of plain bools.  Also, this
fixes a bug where the cache was not being properly refreshes by
a git_submodule_reload_all.
---
 src/submodule.c | 57 +++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 37 insertions(+), 20 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index 5588a4f69..7b06c25c2 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -49,6 +49,16 @@ static git_cvar_map _sm_recurse_map[] = {
 	{GIT_CVAR_TRUE, NULL, GIT_SUBMODULE_RECURSE_YES},
 };
 
+enum {
+	CACHE_OK = 0,
+	CACHE_REFRESH = 1,
+	CACHE_FLUSH = 2
+};
+enum {
+	GITMODULES_EXISTING = 0,
+	GITMODULES_CREATE = 1,
+};
+
 static kh_inline khint_t str_hash_no_trailing_slash(const char *s)
 {
 	khint_t h;
@@ -77,10 +87,10 @@ __KHASH_IMPL(
 	str, static kh_inline, const char *, void *, 1,
 	str_hash_no_trailing_slash, str_equal_no_trailing_slash);
 
-static int submodule_cache_init(git_repository *repo, bool refresh);
+static int submodule_cache_init(git_repository *repo, int refresh);
 static void submodule_cache_free(git_submodule_cache *cache);
 
-static git_config_backend *open_gitmodules(git_submodule_cache *, bool);
+static git_config_backend *open_gitmodules(git_submodule_cache *, int gitmod);
 static int lookup_head_remote_key(git_buf *key, git_repository *repo);
 static int lookup_head_remote(git_buf *url, git_repository *repo);
 static int submodule_get(git_submodule **, git_submodule_cache *, const char *, const char *);
@@ -153,7 +163,7 @@ bool git_submodule__is_submodule(git_repository *repo, const char *name)
 {
 	git_strmap *map;
 
-	if (submodule_cache_init(repo, false) < 0) {
+	if (submodule_cache_init(repo, CACHE_OK) < 0) {
 		giterr_clear();
 		return false;
 	}
@@ -183,7 +193,7 @@ int git_submodule__lookup(
 
 	assert(repo && name);
 
-	if ((error = submodule_cache_init(repo, false)) < 0)
+	if ((error = submodule_cache_init(repo, CACHE_OK)) < 0)
 		return error;
 
 	if ((error = submodule_lookup(out, repo->_submodules, name, NULL)) < 0)
@@ -201,7 +211,7 @@ int git_submodule_lookup(
 
 	assert(repo && name);
 
-	if ((error = submodule_cache_init(repo, true)) < 0)
+	if ((error = submodule_cache_init(repo, CACHE_REFRESH)) < 0)
 		return error;
 
 	if ((error = submodule_lookup(out, repo->_submodules, name, NULL)) < 0) {
@@ -238,7 +248,7 @@ int git_submodule_foreach(
 
 	assert(repo && callback);
 
-	if ((error = submodule_cache_init(repo, true)) < 0)
+	if ((error = submodule_cache_init(repo, CACHE_REFRESH)) < 0)
 		return error;
 
 	git_strmap_foreach_value(repo->_submodules->submodules, sm, {
@@ -317,9 +327,9 @@ int git_submodule_add_setup(
 
 	/* update .gitmodules */
 
-	if ((mods = open_gitmodules(repo->_submodules, true)) == NULL) {
+	if (!(mods = open_gitmodules(repo->_submodules, GITMODULES_CREATE))) {
 		giterr_set(GITERR_SUBMODULE,
-			"Adding submodules to a bare repository is not supported (for now)");
+			"Adding submodules to a bare repository is not supported");
 		return -1;
 	}
 
@@ -517,10 +527,10 @@ int git_submodule_save(git_submodule *submodule)
 
 	assert(submodule);
 
-	mods = open_gitmodules(submodule->repo->_submodules, true);
+	mods = open_gitmodules(submodule->repo->_submodules, GITMODULES_CREATE);
 	if (!mods) {
 		giterr_set(GITERR_SUBMODULE,
-			"Adding submodules to a bare repository is not supported (for now)");
+			"Adding submodules to a bare repository is not supported");
 		return -1;
 	}
 
@@ -929,7 +939,7 @@ int git_submodule_reload_all(git_repository *repo, int force)
 	if (repo->_submodules)
 		submodule_cache_clear_flags(repo->_submodules, 0xFFFFFFFFu);
 
-	if ((error = submodule_cache_init(repo, true)) < 0)
+	if ((error = submodule_cache_init(repo, CACHE_FLUSH)) < 0)
 		return error;
 
 	if (!repo->_submodules || !(map = repo->_submodules->submodules))
@@ -1049,7 +1059,7 @@ int git_submodule_reload(git_submodule *sm, int force)
 		return error;
 
 	/* refresh config data */
-	mods = open_gitmodules(cache, false);
+	mods = open_gitmodules(cache, GITMODULES_EXISTING);
 	if (mods != NULL) {
 		git_buf path = GIT_BUF_INIT;
 
@@ -1537,7 +1547,7 @@ static int submodule_cache_refresh_from_head(
 
 static git_config_backend *open_gitmodules(
 	git_submodule_cache *cache,
-	bool okay_to_create)
+	int okay_to_create)
 {
 	const char *workdir = git_repository_workdir(cache->repo);
 	git_buf path = GIT_BUF_INIT;
@@ -1607,15 +1617,19 @@ static int submodule_cache_alloc(
 	return 0;
 }
 
-static int submodule_cache_refresh(git_submodule_cache *cache, bool force)
+static int submodule_cache_refresh(git_submodule_cache *cache, int refresh)
 {
-	int error = 0, updates = 0, changed;
+	int error = 0, updates = 0, flush, changed;
 	git_config_backend *mods = NULL;
 	const char *wd;
 	git_index *idx = NULL;
 	git_tree *head = NULL;
 	git_buf path = GIT_BUF_INIT;
 
+	if (!refresh)
+		return 0;
+	flush = (refresh == CACHE_FLUSH);
+
 	if (git_mutex_lock(&cache->lock) < 0) {
 		giterr_set(GITERR_OS, "Unable to acquire lock on submodule cache");
 		return -1;
@@ -1626,7 +1640,7 @@ static int submodule_cache_refresh(git_submodule_cache *cache, bool force)
 	/* add submodule information from index */
 
 	if (!git_repository_index(&idx, cache->repo)) {
-		if (force || git_index__changed_relative_to(idx, &cache->index_stamp)) {
+		if (flush || git_index__changed_relative_to(idx, &cache->index_stamp)) {
 			if ((error = submodule_cache_refresh_from_index(cache, idx)) < 0)
 				goto cleanup;
 
@@ -1646,7 +1660,7 @@ static int submodule_cache_refresh(git_submodule_cache *cache, bool force)
 	/* add submodule information from HEAD */
 
 	if (!git_repository_head_tree(&head, cache->repo)) {
-		if (force || !git_oid_equal(&cache->head_id, git_tree_id(head))) {
+		if (flush || !git_oid_equal(&cache->head_id, git_tree_id(head))) {
 			if ((error = submodule_cache_refresh_from_head(cache, head)) < 0)
 				goto cleanup;
 
@@ -1669,6 +1683,9 @@ static int submodule_cache_refresh(git_submodule_cache *cache, bool force)
 		goto cleanup;
 
 	changed = git_futils_filestamp_check(&cache->gitmodules_stamp, path.ptr);
+	if (flush && !changed)
+		changed = 1;
+
 	if (changed < 0) {
 		giterr_clear();
 		submodule_cache_clear_flags(cache, GIT_SUBMODULE_STATUS_IN_CONFIG);
@@ -1709,18 +1726,18 @@ cleanup:
 	return error;
 }
 
-static int submodule_cache_init(git_repository *repo, bool refresh)
+static int submodule_cache_init(git_repository *repo, int cache_refresh)
 {
 	int error = 0;
 	git_submodule_cache *cache = NULL;
 
 	/* if submodules already exist, just refresh as requested */
 	if (repo->_submodules)
-		return refresh ? submodule_cache_refresh(repo->_submodules, false) : 0;
+		return submodule_cache_refresh(repo->_submodules, cache_refresh);
 
 	/* otherwise create a new cache, load it, and atomically swap it in */
 	if (!(error = submodule_cache_alloc(&cache, repo)) &&
-		!(error = submodule_cache_refresh(cache, true)))
+		!(error = submodule_cache_refresh(cache, CACHE_FLUSH)))
 		cache = git__compare_and_swap(&repo->_submodules, NULL, cache);
 
 	/* might have raced with another thread to set cache, so free if needed */
-- 
cgit v1.2.3


From eeeb9654f064e1047ef8f3cb5a38636133426cdd Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Sun, 30 Mar 2014 15:35:56 -0700
Subject: Reinstate efficient submodule reloading

This makes it so that git_submodule_reload_all will actually only
reload changed items unless the `force` flag is used.
---
 src/submodule.c | 234 +++++++++++++++++++++++++++-----------------------------
 1 file changed, 111 insertions(+), 123 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index 7b06c25c2..96b445ace 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -898,66 +898,9 @@ int git_submodule_open(git_repository **subrepo, git_submodule *sm)
 	return git_submodule__open(subrepo, sm, false);
 }
 
-static void submodule_cache_remove_item(
-	git_strmap *map,
-	const char *name,
-	git_submodule *expected,
-	bool free_after_remove)
-{
-	khiter_t pos;
-	git_submodule *found;
-
-	if (!map)
-		return;
-
-	pos = git_strmap_lookup_index(map, name);
-
-	if (!git_strmap_valid_index(map, pos))
-		return;
-
-	found = git_strmap_value_at(map, pos);
-
-	if (expected && found != expected)
-		return;
-
-	git_strmap_set_value_at(map, pos, NULL);
-	git_strmap_delete_at(map, pos);
-
-	if (free_after_remove)
-		git_submodule_free(found);
-}
-
 int git_submodule_reload_all(git_repository *repo, int force)
 {
-	int error = 0;
-	git_submodule *sm;
-	git_strmap *map;
-
-	GIT_UNUSED(force);
-	assert(repo);
-
-	if (repo->_submodules)
-		submodule_cache_clear_flags(repo->_submodules, 0xFFFFFFFFu);
-
-	if ((error = submodule_cache_init(repo, CACHE_FLUSH)) < 0)
-		return error;
-
-	if (!repo->_submodules || !(map = repo->_submodules->submodules))
-		return error;
-
-	git_strmap_foreach_value(map, sm, {
-		if (sm && (sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS) == 0) {
-			/* we must check path != name before first remove, in case
-			 * that call frees the submodule */
-			bool free_as_path = (sm->path != sm->name);
-
-			submodule_cache_remove_item(map, sm->name, sm, true);
-			if (free_as_path)
-				submodule_cache_remove_item(map, sm->path, sm, true);
-		}
-	});
-
-	return error;
+	return submodule_cache_init(repo, force ? CACHE_FLUSH : CACHE_REFRESH);
 }
 
 static void submodule_update_from_index_entry(
@@ -1210,20 +1153,49 @@ static int submodule_alloc(
 	return 0;
 }
 
+static void submodule_cache_remove_item(
+	git_submodule_cache *cache,
+	git_submodule *item,
+	bool free_after_remove)
+{
+	git_strmap *map;
+	const char *name, *alt;
+
+	if (!cache || !(map = cache->submodules) || !item)
+		return;
+
+	name = item->name;
+	alt  = (item->path != item->name) ? item->path : NULL;
+
+	for (; name; name = alt, alt = NULL) {
+		khiter_t pos = git_strmap_lookup_index(map, name);
+		git_submodule *found;
+
+		if (!git_strmap_valid_index(map, pos))
+			continue;
+
+		found = git_strmap_value_at(map, pos);
+
+		if (found != item)
+			continue;
+
+		git_strmap_set_value_at(map, pos, NULL);
+		git_strmap_delete_at(map, pos);
+
+		if (free_after_remove)
+			git_submodule_free(found);
+	}
+}
+
 static void submodule_release(git_submodule *sm)
 {
 	if (!sm)
 		return;
 
-	if (sm->repo && sm->repo->_submodules) {
-		git_strmap *map = sm->repo->_submodules->submodules;
-		bool free_as_path = (sm->path != sm->name);
-
+	if (sm->repo) {
+		git_submodule_cache *cache = sm->repo->_submodules;
 		sm->repo = NULL;
-
-		submodule_cache_remove_item(map, sm->name, sm, false);
-		if (free_as_path)
-			submodule_cache_remove_item(map, sm->path, sm, false);
+		submodule_cache_remove_item(cache, sm, false);
 	}
 
 	if (sm->path != sm->name)
@@ -1619,99 +1591,115 @@ static int submodule_cache_alloc(
 
 static int submodule_cache_refresh(git_submodule_cache *cache, int refresh)
 {
-	int error = 0, updates = 0, flush, changed;
-	git_config_backend *mods = NULL;
-	const char *wd;
+	int error = 0, update_index, update_head, update_gitmod;
 	git_index *idx = NULL;
 	git_tree *head = NULL;
+	const char *wd = NULL;
 	git_buf path = GIT_BUF_INIT;
+	git_submodule *sm;
+	git_config_backend *mods = NULL;
+	uint32_t mask;
 
-	if (!refresh)
+	if (!cache || !cache->repo || !refresh)
 		return 0;
-	flush = (refresh == CACHE_FLUSH);
 
 	if (git_mutex_lock(&cache->lock) < 0) {
 		giterr_set(GITERR_OS, "Unable to acquire lock on submodule cache");
 		return -1;
 	}
 
-	/* TODO: only do the following if the sources appear modified */
+	/* get sources that we will need to check */
 
-	/* add submodule information from index */
+	if (git_repository_index(&idx, cache->repo) < 0)
+		giterr_clear();
+	if (git_repository_head_tree(&head, cache->repo) < 0)
+		giterr_clear();
 
-	if (!git_repository_index(&idx, cache->repo)) {
-		if (flush || git_index__changed_relative_to(idx, &cache->index_stamp)) {
-			if ((error = submodule_cache_refresh_from_index(cache, idx)) < 0)
-				goto cleanup;
+	wd = git_repository_workdir(cache->repo);
+	if (wd && (error = git_buf_joinpath(&path, wd, GIT_MODULES_FILE)) < 0)
+		goto cleanup;
 
-			updates += 1;
-			git_futils_filestamp_set(
-				&cache->index_stamp, git_index__filestamp(idx));
-		}
-	} else {
-		giterr_clear();
+	/* check for invalidation */
 
-		submodule_cache_clear_flags(
-			cache, GIT_SUBMODULE_STATUS_IN_INDEX |
-			GIT_SUBMODULE_STATUS__INDEX_FLAGS |
-			GIT_SUBMODULE_STATUS__INDEX_OID_VALID);
+	if (refresh == CACHE_FLUSH)
+		update_index = update_head = update_gitmod = true;
+	else {
+		update_index =
+			!idx || git_index__changed_relative_to(idx, &cache->index_stamp);
+		update_head =
+			!head || !git_oid_equal(&cache->head_id, git_tree_id(head));
+
+		update_gitmod = (wd != NULL) ?
+			git_futils_filestamp_check(&cache->gitmodules_stamp, path.ptr) :
+			(cache->gitmodules_stamp.mtime != 0);
+		if (update_gitmod < 0)
+			giterr_clear();
 	}
 
-	/* add submodule information from HEAD */
+	/* clear submodule flags that are to be refreshed */
 
-	if (!git_repository_head_tree(&head, cache->repo)) {
-		if (flush || !git_oid_equal(&cache->head_id, git_tree_id(head))) {
-			if ((error = submodule_cache_refresh_from_head(cache, head)) < 0)
-				goto cleanup;
+	mask = 0;
+	if (!idx || update_index)
+		mask |= GIT_SUBMODULE_STATUS_IN_INDEX |
+			GIT_SUBMODULE_STATUS__INDEX_FLAGS |
+			GIT_SUBMODULE_STATUS__INDEX_OID_VALID |
+			GIT_SUBMODULE_STATUS__INDEX_MULTIPLE_ENTRIES;
+	if (!head || update_head)
+		mask |= GIT_SUBMODULE_STATUS_IN_HEAD |
+			GIT_SUBMODULE_STATUS__HEAD_OID_VALID;
+	if (update_gitmod)
+		mask |= GIT_SUBMODULE_STATUS_IN_CONFIG;
+	if (mask != 0)
+		mask |= GIT_SUBMODULE_STATUS_IN_WD |
+			GIT_SUBMODULE_STATUS__WD_SCANNED |
+			GIT_SUBMODULE_STATUS__WD_FLAGS |
+			GIT_SUBMODULE_STATUS__WD_OID_VALID;
 
-			updates += 1;
-			git_oid_cpy(&cache->head_id, git_tree_id(head));
-		}
-	} else {
-		giterr_clear();
+	submodule_cache_clear_flags(cache, mask);
+
+	/* add back submodule information from index */
+
+	if (idx && update_index) {
+		if ((error = submodule_cache_refresh_from_index(cache, idx)) < 0)
+			goto cleanup;
 
-		submodule_cache_clear_flags(
-			cache, GIT_SUBMODULE_STATUS_IN_HEAD |
-			GIT_SUBMODULE_STATUS__HEAD_OID_VALID);
+		git_futils_filestamp_set(
+			&cache->index_stamp, git_index__filestamp(idx));
 	}
 
-	/* add submodule information from .gitmodules */
+	/* add submodule information from HEAD */
 
-	wd = git_repository_workdir(cache->repo);
+	if (head && update_head) {
+		if ((error = submodule_cache_refresh_from_head(cache, head)) < 0)
+			goto cleanup;
 
-	if (wd && (error = git_buf_joinpath(&path, wd, GIT_MODULES_FILE)) < 0)
-		goto cleanup;
+		git_oid_cpy(&cache->head_id, git_tree_id(head));
+	}
 
-	changed = git_futils_filestamp_check(&cache->gitmodules_stamp, path.ptr);
-	if (flush && !changed)
-		changed = 1;
+	/* add submodule information from .gitmodules */
 
-	if (changed < 0) {
-		giterr_clear();
-		submodule_cache_clear_flags(cache, GIT_SUBMODULE_STATUS_IN_CONFIG);
-	} else if (changed > 0 && (mods = open_gitmodules(cache, false)) != NULL) {
-		if ((error = git_config_file_foreach(
+	if (wd && update_gitmod > 0) {
+		if ((mods = open_gitmodules(cache, false)) != NULL &&
+			(error = git_config_file_foreach(
 				mods, submodule_load_from_config, cache)) < 0)
 			goto cleanup;
-		updates += 1;
 	}
 
-	/* shallow scan submodules in work tree */
-
-	if (wd && updates > 0) {
-		git_submodule *sm;
-
-		submodule_cache_clear_flags(
-			cache, GIT_SUBMODULE_STATUS_IN_WD |
-			GIT_SUBMODULE_STATUS__WD_SCANNED |
-			GIT_SUBMODULE_STATUS__WD_FLAGS |
-			GIT_SUBMODULE_STATUS__WD_OID_VALID);
+	/* shallow scan submodules in work tree as needed */
 
+	if (wd && mask != 0) {
 		git_strmap_foreach_value(cache->submodules, sm, {
 			submodule_load_from_wd_lite(sm);
 		});
 	}
 
+	/* remove submodules that no longer exist */
+
+	git_strmap_foreach_value(cache->submodules, sm, {
+		if (sm && (sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS) == 0)
+			submodule_cache_remove_item(cache, sm, true);
+	});
+
 cleanup:
 	git_config_file_free(mods);
 
-- 
cgit v1.2.3


From aa78c9ba778d8c7c2c62f875b974ae53ba90d12b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 1 Apr 2014 10:22:51 -0700
Subject: Minor submodule cache locking improvements

This improvement the management of the lock around submodule cache
updates slightly, using the lock to make sure that foreach can
safely make a snapshot of all existing submodules and making sure
that git_submodule_add_setup also grabs a lock before inserting
the new submodule.  Cache initialization / refresh should already
have been holding the lock correctly as it adds submodules.
---
 src/submodule.c | 58 +++++++++++++++++++++++++++++++++++++++++++--------------
 src/vector.c    |  2 +-
 2 files changed, 45 insertions(+), 15 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index 96b445ace..5061cadc6 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -236,40 +236,62 @@ int git_submodule_lookup(
 	return error;
 }
 
+static void submodule_free_dup(void *sm)
+{
+	git_submodule_free(sm);
+}
+
 int git_submodule_foreach(
 	git_repository *repo,
 	int (*callback)(git_submodule *sm, const char *name, void *payload),
 	void *payload)
 {
 	int error;
+	size_t i;
 	git_submodule *sm;
-	git_vector seen = GIT_VECTOR_INIT;
-	git_vector_set_cmp(&seen, submodule_cmp);
+	git_submodule_cache *cache;
+	git_vector snapshot = GIT_VECTOR_INIT;
 
 	assert(repo && callback);
 
 	if ((error = submodule_cache_init(repo, CACHE_REFRESH)) < 0)
 		return error;
 
-	git_strmap_foreach_value(repo->_submodules->submodules, sm, {
-		/* Usually the following will not come into play - it just prevents
-		 * us from issuing a callback twice for a submodule where the name
-		 * and path are not the same.
-		 */
-		if (GIT_REFCOUNT_VAL(sm) > 1) {
-			if (git_vector_bsearch(NULL, &seen, sm) != GIT_ENOTFOUND)
-				continue;
-			if ((error = git_vector_insert(&seen, sm)) < 0)
+	cache = repo->_submodules;
+
+	if (git_mutex_lock(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to acquire lock on submodule cache");
+		return -1;
+	}
+
+	if (!(error = git_vector_init(
+			&snapshot, kh_size(cache->submodules), submodule_cmp))) {
+
+		git_strmap_foreach_value(cache->submodules, sm, {
+			if ((error = git_vector_insert(&snapshot, sm)) < 0)
 				break;
-		}
+			GIT_REFCOUNT_INC(sm);
+		});
+	}
 
+	git_mutex_unlock(&cache->lock);
+
+	if (error < 0)
+		goto done;
+
+	git_vector_uniq(&snapshot, submodule_free_dup);
+
+	git_vector_foreach(&snapshot, i, sm) {
 		if ((error = callback(sm, sm->name, payload)) != 0) {
 			giterr_set_after_callback(error);
 			break;
 		}
-	});
+	}
 
-	git_vector_free(&seen);
+done:
+	git_vector_foreach(&snapshot, i, sm)
+		git_submodule_free(sm);
+	git_vector_free(&snapshot);
 
 	return error;
 }
@@ -387,10 +409,18 @@ int git_submodule_add_setup(
 
 	/* add submodule to hash and "reload" it */
 
+	if (git_mutex_lock(&repo->_submodules->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to acquire lock on submodule cache");
+		error = -1;
+		goto cleanup;
+	}
+
 	if (!(error = submodule_get(&sm, repo->_submodules, path, NULL)) &&
 		!(error = git_submodule_reload(sm, false)))
 		error = git_submodule_init(sm, false);
 
+	git_mutex_unlock(&repo->_submodules->lock);
+
 cleanup:
 	if (error && sm) {
 		git_submodule_free(sm);
diff --git a/src/vector.c b/src/vector.c
index e5d8919d3..c2c67e6b8 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -54,7 +54,7 @@ int git_vector_dup(git_vector *v, const git_vector *src, git_vector_cmp cmp)
 	bytes = src->length * sizeof(void *);
 
 	v->_alloc_size = src->length;
-	v->_cmp = cmp;
+	v->_cmp = cmp ? cmp : src->_cmp;
 	v->length = src->length;
 	v->flags  = src->flags;
 	if (cmp != src->_cmp)
-- 
cgit v1.2.3


From f28e4c97b38c1ec60dc6ce6e5306067ad24aeb8e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 1 Apr 2014 20:17:49 +0200
Subject: refspec: git_refspec_parse() does not exist

---
 src/refspec.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/refspec.h b/src/refspec.h
index 375465f61..9a87c97a5 100644
--- a/src/refspec.h
+++ b/src/refspec.h
@@ -23,7 +23,6 @@ struct git_refspec {
 
 #define GIT_REFSPEC_TAGS "refs/tags/*:refs/tags/*"
 
-int git_refspec_parse(struct git_refspec *refspec, const char *str);
 int git_refspec__parse(
 	struct git_refspec *refspec,
 	const char *str,
-- 
cgit v1.2.3


From 4ece3e225b566816598238902667552dee4c7deb Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 1 Apr 2014 12:19:11 -0700
Subject: Fix submodule accounting for name and path changes

Wrote tests that try adding, removing, and updating the name of
submodules which showed a number of problems with how we account
for changes when incrementally updating the submodule info.  Most
of these issues didn't exist before because reloading would always
blow away the old submodule data.
---
 src/submodule.c          | 50 ++++++++++++++++++++++++++++--------
 tests/submodule/nosubs.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 107 insertions(+), 10 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index 5061cadc6..913c97a87 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -1345,8 +1345,9 @@ static int submodule_load_from_config(
 	const git_config_entry *entry, void *payload)
 {
 	git_submodule_cache *cache = payload;
-	const char *namestart, *property, *alternate = NULL;
+	const char *namestart, *property;
 	const char *key = entry->name, *value = entry->value, *path;
+	char *alternate = NULL, *replaced = NULL;
 	git_buf name = GIT_BUF_INIT;
 	git_submodule *sm = NULL;
 	int error = 0;
@@ -1377,17 +1378,39 @@ static int submodule_load_from_config(
 	 * should be strcasecmp
 	 */
 
-	if (strcmp(sm->name, name.ptr) != 0) {
-		alternate = sm->name = git_buf_detach(&name);
-	} else if (path && strcmp(path, sm->path) != 0) {
-		alternate = sm->path = git__strdup(value);
-		if (!sm->path) {
-			error = -1;
-			goto done;
+	if (strcmp(sm->name, name.ptr) != 0) { /* name changed */
+		if (!strcmp(sm->path, name.ptr)) { /* already set as path */
+			replaced = sm->name;
+			sm->name = sm->path;
+		} else {
+			if (sm->name != sm->path)
+				replaced = sm->name;
+			alternate = sm->name = git_buf_detach(&name);
+		}
+	}
+	else if (path && strcmp(path, sm->path) != 0) { /* path changed */
+		if (!strcmp(sm->name, value)) { /* already set as name */
+			replaced = sm->path;
+			sm->path = sm->name;
+		} else {
+			if (sm->path != sm->name)
+				replaced = sm->path;
+			if ((alternate = git__strdup(value)) == NULL) {
+				error = -1;
+				goto done;
+			}
+			sm->path = alternate;
 		}
 	}
 
-	/* Found a alternate key for the submodule */
+	/* Deregister under name being replaced */
+	if (replaced) {
+		git_strmap_delete(cache->submodules, replaced);
+		git_submodule_free(sm);
+		git__free(replaced);
+	}
+
+	/* Insert under alternate key */
 	if (alternate) {
 		void *old_sm = NULL;
 		git_strmap_insert2(cache->submodules, alternate, sm, old_sm, error);
@@ -1684,6 +1707,8 @@ static int submodule_cache_refresh(git_submodule_cache *cache, int refresh)
 			GIT_SUBMODULE_STATUS__WD_SCANNED |
 			GIT_SUBMODULE_STATUS__WD_FLAGS |
 			GIT_SUBMODULE_STATUS__WD_OID_VALID;
+	else
+		goto cleanup; /* nothing to do */
 
 	submodule_cache_clear_flags(cache, mask);
 
@@ -1726,7 +1751,12 @@ static int submodule_cache_refresh(git_submodule_cache *cache, int refresh)
 	/* remove submodules that no longer exist */
 
 	git_strmap_foreach_value(cache->submodules, sm, {
-		if (sm && (sm->flags & GIT_SUBMODULE_STATUS__IN_FLAGS) == 0)
+		/* purge unless in HEAD, index, or .gitmodules; no sm for wd only */
+		if (sm != NULL &&
+			!(sm->flags &
+			 (GIT_SUBMODULE_STATUS_IN_HEAD |
+			  GIT_SUBMODULE_STATUS_IN_INDEX |
+			  GIT_SUBMODULE_STATUS_IN_CONFIG)))
 			submodule_cache_remove_item(cache, sm, true);
 	});
 
diff --git a/tests/submodule/nosubs.c b/tests/submodule/nosubs.c
index 5ef4f42ab..cabb53ead 100644
--- a/tests/submodule/nosubs.c
+++ b/tests/submodule/nosubs.c
@@ -2,6 +2,7 @@
 
 #include "clar_libgit2.h"
 #include "posix.h"
+#include "fileops.h"
 
 void test_submodule_nosubs__cleanup(void)
 {
@@ -93,3 +94,69 @@ void test_submodule_nosubs__bad_gitmodules(void)
 	cl_git_pass(git_submodule_lookup(NULL, repo, "foobar"));
 	cl_assert_equal_i(GIT_ENOTFOUND, git_submodule_lookup(NULL, repo, "subdir"));
 }
+
+void test_submodule_nosubs__add_and_delete(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+	git_submodule *sm;
+	git_buf buf = GIT_BUF_INIT;
+
+	/* note the lack of calls to git_submodule_reload - this *should* work */
+
+	cl_git_fail(git_submodule_lookup(NULL, repo, "libgit2"));
+	cl_git_fail(git_submodule_lookup(NULL, repo, "submodules/libgit2"));
+
+	/* create */
+
+	cl_git_pass(git_submodule_add_setup(
+		&sm, repo, "https://github.com/libgit2/libgit2.git", "submodules/libgit2", 1));
+	cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm));
+	cl_assert_equal_s("submodules/libgit2", git_submodule_path(sm));
+	git_submodule_free(sm);
+
+	cl_git_pass(git_futils_readbuffer(&buf, "status/.gitmodules"));
+	cl_assert(strstr(buf.ptr, "[submodule \"submodules/libgit2\"]") != NULL);
+	cl_assert(strstr(buf.ptr, "path = submodules/libgit2") != NULL);
+	git_buf_free(&buf);
+
+	/* lookup */
+
+	cl_git_fail(git_submodule_lookup(&sm, repo, "libgit2"));
+	cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2"));
+	cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm));
+	cl_assert_equal_s("submodules/libgit2", git_submodule_path(sm));
+	git_submodule_free(sm);
+
+	/* update name */
+
+	cl_git_rewritefile(
+		"status/.gitmodules",
+		"[submodule \"libgit2\"]\n"
+		"  path = submodules/libgit2\n"
+		"  url = https://github.com/libgit2/libgit2.git\n");
+
+	cl_git_pass(git_submodule_lookup(&sm, repo, "libgit2"));
+	cl_assert_equal_s("libgit2", git_submodule_name(sm));
+	cl_assert_equal_s("submodules/libgit2", git_submodule_path(sm));
+	git_submodule_free(sm);
+	cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2"));
+	git_submodule_free(sm);
+
+	/* revert name update */
+
+	cl_git_rewritefile(
+		"status/.gitmodules",
+		"[submodule \"submodules/libgit2\"]\n"
+		"  path = submodules/libgit2\n"
+		"  url = https://github.com/libgit2/libgit2.git\n");
+
+	cl_git_fail(git_submodule_lookup(&sm, repo, "libgit2"));
+	cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2"));
+	git_submodule_free(sm);
+
+	/* remove completely */
+
+	cl_must_pass(p_unlink("status/.gitmodules"));
+	cl_git_fail(git_submodule_lookup(&sm, repo, "libgit2"));
+	cl_git_fail(git_submodule_lookup(&sm, repo, "submodules/libgit2"));
+}
-- 
cgit v1.2.3


From 8061d519b33c95a8858752e7d70d40fe8bae90f9 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 1 Apr 2014 13:24:06 -0700
Subject: Remove most submodule reloads from tests

With the new submodule cache validity checks, we generally don't
need to call git_submodule_reload_all to have up-to-date submodule
data.  Some tests are still calling it where I want to actually
test that it can be called safely and doesn't break anything, but
mostly it is not needed.

This also expands some of the existing submodule tests to cover
some variants on the behavior that was already being tested.
---
 tests/diff/submodules.c  |  5 ----
 tests/submodule/lookup.c | 66 ++++++++++++++++++++++++++++--------------------
 tests/submodule/nosubs.c | 18 +++++++++++--
 3 files changed, 55 insertions(+), 34 deletions(-)

diff --git a/tests/diff/submodules.c b/tests/diff/submodules.c
index 2881f74be..02870ac86 100644
--- a/tests/diff/submodules.c
+++ b/tests/diff/submodules.c
@@ -131,8 +131,6 @@ void test_diff_submodules__dirty_submodule_2(void)
 
 	g_repo = setup_fixture_submodules();
 
-	cl_git_pass(git_submodule_reload_all(g_repo, 1));
-
 	opts.flags = GIT_DIFF_INCLUDE_UNTRACKED |
 		GIT_DIFF_SHOW_UNTRACKED_CONTENT |
 		GIT_DIFF_RECURSE_UNTRACKED_DIRS |
@@ -165,8 +163,6 @@ void test_diff_submodules__dirty_submodule_2(void)
 
 	git_diff_free(diff);
 
-	cl_git_pass(git_submodule_reload_all(g_repo, 1));
-
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
 	check_diff_patches(diff, expected_dirty);
 	git_diff_free(diff);
@@ -299,7 +295,6 @@ void test_diff_submodules__invalid_cache(void)
 
 	git_submodule_free(sm);
 
-	cl_git_pass(git_submodule_reload_all(g_repo, 1));
 	cl_git_pass(git_submodule_lookup(&sm, g_repo, smpath));
 
 	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
diff --git a/tests/submodule/lookup.c b/tests/submodule/lookup.c
index 36bde4f6e..86ba25c3a 100644
--- a/tests/submodule/lookup.c
+++ b/tests/submodule/lookup.c
@@ -1,7 +1,7 @@
 #include "clar_libgit2.h"
 #include "submodule_helpers.h"
-#include "posix.h"
 #include "git2/sys/repository.h"
+#include "fileops.h"
 
 static git_repository *g_repo = NULL;
 
@@ -115,13 +115,7 @@ void test_submodule_lookup__lookup_even_with_unborn_head(void)
 		&head, g_repo, "HEAD", "refs/heads/garbage", 1, NULL, NULL));
 	git_reference_free(head);
 
-	assert_submodule_exists(g_repo, "sm_unchanged");
-	assert_submodule_exists(g_repo, "sm_added_and_uncommited");
-	assert_submodule_exists(g_repo, "sm_gitmodules_only");
-	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
-	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
-	refute_submodule_exists(g_repo, "just_a_file", GIT_ENOTFOUND);
-	refute_submodule_exists(g_repo, "no_such_file", GIT_ENOTFOUND);
+	test_submodule_lookup__simple_lookup(); /* baseline should still pass */
 }
 
 void test_submodule_lookup__lookup_even_with_missing_index(void)
@@ -133,44 +127,62 @@ void test_submodule_lookup__lookup_even_with_missing_index(void)
 	git_repository_set_index(g_repo, idx);
 	git_index_free(idx);
 
-	assert_submodule_exists(g_repo, "sm_unchanged");
-	assert_submodule_exists(g_repo, "sm_added_and_uncommited");
-	assert_submodule_exists(g_repo, "sm_gitmodules_only");
-	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
-	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
-	refute_submodule_exists(g_repo, "just_a_file", GIT_ENOTFOUND);
-	refute_submodule_exists(g_repo, "no_such_file", GIT_ENOTFOUND);
+	test_submodule_lookup__simple_lookup(); /* baseline should still pass */
 }
 
 void test_submodule_lookup__just_added(void)
 {
 	git_submodule *sm;
+	git_buf snap1 = GIT_BUF_INIT, snap2 = GIT_BUF_INIT;
+
+	refute_submodule_exists(g_repo, "sm_just_added", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "sm_just_added_2", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "mismatch_name", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "mismatch_path", GIT_ENOTFOUND);
+	test_submodule_lookup__simple_lookup(); /* baseline */
 
-	cl_git_pass(git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_just_added", 1));
+	cl_git_pass(git_futils_readbuffer(&snap1, "submod2/.gitmodules"));
+
+	cl_git_pass(git_submodule_add_setup(&sm, g_repo,
+		"https://github.com/libgit2/libgit2.git", "sm_just_added", 1));
 	git_submodule_free(sm);
 	assert_submodule_exists(g_repo, "sm_just_added");
 
-	cl_git_pass(git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_just_added_2", 1));
+	cl_git_pass(git_submodule_add_setup(&sm, g_repo,
+		"https://github.com/libgit2/libgit2.git", "sm_just_added_2", 1));
 	assert_submodule_exists(g_repo, "sm_just_added_2");
 	git_submodule_free(sm);
 
-	cl_git_append2file("submod2/.gitmodules", "\n[submodule \"mismatch_name\"]\n\tpath = mismatch_path\n\turl = https://example.com/example.git\n\n");
+	cl_git_pass(git_futils_readbuffer(&snap2, "submod2/.gitmodules"));
 
-	cl_git_pass(git_submodule_reload_all(g_repo, 1));
+	cl_git_append2file(
+		"submod2/.gitmodules",
+		"\n[submodule \"mismatch_name\"]\n"
+		"\tpath = mismatch_path\n"
+		"\turl = https://example.com/example.git\n\n");
 
 	assert_submodule_exists(g_repo, "mismatch_name");
 	assert_submodule_exists(g_repo, "mismatch_path");
+	assert_submodule_exists(g_repo, "sm_just_added");
+	assert_submodule_exists(g_repo, "sm_just_added_2");
+	test_submodule_lookup__simple_lookup();
+
+	cl_git_rewritefile("submod2/.gitmodules", snap2.ptr);
+	git_buf_free(&snap2);
 
+	refute_submodule_exists(g_repo, "mismatch_name", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "mismatch_path", GIT_ENOTFOUND);
 	assert_submodule_exists(g_repo, "sm_just_added");
 	assert_submodule_exists(g_repo, "sm_just_added_2");
+	test_submodule_lookup__simple_lookup();
 
-	/* all the regular ones should still be working right, too */
+	cl_git_rewritefile("submod2/.gitmodules", snap1.ptr);
+	git_buf_free(&snap1);
 
-	assert_submodule_exists(g_repo, "sm_unchanged");
-	assert_submodule_exists(g_repo, "sm_added_and_uncommited");
-	assert_submodule_exists(g_repo, "sm_gitmodules_only");
-	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
-	refute_submodule_exists(g_repo, "just_a_dir", GIT_ENOTFOUND);
-	refute_submodule_exists(g_repo, "just_a_file", GIT_ENOTFOUND);
-	refute_submodule_exists(g_repo, "no_such_file", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "mismatch_name", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "mismatch_path", GIT_ENOTFOUND);
+	/* note error code change, because add_setup made a repo in the workdir */
+	refute_submodule_exists(g_repo, "sm_just_added", GIT_EEXISTS);
+	refute_submodule_exists(g_repo, "sm_just_added_2", GIT_EEXISTS);
+	test_submodule_lookup__simple_lookup();
 }
diff --git a/tests/submodule/nosubs.c b/tests/submodule/nosubs.c
index cabb53ead..e343c1620 100644
--- a/tests/submodule/nosubs.c
+++ b/tests/submodule/nosubs.c
@@ -69,7 +69,10 @@ void test_submodule_nosubs__reload_add_reload(void)
 
 	cl_git_pass(git_submodule_reload_all(repo, 0));
 
-	cl_git_pass(git_submodule_add_setup(&sm, repo, "https://github.com/libgit2/libgit2.git", "submodules/libgit2", 1));
+	/* try one add with a reload (to make sure no errors happen) */
+
+	cl_git_pass(git_submodule_add_setup(&sm, repo,
+		"https://github.com/libgit2/libgit2.git", "submodules/libgit2", 1));
 
 	cl_git_pass(git_submodule_reload_all(repo, 0));
 
@@ -79,6 +82,17 @@ void test_submodule_nosubs__reload_add_reload(void)
 	cl_git_pass(git_submodule_lookup(&sm, repo, "submodules/libgit2"));
 	cl_assert_equal_s("submodules/libgit2", git_submodule_name(sm));
 	git_submodule_free(sm);
+
+	/* try one add without a reload (to make sure cache inval works, too) */
+
+	cl_git_pass(git_submodule_add_setup(&sm, repo,
+		"https://github.com/libgit2/libgit2.git", "libgit2-again", 1));
+	cl_assert_equal_s("libgit2-again", git_submodule_name(sm));
+	git_submodule_free(sm);
+
+	cl_git_pass(git_submodule_lookup(&sm, repo, "libgit2-again"));
+	cl_assert_equal_s("libgit2-again", git_submodule_name(sm));
+	git_submodule_free(sm);
 }
 
 void test_submodule_nosubs__bad_gitmodules(void)
@@ -101,7 +115,7 @@ void test_submodule_nosubs__add_and_delete(void)
 	git_submodule *sm;
 	git_buf buf = GIT_BUF_INIT;
 
-	/* note the lack of calls to git_submodule_reload - this *should* work */
+	/* note lack of calls to git_submodule_reload_all - this *should* work */
 
 	cl_git_fail(git_submodule_lookup(NULL, repo, "libgit2"));
 	cl_git_fail(git_submodule_lookup(NULL, repo, "submodules/libgit2"));
-- 
cgit v1.2.3


From bb439de039dac456d4d99eb0a03d1914a984b27f Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Tue, 1 Apr 2014 16:37:19 -0400
Subject: Correct a stale reference to GIT_EBAREINDEX

---
 include/git2/index.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/index.h b/include/git2/index.h
index ae919e133..dad4234d9 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -159,7 +159,7 @@ typedef enum {
  *
  * Since there is no ODB or working directory behind this index,
  * any Index methods which rely on these (e.g. index_add) will
- * fail with the GIT_EBAREINDEX error code.
+ * fail with the GIT_ERROR error code.
  *
  * If you need to access the index of an actual repository,
  * use the `git_repository_index` wrapper.
-- 
cgit v1.2.3


From 8f4e5275e4f7f287b6782e70ff96c5de8fa4059e Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 1 Apr 2014 16:46:25 -0700
Subject: More tests and fix submodule index refresh

There was a little bug where the submodule cache thought that the
index date was out of date even when it wasn't that was resulting
in some extra scans of index data even when not needed.

Mostly this commit adds a bunch of new tests including adding and
removing submodules in the index and in the HEAD and seeing if we
can automatically pick them up when refreshing.
---
 src/index.c                         |  4 +-
 tests/submodule/lookup.c            | 91 +++++++++++++++++++++++++++++++++++--
 tests/submodule/submodule_helpers.c | 36 ++++++++++++---
 tests/submodule/submodule_helpers.h | 15 +++++-
 4 files changed, 132 insertions(+), 14 deletions(-)

diff --git a/src/index.c b/src/index.c
index 6cc8ea1a3..24e447928 100644
--- a/src/index.c
+++ b/src/index.c
@@ -524,7 +524,9 @@ int git_index__changed_relative_to(
 	if (git_index_read(index, false) < 0)
 		giterr_clear();
 
-	return (memcmp(&index->stamp, fs, sizeof(index->stamp)) == 0);
+	return (index->stamp.mtime != fs->mtime ||
+			index->stamp.size != fs->size ||
+			index->stamp.ino != fs->ino);
 }
 
 int git_index_write(git_index *index)
diff --git a/tests/submodule/lookup.c b/tests/submodule/lookup.c
index 86ba25c3a..34de5923e 100644
--- a/tests/submodule/lookup.c
+++ b/tests/submodule/lookup.c
@@ -130,18 +130,63 @@ void test_submodule_lookup__lookup_even_with_missing_index(void)
 	test_submodule_lookup__simple_lookup(); /* baseline should still pass */
 }
 
+static void baseline_tests(void)
+{
+	/* small baseline that should work even if we change the index or make
+	 * commits from the index
+	 */
+	assert_submodule_exists(g_repo, "sm_unchanged");
+	assert_submodule_exists(g_repo, "sm_gitmodules_only");
+	refute_submodule_exists(g_repo, "not-submodule", GIT_EEXISTS);
+}
+
+static void add_submodule_with_commit(const char *name)
+{
+	git_submodule *sm;
+	git_repository *smrepo;
+	git_index *idx;
+	git_buf p = GIT_BUF_INIT;
+
+	cl_git_pass(git_submodule_add_setup(&sm, g_repo,
+		"https://github.com/libgit2/libgit2.git", name, 1));
+
+	assert_submodule_exists(g_repo, name);
+
+	cl_git_pass(git_submodule_open(&smrepo, sm));
+	cl_git_pass(git_repository_index(&idx, smrepo));
+
+	cl_git_pass(git_buf_joinpath(&p, git_repository_workdir(smrepo), "file"));
+	cl_git_mkfile(p.ptr, "new file");
+	git_buf_free(&p);
+
+	cl_git_pass(git_index_add_bypath(idx, "file"));
+	cl_git_pass(git_index_write(idx));
+	git_index_free(idx);
+
+	cl_repo_commit_from_index(NULL, smrepo, NULL, 0, "initial commit");
+	git_repository_free(smrepo);
+
+	cl_git_pass(git_submodule_add_finalize(sm));
+
+	git_submodule_free(sm);
+}
+
 void test_submodule_lookup__just_added(void)
 {
 	git_submodule *sm;
 	git_buf snap1 = GIT_BUF_INIT, snap2 = GIT_BUF_INIT;
+	git_reference *original_head = NULL;
 
 	refute_submodule_exists(g_repo, "sm_just_added", GIT_ENOTFOUND);
 	refute_submodule_exists(g_repo, "sm_just_added_2", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "sm_just_added_idx", GIT_ENOTFOUND);
+	refute_submodule_exists(g_repo, "sm_just_added_head", GIT_ENOTFOUND);
 	refute_submodule_exists(g_repo, "mismatch_name", GIT_ENOTFOUND);
 	refute_submodule_exists(g_repo, "mismatch_path", GIT_ENOTFOUND);
-	test_submodule_lookup__simple_lookup(); /* baseline */
+	baseline_tests();
 
 	cl_git_pass(git_futils_readbuffer(&snap1, "submod2/.gitmodules"));
+	cl_git_pass(git_repository_head(&original_head, g_repo));
 
 	cl_git_pass(git_submodule_add_setup(&sm, g_repo,
 		"https://github.com/libgit2/libgit2.git", "sm_just_added", 1));
@@ -151,8 +196,16 @@ void test_submodule_lookup__just_added(void)
 	cl_git_pass(git_submodule_add_setup(&sm, g_repo,
 		"https://github.com/libgit2/libgit2.git", "sm_just_added_2", 1));
 	assert_submodule_exists(g_repo, "sm_just_added_2");
+	cl_git_fail(git_submodule_add_finalize(sm)); /* fails if no HEAD */
 	git_submodule_free(sm);
 
+	add_submodule_with_commit("sm_just_added_head");
+	cl_repo_commit_from_index(NULL, g_repo, NULL, 0, "commit new sm to head");
+	assert_submodule_exists(g_repo, "sm_just_added_head");
+
+	add_submodule_with_commit("sm_just_added_idx");
+	assert_submodule_exists(g_repo, "sm_just_added_idx");
+
 	cl_git_pass(git_futils_readbuffer(&snap2, "submod2/.gitmodules"));
 
 	cl_git_append2file(
@@ -165,7 +218,9 @@ void test_submodule_lookup__just_added(void)
 	assert_submodule_exists(g_repo, "mismatch_path");
 	assert_submodule_exists(g_repo, "sm_just_added");
 	assert_submodule_exists(g_repo, "sm_just_added_2");
-	test_submodule_lookup__simple_lookup();
+	assert_submodule_exists(g_repo, "sm_just_added_idx");
+	assert_submodule_exists(g_repo, "sm_just_added_head");
+	baseline_tests();
 
 	cl_git_rewritefile("submod2/.gitmodules", snap2.ptr);
 	git_buf_free(&snap2);
@@ -174,7 +229,9 @@ void test_submodule_lookup__just_added(void)
 	refute_submodule_exists(g_repo, "mismatch_path", GIT_ENOTFOUND);
 	assert_submodule_exists(g_repo, "sm_just_added");
 	assert_submodule_exists(g_repo, "sm_just_added_2");
-	test_submodule_lookup__simple_lookup();
+	assert_submodule_exists(g_repo, "sm_just_added_idx");
+	assert_submodule_exists(g_repo, "sm_just_added_head");
+	baseline_tests();
 
 	cl_git_rewritefile("submod2/.gitmodules", snap1.ptr);
 	git_buf_free(&snap1);
@@ -184,5 +241,31 @@ void test_submodule_lookup__just_added(void)
 	/* note error code change, because add_setup made a repo in the workdir */
 	refute_submodule_exists(g_repo, "sm_just_added", GIT_EEXISTS);
 	refute_submodule_exists(g_repo, "sm_just_added_2", GIT_EEXISTS);
-	test_submodule_lookup__simple_lookup();
+	/* these still exist in index and head respectively */
+	assert_submodule_exists(g_repo, "sm_just_added_idx");
+	assert_submodule_exists(g_repo, "sm_just_added_head");
+	baseline_tests();
+
+	{
+		git_index *idx;
+		cl_git_pass(git_repository_index(&idx, g_repo));
+		cl_git_pass(git_index_remove_bypath(idx, "sm_just_added_idx"));
+		cl_git_pass(git_index_remove_bypath(idx, "sm_just_added_head"));
+		cl_git_pass(git_index_write(idx));
+		git_index_free(idx);
+	}
+
+	refute_submodule_exists(g_repo, "sm_just_added_idx", GIT_EEXISTS);
+	assert_submodule_exists(g_repo, "sm_just_added_head");
+
+	{
+		git_signature *sig;
+		cl_git_pass(git_signature_now(&sig, "resetter", "resetter@email.com"));
+		cl_git_pass(git_reference_create(NULL, g_repo, "refs/heads/master", git_reference_target(original_head), 1, sig, "move head back"));
+		git_signature_free(sig);
+		git_reference_free(original_head);
+	}
+
+	refute_submodule_exists(g_repo, "sm_just_added_head", GIT_EEXISTS);
 }
+
diff --git a/tests/submodule/submodule_helpers.c b/tests/submodule/submodule_helpers.c
index 546f0913a..50aa97568 100644
--- a/tests/submodule/submodule_helpers.c
+++ b/tests/submodule/submodule_helpers.c
@@ -126,20 +126,26 @@ git_repository *setup_fixture_submod2(void)
 	return repo;
 }
 
-void assert_submodule_exists(git_repository *repo, const char *name)
+void assert__submodule_exists(
+	git_repository *repo, const char *name,
+	const char *msg, const char *file, int line)
 {
 	git_submodule *sm;
-	cl_git_pass(git_submodule_lookup(&sm, repo, name));
-	cl_assert(sm);
+	int error = git_submodule_lookup(&sm, repo, name);
+	if (error)
+		cl_git_report_failure(error, file, line, msg);
+	cl_assert_at_line(sm != NULL, file, line);
 	git_submodule_free(sm);
 }
 
-void refute_submodule_exists(
-	git_repository *repo, const char *name, int expected_error)
+void refute__submodule_exists(
+	git_repository *repo, const char *name, int expected_error,
+	const char *msg, const char *file, int line)
 {
 	git_submodule *sm;
-	cl_assert_equal_i(
-		expected_error, git_submodule_lookup(&sm, repo, name));
+	clar__assert_equal(
+		file, line, msg, 1, "%i",
+		expected_error, (int)(git_submodule_lookup(&sm, repo, name)));
 }
 
 unsigned int get_submodule_status(git_repository *repo, const char *name)
@@ -154,3 +160,19 @@ unsigned int get_submodule_status(git_repository *repo, const char *name)
 
 	return status;
 }
+
+static int print_submodules(git_submodule *sm, const char *name, void *p)
+{
+	unsigned int loc = 0;
+	GIT_UNUSED(p);
+	git_submodule_location(&loc, sm);
+	fprintf(stderr, "# submodule %s (at %s) flags %x\n",
+		name, git_submodule_path(sm), loc);
+	return 0;
+}
+
+void dump_submodules(git_repository *repo)
+{
+	git_submodule_foreach(repo, print_submodules, NULL);
+}
+
diff --git a/tests/submodule/submodule_helpers.h b/tests/submodule/submodule_helpers.h
index ec5510e3c..4b2620bfa 100644
--- a/tests/submodule/submodule_helpers.h
+++ b/tests/submodule/submodule_helpers.h
@@ -6,5 +6,16 @@ extern git_repository *setup_fixture_submod2(void);
 
 extern unsigned int get_submodule_status(git_repository *, const char *);
 
-extern void assert_submodule_exists(git_repository *, const char *);
-extern void refute_submodule_exists(git_repository *, const char *, int err);
+extern void assert__submodule_exists(
+	git_repository *, const char *, const char *, const char *, int);
+
+#define assert_submodule_exists(repo,name)								\
+	assert__submodule_exists(repo, name, "git_submodule_lookup(" #name ") failed", __FILE__, __LINE__)
+
+extern void refute__submodule_exists(
+	git_repository *, const char *, int err, const char *, const char *, int);
+
+#define refute_submodule_exists(repo,name,code) \
+	refute__submodule_exists(repo, name, code, "expected git_submodule_lookup(" #name ") to fail with error " #code, __FILE__, __LINE__)
+
+extern void dump_submodules(git_repository *repo);
-- 
cgit v1.2.3


From ea1ca3c9216ad72b24a198cfdf4c4eb0d037462f Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 1 Apr 2014 21:30:52 -0700
Subject: Fix skipping content of contained repos

When doing a diff for use in status, we should never show the
content of a git repository contained inside another one.  The
logic to do this was looking for a .git directory and so when a
gitlink plain .git file was used, it was failing to exclude the
directory content.
---
 src/diff.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/diff.c b/src/diff.c
index 25c5937e6..484273f4a 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -880,8 +880,10 @@ static int handle_unmatched_new_item(
 			git_buf *full = NULL;
 			if (git_iterator_current_workdir_path(&full, info->new_iter) < 0)
 				return -1;
-			if (full && git_path_contains_dir(full, DOT_GIT))
+			if (full && git_path_contains(full, DOT_GIT)) {
+				/* TODO: warning if not a valid git repository */
 				recurse_into_dir = false;
+			}
 		}
 
 		/* still have to look into untracked directories to match core git -
-- 
cgit v1.2.3


From a574d584df61f56715281feb6fcf3b7578ead0c6 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 1 Apr 2014 21:32:06 -0700
Subject: New tests of status for repo inside repo

---
 tests/status/status_helpers.h |  10 +++
 tests/status/submodules.c     | 197 +++++++++++++++++++++++++++++++++++++-----
 2 files changed, 183 insertions(+), 24 deletions(-)

diff --git a/tests/status/status_helpers.h b/tests/status/status_helpers.h
index f1f009e02..242076cc9 100644
--- a/tests/status/status_helpers.h
+++ b/tests/status/status_helpers.h
@@ -8,9 +8,19 @@ typedef struct {
 	const unsigned int* expected_statuses;
 	const char** expected_paths;
 	int expected_entry_count;
+	const char *file;
+	int line;
 	bool debug;
 } status_entry_counts;
 
+#define status_counts_init(counts, paths, statuses) do { \
+	memset(&(counts), 0, sizeof(counts)); \
+	(counts).expected_statuses = (statuses); \
+	(counts).expected_paths = (paths); \
+	(counts).file = __FILE__; \
+	(counts).line = __LINE__; \
+	} while (0)
+
 /* cb_status__normal takes payload of "status_entry_counts *" */
 
 extern int cb_status__normal(
diff --git a/tests/status/submodules.c b/tests/status/submodules.c
index 8575f9f2d..6d0d63a5f 100644
--- a/tests/status/submodules.c
+++ b/tests/status/submodules.c
@@ -72,8 +72,15 @@ static int cb_status__match(const char *p, unsigned int s, void *payload)
 	status_entry_counts *counts = payload;
 	int idx = counts->entry_count++;
 
-	cl_assert_equal_s(counts->expected_paths[idx], p);
-	cl_assert(counts->expected_statuses[idx] == s);
+	clar__assert_equal(
+		counts->file, counts->line,
+		"Status path mismatch", 1,
+		"%s", counts->expected_paths[idx], p);
+
+	clar__assert_equal(
+		counts->file, counts->line,
+		"Status code mismatch", 1,
+		"%o", counts->expected_statuses[idx], s);
 
 	return 0;
 }
@@ -88,13 +95,9 @@ void test_status_submodules__1(void)
 	cl_assert(git_path_isdir("submodules/testrepo/.git"));
 	cl_assert(git_path_isfile("submodules/.gitmodules"));
 
-	memset(&counts, 0, sizeof(counts));
-	counts.expected_paths = expected_files;
-	counts.expected_statuses = expected_status;
+	status_counts_init(counts, expected_files, expected_status);
 
-	cl_git_pass(
-		git_status_foreach(g_repo, cb_status__match, &counts)
-	);
+	cl_git_pass( git_status_foreach(g_repo, cb_status__match, &counts) );
 
 	cl_assert_equal_i(6, counts.entry_count);
 }
@@ -146,24 +149,19 @@ void test_status_submodules__moved_head(void)
 
 	/* first do a normal status, which should now include the submodule */
 
-	memset(&counts, 0, sizeof(counts));
-	counts.expected_paths = expected_files_with_sub;
-	counts.expected_statuses = expected_status_with_sub;
-
 	opts.flags = GIT_STATUS_OPT_DEFAULTS;
 
+	status_counts_init(
+		counts, expected_files_with_sub, expected_status_with_sub);
 	cl_git_pass(
 		git_status_foreach_ext(g_repo, &opts, cb_status__match, &counts));
 	cl_assert_equal_i(7, counts.entry_count);
 
 	/* try again with EXCLUDE_SUBMODULES which should skip it */
 
-	memset(&counts, 0, sizeof(counts));
-	counts.expected_paths = expected_files;
-	counts.expected_statuses = expected_status;
-
 	opts.flags = GIT_STATUS_OPT_DEFAULTS | GIT_STATUS_OPT_EXCLUDE_SUBMODULES;
 
+	status_counts_init(counts, expected_files, expected_status);
 	cl_git_pass(
 		git_status_foreach_ext(g_repo, &opts, cb_status__match, &counts));
 	cl_assert_equal_i(6, counts.entry_count);
@@ -201,24 +199,19 @@ void test_status_submodules__dirty_workdir_only(void)
 
 	/* first do a normal status, which should now include the submodule */
 
-	memset(&counts, 0, sizeof(counts));
-	counts.expected_paths = expected_files_with_sub;
-	counts.expected_statuses = expected_status_with_sub;
-
 	opts.flags = GIT_STATUS_OPT_DEFAULTS;
 
+	status_counts_init(
+		counts, expected_files_with_sub, expected_status_with_sub);
 	cl_git_pass(
 		git_status_foreach_ext(g_repo, &opts, cb_status__match, &counts));
 	cl_assert_equal_i(7, counts.entry_count);
 
 	/* try again with EXCLUDE_SUBMODULES which should skip it */
 
-	memset(&counts, 0, sizeof(counts));
-	counts.expected_paths = expected_files;
-	counts.expected_statuses = expected_status;
-
 	opts.flags = GIT_STATUS_OPT_DEFAULTS | GIT_STATUS_OPT_EXCLUDE_SUBMODULES;
 
+	status_counts_init(counts, expected_files, expected_status);
 	cl_git_pass(
 		git_status_foreach_ext(g_repo, &opts, cb_status__match, &counts));
 	cl_assert_equal_i(6, counts.entry_count);
@@ -240,3 +233,159 @@ void test_status_submodules__uninitialized(void)
 	git_repository_free(cloned_repo);
 	cl_git_sandbox_cleanup();
 }
+
+void test_status_submodules__contained_untracked_repo(void)
+{
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	status_entry_counts counts;
+	git_repository *contained;
+	static const char *expected_files_not_ignored[] = {
+		".gitmodules",
+		"added",
+		"deleted",
+		"modified",
+		"untracked"
+	};
+	static unsigned int expected_status_not_ignored[] = {
+		GIT_STATUS_WT_MODIFIED,
+		GIT_STATUS_INDEX_NEW,
+		GIT_STATUS_INDEX_DELETED,
+		GIT_STATUS_WT_MODIFIED,
+		GIT_STATUS_WT_NEW,
+	};
+	static const char *expected_files_with_untracked[] = {
+		".gitmodules",
+		"added",
+		"deleted",
+		"dir/file.md",
+		"modified",
+		"untracked"
+	};
+	static const char *expected_files_with_untracked_dir[] = {
+		".gitmodules",
+		"added",
+		"deleted",
+		"dir/",
+		"modified",
+		"untracked"
+	};
+	static unsigned int expected_status_with_untracked[] = {
+		GIT_STATUS_WT_MODIFIED,
+		GIT_STATUS_INDEX_NEW,
+		GIT_STATUS_INDEX_DELETED,
+		GIT_STATUS_WT_NEW,
+		GIT_STATUS_WT_MODIFIED,
+		GIT_STATUS_WT_NEW
+	};
+
+	g_repo = setup_fixture_submodules();
+
+	/* skip empty directory */
+
+	cl_must_pass(p_mkdir("submodules/dir", 0777));
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED;
+
+	status_counts_init(
+		counts, expected_files_not_ignored, expected_status_not_ignored);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(5, counts.entry_count);
+
+	/* still skipping because empty == ignored */
+
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
+
+	status_counts_init(
+		counts, expected_files_not_ignored, expected_status_not_ignored);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(5, counts.entry_count);
+
+	/* find non-ignored contents of directory */
+
+	cl_git_mkfile("submodules/dir/file.md", "hello");
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
+
+	status_counts_init(
+		counts, expected_files_with_untracked, expected_status_with_untracked);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(6, counts.entry_count);
+
+	/* but skip if all content is ignored */
+
+	cl_git_append2file("submodules/.git/info/exclude", "\n*.md\n\n");
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
+
+	status_counts_init(
+		counts, expected_files_not_ignored, expected_status_not_ignored);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(5, counts.entry_count);
+
+	/* same is true if it contains a git link */
+
+	cl_git_mkfile("submodules/dir/.git", "gitlink: ../.git");
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
+
+	status_counts_init(
+		counts, expected_files_not_ignored, expected_status_not_ignored);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(5, counts.entry_count);
+
+	/* but if it contains tracked files, it should just show up as a
+	 * directory and exclude the files in it
+	 */
+
+	cl_git_mkfile("submodules/dir/another_file", "hello");
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
+
+	status_counts_init(
+		counts, expected_files_with_untracked_dir,
+		expected_status_with_untracked);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(6, counts.entry_count);
+
+	/* that applies to a git repo with a .git directory too */
+
+	cl_must_pass(p_unlink("submodules/dir/.git"));
+	cl_git_pass(git_repository_init(&contained, "submodules/dir", false));
+	git_repository_free(contained);
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS;
+
+	status_counts_init(
+		counts, expected_files_with_untracked_dir,
+		expected_status_with_untracked);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(6, counts.entry_count);
+
+	/* same result even if we don't recurse into subdirectories */
+
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED;
+
+	status_counts_init(
+		counts, expected_files_with_untracked_dir,
+		expected_status_with_untracked);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(6, counts.entry_count);
+
+	/* and if we remove the untracked file, it goes back to ignored */
+
+	cl_must_pass(p_unlink("submodules/dir/another_file"));
+
+	status_counts_init(
+		counts, expected_files_not_ignored, expected_status_not_ignored);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(5, counts.entry_count);
+}
-- 
cgit v1.2.3


From d1a0900442a235d8389d968a70b196a1b0f1ab7b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 1 Apr 2014 21:58:48 -0700
Subject: Skip blame libgit2 test if not in libgit2 repo

One blame test replies on being run from within the libgit2
repository to leverage having a longer history to play with, but
some bundled versions of libgit2 don't have the whole libgit2
history.  This just skips that test if the repository can't be
opened.
---
 tests/blame/simple.c | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/tests/blame/simple.c b/tests/blame/simple.c
index 11ff4cd19..c0d91058a 100644
--- a/tests/blame/simple.c
+++ b/tests/blame/simple.c
@@ -135,13 +135,22 @@ void test_blame_simple__trivial_libgit2(void)
 	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
 	git_object *obj;
 
-	cl_git_pass(git_repository_open(&g_repo, cl_fixture("../..")));
+	/* If we can't open the libgit2 repo, just skip this test */
+	if (git_repository_open(&g_repo, cl_fixture("../..")) < 0) {
+		giterr_clear();
+		return;
+	}
 
 	/* This test can't work on a shallow clone */
 	if (git_repository_is_shallow(g_repo))
 		return;
 
-	cl_git_pass(git_revparse_single(&obj, g_repo, "359fc2d"));
+	/* If somehow it is not a valid libgit2 repo, just move along */
+	if (git_revparse_single(&obj, g_repo, "359fc2d") < 0) {
+		giterr_clear();
+		return;
+	}
+
 	git_oid_cpy(&opts.newest_commit, git_object_id(obj));
 	git_object_free(obj);
 
-- 
cgit v1.2.3


From ddc66e27b605cdfd0edf25af5cf7fb4924fb80e1 Mon Sep 17 00:00:00 2001
From: Rob Rix <rob.rix@github.com>
Date: Wed, 2 Apr 2014 08:02:43 -0400
Subject: Give the correct name for the function in the doc.

Per @carlosmn, git_index_add is now named git_index_add_bypath.
---
 include/git2/index.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/git2/index.h b/include/git2/index.h
index dad4234d9..9a7ad28a6 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -158,8 +158,8 @@ typedef enum {
  * to back it.
  *
  * Since there is no ODB or working directory behind this index,
- * any Index methods which rely on these (e.g. index_add) will
- * fail with the GIT_ERROR error code.
+ * any Index methods which rely on these (e.g. index_add_bypath)
+ * will fail with the GIT_ERROR error code.
  *
  * If you need to access the index of an actual repository,
  * use the `git_repository_index` wrapper.
-- 
cgit v1.2.3


From ada157b2375bea8ed0c7a71320a3325a9903ebd7 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 2 Apr 2014 07:45:16 -0700
Subject: Add warning when skipping blame test

---
 tests/blame/simple.c | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/tests/blame/simple.c b/tests/blame/simple.c
index c0d91058a..86e8fe264 100644
--- a/tests/blame/simple.c
+++ b/tests/blame/simple.c
@@ -135,18 +135,13 @@ void test_blame_simple__trivial_libgit2(void)
 	git_blame_options opts = GIT_BLAME_OPTIONS_INIT;
 	git_object *obj;
 
-	/* If we can't open the libgit2 repo, just skip this test */
-	if (git_repository_open(&g_repo, cl_fixture("../..")) < 0) {
-		giterr_clear();
-		return;
-	}
-
-	/* This test can't work on a shallow clone */
-	if (git_repository_is_shallow(g_repo))
-		return;
-
-	/* If somehow it is not a valid libgit2 repo, just move along */
-	if (git_revparse_single(&obj, g_repo, "359fc2d") < 0) {
+	/* If we can't open the libgit2 repo or if it isn't a full repo
+	 * with proper history, just skip this test */
+	if (git_repository_open(&g_repo, cl_fixture("../..")) < 0 ||
+		git_repository_is_shallow(g_repo) ||
+		git_revparse_single(&obj, g_repo, "359fc2d") < 0)
+	{
+		printf("NOT INSIDE VALID LIBGIT2 REPO; skipping blame test\n");
 		giterr_clear();
 		return;
 	}
-- 
cgit v1.2.3


From 49653665d11cbb5d14d5ad19c327798c98b0cfd1 Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Wed, 2 Apr 2014 18:21:41 +0200
Subject: checkout: Fix submodule_is_config_only's return value

---
 src/checkout.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/checkout.c b/src/checkout.c
index 468c8dc6e..141fc1331 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -339,7 +339,7 @@ static bool submodule_is_config_only(
 
 	git_submodule_free(sm);
 
-	return false;
+	return rval;
 }
 
 static int checkout_action_with_wd(
-- 
cgit v1.2.3


From 0f65733b0855ff9ea838c7d06efdf544e039e05e Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Wed, 2 Apr 2014 18:50:47 +0200
Subject: Clar: skip tests

---
 tests/blame/simple.c | 16 ++++++-------
 tests/clar.c         | 53 ++++++++++++++++++++++++-------------------
 tests/clar.h         |  9 ++++++++
 tests/clar/print.h   | 10 +++++++--
 tests/online/clone.c | 11 ++-------
 tests/online/push.c  | 63 ++++++++++++++++++++++++++--------------------------
 6 files changed, 89 insertions(+), 73 deletions(-)

diff --git a/tests/blame/simple.c b/tests/blame/simple.c
index 86e8fe264..83e5e056b 100644
--- a/tests/blame/simple.c
+++ b/tests/blame/simple.c
@@ -137,14 +137,14 @@ void test_blame_simple__trivial_libgit2(void)
 
 	/* If we can't open the libgit2 repo or if it isn't a full repo
 	 * with proper history, just skip this test */
-	if (git_repository_open(&g_repo, cl_fixture("../..")) < 0 ||
-		git_repository_is_shallow(g_repo) ||
-		git_revparse_single(&obj, g_repo, "359fc2d") < 0)
-	{
-		printf("NOT INSIDE VALID LIBGIT2 REPO; skipping blame test\n");
-		giterr_clear();
-		return;
-	}
+	if (git_repository_open(&g_repo, cl_fixture("../..")) < 0)
+		cl_skip();
+
+	if (git_repository_is_shallow(g_repo))
+		cl_skip();
+
+	if (git_revparse_single(&obj, g_repo, "359fc2d") < 0)
+		cl_skip();
 
 	git_oid_cpy(&opts.newest_commit, git_object_id(obj));
 	git_object_free(obj);
diff --git a/tests/clar.c b/tests/clar.c
index 2f81a1923..154644783 100644
--- a/tests/clar.c
+++ b/tests/clar.c
@@ -109,10 +109,11 @@ static struct {
 	int argc;
 	char **argv;
 
+	enum cl_test_status test_status;
 	const char *active_test;
 	const char *active_suite;
 
-	int suite_errors;
+	int total_skipped;
 	int total_errors;
 
 	int tests_ran;
@@ -150,7 +151,7 @@ struct clar_suite {
 static void clar_print_init(int test_count, int suite_count, const char *suite_names);
 static void clar_print_shutdown(int test_count, int suite_count, int error_count);
 static void clar_print_error(int num, const struct clar_error *error);
-static void clar_print_ontest(const char *test_name, int test_number, int failed);
+static void clar_print_ontest(const char *test_name, int test_number, enum cl_test_status failed);
 static void clar_print_onsuite(const char *suite_name, int suite_index);
 static void clar_print_onabort(const char *msg, ...);
 
@@ -186,8 +187,7 @@ clar_run_test(
 	const struct clar_func *initialize,
 	const struct clar_func *cleanup)
 {
-	int error_st = _clar.suite_errors;
-
+	_clar.test_status = CL_TEST_OK;
 	_clar.trampoline_enabled = 1;
 
 	if (setjmp(_clar.trampoline) == 0) {
@@ -211,14 +211,11 @@ clar_run_test(
 	_clar.local_cleanup = NULL;
 	_clar.local_cleanup_payload = NULL;
 
-	if (_clar.report_errors_only)
+	if (_clar.report_errors_only) {
 		clar_report_errors();
-	else
-		clar_print_ontest(
-			test->name,
-			_clar.tests_ran,
-			(_clar.suite_errors > error_st)
-		);
+	} else {
+		clar_print_ontest(test->name, _clar.tests_ran, _clar.test_status);
+	}
 }
 
 static void
@@ -237,7 +234,6 @@ clar_run_suite(const struct clar_suite *suite, const char *filter)
 		clar_print_onsuite(suite->name, ++_clar.suites_ran);
 
 	_clar.active_suite = suite->name;
-	_clar.suite_errors = 0;
 
 	if (filter) {
 		size_t suitelen = strlen(suite->name);
@@ -413,6 +409,25 @@ clar_test(int argc, char **argv)
 	return errors;
 }
 
+static void abort_test(void)
+{
+	if (!_clar.trampoline_enabled) {
+		clar_print_onabort(
+				"Fatal error: a cleanup method raised an exception.");
+		clar_report_errors();
+		exit(-1);
+	}
+
+	longjmp(_clar.trampoline, -1);
+}
+
+void clar__skip(void)
+{
+	_clar.test_status = CL_TEST_SKIP;
+	_clar.total_skipped++;
+	abort_test();
+}
+
 void clar__fail(
 	const char *file,
 	int line,
@@ -440,19 +455,11 @@ void clar__fail(
 	if (description != NULL)
 		error->description = strdup(description);
 
-	_clar.suite_errors++;
 	_clar.total_errors++;
+	_clar.test_status = CL_TEST_FAILURE;
 
-	if (should_abort) {
-		if (!_clar.trampoline_enabled) {
-			clar_print_onabort(
-				"Fatal error: a cleanup method raised an exception.");
-			clar_report_errors();
-			exit(-1);
-		}
-
-		longjmp(_clar.trampoline, -1);
-	}
+	if (should_abort)
+		abort_test();
 }
 
 void clar__assert(
diff --git a/tests/clar.h b/tests/clar.h
index 81263051d..f9df72e8c 100644
--- a/tests/clar.h
+++ b/tests/clar.h
@@ -9,6 +9,12 @@
 
 #include <stdlib.h>
 
+enum cl_test_status {
+	CL_TEST_OK,
+	CL_TEST_FAILURE,
+	CL_TEST_SKIP
+};
+
 void clar_test_init(int argc, char *argv[]);
 int clar_test_run(void);
 void clar_test_shutdown(void);
@@ -60,6 +66,8 @@ void cl_fixture_cleanup(const char *fixture_name);
 #define cl_fail(desc) clar__fail(__FILE__, __LINE__, "Test failed.", desc, 1)
 #define cl_warning(desc) clar__fail(__FILE__, __LINE__, "Warning during test execution:", desc, 0)
 
+#define cl_skip() clar__skip()
+
 /**
  * Typed assertion macros
  */
@@ -77,6 +85,7 @@ void cl_fixture_cleanup(const char *fixture_name);
 
 #define cl_assert_equal_p(p1,p2) clar__assert_equal(__FILE__,__LINE__,"Pointer mismatch: " #p1 " != " #p2, 1, "%p", (p1), (p2))
 
+void clar__skip(void);
 
 void clar__fail(
 	const char *file,
diff --git a/tests/clar/print.h b/tests/clar/print.h
index 368016f2f..6529b6b4c 100644
--- a/tests/clar/print.h
+++ b/tests/clar/print.h
@@ -35,11 +35,17 @@ static void clar_print_error(int num, const struct clar_error *error)
 	fflush(stdout);
 }
 
-static void clar_print_ontest(const char *test_name, int test_number, int failed)
+static void clar_print_ontest(const char *test_name, int test_number, enum cl_test_status status)
 {
 	(void)test_name;
 	(void)test_number;
-	printf("%c", failed ? 'F' : '.');
+
+	switch(status) {
+	case CL_TEST_OK: printf("."); break;
+	case CL_TEST_FAILURE: printf("F"); break;
+	case CL_TEST_SKIP: printf("S"); break;
+	}
+
 	fflush(stdout);
 }
 
diff --git a/tests/online/clone.c b/tests/online/clone.c
index 9919e8b06..6e0e63950 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -200,15 +200,8 @@ void test_online_clone__cred_callback_failure_return_code_is_tunnelled(void)
 	const char *remote_url = cl_getenv("GITTEST_REMOTE_URL");
 	const char *remote_user = cl_getenv("GITTEST_REMOTE_USER");
 
-	if (!remote_url) {
-		printf("GITTEST_REMOTE_URL unset; skipping clone test\n");
-		return;
-	}
-
-	if (!remote_user) {
-		printf("GITTEST_REMOTE_USER unset; skipping clone test\n");
-		return;
-	}
+	if (!remote_url || !remote_user)
+		clar__skip();
 
 	g_options.remote_callbacks.credentials = cred_failure_cb;
 
diff --git a/tests/online/push.c b/tests/online/push.c
index 55b97b282..716e2e993 100644
--- a/tests/online/push.c
+++ b/tests/online/push.c
@@ -315,46 +315,47 @@ void test_online_push__initialize(void)
 	_remote_default = cl_getenv("GITTEST_REMOTE_DEFAULT");
 	_remote = NULL;
 
-	if (_remote_url) {
-		cl_git_pass(git_remote_create(&_remote, _repo, "test", _remote_url));
+	/* Skip the test if we're missing the remote URL */
+	if (!_remote_url)
+		cl_skip();
 
-		record_callbacks_data_clear(&_record_cbs_data);
-		git_remote_set_callbacks(_remote, &_record_cbs);
+	cl_git_pass(git_remote_create(&_remote, _repo, "test", _remote_url));
 
-		cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_PUSH));
+	record_callbacks_data_clear(&_record_cbs_data);
+	git_remote_set_callbacks(_remote, &_record_cbs);
 
-		/* Clean up previously pushed branches.  Fails if receive.denyDeletes is
-		 * set on the remote.  Also, on Git 1.7.0 and newer, you must run
-		 * 'git config receive.denyDeleteCurrent ignore' in the remote repo in
-		 * order to delete the remote branch pointed to by HEAD (usually master).
-		 * See: https://raw.github.com/git/git/master/Documentation/RelNotes/1.7.0.txt
-		 */
-		cl_git_pass(git_remote_ls(&heads, &heads_len, _remote));
-		cl_git_pass(create_deletion_refspecs(&delete_specs, heads, heads_len));
-		if (delete_specs.length) {
-			git_push *push;
+	cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_PUSH));
 
-			cl_git_pass(git_push_new(&push, _remote));
+	/* Clean up previously pushed branches.  Fails if receive.denyDeletes is
+	 * set on the remote.  Also, on Git 1.7.0 and newer, you must run
+	 * 'git config receive.denyDeleteCurrent ignore' in the remote repo in
+	 * order to delete the remote branch pointed to by HEAD (usually master).
+	 * See: https://raw.github.com/git/git/master/Documentation/RelNotes/1.7.0.txt
+	 */
+	cl_git_pass(git_remote_ls(&heads, &heads_len, _remote));
+	cl_git_pass(create_deletion_refspecs(&delete_specs, heads, heads_len));
+	if (delete_specs.length) {
+		git_push *push;
 
-			git_vector_foreach(&delete_specs, i, curr_del_spec) {
-				git_push_add_refspec(push, curr_del_spec);
-				git__free(curr_del_spec);
-			}
+		cl_git_pass(git_push_new(&push, _remote));
 
-			cl_git_pass(git_push_finish(push));
-			git_push_free(push);
+		git_vector_foreach(&delete_specs, i, curr_del_spec) {
+			git_push_add_refspec(push, curr_del_spec);
+			git__free(curr_del_spec);
 		}
 
-		git_remote_disconnect(_remote);
-		git_vector_free(&delete_specs);
+		cl_git_pass(git_push_finish(push));
+		git_push_free(push);
+	}
 
-		/* Now that we've deleted everything, fetch from the remote */
-		cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_FETCH));
-		cl_git_pass(git_remote_download(_remote));
-		cl_git_pass(git_remote_update_tips(_remote, NULL, NULL));
-		git_remote_disconnect(_remote);
-	} else
-		printf("GITTEST_REMOTE_URL unset; skipping push test\n");
+	git_remote_disconnect(_remote);
+	git_vector_free(&delete_specs);
+
+	/* Now that we've deleted everything, fetch from the remote */
+	cl_git_pass(git_remote_connect(_remote, GIT_DIRECTION_FETCH));
+	cl_git_pass(git_remote_download(_remote));
+	cl_git_pass(git_remote_update_tips(_remote, NULL, NULL));
+	git_remote_disconnect(_remote);
 }
 
 void test_online_push__cleanup(void)
-- 
cgit v1.2.3


From 6f6be8fe4199b5bccad00a9a3ab8b078286c1837 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 2 Apr 2014 18:14:02 +0200
Subject: remote: write tests for cloning from an empty repo

Cloning from an empty repo must set master's upstream to origin's
master, even if neither of them exist.

Fetching from a non-empty origin must then mark the master branch
for-merge. This currently fails.
---
 tests/clone/nonetwork.c          | 34 ++++++++++++++++++++++++++++++++++
 tests/fetchhead/fetchhead_data.h |  1 -
 tests/fetchhead/nonetwork.c      | 36 ++++++++++++++++++++++++++++++++++++
 3 files changed, 70 insertions(+), 1 deletion(-)

diff --git a/tests/clone/nonetwork.c b/tests/clone/nonetwork.c
index 68a277448..4bdc6e13b 100644
--- a/tests/clone/nonetwork.c
+++ b/tests/clone/nonetwork.c
@@ -282,3 +282,37 @@ void test_clone_nonetwork__clone_into_updates_reflog_properly(void)
 	git_remote_free(remote);
 	git_signature_free(sig);
 }
+
+static void cleanup_repository(void *path)
+{
+	if (g_repo) {
+		git_repository_free(g_repo);
+		g_repo = NULL;
+	}
+
+	cl_fixture_cleanup((const char *)path);
+}
+
+void test_clone_nonetwork__clone_from_empty_sets_upstream(void)
+{
+	git_config *config;
+	git_repository *repo;
+	const char *str;
+
+	/* Create an empty repo to clone from */
+	cl_set_cleanup(&cleanup_repository, "./test1");
+	cl_git_pass(git_repository_init(&g_repo, "./test1", 0));
+	cl_set_cleanup(&cleanup_repository, "./repowithunborn");
+	cl_git_pass(git_clone(&repo, "./test1", "./repowithunborn", NULL));
+
+	cl_git_pass(git_repository_config(&config, repo));
+
+	cl_git_pass(git_config_get_string(&str, config, "branch.master.remote"));
+	cl_assert_equal_s("origin", str);
+	cl_git_pass(git_config_get_string(&str, config, "branch.master.merge"));
+	cl_assert_equal_s("refs/heads/master", str);
+
+	git_config_free(config);
+	git_repository_free(repo);
+	cl_fixture_cleanup("./repowithunborn");
+}
diff --git a/tests/fetchhead/fetchhead_data.h b/tests/fetchhead/fetchhead_data.h
index 294c9fb01..34adb3d08 100644
--- a/tests/fetchhead/fetchhead_data.h
+++ b/tests/fetchhead/fetchhead_data.h
@@ -28,4 +28,3 @@
 
 #define FETCH_HEAD_EXPLICIT_DATA \
 	"0966a434eb1a025db6b71485ab63a3bfbea520b6\t\tbranch 'first-merge' of git://github.com/libgit2/TestGitRepository\n"
-
diff --git a/tests/fetchhead/nonetwork.c b/tests/fetchhead/nonetwork.c
index a68ebb0b7..d8c70e8b2 100644
--- a/tests/fetchhead/nonetwork.c
+++ b/tests/fetchhead/nonetwork.c
@@ -307,3 +307,39 @@ void test_fetchhead_nonetwork__invalid_description(void)
 	cl_assert(git__prefixcmp(giterr_last()->message, "Invalid description") == 0);
 }
 
+static int assert_master_for_merge(const char *ref, const char *url, const git_oid *id, unsigned int is_merge, void *data)
+{
+	GIT_UNUSED(url);
+	GIT_UNUSED(id);
+	GIT_UNUSED(data);
+
+	if (!strcmp("refs/heads/master", ref) && !is_merge)
+		return -1;
+
+	return 0;
+}
+
+void test_fetchhead_nonetwork__unborn_with_upstream(void)
+{
+	git_repository *repo;
+	git_remote *remote;
+
+	/* Create an empty repo to clone from */
+	cl_set_cleanup(&cleanup_repository, "./test1");
+	cl_git_pass(git_repository_init(&g_repo, "./test1", 0));
+	cl_set_cleanup(&cleanup_repository, "./repowithunborn");
+	cl_git_pass(git_clone(&repo, "./test1", "./repowithunborn", NULL));
+
+	/* Simulate someone pushing to it by changing to one that has stuff */
+	cl_git_pass(git_remote_load(&remote, repo, "origin"));
+	cl_git_pass(git_remote_set_url(remote, cl_fixture("testrepo.git")));
+	cl_git_pass(git_remote_save(remote));
+
+	cl_git_pass(git_remote_fetch(remote, NULL, NULL));
+	git_remote_free(remote);
+
+	cl_git_pass(git_repository_fetchhead_foreach(repo, assert_master_for_merge, NULL));
+
+	git_repository_free(repo);
+	cl_fixture_cleanup("./repowithunborn");
+}
-- 
cgit v1.2.3


From 67d4997a7e3d95d8ebc9c13481b767efd1d5bb15 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 2 Apr 2014 18:44:01 +0200
Subject: remote: mark branch for-merge even if we're unborn

When the current branch is unborn, git will still mark the current
branch's upstream for-merge if there is an upstream configuration. The
only non-constrived case is cloning from an empty repository which then
gains history. origin's master should be marked for-merge.

In order to do this, we cannot use the high-level wrappers that expect a
reference, as we may not have one. Move over to the internal ones that
expect a reference name, which we do have.
---
 src/remote.c | 27 ++++++++++++++++++++-------
 1 file changed, 20 insertions(+), 7 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index 62ee90375..d3e81b973 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -902,19 +902,32 @@ static int remote_head_for_fetchspec_src(git_remote_head **out, git_vector *upda
 static int remote_head_for_ref(git_remote_head **out, git_refspec *spec, git_vector *update_heads, git_reference *ref)
 {
 	git_reference *resolved_ref = NULL;
-	git_reference *tracking_ref = NULL;
 	git_buf remote_name = GIT_BUF_INIT;
+	git_buf upstream_name = GIT_BUF_INIT;
+	git_repository *repo;
+	const char *ref_name;
 	int error = 0;
 
 	assert(out && spec && ref);
 
 	*out = NULL;
 
-	if ((error = git_reference_resolve(&resolved_ref, ref)) < 0 ||
-		(!git_reference_is_branch(resolved_ref)) ||
-		(error = git_branch_upstream(&tracking_ref, resolved_ref)) < 0 ||
-		(error = git_refspec_rtransform(&remote_name, spec, git_reference_name(tracking_ref))) < 0) {
-		/* Not an error if HEAD is unborn or no tracking branch */
+	repo = git_reference_owner(ref);
+
+	error = git_reference_resolve(&resolved_ref, ref);
+
+	/* If we're in an unborn branch, let's pretend nothing happened */
+	if (error == GIT_ENOTFOUND && git_reference_type(ref) == GIT_REF_SYMBOLIC) {
+		ref_name = git_reference_symbolic_target(ref);
+		error = 0;
+	} else {
+		ref_name = git_reference_name(resolved_ref);
+	}
+
+	if ((!git_reference__is_branch(ref_name)) ||
+	    (error = git_branch_upstream_name(&upstream_name, repo, ref_name)) < 0 ||
+	    (error = git_refspec_rtransform(&remote_name, spec, upstream_name.ptr)) < 0) {
+		/* Not an error if there is no upstream */
 		if (error == GIT_ENOTFOUND)
 			error = 0;
 
@@ -924,9 +937,9 @@ static int remote_head_for_ref(git_remote_head **out, git_refspec *spec, git_vec
 	error = remote_head_for_fetchspec_src(out, update_heads, git_buf_cstr(&remote_name));
 
 cleanup:
-	git_reference_free(tracking_ref);
 	git_reference_free(resolved_ref);
 	git_buf_free(&remote_name);
+	git_buf_free(&upstream_name);
 	return error;
 }
 
-- 
cgit v1.2.3


From 3b4ba2787049c561cd7a9e3fea8fc16e473a0b32 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Thu, 3 Apr 2014 15:50:21 +0200
Subject: Const correctness!

---
 include/git2/blob.h   |  2 +-
 include/git2/branch.h |  7 ++++---
 include/git2/index.h  |  2 +-
 include/git2/merge.h  |  2 +-
 include/git2/push.h   |  2 +-
 include/git2/refs.h   | 12 +++++++-----
 src/blob.c            |  2 +-
 src/branch.c          |  8 +++++---
 src/index.c           |  2 +-
 src/merge.c           |  2 +-
 src/push.c            |  2 +-
 src/refs.c            | 12 +++++++-----
 12 files changed, 31 insertions(+), 24 deletions(-)

diff --git a/include/git2/blob.h b/include/git2/blob.h
index ac4d84392..1b6583309 100644
--- a/include/git2/blob.h
+++ b/include/git2/blob.h
@@ -216,7 +216,7 @@ GIT_EXTERN(int) git_blob_create_frombuffer(
  * @return 1 if the content of the blob is detected
  * as binary; 0 otherwise.
  */
-GIT_EXTERN(int) git_blob_is_binary(git_blob *blob);
+GIT_EXTERN(int) git_blob_is_binary(const git_blob *blob);
 
 /** @} */
 GIT_END_DECL
diff --git a/include/git2/branch.h b/include/git2/branch.h
index d2762019b..ad2a70b1f 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -179,8 +179,9 @@ GIT_EXTERN(int) git_branch_lookup(
  * @return 0 on success; otherwise an error code (e.g., if the
  *  ref is no local or remote branch).
  */
-GIT_EXTERN(int) git_branch_name(const char **out,
-		git_reference *ref);
+GIT_EXTERN(int) git_branch_name(
+		const char **out,
+		const git_reference *ref);
 
 /**
  * Return the reference supporting the remote tracking branch,
@@ -196,7 +197,7 @@ GIT_EXTERN(int) git_branch_name(const char **out,
  */
 GIT_EXTERN(int) git_branch_upstream(
 	git_reference **out,
-	git_reference *branch);
+	const git_reference *branch);
 
 /**
  * Set the upstream configuration for a given local branch
diff --git a/include/git2/index.h b/include/git2/index.h
index 9a7ad28a6..dd6a28e40 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -255,7 +255,7 @@ GIT_EXTERN(int) git_index_write(git_index *index);
  * @param index an existing index object
  * @return path to index file or NULL for in-memory index
  */
-GIT_EXTERN(const char *) git_index_path(git_index *index);
+GIT_EXTERN(const char *) git_index_path(const git_index *index);
 
 /**
  * Read a tree into the index file with stats
diff --git a/include/git2/merge.h b/include/git2/merge.h
index 769df5a8d..6d97e81e6 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -341,7 +341,7 @@ GIT_EXTERN(int) git_merge_base_octopus(
 GIT_EXTERN(int) git_merge_head_from_ref(
 	git_merge_head **out,
 	git_repository *repo,
-	git_reference *ref);
+	const git_reference *ref);
 
 /**
  * Creates a `git_merge_head` from the given fetch head data.  The resulting
diff --git a/include/git2/push.h b/include/git2/push.h
index 899d21e7f..7a8bec12c 100644
--- a/include/git2/push.h
+++ b/include/git2/push.h
@@ -148,7 +148,7 @@ GIT_EXTERN(int) git_push_finish(git_push *push);
  *
  * @return true if remote side successfully unpacked, false otherwise
  */
-GIT_EXTERN(int) git_push_unpack_ok(git_push *push);
+GIT_EXTERN(int) git_push_unpack_ok(const git_push *push);
 
 /**
  * Invoke callback `cb' on each status entry
diff --git a/include/git2/refs.h b/include/git2/refs.h
index 1bbb4ca46..6a1db65a8 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -487,7 +487,9 @@ GIT_EXTERN(void) git_reference_free(git_reference *ref);
  * @param ref2 The second git_reference
  * @return 0 if the same, else a stable but meaningless ordering.
  */
-GIT_EXTERN(int) git_reference_cmp(git_reference *ref1, git_reference *ref2);
+GIT_EXTERN(int) git_reference_cmp(
+	const git_reference *ref1,
+	const git_reference *ref2);
 
 /**
  * Create an iterator for the repo's references
@@ -596,7 +598,7 @@ GIT_EXTERN(int) git_reference_is_branch(const git_reference *ref);
  * @return 1 when the reference lives in the refs/remotes
  * namespace; 0 otherwise.
  */
-GIT_EXTERN(int) git_reference_is_remote(git_reference *ref);
+GIT_EXTERN(int) git_reference_is_remote(const git_reference *ref);
 
 /**
  * Check if a reference is a tag
@@ -606,7 +608,7 @@ GIT_EXTERN(int) git_reference_is_remote(git_reference *ref);
  * @return 1 when the reference lives in the refs/tags
  * namespace; 0 otherwise.
  */
-GIT_EXTERN(int) git_reference_is_tag(git_reference *ref);
+GIT_EXTERN(int) git_reference_is_tag(const git_reference *ref);
 
 /**
  * Check if a reference is a note
@@ -616,7 +618,7 @@ GIT_EXTERN(int) git_reference_is_tag(git_reference *ref);
  * @return 1 when the reference lives in the refs/notes
  * namespace; 0 otherwise.
  */
-GIT_EXTERN(int) git_reference_is_note(git_reference *ref);
+GIT_EXTERN(int) git_reference_is_note(const git_reference *ref);
 
 typedef enum {
 	GIT_REF_FORMAT_NORMAL = 0u,
@@ -720,7 +722,7 @@ GIT_EXTERN(int) git_reference_is_valid_name(const char *refname);
  * @param ref a reference
  * @return the human-readable version of the name
  */
-GIT_EXTERN(const char *) git_reference_shorthand(git_reference *ref);
+GIT_EXTERN(const char *) git_reference_shorthand(const git_reference *ref);
 
 
 /** @} */
diff --git a/src/blob.c b/src/blob.c
index faf8a4a99..0aa2516db 100644
--- a/src/blob.c
+++ b/src/blob.c
@@ -326,7 +326,7 @@ cleanup:
 	return error;
 }
 
-int git_blob_is_binary(git_blob *blob)
+int git_blob_is_binary(const git_blob *blob)
 {
 	git_buf content;
 
diff --git a/src/branch.c b/src/branch.c
index df665a469..63c6ec110 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -281,7 +281,9 @@ int git_branch_lookup(
 	return retrieve_branch_reference(ref_out, repo, branch_name, branch_type == GIT_BRANCH_REMOTE);
 }
 
-int git_branch_name(const char **out, git_reference *ref)
+int git_branch_name(
+	const char **out,
+	const git_reference *ref)
 {
 	const char *branch_name;
 
@@ -450,8 +452,8 @@ cleanup:
 }
 
 int git_branch_upstream(
-		git_reference **tracking_out,
-		git_reference *branch)
+	git_reference **tracking_out,
+	const git_reference *branch)
 {
 	int error;
 	git_buf tracking_name = GIT_BUF_INIT;
diff --git a/src/index.c b/src/index.c
index ea0815e4c..3fcd21115 100644
--- a/src/index.c
+++ b/src/index.c
@@ -553,7 +553,7 @@ int git_index_write(git_index *index)
 	return 0;
 }
 
-const char * git_index_path(git_index *index)
+const char * git_index_path(const git_index *index)
 {
 	assert(index);
 	return index->index_file_path;
diff --git a/src/merge.c b/src/merge.c
index f9ed7b0a3..dd6a39f37 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2695,7 +2695,7 @@ static int merge_head_init(
 int git_merge_head_from_ref(
 	git_merge_head **out,
 	git_repository *repo,
-	git_reference *ref)
+	const git_reference *ref)
 {
 	git_reference *resolved;
 	int error = 0;
diff --git a/src/push.c b/src/push.c
index 521355621..5c8de3339 100644
--- a/src/push.c
+++ b/src/push.c
@@ -651,7 +651,7 @@ int git_push_finish(git_push *push)
 	return 0;
 }
 
-int git_push_unpack_ok(git_push *push)
+int git_push_unpack_ok(const git_push *push)
 {
 	return push->unpack_ok;
 }
diff --git a/src/refs.c b/src/refs.c
index 8b6e09a33..9428f617d 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -1031,7 +1031,9 @@ int git_reference__normalize_name_lax(
 }
 #define GIT_REF_TYPEMASK (GIT_REF_OID | GIT_REF_SYMBOLIC)
 
-int git_reference_cmp(git_reference *ref1, git_reference *ref2)
+int git_reference_cmp(
+	const git_reference *ref1,
+	const git_reference *ref2)
 {
 	git_ref_t type1, type2;
 	assert(ref1 && ref2);
@@ -1148,7 +1150,7 @@ int git_reference__is_remote(const char *ref_name)
 	return git__prefixcmp(ref_name, GIT_REFS_REMOTES_DIR) == 0;
 }
 
-int git_reference_is_remote(git_reference *ref)
+int git_reference_is_remote(const git_reference *ref)
 {
 	assert(ref);
 	return git_reference__is_remote(ref->name);
@@ -1159,7 +1161,7 @@ int git_reference__is_tag(const char *ref_name)
 	return git__prefixcmp(ref_name, GIT_REFS_TAGS_DIR) == 0;
 }
 
-int git_reference_is_tag(git_reference *ref)
+int git_reference_is_tag(const git_reference *ref)
 {
 	assert(ref);
 	return git_reference__is_tag(ref->name);
@@ -1170,7 +1172,7 @@ int git_reference__is_note(const char *ref_name)
 	return git__prefixcmp(ref_name, GIT_REFS_NOTES_DIR) == 0;
 }
 
-int git_reference_is_note(git_reference *ref)
+int git_reference_is_note(const git_reference *ref)
 {
 	assert(ref);
 	return git_reference__is_note(ref->name);
@@ -1244,7 +1246,7 @@ int git_reference_is_valid_name(const char *refname)
 	return git_reference__is_valid_name(refname, GIT_REF_FORMAT_ALLOW_ONELEVEL);
 }
 
-const char *git_reference_shorthand(git_reference *ref)
+const char *git_reference_shorthand(const git_reference *ref)
 {
 	const char *name = ref->name;
 
-- 
cgit v1.2.3


From 12d4ed4de34e312cb491ce1b5562d84846aeb456 Mon Sep 17 00:00:00 2001
From: Jan Melcher <info@yogularm.de>
Date: Sat, 8 Mar 2014 23:04:56 +0100
Subject: Test git_submodule_add_setup with relative url

---
 tests/submodule/modify.c | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/tests/submodule/modify.c b/tests/submodule/modify.c
index 1aaa56388..7cd44e23e 100644
--- a/tests/submodule/modify.c
+++ b/tests/submodule/modify.c
@@ -9,6 +9,10 @@ static git_repository *g_repo = NULL;
 #define SM_LIBGIT2     "sm_libgit2"
 #define SM_LIBGIT2B    "sm_libgit2b"
 
+#define SM_RELATIVE_URL "../TestGitRepository"
+#define SM_RELATIVE_RESOLVED_URL "https://github.com/libgit2/TestGitRepository"
+#define SM_RELATIVE "TestGitRepository"
+
 void test_submodule_modify__initialize(void)
 {
 	g_repo = setup_fixture_submod2();
@@ -62,6 +66,26 @@ void test_submodule_modify__add(void)
 	git_config_free(cfg);
 }
 
+void test_submodule_modify__add_with_relative_url(void) {
+	git_submodule *sm;
+	git_config *cfg;
+	const char *s;
+
+	git_repository* repo;
+	/* setup_fixture_submod2 does not work here because it does not set up origin configuration */
+	cl_git_pass(git_clone(&repo, SM_LIBGIT2_URL, "./sandbox/submodules_cloned", NULL));
+
+	cl_git_pass(
+		git_submodule_add_setup(&sm, repo, SM_RELATIVE_URL, SM_RELATIVE, 1)
+		);
+
+	cl_git_pass(git_repository_config(&cfg, repo));
+	cl_git_pass(
+		git_config_get_string(&s, cfg, "submodule." SM_RELATIVE ".url"));
+	cl_assert_equal_s(s, SM_RELATIVE_RESOLVED_URL);
+	git_config_free(cfg);
+}
+
 static int delete_one_config(const git_config_entry *entry, void *payload)
 {
 	git_config *cfg = payload;
-- 
cgit v1.2.3


From f2fb4bac68e7ab38cf6082655b2da153866a012d Mon Sep 17 00:00:00 2001
From: Jan Melcher <info@yogularm.de>
Date: Wed, 2 Apr 2014 23:55:21 +0200
Subject: git_submodule_resolve_url supports relative urls

The base for the relative urls is determined as follows, with descending
priority:

- remote url of HEAD's remote tracking branch
- remote "origin"
- workdir

This follows git.git behaviour
---
 src/submodule.c          | 136 +++++++++++++++++++++++++++++------------------
 tests/submodule/add.c    | 115 +++++++++++++++++++++++++++++++++++++++
 tests/submodule/modify.c |  73 -------------------------
 3 files changed, 198 insertions(+), 126 deletions(-)
 create mode 100644 tests/submodule/add.c

diff --git a/src/submodule.c b/src/submodule.c
index 913c97a87..24f250aa1 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -91,8 +91,10 @@ static int submodule_cache_init(git_repository *repo, int refresh);
 static void submodule_cache_free(git_submodule_cache *cache);
 
 static git_config_backend *open_gitmodules(git_submodule_cache *, int gitmod);
-static int lookup_head_remote_key(git_buf *key, git_repository *repo);
-static int lookup_head_remote(git_buf *url, git_repository *repo);
+static int get_url_base(git_buf *url, git_repository *repo);
+static int lookup_default_remote(git_remote **remote, git_repository *repo);
+static int lookup_head_remote_key(git_buf *remote_key, git_repository *repo);
+static int lookup_head_remote(git_remote **remote, git_repository *repo);
 static int submodule_get(git_submodule **, git_submodule_cache *, const char *, const char *);
 static int submodule_load_from_config(const git_config_entry *, void *);
 static int submodule_load_from_wd_lite(git_submodule *);
@@ -644,7 +646,7 @@ int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *ur
 	assert(url);
 
 	if (git_path_is_relative(url)) {
-		if (!(error = lookup_head_remote(out, repo)))
+		if (!(error = get_url_base(out, repo)))
 			error = git_path_apply_relative(out, url);
 	} else if (strchr(url, ':') != NULL || url[0] == '/') {
 		error = git_buf_sets(out, url);
@@ -1795,81 +1797,109 @@ static int submodule_cache_init(git_repository *repo, int cache_refresh)
 	return error;
 }
 
-static int lookup_head_remote_key(git_buf *key, git_repository *repo)
+static int get_url_base(git_buf *url, git_repository *repo)
 {
 	int error;
-	git_config *cfg;
-	git_reference *head = NULL, *remote = NULL;
-	const char *tgt, *scan;
+	git_remote *remote;
+	error = lookup_default_remote(&remote, repo);
+	const char *url_ptr;
+
+	assert(url && repo);
+	
+	if (!error)	{
+		url_ptr = git_remote_url(remote);
+	} else if (error == GIT_ENOTFOUND) {
+		/* if repository does not have a default remote, use workdir instead */
+		giterr_clear();
+		error = 0;
+		url_ptr = git_repository_workdir(repo);
+	}
+	
+	if (error < 0)
+		goto cleanup;
+		
+	error = git_buf_sets(url, url_ptr);
 
-	/* 1. resolve HEAD -> refs/heads/BRANCH
-	 * 2. lookup config branch.BRANCH.remote -> ORIGIN
-	 * 3. return remote.ORIGIN.url
-	 */
+cleanup:
+	git_remote_free(remote);
 
-	git_buf_clear(key);
+	return error;
+}
 
-	if ((error = git_repository_config__weakptr(&cfg, repo)) < 0)
-		return error;
+/**
+ * Lookup the remote that is considered the default remote in the current state
+ */
+static int lookup_default_remote(git_remote **remote, git_repository *repo)
+{
+	int error;
+	error = lookup_head_remote(remote, repo);
 
-	if (git_reference_lookup(&head, repo, GIT_HEAD_FILE) < 0) {
-		giterr_set(GITERR_SUBMODULE,
-			"Cannot resolve relative URL when HEAD cannot be resolved");
-		return GIT_ENOTFOUND;
+	assert(remote && repo);
+
+	// if that failed, use 'origin' instead
+	if (error == GIT_ENOTFOUND) {
+		error = git_remote_load(remote, repo, "origin");
 	}
 
-	if (git_reference_type(head) != GIT_REF_SYMBOLIC) {
+	if (error == GIT_ENOTFOUND) {
 		giterr_set(GITERR_SUBMODULE,
-			"Cannot resolve relative URL when HEAD is not symbolic");
-		error = GIT_ENOTFOUND;
-		goto cleanup;
+			"Neither HEAD points to a local tracking branch, nor does origin exist");
 	}
 
-	if ((error = git_branch_upstream(&remote, head)) < 0)
-		goto cleanup;
+	return error;
+}
 
-	/* remote should refer to something like refs/remotes/ORIGIN/BRANCH */
+/**
+ * Lookup name of remote of the local tracking branch HEAD points to
+ */
+static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo)
+{
+	int error;
+	git_reference *head = NULL;
+	git_buf upstream_name = GIT_BUF_INIT;
 
-	if (git_reference_type(remote) != GIT_REF_SYMBOLIC ||
-		git__prefixcmp(
-			git_reference_symbolic_target(remote), GIT_REFS_REMOTES_DIR) != 0)
-	{
-		giterr_set(GITERR_SUBMODULE,
-			"Cannot resolve relative URL when HEAD is not symbolic");
-		error = GIT_ENOTFOUND;
-		goto cleanup;
-	}
+	/* lookup and dereference HEAD */
+	if ((error = git_repository_head(&head, repo) < 0))
+	   goto cleanup;
 
-	scan = tgt = git_reference_symbolic_target(remote) +
-		strlen(GIT_REFS_REMOTES_DIR);
-	while (*scan && (*scan != '/' || (scan > tgt && scan[-1] != '\\')))
-		scan++; /* find non-escaped slash to end ORIGIN name */
+	/* lookup remote tracking branch of HEAD */
+	if ((error = git_branch_upstream_name(&upstream_name, repo, git_reference_name(head))) < 0)
+		goto cleanup;
 
-	error = git_buf_printf(key, "remote.%.*s.url", (int)(scan - tgt), tgt);
+	/* lookup remote of remote tracking branch */
+	if ((error = git_branch_remote_name(remote_name, repo, upstream_name.ptr)) < 0)
+		goto cleanup;
 
 cleanup:
-	if (error < 0)
-		git_buf_clear(key);
-
-	git_reference_free(head);
-	git_reference_free(remote);
+	git_buf_free(&upstream_name);
+	if (head)
+		git_reference_free(head);
 
 	return error;
 }
 
-static int lookup_head_remote(git_buf *url, git_repository *repo)
+/**
+ * Lookup the remote of the local tracking branch HEAD points to
+ */
+static int lookup_head_remote(git_remote **remote, git_repository *repo)
 {
 	int error;
-	git_config *cfg;
-	const char *tgt;
-	git_buf key = GIT_BUF_INIT;
+	git_buf remote_name = GIT_BUF_INIT;
 
-	if (!(error = lookup_head_remote_key(&key, repo)) &&
-		!(error = git_repository_config__weakptr(&cfg, repo)) &&
-		!(error = git_config_get_string(&tgt, cfg, key.ptr)))
-		error = git_buf_sets(url, tgt);
+	assert(remote && repo);
+
+	/* should be NULL in case of error */
+	*remote = NULL;
+
+	/* lookup remote of remote tracking branch name */
+	if ((error = lookup_head_remote_key(&remote_name, repo)) < 0)
+		goto cleanup;
+
+	error = git_remote_load(remote, repo, remote_name.ptr);
+
+cleanup:
+	git_buf_free(&remote_name);
 
-	git_buf_free(&key);
 	return error;
 }
 
diff --git a/tests/submodule/add.c b/tests/submodule/add.c
new file mode 100644
index 000000000..2d51b3d7e
--- /dev/null
+++ b/tests/submodule/add.c
@@ -0,0 +1,115 @@
+#include "clar_libgit2.h"
+#include "posix.h"
+#include "path.h"
+#include "submodule_helpers.h"
+
+static git_repository *g_repo = NULL;
+
+static void assert_submodule_url(const char* name, const char *url);
+
+void test_submodule_add__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_submodule_add__url_absolute(void)
+{
+	g_repo = setup_fixture_submod2();
+	git_submodule *sm;
+
+	/* re-add existing submodule */
+	cl_assert_equal_i(
+		GIT_EEXISTS,
+		git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1));
+
+	/* add a submodule using a gitlink */
+
+	cl_git_pass(
+		git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_libgit2", 1)
+		);
+	git_submodule_free(sm);
+
+	cl_assert(git_path_isfile("submod2/" "sm_libgit2" "/.git"));
+
+	cl_assert(git_path_isdir("submod2/.git/modules"));
+	cl_assert(git_path_isdir("submod2/.git/modules/" "sm_libgit2"));
+	cl_assert(git_path_isfile("submod2/.git/modules/" "sm_libgit2" "/HEAD"));
+	assert_submodule_url("sm_libgit2", "https://github.com/libgit2/libgit2.git");
+
+	/* add a submodule not using a gitlink */
+
+	cl_git_pass(
+		git_submodule_add_setup(&sm, g_repo, "https://github.com/libgit2/libgit2.git", "sm_libgit2b", 0)
+		);
+	git_submodule_free(sm);
+
+	cl_assert(git_path_isdir("submod2/" "sm_libgit2b" "/.git"));
+	cl_assert(git_path_isfile("submod2/" "sm_libgit2b" "/.git/HEAD"));
+	cl_assert(!git_path_exists("submod2/.git/modules/" "sm_libgit2b"));
+	assert_submodule_url("sm_libgit2b", "https://github.com/libgit2/libgit2.git");
+}
+
+void test_submodule_add__url_relative(void) {
+	git_submodule *sm;
+	git_remote *remote;
+	
+	/* default remote url is https://github.com/libgit2/false.git */
+	g_repo = cl_git_sandbox_init("testrepo2");
+	
+	/* make sure we're not defaulting to origin - rename origin -> test_remote */
+	cl_git_pass(git_remote_load(&remote, g_repo, "origin"));
+	cl_git_pass(git_remote_rename(remote, "test_remote", NULL, NULL));
+	cl_git_fail(git_remote_load(&remote, g_repo, "origin"));
+	git_remote_free(remote);
+
+	cl_git_pass(
+		git_submodule_add_setup(&sm, g_repo, "../TestGitRepository", "TestGitRepository", 1)
+		);
+	git_submodule_free(sm);
+		
+	assert_submodule_url("TestGitRepository", "https://github.com/libgit2/TestGitRepository");
+}
+
+void test_submodule_add__url_relative_to_origin(void) {
+	git_submodule *sm;
+	
+	/* default remote url is https://github.com/libgit2/false.git */
+	g_repo = cl_git_sandbox_init("testrepo2");
+
+	cl_git_pass(
+		git_submodule_add_setup(&sm, g_repo, "../TestGitRepository", "TestGitRepository", 1)
+		);
+	git_submodule_free(sm);
+		
+	assert_submodule_url("TestGitRepository", "https://github.com/libgit2/TestGitRepository");
+}
+
+void test_submodule_add__url_relative_to_workdir(void) {
+	git_submodule *sm;
+
+	/* In this repo, HEAD (master) has no remote tracking branc h*/
+	g_repo = cl_git_sandbox_init("testrepo");
+
+	cl_git_pass(
+		git_submodule_add_setup(&sm, g_repo, "./", "TestGitRepository", 1)
+		);
+	git_submodule_free(sm);
+		
+	assert_submodule_url("TestGitRepository", git_repository_workdir(g_repo));
+}
+
+static void assert_submodule_url(const char* name, const char *url)
+{
+	git_config *cfg;
+	const char *s;
+	git_buf key = GIT_BUF_INIT;
+
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+
+	cl_git_pass(git_buf_printf(&key, "submodule.%s.url", name));
+	cl_git_pass(git_config_get_string(&s, cfg, git_buf_cstr(&key)));
+	cl_assert_equal_s(s, url);
+
+	git_config_free(cfg);
+	git_buf_free(&key);
+}
diff --git a/tests/submodule/modify.c b/tests/submodule/modify.c
index 7cd44e23e..7e76f3572 100644
--- a/tests/submodule/modify.c
+++ b/tests/submodule/modify.c
@@ -7,85 +7,12 @@ static git_repository *g_repo = NULL;
 
 #define SM_LIBGIT2_URL "https://github.com/libgit2/libgit2.git"
 #define SM_LIBGIT2     "sm_libgit2"
-#define SM_LIBGIT2B    "sm_libgit2b"
-
-#define SM_RELATIVE_URL "../TestGitRepository"
-#define SM_RELATIVE_RESOLVED_URL "https://github.com/libgit2/TestGitRepository"
-#define SM_RELATIVE "TestGitRepository"
 
 void test_submodule_modify__initialize(void)
 {
 	g_repo = setup_fixture_submod2();
 }
 
-void test_submodule_modify__add(void)
-{
-	git_submodule *sm;
-	git_config *cfg;
-	const char *s;
-
-	/* re-add existing submodule */
-	cl_assert_equal_i(
-		GIT_EEXISTS,
-		git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1));
-
-	/* add a submodule using a gitlink */
-
-	cl_git_pass(
-		git_submodule_add_setup(&sm, g_repo, SM_LIBGIT2_URL, SM_LIBGIT2, 1)
-		);
-	git_submodule_free(sm);
-
-	cl_assert(git_path_isfile("submod2/" SM_LIBGIT2 "/.git"));
-
-	cl_assert(git_path_isdir("submod2/.git/modules"));
-	cl_assert(git_path_isdir("submod2/.git/modules/" SM_LIBGIT2));
-	cl_assert(git_path_isfile("submod2/.git/modules/" SM_LIBGIT2 "/HEAD"));
-
-	cl_git_pass(git_repository_config(&cfg, g_repo));
-	cl_git_pass(
-		git_config_get_string(&s, cfg, "submodule." SM_LIBGIT2 ".url"));
-	cl_assert_equal_s(s, SM_LIBGIT2_URL);
-	git_config_free(cfg);
-
-	/* add a submodule not using a gitlink */
-
-	cl_git_pass(
-		git_submodule_add_setup(&sm, g_repo, SM_LIBGIT2_URL, SM_LIBGIT2B, 0)
-		);
-	git_submodule_free(sm);
-
-	cl_assert(git_path_isdir("submod2/" SM_LIBGIT2B "/.git"));
-	cl_assert(git_path_isfile("submod2/" SM_LIBGIT2B "/.git/HEAD"));
-	cl_assert(!git_path_exists("submod2/.git/modules/" SM_LIBGIT2B));
-
-	cl_git_pass(git_repository_config(&cfg, g_repo));
-	cl_git_pass(
-		git_config_get_string(&s, cfg, "submodule." SM_LIBGIT2B ".url"));
-	cl_assert_equal_s(s, SM_LIBGIT2_URL);
-	git_config_free(cfg);
-}
-
-void test_submodule_modify__add_with_relative_url(void) {
-	git_submodule *sm;
-	git_config *cfg;
-	const char *s;
-
-	git_repository* repo;
-	/* setup_fixture_submod2 does not work here because it does not set up origin configuration */
-	cl_git_pass(git_clone(&repo, SM_LIBGIT2_URL, "./sandbox/submodules_cloned", NULL));
-
-	cl_git_pass(
-		git_submodule_add_setup(&sm, repo, SM_RELATIVE_URL, SM_RELATIVE, 1)
-		);
-
-	cl_git_pass(git_repository_config(&cfg, repo));
-	cl_git_pass(
-		git_config_get_string(&s, cfg, "submodule." SM_RELATIVE ".url"));
-	cl_assert_equal_s(s, SM_RELATIVE_RESOLVED_URL);
-	git_config_free(cfg);
-}
-
 static int delete_one_config(const git_config_entry *entry, void *payload)
 {
 	git_config *cfg = payload;
-- 
cgit v1.2.3


From 18cc7d28c4c5ad4c9ecf7bfeab98a035500fd9d7 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 3 Apr 2014 11:29:08 -0700
Subject: Minor code cleanup

---
 src/submodule.c       | 125 +++++++++++++++++++-------------------------------
 tests/submodule/add.c |  62 +++++++++++++------------
 2 files changed, 79 insertions(+), 108 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index 24f250aa1..e49f09699 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -92,9 +92,7 @@ static void submodule_cache_free(git_submodule_cache *cache);
 
 static git_config_backend *open_gitmodules(git_submodule_cache *, int gitmod);
 static int get_url_base(git_buf *url, git_repository *repo);
-static int lookup_default_remote(git_remote **remote, git_repository *repo);
 static int lookup_head_remote_key(git_buf *remote_key, git_repository *repo);
-static int lookup_head_remote(git_remote **remote, git_repository *repo);
 static int submodule_get(git_submodule **, git_submodule_cache *, const char *, const char *);
 static int submodule_load_from_config(const git_config_entry *, void *);
 static int submodule_load_from_wd_lite(git_submodule *);
@@ -1797,108 +1795,79 @@ static int submodule_cache_init(git_repository *repo, int cache_refresh)
 	return error;
 }
 
-static int get_url_base(git_buf *url, git_repository *repo)
+/* Lookup name of remote of the local tracking branch HEAD points to */
+static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo)
 {
 	int error;
-	git_remote *remote;
-	error = lookup_default_remote(&remote, repo);
-	const char *url_ptr;
-
-	assert(url && repo);
-	
-	if (!error)	{
-		url_ptr = git_remote_url(remote);
-	} else if (error == GIT_ENOTFOUND) {
-		/* if repository does not have a default remote, use workdir instead */
-		giterr_clear();
-		error = 0;
-		url_ptr = git_repository_workdir(repo);
+	git_reference *head = NULL;
+	git_buf upstream_name = GIT_BUF_INIT;
+
+	/* lookup and dereference HEAD */
+	if ((error = git_repository_head(&head, repo)) < 0)
+		return error;
+
+	/* lookup remote tracking branch of HEAD */
+	if (!(error = git_branch_upstream_name(
+			&upstream_name, repo, git_reference_name(head))))
+	{
+		/* lookup remote of remote tracking branch */
+		error = git_branch_remote_name(remote_name, repo, upstream_name.ptr);
+
+		git_buf_free(&upstream_name);
 	}
-	
-	if (error < 0)
-		goto cleanup;
-		
-	error = git_buf_sets(url, url_ptr);
 
-cleanup:
-	git_remote_free(remote);
+	git_reference_free(head);
 
 	return error;
 }
 
-/**
- * Lookup the remote that is considered the default remote in the current state
- */
-static int lookup_default_remote(git_remote **remote, git_repository *repo)
+/* Lookup the remote of the local tracking branch HEAD points to */
+static int lookup_head_remote(git_remote **remote, git_repository *repo)
 {
 	int error;
-	error = lookup_head_remote(remote, repo);
-
-	assert(remote && repo);
+	git_buf remote_name = GIT_BUF_INIT;
 
-	// if that failed, use 'origin' instead
-	if (error == GIT_ENOTFOUND) {
-		error = git_remote_load(remote, repo, "origin");
-	}
+	/* lookup remote of remote tracking branch name */
+	if (!(error = lookup_head_remote_key(&remote_name, repo)))
+		error = git_remote_load(remote, repo, remote_name.ptr);
 
-	if (error == GIT_ENOTFOUND) {
-		giterr_set(GITERR_SUBMODULE,
-			"Neither HEAD points to a local tracking branch, nor does origin exist");
-	}
+	git_buf_free(&remote_name);
 
 	return error;
 }
 
-/**
- * Lookup name of remote of the local tracking branch HEAD points to
- */
-static int lookup_head_remote_key(git_buf *remote_name, git_repository *repo)
+/* Lookup remote, either from HEAD or fall back on origin */
+static int lookup_default_remote(git_remote **remote, git_repository *repo)
 {
-	int error;
-	git_reference *head = NULL;
-	git_buf upstream_name = GIT_BUF_INIT;
-
-	/* lookup and dereference HEAD */
-	if ((error = git_repository_head(&head, repo) < 0))
-	   goto cleanup;
+	int error = lookup_head_remote(remote, repo);
 
-	/* lookup remote tracking branch of HEAD */
-	if ((error = git_branch_upstream_name(&upstream_name, repo, git_reference_name(head))) < 0)
-		goto cleanup;
+	/* if that failed, use 'origin' instead */
+	if (error == GIT_ENOTFOUND)
+		error = git_remote_load(remote, repo, "origin");
 
-	/* lookup remote of remote tracking branch */
-	if ((error = git_branch_remote_name(remote_name, repo, upstream_name.ptr)) < 0)
-		goto cleanup;
-
-cleanup:
-	git_buf_free(&upstream_name);
-	if (head)
-		git_reference_free(head);
+	if (error == GIT_ENOTFOUND)
+		giterr_set(
+			GITERR_SUBMODULE,
+			"Cannot get default remote for submodule - no local tracking "
+			"branch for HEAD and origin does not exist");
 
 	return error;
 }
 
-/**
- * Lookup the remote of the local tracking branch HEAD points to
- */
-static int lookup_head_remote(git_remote **remote, git_repository *repo)
+static int get_url_base(git_buf *url, git_repository *repo)
 {
 	int error;
-	git_buf remote_name = GIT_BUF_INIT;
-
-	assert(remote && repo);
-
-	/* should be NULL in case of error */
-	*remote = NULL;
-
-	/* lookup remote of remote tracking branch name */
-	if ((error = lookup_head_remote_key(&remote_name, repo)) < 0)
-		goto cleanup;
+	git_remote *remote = NULL;
 
-	error = git_remote_load(remote, repo, remote_name.ptr);
-
-cleanup:
-	git_buf_free(&remote_name);
+	if (!(error = lookup_default_remote(&remote, repo))) {
+		error = git_buf_sets(url, git_remote_url(remote));
+		git_remote_free(remote);
+	}
+	else if (error == GIT_ENOTFOUND) {
+		/* if repository does not have a default remote, use workdir instead */
+		giterr_clear();
+		error = git_buf_sets(url, git_repository_workdir(repo));
+	}
 
 	return error;
 }
diff --git a/tests/submodule/add.c b/tests/submodule/add.c
index 2d51b3d7e..af81713f1 100644
--- a/tests/submodule/add.c
+++ b/tests/submodule/add.c
@@ -5,20 +5,35 @@
 
 static git_repository *g_repo = NULL;
 
-static void assert_submodule_url(const char* name, const char *url);
-
 void test_submodule_add__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
 }
 
+static void assert_submodule_url(const char* name, const char *url)
+{
+	git_config *cfg;
+	const char *s;
+	git_buf key = GIT_BUF_INIT;
+
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+
+	cl_git_pass(git_buf_printf(&key, "submodule.%s.url", name));
+	cl_git_pass(git_config_get_string(&s, cfg, git_buf_cstr(&key)));
+	cl_assert_equal_s(s, url);
+
+	git_config_free(cfg);
+	git_buf_free(&key);
+}
+
 void test_submodule_add__url_absolute(void)
 {
-	g_repo = setup_fixture_submod2();
 	git_submodule *sm;
 
+	g_repo = setup_fixture_submod2();
+
 	/* re-add existing submodule */
-	cl_assert_equal_i(
+	cl_git_fail_with(
 		GIT_EEXISTS,
 		git_submodule_add_setup(NULL, g_repo, "whatever", "sm_unchanged", 1));
 
@@ -49,14 +64,15 @@ void test_submodule_add__url_absolute(void)
 	assert_submodule_url("sm_libgit2b", "https://github.com/libgit2/libgit2.git");
 }
 
-void test_submodule_add__url_relative(void) {
+void test_submodule_add__url_relative(void)
+{
 	git_submodule *sm;
 	git_remote *remote;
-	
+
 	/* default remote url is https://github.com/libgit2/false.git */
 	g_repo = cl_git_sandbox_init("testrepo2");
-	
-	/* make sure we're not defaulting to origin - rename origin -> test_remote */
+
+	/* make sure we don't default to origin - rename origin -> test_remote */
 	cl_git_pass(git_remote_load(&remote, g_repo, "origin"));
 	cl_git_pass(git_remote_rename(remote, "test_remote", NULL, NULL));
 	cl_git_fail(git_remote_load(&remote, g_repo, "origin"));
@@ -66,13 +82,14 @@ void test_submodule_add__url_relative(void) {
 		git_submodule_add_setup(&sm, g_repo, "../TestGitRepository", "TestGitRepository", 1)
 		);
 	git_submodule_free(sm);
-		
+
 	assert_submodule_url("TestGitRepository", "https://github.com/libgit2/TestGitRepository");
 }
 
-void test_submodule_add__url_relative_to_origin(void) {
+void test_submodule_add__url_relative_to_origin(void)
+{
 	git_submodule *sm;
-	
+
 	/* default remote url is https://github.com/libgit2/false.git */
 	g_repo = cl_git_sandbox_init("testrepo2");
 
@@ -80,11 +97,12 @@ void test_submodule_add__url_relative_to_origin(void) {
 		git_submodule_add_setup(&sm, g_repo, "../TestGitRepository", "TestGitRepository", 1)
 		);
 	git_submodule_free(sm);
-		
+
 	assert_submodule_url("TestGitRepository", "https://github.com/libgit2/TestGitRepository");
 }
 
-void test_submodule_add__url_relative_to_workdir(void) {
+void test_submodule_add__url_relative_to_workdir(void)
+{
 	git_submodule *sm;
 
 	/* In this repo, HEAD (master) has no remote tracking branc h*/
@@ -94,22 +112,6 @@ void test_submodule_add__url_relative_to_workdir(void) {
 		git_submodule_add_setup(&sm, g_repo, "./", "TestGitRepository", 1)
 		);
 	git_submodule_free(sm);
-		
-	assert_submodule_url("TestGitRepository", git_repository_workdir(g_repo));
-}
-
-static void assert_submodule_url(const char* name, const char *url)
-{
-	git_config *cfg;
-	const char *s;
-	git_buf key = GIT_BUF_INIT;
-
-	cl_git_pass(git_repository_config(&cfg, g_repo));
 
-	cl_git_pass(git_buf_printf(&key, "submodule.%s.url", name));
-	cl_git_pass(git_config_get_string(&s, cfg, git_buf_cstr(&key)));
-	cl_assert_equal_s(s, url);
-
-	git_config_free(cfg);
-	git_buf_free(&key);
+	assert_submodule_url("TestGitRepository", git_repository_workdir(g_repo));
 }
-- 
cgit v1.2.3


From eedeeb9e8f708e9f60568adc4a63307754a603f5 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 3 Apr 2014 11:58:51 -0700
Subject: Test (and fix) the git_submodule_sync changes

I wrote this stuff a while ago and forgot to write tests.  Wanted
to do so now to wrap up the PR and immediately found problems.
---
 src/submodule.c          | 15 ++++++++++++---
 tests/submodule/modify.c | 34 ++++++++++++++++++++++++++--------
 2 files changed, 38 insertions(+), 11 deletions(-)

diff --git a/src/submodule.c b/src/submodule.c
index e49f09699..bea096df5 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -849,12 +849,21 @@ int git_submodule_sync(git_submodule *sm)
 		(sm->flags & GIT_SUBMODULE_STATUS_IN_WD) != 0 &&
 		!(error = git_submodule_open(&smrepo, sm)))
 	{
-		if ((error = lookup_head_remote_key(&key, smrepo)) < 0) {
+		git_buf remote_name = GIT_BUF_INIT;
+
+		if ((error = git_repository_config__weakptr(&cfg, smrepo)) < 0)
+			/* return error from reading submodule config */;
+		else if ((error = lookup_head_remote_key(&remote_name, smrepo)) < 0) {
 			giterr_clear();
-			git_buf_sets(&key, "branch.origin.remote");
+			error = git_buf_sets(&key, "branch.origin.remote");
+		} else {
+			error = git_buf_join3(
+				&key, '.', "branch", remote_name.ptr, "remote");
+			git_buf_free(&remote_name);
 		}
 
-		error = git_config__update_entry(cfg, key.ptr, sm->url, true, true);
+		if (!error)
+			error = git_config__update_entry(cfg, key.ptr, sm->url, true, false);
 
 		git_repository_free(smrepo);
 	}
diff --git a/tests/submodule/modify.c b/tests/submodule/modify.c
index 7e76f3572..582d4166b 100644
--- a/tests/submodule/modify.c
+++ b/tests/submodule/modify.c
@@ -69,6 +69,26 @@ static int sync_one_submodule(
 	return git_submodule_sync(sm);
 }
 
+static void assert_submodule_url_is_synced(
+	git_submodule *sm, const char *parent_key, const char *child_key)
+{
+	git_config *cfg;
+	const char *str;
+	git_repository *smrepo;
+
+	cl_git_pass(git_repository_config(&cfg, g_repo));
+	cl_git_pass(git_config_get_string(&str, cfg, parent_key));
+	cl_assert_equal_s(git_submodule_url(sm), str);
+	git_config_free(cfg);
+
+	cl_git_pass(git_submodule_open(&smrepo, sm));
+	cl_git_pass(git_repository_config(&cfg, smrepo));
+	cl_git_pass(git_config_get_string(&str, cfg, child_key));
+	cl_assert_equal_s(git_submodule_url(sm), str);
+	git_config_free(cfg);
+	git_repository_free(smrepo);
+}
+
 void test_submodule_modify__sync(void)
 {
 	git_submodule *sm1, *sm2, *sm3;
@@ -104,14 +124,12 @@ void test_submodule_modify__sync(void)
 	cl_git_pass(git_submodule_foreach(g_repo, sync_one_submodule, NULL));
 
 	/* check that submodule config is updated */
-	cl_git_pass(git_repository_config(&cfg, g_repo));
-	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM1".url"));
-	cl_assert_equal_s(git_submodule_url(sm1), str);
-	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM2".url"));
-	cl_assert_equal_s(git_submodule_url(sm2), str);
-	cl_git_pass(git_config_get_string(&str, cfg, "submodule."SM3".url"));
-	cl_assert_equal_s(git_submodule_url(sm3), str);
-	git_config_free(cfg);
+	assert_submodule_url_is_synced(
+		sm1, "submodule."SM1".url", "branch.origin.remote");
+	assert_submodule_url_is_synced(
+		sm2, "submodule."SM2".url", "branch.origin.remote");
+	assert_submodule_url_is_synced(
+		sm3, "submodule."SM3".url", "branch.origin.remote");
 
 	git_submodule_free(sm1);
 	git_submodule_free(sm2);
-- 
cgit v1.2.3


From 2b6b85f1168206f6f53144b9c98ecc4ce2e74a88 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 4 Apr 2014 17:02:12 -0700
Subject: Add support for ** matches in ignores

This is an experimental addition to add ** support to fnmatch
pattern matching in libgit2.  It needs more testing.
---
 src/fnmatch.c       | 11 ++++++++---
 tests/attr/ignore.c | 13 +++++++++++++
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/src/fnmatch.c b/src/fnmatch.c
index e3e47f37b..8e5424b75 100644
--- a/src/fnmatch.c
+++ b/src/fnmatch.c
@@ -30,6 +30,7 @@ p_fnmatchx(const char *pattern, const char *string, int flags, size_t recurs)
 		const char *stringstart;
 		char *newp;
 		char c, test;
+		int recurs_flags = flags & ~FNM_PERIOD;
 
 		if (recurs-- == 0)
 				return FNM_NORES;
@@ -53,9 +54,13 @@ p_fnmatchx(const char *pattern, const char *string, int flags, size_t recurs)
 						break;
 				case '*':
 						c = *pattern;
-						/* Collapse multiple stars. */
-						while (c == '*')
+
+						/* Apply '**' to overwrite PATHNAME match */
+						if (c == '*') {
+							flags &= ~FNM_PATHNAME;
+							while (c == '*')
 								c = *++pattern;
+						}
 
 						if (*string == '.' && (flags & FNM_PERIOD) &&
 							(string == stringstart ||
@@ -80,7 +85,7 @@ p_fnmatchx(const char *pattern, const char *string, int flags, size_t recurs)
 						while ((test = *string) != EOS) {
 								int e;
 
-								e = p_fnmatchx(pattern, string, flags & ~FNM_PERIOD, recurs);
+								e = p_fnmatchx(pattern, string, recurs_flags, recurs);
 								if (e != FNM_NOMATCH)
 										return e;
 								if (test == '/' && (flags & FNM_PATHNAME))
diff --git a/tests/attr/ignore.c b/tests/attr/ignore.c
index 0f945ebf6..692f5e4ba 100644
--- a/tests/attr/ignore.c
+++ b/tests/attr/ignore.c
@@ -54,6 +54,19 @@ void test_attr_ignore__ignore_root(void)
 	assert_is_ignored(true, "NewFolder/NewFolder/File.txt");
 }
 
+void test_attr_ignore__full_paths(void)
+{
+	cl_git_rewritefile("attr/.gitignore", "Folder/*/Contained");
+
+	assert_is_ignored(true, "Folder/Middle/Contained");
+	assert_is_ignored(false, "Folder/Middle/More/More/Contained");
+
+	cl_git_rewritefile("attr/.gitignore", "Folder/**/Contained");
+
+	assert_is_ignored(true, "Folder/Middle/Contained");
+	assert_is_ignored(true, "Folder/Middle/More/More/Contained");
+}
+
 
 void test_attr_ignore__skip_gitignore_directory(void)
 {
-- 
cgit v1.2.3


From 4998009a28929affb3f22274b1024bc5a8cdbfb6 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sun, 6 Apr 2014 15:06:46 +0200
Subject: Don't lose our elements when calling git_vector_set()

---
 src/vector.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/vector.c b/src/vector.c
index e5d8919d3..67883cbc5 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -327,8 +327,10 @@ int git_vector_resize_to(git_vector *v, size_t new_length)
 
 int git_vector_set(void **old, git_vector *v, size_t position, void *value)
 {
-	if (git_vector_resize_to(v, position + 1) < 0)
-		return -1;
+	if (position + 1 > v->length) {
+		if (git_vector_resize_to(v, position + 1) < 0)
+			return -1;
+	}
 
 	if (old != NULL)
 		*old = v->contents[position];
-- 
cgit v1.2.3


From c8c91433a8c3c144273d4b362590ebc8761c0523 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Sun, 6 Apr 2014 10:42:26 -0700
Subject: More ** tests for pattern rules

---
 tests/attr/ignore.c  | 54 ++++++++++++++++++++++++++++++++++++++++++++++++----
 tests/clar_libgit2.h |  6 ++++--
 2 files changed, 54 insertions(+), 6 deletions(-)

diff --git a/tests/attr/ignore.c b/tests/attr/ignore.c
index 692f5e4ba..4ed92387c 100644
--- a/tests/attr/ignore.c
+++ b/tests/attr/ignore.c
@@ -16,13 +16,20 @@ void test_attr_ignore__cleanup(void)
 	g_repo = NULL;
 }
 
-void assert_is_ignored(bool expected, const char *filepath)
+void assert_is_ignored_(
+	bool expected, const char *filepath, const char *file, int line)
 {
-	int is_ignored;
+	int is_ignored = 0;
 
-	cl_git_pass(git_ignore_path_is_ignored(&is_ignored, g_repo, filepath));
-	cl_assert_equal_b(expected, is_ignored);
+	cl_git_pass_(
+		git_ignore_path_is_ignored(&is_ignored, g_repo, filepath), file, line);
+
+	clar__assert_equal(
+		file, line, "expected != is_ignored", 1, "%d",
+		(int)(expected != 0), (int)(is_ignored != 0));
 }
+#define assert_is_ignored(expected, filepath) \
+	assert_is_ignored_(expected, filepath, __FILE__, __LINE__)
 
 void test_attr_ignore__honor_temporary_rules(void)
 {
@@ -65,8 +72,47 @@ void test_attr_ignore__full_paths(void)
 
 	assert_is_ignored(true, "Folder/Middle/Contained");
 	assert_is_ignored(true, "Folder/Middle/More/More/Contained");
+
+	cl_git_rewritefile("attr/.gitignore", "Folder/**/Contained/*/Child");
+
+	assert_is_ignored(true, "Folder/Middle/Contained/Happy/Child");
+	assert_is_ignored(false, "Folder/Middle/Contained/Not/Happy/Child");
+	assert_is_ignored(true, "Folder/Middle/More/More/Contained/Happy/Child");
+	assert_is_ignored(false, "Folder/Middle/More/More/Contained/Not/Happy/Child");
 }
 
+void test_attr_ignore__leading_stars(void)
+{
+	cl_git_rewritefile(
+		"attr/.gitignore",
+		"*/onestar\n"
+		"**/twostars\n"
+		"*/parent1/kid1/*\n"
+		"**/parent2/kid2/*\n");
+
+	assert_is_ignored(true, "dir1/onestar");
+	assert_is_ignored(true, "dir1/onestar/child"); /* in ignored dir */
+	assert_is_ignored(false, "dir1/dir2/onestar");
+
+	assert_is_ignored(true, "dir1/twostars");
+	assert_is_ignored(true, "dir1/twostars/child"); /* in ignored dir */
+	assert_is_ignored(true, "dir1/dir2/twostars");
+	assert_is_ignored(true, "dir1/dir2/twostars/child"); /* in ignored dir */
+	assert_is_ignored(true, "dir1/dir2/dir3/twostars");
+
+	assert_is_ignored(true, "dir1/parent1/kid1/file");
+	assert_is_ignored(true, "dir1/parent1/kid1/file/inside/parent");
+	assert_is_ignored(false, "dir1/dir2/parent1/kid1/file");
+	assert_is_ignored(false, "dir1/parent1/file");
+	assert_is_ignored(false, "dir1/kid1/file");
+
+	assert_is_ignored(true, "dir1/parent2/kid2/file");
+	assert_is_ignored(true, "dir1/parent2/kid2/file/inside/parent");
+	assert_is_ignored(true, "dir1/dir2/parent2/kid2/file");
+	assert_is_ignored(true, "dir1/dir2/dir3/parent2/kid2/file");
+	assert_is_ignored(false, "dir1/parent2/file");
+	assert_is_ignored(false, "dir1/kid2/file");
+}
 
 void test_attr_ignore__skip_gitignore_directory(void)
 {
diff --git a/tests/clar_libgit2.h b/tests/clar_libgit2.h
index 915111244..3de80bfa0 100644
--- a/tests/clar_libgit2.h
+++ b/tests/clar_libgit2.h
@@ -11,11 +11,13 @@
  *
  * Use this wrapper around all `git_` library calls that return error codes!
  */
-#define cl_git_pass(expr) do { \
+#define cl_git_pass(expr) cl_git_pass_(expr, __FILE__, __LINE__)
+
+#define cl_git_pass_(expr, file, line) do { \
 	int _lg2_error; \
 	giterr_clear(); \
 	if ((_lg2_error = (expr)) != 0) \
-		cl_git_report_failure(_lg2_error, __FILE__, __LINE__, "Function call failed: " #expr); \
+		cl_git_report_failure(_lg2_error, file, line, "Function call failed: " #expr); \
 	} while (0)
 
 /**
-- 
cgit v1.2.3


From c7d9606066d3a9b75a87c4ca5dd3420a66d0b54f Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Sun, 6 Apr 2014 11:20:22 -0700
Subject: Fix fnmatch comment to be clearer

---
 src/fnmatch.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/fnmatch.c b/src/fnmatch.c
index 8e5424b75..3846bab3c 100644
--- a/src/fnmatch.c
+++ b/src/fnmatch.c
@@ -55,7 +55,9 @@ p_fnmatchx(const char *pattern, const char *string, int flags, size_t recurs)
 				case '*':
 						c = *pattern;
 
-						/* Apply '**' to overwrite PATHNAME match */
+						/* Let '**' override PATHNAME match for this segment.
+						 * It will be restored if/when we recurse below.
+						 */
 						if (c == '*') {
 							flags &= ~FNM_PATHNAME;
 							while (c == '*')
-- 
cgit v1.2.3


From c031129510a4bfaef9b2563de3a8ae82d04f5b6c Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 7 Apr 2014 17:32:23 +0200
Subject: git_repository_state_cleanup() should remove rebase-merge/,
 rebase-apply/ and BISECT_LOG

---
 src/repository.c   |  7 ++++++-
 tests/repo/state.c | 18 ++++++++++++++++++
 2 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/repository.c b/src/repository.c
index 49d1bc63e..37aba4b81 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1966,7 +1966,9 @@ int git_repository__cleanup_files(git_repository *repo, const char *files[], siz
 
 		if ((error = git_buf_joinpath(&path, repo->path_repository, files[i])) < 0 ||
 			(git_path_isfile(git_buf_cstr(&path)) &&
-			(error = p_unlink(git_buf_cstr(&path))) < 0))
+			(error = p_unlink(git_buf_cstr(&path))) < 0) ||
+			(git_path_isdir(git_buf_cstr(&path)) &&
+			(error = git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS)) < 0))
 			goto done;
 	}
 
@@ -1982,6 +1984,9 @@ static const char *state_files[] = {
 	GIT_MERGE_MSG_FILE,
 	GIT_REVERT_HEAD_FILE,
 	GIT_CHERRY_PICK_HEAD_FILE,
+	GIT_BISECT_LOG_FILE,
+	GIT_REBASE_MERGE_DIR,
+	GIT_REBASE_APPLY_DIR,
 };
 
 int git_repository_state_cleanup(git_repository *repo)
diff --git a/tests/repo/state.c b/tests/repo/state.c
index 5e7227205..2d6c780ee 100644
--- a/tests/repo/state.c
+++ b/tests/repo/state.c
@@ -45,52 +45,70 @@ void test_repo_state__merge(void)
 {
 	setup_simple_state(GIT_MERGE_HEAD_FILE);
 	assert_repo_state(GIT_REPOSITORY_STATE_MERGE);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
 void test_repo_state__revert(void)
 {
 	setup_simple_state(GIT_REVERT_HEAD_FILE);
 	assert_repo_state(GIT_REPOSITORY_STATE_REVERT);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
 void test_repo_state__cherry_pick(void)
 {
 	setup_simple_state(GIT_CHERRY_PICK_HEAD_FILE);
 	assert_repo_state(GIT_REPOSITORY_STATE_CHERRY_PICK);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
 void test_repo_state__bisect(void)
 {
 	setup_simple_state(GIT_BISECT_LOG_FILE);
 	assert_repo_state(GIT_REPOSITORY_STATE_BISECT);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
 void test_repo_state__rebase_interactive(void)
 {
 	setup_simple_state(GIT_REBASE_MERGE_INTERACTIVE_FILE);
 	assert_repo_state(GIT_REPOSITORY_STATE_REBASE_INTERACTIVE);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
 void test_repo_state__rebase_merge(void)
 {
 	setup_simple_state(GIT_REBASE_MERGE_DIR "whatever");
 	assert_repo_state(GIT_REPOSITORY_STATE_REBASE_MERGE);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
 void test_repo_state__rebase(void)
 {
 	setup_simple_state(GIT_REBASE_APPLY_REBASING_FILE);
 	assert_repo_state(GIT_REPOSITORY_STATE_REBASE);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
 void test_repo_state__apply_mailbox(void)
 {
 	setup_simple_state(GIT_REBASE_APPLY_APPLYING_FILE);
 	assert_repo_state(GIT_REPOSITORY_STATE_APPLY_MAILBOX);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
 
 void test_repo_state__apply_mailbox_or_rebase(void)
 {
 	setup_simple_state(GIT_REBASE_APPLY_DIR "whatever");
 	assert_repo_state(GIT_REPOSITORY_STATE_APPLY_MAILBOX_OR_REBASE);
+	cl_git_pass(git_repository_state_cleanup(_repo));
+	assert_repo_state(GIT_REPOSITORY_STATE_NONE);
 }
-- 
cgit v1.2.3


From 553184a76245617556373af4cb5343e7fe58f41f Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Thu, 3 Apr 2014 10:53:42 +0200
Subject: Update AUTHORS

---
 AUTHORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/AUTHORS b/AUTHORS
index f3a03ee74..6854ed016 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -25,6 +25,7 @@ Florian Forster
 Holger Weiss
 Ingmar Vanhassel
 J. David Ibáñez
+Jacques Germishuys
 Jakob Pfender
 Jason Penny
 Jason R. McNeil
-- 
cgit v1.2.3


From c813b345503f7b086da7ca1b2d95270e00594323 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 7 Apr 2014 11:45:32 -0700
Subject: Fix bug with multiple iconv conversions in one dir

The internal buffer in the `git_path_iconv_t` structure was not
being reset before the calls to `iconv` were made to convert data,
so if there were multiple decomposed Unicode paths in a single
directory, paths after the first one were being appended to the
first instead of treated as independent data.
---
 src/path.c         |  2 ++
 tests/core/iconv.c | 12 +++++++++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/path.c b/src/path.c
index 1dccf90da..56b6c87f9 100644
--- a/src/path.c
+++ b/src/path.c
@@ -782,6 +782,8 @@ int git_path_iconv(git_path_iconv_t *ic, char **in, size_t *inlen)
 		!git_path_has_non_ascii(*in, *inlen))
 		return 0;
 
+	git_buf_truncate(&ic->buf, 0);
+
 	while (1) {
 		if (git_buf_grow(&ic->buf, wantlen + 1) < 0)
 			return -1;
diff --git a/tests/core/iconv.c b/tests/core/iconv.c
index 8aedab206..cb85f458a 100644
--- a/tests/core/iconv.c
+++ b/tests/core/iconv.c
@@ -39,8 +39,9 @@ void test_core_iconv__decomposed_to_precomposed(void)
 {
 #ifdef GIT_USE_ICONV
 	char *data = nfd;
-	size_t datalen = strlen(nfd);
+	size_t datalen, nfdlen = strlen(nfd);
 
+	datalen = nfdlen;
 	cl_git_pass(git_path_iconv(&ic, &data, &datalen));
 	GIT_UNUSED(datalen);
 
@@ -48,6 +49,15 @@ void test_core_iconv__decomposed_to_precomposed(void)
 	 * (on platforms where iconv is enabled, of course).
 	 */
 	cl_assert_equal_s(nfc, data);
+
+	/* should be able to do it multiple times with the same git_path_iconv_t */
+	data = nfd; datalen = nfdlen;
+	cl_git_pass(git_path_iconv(&ic, &data, &datalen));
+	cl_assert_equal_s(nfc, data);
+
+	data = nfd; datalen = nfdlen;
+	cl_git_pass(git_path_iconv(&ic, &data, &datalen));
+	cl_assert_equal_s(nfc, data);
 #endif
 }
 
-- 
cgit v1.2.3


From 7167fd7ef80f5f34337dd1c696f77ea2bb4d8bd8 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 7 Apr 2014 11:51:12 -0700
Subject: vmg is always right

---
 src/path.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/path.c b/src/path.c
index 56b6c87f9..7cad28d45 100644
--- a/src/path.c
+++ b/src/path.c
@@ -782,7 +782,7 @@ int git_path_iconv(git_path_iconv_t *ic, char **in, size_t *inlen)
 		!git_path_has_non_ascii(*in, *inlen))
 		return 0;
 
-	git_buf_truncate(&ic->buf, 0);
+	git_buf_clear(&ic->buf);
 
 	while (1) {
 		if (git_buf_grow(&ic->buf, wantlen + 1) < 0)
-- 
cgit v1.2.3


From 855c66de66fe39fe219c6dab9d614c6e9d633d9c Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Thu, 27 Mar 2014 16:34:20 -0700
Subject: Introduce core.safecrlf handling

---
 src/config_cache.c  |  1 +
 src/crlf.c          | 34 +++++++++++++++++++++--
 src/repository.h    |  4 ++-
 tests/filter/crlf.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 116 insertions(+), 3 deletions(-)

diff --git a/src/config_cache.c b/src/config_cache.c
index ec75d1501..4bcbf02bf 100644
--- a/src/config_cache.c
+++ b/src/config_cache.c
@@ -68,6 +68,7 @@ static struct map_data _cvar_maps[] = {
 	{"core.trustctime", NULL, 0, GIT_TRUSTCTIME_DEFAULT },
 	{"core.abbrev", _cvar_map_int, 1, GIT_ABBREV_DEFAULT },
 	{"core.precomposeunicode", NULL, 0, GIT_PRECOMPOSE_DEFAULT },
+	{"core.safecrlf", NULL, 0, GIT_SAFE_CRLF_DEFAULT},
 };
 
 int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
diff --git a/src/crlf.c b/src/crlf.c
index 2480cc918..645ada2c6 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -21,6 +21,7 @@ struct crlf_attrs {
 	int crlf_action;
 	int eol;
 	int auto_crlf;
+	int safe_crlf;
 };
 
 struct crlf_filter {
@@ -123,6 +124,9 @@ static int crlf_apply_to_odb(
 	const git_buf *from,
 	const git_filter_source *src)
 {
+	git_buf safe = GIT_BUF_INIT;
+	int error = 0;
+
 	/* Empty file? Nothing to do */
 	if (!git_buf_len(from))
 		return 0;
@@ -154,12 +158,31 @@ static int crlf_apply_to_odb(
 				return GIT_PASSTHROUGH;
 		}
 
-		if (!stats.cr)
+		if (!stats.cr && !ca->safe_crlf)
 			return GIT_PASSTHROUGH;
 	}
 
 	/* Actually drop the carriage returns */
-	return git_buf_text_crlf_to_lf(to, from);
+	if ((error = git_buf_text_crlf_to_lf(to, from)) < 0)
+		return error;
+
+	/* If safecrlf is enabled, sanity-check the result. */
+	if (ca->safe_crlf) {
+		if ((error = git_buf_grow(&safe, max(from->size, to->size))) < 0 ||
+			(error = git_buf_text_lf_to_crlf(&safe, to)) < 0)
+			goto done;
+
+		if (git_buf_cmp(from, &safe) != 0) {
+			giterr_set(GITERR_FILTER, "LF would be replaced by CRLF in '%s'",
+				git_filter_source_path(src));
+			error = -1;
+		}
+	}
+
+done:
+	git_buf_free(&safe);
+
+	return error;
 }
 
 static const char *line_ending(struct crlf_attrs *ca)
@@ -272,6 +295,13 @@ static int crlf_check(
 			return GIT_PASSTHROUGH;
 	}
 
+	if (git_filter_source_mode(src) == GIT_FILTER_CLEAN) {
+		error = git_repository__cvar(
+			&ca.safe_crlf, git_filter_source_repo(src), GIT_CVAR_SAFE_CRLF);
+		if (error < 0)
+			return error;
+	}
+
 	*payload = git__malloc(sizeof(ca));
 	GITERR_CHECK_ALLOC(*payload);
 	memcpy(*payload, &ca, sizeof(ca));
diff --git a/src/repository.h b/src/repository.h
index 99923b63b..e401a82b8 100644
--- a/src/repository.h
+++ b/src/repository.h
@@ -38,6 +38,7 @@ typedef enum {
 	GIT_CVAR_TRUSTCTIME,    /* core.trustctime */
 	GIT_CVAR_ABBREV,        /* core.abbrev */
 	GIT_CVAR_PRECOMPOSE,    /* core.precomposeunicode */
+	GIT_CVAR_SAFE_CRLF,		/* core.safecrlf */
 	GIT_CVAR_CACHE_MAX
 } git_cvar_cached;
 
@@ -89,7 +90,8 @@ typedef enum {
 	GIT_ABBREV_DEFAULT = 7,
 	/* core.precomposeunicode */
 	GIT_PRECOMPOSE_DEFAULT = GIT_CVAR_FALSE,
-
+	/* core.safecrlf */
+	GIT_SAFE_CRLF_DEFAULT = GIT_CVAR_FALSE,
 } git_cvar_value;
 
 /* internal repository init flags */
diff --git a/tests/filter/crlf.c b/tests/filter/crlf.c
index c9fb9cd7f..75320efee 100644
--- a/tests/filter/crlf.c
+++ b/tests/filter/crlf.c
@@ -1,5 +1,6 @@
 #include "clar_libgit2.h"
 #include "git2/sys/filter.h"
+#include "buffer.h"
 
 static git_repository *g_repo = NULL;
 
@@ -69,3 +70,82 @@ void test_filter_crlf__to_odb(void)
 	git_filter_list_free(fl);
 	git_buf_free(&out);
 }
+
+void test_filter_crlf__with_safecrlf(void)
+{
+	git_filter_list *fl;
+	git_filter *crlf;
+	git_buf in = {0}, out = GIT_BUF_INIT;
+
+	cl_repo_set_bool(g_repo, "core.safecrlf", true);
+
+	cl_git_pass(git_filter_list_new(&fl, g_repo, GIT_FILTER_TO_ODB));
+
+	crlf = git_filter_lookup(GIT_FILTER_CRLF);
+	cl_assert(crlf != NULL);
+
+	cl_git_pass(git_filter_list_push(fl, crlf, NULL));
+
+	/* Normalized \r\n succeeds with safecrlf */
+	in.ptr = "Normal\r\nCRLF\r\nline-endings.\r\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr);
+
+	/* Mix of line endings fails with safecrlf */
+	in.ptr = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_fail(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_i(giterr_last()->klass, GITERR_FILTER);
+
+	/* Normalized \n fails with safecrlf */
+	in.ptr = "Normal\nLF\nonly\nline-endings.\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_fail(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_i(giterr_last()->klass, GITERR_FILTER);
+
+	git_filter_list_free(fl);
+	git_buf_free(&out);
+}
+
+void test_filter_crlf__no_safecrlf(void)
+{
+	git_filter_list *fl;
+	git_filter *crlf;
+	git_buf in = {0}, out = GIT_BUF_INIT;
+
+	cl_git_pass(git_filter_list_new(&fl, g_repo, GIT_FILTER_TO_ODB));
+
+	crlf = git_filter_lookup(GIT_FILTER_CRLF);
+	cl_assert(crlf != NULL);
+
+	cl_git_pass(git_filter_list_push(fl, crlf, NULL));
+
+	/* Normalized \r\n succeeds with safecrlf */
+	in.ptr = "Normal\r\nCRLF\r\nline-endings.\r\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr);
+
+	/* Mix of line endings fails with safecrlf */
+	in.ptr = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr);
+
+	/* Normalized \n fails with safecrlf */
+	in.ptr = "Normal\nLF\nonly\nline-endings.\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_s("Normal\nLF\nonly\nline-endings.\n", out.ptr);
+
+	git_filter_list_free(fl);
+	git_buf_free(&out);
+}
+
-- 
cgit v1.2.3


From 7be1caf7f54bff938c71a616f38e9ac375a0b137 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 7 Apr 2014 21:41:36 -0700
Subject: Determine crlf safety by statistics, not literal reversibility

---
 src/crlf.c | 33 +++++++++------------------------
 1 file changed, 9 insertions(+), 24 deletions(-)

diff --git a/src/crlf.c b/src/crlf.c
index 645ada2c6..8be1b9a05 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -124,9 +124,6 @@ static int crlf_apply_to_odb(
 	const git_buf *from,
 	const git_filter_source *src)
 {
-	git_buf safe = GIT_BUF_INIT;
-	int error = 0;
-
 	/* Empty file? Nothing to do */
 	if (!git_buf_len(from))
 		return 0;
@@ -141,6 +138,13 @@ static int crlf_apply_to_odb(
 		if (git_buf_text_gather_stats(&stats, from, false))
 			return GIT_PASSTHROUGH;
 
+		/* If safecrlf is enabled, sanity-check the result. */
+		if (ca->safe_crlf && (stats.cr != stats.crlf || stats.lf != stats.crlf)) {
+			giterr_set(GITERR_FILTER, "LF would be replaced by CRLF in '%s'",
+				git_filter_source_path(src));
+			return -1;
+		}
+
 		/*
 		 * We're currently not going to even try to convert stuff
 		 * that has bare CR characters. Does anybody do that crazy
@@ -158,31 +162,12 @@ static int crlf_apply_to_odb(
 				return GIT_PASSTHROUGH;
 		}
 
-		if (!stats.cr && !ca->safe_crlf)
+		if (!stats.cr)
 			return GIT_PASSTHROUGH;
 	}
 
 	/* Actually drop the carriage returns */
-	if ((error = git_buf_text_crlf_to_lf(to, from)) < 0)
-		return error;
-
-	/* If safecrlf is enabled, sanity-check the result. */
-	if (ca->safe_crlf) {
-		if ((error = git_buf_grow(&safe, max(from->size, to->size))) < 0 ||
-			(error = git_buf_text_lf_to_crlf(&safe, to)) < 0)
-			goto done;
-
-		if (git_buf_cmp(from, &safe) != 0) {
-			giterr_set(GITERR_FILTER, "LF would be replaced by CRLF in '%s'",
-				git_filter_source_path(src));
-			error = -1;
-		}
-	}
-
-done:
-	git_buf_free(&safe);
-
-	return error;
+	return git_buf_text_crlf_to_lf(to, from);
 }
 
 static const char *line_ending(struct crlf_attrs *ca)
-- 
cgit v1.2.3


From 56f8e06e4985f7b14c1bf7c526a5195ba24fd6ee Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Tue, 8 Apr 2014 15:46:45 +0200
Subject: Correct grouping of parentheses

git_graph_descendant_of was returning the result of an assignment
---
 src/graph.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/graph.c b/src/graph.c
index 96fda7add..1c6441140 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -180,7 +180,7 @@ int git_graph_descendant_of(git_repository *repo, const git_oid *commit, const g
 	if (git_oid_equal(commit, ancestor))
 		return 0;
 
-	if ((error = git_merge_base(&merge_base, repo, commit, ancestor) < 0))
+	if ((error = git_merge_base(&merge_base, repo, commit, ancestor)) < 0)
 		return error;
 
 	return git_oid_equal(&merge_base, ancestor);
-- 
cgit v1.2.3


From 8a8e312792807dda38fbe417ec5d511f767f3ace Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Tue, 8 Apr 2014 16:20:49 +0200
Subject: Added a no path test for git_graph_descendant_of

---
 tests/graph/descendant_of.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/graph/descendant_of.c b/tests/graph/descendant_of.c
index ffdd0cfc8..8e9952a09 100644
--- a/tests/graph/descendant_of.c
+++ b/tests/graph/descendant_of.c
@@ -45,3 +45,11 @@ void test_graph_descendant_of__returns_correct_result(void)
 	git_commit_free(other);
 
 }
+
+void test_graph_descendant_of__nopath(void)
+{
+	git_oid oid;
+
+	git_oid_fromstr(&oid, "e90810b8df3e80c413d903f631643c716887138d");
+	cl_assert_equal_i(0, git_graph_descendant_of(_repo, git_commit_id(commit), &oid));
+}
-- 
cgit v1.2.3


From ce2e82694a19b9994acaa9376bff81bc8e968637 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 8 Apr 2014 16:52:20 +0200
Subject: graph: handle not finding a merge base gracefully

git_merge_base() returns GIT_ENOTFOUND when it cannot find a merge
base. graph_desdendant_of() returns a boolean value (barring any
errors), so it needs to catch the NOTFOUND return value and convert it
into false, as not merge base means it cannot be a descendant.
---
 src/graph.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/graph.c b/src/graph.c
index 1c6441140..1c264d997 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -180,7 +180,12 @@ int git_graph_descendant_of(git_repository *repo, const git_oid *commit, const g
 	if (git_oid_equal(commit, ancestor))
 		return 0;
 
-	if ((error = git_merge_base(&merge_base, repo, commit, ancestor)) < 0)
+	error = git_merge_base(&merge_base, repo, commit, ancestor);
+	/* No merge-base found, it's not a descendant */
+	if (error == GIT_ENOTFOUND)
+		return 0;
+
+	if (error < 0)
 		return error;
 
 	return git_oid_equal(&merge_base, ancestor);
-- 
cgit v1.2.3


From eb7e17cc900f1f59f653cd7b277750fb1d5b721a Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 8 Apr 2014 14:47:20 -0700
Subject: Update submodules with parent-tracked content

This updates how libgit2 treats submodule-like directories that
actually have tracked content inside of them.  This is a strange
corner case, but it seems that many people have abortive submodule
setups and then just went ahead and added the files into the
parent repository.  In this case, we should just treat the
submodule as if it was a normal directory.

Libgit2 will still try to skip over real submodules and contained
repositories that do not have tracked files inside them, but this
adds some new handling for cases where the apparently submodule
data is in conflict with the actual list of tracked files.
---
 src/diff.c                | 12 +++++-
 tests/status/submodules.c | 93 +++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 101 insertions(+), 4 deletions(-)

diff --git a/src/diff.c b/src/diff.c
index 484273f4a..e62f45c22 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -876,7 +876,7 @@ static int handle_unmatched_new_item(
 			 DIFF_FLAG_IS_SET(diff, GIT_DIFF_RECURSE_IGNORED_DIRS));
 
 		/* do not advance into directories that contain a .git file */
-		if (recurse_into_dir) {
+		if (recurse_into_dir && !contains_oitem) {
 			git_buf *full = NULL;
 			if (git_iterator_current_workdir_path(&full, info->new_iter) < 0)
 				return -1;
@@ -969,6 +969,16 @@ static int handle_unmatched_new_item(
 		if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {
 			giterr_clear();
 			delta_type = GIT_DELTA_IGNORED;
+
+			/* if this contains a tracked item, treat as normal TREE */
+			if (contains_oitem) {
+				error = git_iterator_advance_into(&info->nitem, info->new_iter);
+				if (error != GIT_ENOTFOUND)
+					return error;
+
+				giterr_clear();
+				return git_iterator_advance(&info->nitem, info->new_iter);
+			}
 		}
 	}
 
diff --git a/tests/status/submodules.c b/tests/status/submodules.c
index 6d0d63a5f..63cf73f36 100644
--- a/tests/status/submodules.c
+++ b/tests/status/submodules.c
@@ -1,7 +1,5 @@
 #include "clar_libgit2.h"
-#include "buffer.h"
-#include "path.h"
-#include "posix.h"
+#include "fileops.h"
 #include "status_helpers.h"
 #include "../submodule/submodule_helpers.h"
 
@@ -389,3 +387,92 @@ void test_status_submodules__contained_untracked_repo(void)
 		g_repo, &opts, cb_status__match, &counts));
 	cl_assert_equal_i(5, counts.entry_count);
 }
+
+void test_status_submodules__broken_stuff_that_git_allows(void)
+{
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	status_entry_counts counts;
+	git_repository *contained;
+	static const char *expected_files_with_broken[] = {
+		".gitmodules",
+		"added",
+		"broken/tracked",
+		"deleted",
+		"ignored",
+		"modified",
+		"untracked"
+	};
+	static unsigned int expected_status_with_broken[] = {
+		GIT_STATUS_WT_MODIFIED,
+		GIT_STATUS_INDEX_NEW,
+		GIT_STATUS_INDEX_NEW,
+		GIT_STATUS_INDEX_DELETED,
+		GIT_STATUS_IGNORED,
+		GIT_STATUS_WT_MODIFIED,
+		GIT_STATUS_WT_NEW,
+	};
+
+	g_repo = setup_fixture_submodules();
+
+	opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RECURSE_UNTRACKED_DIRS |
+		GIT_STATUS_OPT_INCLUDE_IGNORED;
+
+	/* make a directory and stick a tracked item into the index */
+	{
+		git_index *idx;
+		cl_must_pass(p_mkdir("submodules/broken", 0777));
+		cl_git_mkfile("submodules/broken/tracked", "tracked content");
+		cl_git_pass(git_repository_index(&idx, g_repo));
+		cl_git_pass(git_index_add_bypath(idx, "broken/tracked"));
+		cl_git_pass(git_index_write(idx));
+		git_index_free(idx);
+	}
+
+	status_counts_init(
+		counts, expected_files_with_broken, expected_status_with_broken);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(7, counts.entry_count);
+
+	/* directory with tracked items that looks a little bit like a repo */
+
+	cl_must_pass(p_mkdir("submodules/broken/.git", 0777));
+	cl_must_pass(p_mkdir("submodules/broken/.git/info", 0777));
+	cl_git_mkfile("submodules/broken/.git/info/exclude", "# bogus");
+
+	status_counts_init(
+		counts, expected_files_with_broken, expected_status_with_broken);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(7, counts.entry_count);
+
+	/* directory with tracked items that is a repo */
+
+	cl_git_pass(git_futils_rmdir_r(
+		"submodules/broken/.git", NULL, GIT_RMDIR_REMOVE_FILES));
+	cl_git_pass(git_repository_init(&contained, "submodules/broken", false));
+	git_repository_free(contained);
+
+	status_counts_init(
+		counts, expected_files_with_broken, expected_status_with_broken);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(7, counts.entry_count);
+
+	/* directory with tracked items that claims to be a submodule but is not */
+
+	cl_git_pass(git_futils_rmdir_r(
+		"submodules/broken/.git", NULL, GIT_RMDIR_REMOVE_FILES));
+	cl_git_append2file("submodules/.gitmodules",
+		"\n[submodule \"broken\"]\n"
+		"\tpath = broken\n"
+		"\turl = https://github.com/not/used\n\n");
+
+	status_counts_init(
+		counts, expected_files_with_broken, expected_status_with_broken);
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__match, &counts));
+	cl_assert_equal_i(7, counts.entry_count);
+}
+
-- 
cgit v1.2.3


From 76b4e3d4deef499654ccf082e6ee585f4db873ec Mon Sep 17 00:00:00 2001
From: Jeff King <peff@peff.net>
Date: Tue, 8 Apr 2014 18:41:39 -0400
Subject: userdiff: update C/C++ patterns

This pulls upstream changes from:

  git/git@8a2e8da367f7175465118510b474ad365161d6b1

  git/git@abf8f9860248d8c213600974742f18dadaa8fbb5

  git/git@407e07f2a6f55e605fda9e90cb622887269f68b5

all by Johannes Sixt <j6t@kdbg.org>.
---
 src/userdiff.h | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/userdiff.h b/src/userdiff.h
index 7eb095246..bd6943361 100644
--- a/src/userdiff.h
+++ b/src/userdiff.h
@@ -159,15 +159,13 @@ PATTERNS("tex", "^(\\\\((sub)*section|chapter|part)\\*{0,1}\\{.*)$",
 
 PATTERNS("cpp",
 	 /* Jump targets or access declarations */
-	 "!^[ \t]*[A-Za-z_][A-Za-z_0-9]*:.*$\n"
-	 /* C/++ functions/methods at top level */
-	 "^([A-Za-z_][A-Za-z_0-9]*([ \t*]+[A-Za-z_][A-Za-z_0-9]*([ \t]*::[ \t]*[^[:space:]]+)?){1,}[ \t]*\\([^;]*)$\n"
-	 /* compound type at top level */
-	 "^((struct|class|enum)[^;]*)$",
+	 "!^[ \t]*[A-Za-z_][A-Za-z_0-9]*:[[:space:]]*($|/[/*])\n"
+	 /* functions/methods, variables, and compounds at top level */
+	 "^((::[[:space:]]*)?[A-Za-z_].*)$",
 	 /* -- */
 	 "[a-zA-Z_][a-zA-Z0-9_]*"
-	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lL]?"
-	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->"),
+	 "|[-+0-9.e]+[fFlL]?|0[xXbB]?[0-9a-fA-F]+[lLuU]*"
+	 "|[-+*/<>%&^|=!]=|--|\\+\\+|<<=?|>>=?|&&|\\|\\||::|->\\*?|\\.\\*"),
 
 PATTERNS("csharp",
 	 /* Keywords */
-- 
cgit v1.2.3


From 9ce60fadda2a333756523299bff7772d05e69457 Mon Sep 17 00:00:00 2001
From: Jeff King <peff@peff.net>
Date: Tue, 8 Apr 2014 18:40:05 -0400
Subject: userdiff: update ada patterns

This is the moral equivalent of

  git/git@39a87a29ce364ed3337e535adce5973731ba2968

from Adrian Johnson <ajohnson@redneon.com>.
---
 src/userdiff.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/userdiff.h b/src/userdiff.h
index bd6943361..523f2f8d4 100644
--- a/src/userdiff.h
+++ b/src/userdiff.h
@@ -45,13 +45,13 @@ typedef struct {
 static git_diff_driver_definition builtin_defs[] = {
 
 IPATTERN("ada",
-	 "!^(.*[ \t])?(is new|renames|is separate)([ \t].*)?$\n"
+	 "!^(.*[ \t])?(is[ \t]+new|renames|is[ \t]+separate)([ \t].*)?$\n"
 	 "!^[ \t]*with[ \t].*$\n"
 	 "^[ \t]*((procedure|function)[ \t]+.*)$\n"
 	 "^[ \t]*((package|protected|task)[ \t]+.*)$",
 	 /* -- */
 	 "[a-zA-Z][a-zA-Z0-9_]*"
-	 "|[0-9][-+0-9#_.eE]"
+	 "|[-+]?[0-9][0-9#_.aAbBcCdDeEfF]*([eE][+-]?[0-9_]+)?"
 	 "|=>|\\.\\.|\\*\\*|:=|/=|>=|<=|<<|>>|<>"),
 
 IPATTERN("fortran",
-- 
cgit v1.2.3


From c3dcbe8488c6240392e8a5d7553bbffcb0f94ef0 Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Wed, 9 Apr 2014 12:43:27 +0200
Subject: Rewrite `git_repository__cleanup_files`

---
 src/repository.c | 34 ++++++++++++++++++++--------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/src/repository.c b/src/repository.c
index 37aba4b81..6b2705bfa 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1955,26 +1955,32 @@ int git_repository_state(git_repository *repo)
 	return state;
 }
 
-int git_repository__cleanup_files(git_repository *repo, const char *files[], size_t files_len)
+int git_repository__cleanup_files(
+	git_repository *repo, const char *files[], size_t files_len)
 {
-	git_buf path = GIT_BUF_INIT;
+	git_buf buf = GIT_BUF_INIT;
 	size_t i;
-	int error = 0;
+	int error;
 
-	for (i = 0; i < files_len; ++i) {
-		git_buf_clear(&path);
+	for (error = 0, i = 0; !error && i < files_len; ++i) {
+		const char *path;
 
-		if ((error = git_buf_joinpath(&path, repo->path_repository, files[i])) < 0 ||
-			(git_path_isfile(git_buf_cstr(&path)) &&
-			(error = p_unlink(git_buf_cstr(&path))) < 0) ||
-			(git_path_isdir(git_buf_cstr(&path)) &&
-			(error = git_futils_rmdir_r(git_buf_cstr(&path), NULL, GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS)) < 0))
-			goto done;
-	}
+		if (git_buf_joinpath(&buf, repo->path_repository, files[i]) < 0)
+			return -1;
 
-done:
-	git_buf_free(&path);
+		path = git_buf_cstr(&buf);
+
+		if (git_path_isfile(path)) {
+			error = p_unlink(path);
+		} else if (git_path_isdir(path)) {
+			error = git_futils_rmdir_r(path, NULL,
+				GIT_RMDIR_REMOVE_FILES | GIT_RMDIR_REMOVE_BLOCKERS);
+		}
+			
+		git_buf_clear(&buf);
+	}
 
+	git_buf_free(&buf);
 	return error;
 }
 
-- 
cgit v1.2.3


From b3b36a68d16f1fdc383a06fbe85c3cc042d86314 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Thu, 10 Apr 2014 12:43:16 +0200
Subject: Introduce git_buf_putcn

Allows for inserting the same character n amount of times
---
 src/buffer.c | 9 +++++++++
 src/buffer.h | 1 +
 2 files changed, 10 insertions(+)

diff --git a/src/buffer.c b/src/buffer.c
index 83960e912..f6e34a445 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -148,6 +148,15 @@ int git_buf_putc(git_buf *buf, char c)
 	return 0;
 }
 
+int git_buf_putcn(git_buf *buf, char c, size_t len)
+{
+	ENSURE_SIZE(buf, buf->size + len + 1);
+	memset(buf->ptr + buf->size, c, len);
+	buf->size += len;
+	buf->ptr[buf->size] = '\0';
+	return 0;
+}
+
 int git_buf_put(git_buf *buf, const char *data, size_t len)
 {
 	ENSURE_SIZE(buf, buf->size + len + 1);
diff --git a/src/buffer.h b/src/buffer.h
index dba594d97..398aec9b7 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -88,6 +88,7 @@ GIT_INLINE(bool) git_buf_oom(const git_buf *buf)
  */
 int git_buf_sets(git_buf *buf, const char *string);
 int git_buf_putc(git_buf *buf, char c);
+int git_buf_putcn(git_buf *buf, char c, size_t len);
 int git_buf_put(git_buf *buf, const char *data, size_t len);
 int git_buf_puts(git_buf *buf, const char *string);
 int git_buf_printf(git_buf *buf, const char *format, ...) GIT_FORMAT_PRINTF(2, 3);
-- 
cgit v1.2.3


From 8f7bc6461b81499216b73881b07f5476c5085660 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 10 Apr 2014 16:33:39 -0700
Subject: Fix bug popping ignore files during wd iteration

There were a couple bugs in popping ignore files during iteration
that could result in incorrect decisions be made and thus ignore
files below the root either not being loaded correctly or not
being popped at the right time.

One bug was an off-by-one in comparing the path of the gitignore
file with the path being exited during iteration.

The second bug was not correctly truncating the path being tracked
during traversal if there were no ignores on the list (i.e. when
you have no .gitignore at the root, but do have some in contained
directories).
---
 src/ignore.c          |  11 ++++-
 src/ignore.h          |   1 +
 tests/status/ignore.c | 111 ++++++++++++++++++++++++++++++++++++--------------
 3 files changed, 92 insertions(+), 31 deletions(-)

diff --git a/src/ignore.c b/src/ignore.c
index c79fe4871..aef3e39b4 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -78,6 +78,8 @@ static int push_one_ignore(void *payload, git_buf *path)
 {
 	git_ignores *ign = payload;
 
+	ign->depth++;
+
 	return push_ignore_file(
 		ign->repo, ign, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
 }
@@ -108,6 +110,7 @@ int git_ignore__for_path(
 	ignores->repo = repo;
 	git_buf_init(&ignores->dir, 0);
 	ignores->ign_internal = NULL;
+	ignores->depth = 0;
 
 	/* Read the ignore_case flag */
 	if ((error = git_repository__cvar(
@@ -163,6 +166,8 @@ int git_ignore__push_dir(git_ignores *ign, const char *dir)
 	if (git_buf_joinpath(&ign->dir, ign->dir.ptr, dir) < 0)
 		return -1;
 
+	ign->depth++;
+
 	return push_ignore_file(
 		ign->repo, ign, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE);
 }
@@ -174,7 +179,7 @@ int git_ignore__pop_dir(git_ignores *ign)
 		const char *start, *end, *scan;
 		size_t keylen;
 
-		/* - ign->dir looks something like "a/b" (or "a/b/c/d")
+		/* - ign->dir looks something like "a/b/" (or "a/b/c/d/")
 		 * - file->key looks something like "0#a/b/.gitignore
 		 *
 		 * We are popping the last directory off ign->dir.  We also want to
@@ -191,9 +196,13 @@ int git_ignore__pop_dir(git_ignores *ign)
 		if (ign->dir.size >= keylen &&
 			!memcmp(ign->dir.ptr + ign->dir.size - keylen, start, keylen))
 			git_vector_pop(&ign->ign_path);
+	}
 
+	if (--ign->depth > 0) {
 		git_buf_rtruncate_at_char(&ign->dir, '/');
+		git_path_to_dir(&ign->dir);
 	}
+
 	return 0;
 }
 
diff --git a/src/ignore.h b/src/ignore.h
index 851c824bf..46172c72f 100644
--- a/src/ignore.h
+++ b/src/ignore.h
@@ -29,6 +29,7 @@ typedef struct {
 	git_vector ign_path;
 	git_vector ign_global;
 	int ignore_case;
+	int depth;
 } git_ignores;
 
 extern int git_ignore__for_path(
diff --git a/tests/status/ignore.c b/tests/status/ignore.c
index acdc8fb58..1fefcba5f 100644
--- a/tests/status/ignore.c
+++ b/tests/status/ignore.c
@@ -228,6 +228,32 @@ void test_status_ignore__subdirectories(void)
 	cl_assert(ignored);
 }
 
+static void make_test_data(void)
+{
+	static const char *files[] = {
+		"empty_standard_repo/dir/a/ignore_me",
+		"empty_standard_repo/dir/b/ignore_me",
+		"empty_standard_repo/dir/ignore_me",
+		"empty_standard_repo/ignore_also/file",
+		"empty_standard_repo/ignore_me",
+		"empty_standard_repo/test/ignore_me/file",
+		"empty_standard_repo/test/ignore_me/file2",
+		"empty_standard_repo/test/ignore_me/and_me/file",
+		NULL
+	};
+	static const char *repo = "empty_standard_repo";
+	const char **scan;
+	size_t repolen = strlen(repo) + 1;
+
+	g_repo = cl_git_sandbox_init(repo);
+
+	for (scan = files; *scan != NULL; ++scan) {
+		cl_git_pass(git_futils_mkdir(
+			*scan + repolen, repo, 0777, GIT_MKDIR_PATH | GIT_MKDIR_SKIP_LAST));
+		cl_git_mkfile(*scan, "contents");
+	}
+}
+
 void test_status_ignore__subdirectories_recursion(void)
 {
 	/* Let's try again with recursing into ignored dirs turned on */
@@ -235,6 +261,9 @@ void test_status_ignore__subdirectories_recursion(void)
 	status_entry_counts counts;
 	static const char *paths_r[] = {
 		".gitignore",
+		"dir/a/ignore_me",
+		"dir/b/ignore_me",
+		"dir/ignore_me",
 		"ignore_also/file",
 		"ignore_me",
 		"test/ignore_me/and_me/file",
@@ -242,49 +271,30 @@ void test_status_ignore__subdirectories_recursion(void)
 		"test/ignore_me/file2",
 	};
 	static const unsigned int statuses_r[] = {
-		GIT_STATUS_WT_NEW,
-		GIT_STATUS_IGNORED,
-		GIT_STATUS_IGNORED,
-		GIT_STATUS_IGNORED,
-		GIT_STATUS_IGNORED,
-		GIT_STATUS_IGNORED,
+		GIT_STATUS_WT_NEW,  GIT_STATUS_IGNORED, GIT_STATUS_IGNORED,
+		GIT_STATUS_IGNORED, GIT_STATUS_IGNORED, GIT_STATUS_IGNORED,
+		GIT_STATUS_IGNORED, GIT_STATUS_IGNORED, GIT_STATUS_IGNORED,
 	};
 	static const char *paths_nr[] = {
 		".gitignore",
+		"dir/a/ignore_me",
+		"dir/b/ignore_me",
+		"dir/ignore_me",
 		"ignore_also/",
 		"ignore_me",
 		"test/ignore_me/",
 	};
 	static const unsigned int statuses_nr[] = {
 		GIT_STATUS_WT_NEW,
-		GIT_STATUS_IGNORED,
-		GIT_STATUS_IGNORED,
-		GIT_STATUS_IGNORED,
+		GIT_STATUS_IGNORED, GIT_STATUS_IGNORED, GIT_STATUS_IGNORED,
+		GIT_STATUS_IGNORED, GIT_STATUS_IGNORED, GIT_STATUS_IGNORED,
 	};
 
-	g_repo = cl_git_sandbox_init("empty_standard_repo");
-
+	make_test_data();
 	cl_git_rewritefile("empty_standard_repo/.gitignore", "ignore_me\n/ignore_also\n");
 
-	cl_git_mkfile(
-		"empty_standard_repo/ignore_me", "I'm going to be ignored!");
-	cl_git_pass(git_futils_mkdir_r(
-		"empty_standard_repo/test/ignore_me", NULL, 0775));
-	cl_git_mkfile(
-		"empty_standard_repo/test/ignore_me/file", "I'm going to be ignored!");
-	cl_git_mkfile(
-		"empty_standard_repo/test/ignore_me/file2", "Me, too!");
-	cl_git_pass(git_futils_mkdir_r(
-		"empty_standard_repo/test/ignore_me/and_me", NULL, 0775));
-	cl_git_mkfile(
-		"empty_standard_repo/test/ignore_me/and_me/file", "Deeply ignored");
-	cl_git_pass(git_futils_mkdir_r(
-		"empty_standard_repo/ignore_also", NULL, 0775));
-	cl_git_mkfile(
-		"empty_standard_repo/ignore_also/file", "I'm going to be ignored!");
-
 	memset(&counts, 0x0, sizeof(status_entry_counts));
-	counts.expected_entry_count = 6;
+	counts.expected_entry_count = 9;
 	counts.expected_paths = paths_r;
 	counts.expected_statuses = statuses_r;
 
@@ -299,7 +309,7 @@ void test_status_ignore__subdirectories_recursion(void)
 
 
 	memset(&counts, 0x0, sizeof(status_entry_counts));
-	counts.expected_entry_count = 4;
+	counts.expected_entry_count = 7;
 	counts.expected_paths = paths_nr;
 	counts.expected_statuses = statuses_nr;
 
@@ -313,6 +323,47 @@ void test_status_ignore__subdirectories_recursion(void)
 	cl_assert_equal_i(0, counts.wrong_sorted_path);
 }
 
+void test_status_ignore__subdirectories_not_at_root(void)
+{
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	status_entry_counts counts;
+	static const char *paths_1[] = {
+		"dir/.gitignore",
+		"dir/a/ignore_me",
+		"dir/b/ignore_me",
+		"dir/ignore_me",
+		"ignore_also/file",
+		"ignore_me",
+		"test/.gitignore",
+		"test/ignore_me/and_me/file",
+		"test/ignore_me/file",
+		"test/ignore_me/file2",
+	};
+	static const unsigned int statuses_1[] = {
+		GIT_STATUS_WT_NEW,  GIT_STATUS_IGNORED, GIT_STATUS_IGNORED,
+		GIT_STATUS_IGNORED, GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW,
+		GIT_STATUS_WT_NEW, GIT_STATUS_IGNORED, GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW,
+	};
+
+	make_test_data();
+	cl_git_rewritefile("empty_standard_repo/dir/.gitignore", "ignore_me\n/ignore_also\n");
+	cl_git_rewritefile("empty_standard_repo/test/.gitignore", "and_me\n");
+
+	memset(&counts, 0x0, sizeof(status_entry_counts));
+	counts.expected_entry_count = 10;
+	counts.expected_paths = paths_1;
+	counts.expected_statuses = statuses_1;
+
+	opts.flags = GIT_STATUS_OPT_DEFAULTS | GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
+
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__normal, &counts));
+
+	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
+	cl_assert_equal_i(0, counts.wrong_status_flags_count);
+	cl_assert_equal_i(0, counts.wrong_sorted_path);
+}
+
 void test_status_ignore__adding_internal_ignores(void)
 {
 	int ignored;
-- 
cgit v1.2.3


From 8e14b47fd788ce5ae0d1a003a8fba17753eb7db5 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Thu, 10 Apr 2014 12:42:29 +0200
Subject: Introduce git__date_rfc2822_fmt. Allows for RFC2822 date headers

---
 src/date.c | 28 ++++++++++++++++++++++++++++
 src/util.h | 12 ++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/src/date.c b/src/date.c
index 7849c2f02..0e1b31aee 100644
--- a/src/date.c
+++ b/src/date.c
@@ -874,3 +874,31 @@ int git__date_parse(git_time_t *out, const char *date)
 	*out = approxidate_str(date, time_sec, &error_ret);
    return error_ret;
 }
+
+int git__date_rfc2822_fmt(char *out, size_t len, const git_time *date)
+{
+	int written;
+	struct tm gmt;
+	time_t t;
+
+	assert(out && date);
+
+	t = (time_t) (date->time + date->offset * 60);
+
+	if (p_gmtime_r (&t, &gmt) == NULL)
+		return -1;
+
+	written = p_snprintf(out, len, "%.3s, %u %.3s %.4u %02u:%02u:%02u %+03d%02d",
+		weekday_names[gmt.tm_wday],
+		gmt.tm_mday,
+		month_names[gmt.tm_mon],
+		gmt.tm_year + 1900,
+		gmt.tm_hour, gmt.tm_min, gmt.tm_sec,
+		date->offset / 60, date->offset % 60);
+
+	if (written < 0 || (written > (int) len - 1))
+		return -1;
+
+	return 0;
+}
+
diff --git a/src/util.h b/src/util.h
index e378786d9..5c2c563d6 100644
--- a/src/util.h
+++ b/src/util.h
@@ -20,6 +20,8 @@
 # define max(a,b) ((a) > (b) ? (a) : (b))
 #endif
 
+#define GIT_DATE_RFC2822_SZ  32
+
 /*
  * Custom memory allocation wrappers
  * that set error code and error message
@@ -328,6 +330,16 @@ extern int git__parse_bool(int *out, const char *value);
  */
 extern int git__date_parse(git_time_t *out, const char *date);
 
+/*
+ * Format a git_time as a RFC2822 string
+ *
+ * @param out buffer to store formatted date; a '\\0' terminator will automatically be added.
+ * @param len size of the buffer; should be atleast `GIT_DATE_RFC2822_SZ` in size;
+ * @param date the date to be formatted
+ * @return 0 if successful; -1 on error
+ */
+extern int git__date_rfc2822_fmt(char *out, size_t len, const git_time *date);
+
 /*
  * Unescapes a string in-place.
  *
-- 
cgit v1.2.3


From 51297cadb32df3f7e1b1820034ff5a4ed6703668 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Thu, 10 Apr 2014 12:44:12 +0200
Subject: Added RFC2822 date format test cases

---
 tests/date/rfc2822.c | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 tests/date/rfc2822.c

diff --git a/tests/date/rfc2822.c b/tests/date/rfc2822.c
new file mode 100644
index 000000000..eda475ac9
--- /dev/null
+++ b/tests/date/rfc2822.c
@@ -0,0 +1,40 @@
+#include "clar_libgit2.h"
+
+#include "util.h"
+
+void test_date_rfc2822__format_rfc2822_no_offset(void)
+{
+	git_time t = {1397031663, 0};
+	char buf[GIT_DATE_RFC2822_SZ];
+
+	cl_git_pass(git__date_rfc2822_fmt(buf, sizeof(buf), &t));
+	cl_assert(strcmp(buf, "Wed, 9 Apr 2014 08:21:03 +0000") == 0);
+}
+
+void test_date_rfc2822__format_rfc2822_positive_offset(void)
+{
+	git_time t = {1397031663, 120};
+	char buf[GIT_DATE_RFC2822_SZ];
+
+	cl_git_pass(git__date_rfc2822_fmt(buf, sizeof(buf), &t));
+	cl_assert(strcmp(buf, "Wed, 9 Apr 2014 10:21:03 +0200") == 0);
+}
+
+void test_date_rfc2822__format_rfc2822_negative_offset(void)
+{
+	git_time t = {1397031663, -120};
+	char buf[GIT_DATE_RFC2822_SZ];
+
+	cl_git_pass(git__date_rfc2822_fmt(buf, sizeof(buf), &t));
+	cl_assert(strcmp(buf, "Wed, 9 Apr 2014 06:21:03 -0200") == 0);
+}
+
+void test_date_rfc2822__format_rfc2822_buffer_too_small(void)
+{
+	// "Wed, 10 Apr 2014 08:21:03 +0000"
+	git_time t = {1397031663 + 86400, 0};
+	char buf[GIT_DATE_RFC2822_SZ-1];
+
+	cl_git_fail(git__date_rfc2822_fmt(buf, sizeof(buf), &t));
+}
+
-- 
cgit v1.2.3


From 7a28f268adc1d2569ce504147af05834ae94c01a Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Thu, 10 Apr 2014 12:44:51 +0200
Subject: Fix const-correctness of git_patch_get_delta, git_patch_num_hunks,
 git_patch_num_lines_in_hunk

---
 include/git2/patch.h | 6 +++---
 src/diff_patch.c     | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/git2/patch.h b/include/git2/patch.h
index f5ec682c6..47c395669 100644
--- a/include/git2/patch.h
+++ b/include/git2/patch.h
@@ -141,12 +141,12 @@ GIT_EXTERN(void) git_patch_free(git_patch *patch);
 /**
  * Get the delta associated with a patch
  */
-GIT_EXTERN(const git_diff_delta *) git_patch_get_delta(git_patch *patch);
+GIT_EXTERN(const git_diff_delta *) git_patch_get_delta(const git_patch *patch);
 
 /**
  * Get the number of hunks in a patch
  */
-GIT_EXTERN(size_t) git_patch_num_hunks(git_patch *patch);
+GIT_EXTERN(size_t) git_patch_num_hunks(const git_patch *patch);
 
 /**
  * Get line counts of each type in a patch.
@@ -197,7 +197,7 @@ GIT_EXTERN(int) git_patch_get_hunk(
  * @return Number of lines in hunk or -1 if invalid hunk index
  */
 GIT_EXTERN(int) git_patch_num_lines_in_hunk(
-	git_patch *patch,
+	const git_patch *patch,
 	size_t hunk_idx);
 
 /**
diff --git a/src/diff_patch.c b/src/diff_patch.c
index dd8b73938..38d5f4257 100644
--- a/src/diff_patch.c
+++ b/src/diff_patch.c
@@ -631,13 +631,13 @@ void git_patch_free(git_patch *patch)
 		GIT_REFCOUNT_DEC(patch, diff_patch_free);
 }
 
-const git_diff_delta *git_patch_get_delta(git_patch *patch)
+const git_diff_delta *git_patch_get_delta(const git_patch *patch)
 {
 	assert(patch);
 	return patch->delta;
 }
 
-size_t git_patch_num_hunks(git_patch *patch)
+size_t git_patch_num_hunks(const git_patch *patch)
 {
 	assert(patch);
 	return git_array_size(patch->hunks);
@@ -708,7 +708,7 @@ int git_patch_get_hunk(
 	return 0;
 }
 
-int git_patch_num_lines_in_hunk(git_patch *patch, size_t hunk_idx)
+int git_patch_num_lines_in_hunk(const git_patch *patch, size_t hunk_idx)
 {
 	diff_patch_hunk *hunk;
 	assert(patch);
-- 
cgit v1.2.3


From efaa342cbb62069510a3787da433e6b5b935fcde Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 11 Apr 2014 22:07:49 +0200
Subject: Correct C90 warnings

---
 src/global.c      | 3 ++-
 tests/repo/open.c | 5 +++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/global.c b/src/global.c
index 8c8f55a90..c26b4b311 100644
--- a/src/global.c
+++ b/src/global.c
@@ -183,6 +183,7 @@ int git_threads_init(void)
 
 void git_threads_shutdown(void)
 {
+	void *ptr = NULL;
 	pthread_once_t new_once = PTHREAD_ONCE_INIT;
 
 	if (git_atomic_dec(&git__n_inits) > 0) return;
@@ -190,7 +191,7 @@ void git_threads_shutdown(void)
 	/* Shut down any subsystems that have global state */
 	git__shutdown();
 
-	void *ptr = pthread_getspecific(_tls_key);
+	ptr = pthread_getspecific(_tls_key);
 	pthread_setspecific(_tls_key, NULL);
 	git__free(ptr);
 
diff --git a/tests/repo/open.c b/tests/repo/open.c
index f7420bd3a..190adff1c 100644
--- a/tests/repo/open.c
+++ b/tests/repo/open.c
@@ -102,14 +102,13 @@ void test_repo_open__gitlinked(void)
 
 void test_repo_open__from_git_new_workdir(void)
 {
+#ifndef GIT_WIN32
 	/* The git-new-workdir script that ships with git sets up a bunch of
 	 * symlinks to create a second workdir that shares the object db with
 	 * another checkout.  Libgit2 can open a repo that has been configured
 	 * this way.
 	 */
-	cl_git_sandbox_init("empty_standard_repo");
 
-#ifndef GIT_WIN32
 	git_repository *repo2;
 	git_buf link_tgt = GIT_BUF_INIT, link = GIT_BUF_INIT, body = GIT_BUF_INIT;
 	const char **scan;
@@ -122,6 +121,8 @@ void test_repo_open__from_git_new_workdir(void)
 		"HEAD", NULL
 	};
 
+	cl_git_sandbox_init("empty_standard_repo");
+
 	cl_git_pass(p_mkdir("alternate", 0777));
 	cl_git_pass(p_mkdir("alternate/.git", 0777));
 
-- 
cgit v1.2.3


From 399f2b6294963b8a7a154ffd0103484d018c4e27 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 7 Apr 2014 20:15:45 +0200
Subject: Introduce git_merge__extract_conflict_paths

---
 src/merge.c | 41 +++++++++++++++++++++++++++++++++++++++++
 src/merge.h |  2 ++
 2 files changed, 43 insertions(+)

diff --git a/src/merge.c b/src/merge.c
index dd6a39f37..371fad776 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2469,6 +2469,47 @@ done:
 	return error;
 }
 
+int git_merge__append_conflicts_to_merge_msg(
+	git_repository *repo,
+	git_index *index)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	git_buf file_path = GIT_BUF_INIT;
+	const char *last = NULL;
+	size_t i;
+	int error;
+
+	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_MERGE_MSG_FILE)) < 0 ||
+		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_APPEND, GIT_MERGE_FILE_MODE)) < 0)
+		goto cleanup;
+
+	if (git_index_has_conflicts(index))
+		git_filebuf_printf(&file, "\nConflicts:\n");
+
+	for (i = 0; i < git_index_entrycount(index); i++) {
+		const git_index_entry *e = git_index_get_byindex(index, i);
+
+		if (git_index_entry_stage(e) == 0)
+			continue;
+
+		if (last == NULL || strcmp(e->path, last) != 0)
+			git_filebuf_printf(&file, "\t%s\n", e->path);
+
+		last = e->path;
+	}
+
+	error = git_filebuf_commit(&file);
+
+cleanup:
+	if (error < 0)
+		git_filebuf_cleanup(&file);
+
+	git_buf_free(&file_path);
+
+	return error;
+}
+
+
 static int merge_state_cleanup(git_repository *repo)
 {
 	const char *state_files[] = {
diff --git a/src/merge.h b/src/merge.h
index 2362da04d..00f6197bf 100644
--- a/src/merge.h
+++ b/src/merge.h
@@ -151,4 +151,6 @@ int git_merge__setup(
 
 int git_merge__indexes(git_repository *repo, git_index *index_new);
 
+int git_merge__append_conflicts_to_merge_msg(git_repository *repo, git_index *index);
+
 #endif
-- 
cgit v1.2.3


From 4d7b993904008001ad995d6b27af0e8c71277c55 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Tue, 1 Apr 2014 22:18:19 +0200
Subject: Added cherry-pick support

---
 include/git2.h            |   1 +
 include/git2/cherrypick.h |  88 ++++++++++++++++++
 include/git2/errors.h     |   1 +
 src/cherrypick.c          | 230 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 320 insertions(+)
 create mode 100644 include/git2/cherrypick.h
 create mode 100644 src/cherrypick.c

diff --git a/include/git2.h b/include/git2.h
index 704fb585a..f74976061 100644
--- a/include/git2.h
+++ b/include/git2.h
@@ -14,6 +14,7 @@
 #include "git2/branch.h"
 #include "git2/buffer.h"
 #include "git2/checkout.h"
+#include "git2/cherrypick.h"
 #include "git2/clone.h"
 #include "git2/commit.h"
 #include "git2/common.h"
diff --git a/include/git2/cherrypick.h b/include/git2/cherrypick.h
new file mode 100644
index 000000000..7c48e6659
--- /dev/null
+++ b/include/git2/cherrypick.h
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_git_cherrypick_h__
+#define INCLUDE_git_cherrypick_h__
+
+#include "common.h"
+#include "types.h"
+#include "merge.h"
+
+/**
+ * @file git2/cherrypick.h
+ * @brief Git cherry-pick routines
+ * @defgroup git_cherrypick Git cherry-pick routines
+ * @ingroup Git
+ * @{
+ */
+GIT_BEGIN_DECL
+
+typedef struct {
+	unsigned int version;
+
+	/** For merge commits, the "mainline" is treated as the parent. */
+	unsigned int mainline;
+
+	git_merge_options merge_opts;
+	git_checkout_options checkout_opts;
+} git_cherry_pick_options;
+
+#define GIT_CHERRY_PICK_OPTIONS_VERSION 1
+#define GIT_CHERRY_PICK_OPTIONS_INIT {GIT_CHERRY_PICK_OPTIONS_VERSION, 0, GIT_MERGE_OPTIONS_INIT, GIT_CHECKOUT_OPTIONS_INIT}
+
+/**
+ * Initializes a `git_cherry_pick_options` with default values. Equivalent to
+ * creating an instance with GIT_CHERRY_PICK_OPTIONS_INIT.
+ *
+ * @param opts the `git_cherry_pick_options` instance to initialize.
+ * @param version the version of the struct; you should pass
+ *        `GIT_CHERRY_PICK_OPTIONS_VERSION` here.
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_cherry_pick_init_opts(
+	git_cherry_pick_options* opts,
+	int version);
+
+/**
+ * Cherry-picks the given commit against the given "our" commit, producing an
+ * index that reflects the result of the cherry-pick.
+ *
+ * The returned index must be freed explicitly with `git_index_free`.
+ *
+ * @param out pointer to store the index result in
+ * @param repo the repository that contains the given commits
+ * @param cherry_pick_commit the commit to cherry-pick
+ * @param our_commit the commit to revert against (eg, HEAD)
+ * @param mainline the parent of the revert commit, if it is a merge
+ * @param merge_tree_opts the merge tree options (or null for defaults)
+ * @return zero on success, -1 on failure.
+ */
+GIT_EXTERN(int) git_cherry_pick_commit(
+	git_index **out,
+	git_repository *repo,
+	git_commit *cherry_pick_commit,
+	git_commit *our_commit,
+	unsigned int mainline,
+	const git_merge_options *merge_options);
+
+/**
+ * Cherry-pick the given commit, producing changes in the index and working directory.
+ *
+ * @param repo the repository to cherry-pick
+ * @param commit the commit to cherry-pick
+ * @param cherry_pick_options the cherry-pick options (or null for defaults)
+ * @return zero on success, -1 on failure.
+ */
+GIT_EXTERN(int) git_cherry_pick(
+	git_repository *repo,
+	git_commit *commit,
+	const git_cherry_pick_options *cherry_pick_options);
+
+/** @} */
+GIT_END_DECL
+
+#endif
+
diff --git a/include/git2/errors.h b/include/git2/errors.h
index bcf2f80ab..e22f0d86d 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -86,6 +86,7 @@ typedef enum {
 	GITERR_FILTER,
 	GITERR_REVERT,
 	GITERR_CALLBACK,
+	GITERR_CHERRYPICK,
 } git_error_t;
 
 /**
diff --git a/src/cherrypick.c b/src/cherrypick.c
new file mode 100644
index 000000000..67a2c6af3
--- /dev/null
+++ b/src/cherrypick.c
@@ -0,0 +1,230 @@
+/*
+* Copyright (C) the libgit2 contributors. All rights reserved.
+*
+* This file is part of libgit2, distributed under the GNU GPL v2 with
+* a Linking Exception. For full terms see the included COPYING file.
+*/
+
+#include "common.h"
+#include "repository.h"
+#include "filebuf.h"
+#include "merge.h"
+#include "vector.h"
+
+#include "git2/types.h"
+#include "git2/merge.h"
+#include "git2/cherrypick.h"
+#include "git2/commit.h"
+#include "git2/sys/commit.h"
+
+#define GIT_CHERRY_PICK_FILE_MODE		0666
+
+static int write_cherry_pick_head(
+	git_repository *repo,
+	const char *commit_oidstr)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	git_buf file_path = GIT_BUF_INIT;
+	int error = 0;
+
+	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_CHERRY_PICK_HEAD_FILE)) >= 0 &&
+		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_CHERRY_PICK_FILE_MODE)) >= 0 &&
+		(error = git_filebuf_printf(&file, "%s\n", commit_oidstr)) >= 0)
+		error = git_filebuf_commit(&file);
+
+	if (error < 0)
+		git_filebuf_cleanup(&file);
+
+	git_buf_free(&file_path);
+
+	return error;
+}
+
+static int write_merge_msg(
+	git_repository *repo,
+	const char *commit_msg)
+{
+	git_filebuf file = GIT_FILEBUF_INIT;
+	git_buf file_path = GIT_BUF_INIT;
+	int error = 0;
+
+	if ((error = git_buf_joinpath(&file_path, repo->path_repository, GIT_MERGE_MSG_FILE)) < 0 ||
+		(error = git_filebuf_open(&file, file_path.ptr, GIT_FILEBUF_FORCE, GIT_CHERRY_PICK_FILE_MODE)) < 0 ||
+		(error = git_filebuf_printf(&file, "%s", commit_msg)) < 0)
+		goto cleanup;
+
+	error = git_filebuf_commit(&file);
+
+cleanup:
+	if (error < 0)
+		git_filebuf_cleanup(&file);
+
+	git_buf_free(&file_path);
+
+	return error;
+}
+
+static int cherry_pick_normalize_opts(
+	git_repository *repo,
+	git_cherry_pick_options *opts,
+	const git_cherry_pick_options *given,
+	const char *their_label)
+{
+	int error = 0;
+	unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE_CREATE |
+		GIT_CHECKOUT_ALLOW_CONFLICTS;
+
+	GIT_UNUSED(repo);
+
+	if (given != NULL)
+		memcpy(opts, given, sizeof(git_cherry_pick_options));
+	else {
+		git_cherry_pick_options default_opts = GIT_CHERRY_PICK_OPTIONS_INIT;
+		memcpy(opts, &default_opts, sizeof(git_cherry_pick_options));
+	}
+
+	if (!opts->checkout_opts.checkout_strategy)
+		opts->checkout_opts.checkout_strategy = default_checkout_strategy;
+
+	if (!opts->checkout_opts.our_label)
+		opts->checkout_opts.our_label = "HEAD";
+
+	if (!opts->checkout_opts.their_label)
+		opts->checkout_opts.their_label = their_label;
+
+	return error;
+}
+
+static int cherry_pick_state_cleanup(git_repository *repo)
+{
+	const char *state_files[] = { GIT_CHERRY_PICK_HEAD_FILE, GIT_MERGE_MSG_FILE };
+
+	return git_repository__cleanup_files(repo, state_files, ARRAY_SIZE(state_files));
+}
+
+static int cherry_pick_seterr(git_commit *commit, const char *fmt)
+{
+	char commit_oidstr[GIT_OID_HEXSZ + 1];
+
+	giterr_set(GITERR_CHERRYPICK, fmt,
+		git_oid_tostr(commit_oidstr, GIT_OID_HEXSZ + 1, git_commit_id(commit)));
+
+	return -1;
+}
+
+int git_cherry_pick_commit(
+	git_index **out,
+	git_repository *repo,
+	git_commit *cherry_pick_commit,
+	git_commit *our_commit,
+	unsigned int mainline,
+	const git_merge_options *merge_opts)
+{
+	git_commit *parent_commit = NULL;
+	git_tree *parent_tree = NULL, *our_tree = NULL, *cherry_pick_tree = NULL;
+	int parent = 0, error = 0;
+
+	assert(out && repo && cherry_pick_commit && our_commit);
+
+	if (git_commit_parentcount(cherry_pick_commit) > 1) {
+		if (!mainline)
+			return cherry_pick_seterr(cherry_pick_commit,
+				"Mainline branch is not specified but %s is a merge commit");
+
+		parent = mainline;
+	} else {
+		if (mainline)
+			return cherry_pick_seterr(cherry_pick_commit,
+				"Mainline branch specified but %s is not a merge commit");
+
+		parent = git_commit_parentcount(cherry_pick_commit);
+	}
+
+	if (parent &&
+		((error = git_commit_parent(&parent_commit, cherry_pick_commit, (parent - 1))) < 0 ||
+		(error = git_commit_tree(&parent_tree, parent_commit)) < 0))
+		goto done;
+
+	if ((error = git_commit_tree(&cherry_pick_tree, cherry_pick_commit)) < 0 ||
+		(error = git_commit_tree(&our_tree, our_commit)) < 0)
+		goto done;
+
+	error = git_merge_trees(out, repo, parent_tree, our_tree, cherry_pick_tree, merge_opts);
+
+done:
+	git_tree_free(parent_tree);
+	git_tree_free(our_tree);
+	git_tree_free(cherry_pick_tree);
+	git_commit_free(parent_commit);
+
+	return error;
+}
+
+int git_cherry_pick(
+	git_repository *repo,
+	git_commit *commit,
+	const git_cherry_pick_options *given_opts)
+{
+	git_cherry_pick_options opts;
+	git_reference *our_ref = NULL;
+	git_commit *our_commit = NULL;
+	char commit_oidstr[GIT_OID_HEXSZ + 1];
+	const char *commit_msg, *commit_summary;
+	git_buf their_label = GIT_BUF_INIT;
+	git_index *index_new = NULL, *index_repo = NULL;
+	int error = 0;
+
+	assert(repo && commit);
+
+	GITERR_CHECK_VERSION(given_opts, GIT_CHERRY_PICK_OPTIONS_VERSION, "git_cherry_pick_options");
+
+	if ((error = git_repository__ensure_not_bare(repo, "cherry-pick")) < 0)
+		return error;
+
+	if ((commit_msg = git_commit_message(commit)) == NULL ||
+		(commit_summary = git_commit_summary(commit)) == NULL) {
+		error = -1;
+		goto on_error;
+	}
+
+	git_oid_fmt(commit_oidstr, git_commit_id(commit));
+
+	if ((error = write_merge_msg(repo, commit_msg)) < 0 ||
+		(error = git_buf_printf(&their_label, "%.7s... %s", commit_oidstr, commit_summary)) < 0 ||
+		(error = cherry_pick_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 ||
+		(error = write_cherry_pick_head(repo, commit_oidstr)) < 0 ||
+		(error = git_repository_head(&our_ref, repo)) < 0 ||
+		(error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJ_COMMIT)) < 0 ||
+		(error = git_cherry_pick_commit(&index_new, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 ||
+		(error = git_merge__indexes(repo, index_new)) < 0 ||
+		(error = git_repository_index(&index_repo, repo)) < 0 ||
+		(error = git_merge__append_conflicts_to_merge_msg(repo, index_repo)) < 0 ||
+		(error = git_checkout_index(repo, index_repo, &opts.checkout_opts)) < 0)
+		goto on_error;
+
+	goto done;
+
+on_error:
+	cherry_pick_state_cleanup(repo);
+
+done:
+	git_index_free(index_new);
+	git_index_free(index_repo);
+	git_commit_free(our_commit);
+	git_reference_free(our_ref);
+	git_buf_free(&their_label);
+
+	return error;
+}
+
+int git_cherry_pick_init_opts(git_cherry_pick_options* opts, int version)
+{
+	if (version != GIT_CHERRY_PICK_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_cherry_pick_options", version);
+		return -1;
+	} else {
+		git_cherry_pick_options o = GIT_CHERRY_PICK_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
-- 
cgit v1.2.3


From 103b7d21226e43192cf138ecf0b98b51796ae0ed Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Wed, 2 Apr 2014 13:57:11 +0200
Subject: Added cherry pick tests

---
 tests/cherrypick/bare.c                            | 106 +++++
 tests/cherrypick/workdir.c                         | 429 +++++++++++++++++++++
 tests/resources/cherrypick/.gitted/HEAD            |   1 +
 tests/resources/cherrypick/.gitted/config          |   7 +
 tests/resources/cherrypick/.gitted/index           | Bin 0 -> 248 bytes
 tests/resources/cherrypick/.gitted/info/exclude    |   6 +
 .../01/a2b453c2647c71ccfefc285f2266d1f00b8253      | Bin 0 -> 30 bytes
 .../02/67838e09bbc5969bba035be2d27c8a6de694d8      | Bin 0 -> 38 bytes
 .../06/3fc9f01e6e9ec2a8d8f749885e931875e50d37      | Bin 0 -> 141 bytes
 .../08/9ac03f76058b5ba0b44bb268f317f9242481e9      |   3 +
 .../0d/447a6c2528b06616cde3b209a4b4ea3dcb8d65      | Bin 0 -> 107 bytes
 .../11/24c2c1ae07b26fded662d6c3f3631d9dc16f88      | Bin 0 -> 31 bytes
 .../12/905f4ea5b76f9d3fdcfe73e462201c06ae632a      | Bin 0 -> 108 bytes
 .../19/c5c7207054604b69c84d08a7571ef9672bb5c2      | Bin 0 -> 28 bytes
 .../1c/2116845780455ecf916538c1cc27c4222452af      | Bin 0 -> 116 bytes
 .../1c/c85eb4ff0a8438fde1b14274c6f87f891b36a0      | Bin 0 -> 117 bytes
 .../1e/1cb7391d25dcd8daba88f1f627f3045982286c      | Bin 0 -> 32 bytes
 .../20/fc1a4c9d994021f43d33ab75e4252e27ca661d      | Bin 0 -> 126 bytes
 .../28/d9eb4208074ad1cc84e71ccc908b34573f05d2      | Bin 0 -> 28 bytes
 .../2a/26c7e88b285613b302ba76712bc998863f3cbc      |   1 +
 .../2a/c3b376093de405b0a951bff578655b1c2b7fa1      |   1 +
 .../2c/acbcaabf785f1ac231e8519849d4ad38692f2c      | Bin 0 -> 26 bytes
 .../35/cb210149022c7379b0a67b0dec13cc628ff87d      | Bin 0 -> 137 bytes
 .../38/c05a857e831a7e759d83778bfc85d003e21c45      | Bin 0 -> 27 bytes
 .../3f/9eed8946df9e2c737d3b8dc0b8e78959aacd92      |   5 +
 .../40/9a1bec58bf35348e8b62b72bb9c1f45cf5a587      | Bin 0 -> 33 bytes
 .../44/cd2ed2052c9c68f9a439d208e9614dc2a55c70      |   1 +
 .../48/7434cace79238a7091e2220611d4f20a765690      | Bin 0 -> 33 bytes
 .../49/20ad2f17162dcc8823ad491444dcb87f5899c9      | Bin 0 -> 36 bytes
 .../4b/825dc642cb6eb9a060e54bf8d69288fbee4904      | Bin 0 -> 15 bytes
 .../4c/532774cc1fea37f6efc2256763a64d38c8cdde      | Bin 0 -> 26 bytes
 .../51/145af30d411a50195b66517d825e69bf57ed22      | Bin 0 -> 107 bytes
 .../54/61de53ffadbf15be4dd6345997c15689573209      |   4 +
 .../54/784f10955e92ab27e4fa832e40cb2baf1edbdc      | Bin 0 -> 74 bytes
 .../56/3f6473a3858f99b80e5f93c660512ed38e1e6f      | Bin 0 -> 31 bytes
 .../58/a957ef0061c1a8ef995c855dfab4f5da8d6617      | Bin 0 -> 32 bytes
 .../5d/c7e1f440ce74d5503a0dfbc6c30e091475f774      | Bin 0 -> 31 bytes
 .../5e/2206cda1c56430ad107a6866a829c159e0b9ea      |   1 +
 .../5f/77a2a13935ac62a629553f8944ad57b1ed8b4a      | Bin 0 -> 106 bytes
 .../63/c0d92b95253c4a40d3883f423a54be47d2c4c8      | Bin 0 -> 30 bytes
 .../6c/e83eb5f0fd34a10c3d25c6b36d2ed7ec0d6ce7      | Bin 0 -> 108 bytes
 .../6d/1c2afe5eeb9e497528e2780ac468a5465cbc96      |   1 +
 .../74/f06b5bfec6d33d7264f73606b57a7c0b963819      | Bin 0 -> 141 bytes
 .../82/8b08c52d2cba30952e0e008f60b25b5ba0d41a      | Bin 0 -> 107 bytes
 .../85/36dd6f0ec3ddecb9f9b6c8c64c6d322cd01211      | Bin 0 -> 36 bytes
 .../85/a4a1d791973644f24c72f5e89420d3064cc452      | Bin 0 -> 27 bytes
 .../8b/5c30499a71001189b647f4d5b57fa8f04897ce      | Bin 0 -> 107 bytes
 .../96/4ea3da044d9083181a88ba6701de9e35778bf4      | Bin 0 -> 181 bytes
 .../9c/c39fca3765a2facbe31157f7d60c2602193f36      | Bin 0 -> 107 bytes
 .../9c/cb9bf50c011fd58dcbaa65df917bf79539717f      | Bin 0 -> 30 bytes
 .../a1/0b59f4280491afe6e430c30654a7acc67d4a33      | Bin 0 -> 30 bytes
 .../a2/1b4bfe7a04ab18024fb57f4ae9a52a1acef394      | Bin 0 -> 173 bytes
 .../a4/3a050c588d4e92f11a6b139680923e9728477d      |   1 +
 .../a5/8ca3fee5eb68b11adc2703e5843f968c9dad1e      | Bin 0 -> 28 bytes
 .../a6/61b5dec1004e2c62654ded3762370c27cf266b      | Bin 0 -> 27 bytes
 .../a6/9ef8fcbb9a2c509a7dbf4f23d257eb551d5610      |   1 +
 .../a8/3c6f70297b805dedc549e6583582966f6ebcab      | Bin 0 -> 138 bytes
 .../a9/020cd240774e4d672732bcb82d516d9685da76      | Bin 0 -> 26 bytes
 .../ab/4115f808bc585b60f822da7020af86d20f62c8      | Bin 0 -> 213 bytes
 .../ab/e4603bc7cd5b8167a267e0e2418fd2348f8cff      |   4 +
 .../b8/26e9b36e22e949ec885e7a1f3db496bbab6cd0      | Bin 0 -> 108 bytes
 .../ba/fbf6912c09505ac60575cd43d3f2aba3bd84d8      | Bin 0 -> 175 bytes
 .../bb/14296ffa9dfbf935ec9ce2f9ed7808d952226b      | Bin 0 -> 38 bytes
 .../bc/4dd0744364d1db380a9811bd264c101065231e      | Bin 0 -> 55 bytes
 .../bd/65d4083845ed5ed4e1fe5feb85ac395d0760c8      |   2 +
 .../bd/6ffc8c6c41f0f85ff9e3d61c9479516bac0024      | Bin 0 -> 31 bytes
 .../bd/a51965cb36c0c5731c8cb50b80a36cac81018e      | Bin 0 -> 107 bytes
 .../ce/d8fb81b6ec534d5deaf2a48b4b96c799712507      |   1 +
 .../cf/c4f0999a8367568e049af4f72e452d40828a15      | Bin 0 -> 180 bytes
 .../d0/f21e17beb5b9d953b1d8349049818a4f2edd1e      |   1 +
 .../d3/d77487660ee3c0194ee01dc5eaf478782b1c7e      |   1 +
 .../e2/33b9ed408a95e9d4b65fec7fc34943a556deb2      | Bin 0 -> 31 bytes
 .../e5/183bfd18e3a0a691fadde2f0d5610b73282d31      | Bin 0 -> 33 bytes
 .../e6/ae8889c40c77d7be02758235b5b3f7a4f2a129      | Bin 0 -> 107 bytes
 .../e7/811a2bc55635f182750f0420da5ad232c1af91      | Bin 0 -> 107 bytes
 .../e9/b63f3655b2ad80c0ff587389b5a9589a3a7110      |   2 +
 .../eb/da71fe44dcb60c53b8fbd53208a1204d32e959      | Bin 0 -> 36 bytes
 .../f0/5ed049854c1596a7cc0e957fab34961077f3ae      | Bin 0 -> 36 bytes
 .../f0/a4e1c66bb548cd2b22eebefda703872e969775      | Bin 0 -> 191 bytes
 .../f2/ec8c8cf1a9fb7aa047a25a4308bfe860237ad4      | Bin 0 -> 32 bytes
 .../f5/684c96bf40c709877b56404cd8a5dd2d2a7978      | Bin 0 -> 106 bytes
 .../f9/0f9dcbdac2cce5cc166346160e19cb693ef4e8      | Bin 0 -> 31 bytes
 .../cherrypick/.gitted/refs/heads/automerge-branch |   1 +
 .../resources/cherrypick/.gitted/refs/heads/master |   1 +
 .../cherrypick/.gitted/refs/heads/merge-branch     |   1 +
 .../cherrypick/.gitted/refs/heads/merge-conflicts  |   1 +
 .../cherrypick/.gitted/refs/heads/merge-mainline   |   1 +
 .../resources/cherrypick/.gitted/refs/heads/orphan |   1 +
 .../cherrypick/.gitted/refs/heads/renames          |   1 +
 tests/resources/cherrypick/file1.txt               |  15 +
 tests/resources/cherrypick/file2.txt               |  15 +
 tests/resources/cherrypick/file3.txt               |  15 +
 92 files changed, 631 insertions(+)
 create mode 100644 tests/cherrypick/bare.c
 create mode 100644 tests/cherrypick/workdir.c
 create mode 100644 tests/resources/cherrypick/.gitted/HEAD
 create mode 100644 tests/resources/cherrypick/.gitted/config
 create mode 100644 tests/resources/cherrypick/.gitted/index
 create mode 100644 tests/resources/cherrypick/.gitted/info/exclude
 create mode 100644 tests/resources/cherrypick/.gitted/objects/01/a2b453c2647c71ccfefc285f2266d1f00b8253
 create mode 100644 tests/resources/cherrypick/.gitted/objects/02/67838e09bbc5969bba035be2d27c8a6de694d8
 create mode 100644 tests/resources/cherrypick/.gitted/objects/06/3fc9f01e6e9ec2a8d8f749885e931875e50d37
 create mode 100644 tests/resources/cherrypick/.gitted/objects/08/9ac03f76058b5ba0b44bb268f317f9242481e9
 create mode 100644 tests/resources/cherrypick/.gitted/objects/0d/447a6c2528b06616cde3b209a4b4ea3dcb8d65
 create mode 100644 tests/resources/cherrypick/.gitted/objects/11/24c2c1ae07b26fded662d6c3f3631d9dc16f88
 create mode 100644 tests/resources/cherrypick/.gitted/objects/12/905f4ea5b76f9d3fdcfe73e462201c06ae632a
 create mode 100644 tests/resources/cherrypick/.gitted/objects/19/c5c7207054604b69c84d08a7571ef9672bb5c2
 create mode 100644 tests/resources/cherrypick/.gitted/objects/1c/2116845780455ecf916538c1cc27c4222452af
 create mode 100644 tests/resources/cherrypick/.gitted/objects/1c/c85eb4ff0a8438fde1b14274c6f87f891b36a0
 create mode 100644 tests/resources/cherrypick/.gitted/objects/1e/1cb7391d25dcd8daba88f1f627f3045982286c
 create mode 100644 tests/resources/cherrypick/.gitted/objects/20/fc1a4c9d994021f43d33ab75e4252e27ca661d
 create mode 100644 tests/resources/cherrypick/.gitted/objects/28/d9eb4208074ad1cc84e71ccc908b34573f05d2
 create mode 100644 tests/resources/cherrypick/.gitted/objects/2a/26c7e88b285613b302ba76712bc998863f3cbc
 create mode 100644 tests/resources/cherrypick/.gitted/objects/2a/c3b376093de405b0a951bff578655b1c2b7fa1
 create mode 100644 tests/resources/cherrypick/.gitted/objects/2c/acbcaabf785f1ac231e8519849d4ad38692f2c
 create mode 100644 tests/resources/cherrypick/.gitted/objects/35/cb210149022c7379b0a67b0dec13cc628ff87d
 create mode 100644 tests/resources/cherrypick/.gitted/objects/38/c05a857e831a7e759d83778bfc85d003e21c45
 create mode 100644 tests/resources/cherrypick/.gitted/objects/3f/9eed8946df9e2c737d3b8dc0b8e78959aacd92
 create mode 100644 tests/resources/cherrypick/.gitted/objects/40/9a1bec58bf35348e8b62b72bb9c1f45cf5a587
 create mode 100644 tests/resources/cherrypick/.gitted/objects/44/cd2ed2052c9c68f9a439d208e9614dc2a55c70
 create mode 100644 tests/resources/cherrypick/.gitted/objects/48/7434cace79238a7091e2220611d4f20a765690
 create mode 100644 tests/resources/cherrypick/.gitted/objects/49/20ad2f17162dcc8823ad491444dcb87f5899c9
 create mode 100644 tests/resources/cherrypick/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904
 create mode 100644 tests/resources/cherrypick/.gitted/objects/4c/532774cc1fea37f6efc2256763a64d38c8cdde
 create mode 100644 tests/resources/cherrypick/.gitted/objects/51/145af30d411a50195b66517d825e69bf57ed22
 create mode 100644 tests/resources/cherrypick/.gitted/objects/54/61de53ffadbf15be4dd6345997c15689573209
 create mode 100644 tests/resources/cherrypick/.gitted/objects/54/784f10955e92ab27e4fa832e40cb2baf1edbdc
 create mode 100644 tests/resources/cherrypick/.gitted/objects/56/3f6473a3858f99b80e5f93c660512ed38e1e6f
 create mode 100644 tests/resources/cherrypick/.gitted/objects/58/a957ef0061c1a8ef995c855dfab4f5da8d6617
 create mode 100644 tests/resources/cherrypick/.gitted/objects/5d/c7e1f440ce74d5503a0dfbc6c30e091475f774
 create mode 100644 tests/resources/cherrypick/.gitted/objects/5e/2206cda1c56430ad107a6866a829c159e0b9ea
 create mode 100644 tests/resources/cherrypick/.gitted/objects/5f/77a2a13935ac62a629553f8944ad57b1ed8b4a
 create mode 100644 tests/resources/cherrypick/.gitted/objects/63/c0d92b95253c4a40d3883f423a54be47d2c4c8
 create mode 100644 tests/resources/cherrypick/.gitted/objects/6c/e83eb5f0fd34a10c3d25c6b36d2ed7ec0d6ce7
 create mode 100644 tests/resources/cherrypick/.gitted/objects/6d/1c2afe5eeb9e497528e2780ac468a5465cbc96
 create mode 100644 tests/resources/cherrypick/.gitted/objects/74/f06b5bfec6d33d7264f73606b57a7c0b963819
 create mode 100644 tests/resources/cherrypick/.gitted/objects/82/8b08c52d2cba30952e0e008f60b25b5ba0d41a
 create mode 100644 tests/resources/cherrypick/.gitted/objects/85/36dd6f0ec3ddecb9f9b6c8c64c6d322cd01211
 create mode 100644 tests/resources/cherrypick/.gitted/objects/85/a4a1d791973644f24c72f5e89420d3064cc452
 create mode 100644 tests/resources/cherrypick/.gitted/objects/8b/5c30499a71001189b647f4d5b57fa8f04897ce
 create mode 100644 tests/resources/cherrypick/.gitted/objects/96/4ea3da044d9083181a88ba6701de9e35778bf4
 create mode 100644 tests/resources/cherrypick/.gitted/objects/9c/c39fca3765a2facbe31157f7d60c2602193f36
 create mode 100644 tests/resources/cherrypick/.gitted/objects/9c/cb9bf50c011fd58dcbaa65df917bf79539717f
 create mode 100644 tests/resources/cherrypick/.gitted/objects/a1/0b59f4280491afe6e430c30654a7acc67d4a33
 create mode 100644 tests/resources/cherrypick/.gitted/objects/a2/1b4bfe7a04ab18024fb57f4ae9a52a1acef394
 create mode 100644 tests/resources/cherrypick/.gitted/objects/a4/3a050c588d4e92f11a6b139680923e9728477d
 create mode 100644 tests/resources/cherrypick/.gitted/objects/a5/8ca3fee5eb68b11adc2703e5843f968c9dad1e
 create mode 100644 tests/resources/cherrypick/.gitted/objects/a6/61b5dec1004e2c62654ded3762370c27cf266b
 create mode 100644 tests/resources/cherrypick/.gitted/objects/a6/9ef8fcbb9a2c509a7dbf4f23d257eb551d5610
 create mode 100644 tests/resources/cherrypick/.gitted/objects/a8/3c6f70297b805dedc549e6583582966f6ebcab
 create mode 100644 tests/resources/cherrypick/.gitted/objects/a9/020cd240774e4d672732bcb82d516d9685da76
 create mode 100644 tests/resources/cherrypick/.gitted/objects/ab/4115f808bc585b60f822da7020af86d20f62c8
 create mode 100644 tests/resources/cherrypick/.gitted/objects/ab/e4603bc7cd5b8167a267e0e2418fd2348f8cff
 create mode 100644 tests/resources/cherrypick/.gitted/objects/b8/26e9b36e22e949ec885e7a1f3db496bbab6cd0
 create mode 100644 tests/resources/cherrypick/.gitted/objects/ba/fbf6912c09505ac60575cd43d3f2aba3bd84d8
 create mode 100644 tests/resources/cherrypick/.gitted/objects/bb/14296ffa9dfbf935ec9ce2f9ed7808d952226b
 create mode 100644 tests/resources/cherrypick/.gitted/objects/bc/4dd0744364d1db380a9811bd264c101065231e
 create mode 100644 tests/resources/cherrypick/.gitted/objects/bd/65d4083845ed5ed4e1fe5feb85ac395d0760c8
 create mode 100644 tests/resources/cherrypick/.gitted/objects/bd/6ffc8c6c41f0f85ff9e3d61c9479516bac0024
 create mode 100644 tests/resources/cherrypick/.gitted/objects/bd/a51965cb36c0c5731c8cb50b80a36cac81018e
 create mode 100644 tests/resources/cherrypick/.gitted/objects/ce/d8fb81b6ec534d5deaf2a48b4b96c799712507
 create mode 100644 tests/resources/cherrypick/.gitted/objects/cf/c4f0999a8367568e049af4f72e452d40828a15
 create mode 100644 tests/resources/cherrypick/.gitted/objects/d0/f21e17beb5b9d953b1d8349049818a4f2edd1e
 create mode 100644 tests/resources/cherrypick/.gitted/objects/d3/d77487660ee3c0194ee01dc5eaf478782b1c7e
 create mode 100644 tests/resources/cherrypick/.gitted/objects/e2/33b9ed408a95e9d4b65fec7fc34943a556deb2
 create mode 100644 tests/resources/cherrypick/.gitted/objects/e5/183bfd18e3a0a691fadde2f0d5610b73282d31
 create mode 100644 tests/resources/cherrypick/.gitted/objects/e6/ae8889c40c77d7be02758235b5b3f7a4f2a129
 create mode 100644 tests/resources/cherrypick/.gitted/objects/e7/811a2bc55635f182750f0420da5ad232c1af91
 create mode 100644 tests/resources/cherrypick/.gitted/objects/e9/b63f3655b2ad80c0ff587389b5a9589a3a7110
 create mode 100644 tests/resources/cherrypick/.gitted/objects/eb/da71fe44dcb60c53b8fbd53208a1204d32e959
 create mode 100644 tests/resources/cherrypick/.gitted/objects/f0/5ed049854c1596a7cc0e957fab34961077f3ae
 create mode 100644 tests/resources/cherrypick/.gitted/objects/f0/a4e1c66bb548cd2b22eebefda703872e969775
 create mode 100644 tests/resources/cherrypick/.gitted/objects/f2/ec8c8cf1a9fb7aa047a25a4308bfe860237ad4
 create mode 100644 tests/resources/cherrypick/.gitted/objects/f5/684c96bf40c709877b56404cd8a5dd2d2a7978
 create mode 100644 tests/resources/cherrypick/.gitted/objects/f9/0f9dcbdac2cce5cc166346160e19cb693ef4e8
 create mode 100644 tests/resources/cherrypick/.gitted/refs/heads/automerge-branch
 create mode 100644 tests/resources/cherrypick/.gitted/refs/heads/master
 create mode 100644 tests/resources/cherrypick/.gitted/refs/heads/merge-branch
 create mode 100644 tests/resources/cherrypick/.gitted/refs/heads/merge-conflicts
 create mode 100644 tests/resources/cherrypick/.gitted/refs/heads/merge-mainline
 create mode 100644 tests/resources/cherrypick/.gitted/refs/heads/orphan
 create mode 100644 tests/resources/cherrypick/.gitted/refs/heads/renames
 create mode 100644 tests/resources/cherrypick/file1.txt
 create mode 100644 tests/resources/cherrypick/file2.txt
 create mode 100644 tests/resources/cherrypick/file3.txt

diff --git a/tests/cherrypick/bare.c b/tests/cherrypick/bare.c
new file mode 100644
index 000000000..7ac1054a1
--- /dev/null
+++ b/tests/cherrypick/bare.c
@@ -0,0 +1,106 @@
+#include "clar.h"
+#include "clar_libgit2.h"
+
+#include "buffer.h"
+#include "fileops.h"
+#include "git2/cherrypick.h"
+
+#include "../merge/merge_helpers.h"
+
+#define TEST_REPO_PATH "cherrypick"
+
+static git_repository *repo;
+
+void test_cherrypick_bare__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+}
+
+void test_cherrypick_bare__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_cherrypick_bare__automerge(void)
+{
+	git_commit *head = NULL, *commit = NULL;
+	git_index *index = NULL;
+	git_oid head_oid, cherry_oid;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "38c05a857e831a7e759d83778bfc85d003e21c45", 0, "file1.txt" },
+		{ 0100644, "a661b5dec1004e2c62654ded3762370c27cf266b", 0, "file2.txt" },
+		{ 0100644, "df6b290e0bd6a89b01d69f66687e8abf385283ca", 0, "file3.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+
+	git_oid_fromstr(&cherry_oid, "cfc4f0999a8367568e049af4f72e452d40828a15");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+
+	cl_git_pass(git_cherry_pick_commit(&index, repo, commit, head, 0, NULL));
+	cl_assert(merge_test_index(index, merge_index_entries, 3));
+
+	git_index_free(index);
+	git_commit_free(head);
+	git_commit_free(commit);
+}
+
+void test_cherrypick_bare__conflicts(void)
+{
+	git_commit *head = NULL, *commit = NULL;
+	git_index *index = NULL;
+	git_oid head_oid, cherry_oid;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "242e7977ba73637822ffb265b46004b9b0e5153b", 0, "file1.txt" },
+		{ 0100644, "a58ca3fee5eb68b11adc2703e5843f968c9dad1e", 1, "file2.txt" },
+		{ 0100644, "bd6ffc8c6c41f0f85ff9e3d61c9479516bac0024", 2, "file2.txt" },
+		{ 0100644, "563f6473a3858f99b80e5f93c660512ed38e1e6f", 3, "file2.txt" },
+		{ 0100644, "28d9eb4208074ad1cc84e71ccc908b34573f05d2", 1, "file3.txt" },
+		{ 0100644, "1124c2c1ae07b26fded662d6c3f3631d9dc16f88", 2, "file3.txt" },
+		{ 0100644, "e233b9ed408a95e9d4b65fec7fc34943a556deb2", 3, "file3.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+
+	git_oid_fromstr(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+
+	cl_git_pass(git_cherry_pick_commit(&index, repo, commit, head, 0, NULL));
+	cl_assert(merge_test_index(index, merge_index_entries, 7));
+
+	git_index_free(index);
+	git_commit_free(head);
+	git_commit_free(commit);
+}
+
+void test_cherrypick_bare__orphan(void)
+{
+	git_commit *head = NULL, *commit = NULL;
+	git_index *index = NULL;
+	git_oid head_oid, cherry_oid;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "38c05a857e831a7e759d83778bfc85d003e21c45", 0, "file1.txt" },
+		{ 0100644, "a661b5dec1004e2c62654ded3762370c27cf266b", 0, "file2.txt" },
+		{ 0100644, "85a4a1d791973644f24c72f5e89420d3064cc452", 0, "file3.txt" },
+		{ 0100644, "9ccb9bf50c011fd58dcbaa65df917bf79539717f", 0, "orphan.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+
+	git_oid_fromstr(&cherry_oid, "74f06b5bfec6d33d7264f73606b57a7c0b963819");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+
+	cl_git_pass(git_cherry_pick_commit(&index, repo, commit, head, 0, NULL));
+	cl_assert(merge_test_index(index, merge_index_entries, 4));
+
+	git_index_free(index);
+	git_commit_free(head);
+	git_commit_free(commit);
+}
+
diff --git a/tests/cherrypick/workdir.c b/tests/cherrypick/workdir.c
new file mode 100644
index 000000000..581a5f997
--- /dev/null
+++ b/tests/cherrypick/workdir.c
@@ -0,0 +1,429 @@
+#include "clar.h"
+#include "clar_libgit2.h"
+
+#include "buffer.h"
+#include "fileops.h"
+#include "git2/cherrypick.h"
+
+#include "../merge/merge_helpers.h"
+
+#define TEST_REPO_PATH "cherrypick"
+
+static git_repository *repo;
+static git_index *repo_index;
+
+// Fixture setup and teardown
+void test_cherrypick_workdir__initialize(void)
+{
+	repo = cl_git_sandbox_init(TEST_REPO_PATH);
+	git_repository_index(&repo_index, repo);
+}
+
+void test_cherrypick_workdir__cleanup(void)
+{
+	git_index_free(repo_index);
+	cl_git_sandbox_cleanup();
+}
+
+/* git reset --hard d3d77487660ee3c0194ee01dc5eaf478782b1c7e
+ * git cherry-pick cfc4f0999a8367568e049af4f72e452d40828a15
+ * git cherry-pick 964ea3da044d9083181a88ba6701de9e35778bf4
+ * git cherry-pick a43a050c588d4e92f11a6b139680923e9728477d
+ */
+void test_cherrypick_workdir__automerge(void)
+{
+	git_oid head_oid;
+	git_signature *signature = NULL;
+	size_t i;
+
+	const char *cherry_pick_oids[] = {
+		"cfc4f0999a8367568e049af4f72e452d40828a15",
+		"964ea3da044d9083181a88ba6701de9e35778bf4",
+		"a43a050c588d4e92f11a6b139680923e9728477d",
+	};
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "38c05a857e831a7e759d83778bfc85d003e21c45", 0, "file1.txt" },
+		{ 0100644, "a661b5dec1004e2c62654ded3762370c27cf266b", 0, "file2.txt" },
+		{ 0100644, "df6b290e0bd6a89b01d69f66687e8abf385283ca", 0, "file3.txt" },
+
+		{ 0100644, "38c05a857e831a7e759d83778bfc85d003e21c45", 0, "file1.txt" },
+		{ 0100644, "bd8fc3c59fb52d3c8b5907ace7defa5803f82419", 0, "file2.txt" },
+		{ 0100644, "df6b290e0bd6a89b01d69f66687e8abf385283ca", 0, "file3.txt" },
+
+		{ 0100644, "f06427bee380364bc7e0cb26a9245158e4726ce0", 0, "file1.txt" },
+		{ 0100644, "bd8fc3c59fb52d3c8b5907ace7defa5803f82419", 0, "file2.txt" },
+		{ 0100644, "df6b290e0bd6a89b01d69f66687e8abf385283ca", 0, "file3.txt" },
+	};
+
+	cl_git_pass(git_signature_new(&signature, "Picker", "picker@example.org", time(NULL), 0));
+
+	git_oid_fromstr(&head_oid, "d3d77487660ee3c0194ee01dc5eaf478782b1c7e");
+
+	for (i = 0; i < 3; ++i) {
+		git_commit *head = NULL, *commit = NULL;
+		git_oid cherry_oid, cherry_picked_oid, cherry_picked_tree_oid;
+		git_tree *cherry_picked_tree = NULL;
+
+		cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+		cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+
+		git_oid_fromstr(&cherry_oid, cherry_pick_oids[i]);
+		cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+		cl_git_pass(git_cherry_pick(repo, commit, NULL));
+
+		cl_assert(git_path_exists(TEST_REPO_PATH "/.git/CHERRY_PICK_HEAD"));
+		cl_assert(git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+
+		cl_git_pass(git_index_write_tree(&cherry_picked_tree_oid, repo_index));
+		cl_git_pass(git_tree_lookup(&cherry_picked_tree, repo, &cherry_picked_tree_oid));
+		cl_git_pass(git_commit_create(&cherry_picked_oid, repo, "HEAD", signature, signature, NULL,
+			"Cherry picked!", cherry_picked_tree, 1, (const git_commit **)&head));
+
+		cl_assert(merge_test_index(repo_index, merge_index_entries + i * 3, 3));
+
+		git_oid_cpy(&head_oid, &cherry_picked_oid);
+
+		git_tree_free(cherry_picked_tree);
+		git_commit_free(head);
+		git_commit_free(commit);
+	}
+
+	git_signature_free(signature);
+}
+
+/* git reset --hard bafbf6912c09505ac60575cd43d3f2aba3bd84d8
+ * git cherry-pick e9b63f3655b2ad80c0ff587389b5a9589a3a7110
+ */
+void test_cherrypick_workdir__conflicts(void)
+{
+	git_commit *head = NULL, *commit = NULL;
+	git_oid head_oid, cherry_oid;
+	git_buf conflicting_buf = GIT_BUF_INIT, mergemsg_buf = GIT_BUF_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "242e7977ba73637822ffb265b46004b9b0e5153b", 0, "file1.txt" },
+		{ 0100644, "a58ca3fee5eb68b11adc2703e5843f968c9dad1e", 1, "file2.txt" },
+		{ 0100644, "bd6ffc8c6c41f0f85ff9e3d61c9479516bac0024", 2, "file2.txt" },
+		{ 0100644, "563f6473a3858f99b80e5f93c660512ed38e1e6f", 3, "file2.txt" },
+		{ 0100644, "28d9eb4208074ad1cc84e71ccc908b34573f05d2", 1, "file3.txt" },
+		{ 0100644, "1124c2c1ae07b26fded662d6c3f3631d9dc16f88", 2, "file3.txt" },
+		{ 0100644, "e233b9ed408a95e9d4b65fec7fc34943a556deb2", 3, "file3.txt" },
+	};
+
+	git_oid_fromstr(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8");
+
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+
+	git_oid_fromstr(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+	cl_git_pass(git_cherry_pick(repo, commit, NULL));
+
+	cl_assert(git_path_exists(TEST_REPO_PATH "/.git/CHERRY_PICK_HEAD"));
+	cl_assert(git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 7));
+
+	cl_git_pass(git_futils_readbuffer(&mergemsg_buf,
+		TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_assert(strcmp(git_buf_cstr(&mergemsg_buf),
+		"Change all files\n" \
+		"\n" \
+		"Conflicts:\n" \
+		"\tfile2.txt\n" \
+		"\tfile3.txt\n") == 0);
+
+	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
+		TEST_REPO_PATH "/file2.txt"));
+
+	cl_assert(strcmp(git_buf_cstr(&conflicting_buf),
+		"!File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2!!\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"File 2\n" \
+		"<<<<<<< HEAD\n" \
+		"File 2\n" \
+		"=======\n" \
+		"File 2!\n" \
+		"File 2\n" \
+		"File 2!\n" \
+		">>>>>>> e9b63f3... Change all files\n") == 0);
+
+	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
+		TEST_REPO_PATH "/file3.txt"));
+
+	cl_assert(strcmp(git_buf_cstr(&conflicting_buf),
+		"!File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3!!\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"File 3\n" \
+		"<<<<<<< HEAD\n" \
+		"=======\n" \
+		"File 3!\n" \
+		"File 3!\n" \
+		">>>>>>> e9b63f3... Change all files\n") == 0);
+
+	git_commit_free(commit);
+	git_commit_free(head);
+	git_buf_free(&mergemsg_buf);
+	git_buf_free(&conflicting_buf);
+}
+
+/* git reset --hard bafbf6912c09505ac60575cd43d3f2aba3bd84d8
+ * git cherry-pick -X ours e9b63f3655b2ad80c0ff587389b5a9589a3a7110
+ */
+void test_cherrypick_workdir__conflict_use_ours(void)
+{
+	git_commit *head = NULL, *commit = NULL;
+	git_oid head_oid, cherry_oid;
+	git_cherry_pick_options opts = GIT_CHERRY_PICK_OPTIONS_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "242e7977ba73637822ffb265b46004b9b0e5153b", 0, "file1.txt" },
+		{ 0100644, "a58ca3fee5eb68b11adc2703e5843f968c9dad1e", 1, "file2.txt" },
+		{ 0100644, "bd6ffc8c6c41f0f85ff9e3d61c9479516bac0024", 2, "file2.txt" },
+		{ 0100644, "563f6473a3858f99b80e5f93c660512ed38e1e6f", 3, "file2.txt" },
+		{ 0100644, "28d9eb4208074ad1cc84e71ccc908b34573f05d2", 1, "file3.txt" },
+		{ 0100644, "1124c2c1ae07b26fded662d6c3f3631d9dc16f88", 2, "file3.txt" },
+		{ 0100644, "e233b9ed408a95e9d4b65fec7fc34943a556deb2", 3, "file3.txt" },
+	};
+
+	struct merge_index_entry merge_filesystem_entries[] = {
+		{ 0100644, "242e7977ba73637822ffb265b46004b9b0e5153b", 0, "file1.txt" },
+		{ 0100644, "bd6ffc8c6c41f0f85ff9e3d61c9479516bac0024", 0, "file2.txt" },
+		{ 0100644, "1124c2c1ae07b26fded662d6c3f3631d9dc16f88", 0, "file3.txt" },
+	};
+
+	/* leave the index in a conflicted state, but checkout "ours" to the workdir */
+	opts.checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_USE_OURS;
+
+	git_oid_fromstr(&head_oid, "bafbf6912c09505ac60575cd43d3f2aba3bd84d8");
+
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+
+	git_oid_fromstr(&cherry_oid, "e9b63f3655b2ad80c0ff587389b5a9589a3a7110");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+	cl_git_pass(git_cherry_pick(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 7));
+	cl_assert(merge_test_workdir(repo, merge_filesystem_entries, 3));
+
+	/* resolve conflicts in the index by taking "ours" */
+	opts.merge_opts.file_favor = GIT_MERGE_FILE_FAVOR_OURS;
+
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+	cl_git_pass(git_cherry_pick(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_filesystem_entries, 3));
+	cl_assert(merge_test_workdir(repo, merge_filesystem_entries, 3));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard cfc4f0999a8367568e049af4f72e452d40828a15
+ * git cherry-pick 2a26c7e88b285613b302ba76712bc998863f3cbc
+ */
+void test_cherrypick_workdir__rename(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, cherry_oid;
+	git_cherry_pick_options opts = GIT_CHERRY_PICK_OPTIONS_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "19c5c7207054604b69c84d08a7571ef9672bb5c2", 0, "file1.txt" },
+		{ 0100644, "a58ca3fee5eb68b11adc2703e5843f968c9dad1e", 0, "file2.txt" },
+		{ 0100644, "28d9eb4208074ad1cc84e71ccc908b34573f05d2", 0, "file3.txt.renamed" },
+	};
+
+	opts.merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_opts.rename_threshold = 50;
+
+	git_oid_fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+
+	git_oid_fromstr(&cherry_oid, "2a26c7e88b285613b302ba76712bc998863f3cbc");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+	cl_git_pass(git_cherry_pick(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard 44cd2ed2052c9c68f9a439d208e9614dc2a55c70
+ * git cherry-pick 2a26c7e88b285613b302ba76712bc998863f3cbc
+ */
+void test_cherrypick_workdir__both_renamed(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, cherry_oid;
+	git_buf mergemsg_buf = GIT_BUF_INIT;
+	git_cherry_pick_options opts = GIT_CHERRY_PICK_OPTIONS_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "19c5c7207054604b69c84d08a7571ef9672bb5c2", 0, "file1.txt" },
+		{ 0100644, "a58ca3fee5eb68b11adc2703e5843f968c9dad1e", 0, "file2.txt" },
+		{ 0100644, "e233b9ed408a95e9d4b65fec7fc34943a556deb2", 1, "file3.txt" },
+		{ 0100644, "e233b9ed408a95e9d4b65fec7fc34943a556deb2", 3, "file3.txt.renamed" },
+		{ 0100644, "28d9eb4208074ad1cc84e71ccc908b34573f05d2", 2, "file3.txt.renamed_on_branch" },
+	};
+
+	opts.merge_opts.flags |= GIT_MERGE_TREE_FIND_RENAMES;
+	opts.merge_opts.rename_threshold = 50;
+
+	git_oid_fromstr(&head_oid, "44cd2ed2052c9c68f9a439d208e9614dc2a55c70");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+
+	git_oid_fromstr(&cherry_oid, "2a26c7e88b285613b302ba76712bc998863f3cbc");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+	cl_git_pass(git_cherry_pick(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 5));
+
+	cl_git_pass(git_futils_readbuffer(&mergemsg_buf,
+		TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_assert(strcmp(git_buf_cstr(&mergemsg_buf),
+		"Renamed file3.txt -> file3.txt.renamed\n" \
+		"\n" \
+		"Conflicts:\n" \
+		"\tfile3.txt\n" \
+		"\tfile3.txt.renamed\n" \
+		"\tfile3.txt.renamed_on_branch\n") == 0);
+
+	git_buf_free(&mergemsg_buf);
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+void test_cherrypick_workdir__nonmerge_fails_mainline_specified(void)
+{
+	git_reference *head;
+	git_commit *commit;
+	git_cherry_pick_options opts = GIT_CHERRY_PICK_OPTIONS_INIT;
+
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel((git_object **)&commit, head, GIT_OBJ_COMMIT));
+
+	opts.mainline = 1;
+	cl_must_fail(git_cherry_pick(repo, commit, &opts));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/CHERRY_PICK_HEAD"));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+
+	git_reference_free(head);
+	git_commit_free(commit);
+}
+
+/* git reset --hard cfc4f0999a8367568e049af4f72e452d40828a15
+ * git cherry-pick abe4603bc7cd5b8167a267e0e2418fd2348f8cff
+ */
+void test_cherrypick_workdir__merge_fails_without_mainline_specified(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, cherry_oid;
+
+	git_oid_fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+
+	git_oid_fromstr(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+
+	cl_must_fail(git_cherry_pick(repo, commit, NULL));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/CHERRY_PICK_HEAD"));
+	cl_assert(!git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard cfc4f0999a8367568e049af4f72e452d40828a15
+ * git cherry-pick -m1 abe4603bc7cd5b8167a267e0e2418fd2348f8cff
+ */
+void test_cherrypick_workdir__merge_first_parent(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, cherry_oid;
+	git_cherry_pick_options opts = GIT_CHERRY_PICK_OPTIONS_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "f90f9dcbdac2cce5cc166346160e19cb693ef4e8", 0, "file1.txt" },
+		{ 0100644, "563f6473a3858f99b80e5f93c660512ed38e1e6f", 0, "file2.txt" },
+		{ 0100644, "e233b9ed408a95e9d4b65fec7fc34943a556deb2", 0, "file3.txt" },
+	};
+
+	opts.mainline = 1;
+
+	git_oid_fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+
+	git_oid_fromstr(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+
+	cl_git_pass(git_cherry_pick(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
+/* git reset --hard cfc4f0999a8367568e049af4f72e452d40828a15
+ * git cherry-pick -m2 abe4603bc7cd5b8167a267e0e2418fd2348f8cff
+ */
+void test_cherrypick_workdir__merge_second_parent(void)
+{
+	git_commit *head, *commit;
+	git_oid head_oid, cherry_oid;
+	git_cherry_pick_options opts = GIT_CHERRY_PICK_OPTIONS_INIT;
+
+	struct merge_index_entry merge_index_entries[] = {
+		{ 0100644, "487434cace79238a7091e2220611d4f20a765690", 0, "file1.txt" },
+		{ 0100644, "e5183bfd18e3a0a691fadde2f0d5610b73282d31", 0, "file2.txt" },
+		{ 0100644, "409a1bec58bf35348e8b62b72bb9c1f45cf5a587", 0, "file3.txt" },
+	};
+
+	opts.mainline = 2;
+
+	git_oid_fromstr(&head_oid, "cfc4f0999a8367568e049af4f72e452d40828a15");
+	cl_git_pass(git_commit_lookup(&head, repo, &head_oid));
+	cl_git_pass(git_reset(repo, (git_object *)head, GIT_RESET_HARD, NULL, NULL));
+
+	git_oid_fromstr(&cherry_oid, "abe4603bc7cd5b8167a267e0e2418fd2348f8cff");
+	cl_git_pass(git_commit_lookup(&commit, repo, &cherry_oid));
+
+	cl_git_pass(git_cherry_pick(repo, commit, &opts));
+
+	cl_assert(merge_test_index(repo_index, merge_index_entries, 3));
+
+	git_commit_free(commit);
+	git_commit_free(head);
+}
+
diff --git a/tests/resources/cherrypick/.gitted/HEAD b/tests/resources/cherrypick/.gitted/HEAD
new file mode 100644
index 000000000..656ac0e0a
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/automerge-branch
diff --git a/tests/resources/cherrypick/.gitted/config b/tests/resources/cherrypick/.gitted/config
new file mode 100644
index 000000000..6c9406b7d
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/config
@@ -0,0 +1,7 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+	ignorecase = true
+	precomposeunicode = true
diff --git a/tests/resources/cherrypick/.gitted/index b/tests/resources/cherrypick/.gitted/index
new file mode 100644
index 000000000..7291006c8
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/index differ
diff --git a/tests/resources/cherrypick/.gitted/info/exclude b/tests/resources/cherrypick/.gitted/info/exclude
new file mode 100644
index 000000000..a5196d1be
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/info/exclude
@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
diff --git a/tests/resources/cherrypick/.gitted/objects/01/a2b453c2647c71ccfefc285f2266d1f00b8253 b/tests/resources/cherrypick/.gitted/objects/01/a2b453c2647c71ccfefc285f2266d1f00b8253
new file mode 100644
index 000000000..736a7f57b
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/01/a2b453c2647c71ccfefc285f2266d1f00b8253 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/02/67838e09bbc5969bba035be2d27c8a6de694d8 b/tests/resources/cherrypick/.gitted/objects/02/67838e09bbc5969bba035be2d27c8a6de694d8
new file mode 100644
index 000000000..4eacb26f5
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/02/67838e09bbc5969bba035be2d27c8a6de694d8 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/06/3fc9f01e6e9ec2a8d8f749885e931875e50d37 b/tests/resources/cherrypick/.gitted/objects/06/3fc9f01e6e9ec2a8d8f749885e931875e50d37
new file mode 100644
index 000000000..48fa6efcd
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/06/3fc9f01e6e9ec2a8d8f749885e931875e50d37 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/08/9ac03f76058b5ba0b44bb268f317f9242481e9 b/tests/resources/cherrypick/.gitted/objects/08/9ac03f76058b5ba0b44bb268f317f9242481e9
new file mode 100644
index 000000000..06d1c694e
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/08/9ac03f76058b5ba0b44bb268f317f9242481e9
@@ -0,0 +1,3 @@
+x
¥ÎA
+Â0@Q×9Å왤“i"î—Þ`L§µB¬MÓ…··àܾÅç§)籂#ÞÕ¢
+^�CN�Øä™”Îb+˜%¸˜¬�Š÷¨bÞRôU!õ‰zŒ1Jh¸õ)JO}딼ëƒb½‘µ>¦WIóª\´äqy¬ŸŽÏŸ
祖QªÒ”O`›ÈDÍ6
{tˆfÓmµê_sÓy‹‚@Ö2¨ù("O-
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/0d/447a6c2528b06616cde3b209a4b4ea3dcb8d65 b/tests/resources/cherrypick/.gitted/objects/0d/447a6c2528b06616cde3b209a4b4ea3dcb8d65
new file mode 100644
index 000000000..9a3ea3209
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/0d/447a6c2528b06616cde3b209a4b4ea3dcb8d65 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/11/24c2c1ae07b26fded662d6c3f3631d9dc16f88 b/tests/resources/cherrypick/.gitted/objects/11/24c2c1ae07b26fded662d6c3f3631d9dc16f88
new file mode 100644
index 000000000..62abc3c5b
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/11/24c2c1ae07b26fded662d6c3f3631d9dc16f88 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/12/905f4ea5b76f9d3fdcfe73e462201c06ae632a b/tests/resources/cherrypick/.gitted/objects/12/905f4ea5b76f9d3fdcfe73e462201c06ae632a
new file mode 100644
index 000000000..162844a70
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/12/905f4ea5b76f9d3fdcfe73e462201c06ae632a differ
diff --git a/tests/resources/cherrypick/.gitted/objects/19/c5c7207054604b69c84d08a7571ef9672bb5c2 b/tests/resources/cherrypick/.gitted/objects/19/c5c7207054604b69c84d08a7571ef9672bb5c2
new file mode 100644
index 000000000..d5cd6d3f2
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/19/c5c7207054604b69c84d08a7571ef9672bb5c2 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/1c/2116845780455ecf916538c1cc27c4222452af b/tests/resources/cherrypick/.gitted/objects/1c/2116845780455ecf916538c1cc27c4222452af
new file mode 100644
index 000000000..f9a841d4f
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/1c/2116845780455ecf916538c1cc27c4222452af differ
diff --git a/tests/resources/cherrypick/.gitted/objects/1c/c85eb4ff0a8438fde1b14274c6f87f891b36a0 b/tests/resources/cherrypick/.gitted/objects/1c/c85eb4ff0a8438fde1b14274c6f87f891b36a0
new file mode 100644
index 000000000..98b792b64
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/1c/c85eb4ff0a8438fde1b14274c6f87f891b36a0 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/1e/1cb7391d25dcd8daba88f1f627f3045982286c b/tests/resources/cherrypick/.gitted/objects/1e/1cb7391d25dcd8daba88f1f627f3045982286c
new file mode 100644
index 000000000..10a5be6fe
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/1e/1cb7391d25dcd8daba88f1f627f3045982286c differ
diff --git a/tests/resources/cherrypick/.gitted/objects/20/fc1a4c9d994021f43d33ab75e4252e27ca661d b/tests/resources/cherrypick/.gitted/objects/20/fc1a4c9d994021f43d33ab75e4252e27ca661d
new file mode 100644
index 000000000..c8b26cd01
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/20/fc1a4c9d994021f43d33ab75e4252e27ca661d differ
diff --git a/tests/resources/cherrypick/.gitted/objects/28/d9eb4208074ad1cc84e71ccc908b34573f05d2 b/tests/resources/cherrypick/.gitted/objects/28/d9eb4208074ad1cc84e71ccc908b34573f05d2
new file mode 100644
index 000000000..80363b016
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/28/d9eb4208074ad1cc84e71ccc908b34573f05d2 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/2a/26c7e88b285613b302ba76712bc998863f3cbc b/tests/resources/cherrypick/.gitted/objects/2a/26c7e88b285613b302ba76712bc998863f3cbc
new file mode 100644
index 000000000..283113999
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/2a/26c7e88b285613b302ba76712bc998863f3cbc
@@ -0,0 +1 @@
+x
¥�MjÃ0…»Ö)f_jôï„�]¡ËÜ`$�—*Nä1´·¯C=@—ï{ðñ^YZ›lLOÒ™Á”‚�³¯Uz‡ub“�·£/±âX1™ì"iu£ÎW
N9ºêbÙÒ„ºèZŽS”&r4£mrY:¼Q¹o¼Â+÷6¯—í{…ÃÇ/{?­ÒgÊÒŽ`\ŠÞk-<k«µÚé>Uø_uæ+5ž ÎŸìùx9þ…a?õ¨Õ7˜W…
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/2a/c3b376093de405b0a951bff578655b1c2b7fa1 b/tests/resources/cherrypick/.gitted/objects/2a/c3b376093de405b0a951bff578655b1c2b7fa1
new file mode 100644
index 000000000..a3294d764
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/2a/c3b376093de405b0a951bff578655b1c2b7fa1
@@ -0,0 +1 @@
+x
•�ÁJÅ0E]ç+f÷¢¤“Iš
w‚àGLÒÉk…´š¦ÿÞÊóÜž‡{óVëÒ
G{×›*¤ˆA9¹ ˆÊÄšcô:ÊPÜ”ˆCJ’Bž¬ù”¦k‡\2ËÌ]}ˆj‰¥PQÉãD6b”Á9ú¼5x“üuè¯Úê²ÏÇ÷O7v}Ù{[¤ËcÞê3Ž‘‹žàÞ¢µæ¤çÔ®ÿ�#þEÌ»¶ëy³Éšg¸TÙÏà–µoPÕÃM™Í/X˜
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/2c/acbcaabf785f1ac231e8519849d4ad38692f2c b/tests/resources/cherrypick/.gitted/objects/2c/acbcaabf785f1ac231e8519849d4ad38692f2c
new file mode 100644
index 000000000..74b48dd6b
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/2c/acbcaabf785f1ac231e8519849d4ad38692f2c differ
diff --git a/tests/resources/cherrypick/.gitted/objects/35/cb210149022c7379b0a67b0dec13cc628ff87d b/tests/resources/cherrypick/.gitted/objects/35/cb210149022c7379b0a67b0dec13cc628ff87d
new file mode 100644
index 000000000..c0466f46a
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/35/cb210149022c7379b0a67b0dec13cc628ff87d differ
diff --git a/tests/resources/cherrypick/.gitted/objects/38/c05a857e831a7e759d83778bfc85d003e21c45 b/tests/resources/cherrypick/.gitted/objects/38/c05a857e831a7e759d83778bfc85d003e21c45
new file mode 100644
index 000000000..d4f1cf8ac
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/38/c05a857e831a7e759d83778bfc85d003e21c45 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/3f/9eed8946df9e2c737d3b8dc0b8e78959aacd92 b/tests/resources/cherrypick/.gitted/objects/3f/9eed8946df9e2c737d3b8dc0b8e78959aacd92
new file mode 100644
index 000000000..8c4d6d94f
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/3f/9eed8946df9e2c737d3b8dc0b8e78959aacd92
@@ -0,0 +1,5 @@
+x
��MjÃ0…»Ö)fj¤ñH– „ì]æÃdÔ¸Dq#ËÐÞ¾
+-tßåûáã=YJ™`HO­ª‚t.DòS´ä½JN.ø1ŠÁIÉ#góÁUo
$e›Râ8†É‡¨–gÊj/žÉFŒì¼á­]–
+¯,÷MW8j-ózÙ¾VxyÿñÞk«37d){pc
+Ôˆ°³h­énŸÚô
+îbNzã¢gÈóUÇ¡}6xÞÿ‰¡ŸzÄæï*V8
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/40/9a1bec58bf35348e8b62b72bb9c1f45cf5a587 b/tests/resources/cherrypick/.gitted/objects/40/9a1bec58bf35348e8b62b72bb9c1f45cf5a587
new file mode 100644
index 000000000..60d5dca4a
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/40/9a1bec58bf35348e8b62b72bb9c1f45cf5a587 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/44/cd2ed2052c9c68f9a439d208e9614dc2a55c70 b/tests/resources/cherrypick/.gitted/objects/44/cd2ed2052c9c68f9a439d208e9614dc2a55c70
new file mode 100644
index 000000000..8697c4e66
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/44/cd2ed2052c9c68f9a439d208e9614dc2a55c70
@@ -0,0 +1 @@
+x
¥�ÁNÄ0C9ç+推’É$M$´â†Ä‘XÍ&Úi!M%ø{ºð	ÜìgɲÓZëÜ
Çp×› .É0¥˜c$�¦�ÍÖòetBèPpLì½Éꃛ,RITtŒ‘ƒõ£óA4E.TFr˜Ilœâ½OkƒNŸ»lð,­ÎÛ´oðxýcoO[o3wÒZO`lôD.÷µV=¦vùW‰z•…«d(ó»Ø¡ux8ýš›ŽO·ô¼.çKã%MêÖ?ZØ
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/48/7434cace79238a7091e2220611d4f20a765690 b/tests/resources/cherrypick/.gitted/objects/48/7434cace79238a7091e2220611d4f20a765690
new file mode 100644
index 000000000..a1fa599e1
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/48/7434cace79238a7091e2220611d4f20a765690 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/49/20ad2f17162dcc8823ad491444dcb87f5899c9 b/tests/resources/cherrypick/.gitted/objects/49/20ad2f17162dcc8823ad491444dcb87f5899c9
new file mode 100644
index 000000000..bf96fccad
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/49/20ad2f17162dcc8823ad491444dcb87f5899c9 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 b/tests/resources/cherrypick/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904
new file mode 100644
index 000000000..adf64119a
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/4b/825dc642cb6eb9a060e54bf8d69288fbee4904 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/4c/532774cc1fea37f6efc2256763a64d38c8cdde b/tests/resources/cherrypick/.gitted/objects/4c/532774cc1fea37f6efc2256763a64d38c8cdde
new file mode 100644
index 000000000..2e56d7403
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/4c/532774cc1fea37f6efc2256763a64d38c8cdde differ
diff --git a/tests/resources/cherrypick/.gitted/objects/51/145af30d411a50195b66517d825e69bf57ed22 b/tests/resources/cherrypick/.gitted/objects/51/145af30d411a50195b66517d825e69bf57ed22
new file mode 100644
index 000000000..3e01376bd
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/51/145af30d411a50195b66517d825e69bf57ed22 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/54/61de53ffadbf15be4dd6345997c15689573209 b/tests/resources/cherrypick/.gitted/objects/54/61de53ffadbf15be4dd6345997c15689573209
new file mode 100644
index 000000000..7d2b233a6
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/54/61de53ffadbf15be4dd6345997c15689573209
@@ -0,0 +1,4 @@
+x
��MjÃ0…»Ö)fj¤ñH– „ì]æÃdÔ¸Dq#ËÐÞ¾
+-tßåûáã=YJ™`HO­ª‚t.DòS´ä½JN.ø1ŠÁIÉ#góÁUo
$e›Râ8†É‡¨–gÊj/žÉFŒì¼á­]–
+¯,÷MW8j-ózÙ¾VxyÿñÞk«37d){pc
+Ôˆ°³h­énŸÚô?J¿sÒ=Cž¯:í³ÁóþOýÔ#6ßïäV<
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/54/784f10955e92ab27e4fa832e40cb2baf1edbdc b/tests/resources/cherrypick/.gitted/objects/54/784f10955e92ab27e4fa832e40cb2baf1edbdc
new file mode 100644
index 000000000..2a5bcec27
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/54/784f10955e92ab27e4fa832e40cb2baf1edbdc differ
diff --git a/tests/resources/cherrypick/.gitted/objects/56/3f6473a3858f99b80e5f93c660512ed38e1e6f b/tests/resources/cherrypick/.gitted/objects/56/3f6473a3858f99b80e5f93c660512ed38e1e6f
new file mode 100644
index 000000000..8847ed689
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/56/3f6473a3858f99b80e5f93c660512ed38e1e6f differ
diff --git a/tests/resources/cherrypick/.gitted/objects/58/a957ef0061c1a8ef995c855dfab4f5da8d6617 b/tests/resources/cherrypick/.gitted/objects/58/a957ef0061c1a8ef995c855dfab4f5da8d6617
new file mode 100644
index 000000000..f161a1941
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/58/a957ef0061c1a8ef995c855dfab4f5da8d6617 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/5d/c7e1f440ce74d5503a0dfbc6c30e091475f774 b/tests/resources/cherrypick/.gitted/objects/5d/c7e1f440ce74d5503a0dfbc6c30e091475f774
new file mode 100644
index 000000000..77deeaf0b
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/5d/c7e1f440ce74d5503a0dfbc6c30e091475f774 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/5e/2206cda1c56430ad107a6866a829c159e0b9ea b/tests/resources/cherrypick/.gitted/objects/5e/2206cda1c56430ad107a6866a829c159e0b9ea
new file mode 100644
index 000000000..aa30f501f
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/5e/2206cda1c56430ad107a6866a829c159e0b9ea
@@ -0,0 +1 @@
+x
+)JMU044d040031QHËÌI5Ô+©(aøô¦§çãÊßUÜE9sì‘ \uI‘X‘œÌvKYÕ;7níêøøMý3Kd“F’"c°¢ˆ•áï®x?3¦5ö×–¯·zÓÄ
Ѩ1*
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/5f/77a2a13935ac62a629553f8944ad57b1ed8b4a b/tests/resources/cherrypick/.gitted/objects/5f/77a2a13935ac62a629553f8944ad57b1ed8b4a
new file mode 100644
index 000000000..5e622a1fa
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/5f/77a2a13935ac62a629553f8944ad57b1ed8b4a differ
diff --git a/tests/resources/cherrypick/.gitted/objects/63/c0d92b95253c4a40d3883f423a54be47d2c4c8 b/tests/resources/cherrypick/.gitted/objects/63/c0d92b95253c4a40d3883f423a54be47d2c4c8
new file mode 100644
index 000000000..eafe2c30a
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/63/c0d92b95253c4a40d3883f423a54be47d2c4c8 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/6c/e83eb5f0fd34a10c3d25c6b36d2ed7ec0d6ce7 b/tests/resources/cherrypick/.gitted/objects/6c/e83eb5f0fd34a10c3d25c6b36d2ed7ec0d6ce7
new file mode 100644
index 000000000..1c1f5034d
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/6c/e83eb5f0fd34a10c3d25c6b36d2ed7ec0d6ce7 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/6d/1c2afe5eeb9e497528e2780ac468a5465cbc96 b/tests/resources/cherrypick/.gitted/objects/6d/1c2afe5eeb9e497528e2780ac468a5465cbc96
new file mode 100644
index 000000000..a98378a70
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/6d/1c2afe5eeb9e497528e2780ac468a5465cbc96
@@ -0,0 +1 @@
+x
¥Î=jÃ@@áÔ{Šé
fvöLpgp“3ÌŽF–²œÕªðímðÒ¾âãɺ,sòþ«7Uàì$Ž	©¤š1:HðEcÈ.d*1ŽQ«p5nzïà‚T²h}A"I.•ŠSÅAÅ:‘Hysï}Z\YþvÝà¢m™·inpúý´ÛyëmæÎGY—o°®Ä`É$Dó®ïÕ®ÿBÌO{L|‡f^äðOA
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/74/f06b5bfec6d33d7264f73606b57a7c0b963819 b/tests/resources/cherrypick/.gitted/objects/74/f06b5bfec6d33d7264f73606b57a7c0b963819
new file mode 100644
index 000000000..732011fce
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/74/f06b5bfec6d33d7264f73606b57a7c0b963819 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/82/8b08c52d2cba30952e0e008f60b25b5ba0d41a b/tests/resources/cherrypick/.gitted/objects/82/8b08c52d2cba30952e0e008f60b25b5ba0d41a
new file mode 100644
index 000000000..302014bff
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/82/8b08c52d2cba30952e0e008f60b25b5ba0d41a differ
diff --git a/tests/resources/cherrypick/.gitted/objects/85/36dd6f0ec3ddecb9f9b6c8c64c6d322cd01211 b/tests/resources/cherrypick/.gitted/objects/85/36dd6f0ec3ddecb9f9b6c8c64c6d322cd01211
new file mode 100644
index 000000000..db6faa9e2
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/85/36dd6f0ec3ddecb9f9b6c8c64c6d322cd01211 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/85/a4a1d791973644f24c72f5e89420d3064cc452 b/tests/resources/cherrypick/.gitted/objects/85/a4a1d791973644f24c72f5e89420d3064cc452
new file mode 100644
index 000000000..7fe69b6f8
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/85/a4a1d791973644f24c72f5e89420d3064cc452 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/8b/5c30499a71001189b647f4d5b57fa8f04897ce b/tests/resources/cherrypick/.gitted/objects/8b/5c30499a71001189b647f4d5b57fa8f04897ce
new file mode 100644
index 000000000..8b1638fbb
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/8b/5c30499a71001189b647f4d5b57fa8f04897ce differ
diff --git a/tests/resources/cherrypick/.gitted/objects/96/4ea3da044d9083181a88ba6701de9e35778bf4 b/tests/resources/cherrypick/.gitted/objects/96/4ea3da044d9083181a88ba6701de9e35778bf4
new file mode 100644
index 000000000..2dec33f69
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/96/4ea3da044d9083181a88ba6701de9e35778bf4 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/9c/c39fca3765a2facbe31157f7d60c2602193f36 b/tests/resources/cherrypick/.gitted/objects/9c/c39fca3765a2facbe31157f7d60c2602193f36
new file mode 100644
index 000000000..00314454f
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/9c/c39fca3765a2facbe31157f7d60c2602193f36 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/9c/cb9bf50c011fd58dcbaa65df917bf79539717f b/tests/resources/cherrypick/.gitted/objects/9c/cb9bf50c011fd58dcbaa65df917bf79539717f
new file mode 100644
index 000000000..1266aff36
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/9c/cb9bf50c011fd58dcbaa65df917bf79539717f differ
diff --git a/tests/resources/cherrypick/.gitted/objects/a1/0b59f4280491afe6e430c30654a7acc67d4a33 b/tests/resources/cherrypick/.gitted/objects/a1/0b59f4280491afe6e430c30654a7acc67d4a33
new file mode 100644
index 000000000..7aa0a5dcd
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/a1/0b59f4280491afe6e430c30654a7acc67d4a33 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/a2/1b4bfe7a04ab18024fb57f4ae9a52a1acef394 b/tests/resources/cherrypick/.gitted/objects/a2/1b4bfe7a04ab18024fb57f4ae9a52a1acef394
new file mode 100644
index 000000000..07b7195d2
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/a2/1b4bfe7a04ab18024fb57f4ae9a52a1acef394 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/a4/3a050c588d4e92f11a6b139680923e9728477d b/tests/resources/cherrypick/.gitted/objects/a4/3a050c588d4e92f11a6b139680923e9728477d
new file mode 100644
index 000000000..4713fb2db
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/a4/3a050c588d4e92f11a6b139680923e9728477d
@@ -0,0 +1 @@
+x
¥ÎMjÃ0†á®uŠÙÂHŠþ ”B�Üb4Ç.‘ÝJ2´·� Gèöáãåã½”µƒqñ¥WÈ9�¼ãl=#»`5GÎsDD5ê(ꋪlìXš!—„Æp°!e$2NÂÚ2{ç9†IÑÑ—½Â�øû�W©emËñÛàõóÏîï­×•:�y/o mò“‚7pBƒ¨†Ž«]þQmw™`^¢Ïý§Ã¾A¡6ºê	mT
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/a5/8ca3fee5eb68b11adc2703e5843f968c9dad1e b/tests/resources/cherrypick/.gitted/objects/a5/8ca3fee5eb68b11adc2703e5843f968c9dad1e
new file mode 100644
index 000000000..1c3f2fb01
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/a5/8ca3fee5eb68b11adc2703e5843f968c9dad1e differ
diff --git a/tests/resources/cherrypick/.gitted/objects/a6/61b5dec1004e2c62654ded3762370c27cf266b b/tests/resources/cherrypick/.gitted/objects/a6/61b5dec1004e2c62654ded3762370c27cf266b
new file mode 100644
index 000000000..d94a9541f
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/a6/61b5dec1004e2c62654ded3762370c27cf266b differ
diff --git a/tests/resources/cherrypick/.gitted/objects/a6/9ef8fcbb9a2c509a7dbf4f23d257eb551d5610 b/tests/resources/cherrypick/.gitted/objects/a6/9ef8fcbb9a2c509a7dbf4f23d257eb551d5610
new file mode 100644
index 000000000..69feba205
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/a6/9ef8fcbb9a2c509a7dbf4f23d257eb551d5610
@@ -0,0 +1 @@
+x
¥Î1ŠÃ0@Ñ­uŠéA�¤,!] åÞ`,�/h�Èr‘ÛÇ°GHûŠÏÏK­s¤ðÕ›*heæ”Éæ§8ªÅè�ýèJ*(&ó�¦rÉTlJIØ…è«¥$…JD%�YF–ÁÙú}ip•üÜt…‹¶:¯÷íµÂ÷ï¿ÝÎko³t9楞`p)9ö­5»î«]?Š˜}nsS¨ÚnjÞGPOL
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/a8/3c6f70297b805dedc549e6583582966f6ebcab b/tests/resources/cherrypick/.gitted/objects/a8/3c6f70297b805dedc549e6583582966f6ebcab
new file mode 100644
index 000000000..5a6db508e
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/a8/3c6f70297b805dedc549e6583582966f6ebcab differ
diff --git a/tests/resources/cherrypick/.gitted/objects/a9/020cd240774e4d672732bcb82d516d9685da76 b/tests/resources/cherrypick/.gitted/objects/a9/020cd240774e4d672732bcb82d516d9685da76
new file mode 100644
index 000000000..61741aff9
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/a9/020cd240774e4d672732bcb82d516d9685da76 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/ab/4115f808bc585b60f822da7020af86d20f62c8 b/tests/resources/cherrypick/.gitted/objects/ab/4115f808bc585b60f822da7020af86d20f62c8
new file mode 100644
index 000000000..08c4bef57
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/ab/4115f808bc585b60f822da7020af86d20f62c8 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/ab/e4603bc7cd5b8167a267e0e2418fd2348f8cff b/tests/resources/cherrypick/.gitted/objects/ab/e4603bc7cd5b8167a267e0e2418fd2348f8cff
new file mode 100644
index 000000000..4e4fe6f12
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/ab/e4603bc7cd5b8167a267e0e2418fd2348f8cff
@@ -0,0 +1,4 @@
+x
¥�KNÄ0DYç½›Ùî´?Bì��8D»ÓžÉHNÀqÜžŒFœ€í«ª'•¬µÎÐƇÞT!‰`*Â<±+,YÑZ
+%LÞˆóÆÙ„ýðÅM—ì“–X$çÄNÈ$S.cq89
+š‰ìDÞš¿¾¦ìo{¢ìxŠFL)Æ”‰ÅÄÈÁ}ÞûemðÁò½ëïÚê¼]öŸ
^®wv~Ûz›¹ó³¬õ,&?Ži„GãŒz\ëú/Éð©í¬�/r�Såíž`^ú
+õ=Ý£áX¾fZ
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/b8/26e9b36e22e949ec885e7a1f3db496bbab6cd0 b/tests/resources/cherrypick/.gitted/objects/b8/26e9b36e22e949ec885e7a1f3db496bbab6cd0
new file mode 100644
index 000000000..e3bf3a017
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/b8/26e9b36e22e949ec885e7a1f3db496bbab6cd0 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/ba/fbf6912c09505ac60575cd43d3f2aba3bd84d8 b/tests/resources/cherrypick/.gitted/objects/ba/fbf6912c09505ac60575cd43d3f2aba3bd84d8
new file mode 100644
index 000000000..956da8b71
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/ba/fbf6912c09505ac60575cd43d3f2aba3bd84d8 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/bb/14296ffa9dfbf935ec9ce2f9ed7808d952226b b/tests/resources/cherrypick/.gitted/objects/bb/14296ffa9dfbf935ec9ce2f9ed7808d952226b
new file mode 100644
index 000000000..b5583685a
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/bb/14296ffa9dfbf935ec9ce2f9ed7808d952226b differ
diff --git a/tests/resources/cherrypick/.gitted/objects/bc/4dd0744364d1db380a9811bd264c101065231e b/tests/resources/cherrypick/.gitted/objects/bc/4dd0744364d1db380a9811bd264c101065231e
new file mode 100644
index 000000000..01d88a283
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/bc/4dd0744364d1db380a9811bd264c101065231e differ
diff --git a/tests/resources/cherrypick/.gitted/objects/bd/65d4083845ed5ed4e1fe5feb85ac395d0760c8 b/tests/resources/cherrypick/.gitted/objects/bd/65d4083845ed5ed4e1fe5feb85ac395d0760c8
new file mode 100644
index 000000000..6a0eccb5e
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/bd/65d4083845ed5ed4e1fe5feb85ac395d0760c8
@@ -0,0 +1,2 @@
+x
¥ÍA
+B!€áÖžböAŒ6ŠBD» [¨o^Ï@$ݾ¡í·øÿÜj-Ú›ƒtf ä�]²#““ã":dKiõ‹Æû51S@RqÊÖ:<b~Opç^ËØægÀåõ³çmH/Qâ)·z}ÎjCˆpDƒ¨vÝ×ÂEÔK»<È
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/bd/6ffc8c6c41f0f85ff9e3d61c9479516bac0024 b/tests/resources/cherrypick/.gitted/objects/bd/6ffc8c6c41f0f85ff9e3d61c9479516bac0024
new file mode 100644
index 000000000..56f836779
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/bd/6ffc8c6c41f0f85ff9e3d61c9479516bac0024 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/bd/a51965cb36c0c5731c8cb50b80a36cac81018e b/tests/resources/cherrypick/.gitted/objects/bd/a51965cb36c0c5731c8cb50b80a36cac81018e
new file mode 100644
index 000000000..1187a7089
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/bd/a51965cb36c0c5731c8cb50b80a36cac81018e differ
diff --git a/tests/resources/cherrypick/.gitted/objects/ce/d8fb81b6ec534d5deaf2a48b4b96c799712507 b/tests/resources/cherrypick/.gitted/objects/ce/d8fb81b6ec534d5deaf2a48b4b96c799712507
new file mode 100644
index 000000000..569ee0c99
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/ce/d8fb81b6ec534d5deaf2a48b4b96c799712507
@@ -0,0 +1 @@
+x
¥ÎÍJÅ0@a×yŠì…Ëä?
]	¾Åd2i+7�¦)èÛ[ðÜ~‹Ã¡ÞÚ6¥öîafY��–’ÏÕH1„ì¼K%¢+E�!…(>qð>¥q”µehMÁ„”
}ÈP˜”!ò:ÖCxεùŽôuò!ßx´íXÏŸC>}üÙòṟáÄõö,•IÞç‚“� 
Ä¥×êäEÄë9{ã±0æ;KZq_®�¾ËºÝYÝæ÷¿t3V�
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/cf/c4f0999a8367568e049af4f72e452d40828a15 b/tests/resources/cherrypick/.gitted/objects/cf/c4f0999a8367568e049af4f72e452d40828a15
new file mode 100644
index 000000000..d7deb0bff
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/cf/c4f0999a8367568e049af4f72e452d40828a15 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/d0/f21e17beb5b9d953b1d8349049818a4f2edd1e b/tests/resources/cherrypick/.gitted/objects/d0/f21e17beb5b9d953b1d8349049818a4f2edd1e
new file mode 100644
index 000000000..65c846fa4
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/d0/f21e17beb5b9d953b1d8349049818a4f2edd1e
@@ -0,0 +1 @@
+x
¥ŽAjÃ0E»Ö)f_¶¤‘,¡]z‹‘<²]"«•ÇÐÞ¾‚!Ëÿø<^ª¥lÚá‹4fÀì=iM0HÉir: š<kiFGž§hI}Sã] õ™ã4FÇ	��qfÊšlÿÄà’Á�¯è”µ6ø¤ôsò
ÜÊv¬çß
ׯ[Þi	]R-7è	ÎÄ	áuÐà:í©ÂOIÔû)µp[˜â�!­´/=§î�·;ë‹üŠú&éWY
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/d3/d77487660ee3c0194ee01dc5eaf478782b1c7e b/tests/resources/cherrypick/.gitted/objects/d3/d77487660ee3c0194ee01dc5eaf478782b1c7e
new file mode 100644
index 000000000..b42df7e50
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/d3/d77487660ee3c0194ee01dc5eaf478782b1c7e
@@ -0,0 +1 @@
+x
¥ÎKJ1€a×9Eí…!ïI@df%x‹ª¤ú!“Ž¦«AooƒGpû-~þÒ[[lO2˜AW﯋
6‘ŽÑÄRÙ‘Õ=yFW¥ƒúÄÁ›@Õ“5l®Ä(×™šœÏÚçdúÉr­†²ô
ïX¾Þá�G[÷åøÙáåãÏæÛ.cEÁKéíŒËÑ»²…gmµV§ž«ÂÿŠ¨û!½ñ˜éÁPÜæs§o0­vùõ*Wd
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/e2/33b9ed408a95e9d4b65fec7fc34943a556deb2 b/tests/resources/cherrypick/.gitted/objects/e2/33b9ed408a95e9d4b65fec7fc34943a556deb2
new file mode 100644
index 000000000..b344c9cc8
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/e2/33b9ed408a95e9d4b65fec7fc34943a556deb2 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/e5/183bfd18e3a0a691fadde2f0d5610b73282d31 b/tests/resources/cherrypick/.gitted/objects/e5/183bfd18e3a0a691fadde2f0d5610b73282d31
new file mode 100644
index 000000000..fdc05714f
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/e5/183bfd18e3a0a691fadde2f0d5610b73282d31 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/e6/ae8889c40c77d7be02758235b5b3f7a4f2a129 b/tests/resources/cherrypick/.gitted/objects/e6/ae8889c40c77d7be02758235b5b3f7a4f2a129
new file mode 100644
index 000000000..3345907db
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/e6/ae8889c40c77d7be02758235b5b3f7a4f2a129 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/e7/811a2bc55635f182750f0420da5ad232c1af91 b/tests/resources/cherrypick/.gitted/objects/e7/811a2bc55635f182750f0420da5ad232c1af91
new file mode 100644
index 000000000..238873025
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/e7/811a2bc55635f182750f0420da5ad232c1af91 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/e9/b63f3655b2ad80c0ff587389b5a9589a3a7110 b/tests/resources/cherrypick/.gitted/objects/e9/b63f3655b2ad80c0ff587389b5a9589a3a7110
new file mode 100644
index 000000000..ab0a27f37
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/objects/e9/b63f3655b2ad80c0ff587389b5a9589a3a7110
@@ -0,0 +1,2 @@
+x
¥ÎMjÃ0@á®uŠÙŠ<Ë!�E¡·É£ØÅ?‰$/rûz„n¿Åã¥}]çHÃG+ªzåè¼"*k
+¡×AºìÆHìc”èÓhÍ]Šn
RN”-3Kp~è}PK,™ò€J=Ždéz#G›ö?’‡VøÖ²Îu:žN¿v»ÔVfiò•öõ�cOÎ;‹ðiÑZóÖ÷jÓEÌu’í¦ Ëy^´š-˜P@
\ No newline at end of file
diff --git a/tests/resources/cherrypick/.gitted/objects/eb/da71fe44dcb60c53b8fbd53208a1204d32e959 b/tests/resources/cherrypick/.gitted/objects/eb/da71fe44dcb60c53b8fbd53208a1204d32e959
new file mode 100644
index 000000000..19d0c5288
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/eb/da71fe44dcb60c53b8fbd53208a1204d32e959 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/f0/5ed049854c1596a7cc0e957fab34961077f3ae b/tests/resources/cherrypick/.gitted/objects/f0/5ed049854c1596a7cc0e957fab34961077f3ae
new file mode 100644
index 000000000..ab454399e
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/f0/5ed049854c1596a7cc0e957fab34961077f3ae differ
diff --git a/tests/resources/cherrypick/.gitted/objects/f0/a4e1c66bb548cd2b22eebefda703872e969775 b/tests/resources/cherrypick/.gitted/objects/f0/a4e1c66bb548cd2b22eebefda703872e969775
new file mode 100644
index 000000000..558dd0a44
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/f0/a4e1c66bb548cd2b22eebefda703872e969775 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/f2/ec8c8cf1a9fb7aa047a25a4308bfe860237ad4 b/tests/resources/cherrypick/.gitted/objects/f2/ec8c8cf1a9fb7aa047a25a4308bfe860237ad4
new file mode 100644
index 000000000..a0117515c
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/f2/ec8c8cf1a9fb7aa047a25a4308bfe860237ad4 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/f5/684c96bf40c709877b56404cd8a5dd2d2a7978 b/tests/resources/cherrypick/.gitted/objects/f5/684c96bf40c709877b56404cd8a5dd2d2a7978
new file mode 100644
index 000000000..83bb5a0cc
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/f5/684c96bf40c709877b56404cd8a5dd2d2a7978 differ
diff --git a/tests/resources/cherrypick/.gitted/objects/f9/0f9dcbdac2cce5cc166346160e19cb693ef4e8 b/tests/resources/cherrypick/.gitted/objects/f9/0f9dcbdac2cce5cc166346160e19cb693ef4e8
new file mode 100644
index 000000000..71be9f834
Binary files /dev/null and b/tests/resources/cherrypick/.gitted/objects/f9/0f9dcbdac2cce5cc166346160e19cb693ef4e8 differ
diff --git a/tests/resources/cherrypick/.gitted/refs/heads/automerge-branch b/tests/resources/cherrypick/.gitted/refs/heads/automerge-branch
new file mode 100644
index 000000000..9330ef3d1
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/refs/heads/automerge-branch
@@ -0,0 +1 @@
+d3d77487660ee3c0194ee01dc5eaf478782b1c7e
diff --git a/tests/resources/cherrypick/.gitted/refs/heads/master b/tests/resources/cherrypick/.gitted/refs/heads/master
new file mode 100644
index 000000000..aa8913beb
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/refs/heads/master
@@ -0,0 +1 @@
+2a26c7e88b285613b302ba76712bc998863f3cbc
diff --git a/tests/resources/cherrypick/.gitted/refs/heads/merge-branch b/tests/resources/cherrypick/.gitted/refs/heads/merge-branch
new file mode 100644
index 000000000..ea5b277ec
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/refs/heads/merge-branch
@@ -0,0 +1 @@
+abe4603bc7cd5b8167a267e0e2418fd2348f8cff
diff --git a/tests/resources/cherrypick/.gitted/refs/heads/merge-conflicts b/tests/resources/cherrypick/.gitted/refs/heads/merge-conflicts
new file mode 100644
index 000000000..f63f17efb
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/refs/heads/merge-conflicts
@@ -0,0 +1 @@
+bafbf6912c09505ac60575cd43d3f2aba3bd84d8
diff --git a/tests/resources/cherrypick/.gitted/refs/heads/merge-mainline b/tests/resources/cherrypick/.gitted/refs/heads/merge-mainline
new file mode 100644
index 000000000..0ec5e458c
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/refs/heads/merge-mainline
@@ -0,0 +1 @@
+cfc4f0999a8367568e049af4f72e452d40828a15
diff --git a/tests/resources/cherrypick/.gitted/refs/heads/orphan b/tests/resources/cherrypick/.gitted/refs/heads/orphan
new file mode 100644
index 000000000..f4d6a7467
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/refs/heads/orphan
@@ -0,0 +1 @@
+74f06b5bfec6d33d7264f73606b57a7c0b963819
diff --git a/tests/resources/cherrypick/.gitted/refs/heads/renames b/tests/resources/cherrypick/.gitted/refs/heads/renames
new file mode 100644
index 000000000..df5587173
--- /dev/null
+++ b/tests/resources/cherrypick/.gitted/refs/heads/renames
@@ -0,0 +1 @@
+44cd2ed2052c9c68f9a439d208e9614dc2a55c70
diff --git a/tests/resources/cherrypick/file1.txt b/tests/resources/cherrypick/file1.txt
new file mode 100644
index 000000000..38c05a857
--- /dev/null
+++ b/tests/resources/cherrypick/file1.txt
@@ -0,0 +1,15 @@
+!File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
+File 1
diff --git a/tests/resources/cherrypick/file2.txt b/tests/resources/cherrypick/file2.txt
new file mode 100644
index 000000000..a661b5dec
--- /dev/null
+++ b/tests/resources/cherrypick/file2.txt
@@ -0,0 +1,15 @@
+!File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
+File 2
diff --git a/tests/resources/cherrypick/file3.txt b/tests/resources/cherrypick/file3.txt
new file mode 100644
index 000000000..85a4a1d79
--- /dev/null
+++ b/tests/resources/cherrypick/file3.txt
@@ -0,0 +1,15 @@
+!File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
+File 3
-- 
cgit v1.2.3


From 6fefb7af84170fb67a7e6c8493fc00421787bb87 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sun, 13 Apr 2014 19:53:35 +0200
Subject: Capture conflict information in MERGE_MSG for revert and merge

---
 src/merge.c                  |  1 +
 src/revert.c                 |  1 +
 tests/merge/workdir/simple.c | 10 +++++++++-
 tests/revert/workdir.c       | 14 +++++++++++++-
 4 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/merge.c b/src/merge.c
index 371fad776..10c19b5c5 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2662,6 +2662,7 @@ int git_merge(
 	if ((error = git_merge_trees(&index_new, repo, ancestor_tree, our_tree, their_trees[0], merge_opts)) < 0 ||
 		(error = git_merge__indexes(repo, index_new)) < 0 ||
 		(error = git_repository_index(&index_repo, repo)) < 0 ||
+		(error = git_merge__append_conflicts_to_merge_msg(repo, index_repo)) < 0 ||
 		(error = git_checkout_index(repo, index_repo, &checkout_opts)) < 0)
 		goto on_error;
 
diff --git a/src/revert.c b/src/revert.c
index 4039ec34c..29e124f6c 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -201,6 +201,7 @@ int git_revert(
 		(error = git_revert_commit(&index_new, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 ||
 		(error = git_merge__indexes(repo, index_new)) < 0 ||
 		(error = git_repository_index(&index_repo, repo)) < 0 ||
+		(error = git_merge__append_conflicts_to_merge_msg(repo, index_repo)) < 0 ||
 		(error = git_checkout_index(repo, index_repo, &opts.checkout_opts)) < 0)
 		goto on_error;
 
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index 032e97f8d..cf5b16e7a 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -214,7 +214,7 @@ void test_merge_workdir_simple__automerge_crlf(void)
 
 void test_merge_workdir_simple__mergefile(void)
 {
-	git_buf conflicting_buf = GIT_BUF_INIT;
+	git_buf conflicting_buf = GIT_BUF_INIT, mergemsg_buf = GIT_BUF_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		ADDED_IN_MASTER_INDEX_ENTRY,
@@ -240,7 +240,15 @@ void test_merge_workdir_simple__mergefile(void)
 	cl_git_pass(git_futils_readbuffer(&conflicting_buf,
 		TEST_REPO_PATH "/conflicting.txt"));
 	cl_assert(strcmp(conflicting_buf.ptr, CONFLICTING_MERGE_FILE) == 0);
+	cl_git_pass(git_futils_readbuffer(&mergemsg_buf,
+		TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_assert(strcmp(git_buf_cstr(&mergemsg_buf),
+		"Merge commit '7cb63eed597130ba4abb87b3e544b85021905520'\n" \
+		"\n" \
+		"Conflicts:\n" \
+		"\tconflicting.txt\n") == 0);
 	git_buf_free(&conflicting_buf);
+	git_buf_free(&mergemsg_buf);
 
 	cl_assert(merge_test_index(repo_index, merge_index_entries, 8));
 	cl_assert(merge_test_reuc(repo_index, merge_reuc_entries, 3));
diff --git a/tests/revert/workdir.c b/tests/revert/workdir.c
index 694f24710..e3d7e968a 100644
--- a/tests/revert/workdir.c
+++ b/tests/revert/workdir.c
@@ -66,7 +66,7 @@ void test_revert_workdir__conflicts(void)
 	git_reference *head_ref;
 	git_commit *head, *commit;
 	git_oid revert_oid;
-	git_buf conflicting_buf = GIT_BUF_INIT;
+	git_buf conflicting_buf = GIT_BUF_INIT, mergemsg_buf = GIT_BUF_INIT;
 
 	struct merge_index_entry merge_index_entries[] = {
 		{ 0100644, "7731926a337c4eaba1e2187d90ebfa0a93659382", 1, "file1.txt" },
@@ -112,9 +112,21 @@ void test_revert_workdir__conflicts(void)
 		"File one\n" \
 		">>>>>>> parent of 72333f4... automergeable changes\n") == 0);
 
+	cl_assert(git_path_exists(TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_git_pass(git_futils_readbuffer(&mergemsg_buf,
+		TEST_REPO_PATH "/.git/MERGE_MSG"));
+	cl_assert(strcmp(mergemsg_buf.ptr,
+		"Revert \"automergeable changes\"\n" \
+		"\n" \
+		"This reverts commit 72333f47d4e83616630ff3b0ffe4c0faebcc3c45.\n"
+		"\n" \
+		"Conflicts:\n" \
+		"\tfile1.txt\n") == 0);
+
 	git_commit_free(commit);
 	git_commit_free(head);
 	git_reference_free(head_ref);
+	git_buf_free(&mergemsg_buf);
 	git_buf_free(&conflicting_buf);
 }
 
-- 
cgit v1.2.3


From a9528b8fdd627e11b9dee099a10fa7697380b3e7 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 14 Apr 2014 15:59:48 -0700
Subject: Fix core.excludesfile named .gitignore

Ignore rules with slashes in them are matched using FNM_PATHNAME
and use the path to the .gitignore file from the root of the
repository along with the path fragment (including slashes) in
the ignore file itself.  Unfortunately, the relative path to the
.gitignore file was being applied to the global core.excludesfile
if that was also named ".gitignore".

This fixes that with more precise matching and includes test for
ignore rules with leading slashes (which were the primary example
of this being broken in the real world).

This also backports an improvement to the file context logic from
the threadsafe-iterators branch where we don't rely on mutating
the key of the attribute file name to generate the context path.
---
 src/attr_file.c       | 18 ++++++++---------
 src/ignore.c          | 12 ++++-------
 tests/attr/ignore.c   | 21 +++++++++----------
 tests/clar_libgit2.c  | 21 +++++++++++++++++++
 tests/clar_libgit2.h  |  3 +++
 tests/status/ignore.c | 56 +++++++++++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 101 insertions(+), 30 deletions(-)

diff --git a/src/attr_file.c b/src/attr_file.c
index 4eb732436..ea92336f7 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -61,8 +61,7 @@ int git_attr_file__parse_buffer(
 	git_repository *repo, void *parsedata, const char *buffer, git_attr_file *attrs)
 {
 	int error = 0;
-	const char *scan = NULL;
-	char *context = NULL;
+	const char *scan = NULL, *context = NULL;
 	git_attr_rule *rule = NULL;
 
 	GIT_UNUSED(parsedata);
@@ -72,10 +71,10 @@ int git_attr_file__parse_buffer(
 	scan = buffer;
 
 	/* if subdir file path, convert context for file paths */
-	if (attrs->key && git__suffixcmp(attrs->key, "/" GIT_ATTR_FILE) == 0) {
+	if (attrs->key &&
+		git_path_root(attrs->key + 2) < 0 &&
+		git__suffixcmp(attrs->key, "/" GIT_ATTR_FILE) == 0)
 		context = attrs->key + 2;
-		context[strlen(context) - strlen(GIT_ATTR_FILE)] = '\0';
-	}
 
 	while (!error && *scan) {
 		/* allocate rule if needed */
@@ -115,10 +114,6 @@ int git_attr_file__parse_buffer(
 
 	git_attr_rule__free(rule);
 
-	/* restore file path used for context */
-	if (context)
-		context[strlen(context)] = '.'; /* first char of GIT_ATTR_FILE */
-
 	return error;
 }
 
@@ -414,7 +409,10 @@ int git_attr_fnmatch__parse(
 	if ((spec->flags & GIT_ATTR_FNMATCH_FULLPATH) != 0 &&
 		source != NULL && git_path_root(pattern) < 0)
 	{
-		size_t sourcelen = strlen(source);
+        /* use context path minus the trailing filename */
+        char *slash = strrchr(source, '/');
+        size_t sourcelen = slash ? slash - source + 1 : 0;
+
 		/* given an unrooted fullpath match from a file inside a repo,
 		 * prefix the pattern with the relative directory of the source file
 		 */
diff --git a/src/ignore.c b/src/ignore.c
index aef3e39b4..5cf4fca5c 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -14,8 +14,7 @@ static int parse_ignore_file(
 {
 	int error = 0;
 	git_attr_fnmatch *match = NULL;
-	const char *scan = NULL;
-	char *context = NULL;
+	const char *scan = NULL, *context = NULL;
 	int ignore_case = false;
 
 	/* Prefer to have the caller pass in a git_ignores as the parsedata
@@ -25,10 +24,10 @@ static int parse_ignore_file(
 	else if (git_repository__cvar(&ignore_case, repo, GIT_CVAR_IGNORECASE) < 0)
 		return error;
 
-	if (ignores->key && git__suffixcmp(ignores->key, "/" GIT_IGNORE_FILE) == 0) {
+	if (ignores->key &&
+		git_path_root(ignores->key + 2) < 0 &&
+		git__suffixcmp(ignores->key, "/" GIT_IGNORE_FILE) == 0)
 		context = ignores->key + 2;
-		context[strlen(context) - strlen(GIT_IGNORE_FILE)] = '\0';
-	}
 
 	scan = buffer;
 
@@ -64,9 +63,6 @@ static int parse_ignore_file(
 	}
 
 	git__free(match);
-	/* restore file path used for context */
-	if (context)
-		context[strlen(context)] = '.'; /* first char of GIT_IGNORE_FILE */
 
 	return error;
 }
diff --git a/tests/attr/ignore.c b/tests/attr/ignore.c
index 4ed92387c..a83c5bd74 100644
--- a/tests/attr/ignore.c
+++ b/tests/attr/ignore.c
@@ -130,22 +130,18 @@ void test_attr_ignore__skip_gitignore_directory(void)
 
 void test_attr_ignore__expand_tilde_to_homedir(void)
 {
-	git_buf path = GIT_BUF_INIT;
+	git_buf cleanup = GIT_BUF_INIT;
 	git_config *cfg;
 
 	assert_is_ignored(false, "example.global_with_tilde");
 
-	/* construct fake home with fake global excludes */
-
-	cl_must_pass(p_mkdir("home", 0777));
-	cl_git_pass(git_path_prettify(&path, "home", NULL));
-	cl_git_pass(git_libgit2_opts(
-		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr));
+	cl_fake_home(&cleanup);
 
-	cl_git_mkfile("home/globalexcludes", "# found me\n*.global_with_tilde\n");
+	/* construct fake home with fake global excludes */
+	cl_git_mkfile("home/globalexclude", "# found me\n*.global_with_tilde\n");
 
 	cl_git_pass(git_repository_config(&cfg, g_repo));
-	cl_git_pass(git_config_set_string(cfg, "core.excludesfile", "~/globalexcludes"));
+	cl_git_pass(git_config_set_string(cfg, "core.excludesfile", "~/globalexclude"));
 	git_config_free(cfg);
 
 	git_attr_cache_flush(g_repo); /* must reset to pick up change */
@@ -154,8 +150,9 @@ void test_attr_ignore__expand_tilde_to_homedir(void)
 
 	cl_git_pass(git_futils_rmdir_r("home", NULL, GIT_RMDIR_REMOVE_FILES));
 
-	cl_git_pass(git_libgit2_opts(
-		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, NULL));
+	cl_fake_home_cleanup(&cleanup);
 
-	git_buf_free(&path);
+	git_attr_cache_flush(g_repo); /* must reset to pick up change */
+
+	assert_is_ignored(false, "example.global_with_tilde");
 }
diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c
index 9b062ef78..90e53c5e6 100644
--- a/tests/clar_libgit2.c
+++ b/tests/clar_libgit2.c
@@ -490,3 +490,24 @@ void clar__assert_equal_file(
 	clar__assert_equal(file, line, "mismatched file length", 1, "%"PRIuZ,
 		(size_t)expected_bytes, (size_t)total_bytes);
 }
+
+void cl_fake_home(git_buf *restore)
+{
+	git_buf path = GIT_BUF_INIT;
+
+	cl_git_pass(git_libgit2_opts(
+		GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore));
+
+	cl_must_pass(p_mkdir("home", 0777));
+	cl_git_pass(git_path_prettify(&path, "home", NULL));
+	cl_git_pass(git_libgit2_opts(
+		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr));
+	git_buf_free(&path);
+}
+
+void cl_fake_home_cleanup(git_buf *restore)
+{
+	cl_git_pass(git_libgit2_opts(
+		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore->ptr));
+	git_buf_free(restore);
+}
diff --git a/tests/clar_libgit2.h b/tests/clar_libgit2.h
index 3de80bfa0..c2489db38 100644
--- a/tests/clar_libgit2.h
+++ b/tests/clar_libgit2.h
@@ -120,4 +120,7 @@ int cl_repo_get_bool(git_repository *repo, const char *cfg);
 
 void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value);
 
+void cl_fake_home(git_buf *restore);
+void cl_fake_home_cleanup(git_buf *restore);
+
 #endif
diff --git a/tests/status/ignore.c b/tests/status/ignore.c
index 1fefcba5f..d6c26a847 100644
--- a/tests/status/ignore.c
+++ b/tests/status/ignore.c
@@ -364,6 +364,62 @@ void test_status_ignore__subdirectories_not_at_root(void)
 	cl_assert_equal_i(0, counts.wrong_sorted_path);
 }
 
+void test_status_ignore__leading_slash_ignores(void)
+{
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	status_entry_counts counts;
+	git_buf home = GIT_BUF_INIT;
+	static const char *paths_2[] = {
+		"dir/.gitignore",
+		"dir/a/ignore_me",
+		"dir/b/ignore_me",
+		"dir/ignore_me",
+		"ignore_also/file",
+		"ignore_me",
+		"test/.gitignore",
+		"test/ignore_me/and_me/file",
+		"test/ignore_me/file",
+		"test/ignore_me/file2",
+	};
+	static const unsigned int statuses_2[] = {
+		GIT_STATUS_WT_NEW,  GIT_STATUS_WT_NEW,  GIT_STATUS_WT_NEW,
+		GIT_STATUS_IGNORED, GIT_STATUS_IGNORED, GIT_STATUS_IGNORED,
+		GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW,
+	};
+
+	make_test_data();
+
+	cl_fake_home(&home);
+	cl_git_mkfile("home/.gitignore", "/ignore_me\n");
+	{
+		git_config *cfg;
+		cl_git_pass(git_repository_config(&cfg, g_repo));
+		cl_git_pass(git_config_set_string(
+			cfg, "core.excludesfile", "~/.gitignore"));
+		git_config_free(cfg);
+	}
+
+	cl_git_rewritefile("empty_standard_repo/.git/info/exclude", "/ignore_also\n");
+	cl_git_rewritefile("empty_standard_repo/dir/.gitignore", "/ignore_me\n");
+	cl_git_rewritefile("empty_standard_repo/test/.gitignore", "/and_me\n");
+
+	memset(&counts, 0x0, sizeof(status_entry_counts));
+	counts.expected_entry_count = 10;
+	counts.expected_paths = paths_2;
+	counts.expected_statuses = statuses_2;
+
+	opts.flags = GIT_STATUS_OPT_DEFAULTS | GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
+
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__normal, &counts));
+
+	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
+	cl_assert_equal_i(0, counts.wrong_status_flags_count);
+	cl_assert_equal_i(0, counts.wrong_sorted_path);
+
+	cl_fake_home_cleanup(&home);
+}
+
 void test_status_ignore__adding_internal_ignores(void)
 {
 	int ignored;
-- 
cgit v1.2.3


From cab39378dc4dba7cc501255f066808c713dd11ef Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 11 Apr 2014 19:14:18 +0200
Subject: Added git_diff_stats test files

---
 tests/resources/diff_format_email/.gitted/HEAD         |   1 +
 tests/resources/diff_format_email/.gitted/config       |   7 +++++++
 tests/resources/diff_format_email/.gitted/index        | Bin 0 -> 256 bytes
 tests/resources/diff_format_email/.gitted/info/exclude |   6 ++++++
 .../objects/0a/37045ca6d8503e9bcf06a12abbbc8e92664cce  | Bin 0 -> 29 bytes
 .../objects/10/808fe9c9be5a190c0ba68d1a002233fb363508  | Bin 0 -> 176 bytes
 .../objects/13/ecf3d572dbc5e5b32c8ba067d1d1e0939572e8  | Bin 0 -> 34 bytes
 .../objects/17/cfad36e93db7706b16bef5ef842ba1e5ca06ab  | Bin 0 -> 155 bytes
 .../objects/1a/9932083f96b0db42552103d40076f62fa8235e  | Bin 0 -> 54 bytes
 .../objects/1a/e3be57f869687d983066a0f5d2aaea1b82ddc5  | Bin 0 -> 162 bytes
 .../objects/1b/525b0a6c5218b069b601ce91fce8eaf0a54e20  | Bin 0 -> 31 bytes
 .../objects/1e/82c3b234e37da82e5b23e0e2a70bca68ee12c6  | Bin 0 -> 28 bytes
 .../objects/1e/875da9b1e67f853b2eec3e202c21c867097234  | Bin 0 -> 121 bytes
 .../objects/20/609dbbc32bbfc827528eec3fcea2d024e6dd8a  | Bin 0 -> 121 bytes
 .../objects/23/f92946d3f38bd090f700d3e8e7b728ffc58264  | Bin 0 -> 155 bytes
 .../objects/24/97c5249408494e66e25070a8c74e49eaeeb6c3  | Bin 0 -> 162 bytes
 .../objects/24/9a4263be23b4d1c02484cb840b6eca4c6cf74d  | Bin 0 -> 171 bytes
 .../objects/25/2a3e19fd2c6fb7b20c111142c5bd5fb9ea6b8e  | Bin 0 -> 121 bytes
 .../objects/27/93544db9060bab4f9169e5b89c82f9fa7c7fa6  | Bin 0 -> 120 bytes
 .../objects/29/1f1ff3cbb9a6f153678d9657679e3d4bf257df  | Bin 0 -> 29 bytes
 .../objects/2f/f7b811eee62a73959350b1f7349f6f4d0c882d  | Bin 0 -> 54 bytes
 .../objects/39/91dce9e71a0641ca49a6a4eea6c9e7ff402ed4  | Bin 0 -> 166 bytes
 .../objects/45/eef2a9317e179984649de247269e38cd5d99cf  |   2 ++
 .../objects/4a/076277b884c519a932be67e346db2ac80a98fa  | Bin 0 -> 40 bytes
 .../objects/4c/3bd7182ad66ea7aa20ba47ae82812b710d169c  | Bin 0 -> 179 bytes
 .../objects/4c/a10087e696d2ba78d07b146a118e9a7096ed4f  | Bin 0 -> 173 bytes
 .../objects/4d/de2b17d1c982cd988f21d24350a214401e4a1e  | Bin 0 -> 121 bytes
 .../objects/4f/31e0248ac800a1edc78b74f74e86f5eba90e87  | Bin 0 -> 54 bytes
 .../objects/50/17c9456d013b2c7712d29aab73b681c880f509  | Bin 0 -> 54 bytes
 .../objects/50/438cfa585c1d15cf3650ed1bf641da937cc261  | Bin 0 -> 123 bytes
 .../objects/52/c3cd1ff6234b95fecbaf9ef13624da17697b8d  | Bin 0 -> 41 bytes
 .../objects/55/0d730ba1b8c4937ea170b37c7ba91d792c0aaa  | Bin 0 -> 123 bytes
 .../objects/66/81f1844dc677e5ff07ffd993461f5c441e6af5  | Bin 0 -> 35 bytes
 .../objects/69/ddefb5c245e2f9ee62bd4cabd8ebe60a01e448  | Bin 0 -> 54 bytes
 .../objects/6b/6c2067c6d968f9bddb9b900ee1ab7e5b067430  |   2 ++
 .../objects/6b/ef49b206b29d9c46456e075722cd1a48b41e4c  | Bin 0 -> 121 bytes
 .../objects/6c/15659c036377aebf3b4569959ca1f5bedb551f  | Bin 0 -> 167 bytes
 .../objects/6e/05acc5a5dab507d91a0a0cc0fb05a3dd98892d  |   2 ++
 .../objects/74/6d514eae0c330261d37940cab33aa97fefbd93  |   1 +
 .../objects/74/a4d5394ebcfa7e9f445680897dfbc96586bc86  | Bin 0 -> 38 bytes
 .../objects/77/d0a3ed37236a7941d564f08d68d3b36462d231  |   2 ++
 .../objects/7a/de76dd34bba4733cf9878079f9fd4a456a9189  |   3 +++
 .../objects/7a/ff11da95ca2be0bfb74b06e7cc1c480559dbe7  | Bin 0 -> 26 bytes
 .../objects/7f/854619451620f7fbcec7ea171675e615ce92b6  | Bin 0 -> 179 bytes
 .../objects/87/3806f6f27e631eb0b23e4b56bea2bfac14a373  | Bin 0 -> 181 bytes
 .../objects/89/47a46e2097638ca6040ad4877246f4186ec3bd  |   2 ++
 .../objects/89/7d3af16ca9e420cd071b1c4541bd2b91d04c8c  |   1 +
 .../objects/8d/7523f6fcb2404257889abe0d96f093d9f524f9  |   1 +
 .../objects/8d/fa038554d5b682a51bda8ee3038cee6c63be76  | Bin 0 -> 120 bytes
 .../objects/92/64b96c6d104d0e07ae33d3007b6a48246c6f92  | Bin 0 -> 181 bytes
 .../objects/94/350226b3aa14efac831c803a51f7a09f3fc31a  | Bin 0 -> 24 bytes
 .../objects/94/75e21dcbc515af8f641576400e4b450e5f4c03  | Bin 0 -> 62 bytes
 .../objects/94/aaae8954e8bb613de636071da663a621695911  | Bin 0 -> 29 bytes
 .../objects/9a/2d780ac2ea0aeabdb9d2a876e6bbfff17b2c44  | Bin 0 -> 28 bytes
 .../objects/9a/c0329b8b7a4046210d8b8b02ac02055667de63  | Bin 0 -> 29 bytes
 .../objects/9a/c35ff15cd8864aeafd889e4826a3150f0b06c4  | Bin 0 -> 20 bytes
 .../objects/9b/997daca2a0beb5cc44b32c64f100a9a26d4d4b  | Bin 0 -> 22 bytes
 .../objects/a3/ac918e3a6604294b239cb956363e83d71abb3b  |   1 +
 .../objects/a5/ac978d4f2a1784f847f41223a34c3e78934238  | Bin 0 -> 54 bytes
 .../objects/a7/29eab45c84563135e8631d4010230bc0479f1f  | Bin 0 -> 40 bytes
 .../objects/a9/7157a0d0571698728b6f2f7675b456c98c5961  | Bin 0 -> 62 bytes
 .../objects/af/8f41d0cb7a3079a8f8e231ea2ab8b97837ce13  | Bin 0 -> 50 bytes
 .../objects/b0/5cecf1949d192b6df852b3f71853ef820ee235  | Bin 0 -> 37 bytes
 .../objects/b4/f457c219dbb3517be908d4e70f0ada2fd8b8f9  | Bin 0 -> 54 bytes
 .../objects/bd/474b2519cc15eab801ff851cc7d50f0dee49a1  | Bin 0 -> 18 bytes
 .../objects/bd/f7ba6bc5c4e57ca6595928dcbe6753c8a663ff  | Bin 0 -> 35 bytes
 .../objects/cb/a89408dc016f4caddb6dc886fcb58f587a78df  |   3 +++
 .../objects/cd/471f0d8770371e1bc78bcbb38db4c7e4106bd2  | Bin 0 -> 180 bytes
 .../objects/cd/ed722d05305c6b181f188c118d2d9810f39bb8  | Bin 0 -> 163 bytes
 .../objects/ce/2792fcae8d704a56901754a0583a7418a21d8a  | Bin 0 -> 121 bytes
 .../objects/d1/4aa252e52a709d03a3d3d0d965e177eb0a674e  |   1 +
 .../objects/d7/bb447df12c6a8aba8727005482fb211f11297a  | Bin 0 -> 156 bytes
 .../objects/db/e8727e4806ae88ccc3f0755cae8f8cb7efa2cc  | Bin 0 -> 175 bytes
 .../objects/e1/2af77c510e8ce4c261a3758736109c2c2dd1f0  | Bin 0 -> 51 bytes
 .../objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391  | Bin 0 -> 15 bytes
 .../objects/e9/091231467304a5ef112de02361d795ef051ee1  | Bin 0 -> 24 bytes
 .../objects/ee/251372f131d82e575f16fe51c778406d88f8c2  |   2 ++
 .../objects/f3/d35bd592fefd8280fc0c302fa9f27dbdd721a3  |   1 +
 .../objects/f4/07be01334e07bfb8f57cd2078f0ee3eb61e085  |   1 +
 .../objects/f9/e215d309644e24fa50d6bd6e6eedba166e56bc  |   2 ++
 .../objects/fc/a0c10eb9f1af6494a448d5733d283f5232a514  | Bin 0 -> 176 bytes
 .../objects/ff/8d35b41494f7f0dc92f95d67f54fff274d3fcb  | Bin 0 -> 29 bytes
 .../diff_format_email/.gitted/refs/heads/binary        |   1 +
 .../diff_format_email/.gitted/refs/heads/master        |   1 +
 .../diff_format_email/.gitted/refs/heads/multihunk     |   1 +
 .../diff_format_email/.gitted/refs/heads/rename        |   1 +
 tests/resources/diff_format_email/file1.txt.renamed    |  17 +++++++++++++++++
 tests/resources/diff_format_email/file2.txt            |   5 +++++
 tests/resources/diff_format_email/file3.txt            |   5 +++++
 89 files changed, 72 insertions(+)
 create mode 100644 tests/resources/diff_format_email/.gitted/HEAD
 create mode 100644 tests/resources/diff_format_email/.gitted/config
 create mode 100644 tests/resources/diff_format_email/.gitted/index
 create mode 100644 tests/resources/diff_format_email/.gitted/info/exclude
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/0a/37045ca6d8503e9bcf06a12abbbc8e92664cce
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/10/808fe9c9be5a190c0ba68d1a002233fb363508
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/13/ecf3d572dbc5e5b32c8ba067d1d1e0939572e8
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/17/cfad36e93db7706b16bef5ef842ba1e5ca06ab
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/1a/9932083f96b0db42552103d40076f62fa8235e
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/1a/e3be57f869687d983066a0f5d2aaea1b82ddc5
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/1b/525b0a6c5218b069b601ce91fce8eaf0a54e20
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/1e/82c3b234e37da82e5b23e0e2a70bca68ee12c6
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/1e/875da9b1e67f853b2eec3e202c21c867097234
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/20/609dbbc32bbfc827528eec3fcea2d024e6dd8a
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/23/f92946d3f38bd090f700d3e8e7b728ffc58264
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/24/97c5249408494e66e25070a8c74e49eaeeb6c3
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/24/9a4263be23b4d1c02484cb840b6eca4c6cf74d
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/25/2a3e19fd2c6fb7b20c111142c5bd5fb9ea6b8e
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/27/93544db9060bab4f9169e5b89c82f9fa7c7fa6
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/29/1f1ff3cbb9a6f153678d9657679e3d4bf257df
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/2f/f7b811eee62a73959350b1f7349f6f4d0c882d
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/39/91dce9e71a0641ca49a6a4eea6c9e7ff402ed4
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/45/eef2a9317e179984649de247269e38cd5d99cf
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/4a/076277b884c519a932be67e346db2ac80a98fa
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/4c/3bd7182ad66ea7aa20ba47ae82812b710d169c
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/4c/a10087e696d2ba78d07b146a118e9a7096ed4f
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/4d/de2b17d1c982cd988f21d24350a214401e4a1e
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/4f/31e0248ac800a1edc78b74f74e86f5eba90e87
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/50/17c9456d013b2c7712d29aab73b681c880f509
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/50/438cfa585c1d15cf3650ed1bf641da937cc261
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/52/c3cd1ff6234b95fecbaf9ef13624da17697b8d
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/55/0d730ba1b8c4937ea170b37c7ba91d792c0aaa
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/66/81f1844dc677e5ff07ffd993461f5c441e6af5
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/69/ddefb5c245e2f9ee62bd4cabd8ebe60a01e448
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/6b/6c2067c6d968f9bddb9b900ee1ab7e5b067430
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/6b/ef49b206b29d9c46456e075722cd1a48b41e4c
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/6c/15659c036377aebf3b4569959ca1f5bedb551f
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/6e/05acc5a5dab507d91a0a0cc0fb05a3dd98892d
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/74/6d514eae0c330261d37940cab33aa97fefbd93
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/74/a4d5394ebcfa7e9f445680897dfbc96586bc86
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/77/d0a3ed37236a7941d564f08d68d3b36462d231
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/7a/de76dd34bba4733cf9878079f9fd4a456a9189
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/7a/ff11da95ca2be0bfb74b06e7cc1c480559dbe7
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/7f/854619451620f7fbcec7ea171675e615ce92b6
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/87/3806f6f27e631eb0b23e4b56bea2bfac14a373
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/89/47a46e2097638ca6040ad4877246f4186ec3bd
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/89/7d3af16ca9e420cd071b1c4541bd2b91d04c8c
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/8d/7523f6fcb2404257889abe0d96f093d9f524f9
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/8d/fa038554d5b682a51bda8ee3038cee6c63be76
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/92/64b96c6d104d0e07ae33d3007b6a48246c6f92
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/94/350226b3aa14efac831c803a51f7a09f3fc31a
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/94/75e21dcbc515af8f641576400e4b450e5f4c03
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/94/aaae8954e8bb613de636071da663a621695911
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/9a/2d780ac2ea0aeabdb9d2a876e6bbfff17b2c44
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/9a/c0329b8b7a4046210d8b8b02ac02055667de63
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/9a/c35ff15cd8864aeafd889e4826a3150f0b06c4
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/9b/997daca2a0beb5cc44b32c64f100a9a26d4d4b
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/a3/ac918e3a6604294b239cb956363e83d71abb3b
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/a5/ac978d4f2a1784f847f41223a34c3e78934238
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/a7/29eab45c84563135e8631d4010230bc0479f1f
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/a9/7157a0d0571698728b6f2f7675b456c98c5961
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/af/8f41d0cb7a3079a8f8e231ea2ab8b97837ce13
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/b0/5cecf1949d192b6df852b3f71853ef820ee235
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/b4/f457c219dbb3517be908d4e70f0ada2fd8b8f9
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/bd/474b2519cc15eab801ff851cc7d50f0dee49a1
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/bd/f7ba6bc5c4e57ca6595928dcbe6753c8a663ff
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/cb/a89408dc016f4caddb6dc886fcb58f587a78df
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/cd/471f0d8770371e1bc78bcbb38db4c7e4106bd2
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/cd/ed722d05305c6b181f188c118d2d9810f39bb8
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/ce/2792fcae8d704a56901754a0583a7418a21d8a
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/d1/4aa252e52a709d03a3d3d0d965e177eb0a674e
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/d7/bb447df12c6a8aba8727005482fb211f11297a
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/db/e8727e4806ae88ccc3f0755cae8f8cb7efa2cc
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/e1/2af77c510e8ce4c261a3758736109c2c2dd1f0
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/e9/091231467304a5ef112de02361d795ef051ee1
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/ee/251372f131d82e575f16fe51c778406d88f8c2
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/f3/d35bd592fefd8280fc0c302fa9f27dbdd721a3
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/f4/07be01334e07bfb8f57cd2078f0ee3eb61e085
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/f9/e215d309644e24fa50d6bd6e6eedba166e56bc
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/fc/a0c10eb9f1af6494a448d5733d283f5232a514
 create mode 100644 tests/resources/diff_format_email/.gitted/objects/ff/8d35b41494f7f0dc92f95d67f54fff274d3fcb
 create mode 100644 tests/resources/diff_format_email/.gitted/refs/heads/binary
 create mode 100644 tests/resources/diff_format_email/.gitted/refs/heads/master
 create mode 100644 tests/resources/diff_format_email/.gitted/refs/heads/multihunk
 create mode 100644 tests/resources/diff_format_email/.gitted/refs/heads/rename
 create mode 100755 tests/resources/diff_format_email/file1.txt.renamed
 create mode 100644 tests/resources/diff_format_email/file2.txt
 create mode 100644 tests/resources/diff_format_email/file3.txt

diff --git a/tests/resources/diff_format_email/.gitted/HEAD b/tests/resources/diff_format_email/.gitted/HEAD
new file mode 100644
index 000000000..cb089cd89
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/HEAD
@@ -0,0 +1 @@
+ref: refs/heads/master
diff --git a/tests/resources/diff_format_email/.gitted/config b/tests/resources/diff_format_email/.gitted/config
new file mode 100644
index 000000000..6c9406b7d
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/config
@@ -0,0 +1,7 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+	ignorecase = true
+	precomposeunicode = true
diff --git a/tests/resources/diff_format_email/.gitted/index b/tests/resources/diff_format_email/.gitted/index
new file mode 100644
index 000000000..f73027e56
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/index differ
diff --git a/tests/resources/diff_format_email/.gitted/info/exclude b/tests/resources/diff_format_email/.gitted/info/exclude
new file mode 100644
index 000000000..a5196d1be
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/info/exclude
@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
diff --git a/tests/resources/diff_format_email/.gitted/objects/0a/37045ca6d8503e9bcf06a12abbbc8e92664cce b/tests/resources/diff_format_email/.gitted/objects/0a/37045ca6d8503e9bcf06a12abbbc8e92664cce
new file mode 100644
index 000000000..1ece99cde
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/0a/37045ca6d8503e9bcf06a12abbbc8e92664cce differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/10/808fe9c9be5a190c0ba68d1a002233fb363508 b/tests/resources/diff_format_email/.gitted/objects/10/808fe9c9be5a190c0ba68d1a002233fb363508
new file mode 100644
index 000000000..90313feec
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/10/808fe9c9be5a190c0ba68d1a002233fb363508 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/13/ecf3d572dbc5e5b32c8ba067d1d1e0939572e8 b/tests/resources/diff_format_email/.gitted/objects/13/ecf3d572dbc5e5b32c8ba067d1d1e0939572e8
new file mode 100644
index 000000000..360dc3bc7
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/13/ecf3d572dbc5e5b32c8ba067d1d1e0939572e8 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/17/cfad36e93db7706b16bef5ef842ba1e5ca06ab b/tests/resources/diff_format_email/.gitted/objects/17/cfad36e93db7706b16bef5ef842ba1e5ca06ab
new file mode 100644
index 000000000..603aa496a
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/17/cfad36e93db7706b16bef5ef842ba1e5ca06ab differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/1a/9932083f96b0db42552103d40076f62fa8235e b/tests/resources/diff_format_email/.gitted/objects/1a/9932083f96b0db42552103d40076f62fa8235e
new file mode 100644
index 000000000..b6f04538e
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/1a/9932083f96b0db42552103d40076f62fa8235e differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/1a/e3be57f869687d983066a0f5d2aaea1b82ddc5 b/tests/resources/diff_format_email/.gitted/objects/1a/e3be57f869687d983066a0f5d2aaea1b82ddc5
new file mode 100644
index 000000000..be85c78ba
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/1a/e3be57f869687d983066a0f5d2aaea1b82ddc5 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/1b/525b0a6c5218b069b601ce91fce8eaf0a54e20 b/tests/resources/diff_format_email/.gitted/objects/1b/525b0a6c5218b069b601ce91fce8eaf0a54e20
new file mode 100644
index 000000000..e8145edfd
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/1b/525b0a6c5218b069b601ce91fce8eaf0a54e20 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/1e/82c3b234e37da82e5b23e0e2a70bca68ee12c6 b/tests/resources/diff_format_email/.gitted/objects/1e/82c3b234e37da82e5b23e0e2a70bca68ee12c6
new file mode 100644
index 000000000..3ae87cfa9
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/1e/82c3b234e37da82e5b23e0e2a70bca68ee12c6 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/1e/875da9b1e67f853b2eec3e202c21c867097234 b/tests/resources/diff_format_email/.gitted/objects/1e/875da9b1e67f853b2eec3e202c21c867097234
new file mode 100644
index 000000000..f80b3612c
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/1e/875da9b1e67f853b2eec3e202c21c867097234 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/20/609dbbc32bbfc827528eec3fcea2d024e6dd8a b/tests/resources/diff_format_email/.gitted/objects/20/609dbbc32bbfc827528eec3fcea2d024e6dd8a
new file mode 100644
index 000000000..190c3f272
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/20/609dbbc32bbfc827528eec3fcea2d024e6dd8a differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/23/f92946d3f38bd090f700d3e8e7b728ffc58264 b/tests/resources/diff_format_email/.gitted/objects/23/f92946d3f38bd090f700d3e8e7b728ffc58264
new file mode 100644
index 000000000..42f49ae8a
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/23/f92946d3f38bd090f700d3e8e7b728ffc58264 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/24/97c5249408494e66e25070a8c74e49eaeeb6c3 b/tests/resources/diff_format_email/.gitted/objects/24/97c5249408494e66e25070a8c74e49eaeeb6c3
new file mode 100644
index 000000000..e1ede9ae9
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/24/97c5249408494e66e25070a8c74e49eaeeb6c3 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/24/9a4263be23b4d1c02484cb840b6eca4c6cf74d b/tests/resources/diff_format_email/.gitted/objects/24/9a4263be23b4d1c02484cb840b6eca4c6cf74d
new file mode 100644
index 000000000..1b8d68951
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/24/9a4263be23b4d1c02484cb840b6eca4c6cf74d differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/25/2a3e19fd2c6fb7b20c111142c5bd5fb9ea6b8e b/tests/resources/diff_format_email/.gitted/objects/25/2a3e19fd2c6fb7b20c111142c5bd5fb9ea6b8e
new file mode 100644
index 000000000..10c34009d
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/25/2a3e19fd2c6fb7b20c111142c5bd5fb9ea6b8e differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/27/93544db9060bab4f9169e5b89c82f9fa7c7fa6 b/tests/resources/diff_format_email/.gitted/objects/27/93544db9060bab4f9169e5b89c82f9fa7c7fa6
new file mode 100644
index 000000000..689f5b9a1
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/27/93544db9060bab4f9169e5b89c82f9fa7c7fa6 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/29/1f1ff3cbb9a6f153678d9657679e3d4bf257df b/tests/resources/diff_format_email/.gitted/objects/29/1f1ff3cbb9a6f153678d9657679e3d4bf257df
new file mode 100644
index 000000000..6af5dda9d
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/29/1f1ff3cbb9a6f153678d9657679e3d4bf257df differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/2f/f7b811eee62a73959350b1f7349f6f4d0c882d b/tests/resources/diff_format_email/.gitted/objects/2f/f7b811eee62a73959350b1f7349f6f4d0c882d
new file mode 100644
index 000000000..d2b911d0e
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/2f/f7b811eee62a73959350b1f7349f6f4d0c882d differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/39/91dce9e71a0641ca49a6a4eea6c9e7ff402ed4 b/tests/resources/diff_format_email/.gitted/objects/39/91dce9e71a0641ca49a6a4eea6c9e7ff402ed4
new file mode 100644
index 000000000..69d213dcb
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/39/91dce9e71a0641ca49a6a4eea6c9e7ff402ed4 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/45/eef2a9317e179984649de247269e38cd5d99cf b/tests/resources/diff_format_email/.gitted/objects/45/eef2a9317e179984649de247269e38cd5d99cf
new file mode 100644
index 000000000..e5014565b
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/45/eef2a9317e179984649de247269e38cd5d99cf
@@ -0,0 +1,2 @@
+x
¥ÎÁJÅ0…a×yŠÙ_�I›IqwÁ¥o0�Lo+$¹&©àÛ[õÜþŸ””öƒŸzU…à&ÒÁFY„,ñ:¯ÞYš¼CT·8B¥Õ	ŽæÎUs¯H,BL‘Â)ËÈ(‚ër.cŒažÃ
}+^Y>mpÕšö¶_
žÞÿÚí¥õºsçG)éì&k}˜G¸à€hÎzR»þëļi*Ÿ
+RrÿñsŽ ç›Âý—Ôö’›ùÐXã
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/4a/076277b884c519a932be67e346db2ac80a98fa b/tests/resources/diff_format_email/.gitted/objects/4a/076277b884c519a932be67e346db2ac80a98fa
new file mode 100644
index 000000000..b855408e8
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/4a/076277b884c519a932be67e346db2ac80a98fa differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/4c/3bd7182ad66ea7aa20ba47ae82812b710d169c b/tests/resources/diff_format_email/.gitted/objects/4c/3bd7182ad66ea7aa20ba47ae82812b710d169c
new file mode 100644
index 000000000..65740b42c
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/4c/3bd7182ad66ea7aa20ba47ae82812b710d169c differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/4c/a10087e696d2ba78d07b146a118e9a7096ed4f b/tests/resources/diff_format_email/.gitted/objects/4c/a10087e696d2ba78d07b146a118e9a7096ed4f
new file mode 100644
index 000000000..b05e7d634
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/4c/a10087e696d2ba78d07b146a118e9a7096ed4f differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/4d/de2b17d1c982cd988f21d24350a214401e4a1e b/tests/resources/diff_format_email/.gitted/objects/4d/de2b17d1c982cd988f21d24350a214401e4a1e
new file mode 100644
index 000000000..57a8dfed1
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/4d/de2b17d1c982cd988f21d24350a214401e4a1e differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/4f/31e0248ac800a1edc78b74f74e86f5eba90e87 b/tests/resources/diff_format_email/.gitted/objects/4f/31e0248ac800a1edc78b74f74e86f5eba90e87
new file mode 100644
index 000000000..0f31b97d6
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/4f/31e0248ac800a1edc78b74f74e86f5eba90e87 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/50/17c9456d013b2c7712d29aab73b681c880f509 b/tests/resources/diff_format_email/.gitted/objects/50/17c9456d013b2c7712d29aab73b681c880f509
new file mode 100644
index 000000000..5b96aa5ea
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/50/17c9456d013b2c7712d29aab73b681c880f509 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/50/438cfa585c1d15cf3650ed1bf641da937cc261 b/tests/resources/diff_format_email/.gitted/objects/50/438cfa585c1d15cf3650ed1bf641da937cc261
new file mode 100644
index 000000000..8db9090bc
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/50/438cfa585c1d15cf3650ed1bf641da937cc261 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/52/c3cd1ff6234b95fecbaf9ef13624da17697b8d b/tests/resources/diff_format_email/.gitted/objects/52/c3cd1ff6234b95fecbaf9ef13624da17697b8d
new file mode 100644
index 000000000..4bbc0ea43
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/52/c3cd1ff6234b95fecbaf9ef13624da17697b8d differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/55/0d730ba1b8c4937ea170b37c7ba91d792c0aaa b/tests/resources/diff_format_email/.gitted/objects/55/0d730ba1b8c4937ea170b37c7ba91d792c0aaa
new file mode 100644
index 000000000..680e48762
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/55/0d730ba1b8c4937ea170b37c7ba91d792c0aaa differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/66/81f1844dc677e5ff07ffd993461f5c441e6af5 b/tests/resources/diff_format_email/.gitted/objects/66/81f1844dc677e5ff07ffd993461f5c441e6af5
new file mode 100644
index 000000000..86a38289b
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/66/81f1844dc677e5ff07ffd993461f5c441e6af5 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/69/ddefb5c245e2f9ee62bd4cabd8ebe60a01e448 b/tests/resources/diff_format_email/.gitted/objects/69/ddefb5c245e2f9ee62bd4cabd8ebe60a01e448
new file mode 100644
index 000000000..81b606f4e
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/69/ddefb5c245e2f9ee62bd4cabd8ebe60a01e448 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/6b/6c2067c6d968f9bddb9b900ee1ab7e5b067430 b/tests/resources/diff_format_email/.gitted/objects/6b/6c2067c6d968f9bddb9b900ee1ab7e5b067430
new file mode 100644
index 000000000..aa9d7b0cd
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/6b/6c2067c6d968f9bddb9b900ee1ab7e5b067430
@@ -0,0 +1,2 @@
+x
¥Î;
+1…aë¬âö‚ä�	ˆX)¸‹$sãDˆ3æ
º{.Áö+þsšsjÀ…Þµ‚'£fg=Cm⤄çˆA §<p&m¨5\H²¹‚Ï:0¥•
ThaŒC…—J[;̱¨<Î^)‰ëmYÜ\xu¬pÅ’S]ú§Âññ³û¹¶’\s‡°æ01†¸dTžrJÉÐqµá_rIﾑ/P¿Ký
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/6b/ef49b206b29d9c46456e075722cd1a48b41e4c b/tests/resources/diff_format_email/.gitted/objects/6b/ef49b206b29d9c46456e075722cd1a48b41e4c
new file mode 100644
index 000000000..49e9d65f4
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/6b/ef49b206b29d9c46456e075722cd1a48b41e4c differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/6c/15659c036377aebf3b4569959ca1f5bedb551f b/tests/resources/diff_format_email/.gitted/objects/6c/15659c036377aebf3b4569959ca1f5bedb551f
new file mode 100644
index 000000000..e32471ba9
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/6c/15659c036377aebf3b4569959ca1f5bedb551f differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/6e/05acc5a5dab507d91a0a0cc0fb05a3dd98892d b/tests/resources/diff_format_email/.gitted/objects/6e/05acc5a5dab507d91a0a0cc0fb05a3dd98892d
new file mode 100644
index 000000000..26ee22429
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/6e/05acc5a5dab507d91a0a0cc0fb05a3dd98892d
@@ -0,0 +1,2 @@
+x
¥�ANÄ0EYçÞ�¨œ8“`	�f‡Ä’¸‰ËtD¦�ºÜž"€åOúú¿,­Í!ñ�uUÈ1Õ£�*Š…Cò•2G,2‰pžt+“{—®7)ŽœJªcEÅ,JT	1�IâCˆ»›88Ùì²tx–ò±é
+OÚÛ¼^¶¯¯¿ìõ¼ZŸÅd(K;�'Θ‘�	ÝN÷©¦ÿ*q/z“¦¦ùMý`Ÿ÷§¿0ì§~´ûàW@
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/74/6d514eae0c330261d37940cab33aa97fefbd93 b/tests/resources/diff_format_email/.gitted/objects/74/6d514eae0c330261d37940cab33aa97fefbd93
new file mode 100644
index 000000000..ee55d64d7
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/74/6d514eae0c330261d37940cab33aa97fefbd93
@@ -0,0 +1 @@
+x
+)JMU01e040031QHËÌI5Ô+©(Ñ+JÍKÌMMaXY¾àB¸ØŒ¢î|ý²Ò-a'{"
ÌŠw
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/74/a4d5394ebcfa7e9f445680897dfbc96586bc86 b/tests/resources/diff_format_email/.gitted/objects/74/a4d5394ebcfa7e9f445680897dfbc96586bc86
new file mode 100644
index 000000000..1bae4a6d6
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/74/a4d5394ebcfa7e9f445680897dfbc96586bc86 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/77/d0a3ed37236a7941d564f08d68d3b36462d231 b/tests/resources/diff_format_email/.gitted/objects/77/d0a3ed37236a7941d564f08d68d3b36462d231
new file mode 100644
index 000000000..db037caf9
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/77/d0a3ed37236a7941d564f08d68d3b36462d231
@@ -0,0 +1,2 @@
+x
¥�Aj1E³ö)´/�ìØ„�®
+¹…$ËÍ<N<žEoŸ�¡ÛÇçñŸ´Zç
èãatU@ì)3‹Cæ"	㓪¸"J˜-z
9'2OêºHÑ%J(5¸IÙ2:õ|¼ï¹�Lž\t†¶qon$¯MWøÖ^çõ¾ý®p~ü±Ÿë:úLƒ>¥ÕLîqŠÞGø°h­Ùé~uè¿$æ+g¨­+H[Æ^`ÞÈ�QW
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/7a/de76dd34bba4733cf9878079f9fd4a456a9189 b/tests/resources/diff_format_email/.gitted/objects/7a/de76dd34bba4733cf9878079f9fd4a456a9189
new file mode 100644
index 000000000..cf9bdaa5f
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/7a/de76dd34bba4733cf9878079f9fd4a456a9189
@@ -0,0 +1,3 @@
+x
¥ŽA
+Â0E]ç³d’4M"î÷`šm…´5IÞÞ¢Gpû>¼ÿâœÒXÁ4aW³°nˆŒ3âyŒ–,[F­í½ôH­oD-”eªÐ
+:ŠÑ‘cêzš�0F¼÷Ûb™C×ÊÖ:Ì®_«¸HNcÖw�ãóÇçRóH•qN'Ð6x­½F{4ˆj£[j•¿$ê¶0U�åû_Æy*ê&R
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/7a/ff11da95ca2be0bfb74b06e7cc1c480559dbe7 b/tests/resources/diff_format_email/.gitted/objects/7a/ff11da95ca2be0bfb74b06e7cc1c480559dbe7
new file mode 100644
index 000000000..d8c9934f7
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/7a/ff11da95ca2be0bfb74b06e7cc1c480559dbe7 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/7f/854619451620f7fbcec7ea171675e615ce92b6 b/tests/resources/diff_format_email/.gitted/objects/7f/854619451620f7fbcec7ea171675e615ce92b6
new file mode 100644
index 000000000..df4cbb322
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/7f/854619451620f7fbcec7ea171675e615ce92b6 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/87/3806f6f27e631eb0b23e4b56bea2bfac14a373 b/tests/resources/diff_format_email/.gitted/objects/87/3806f6f27e631eb0b23e4b56bea2bfac14a373
new file mode 100644
index 000000000..890abcd4a
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/87/3806f6f27e631eb0b23e4b56bea2bfac14a373 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/89/47a46e2097638ca6040ad4877246f4186ec3bd b/tests/resources/diff_format_email/.gitted/objects/89/47a46e2097638ca6040ad4877246f4186ec3bd
new file mode 100644
index 000000000..d4018bf8e
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/89/47a46e2097638ca6040ad4877246f4186ec3bd
@@ -0,0 +1,2 @@
+x
•ŽAjÃ0E³Ö)´/„ÑŒ,ÉJw….{ƒ‘ò�8 ;•åEo_C{�nßâ½WÖZçnYÒ©7À:¤8\uÌ!Ni�Ì@0qaWRˆ4FožÚ°t›¢$
+S˜8"ˆC¦ÌŸ‡�¡œ'-ΫD1º÷ûÚ쇖¯›}G«óvß¿7{yü²ÛÛÖÛ¬]Ïe­¯ÖÉ¢‘¼Øb"sÐcµãßöÎñŸÄ|bÑŠ«ù
þûLÊ
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/89/7d3af16ca9e420cd071b1c4541bd2b91d04c8c b/tests/resources/diff_format_email/.gitted/objects/89/7d3af16ca9e420cd071b1c4541bd2b91d04c8c
new file mode 100644
index 000000000..1dce143b7
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/89/7d3af16ca9e420cd071b1c4541bd2b91d04c8c
@@ -0,0 +1 @@
+x
¥ÎANÄ0@QÖ9…÷HȵÓ$•šY!q'±™ éÒt1·g$ŽÀö-¾~ÙÖµ
 ŸžFWb[hñ¡²qÊ´ˆXY“Æ)™•9Qðî[ºÞ¤È	ƒ£¨�'͘‰Õç9dÊ&eò‘�ã²uø�òsèïÚ׶_Žû¯_öyÚGo2ä¥lëL¼D�3§ÏHˆî¡�Õ¡ÿŠ¸s­Z!·›ô;X»ªû"Pq
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/8d/7523f6fcb2404257889abe0d96f093d9f524f9 b/tests/resources/diff_format_email/.gitted/objects/8d/7523f6fcb2404257889abe0d96f093d9f524f9
new file mode 100644
index 000000000..903ec751c
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/8d/7523f6fcb2404257889abe0d96f093d9f524f9
@@ -0,0 +1 @@
+x
¥ÎAJÅ0€a×9Åì™IÓ¤
w‚à!f&_äõUÓtñnoÁ#¸ý¿nëÚø™F7JZ¹LÑòT$%ŒBQ¬ÎV—à…ÉfeŒ,î›»Ý,9•‰+EålÁ£L$¤a$ÅK¦‚Au|ŒËÖá�õç°Þ¬¯m¿÷ž¿þÚçë>zãÁOº­/@SN
Of�Gôˆî¬çê°!îc+­6+ íÆýµ]ÍýERÚ
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/8d/fa038554d5b682a51bda8ee3038cee6c63be76 b/tests/resources/diff_format_email/.gitted/objects/8d/fa038554d5b682a51bda8ee3038cee6c63be76
new file mode 100644
index 000000000..b5e08f901
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/8d/fa038554d5b682a51bda8ee3038cee6c63be76 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/92/64b96c6d104d0e07ae33d3007b6a48246c6f92 b/tests/resources/diff_format_email/.gitted/objects/92/64b96c6d104d0e07ae33d3007b6a48246c6f92
new file mode 100644
index 000000000..75b047a64
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/92/64b96c6d104d0e07ae33d3007b6a48246c6f92 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/94/350226b3aa14efac831c803a51f7a09f3fc31a b/tests/resources/diff_format_email/.gitted/objects/94/350226b3aa14efac831c803a51f7a09f3fc31a
new file mode 100644
index 000000000..a5286bc68
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/94/350226b3aa14efac831c803a51f7a09f3fc31a differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/94/75e21dcbc515af8f641576400e4b450e5f4c03 b/tests/resources/diff_format_email/.gitted/objects/94/75e21dcbc515af8f641576400e4b450e5f4c03
new file mode 100644
index 000000000..9e26e34cd
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/94/75e21dcbc515af8f641576400e4b450e5f4c03 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/94/aaae8954e8bb613de636071da663a621695911 b/tests/resources/diff_format_email/.gitted/objects/94/aaae8954e8bb613de636071da663a621695911
new file mode 100644
index 000000000..5fc167e79
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/94/aaae8954e8bb613de636071da663a621695911 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/9a/2d780ac2ea0aeabdb9d2a876e6bbfff17b2c44 b/tests/resources/diff_format_email/.gitted/objects/9a/2d780ac2ea0aeabdb9d2a876e6bbfff17b2c44
new file mode 100644
index 000000000..be48c275e
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/9a/2d780ac2ea0aeabdb9d2a876e6bbfff17b2c44 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/9a/c0329b8b7a4046210d8b8b02ac02055667de63 b/tests/resources/diff_format_email/.gitted/objects/9a/c0329b8b7a4046210d8b8b02ac02055667de63
new file mode 100644
index 000000000..f322a7ce4
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/9a/c0329b8b7a4046210d8b8b02ac02055667de63 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/9a/c35ff15cd8864aeafd889e4826a3150f0b06c4 b/tests/resources/diff_format_email/.gitted/objects/9a/c35ff15cd8864aeafd889e4826a3150f0b06c4
new file mode 100644
index 000000000..75cd71426
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/9a/c35ff15cd8864aeafd889e4826a3150f0b06c4 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/9b/997daca2a0beb5cc44b32c64f100a9a26d4d4b b/tests/resources/diff_format_email/.gitted/objects/9b/997daca2a0beb5cc44b32c64f100a9a26d4d4b
new file mode 100644
index 000000000..d84ab8dcc
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/9b/997daca2a0beb5cc44b32c64f100a9a26d4d4b differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/a3/ac918e3a6604294b239cb956363e83d71abb3b b/tests/resources/diff_format_email/.gitted/objects/a3/ac918e3a6604294b239cb956363e83d71abb3b
new file mode 100644
index 000000000..a693df5c8
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/a3/ac918e3a6604294b239cb956363e83d71abb3b
@@ -0,0 +1 @@
+x
¥ÎMJ1@a×9Eí©TçDf7 xˆJRåD¦§5�^Ìíðn¿ÅãÕm]ûòöih±çbSK5pâÂ)RDô.‘²V­¥Ù|ó�Û„Ô¢§EƒÖBù˜Ræ"ØrPÌKËêÉi6|ÌË6à�ëÏ!;œe¬}¿÷^¿þìó´ÏÑyòKÝÖ7°KŽC ÏHˆæ¡�Õ)ÿŠ˜�­uíÒ ô�;h¿ŠùÜüQK
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/a5/ac978d4f2a1784f847f41223a34c3e78934238 b/tests/resources/diff_format_email/.gitted/objects/a5/ac978d4f2a1784f847f41223a34c3e78934238
new file mode 100644
index 000000000..f0483943b
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/a5/ac978d4f2a1784f847f41223a34c3e78934238 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/a7/29eab45c84563135e8631d4010230bc0479f1f b/tests/resources/diff_format_email/.gitted/objects/a7/29eab45c84563135e8631d4010230bc0479f1f
new file mode 100644
index 000000000..5c1faf009
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/a7/29eab45c84563135e8631d4010230bc0479f1f differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/a9/7157a0d0571698728b6f2f7675b456c98c5961 b/tests/resources/diff_format_email/.gitted/objects/a9/7157a0d0571698728b6f2f7675b456c98c5961
new file mode 100644
index 000000000..3baf494be
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/a9/7157a0d0571698728b6f2f7675b456c98c5961 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/af/8f41d0cb7a3079a8f8e231ea2ab8b97837ce13 b/tests/resources/diff_format_email/.gitted/objects/af/8f41d0cb7a3079a8f8e231ea2ab8b97837ce13
new file mode 100644
index 000000000..f0dcaa9ac
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/af/8f41d0cb7a3079a8f8e231ea2ab8b97837ce13 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/b0/5cecf1949d192b6df852b3f71853ef820ee235 b/tests/resources/diff_format_email/.gitted/objects/b0/5cecf1949d192b6df852b3f71853ef820ee235
new file mode 100644
index 000000000..28e148f41
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/b0/5cecf1949d192b6df852b3f71853ef820ee235 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/b4/f457c219dbb3517be908d4e70f0ada2fd8b8f9 b/tests/resources/diff_format_email/.gitted/objects/b4/f457c219dbb3517be908d4e70f0ada2fd8b8f9
new file mode 100644
index 000000000..0c74e7696
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/b4/f457c219dbb3517be908d4e70f0ada2fd8b8f9 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/bd/474b2519cc15eab801ff851cc7d50f0dee49a1 b/tests/resources/diff_format_email/.gitted/objects/bd/474b2519cc15eab801ff851cc7d50f0dee49a1
new file mode 100644
index 000000000..2dc82087b
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/bd/474b2519cc15eab801ff851cc7d50f0dee49a1 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/bd/f7ba6bc5c4e57ca6595928dcbe6753c8a663ff b/tests/resources/diff_format_email/.gitted/objects/bd/f7ba6bc5c4e57ca6595928dcbe6753c8a663ff
new file mode 100644
index 000000000..af0232aa1
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/bd/f7ba6bc5c4e57ca6595928dcbe6753c8a663ff differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/cb/a89408dc016f4caddb6dc886fcb58f587a78df b/tests/resources/diff_format_email/.gitted/objects/cb/a89408dc016f4caddb6dc886fcb58f587a78df
new file mode 100644
index 000000000..e03c74935
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/cb/a89408dc016f4caddb6dc886fcb58f587a78df
@@ -0,0 +1,3 @@
+x
¥ÎK
+Â0FaÇYE悤¹ÍCq&8t7É[!­¦éÀÝ[p	N¿ÁáĹ”±IM~×* }ʬÈÓ'¬×lº�Ø´il´à¬xqÅÔ¤wä•Í6kK‚
+šÐcX‡Ì±ë™	^Û0Wyãø^±È+j—aý,òôüÙã²´:rãCœËYvttZUOr¯´RbÓmµá¯ˆ¸câ‚$¾’ÏM‘
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/cd/471f0d8770371e1bc78bcbb38db4c7e4106bd2 b/tests/resources/diff_format_email/.gitted/objects/cd/471f0d8770371e1bc78bcbb38db4c7e4106bd2
new file mode 100644
index 000000000..155b45273
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/cd/471f0d8770371e1bc78bcbb38db4c7e4106bd2 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/cd/ed722d05305c6b181f188c118d2d9810f39bb8 b/tests/resources/diff_format_email/.gitted/objects/cd/ed722d05305c6b181f188c118d2d9810f39bb8
new file mode 100644
index 000000000..fd9363612
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/cd/ed722d05305c6b181f188c118d2d9810f39bb8 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/ce/2792fcae8d704a56901754a0583a7418a21d8a b/tests/resources/diff_format_email/.gitted/objects/ce/2792fcae8d704a56901754a0583a7418a21d8a
new file mode 100644
index 000000000..5863cec1b
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/ce/2792fcae8d704a56901754a0583a7418a21d8a differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/d1/4aa252e52a709d03a3d3d0d965e177eb0a674e b/tests/resources/diff_format_email/.gitted/objects/d1/4aa252e52a709d03a3d3d0d965e177eb0a674e
new file mode 100644
index 000000000..a5d4d78e9
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/d1/4aa252e52a709d03a3d3d0d965e177eb0a674e
@@ -0,0 +1 @@
+x
+)JMU01e040075UHËÌI5Ô+©(Ñ+JÍKÌMMaXY¾àB¸ØŒ¢î|ý²Ò-a'{"
Íz
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/d7/bb447df12c6a8aba8727005482fb211f11297a b/tests/resources/diff_format_email/.gitted/objects/d7/bb447df12c6a8aba8727005482fb211f11297a
new file mode 100644
index 000000000..85eb8141c
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/d7/bb447df12c6a8aba8727005482fb211f11297a differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/db/e8727e4806ae88ccc3f0755cae8f8cb7efa2cc b/tests/resources/diff_format_email/.gitted/objects/db/e8727e4806ae88ccc3f0755cae8f8cb7efa2cc
new file mode 100644
index 000000000..8e250ece2
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/db/e8727e4806ae88ccc3f0755cae8f8cb7efa2cc differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/e1/2af77c510e8ce4c261a3758736109c2c2dd1f0 b/tests/resources/diff_format_email/.gitted/objects/e1/2af77c510e8ce4c261a3758736109c2c2dd1f0
new file mode 100644
index 000000000..92a89a2cf
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/e1/2af77c510e8ce4c261a3758736109c2c2dd1f0 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/tests/resources/diff_format_email/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
new file mode 100644
index 000000000..711223894
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/e9/091231467304a5ef112de02361d795ef051ee1 b/tests/resources/diff_format_email/.gitted/objects/e9/091231467304a5ef112de02361d795ef051ee1
new file mode 100644
index 000000000..43a006231
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/e9/091231467304a5ef112de02361d795ef051ee1 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/ee/251372f131d82e575f16fe51c778406d88f8c2 b/tests/resources/diff_format_email/.gitted/objects/ee/251372f131d82e575f16fe51c778406d88f8c2
new file mode 100644
index 000000000..ee1edad9a
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/ee/251372f131d82e575f16fe51c778406d88f8c2
@@ -0,0 +1,2 @@
+x
¥ÎM
+Â0@a×9Eö‚dò3“€ˆ+o‘¦¡¶¦)èí-x·ßâñÒ4Ž¥Imp×*³Ô9Sç
˜u$\0Nu�ÉØ�1Û^%ïu/æXùÙ$eï,B°P«L¹Kœˆ# 9Fp‰ƒîPĵ
S•·˜^+/òÊu,Ë°~y|üì~^Z-±ÅCšÆ“H‘²hå^i¥Ä¦Ûjã¿"âRÞë,¾HrKï
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/f3/d35bd592fefd8280fc0c302fa9f27dbdd721a3 b/tests/resources/diff_format_email/.gitted/objects/f3/d35bd592fefd8280fc0c302fa9f27dbdd721a3
new file mode 100644
index 000000000..62d747cf6
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/f3/d35bd592fefd8280fc0c302fa9f27dbdd721a3
@@ -0,0 +1 @@
+x
¥ÍA @Qלbö&fhi)‰1îŒÞb€A1b#LÞÞ&=‚Û¿x?Ì¥d
íìN*3x“Ì`C§]ô¾´õìpŠ†-&¤H]Š“Ÿ’S´Èc®p£ðY¸Á…kÉí±|Ÿ[»Ÿ›ÔLB‡0—èÞYûq4°ÇQ­u]ÿ…¨ë;K¦lšú
H°B¿
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/f4/07be01334e07bfb8f57cd2078f0ee3eb61e085 b/tests/resources/diff_format_email/.gitted/objects/f4/07be01334e07bfb8f57cd2078f0ee3eb61e085
new file mode 100644
index 000000000..d858a87b5
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/f4/07be01334e07bfb8f57cd2078f0ee3eb61e085
@@ -0,0 +1 @@
+x
¥ÎMNÄ0@aÖ9…÷”8®ÓH±CBâNâ™v íL~Üž‘8Ûoñôò±mk¤øЫ*pÒÅ„–Æ31M¬6L
1'4'rJÙ\¥êÞ!„bÅkñ
=KˆäÊÄt²sá¹øä™zgdôå¨ð!ù6´Á»ÖmmËøiðrù³ó[ëu•.ÏùØ^ÁùК<Z´ÖÜõ¾Úõ_ó9¾ûú´Œýò"ûY›ùû÷PR
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/f9/e215d309644e24fa50d6bd6e6eedba166e56bc b/tests/resources/diff_format_email/.gitted/objects/f9/e215d309644e24fa50d6bd6e6eedba166e56bc
new file mode 100644
index 000000000..b9919c225
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/objects/f9/e215d309644e24fa50d6bd6e6eedba166e56bc
@@ -0,0 +1,2 @@
+x
¥ÎM
+Â0@a×9Eö‚ÌLÚL"®¼ÅäG­[Óôö<‚Ûoñxq,ehšŒÝ´š³î
9ú®·	ЊÌH‰¼H`¬Ãè\{ðj’šŸMwÑ„ÄèH’µYX„ HÇ’9¤À	­�J–v«¾H|-yÖç\Ë0ߗϬ÷�ŸÝŽs«ƒ4Ùű4ÏÀÐé-€Zu]mù¯ˆ:
ïeR_K§
\ No newline at end of file
diff --git a/tests/resources/diff_format_email/.gitted/objects/fc/a0c10eb9f1af6494a448d5733d283f5232a514 b/tests/resources/diff_format_email/.gitted/objects/fc/a0c10eb9f1af6494a448d5733d283f5232a514
new file mode 100644
index 000000000..776221d21
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/fc/a0c10eb9f1af6494a448d5733d283f5232a514 differ
diff --git a/tests/resources/diff_format_email/.gitted/objects/ff/8d35b41494f7f0dc92f95d67f54fff274d3fcb b/tests/resources/diff_format_email/.gitted/objects/ff/8d35b41494f7f0dc92f95d67f54fff274d3fcb
new file mode 100644
index 000000000..92964252a
Binary files /dev/null and b/tests/resources/diff_format_email/.gitted/objects/ff/8d35b41494f7f0dc92f95d67f54fff274d3fcb differ
diff --git a/tests/resources/diff_format_email/.gitted/refs/heads/binary b/tests/resources/diff_format_email/.gitted/refs/heads/binary
new file mode 100644
index 000000000..7e563c957
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/refs/heads/binary
@@ -0,0 +1 @@
+a3ac918e3a6604294b239cb956363e83d71abb3b
diff --git a/tests/resources/diff_format_email/.gitted/refs/heads/master b/tests/resources/diff_format_email/.gitted/refs/heads/master
new file mode 100644
index 000000000..f0f3f932a
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/refs/heads/master
@@ -0,0 +1 @@
+873806f6f27e631eb0b23e4b56bea2bfac14a373
diff --git a/tests/resources/diff_format_email/.gitted/refs/heads/multihunk b/tests/resources/diff_format_email/.gitted/refs/heads/multihunk
new file mode 100644
index 000000000..41bd37f39
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/refs/heads/multihunk
@@ -0,0 +1 @@
+cd471f0d8770371e1bc78bcbb38db4c7e4106bd2
diff --git a/tests/resources/diff_format_email/.gitted/refs/heads/rename b/tests/resources/diff_format_email/.gitted/refs/heads/rename
new file mode 100644
index 000000000..3025fbc64
--- /dev/null
+++ b/tests/resources/diff_format_email/.gitted/refs/heads/rename
@@ -0,0 +1 @@
+4ca10087e696d2ba78d07b146a118e9a7096ed4f
diff --git a/tests/resources/diff_format_email/file1.txt.renamed b/tests/resources/diff_format_email/file1.txt.renamed
new file mode 100755
index 000000000..a97157a0d
--- /dev/null
+++ b/tests/resources/diff_format_email/file1.txt.renamed
@@ -0,0 +1,17 @@
+file1.txt
+file1.txt
+_file1.txt_
+file1.txt
+file1.txt
+file1.txt_renamed
+file1.txt
+
+
+file1.txt
+file1.txt
+file1.txt_renamed
+file1.txt
+file1.txt
+_file1.txt_
+_file1.txt_
+file1.txt
diff --git a/tests/resources/diff_format_email/file2.txt b/tests/resources/diff_format_email/file2.txt
new file mode 100644
index 000000000..7aff11da9
--- /dev/null
+++ b/tests/resources/diff_format_email/file2.txt
@@ -0,0 +1,5 @@
+file2
+file2
+file2
+file2!
+file2
diff --git a/tests/resources/diff_format_email/file3.txt b/tests/resources/diff_format_email/file3.txt
new file mode 100644
index 000000000..9a2d780ac
--- /dev/null
+++ b/tests/resources/diff_format_email/file3.txt
@@ -0,0 +1,5 @@
+file3
+file3!
+file3
+file3
+file3
-- 
cgit v1.2.3


From 360314c9dbb383b3737876a9c229e22050ec9c49 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 11 Apr 2014 19:03:29 +0200
Subject: Introduce git_diff_get_stats, git_diff_stats_files_changed,
 git_diff_stats_insertions, git_diff_stats_deletions and git_diff_stats_to_buf

---
 include/git2/diff.h |  85 +++++++++++
 src/diff_stats.c    | 343 +++++++++++++++++++++++++++++++++++++++++
 tests/diff/stats.c  | 428 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 856 insertions(+)
 create mode 100644 src/diff_stats.c
 create mode 100644 tests/diff/stats.c

diff --git a/include/git2/diff.h b/include/git2/diff.h
index f855f52ba..571f0c887 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -1072,6 +1072,91 @@ GIT_EXTERN(int) git_diff_buffers(
 	git_diff_line_cb line_cb,
 	void *payload);
 
+/**
+ * This is an opaque structure which is allocated by `git_diff_get_stats`.
+ * You are responsible for releasing the object memory when done, using the
+ * `git_diff_stats_free()` function.
+ */
+typedef struct git_diff_stats git_diff_stats;
+
+/**
+ * Formatting options for diff stats
+ */
+typedef enum {
+	/** No stats*/
+	GIT_DIFF_STATS_NONE = 0,
+
+	/** Full statistics, equivalent of `--stat` */
+	GIT_DIFF_STATS_FULL = (1u << 0),
+
+	/** Short statistics, equivalent of `--shortstat` */
+	GIT_DIFF_STATS_SHORT = (1u << 1),
+
+	/** Number statistics, equivalent of `--numstat` */
+	GIT_DIFF_STATS_NUMBER = (1u << 2),
+
+	/** Extended header information such as creations, renames and mode changes, equivalent of `--summary` */
+	GIT_DIFF_STATS_INCLUDE_SUMMARY = (1u << 3),
+} git_diff_stats_format_t;
+
+/**
+ * Accumlate diff statistics for all patches.
+ *
+ * @param out Structure containg the diff statistics.
+ * @param diff A git_diff generated by one of the above functions.
+ * @return 0 on success; non-zero on error
+ */
+GIT_EXTERN(int) git_diff_get_stats(
+	git_diff_stats **out,
+	git_diff *diff);
+
+/**
+ * Get the total number of files changed in a diff
+ *
+ * @param stats A `git_diff_stats` generated by one of the above functions.
+ * @return total number of files changed in the diff
+ */
+GIT_EXTERN(size_t) git_diff_stats_files_changed(
+	const git_diff_stats *stats);
+
+/**
+ * Get the total number of insertions in a diff
+ *
+ * @param stats A `git_diff_stats` generated by one of the above functions.
+ * @return total number of insertions in the diff
+ */
+GIT_EXTERN(size_t) git_diff_stats_insertions(
+	const git_diff_stats *stats);
+
+/**
+ * Get the total number of deletions in a diff
+ *
+ * @param stats A `git_diff_stats` generated by one of the above functions.
+ * @return total number of deletions in the diff
+ */
+GIT_EXTERN(size_t) git_diff_stats_deletions(
+	const git_diff_stats *stats);
+
+/**
+ * Print diff statistics to a `git_buf`.
+ *
+ * @param out buffer to store the formatted diff statistics in.
+ * @param stats A `git_diff_stats` generated by one of the above functions.
+ * @param format Formatting option.
+ * @return 0 on success; non-zero on error
+ */
+GIT_EXTERN(int) git_diff_stats_to_buf(
+	git_buf *out,
+	const git_diff_stats *stats,
+	git_diff_stats_format_t format);
+
+/**
+ * Deallocate a `git_diff_stats`.
+ *
+ * @param stats The previously created statistics object;
+ * cannot be used after free.
+ */
+GIT_EXTERN(void) git_diff_stats_free(git_diff_stats *stats);
 
 GIT_END_DECL
 
diff --git a/src/diff_stats.c b/src/diff_stats.c
new file mode 100644
index 000000000..bb436bf7b
--- /dev/null
+++ b/src/diff_stats.c
@@ -0,0 +1,343 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#include "common.h"
+#include "vector.h"
+#include "diff.h"
+#include "diff_patch.h"
+
+#define DIFF_RENAME_FILE_SEPARATOR " => "
+
+struct git_diff_stats {
+	git_vector patches;
+
+	size_t files_changed;
+	size_t insertions;
+	size_t deletions;
+};
+
+static size_t diff_get_filename_padding(
+	int has_renames,
+	const git_diff_stats *stats)
+{
+	const git_patch *patch = NULL;
+	size_t i, max_padding = 0;
+
+	if (has_renames) {
+		git_vector_foreach(&stats->patches, i, patch) {
+			const git_diff_delta *delta = NULL;
+			size_t len;
+
+			delta = git_patch_get_delta(patch);
+			if (strcmp(delta->old_file.path, delta->new_file.path) == 0)
+				continue;
+
+			if ((len = strlen(delta->old_file.path) + strlen(delta->new_file.path)) > max_padding)
+				max_padding = len;
+		}
+	}
+
+	git_vector_foreach(&stats->patches, i, patch) {
+		const git_diff_delta *delta = NULL;
+		size_t len;
+
+		delta = git_patch_get_delta(patch);
+		len = strlen(delta->new_file.path);
+
+		if (strcmp(delta->old_file.path, delta->new_file.path) != 0)
+			continue;
+
+		if (len > max_padding)
+			max_padding = len;
+	}
+
+	return max_padding;
+}
+
+int git_diff_file_stats__full_to_buf(
+	git_buf *out,
+	size_t max_padding,
+	int has_renames,
+	const git_patch *patch)
+{
+	const char *old_path = NULL, *new_path = NULL;
+	const git_diff_delta *delta = NULL;
+	size_t padding, old_size, new_size;
+	int error;
+
+	delta = git_patch_get_delta(patch);
+
+	old_path = delta->old_file.path;
+	new_path = delta->new_file.path;
+	old_size = delta->old_file.size;
+	new_size = delta->new_file.size;
+
+	if ((error = git_buf_printf(out, " %s", old_path)) < 0)
+		goto on_error;
+
+	if (strcmp(old_path, new_path) != 0) {
+		padding = max_padding - strlen(old_path) - strlen(new_path);
+
+		if ((error = git_buf_printf(out, DIFF_RENAME_FILE_SEPARATOR "%s", new_path)) < 0)
+			goto on_error;
+	}
+	else {
+		padding = max_padding - strlen(old_path);
+
+		if (has_renames)
+			padding += strlen(DIFF_RENAME_FILE_SEPARATOR);
+	}
+
+	if ((error = git_buf_putcn(out, ' ', padding)) < 0 ||
+		(error = git_buf_puts(out, " | ")) < 0)
+			goto on_error;
+
+	if (delta->flags & GIT_DIFF_FLAG_BINARY) {
+		if ((error = git_buf_printf(out, "Bin %" PRIuZ " -> %" PRIuZ " bytes", old_size, new_size)) < 0)
+			goto on_error;
+	}
+	else {
+		size_t insertions, deletions;
+
+		if ((error = git_patch_line_stats(NULL, &insertions, &deletions, patch)) < 0)
+			goto on_error;
+
+		if ((error = git_buf_printf(out, "%" PRIuZ, insertions + deletions)) < 0)
+			goto on_error;
+
+		if (insertions || deletions) {
+			if ((error = git_buf_putc(out, ' ')) < 0 ||
+				(error = git_buf_putcn(out, '+', insertions)) < 0 ||
+				(error = git_buf_putcn(out, '-', deletions)) < 0)
+					goto on_error;
+		}
+	}
+
+	error = git_buf_putc(out, '\n');
+
+on_error:
+	return error;
+}
+
+int git_diff_file_stats__number_to_buf(
+	git_buf *out,
+	const git_patch *patch)
+{
+	const git_diff_delta *delta = NULL;
+	const char *path = NULL;
+	size_t insertions, deletions;
+	int error;
+
+	delta = git_patch_get_delta(patch);
+	path = delta->new_file.path;
+
+	if ((error = git_patch_line_stats(NULL, &insertions, &deletions, patch)) < 0)
+		return error;
+
+	if (delta->flags & GIT_DIFF_FLAG_BINARY)
+		error = git_buf_printf(out, "%-8c" "%-8c" "%s\n", '-', '-', path);
+	else
+		error = git_buf_printf(out, "%-8" PRIuZ "%-8" PRIuZ "%s\n", insertions, deletions, path);
+
+	return error;
+}
+
+int git_diff_file_stats__summary_to_buf(
+	git_buf *out,
+	const git_patch *patch)
+{
+	const git_diff_delta *delta = NULL;
+
+	delta = git_patch_get_delta(patch);
+
+	if (delta->old_file.mode != delta->new_file.mode) {
+		if (delta->old_file.mode == 0) {
+			git_buf_printf(out, " create mode %06o %s\n",
+				delta->new_file.mode, delta->new_file.path);
+		}
+		else if (delta->new_file.mode == 0) {
+			git_buf_printf(out, " delete mode %06o %s\n",
+				delta->old_file.mode, delta->old_file.path);
+		}
+		else {
+			git_buf_printf(out, " mode change %06o => %06o %s\n",
+				delta->old_file.mode, delta->new_file.mode, delta->new_file.path);
+		}
+	}
+
+	return 0;
+}
+
+int git_diff_stats__has_renames(
+	const git_diff_stats *stats)
+{
+	git_patch *patch = NULL;
+	size_t i;
+
+	git_vector_foreach(&stats->patches, i, patch) {
+		const git_diff_delta *delta = git_patch_get_delta(patch);
+
+		if (strcmp(delta->old_file.path, delta->new_file.path) != 0) {
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+int git_diff_stats__add_file_stats(
+	git_diff_stats *stats,
+	git_patch *patch)
+{
+	const git_diff_delta *delta = NULL;
+	int error = 0;
+
+	if ((delta = git_patch_get_delta(patch)) == NULL)
+		return -1;
+
+	if ((error = git_vector_insert(&stats->patches, patch)) < 0)
+		return error;
+
+	return error;
+}
+
+int git_diff_get_stats(
+	git_diff_stats **out,
+	git_diff *diff)
+{
+	size_t i, deltas;
+	size_t total_insertions = 0, total_deletions = 0;
+	git_diff_stats *stats = NULL;
+	int error = 0;
+
+	assert(out && diff);
+
+	stats = git__calloc(1, sizeof(git_diff_stats));
+	GITERR_CHECK_ALLOC(stats);
+
+	deltas = git_diff_num_deltas(diff);
+
+	for (i = 0; i < deltas; ++i) {
+		git_patch *patch = NULL;
+		size_t add, remove;
+
+		if ((error = git_patch_from_diff(&patch, diff, i)) < 0)
+			goto on_error;
+
+		if ((error = git_patch_line_stats(NULL, &add, &remove, patch)) < 0 ||
+			(error = git_diff_stats__add_file_stats(stats, patch)) < 0) {
+			git_patch_free(patch);
+			goto on_error;
+		}
+
+		total_insertions += add;
+		total_deletions += remove;
+	}
+
+	stats->files_changed = deltas;
+	stats->insertions = total_insertions;
+	stats->deletions = total_deletions;
+
+	*out = stats;
+
+	goto done;
+
+on_error:
+	git_diff_stats_free(stats);
+
+done:
+	return error;
+}
+
+size_t git_diff_stats_files_changed(
+	const git_diff_stats *stats)
+{
+	assert(stats);
+
+	return stats->files_changed;
+}
+
+size_t git_diff_stats_insertions(
+	const git_diff_stats *stats)
+{
+	assert(stats);
+
+	return stats->insertions;
+}
+
+size_t git_diff_stats_deletions(
+	const git_diff_stats *stats)
+{
+	assert(stats);
+
+	return stats->deletions;
+}
+
+int git_diff_stats_to_buf(
+	git_buf *out,
+	const git_diff_stats *stats,
+	git_diff_stats_format_t format)
+{
+	git_patch *patch = NULL;
+	size_t i;
+	int has_renames = 0, error = 0;
+
+	assert(out && stats);
+
+	/* check if we have renames, it affects the padding */
+	has_renames = git_diff_stats__has_renames(stats);
+
+	git_vector_foreach(&stats->patches, i, patch) {
+		if (format & GIT_DIFF_STATS_FULL) {
+			size_t max_padding = diff_get_filename_padding(has_renames, stats);
+
+			error = git_diff_file_stats__full_to_buf(out, max_padding, has_renames, patch);
+		}
+		else if (format & GIT_DIFF_STATS_NUMBER) {
+			error = git_diff_file_stats__number_to_buf(out, patch);
+		}
+
+		if (error < 0)
+			return error;
+	}
+
+	if (format & GIT_DIFF_STATS_FULL || format & GIT_DIFF_STATS_SHORT) {
+		error = git_buf_printf(out, " %" PRIuZ " file%s changed, %" PRIuZ " insertions(+), %" PRIuZ " deletions(-)\n",
+					stats->files_changed, stats->files_changed > 1 ? "s" : "",
+					stats->insertions, stats->deletions);
+
+		if (error < 0)
+			return error;
+	}
+
+	if (format & GIT_DIFF_STATS_INCLUDE_SUMMARY) {
+		git_vector_foreach(&stats->patches, i, patch) {
+			if ((error = git_diff_file_stats__summary_to_buf(out, patch)) < 0)
+				return error;
+		}
+
+		if (git_vector_length(&stats->patches) > 0)
+			git_buf_putc(out, '\n');
+	}
+
+	return error;
+}
+
+void git_diff_stats_free(git_diff_stats *stats)
+{
+	size_t i;
+	git_patch *patch;
+
+	if (stats == NULL)
+		return;
+
+	git_vector_foreach(&stats->patches, i, patch)
+		git_patch_free(patch);
+
+	git_vector_free(&stats->patches);
+	git__free(stats);
+}
+
diff --git a/tests/diff/stats.c b/tests/diff/stats.c
new file mode 100644
index 000000000..131b7681d
--- /dev/null
+++ b/tests/diff/stats.c
@@ -0,0 +1,428 @@
+#include "clar.h"
+#include "clar_libgit2.h"
+
+#include "buffer.h"
+#include "commit.h"
+#include "diff.h"
+
+static git_repository *repo;
+
+void test_diff_stats__initialize(void)
+{
+	repo = cl_git_sandbox_init("diff_format_email");
+}
+
+void test_diff_stats__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_diff_stats__stat(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file1.txt | 8 +++++---\n" \
+	" 1 file changed, 5 insertions(+), 3 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 1);
+	cl_assert(git_diff_stats_insertions(stats) == 5);
+	cl_assert(git_diff_stats_deletions(stats) == 3);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__multiple_hunks(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file2.txt | 5 +++--\n" \
+	" file3.txt | 6 ++++--\n" \
+	" 2 files changed, 7 insertions(+), 4 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "cd471f0d8770371e1bc78bcbb38db4c7e4106bd2");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 2);
+	cl_assert(git_diff_stats_insertions(stats) == 7);
+	cl_assert(git_diff_stats_deletions(stats) == 4);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__numstat(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	"3       2       file2.txt\n"
+	"4       2       file3.txt\n";
+
+	git_oid_fromstr(&oid, "cd471f0d8770371e1bc78bcbb38db4c7e4106bd2");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_NUMBER));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__shortstat(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" 1 file changed, 5 insertions(+), 3 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 1);
+	cl_assert(git_diff_stats_insertions(stats) == 5);
+	cl_assert(git_diff_stats_deletions(stats) == 3);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_SHORT));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__rename(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file2.txt => file2.txt.renamed | 1 +\n"
+	" file3.txt => file3.txt.renamed | 4 +++-\n"
+	" 2 files changed, 4 insertions(+), 1 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "8947a46e2097638ca6040ad4877246f4186ec3bd");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_find_similar(diff, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 2);
+	cl_assert(git_diff_stats_insertions(stats) == 4);
+	cl_assert(git_diff_stats_deletions(stats) == 1);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__rename_nochanges(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file2.txt.renamed => file2.txt.renamed2 | 0\n"
+	" file3.txt.renamed => file3.txt.renamed2 | 0\n"
+	" 2 files changed, 0 insertions(+), 0 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "3991dce9e71a0641ca49a6a4eea6c9e7ff402ed4");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_find_similar(diff, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 2);
+	cl_assert(git_diff_stats_insertions(stats) == 0);
+	cl_assert(git_diff_stats_deletions(stats) == 0);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__rename_and_modifiy(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file2.txt.renamed2                      | 2 +-\n"
+	" file3.txt.renamed2 => file3.txt.renamed | 0\n"
+	" 2 files changed, 1 insertions(+), 1 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "4ca10087e696d2ba78d07b146a118e9a7096ed4f");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_find_similar(diff, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 2);
+	cl_assert(git_diff_stats_insertions(stats) == 1);
+	cl_assert(git_diff_stats_deletions(stats) == 1);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__rename_no_find(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file2.txt         | 5 -----\n"
+	" file2.txt.renamed | 6 ++++++\n"
+	" file3.txt         | 5 -----\n"
+	" file3.txt.renamed | 7 +++++++\n"
+	" 4 files changed, 13 insertions(+), 10 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "8947a46e2097638ca6040ad4877246f4186ec3bd");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 4);
+	cl_assert(git_diff_stats_insertions(stats) == 13);
+	cl_assert(git_diff_stats_deletions(stats) == 10);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__rename_nochanges_no_find(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file2.txt.renamed  | 6 ------\n"
+	" file2.txt.renamed2 | 6 ++++++\n"
+	" file3.txt.renamed  | 7 -------\n"
+	" file3.txt.renamed2 | 7 +++++++\n"
+	" 4 files changed, 13 insertions(+), 13 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "3991dce9e71a0641ca49a6a4eea6c9e7ff402ed4");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 4);
+	cl_assert(git_diff_stats_insertions(stats) == 13);
+	cl_assert(git_diff_stats_deletions(stats) == 13);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__rename_and_modifiy_no_find(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file2.txt.renamed2 | 2 +-\n"
+	" file3.txt.renamed  | 7 +++++++\n"
+	" file3.txt.renamed2 | 7 -------\n"
+	" 3 files changed, 8 insertions(+), 8 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "4ca10087e696d2ba78d07b146a118e9a7096ed4f");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 3);
+	cl_assert(git_diff_stats_insertions(stats) == 8);
+	cl_assert(git_diff_stats_deletions(stats) == 8);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__binary(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	/* TODO: Actually 0 bytes here should be 5!. Seems like we don't load the new content for binary files? */
+	const char *stat =
+	" binary.bin | Bin 3 -> 0 bytes\n"
+	" 1 file changed, 0 insertions(+), 0 deletions(-)\n";
+
+	git_oid_fromstr(&oid, "8d7523f6fcb2404257889abe0d96f093d9f524f9");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+	cl_assert(git_diff_stats_files_changed(stats) == 1);
+	cl_assert(git_diff_stats_insertions(stats) == 0);
+	cl_assert(git_diff_stats_deletions(stats) == 0);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__binary_numstat(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	"-       -       binary.bin\n";
+
+	git_oid_fromstr(&oid, "8d7523f6fcb2404257889abe0d96f093d9f524f9");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_NUMBER));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_stats__mode_change(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_stats *stats = NULL;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *stat =
+	" file1.txt.renamed | 0\n" \
+	" 1 file changed, 0 insertions(+), 0 deletions(-)\n" \
+	" mode change 100644 => 100755 file1.txt.renamed\n" \
+	"\n";
+
+	git_oid_fromstr(&oid, "7ade76dd34bba4733cf9878079f9fd4a456a9189");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+
+	cl_git_pass(git_diff_get_stats(&stats, diff));
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+
+	git_diff_stats_free(stats);
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
-- 
cgit v1.2.3


From d8cc1fb653387d9acc28b075147084cf452c43dc Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 11 Apr 2014 19:15:15 +0200
Subject: Introduce git_diff_format_email and git_diff_commit_as_email

---
 include/git2/diff.h       |  88 +++++++++
 src/diff.c                | 204 +++++++++++++++++++++
 src/diff.h                |   3 +
 tests/diff/format_email.c | 445 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 740 insertions(+)
 create mode 100644 tests/diff/format_email.c

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 571f0c887..a0cfbc918 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -1158,6 +1158,94 @@ GIT_EXTERN(int) git_diff_stats_to_buf(
  */
 GIT_EXTERN(void) git_diff_stats_free(git_diff_stats *stats);
 
+/**
+ * Formatting options for diff e-mail generation
+ */
+typedef enum {
+	/** Normal patch, the default */
+	GIT_DIFF_FORMAT_EMAIL_NONE = 0,
+
+	/** Don't insert "[PATCH]" in the subject header*/
+	GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER = (1 << 0),
+
+} git_diff_format_email_flags_t;
+
+/**
+ * Options for controlling the formatting of the generated e-mail.
+ */
+typedef struct {
+	unsigned int version;
+
+	git_diff_format_email_flags_t flags;
+
+	/** This patch number */
+	size_t patch_no;
+
+	/** Total number of patches in this series */
+	size_t total_patches;
+
+	/** id to use for the commit */
+	const git_oid *id;
+
+	/** Summary of the change */
+	const char *summary;
+
+	/** Author of the change */
+	const git_signature *author;
+} git_diff_format_email_options;
+
+#define GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION 1
+#define GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT {GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION, 0, 1, 1, NULL, NULL, NULL}
+
+/**
+ * Create an e-mail ready patch from a diff.
+ *
+ * @param out buffer to store the e-mail patch in
+ * @param diff containing the commit
+ * @param opts structure with options to influence content and formatting.
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_diff_format_email(
+	git_buf *out,
+	git_diff *diff,
+	const git_diff_format_email_options *opts);
+
+/**
+ * Create an e-mail ready patch for a commit.
+ *
+ * Does not support creating patches for merge commits (yet).
+ *
+ * @param out buffer to store the e-mail patch in
+ * @param repo containing the commit
+ * @param commit pointer to up commit
+ * @param patch_no patch number of the commit
+ * @param total_patches total number of patches in the patch set
+ * @param flags determines the formatting of the e-mail
+ * @param diff_opts structure with options to influence diff or NULL for defaults.
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_diff_commit_as_email(
+	git_buf *out,
+	git_repository *repo,
+	git_commit *commit,
+	size_t patch_no,
+	size_t total_patches,
+	git_diff_format_email_flags_t flags,
+	const git_diff_options *diff_opts);
+
+/**
+* Initializes a `git_diff_format_email_options` with default values. Equivalent to
+* creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
+*
+* @param opts the `git_diff_format_email_options` instance to initialize.
+* @param version the version of the struct; you should pass
+* `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION` here.
+* @return Zero on success; -1 on failure.
+*/
+GIT_EXTERN(int) git_diff_format_email_init_options(
+	git_diff_format_email_options *opts,
+	int version);
+
 GIT_END_DECL
 
 /** @} */
diff --git a/src/diff.c b/src/diff.c
index e62f45c22..ba3cd26b5 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -1427,6 +1427,198 @@ int git_diff__paired_foreach(
 	return error;
 }
 
+int git_diff__commit(
+	git_diff **diff,
+	git_repository *repo,
+	const git_commit *commit,
+	const git_diff_options *opts)
+{
+	git_commit *parent = NULL;
+	git_diff *commit_diff = NULL;
+	git_tree *old_tree = NULL, *new_tree = NULL;
+	size_t parents;
+	int error = 0;
+
+	if ((parents = git_commit_parentcount(commit)) > 1) {
+		char commit_oidstr[GIT_OID_HEXSZ + 1];
+
+		error = -1;
+		giterr_set(GITERR_INVALID, "Commit %s is a merge commit",
+			git_oid_tostr(commit_oidstr, GIT_OID_HEXSZ + 1, git_commit_id(commit)));
+		goto on_error;
+	}
+
+	if (parents > 0)
+		if ((error = git_commit_parent(&parent, commit, 0)) < 0 ||
+			(error = git_commit_tree(&old_tree, parent)) < 0)
+				goto on_error;
+
+	if ((error = git_commit_tree(&new_tree, commit)) < 0 ||
+		(error = git_diff_tree_to_tree(&commit_diff, repo, old_tree, new_tree, opts)) < 0)
+			goto on_error;
+
+	*diff = commit_diff;
+
+on_error:
+	git_tree_free(new_tree);
+	git_tree_free(old_tree);
+	git_commit_free(parent);
+
+	return error;
+}
+
+int git_diff_format_email__append_header_tobuf(
+	git_buf *out,
+	const git_oid *id,
+	const git_signature *author,
+	const char *summary,
+	size_t patch_no,
+	size_t total_patches,
+	bool exclude_patchno_marker)
+{
+	char idstr[GIT_OID_HEXSZ + 1];
+	char date_str[GIT_DATE_RFC2822_SZ];
+	int error = 0;
+
+	git_oid_fmt(idstr, id);
+	idstr[GIT_OID_HEXSZ] = '\0';
+
+	if ((error = git__date_rfc2822_fmt(date_str, sizeof(date_str), &author->when)) < 0)
+		return error;
+
+	error = git_buf_printf(out,
+				"From %s Mon Sep 17 00:00:00 2001\n" \
+				"From: %s <%s>\n" \
+				"Date: %s\n" \
+				"Subject: ",
+				idstr,
+				author->name, author->email,
+				date_str);
+
+	if (error < 0)
+		return error;
+
+	if (!exclude_patchno_marker) {
+		if (total_patches == 1) {
+			error = git_buf_puts(out, "[PATCH] ");
+		} else {
+			error = git_buf_printf(out, "[PATCH %"PRIuZ"/%"PRIuZ"] ", patch_no, total_patches);
+		}
+
+		if (error < 0)
+			return error;
+	}
+
+	error = git_buf_printf(out, "%s\n\n", summary);
+
+	return error;
+}
+
+int git_diff_format_email__append_patches_tobuf(
+	git_buf *out,
+	git_diff *diff)
+{
+	size_t i, deltas;
+	int error = 0;
+
+	deltas = git_diff_num_deltas(diff);
+
+	for (i = 0; i < deltas; ++i) {
+		git_patch *patch = NULL;
+
+		if ((error = git_patch_from_diff(&patch, diff, i)) >= 0)
+			error = git_patch_to_buf(out, patch);
+
+		git_patch_free(patch);
+
+		if (error < 0)
+			break;
+	}
+
+	return error;
+}
+
+int git_diff_format_email(
+	git_buf *out,
+	git_diff *diff,
+	const git_diff_format_email_options *opts)
+{
+	git_diff_stats *stats = NULL;
+	bool ignore_marker;
+	unsigned int format_flags = 0;
+	int error;
+
+	assert(out && diff && opts);
+	assert(opts->summary && opts->id && opts->author);
+
+	GITERR_CHECK_VERSION(opts, GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION, "git_format_email_options");
+
+	if ((ignore_marker = opts->flags & GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER) == false) {
+		if (opts->patch_no > opts->total_patches) {
+			giterr_set(GITERR_INVALID, "patch %"PRIuZ" out of range. max %"PRIuZ, opts->patch_no, opts->total_patches);
+			return -1;
+		}
+
+		if (opts->patch_no == 0) {
+			giterr_set(GITERR_INVALID, "invalid patch no %"PRIuZ". should be >0", opts->patch_no);
+			return -1;
+		}
+	}
+
+	error = git_diff_format_email__append_header_tobuf(out,
+				opts->id, opts->author, opts->summary,
+				opts->patch_no, opts->total_patches, ignore_marker);
+
+	if (error < 0)
+		goto on_error;
+
+	format_flags = GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY;
+
+	if ((error = git_buf_puts(out, "---\n")) < 0 ||
+		(error = git_diff_get_stats(&stats, diff)) < 0 ||
+		(error = git_diff_stats_to_buf(out, stats, format_flags)) < 0 ||
+		(error = git_diff_format_email__append_patches_tobuf(out, diff)) < 0)
+			goto on_error;
+
+	error = git_buf_puts(out, "--\nlibgit2 " LIBGIT2_VERSION "\n\n");
+
+on_error:
+	git_diff_stats_free(stats);
+
+	return error;
+}
+
+int git_diff_commit_as_email(
+	git_buf *out,
+	git_repository *repo,
+	git_commit *commit,
+	size_t patch_no,
+	size_t total_patches,
+	git_diff_format_email_flags_t flags,
+	const git_diff_options *diff_opts)
+{
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	int error;
+
+	assert (out && repo && commit);
+
+	opts.flags = flags;
+	opts.patch_no = patch_no;
+	opts.total_patches = total_patches;
+	opts.id = git_commit_id(commit);
+	opts.summary = git_commit_summary(commit);
+	opts.author = git_commit_author(commit);
+
+	if ((error = git_diff__commit(&diff, repo, commit, diff_opts)) < 0)
+		return error;
+
+	error = git_diff_format_email(out, diff, &opts);
+
+	git_diff_free(diff);
+	return error;
+}
+
 int git_diff_init_options(git_diff_options* opts, int version)
 {
 	if (version != GIT_DIFF_OPTIONS_VERSION) {
@@ -1450,3 +1642,15 @@ int git_diff_find_init_options(git_diff_find_options* opts, int version)
 		return 0;
 	}
 }
+
+int git_diff_format_email_init_options(git_diff_format_email_options* opts, int version)
+{
+	if (version != GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_format_email_options", version);
+		return -1;
+	} else {
+		git_diff_format_email_options o = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+		memcpy(opts, &o, sizeof(o));
+		return 0;
+	}
+}
diff --git a/src/diff.h b/src/diff.h
index c588f6301..aae8fbff1 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -116,6 +116,9 @@ extern void git_diff_find_similar__hashsig_free(void *sig, void *payload);
 extern int git_diff_find_similar__calc_similarity(
 	int *score, void *siga, void *sigb, void *payload);
 
+extern int git_diff__commit(
+	git_diff **diff, git_repository *repo, const git_commit *commit, const git_diff_options *opts);
+
 /*
  * Sometimes a git_diff_file will have a zero size; this attempts to
  * fill in the size without loading the blob if possible.  If that is
diff --git a/tests/diff/format_email.c b/tests/diff/format_email.c
new file mode 100644
index 000000000..ff0209e6f
--- /dev/null
+++ b/tests/diff/format_email.c
@@ -0,0 +1,445 @@
+#include "clar.h"
+#include "clar_libgit2.h"
+
+#include "buffer.h"
+#include "commit.h"
+#include "diff.h"
+
+static git_repository *repo;
+
+void test_diff_format_email__initialize(void)
+{
+	repo = cl_git_sandbox_init("diff_format_email");
+}
+
+void test_diff_format_email__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_diff_format_email__simple(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *email = 
+	"From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \
+	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
+	"Date: Wed, 9 Apr 2014 20:57:01 +0200\n" \
+	"Subject: [PATCH] Modify some content\n" \
+	"\n" \
+	"---\n" \
+	" file1.txt | 8 +++++---\n" \
+	" 1 file changed, 5 insertions(+), 3 deletions(-)\n" \
+	"\n" \
+	"diff --git a/file1.txt b/file1.txt\n" \
+	"index 94aaae8..af8f41d 100644\n" \
+	"--- a/file1.txt\n" \
+	"+++ b/file1.txt\n" \
+	"@@ -1,15 +1,17 @@\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"+_file1.txt_\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"+\n" \
+	"+\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"+_file1.txt_\n" \
+	"+_file1.txt_\n" \
+	" file1.txt\n" \
+	"--\n" \
+	"libgit2 " LIBGIT2_VERSION "\n" \
+	"\n";
+
+	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = git_commit_summary(commit);
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_buf_clear(&buf);
+	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1, 0, NULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_format_email__multiple(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *email = 
+	"From 10808fe9c9be5a190c0ba68d1a002233fb363508 Mon Sep 17 00:00:00 2001\n" \
+	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
+	"Date: Thu, 10 Apr 2014 19:37:05 +0200\n" \
+	"Subject: [PATCH 1/2] Added file2.txt file3.txt\n" \
+	"\n" \
+	"---\n" \
+	" file2.txt | 5 +++++\n" \
+	" file3.txt | 5 +++++\n" \
+	" 2 files changed, 10 insertions(+), 0 deletions(-)\n" \
+	" create mode 100644 file2.txt\n" \
+	" create mode 100644 file3.txt\n" \
+	"\n" \
+	"diff --git a/file2.txt b/file2.txt\n" \
+	"new file mode 100644\n" \
+	"index 0000000..e909123\n" \
+	"--- /dev/null\n" \
+	"+++ b/file2.txt\n" \
+	"@@ -0,0 +1,5 @@\n" \
+	"+file2\n" \
+	"+file2\n" \
+	"+file2\n" \
+	"+file2\n" \
+	"+file2\n" \
+	"diff --git a/file3.txt b/file3.txt\n" \
+	"new file mode 100644\n" \
+	"index 0000000..9435022\n" \
+	"--- /dev/null\n" \
+	"+++ b/file3.txt\n" \
+	"@@ -0,0 +1,5 @@\n" \
+	"+file3\n" \
+	"+file3\n" \
+	"+file3\n" \
+	"+file3\n" \
+	"+file3\n" \
+	"--\n" \
+	"libgit2 " LIBGIT2_VERSION "\n" \
+	"\n" \
+	"From 873806f6f27e631eb0b23e4b56bea2bfac14a373 Mon Sep 17 00:00:00 2001\n" \
+	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
+	"Date: Thu, 10 Apr 2014 19:37:36 +0200\n" \
+	"Subject: [PATCH 2/2] Modified file2.txt, file3.txt\n" \
+	"\n" \
+	"---\n" \
+	" file2.txt | 2 +-\n" \
+	" file3.txt | 2 +-\n" \
+	" 2 files changed, 2 insertions(+), 2 deletions(-)\n" \
+	"\n" \
+	"diff --git a/file2.txt b/file2.txt\n" \
+	"index e909123..7aff11d 100644\n" \
+	"--- a/file2.txt\n" \
+	"+++ b/file2.txt\n" \
+	"@@ -1,5 +1,5 @@\n" \
+	" file2\n" \
+	" file2\n" \
+	" file2\n" \
+	"-file2\n" \
+	"+file2!\n" \
+	" file2\n" \
+	"diff --git a/file3.txt b/file3.txt\n" \
+	"index 9435022..9a2d780 100644\n" \
+	"--- a/file3.txt\n" \
+	"+++ b/file3.txt\n" \
+	"@@ -1,5 +1,5 @@\n" \
+	" file3\n" \
+	"-file3\n" \
+	"+file3!\n" \
+	" file3\n" \
+	" file3\n" \
+	" file3\n" \
+	"--\n" \
+	"libgit2 " LIBGIT2_VERSION "\n" \
+	"\n";
+
+	git_oid_fromstr(&oid, "10808fe9c9be5a190c0ba68d1a002233fb363508");
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = git_commit_summary(commit);
+	opts.patch_no = 1;
+	opts.total_patches = 2;
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	diff = NULL;
+	commit = NULL;
+
+	git_oid_fromstr(&oid, "873806f6f27e631eb0b23e4b56bea2bfac14a373");
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = git_commit_summary(commit);
+	opts.patch_no = 2;
+	opts.total_patches = 2;
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
+
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_format_email__exclude_marker(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *email = 
+	"From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \
+	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
+	"Date: Wed, 9 Apr 2014 20:57:01 +0200\n" \
+	"Subject: Modify some content\n" \
+	"\n" \
+	"---\n" \
+	" file1.txt | 8 +++++---\n" \
+	" 1 file changed, 5 insertions(+), 3 deletions(-)\n" \
+	"\n" \
+	"diff --git a/file1.txt b/file1.txt\n" \
+	"index 94aaae8..af8f41d 100644\n" \
+	"--- a/file1.txt\n" \
+	"+++ b/file1.txt\n" \
+	"@@ -1,15 +1,17 @@\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"+_file1.txt_\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"+\n" \
+	"+\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"+_file1.txt_\n" \
+	"+_file1.txt_\n" \
+	" file1.txt\n" \
+	"--\n" \
+	"libgit2 " LIBGIT2_VERSION "\n" \
+	"\n";
+
+	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = git_commit_summary(commit);
+
+	opts.flags |= GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER;
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_buf_clear(&buf);
+	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1,
+		GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER, NULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_format_email__invalid_no(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = git_commit_summary(commit);
+	opts.patch_no = 2;
+	opts.total_patches = 1;
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_fail(git_diff_format_email(&buf, diff, &opts));
+	cl_git_fail(git_diff_commit_as_email(&buf, repo, commit, 2, 1, 0, NULL));
+	cl_git_fail(git_diff_commit_as_email(&buf, repo, commit, 0, 0, 0, NULL));
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_format_email__mode_change(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *email = 
+	"From 7ade76dd34bba4733cf9878079f9fd4a456a9189 Mon Sep 17 00:00:00 2001\n" \
+	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
+	"Date: Thu, 10 Apr 2014 10:05:03 +0200\n" \
+	"Subject: [PATCH] Update permissions\n" \
+	"\n" \
+	"---\n" \
+	" file1.txt.renamed | 0\n" \
+	" 1 file changed, 0 insertions(+), 0 deletions(-)\n" \
+	" mode change 100644 => 100755 file1.txt.renamed\n" \
+	"\n" \
+	"diff --git a/file1.txt.renamed b/file1.txt.renamed\n" \
+	"old mode 100644\n" \
+	"new mode 100755\n" \
+	"index a97157a..a97157a\n" \
+	"--- a/file1.txt.renamed\n" \
+	"+++ b/file1.txt.renamed\n" \
+	"--\n" \
+	"libgit2 " LIBGIT2_VERSION "\n" \
+	"\n";
+
+	git_oid_fromstr(&oid, "7ade76dd34bba4733cf9878079f9fd4a456a9189");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = git_commit_summary(commit);
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_buf_clear(&buf);
+	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1, 0, NULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_format_email__rename_add_remove(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *email = 
+	"From 6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d Mon Sep 17 00:00:00 2001\n" \
+	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
+	"Date: Wed, 9 Apr 2014 21:15:56 +0200\n" \
+	"Subject: [PATCH] Renamed file1.txt -> file1.txt.renamed\n" \
+	"\n" \
+	"---\n" \
+	" file1.txt         | 17 -----------------\n" \
+	" file1.txt.renamed | 17 +++++++++++++++++\n" \
+	" 2 files changed, 17 insertions(+), 17 deletions(-)\n" \
+	" delete mode 100644 file1.txt\n" \
+	" create mode 100644 file1.txt.renamed\n" \
+	"\n" \
+	"diff --git a/file1.txt b/file1.txt\n" \
+	"deleted file mode 100644\n" \
+	"index af8f41d..0000000\n" \
+	"--- a/file1.txt\n" \
+	"+++ /dev/null\n" \
+	"@@ -1,17 +0,0 @@\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-_file1.txt_\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-\n" \
+	"-\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-_file1.txt_\n" \
+	"-_file1.txt_\n" \
+	"-file1.txt\n" \
+	"diff --git a/file1.txt.renamed b/file1.txt.renamed\n" \
+	"new file mode 100644\n" \
+	"index 0000000..a97157a\n" \
+	"--- /dev/null\n" \
+	"+++ b/file1.txt.renamed\n" \
+	"@@ -0,0 +1,17 @@\n" \
+	"+file1.txt\n" \
+	"+file1.txt\n" \
+	"+_file1.txt_\n" \
+	"+file1.txt\n" \
+	"+file1.txt\n" \
+	"+file1.txt_renamed\n" \
+	"+file1.txt\n" \
+	"+\n" \
+	"+\n" \
+	"+file1.txt\n" \
+	"+file1.txt\n" \
+	"+file1.txt_renamed\n" \
+	"+file1.txt\n" \
+	"+file1.txt\n" \
+	"+_file1.txt_\n" \
+	"+_file1.txt_\n" \
+	"+file1.txt\n" \
+	"--\n" \
+	"libgit2 " LIBGIT2_VERSION "\n" \
+	"\n";
+
+	git_oid_fromstr(&oid, "6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = git_commit_summary(commit);
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_buf_clear(&buf);
+	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1, 0, NULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
-- 
cgit v1.2.3


From a56b418d8541e04f02be1227772b13762bfebaed Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 11 Apr 2014 22:57:15 +0200
Subject: Sanitize git_diff_format_email_options' summary parameter

It will form part of the subject line and should thus be one line.
---
 src/diff.c                | 20 +++++++++++++-
 tests/diff/format_email.c | 68 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/src/diff.c b/src/diff.c
index ba3cd26b5..cb05a5faf 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -1544,6 +1544,7 @@ int git_diff_format_email(
 	const git_diff_format_email_options *opts)
 {
 	git_diff_stats *stats = NULL;
+	char *summary = NULL, *loc = NULL;
 	bool ignore_marker;
 	unsigned int format_flags = 0;
 	int error;
@@ -1565,8 +1566,24 @@ int git_diff_format_email(
 		}
 	}
 
+	/* the summary we receive may not be clean.
+	 * it could potentially contain new line characters
+	 * or not be set, sanitize, */
+	if ((loc = strpbrk(opts->summary, "\r\n")) != NULL) {
+		size_t offset = 0;
+
+		if ((offset = (loc - opts->summary)) == 0) {
+			giterr_set(GITERR_INVALID, "summary is empty");
+			error = -1;
+		}
+
+		summary = git__calloc(offset + 1, sizeof(char));
+		GITERR_CHECK_ALLOC(summary);
+		strncpy(summary, opts->summary, offset);
+	}
+
 	error = git_diff_format_email__append_header_tobuf(out,
-				opts->id, opts->author, opts->summary,
+				opts->id, opts->author, summary == NULL ? opts->summary : summary,
 				opts->patch_no, opts->total_patches, ignore_marker);
 
 	if (error < 0)
@@ -1583,6 +1600,7 @@ int git_diff_format_email(
 	error = git_buf_puts(out, "--\nlibgit2 " LIBGIT2_VERSION "\n\n");
 
 on_error:
+	git__free(summary);
 	git_diff_stats_free(stats);
 
 	return error;
diff --git a/tests/diff/format_email.c b/tests/diff/format_email.c
index ff0209e6f..dbd41552f 100644
--- a/tests/diff/format_email.c
+++ b/tests/diff/format_email.c
@@ -443,3 +443,71 @@ void test_diff_format_email__rename_add_remove(void)
 	git_buf_free(&buf);
 }
 
+void test_diff_format_email__multiline_summary(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	const char *email =
+	"From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \
+	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
+	"Date: Wed, 9 Apr 2014 20:57:01 +0200\n" \
+	"Subject: [PATCH] Modify some content\n" \
+	"\n" \
+	"---\n" \
+	" file1.txt | 8 +++++---\n" \
+	" 1 file changed, 5 insertions(+), 3 deletions(-)\n" \
+	"\n" \
+	"diff --git a/file1.txt b/file1.txt\n" \
+	"index 94aaae8..af8f41d 100644\n" \
+	"--- a/file1.txt\n" \
+	"+++ b/file1.txt\n" \
+	"@@ -1,15 +1,17 @@\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"+_file1.txt_\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"+\n" \
+	"+\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	" file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"-file1.txt\n" \
+	"+_file1.txt_\n" \
+	"+_file1.txt_\n" \
+	" file1.txt\n" \
+	"--\n" \
+	"libgit2 " LIBGIT2_VERSION "\n" \
+	"\n";
+
+	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = "Modify some content\nSome extra stuff here";
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_buf_clear(&buf);
+	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1, 0, NULL));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
-- 
cgit v1.2.3


From 39206ca256409edb7102edf0d30a6ced2e5f16e3 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 14 Apr 2014 17:12:56 +0200
Subject: Added a test case for formatting a binary patch e-mail

---
 tests/diff/format_email.c | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/tests/diff/format_email.c b/tests/diff/format_email.c
index dbd41552f..3260fdea8 100644
--- a/tests/diff/format_email.c
+++ b/tests/diff/format_email.c
@@ -511,3 +511,46 @@ void test_diff_format_email__multiline_summary(void)
 	git_buf_free(&buf);
 }
 
+void test_diff_format_email__binary(void)
+{
+	git_oid oid;
+	git_commit *commit = NULL;
+	git_diff *diff = NULL;
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	git_buf buf = GIT_BUF_INIT;
+
+	/* TODO: Actually 0 bytes here should be 5!. Seems like we don't load the new content for binary files? */
+	const char *email =
+	"From 8d7523f6fcb2404257889abe0d96f093d9f524f9 Mon Sep 17 00:00:00 2001\n" \
+	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
+	"Date: Sun, 13 Apr 2014 18:10:18 +0200\n" \
+	"Subject: [PATCH] Modified binary file\n" \
+	"\n" \
+	"---\n" \
+	" binary.bin | Bin 3 -> 0 bytes\n" \
+	" 1 file changed, 0 insertions(+), 0 deletions(-)\n" \
+	"\n" \
+	"diff --git a/binary.bin b/binary.bin\n" \
+	"index bd474b2..9ac35ff 100644\n" \
+	"Binary files a/binary.bin and b/binary.bin differ\n" \
+	"--\n" \
+	"libgit2 " LIBGIT2_VERSION "\n" \
+	"\n";
+
+	git_oid_fromstr(&oid, "8d7523f6fcb2404257889abe0d96f093d9f524f9");
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts.id = git_commit_id(commit);
+	opts.author = git_commit_author(commit);
+	opts.summary = "Modified binary file";
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
+	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
-- 
cgit v1.2.3


From fa13ee2d7cfadf0b1d425708657d93aeae728f46 Mon Sep 17 00:00:00 2001
From: Sven Strickroth <email@cs-ware.de>
Date: Wed, 16 Apr 2014 16:59:43 +0200
Subject: Add GIT_BRANCH_ALL to git_branch_t enum

git_branch_t is an enum so requesting GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE is not possible as it is not a member of the enum (at least VS2013 C++ complains about it).

This fixes a regression introduced in commit a667ca8298193b3103c1dbdcb1f6c527e6e99eb2 (PR #1946).

Signed-off-by: Sven Strickroth <email@cs-ware.de>
---
 include/git2/branch.h          | 2 +-
 include/git2/types.h           | 1 +
 tests/refs/branches/iterator.c | 4 ++--
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/include/git2/branch.h b/include/git2/branch.h
index ad2a70b1f..f28410000 100644
--- a/include/git2/branch.h
+++ b/include/git2/branch.h
@@ -84,7 +84,7 @@ typedef struct git_branch_iterator git_branch_iterator;
  * @param repo Repository where to find the branches.
  * @param list_flags Filtering flags for the branch
  * listing. Valid values are GIT_BRANCH_LOCAL, GIT_BRANCH_REMOTE
- * or a combination of the two.
+ * or GIT_BRANCH_ALL.
  *
  * @return 0 on success  or an error code
  */
diff --git a/include/git2/types.h b/include/git2/types.h
index 2229f6bf4..9db59b16b 100644
--- a/include/git2/types.h
+++ b/include/git2/types.h
@@ -193,6 +193,7 @@ typedef enum {
 typedef enum {
 	GIT_BRANCH_LOCAL = 1,
 	GIT_BRANCH_REMOTE = 2,
+	GIT_BRANCH_ALL = GIT_BRANCH_LOCAL|GIT_BRANCH_REMOTE,
 } git_branch_t;
 
 /** Valid modes for index and tree entries. */
diff --git a/tests/refs/branches/iterator.c b/tests/refs/branches/iterator.c
index 29ca59aca..76b35a7d6 100644
--- a/tests/refs/branches/iterator.c
+++ b/tests/refs/branches/iterator.c
@@ -48,7 +48,7 @@ static void assert_retrieval(unsigned int flags, unsigned int expected_count)
 
 void test_refs_branches_iterator__retrieve_all_branches(void)
 {
-	assert_retrieval(GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE, 14);
+	assert_retrieval(GIT_BRANCH_ALL, 14);
 }
 
 void test_refs_branches_iterator__retrieve_remote_branches(void)
@@ -139,7 +139,7 @@ void test_refs_branches_iterator__mix_of_packed_and_loose(void)
 
 	r2 = cl_git_sandbox_init("testrepo2");
 
-	cl_git_pass(git_branch_iterator_new(&iter, r2, GIT_BRANCH_LOCAL | GIT_BRANCH_REMOTE));
+	cl_git_pass(git_branch_iterator_new(&iter, r2, GIT_BRANCH_ALL));
 	contains_branches(exp, iter);
 
 	git_branch_iterator_free(iter);
-- 
cgit v1.2.3


From c67fd4c9d5e1ff715df28b884d7f7f9f20fad1ec Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 7 Feb 2014 11:20:36 -0800
Subject: Some vector utility tweaks

This is just laying some groundwork for internal index changes
that I'm working on.
---
 src/checkout.c      |  8 ++++++--
 src/index.c         |  7 +++++--
 src/merge.c         |  6 ++++--
 src/vector.c        | 21 +++++++++++++++++++--
 src/vector.h        |  8 +++++++-
 tests/core/vector.c | 15 ++++++++-------
 tests/index/tests.c | 20 +++-----------------
 7 files changed, 52 insertions(+), 33 deletions(-)

diff --git a/src/checkout.c b/src/checkout.c
index 141fc1331..f9bc5e9d8 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -653,10 +653,13 @@ static int checkout_conflictdata_cmp(const void *a, const void *b)
 	return diff;
 }
 
-int checkout_conflictdata_empty(const git_vector *conflicts, size_t idx)
+int checkout_conflictdata_empty(
+	const git_vector *conflicts, size_t idx, void *payload)
 {
 	checkout_conflictdata *conflict;
 
+	GIT_UNUSED(payload);
+
 	if ((conflict = git_vector_get(conflicts, idx)) == NULL)
 		return -1;
 
@@ -954,7 +957,8 @@ static int checkout_conflicts_coalesce_renames(
 			ancestor_conflict->one_to_two = 1;
 	}
 
-	git_vector_remove_matching(&data->conflicts, checkout_conflictdata_empty);
+	git_vector_remove_matching(
+		&data->conflicts, checkout_conflictdata_empty, NULL);
 
 done:
 	return error;
diff --git a/src/index.c b/src/index.c
index b0b5eae9d..08c4b79b6 100644
--- a/src/index.c
+++ b/src/index.c
@@ -1228,10 +1228,13 @@ int git_index_conflict_remove(git_index *index, const char *path)
 	return 0;
 }
 
-static int index_conflicts_match(const git_vector *v, size_t idx)
+static int index_conflicts_match(const git_vector *v, size_t idx, void *p)
 {
+	git_index *index = p;
 	git_index_entry *entry = git_vector_get(v, idx);
 
+	GIT_UNUSED(index);
+
 	if (GIT_IDXENTRY_STAGE(entry) > 0) {
 		index_entry_free(entry);
 		return 1;
@@ -1243,7 +1246,7 @@ static int index_conflicts_match(const git_vector *v, size_t idx)
 void git_index_conflict_cleanup(git_index *index)
 {
 	assert(index);
-	git_vector_remove_matching(&index->entries, index_conflicts_match);
+	git_vector_remove_matching(&index->entries, index_conflicts_match, index);
 }
 
 int git_index_has_conflicts(const git_index *index)
diff --git a/src/merge.c b/src/merge.c
index 10c19b5c5..9c4a07b58 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -995,10 +995,12 @@ static void merge_diff_list_coalesce_renames(
 	}
 }
 
-static int merge_diff_empty(const git_vector *conflicts, size_t idx)
+static int merge_diff_empty(const git_vector *conflicts, size_t idx, void *p)
 {
 	git_merge_diff *conflict = conflicts->contents[idx];
 
+	GIT_UNUSED(p);
+
 	return (!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->ancestor_entry) &&
 		!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry) &&
 		!GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry));
@@ -1079,7 +1081,7 @@ int git_merge_diff_list__find_renames(
 	merge_diff_list_coalesce_renames(diff_list, similarity_ours, similarity_theirs, opts);
 
 	/* And remove any entries that were merged and are now empty. */
-	git_vector_remove_matching(&diff_list->conflicts, merge_diff_empty);
+	git_vector_remove_matching(&diff_list->conflicts, merge_diff_empty, NULL);
 
 done:
 	if (cache != NULL) {
diff --git a/src/vector.c b/src/vector.c
index 37ea07f0b..9f7eed5a3 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -276,14 +276,16 @@ void git_vector_uniq(git_vector *v, void  (*git_free_cb)(void *))
 }
 
 void git_vector_remove_matching(
-	git_vector *v, int (*match)(const git_vector *v, size_t idx))
+	git_vector *v,
+	int (*match)(const git_vector *v, size_t idx, void *payload),
+	void *payload)
 {
 	size_t i, j;
 
 	for (i = 0, j = 0; j < v->length; ++j) {
 		v->contents[i] = v->contents[j];
 
-		if (!match(v, i))
+		if (!match(v, i, payload))
 			i++;
 	}
 
@@ -339,3 +341,18 @@ int git_vector_set(void **old, git_vector *v, size_t position, void *value)
 
 	return 0;
 }
+
+int git_vector_verify_sorted(const git_vector *v)
+{
+	size_t i;
+
+	if (!git_vector_is_sorted(v))
+		return -1;
+
+	for (i = 1; i < v->length; ++i) {
+		if (v->_cmp(v->contents[i - 1], v->contents[i]) > 0)
+			return -1;
+	}
+
+	return 0;
+}
diff --git a/src/vector.h b/src/vector.h
index 682b6ad27..aac46c4b3 100644
--- a/src/vector.h
+++ b/src/vector.h
@@ -85,8 +85,11 @@ int git_vector_insert_sorted(git_vector *v, void *element,
 int git_vector_remove(git_vector *v, size_t idx);
 void git_vector_pop(git_vector *v);
 void git_vector_uniq(git_vector *v, void  (*git_free_cb)(void *));
+
 void git_vector_remove_matching(
-	git_vector *v, int (*match)(const git_vector *v, size_t idx));
+	git_vector *v,
+	int (*match)(const git_vector *v, size_t idx, void *payload),
+	void *payload);
 
 int git_vector_resize_to(git_vector *v, size_t new_length);
 int git_vector_set(void **old, git_vector *v, size_t position, void *value);
@@ -108,4 +111,7 @@ GIT_INLINE(void) git_vector_set_cmp(git_vector *v, git_vector_cmp cmp)
 	}
 }
 
+/* Just use this in tests, not for realz. returns -1 if not sorted */
+int git_vector_verify_sorted(const git_vector *v);
+
 #endif
diff --git a/tests/core/vector.c b/tests/core/vector.c
index db52c004f..66f90b82b 100644
--- a/tests/core/vector.c
+++ b/tests/core/vector.c
@@ -190,8 +190,9 @@ void test_core_vector__5(void)
 	git_vector_free(&x);
 }
 
-static int remove_ones(const git_vector *v, size_t idx)
+static int remove_ones(const git_vector *v, size_t idx, void *p)
 {
+	GIT_UNUSED(p);
 	return (git_vector_get(v, idx) == (void *)0x001);
 }
 
@@ -206,7 +207,7 @@ void test_core_vector__remove_matching(void)
 	git_vector_insert(&x, (void*) 0x001);
 
 	cl_assert(x.length == 1);
-	git_vector_remove_matching(&x, remove_ones);
+	git_vector_remove_matching(&x, remove_ones, NULL);
 	cl_assert(x.length == 0);
 
 	git_vector_insert(&x, (void*) 0x001);
@@ -214,7 +215,7 @@ void test_core_vector__remove_matching(void)
 	git_vector_insert(&x, (void*) 0x001);
 
 	cl_assert(x.length == 3);
-	git_vector_remove_matching(&x, remove_ones);
+	git_vector_remove_matching(&x, remove_ones, NULL);
 	cl_assert(x.length == 0);
 
 	git_vector_insert(&x, (void*) 0x002);
@@ -223,7 +224,7 @@ void test_core_vector__remove_matching(void)
 	git_vector_insert(&x, (void*) 0x001);
 
 	cl_assert(x.length == 4);
-	git_vector_remove_matching(&x, remove_ones);
+	git_vector_remove_matching(&x, remove_ones, NULL);
 	cl_assert(x.length == 2);
 
 	git_vector_foreach(&x, i, compare) {
@@ -238,7 +239,7 @@ void test_core_vector__remove_matching(void)
 	git_vector_insert(&x, (void*) 0x001);
 
 	cl_assert(x.length == 4);
-	git_vector_remove_matching(&x, remove_ones);
+	git_vector_remove_matching(&x, remove_ones, NULL);
 	cl_assert(x.length == 2);
 
 	git_vector_foreach(&x, i, compare) {
@@ -253,7 +254,7 @@ void test_core_vector__remove_matching(void)
 	git_vector_insert(&x, (void*) 0x001);
 
 	cl_assert(x.length == 4);
-	git_vector_remove_matching(&x, remove_ones);
+	git_vector_remove_matching(&x, remove_ones, NULL);
 	cl_assert(x.length == 2);
 
 	git_vector_foreach(&x, i, compare) {
@@ -268,7 +269,7 @@ void test_core_vector__remove_matching(void)
 	git_vector_insert(&x, (void*) 0x003);
 
 	cl_assert(x.length == 4);
-	git_vector_remove_matching(&x, remove_ones);
+	git_vector_remove_matching(&x, remove_ones, NULL);
 	cl_assert(x.length == 4);
 
 	git_vector_free(&x);
diff --git a/tests/index/tests.c b/tests/index/tests.c
index 6e28af1f7..fa5c0bb1a 100644
--- a/tests/index/tests.c
+++ b/tests/index/tests.c
@@ -544,36 +544,22 @@ void test_index_tests__corrupted_extension(void)
 	cl_git_fail_with(git_index_open(&index, TEST_INDEXBAD_PATH), GIT_ERROR);
 }
 
-static void assert_index_is_sorted(git_index *index)
-{
-	git_vector *entries = &index->entries;
-	size_t i;
-
-	cl_assert(git_vector_is_sorted(entries));
-
-	for (i = 1; i < git_vector_length(entries); ++i) {
-		git_index_entry *prev = git_vector_get(entries, i - 1);
-		git_index_entry *curr = git_vector_get(entries, i);
-		cl_assert(index->entries._cmp(prev, curr) <= 0);
-	}
-}
-
 void test_index_tests__reload_while_ignoring_case(void)
 {
 	git_index *index;
 	unsigned int caps;
 
 	cl_git_pass(git_index_open(&index, TEST_INDEX_PATH));
-	assert_index_is_sorted(index);
+	cl_git_pass(git_vector_verify_sorted(&index->entries));
 
 	caps = git_index_caps(index);
 	cl_git_pass(git_index_set_caps(index, caps &= ~GIT_INDEXCAP_IGNORE_CASE));
 	cl_git_pass(git_index_read(index, true));
-	assert_index_is_sorted(index);
+	cl_git_pass(git_vector_verify_sorted(&index->entries));
 
 	cl_git_pass(git_index_set_caps(index, caps | GIT_INDEXCAP_IGNORE_CASE));
 	cl_git_pass(git_index_read(index, true));
-	assert_index_is_sorted(index);
+	cl_git_pass(git_vector_verify_sorted(&index->entries));
 
 	git_index_free(index);
 }
-- 
cgit v1.2.3


From 3dbee456564a9baf24631bfe219f81434d8fdfa6 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 7 Feb 2014 14:10:35 -0800
Subject: Some index internals refactoring

Again, laying groundwork for some index iterator changes, this
contains a bunch of code refactorings for index internals that
should make it easier down the line to add locking around index
modifications.  Also this removes the redundant prefix_position
function and fixes some potential memory leaks.
---
 include/git2/index.h |  15 ++-
 src/checkout.c       |  10 +-
 src/index.c          | 358 +++++++++++++++++++++++++++------------------------
 src/index.h          |   6 +-
 src/iterator.c       |   6 +-
 5 files changed, 219 insertions(+), 176 deletions(-)

diff --git a/include/git2/index.h b/include/git2/index.h
index dd6a28e40..4d33f13d2 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -77,7 +77,12 @@ typedef struct git_index_entry {
 #define GIT_IDXENTRY_VALID     (0x8000)
 #define GIT_IDXENTRY_STAGESHIFT 12
 
-#define GIT_IDXENTRY_STAGE(E) (((E)->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT)
+#define GIT_IDXENTRY_STAGE(E) \
+	(((E)->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT)
+
+#define GIT_IDXENTRY_STAGE_SET(E,S) do { \
+	(E)->flags = ((E)->flags & ~GIT_IDXENTRY_STAGEMASK) | \
+		(((S) & 0x03) << GIT_IDXENTRY_STAGESHIFT); } while (0)
 
 /**
  * Bitmasks for on-disk fields of `git_index_entry`'s `flags_extended`
@@ -327,12 +332,14 @@ GIT_EXTERN(size_t) git_index_entrycount(const git_index *index);
 
 /**
  * Clear the contents (all the entries) of an index object.
- * This clears the index object in memory; changes must be manually
- * written to disk for them to take effect.
+ *
+ * This clears the index object in memory; changes must be explicitly
+ * written to disk for them to take effect persistently.
  *
  * @param index an existing index object
+ * @return 0 on success, error code < 0 on failure
  */
-GIT_EXTERN(void) git_index_clear(git_index *index);
+GIT_EXTERN(int) git_index_clear(git_index *index);
 
 /**
  * Get a pointer to one of the entries in the index
diff --git a/src/checkout.c b/src/checkout.c
index f9bc5e9d8..a251c08c0 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -277,19 +277,23 @@ static int checkout_action_wd_only(
 
 	/* check if item is tracked in the index but not in the checkout diff */
 	if (data->index != NULL) {
+		size_t pos;
+
+		error = git_index__find(
+			&pos, data->index, wd->path, 0, GIT_INDEX_STAGE_ANY);
+
 		if (wd->mode != GIT_FILEMODE_TREE) {
-			if (!(error = git_index_find(NULL, data->index, wd->path))) {
+			if (!error) { /* found by git_index__find call */
 				notify = GIT_CHECKOUT_NOTIFY_DIRTY;
 				remove = ((data->strategy & GIT_CHECKOUT_FORCE) != 0);
 			} else if (error != GIT_ENOTFOUND)
 				return error;
 			else
-				giterr_clear();
+				error = 0; /* git_index__find does not set error msg */
 		} else {
 			/* for tree entries, we have to see if there are any index
 			 * entries that are contained inside that tree
 			 */
-			size_t pos = git_index__prefix_position(data->index, wd->path);
 			const git_index_entry *e = git_index_get_byindex(data->index, pos);
 
 			if (e != NULL && data->diff->pfxcomp(e->path, wd->path) == 0) {
diff --git a/src/index.c b/src/index.c
index 08c4b79b6..8bc5cb13c 100644
--- a/src/index.c
+++ b/src/index.c
@@ -345,7 +345,7 @@ void git_index__set_ignore_case(git_index *index, bool ignore_case)
 int git_index_open(git_index **index_out, const char *index_path)
 {
 	git_index *index;
-	int error;
+	int error = -1;
 
 	assert(index_out);
 
@@ -354,7 +354,8 @@ int git_index_open(git_index **index_out, const char *index_path)
 
 	if (index_path != NULL) {
 		index->index_file_path = git__strdup(index_path);
-		GITERR_CHECK_ALLOC(index->index_file_path);
+		if (!index->index_file_path)
+			goto fail;
 
 		/* Check if index file is stored on disk already */
 		if (git_path_exists(index->index_file_path) == true)
@@ -364,22 +365,24 @@ int git_index_open(git_index **index_out, const char *index_path)
 	if (git_vector_init(&index->entries, 32, index_cmp) < 0 ||
 		git_vector_init(&index->names, 32, conflict_name_cmp) < 0 ||
 		git_vector_init(&index->reuc, 32, reuc_cmp) < 0)
-		return -1;
+		goto fail;
 
 	index->entries_cmp_path = index_cmp_path;
 	index->entries_search = index_srch;
 	index->entries_search_path = index_srch_path;
 	index->reuc_search = reuc_srch;
 
-	if ((index_path != NULL) && ((error = git_index_read(index, true)) < 0)) {
-		git_index_free(index);
-		return error;
-	}
+	if (index_path != NULL && (error = git_index_read(index, true)) < 0)
+		goto fail;
 
 	*index_out = index;
 	GIT_REFCOUNT_INC(index);
 
 	return 0;
+
+fail:
+	git_index_free(index);
+	return error;
 }
 
 int git_index_new(git_index **out)
@@ -418,18 +421,20 @@ static void index_entries_free(git_vector *entries)
 	git_vector_clear(entries);
 }
 
-void git_index_clear(git_index *index)
+int git_index_clear(git_index *index)
 {
 	assert(index);
 
+	git_tree_cache_free(index->tree);
+	index->tree = NULL;
+
 	index_entries_free(&index->entries);
 	git_index_reuc_clear(index);
 	git_index_name_clear(index);
 
 	git_futils_filestamp_set(&index->stamp, NULL);
 
-	git_tree_cache_free(index->tree);
-	index->tree = NULL;
+	return 0;
 }
 
 static int create_index_error(int error, const char *msg)
@@ -495,7 +500,7 @@ int git_index_read(git_index *index, int force)
 
 	if (!index->on_disk) {
 		if (force)
-			git_index_clear(index);
+			return git_index_clear(index);
 		return 0;
 	}
 
@@ -507,8 +512,10 @@ int git_index_read(git_index *index, int force)
 	if (error < 0)
 		return error;
 
-	git_index_clear(index);
-	error = parse_index(index, buffer.ptr, buffer.size);
+	error = git_index_clear(index);
+
+	if (!error)
+		error = parse_index(index, buffer.ptr, buffer.size);
 
 	if (!error)
 		git_futils_filestamp_set(&index->stamp, &stamp);
@@ -679,12 +686,31 @@ static int index_entry_init(
 
 	entry->id = oid;
 	entry->path = git__strdup(rel_path);
-	GITERR_CHECK_ALLOC(entry->path);
+	if (!entry->path) {
+		git__free(entry);
+		return -1;
+	}
 
 	*entry_out = entry;
 	return 0;
 }
 
+static int index_remove_entry(git_index *index, size_t pos)
+{
+	int error = 0;
+	git_index_entry *entry = git_vector_get(&index->entries, pos);
+
+	if (entry != NULL)
+		git_tree_cache_invalidate_path(index->tree, entry->path);
+
+	error = git_vector_remove(&index->entries, pos);
+
+	if (!error)
+		index_entry_free(entry);
+
+	return error;
+}
+
 static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
 	const char *path,
 	int ancestor_mode, const git_oid *ancestor_oid,
@@ -701,8 +727,10 @@ static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
 	GITERR_CHECK_ALLOC(reuc);
 
 	reuc->path = git__strdup(path);
-	if (reuc->path == NULL)
+	if (reuc->path == NULL) {
+		git__free(reuc);
 		return -1;
+	}
 
 	if ((reuc->mode[0] = ancestor_mode) > 0)
 		git_oid_cpy(&reuc->oid[0], ancestor_oid);
@@ -717,22 +745,29 @@ static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
 	return 0;
 }
 
-static git_index_entry *index_entry_dup(const git_index_entry *source_entry)
+static int index_entry_dup(git_index_entry **out, const git_index_entry *src)
 {
 	git_index_entry *entry;
 
+	if (!src) {
+		*out = NULL;
+		return 0;
+	}
+
 	entry = git__malloc(sizeof(git_index_entry));
-	if (!entry)
-		return NULL;
+	GITERR_CHECK_ALLOC(entry);
 
-	memcpy(entry, source_entry, sizeof(git_index_entry));
+	memcpy(entry, src, sizeof(git_index_entry));
 
 	/* duplicate the path string so we own it */
 	entry->path = git__strdup(entry->path);
-	if (!entry->path)
-		return NULL;
+	if (!entry->path) {
+		git__free(entry);
+		return -1;
+	}
 
-	return entry;
+	*out = entry;
+	return 0;
 }
 
 static int has_file_name(git_index *index,
@@ -757,7 +792,9 @@ static int has_file_name(git_index *index,
 		retval = -1;
 		if (!ok_to_replace)
 			break;
-		git_vector_remove(&index->entries, --pos);
+
+		if (index_remove_entry(index, --pos) < 0)
+			break;
 	}
 	return retval;
 }
@@ -790,7 +827,8 @@ static int has_dir_name(git_index *index,
 			if (!ok_to_replace)
 				break;
 
-			git_vector_remove(&index->entries, position);
+			if (index_remove_entry(index, position) < 0)
+				break;
 			continue;
 		}
 
@@ -830,12 +868,22 @@ static int check_file_directory_collision(git_index *index,
 	return 0;
 }
 
-static int index_insert(git_index *index, git_index_entry *entry, int replace)
+/* index_insert takes ownership of the new entry - if it can't insert
+ * it, then it will return an error **and also free the entry**.  When
+ * it replaces an existing entry, it will update the entry_ptr with the
+ * actual entry in the index (and free the passed in one).
+ */
+static int index_insert(
+	git_index *index, git_index_entry **entry_ptr, int replace)
 {
+	int error = 0;
 	size_t path_length, position;
-	git_index_entry **existing = NULL;
+	git_index_entry *existing = NULL, *entry;
 
-	assert(index && entry && entry->path != NULL);
+	assert(index && entry_ptr);
+
+	entry = *entry_ptr;
+	assert(entry && entry->path);
 
 	/* make sure that the path length flag is correct */
 	path_length = strlen(entry->path);
@@ -850,27 +898,41 @@ static int index_insert(git_index *index, git_index_entry *entry, int replace)
 	/* look if an entry with this path already exists */
 	if (!git_index__find(
 			&position, index, entry->path, 0, GIT_IDXENTRY_STAGE(entry))) {
-		existing = (git_index_entry **)&index->entries.contents[position];
+		existing = index->entries.contents[position];
 		/* update filemode to existing values if stat is not trusted */
-		entry->mode = index_merge_mode(index, *existing, entry->mode);
+		entry->mode = index_merge_mode(index, existing, entry->mode);
 	}
 
-	if (check_file_directory_collision(index, entry, position, replace) < 0)
-		return -1;
+	error = check_file_directory_collision(index, entry, position, replace);
+	if (error < 0)
+		goto done;
+
+	/* if we are replacing an existing item, overwrite the existing entry
+	 * and return it in place of the passed in one.
+	 */
+	if (existing && replace) {
+		git__free(entry->path);
+		entry->path = existing->path;
+
+		memcpy(existing, entry, sizeof(*entry));
+		*entry_ptr = existing;
+
+		git__free(entry);
+		return 0;
+	}
 
 	/* if replacing is not requested or no existing entry exists, just
 	 * insert entry at the end; the index is no longer sorted
 	 */
-	if (!replace || !existing)
-		return git_vector_insert(&index->entries, entry);
+	error = git_vector_insert(&index->entries, entry);
 
-	/* exists, replace it (preserving name from existing entry) */
-	git__free(entry->path);
-	entry->path = (*existing)->path;
-	git__free(*existing);
-	*existing = entry;
+done:
+	if (error < 0) {
+		index_entry_free(*entry_ptr);
+		*entry_ptr = NULL;
+	}
 
-	return 0;
+	return error;
 }
 
 static int index_conflict_to_reuc(git_index *index, const char *path)
@@ -907,19 +969,15 @@ int git_index_add_bypath(git_index *index, const char *path)
 	assert(index && path);
 
 	if ((ret = index_entry_init(&entry, index, path)) < 0 ||
-		(ret = index_insert(index, entry, 1)) < 0)
-		goto on_error;
+		(ret = index_insert(index, &entry, 1)) < 0)
+		return ret;
 
 	/* Adding implies conflict was resolved, move conflict entries to REUC */
 	if ((ret = index_conflict_to_reuc(index, path)) < 0 && ret != GIT_ENOTFOUND)
-		goto on_error;
+		return ret;
 
 	git_tree_cache_invalidate_path(index->tree, entry->path);
 	return 0;
-
-on_error:
-	index_entry_free(entry);
-	return ret;
 }
 
 int git_index_remove_bypath(git_index *index, const char *path)
@@ -942,14 +1000,11 @@ int git_index_add(git_index *index, const git_index_entry *source_entry)
 	git_index_entry *entry = NULL;
 	int ret;
 
-	entry = index_entry_dup(source_entry);
-	if (entry == NULL)
-		return -1;
+	assert(index && source_entry);
 
-	if ((ret = index_insert(index, entry, 1)) < 0) {
-		index_entry_free(entry);
+	if ((ret = index_entry_dup(&entry, source_entry)) < 0 ||
+		(ret = index_insert(index, &entry, 1)) < 0)
 		return ret;
-	}
 
 	git_tree_cache_invalidate_path(index->tree, entry->path);
 	return 0;
@@ -958,8 +1013,6 @@ int git_index_add(git_index *index, const git_index_entry *source_entry)
 int git_index_remove(git_index *index, const char *path, int stage)
 {
 	size_t position;
-	int error;
-	git_index_entry *entry;
 
 	if (git_index__find(&position, index, path, 0, stage) < 0) {
 		giterr_set(GITERR_INDEX, "Index does not contain %s at stage %d",
@@ -967,16 +1020,7 @@ int git_index_remove(git_index *index, const char *path, int stage)
 		return GIT_ENOTFOUND;
 	}
 
-	entry = git_vector_get(&index->entries, position);
-	if (entry != NULL)
-		git_tree_cache_invalidate_path(index->tree, entry->path);
-
-	error = git_vector_remove(&index->entries, position);
-
-	if (!error)
-		index_entry_free(entry);
-
-	return error;
+	return index_remove_entry(index, position);
 }
 
 int git_index_remove_directory(git_index *index, const char *dir, int stage)
@@ -989,9 +1033,7 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 	if (git_buf_sets(&pfx, dir) < 0 || git_path_to_dir(&pfx) < 0)
 		return -1;
 
-	git_vector_sort(&index->entries);
-
-	pos = git_index__prefix_position(index, pfx.ptr);
+	git_index__find(&pos, index, pfx.ptr, pfx.size, GIT_INDEX_STAGE_ANY);
 
 	while (1) {
 		entry = git_vector_get(&index->entries, pos);
@@ -1003,11 +1045,8 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 			continue;
 		}
 
-		git_tree_cache_invalidate_path(index->tree, entry->path);
-
-		if ((error = git_vector_remove(&index->entries, pos)) < 0)
+		if ((error = index_remove_entry(index, pos)) < 0)
 			break;
-		index_entry_free(entry);
 
 		/* removed entry at 'pos' so we don't need to increment it */
 	}
@@ -1063,22 +1102,6 @@ int git_index_find(size_t *at_pos, git_index *index, const char *path)
 	return 0;
 }
 
-size_t git_index__prefix_position(git_index *index, const char *path)
-{
-	struct entry_srch_key srch_key;
-	size_t pos;
-
-	srch_key.path = path;
-	srch_key.path_len = strlen(path);
-	srch_key.stage = 0;
-
-	git_vector_sort(&index->entries);
-	git_vector_bsearch2(
-		&pos, &index->entries, index->entries_search, &srch_key);
-
-	return pos;
-}
-
 int git_index_conflict_add(git_index *index,
 	const git_index_entry *ancestor_entry,
 	const git_index_entry *our_entry,
@@ -1090,21 +1113,22 @@ int git_index_conflict_add(git_index *index,
 
 	assert (index);
 
-	if ((ancestor_entry != NULL && (entries[0] = index_entry_dup(ancestor_entry)) == NULL) ||
-		(our_entry != NULL && (entries[1] = index_entry_dup(our_entry)) == NULL) ||
-		(their_entry != NULL && (entries[2] = index_entry_dup(their_entry)) == NULL))
-		return -1;
+	if ((ret = index_entry_dup(&entries[0], ancestor_entry)) < 0 ||
+		(ret = index_entry_dup(&entries[1], our_entry)) < 0 ||
+		(ret = index_entry_dup(&entries[2], their_entry)) < 0)
+		goto on_error;
 
 	for (i = 0; i < 3; i++) {
 		if (entries[i] == NULL)
 			continue;
 
 		/* Make sure stage is correct */
-		entries[i]->flags = (entries[i]->flags & ~GIT_IDXENTRY_STAGEMASK) |
-			((i+1) << GIT_IDXENTRY_STAGESHIFT);
+		GIT_IDXENTRY_STAGE_SET(entries[i], i + 1);
 
-		if ((ret = index_insert(index, entries[i], 1)) < 0)
+		if ((ret = index_insert(index, &entries[i], 1)) < 0)
 			goto on_error;
+
+		entries[i] = NULL; /* don't free if later entry fails */
 	}
 
 	return 0;
@@ -1196,7 +1220,7 @@ int git_index_conflict_get(
 
 int git_index_conflict_remove(git_index *index, const char *path)
 {
-	size_t pos, posmax;
+	size_t pos;
 	git_index_entry *conflict_entry;
 	int error = 0;
 
@@ -1205,10 +1229,7 @@ int git_index_conflict_remove(git_index *index, const char *path)
 	if (git_index_find(&pos, index, path) < 0)
 		return GIT_ENOTFOUND;
 
-	posmax = git_index_entrycount(index);
-
-	while (pos < posmax) {
-		conflict_entry = git_vector_get(&index->entries, pos);
+	while ((conflict_entry = git_vector_get(&index->entries, pos)) != NULL) {
 
 		if (index->entries_cmp_path(conflict_entry->path, path) != 0)
 			break;
@@ -1218,14 +1239,11 @@ int git_index_conflict_remove(git_index *index, const char *path)
 			continue;
 		}
 
-		if ((error = git_vector_remove(&index->entries, pos)) < 0)
-			return error;
-
-		index_entry_free(conflict_entry);
-		posmax--;
+		if ((error = index_remove_entry(index, pos)) < 0)
+			break;
 	}
 
-	return 0;
+	return error;
 }
 
 static int index_conflicts_match(const git_vector *v, size_t idx, void *p)
@@ -1341,32 +1359,36 @@ const git_index_name_entry *git_index_name_get_byindex(
 	return git_vector_get(&index->names, n);
 }
 
+static void index_name_entry_free(git_index_name_entry *ne)
+{
+	if (!ne)
+		return;
+	git__free(ne->ancestor);
+	git__free(ne->ours);
+	git__free(ne->theirs);
+	git__free(ne);
+}
+
 int git_index_name_add(git_index *index,
 	const char *ancestor, const char *ours, const char *theirs)
 {
 	git_index_name_entry *conflict_name;
 
-	assert ((ancestor && ours) || (ancestor && theirs) || (ours && theirs));
+	assert((ancestor && ours) || (ancestor && theirs) || (ours && theirs));
 
 	conflict_name = git__calloc(1, sizeof(git_index_name_entry));
 	GITERR_CHECK_ALLOC(conflict_name);
 
-	if (ancestor) {
-		conflict_name->ancestor = git__strdup(ancestor);
-		GITERR_CHECK_ALLOC(conflict_name->ancestor);
-	}
-
-	if (ours) {
-		conflict_name->ours = git__strdup(ours);
-		GITERR_CHECK_ALLOC(conflict_name->ours);
-	}
-
-	if (theirs) {
-		conflict_name->theirs = git__strdup(theirs);
-		GITERR_CHECK_ALLOC(conflict_name->theirs);
+	if ((ancestor && !(conflict_name->ancestor = git__strdup(ancestor))) ||
+		(ours     && !(conflict_name->ours     = git__strdup(ours))) ||
+		(theirs   && !(conflict_name->theirs   = git__strdup(theirs))) ||
+		git_vector_insert(&index->names, conflict_name) < 0)
+	{
+		index_name_entry_free(conflict_name);
+		return -1;
 	}
 
-	return git_vector_insert(&index->names, conflict_name);
+	return 0;
 }
 
 void git_index_name_clear(git_index *index)
@@ -1376,18 +1398,8 @@ void git_index_name_clear(git_index *index)
 
 	assert(index);
 
-	git_vector_foreach(&index->names, i, conflict_name) {
-		if (conflict_name->ancestor)
-			git__free(conflict_name->ancestor);
-
-		if (conflict_name->ours)
-			git__free(conflict_name->ours);
-
-		if (conflict_name->theirs)
-			git__free(conflict_name->theirs);
-
-		git__free(conflict_name);
-	}
+	git_vector_foreach(&index->names, i, conflict_name)
+		index_name_entry_free(conflict_name);
 
 	git_vector_clear(&index->names);
 }
@@ -1432,15 +1444,13 @@ int git_index_reuc_add(git_index *index, const char *path,
 
 	assert(index && path);
 
-	if ((error = index_entry_reuc_init(&reuc, path, ancestor_mode, ancestor_oid, our_mode, our_oid, their_mode, their_oid)) < 0 ||
+	if ((error = index_entry_reuc_init(&reuc, path, ancestor_mode,
+			ancestor_oid, our_mode, our_oid, their_mode, their_oid)) < 0 ||
 		(error = index_reuc_insert(index, reuc, 1)) < 0)
-	{
 		index_entry_reuc_free(reuc);
-		return error;
-	}
 
 	return error;
-} 
+}
 
 int git_index_reuc_find(size_t *at_pos, git_index *index, const char *path)
 {
@@ -1752,6 +1762,7 @@ static size_t read_extension(git_index *index, const char *buffer, size_t buffer
 
 static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 {
+	int error = 0;
 	unsigned int i;
 	struct index_header header = { 0 };
 	git_oid checksum_calculated, checksum_expected;
@@ -1771,8 +1782,8 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 	git_hash_buf(&checksum_calculated, buffer, buffer_size - INDEX_FOOTER_SIZE);
 
 	/* Parse header */
-	if (read_header(&header, buffer) < 0)
-		return -1;
+	if ((error = read_header(&header, buffer)) < 0)
+		return error;
 
 	seek_forward(INDEX_HEADER_SIZE);
 
@@ -1784,22 +1795,29 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 		git_index_entry *entry;
 
 		entry = git__malloc(sizeof(git_index_entry));
-		GITERR_CHECK_ALLOC(entry);
+		if (!entry) {
+			error = -1;
+			goto done;
+		}
 
 		entry_size = read_entry(entry, buffer, buffer_size);
 
 		/* 0 bytes read means an object corruption */
-		if (entry_size == 0)
-			return index_error_invalid("invalid entry");
+		if (entry_size == 0) {
+			error = index_error_invalid("invalid entry");
+			goto done;
+		}
 
-		if (git_vector_insert(&index->entries, entry) < 0)
-			return -1;
+		if ((error = git_vector_insert(&index->entries, entry)) < 0)
+			goto done;
 
 		seek_forward(entry_size);
 	}
 
-	if (i != header.entry_count)
-		return index_error_invalid("header entries changed while parsing");
+	if (i != header.entry_count) {
+		error = index_error_invalid("header entries changed while parsing");
+		goto done;
+	}
 
 	/* There's still space for some extensions! */
 	while (buffer_size > INDEX_FOOTER_SIZE) {
@@ -1808,20 +1826,28 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 		extension_size = read_extension(index, buffer, buffer_size);
 
 		/* see if we have read any bytes from the extension */
-		if (extension_size == 0)
-			return index_error_invalid("extension is truncated");
+		if (extension_size == 0) {
+			error = index_error_invalid("extension is truncated");
+			goto done;
+		}
 
 		seek_forward(extension_size);
 	}
 
-	if (buffer_size != INDEX_FOOTER_SIZE)
-		return index_error_invalid("buffer size does not match index footer size");
+	if (buffer_size != INDEX_FOOTER_SIZE) {
+		error = index_error_invalid(
+			"buffer size does not match index footer size");
+		goto done;
+	}
 
 	/* 160-bit SHA-1 over the content of the index file before this checksum. */
 	git_oid_fromraw(&checksum_expected, (const unsigned char *)buffer);
 
-	if (git_oid__cmp(&checksum_calculated, &checksum_expected) != 0)
-		return index_error_invalid("calculated checksum does not match expected");
+	if (git_oid__cmp(&checksum_calculated, &checksum_expected) != 0) {
+		error = index_error_invalid(
+			"calculated checksum does not match expected");
+		goto done;
+	}
 
 #undef seek_forward
 
@@ -1831,7 +1857,8 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 	git_vector_set_sorted(&index->entries, !index->ignore_case);
 	git_vector_sort(&index->entries);
 
-	return 0;
+done:
+	return error;
 }
 
 static bool is_index_extended(git_index *index)
@@ -1916,19 +1943,20 @@ static int write_entries(git_index *index, git_filebuf *file)
 {
 	int error = 0;
 	size_t i;
-	git_vector case_sorted;
+	git_vector case_sorted, *entries;
 	git_index_entry *entry;
-	git_vector *out = &index->entries;
 
 	/* If index->entries is sorted case-insensitively, then we need
 	 * to re-sort it case-sensitively before writing */
 	if (index->ignore_case) {
 		git_vector_dup(&case_sorted, &index->entries, index_cmp);
 		git_vector_sort(&case_sorted);
-		out = &case_sorted;
+		entries = &case_sorted;
+	} else {
+		entries = &index->entries;
 	}
 
-	git_vector_foreach(out, i, entry)
+	git_vector_foreach(entries, i, entry)
 		if ((error = write_disk_entry(file, entry)) < 0)
 			break;
 
@@ -2179,8 +2207,11 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
 
 	if (!error) {
 		git_vector_sort(&entries);
-		git_index_clear(index);
-		git_vector_swap(&entries, &index->entries);
+
+		if ((error = git_index_clear(index)) < 0)
+			/* well, this isn't good */;
+		else
+			git_vector_swap(&entries, &index->entries);
 	}
 
 	git_vector_free(&entries);
@@ -2272,17 +2303,14 @@ int git_index_add_all(
 			break;
 
 		/* make the new entry to insert */
-		if ((entry = index_entry_dup(wd)) == NULL) {
-			error = -1;
+		if ((error = index_entry_dup(&entry, wd)) < 0)
 			break;
-		}
+
 		entry->id = blobid;
 
 		/* add working directory item to index */
-		if ((error = index_insert(index, entry, 1)) < 0) {
-			index_entry_free(entry);
+		if ((error = index_insert(index, &entry, 1)) < 0)
 			break;
-		}
 
 		git_tree_cache_invalidate_path(index->tree, wd->path);
 
diff --git a/src/index.h b/src/index.h
index 17f04f0ad..cabdbca30 100644
--- a/src/index.h
+++ b/src/index.h
@@ -50,11 +50,13 @@ struct git_index_conflict_iterator {
 extern void git_index_entry__init_from_stat(
 	git_index_entry *entry, struct stat *st, bool trust_mode);
 
-extern size_t git_index__prefix_position(git_index *index, const char *path);
-
 extern int git_index_entry__cmp(const void *a, const void *b);
 extern int git_index_entry__cmp_icase(const void *a, const void *b);
 
+/* Search index for `path`, returning GIT_ENOTFOUND if it does not exist.
+ * `at_pos` is set to the position where it is or would be inserted.
+ * Pass `path_len` as strlen of path or 0 to call strlen internally.
+ */
 extern int git_index__find(
 	size_t *at_pos, git_index *index, const char *path, size_t path_len, int stage);
 
diff --git a/src/iterator.c b/src/iterator.c
index a7a44914c..45655254c 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -815,8 +815,10 @@ static int index_iterator__reset(
 	if (iterator__reset_range(self, start, end) < 0)
 		return -1;
 
-	ii->current = ii->base.start ?
-		git_index__prefix_position(ii->index, ii->base.start) : 0;
+	ii->current = 0;
+
+	if (ii->base.start)
+		git_index__find(&ii->current, ii->index, ii->base.start, 0, 0);
 
 	if ((ie = index_iterator__skip_conflicts(ii)) == NULL)
 		return 0;
-- 
cgit v1.2.3


From 27e54bcf82fe27bdfadbaa9c5383ee8a948ea33c Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 7 Feb 2014 14:17:19 -0800
Subject: Add public diff print helpers

The usefulness of these helpers came up for me while debugging
some of the iterator changes that I was making, so since they
have also been requested (albeit indirectly) I thought I'd include
them.
---
 include/git2/sys/diff.h   | 63 +++++++++++++++++++++++++++++++++++++++++++++++
 src/diff_print.c          | 28 +++++++++++++++++++--
 tests/diff/diff_helpers.c | 29 ++++++----------------
 3 files changed, 96 insertions(+), 24 deletions(-)
 create mode 100644 include/git2/sys/diff.h

diff --git a/include/git2/sys/diff.h b/include/git2/sys/diff.h
new file mode 100644
index 000000000..bc6cdf393
--- /dev/null
+++ b/include/git2/sys/diff.h
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_sys_git_diff_h__
+#define INCLUDE_sys_git_diff_h__
+
+#include "git2/common.h"
+#include "git2/types.h"
+#include "git2/oid.h"
+
+/**
+ * @file git2/sys/diff.h
+ * @brief Low-level Git diff utilities
+ * @ingroup Git
+ * @{
+ */
+GIT_BEGIN_DECL
+
+/**
+ * Diff print callback that writes to a git_buf.
+ *
+ * This function is provided not for you to call it directly, but instead
+ * so you can use it as a function pointer to the `git_diff_print` or
+ * `git_patch_print` APIs.  When using those APIs, you specify a callback
+ * to actually handle the diff and/or patch data.
+ *
+ * Use this callback to easily write that data to a `git_buf` buffer.  You
+ * must pass a `git_buf *` value as the payload to the `git_diff_print`
+ * and/or `git_patch_print` function.  The data will be appended to the
+ * buffer (after any existing content).
+ */
+GIT_EXTERN(int) git_diff_print_callback__to_buf(
+	const git_diff_delta *delta,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
+	void *payload); /*< payload must be a `git_buf *` */
+
+/**
+ * Diff print callback that writes to stdio FILE handle.
+ *
+ * This function is provided not for you to call it directly, but instead
+ * so you can use it as a function pointer to the `git_diff_print` or
+ * `git_patch_print` APIs.  When using those APIs, you specify a callback
+ * to actually handle the diff and/or patch data.
+ *
+ * Use this callback to easily write that data to a stdio FILE handle.  You
+ * must pass a `FILE *` value (such as `stdout` or `stderr` or the return
+ * value from `fopen()`) as the payload to the `git_diff_print`
+ * and/or `git_patch_print` function.  If you pass NULL, this will write
+ * data to `stdout`.
+ */
+GIT_EXTERN(int) git_diff_print_callback__to_file_handle(
+	const git_diff_delta *delta,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
+	void *payload); /*< payload must be a `FILE *` */
+
+/** @} */
+GIT_END_DECL
+#endif
diff --git a/src/diff_print.c b/src/diff_print.c
index 1a09bed54..a7f7b6fe8 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -8,6 +8,7 @@
 #include "diff.h"
 #include "diff_patch.h"
 #include "fileops.h"
+#include "git2/sys/diff.h"
 
 typedef struct {
 	git_diff *diff;
@@ -435,7 +436,7 @@ int git_patch_print(
 	return error;
 }
 
-static int diff_print_to_buffer_cb(
+int git_diff_print_callback__to_buf(
 	const git_diff_delta *delta,
 	const git_diff_hunk *hunk,
 	const git_diff_line *line,
@@ -444,6 +445,11 @@ static int diff_print_to_buffer_cb(
 	git_buf *output = payload;
 	GIT_UNUSED(delta); GIT_UNUSED(hunk);
 
+	if (!output) {
+		giterr_set(GITERR_INVALID, "Buffer pointer must be provided");
+		return -1;
+	}
+
 	if (line->origin == GIT_DIFF_LINE_ADDITION ||
 		line->origin == GIT_DIFF_LINE_DELETION ||
 		line->origin == GIT_DIFF_LINE_CONTEXT)
@@ -452,10 +458,28 @@ static int diff_print_to_buffer_cb(
 	return git_buf_put(output, line->content, line->content_len);
 }
 
+int git_diff_print_callback__to_file_handle(
+	const git_diff_delta *delta,
+	const git_diff_hunk *hunk,
+	const git_diff_line *line,
+	void *payload)
+{
+	FILE *fp = payload ? payload : stdout;
+
+	GIT_UNUSED(delta); GIT_UNUSED(hunk);
+
+	if (line->origin == GIT_DIFF_LINE_CONTEXT ||
+		line->origin == GIT_DIFF_LINE_ADDITION ||
+		line->origin == GIT_DIFF_LINE_DELETION)
+		fputc(line->origin, fp);
+	fwrite(line->content, 1, line->content_len, fp);
+	return 0;
+}
+
 /* print a git_patch to a git_buf */
 int git_patch_to_buf(
 	git_buf *out,
 	git_patch *patch)
 {
-	return git_patch_print(patch, diff_print_to_buffer_cb, out);
+	return git_patch_print(patch, git_diff_print_callback__to_buf, out);
 }
diff --git a/tests/diff/diff_helpers.c b/tests/diff/diff_helpers.c
index 33bb561f6..279cb20c5 100644
--- a/tests/diff/diff_helpers.c
+++ b/tests/diff/diff_helpers.c
@@ -1,5 +1,6 @@
 #include "clar_libgit2.h"
 #include "diff_helpers.h"
+#include "git2/sys/diff.h"
 
 git_tree *resolve_commit_oid_to_tree(
 	git_repository *repo,
@@ -215,32 +216,16 @@ abort:
 	return GIT_EUSER;
 }
 
-static int diff_print_cb(
-	const git_diff_delta *delta,
-	const git_diff_hunk *hunk,
-	const git_diff_line *line,
-	void *payload)
-{
-	FILE *fp = payload;
-
-	GIT_UNUSED(delta); GIT_UNUSED(hunk);
-
-	if (line->origin == GIT_DIFF_LINE_CONTEXT ||
-		line->origin == GIT_DIFF_LINE_ADDITION ||
-		line->origin == GIT_DIFF_LINE_DELETION)
-		fputc(line->origin, fp);
-	fwrite(line->content, 1, line->content_len, fp);
-	return 0;
-}
-
 void diff_print(FILE *fp, git_diff *diff)
 {
-	cl_git_pass(git_diff_print(
-		diff, GIT_DIFF_FORMAT_PATCH, diff_print_cb, fp ? fp : stderr));
+	cl_git_pass(
+		git_diff_print(diff, GIT_DIFF_FORMAT_PATCH,
+			git_diff_print_callback__to_file_handle, fp ? fp : stderr));
 }
 
 void diff_print_raw(FILE *fp, git_diff *diff)
 {
-	cl_git_pass(git_diff_print(
-		diff, GIT_DIFF_FORMAT_RAW, diff_print_cb, fp ? fp : stderr));
+	cl_git_pass(
+		git_diff_print(diff, GIT_DIFF_FORMAT_RAW,
+			git_diff_print_callback__to_file_handle, fp ? fp : stderr));
 }
-- 
cgit v1.2.3


From 54edbb9871ad543baefc62310512719fc70539be Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 7 Feb 2014 16:48:27 -0800
Subject: Add index snapshot and use it for iterator

---
 src/index.c    | 42 +++++++++++++++++++++++++++++++++---------
 src/index.h    | 12 ++++++++++++
 src/iterator.c | 35 ++++++++++++++++++++++-------------
 3 files changed, 67 insertions(+), 22 deletions(-)

diff --git a/src/index.c b/src/index.c
index 8bc5cb13c..58b359bfe 100644
--- a/src/index.c
+++ b/src/index.c
@@ -1056,21 +1056,26 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 	return error;
 }
 
-int git_index__find(
-	size_t *out, git_index *index, const char *path, size_t path_len, int stage)
+int git_index__find_in_entries(
+	size_t *out, git_vector *entries, git_vector_cmp entry_cmp,
+	const char *path, size_t path_len, int stage)
 {
 	struct entry_srch_key srch_key;
-
-	assert(path);
-
-	git_vector_sort(&index->entries);
-
 	srch_key.path = path;
 	srch_key.path_len = !path_len ? strlen(path) : path_len;
 	srch_key.stage = stage;
+	return git_vector_bsearch2(out, entries, entry_cmp, &srch_key);
+}
 
-	return git_vector_bsearch2(
-		out, &index->entries, index->entries_search, &srch_key);
+int git_index__find(
+	size_t *out, git_index *index, const char *path, size_t path_len, int stage)
+{
+	assert(index && path);
+
+	git_vector_sort(&index->entries);
+
+	return git_index__find_in_entries(
+		out, &index->entries, index->entries_search, path, path_len, stage);
 }
 
 int git_index_find(size_t *at_pos, git_index *index, const char *path)
@@ -2442,3 +2447,22 @@ int git_index_update_all(
 
 	return error;
 }
+
+int git_index__snapshot(git_vector *entries, git_index *index)
+{
+	int error;
+
+	GIT_REFCOUNT_INC(index);
+	git_vector_sort(&index->entries);
+	error = git_vector_dup(entries, &index->entries, index->entries._cmp);
+
+	if (error < 0)
+		git_index_free(index);
+
+	return error;
+}
+
+void git_index__release_snapshot(git_index *index)
+{
+	git_index_free(index);
+}
diff --git a/src/index.h b/src/index.h
index cabdbca30..2b6f5c98b 100644
--- a/src/index.h
+++ b/src/index.h
@@ -71,4 +71,16 @@ GIT_INLINE(const git_futils_filestamp *) git_index__filestamp(git_index *index)
 
 extern int git_index__changed_relative_to(git_index *index, const git_futils_filestamp *fs);
 
+/* Copy the current entries vector *and* increment the index refcount.
+ * Call `git_index__release_snapshot` when done.
+ */
+extern int git_index__snapshot(git_vector *entries, git_index *index);
+extern void git_index__release_snapshot(git_index *index);
+
+/* Allow searching in a snapshot; entries must already be sorted! */
+extern int git_index__find_in_entries(
+	size_t *at_pos,
+	git_vector *entries, git_vector_cmp entry_cmp,
+	const char *path, size_t path_len, int stage);
+
 #endif
diff --git a/src/iterator.c b/src/iterator.c
index 45655254c..a84f4d3db 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -644,6 +644,8 @@ typedef struct {
 	git_iterator base;
 	git_iterator_callbacks cb;
 	git_index *index;
+	git_vector entries;
+	git_vector_cmp entry_srch;
 	size_t current;
 	/* when not in autoexpand mode, use these to represent "tree" state */
 	git_buf partial;
@@ -654,10 +656,10 @@ typedef struct {
 
 static const git_index_entry *index_iterator__index_entry(index_iterator *ii)
 {
-	const git_index_entry *ie = git_index_get_byindex(ii->index, ii->current);
+	const git_index_entry *ie = git_vector_get(&ii->entries, ii->current);
 
 	if (ie != NULL && iterator__past_end(ii, ie->path)) {
-		ii->current = git_index_entrycount(ii->index);
+		ii->current = git_vector_length(&ii->entries);
 		ie = NULL;
 	}
 
@@ -726,7 +728,7 @@ static int index_iterator__current(
 	const git_index_entry **entry, git_iterator *self)
 {
 	index_iterator *ii = (index_iterator *)self;
-	const git_index_entry *ie = git_index_get_byindex(ii->index, ii->current);
+	const git_index_entry *ie = git_vector_get(&ii->entries, ii->current);
 
 	if (ie != NULL && index_iterator__at_tree(ii)) {
 		ii->tree_entry.path = ii->partial.ptr;
@@ -744,14 +746,14 @@ static int index_iterator__current(
 static int index_iterator__at_end(git_iterator *self)
 {
 	index_iterator *ii = (index_iterator *)self;
-	return (ii->current >= git_index_entrycount(ii->index));
+	return (ii->current >= git_vector_length(&ii->entries));
 }
 
 static int index_iterator__advance(
 	const git_index_entry **entry, git_iterator *self)
 {
 	index_iterator *ii = (index_iterator *)self;
-	size_t entrycount = git_index_entrycount(ii->index);
+	size_t entrycount = git_vector_length(&ii->entries);
 	const git_index_entry *ie;
 
 	if (!iterator__has_been_accessed(ii))
@@ -766,7 +768,7 @@ static int index_iterator__advance(
 			while (ii->current < entrycount) {
 				ii->current++;
 
-				if (!(ie = git_index_get_byindex(ii->index, ii->current)) ||
+				if (!(ie = git_vector_get(&ii->entries, ii->current)) ||
 					ii->base.prefixcomp(ie->path, ii->partial.ptr) != 0)
 					break;
 			}
@@ -789,7 +791,7 @@ static int index_iterator__advance_into(
 	const git_index_entry **entry, git_iterator *self)
 {
 	index_iterator *ii = (index_iterator *)self;
-	const git_index_entry *ie = git_index_get_byindex(ii->index, ii->current);
+	const git_index_entry *ie = git_vector_get(&ii->entries, ii->current);
 
 	if (ie != NULL && index_iterator__at_tree(ii)) {
 		if (ii->restore_terminator)
@@ -818,7 +820,8 @@ static int index_iterator__reset(
 	ii->current = 0;
 
 	if (ii->base.start)
-		git_index__find(&ii->current, ii->index, ii->base.start, 0, 0);
+		git_index__find_in_entries(
+			&ii->current, &ii->entries, ii->entry_srch, ii->base.start, 0, 0);
 
 	if ((ie = index_iterator__skip_conflicts(ii)) == NULL)
 		return 0;
@@ -843,9 +846,9 @@ static int index_iterator__reset(
 static void index_iterator__free(git_iterator *self)
 {
 	index_iterator *ii = (index_iterator *)self;
-	git_index_free(ii->index);
+	git_index__release_snapshot(ii->index);
 	ii->index = NULL;
-
+	git_vector_free(&ii->entries);
 	git_buf_free(&ii->partial);
 }
 
@@ -856,9 +859,17 @@ int git_iterator_for_index(
 	const char *start,
 	const char *end)
 {
+	int error = 0;
 	index_iterator *ii = git__calloc(1, sizeof(index_iterator));
 	GITERR_CHECK_ALLOC(ii);
 
+	if ((error = git_index__snapshot(&ii->entries, index)) < 0) {
+		git__free(ii);
+		return error;
+	}
+	ii->index = index;
+	ii->entry_srch = index->entries_search;
+
 	ITERATOR_BASE_INIT(ii, index, INDEX, git_index_owner(index));
 
 	if (index->ignore_case) {
@@ -866,8 +877,7 @@ int git_iterator_for_index(
 		ii->base.prefixcomp = git__prefixcmp_icase;
 	}
 
-	ii->index = index;
-	GIT_REFCOUNT_INC(index);
+	/* TODO: resort entries to match desired ignore_case behavior */
 
 	git_buf_init(&ii->partial, 0);
 	ii->tree_entry.mode = GIT_FILEMODE_TREE;
@@ -875,7 +885,6 @@ int git_iterator_for_index(
 	index_iterator__reset((git_iterator *)ii, NULL, NULL);
 
 	*iter = (git_iterator *)ii;
-
 	return 0;
 }
 
-- 
cgit v1.2.3


From dac160489bbf8de90d2f1ae152df68ded2603598 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Sat, 8 Feb 2014 16:42:26 -0800
Subject: Add mutex around index entries changes

This surrounds any function that mutates the entries vector with
a mutex so it can be safely snapshotted.
---
 src/index.c | 225 ++++++++++++++++++++++++++++++++++++++++++++----------------
 src/index.h |   7 +-
 2 files changed, 169 insertions(+), 63 deletions(-)

diff --git a/src/index.c b/src/index.c
index 58b359bfe..f28cbef27 100644
--- a/src/index.c
+++ b/src/index.c
@@ -325,6 +325,28 @@ static unsigned int index_merge_mode(
 	return git_index__create_mode(mode);
 }
 
+static int index_sort_if_needed(git_index *index, bool need_lock)
+{
+	/* not truly threadsafe because between when this checks and/or
+	 * sorts the array another thread could come in and unsort it
+	 */
+
+	if (git_vector_is_sorted(&index->entries))
+		return 0;
+
+	if (need_lock && git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to lock index");
+		return -1;
+	}
+
+	git_vector_sort(&index->entries);
+
+	if (need_lock)
+		git_mutex_unlock(&index->lock);
+
+	return 0;
+}
+
 void git_index__set_ignore_case(git_index *index, bool ignore_case)
 {
 	index->ignore_case = ignore_case;
@@ -334,7 +356,7 @@ void git_index__set_ignore_case(git_index *index, bool ignore_case)
 	index->entries_search_path = ignore_case ? index_isrch_path : index_srch_path;
 
 	git_vector_set_cmp(&index->entries, ignore_case ? index_icmp : index_cmp);
-	git_vector_sort(&index->entries);
+	index_sort_if_needed(index, true);
 
 	index->reuc_search = ignore_case ? reuc_isrch : reuc_srch;
 
@@ -352,6 +374,12 @@ int git_index_open(git_index **index_out, const char *index_path)
 	index = git__calloc(1, sizeof(git_index));
 	GITERR_CHECK_ALLOC(index);
 
+	if (git_mutex_init(&index->lock)) {
+		giterr_set(GITERR_OS, "Failed to initialize lock");
+		git__free(index);
+		return -1;
+	}
+
 	if (index_path != NULL) {
 		index->index_file_path = git__strdup(index_path);
 		if (!index->index_file_path)
@@ -364,7 +392,8 @@ int git_index_open(git_index **index_out, const char *index_path)
 
 	if (git_vector_init(&index->entries, 32, index_cmp) < 0 ||
 		git_vector_init(&index->names, 32, conflict_name_cmp) < 0 ||
-		git_vector_init(&index->reuc, 32, reuc_cmp) < 0)
+		git_vector_init(&index->reuc, 32, reuc_cmp) < 0 ||
+		git_vector_init(&index->deleted, 2, index_cmp) < 0)
 		goto fail;
 
 	index->entries_cmp_path = index_cmp_path;
@@ -392,12 +421,19 @@ int git_index_new(git_index **out)
 
 static void index_free(git_index *index)
 {
+	/* index iterators increment the refcount of the index, so if we
+	 * get here then there should be no outstanding iterators.
+	 */
+	assert(!git_atomic_get(&index->readers));
+
 	git_index_clear(index);
 	git_vector_free(&index->entries);
 	git_vector_free(&index->names);
 	git_vector_free(&index->reuc);
+	git_vector_free(&index->deleted);
 
 	git__free(index->index_file_path);
+	git_mutex_free(&index->lock);
 
 	git__memzero(index, sizeof(*index));
 	git__free(index);
@@ -411,30 +447,74 @@ void git_index_free(git_index *index)
 	GIT_REFCOUNT_DEC(index, index_free);
 }
 
-static void index_entries_free(git_vector *entries)
+/* call with locked index */
+static void index_free_deleted(git_index *index)
 {
 	size_t i;
 
-	for (i = 0; i < entries->length; ++i)
-		index_entry_free(git__swap(entries->contents[i], NULL));
+	if (git_atomic_get(&index->readers) > 0)
+		return;
+
+	for (i = 0; i < index->deleted.length; ++i)
+		index_entry_free(git__swap(index->deleted.contents[i], NULL));
+
+	git_vector_clear(&index->deleted);
+}
+
+static int index_remove_entry(git_index *index, size_t pos, bool need_lock)
+{
+	int error = 0;
+	git_index_entry *entry = git_vector_get(&index->entries, pos);
+
+	if (entry != NULL)
+		git_tree_cache_invalidate_path(index->tree, entry->path);
+
+	if (need_lock && git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to lock index");
+		return -1;
+	}
+
+	error = git_vector_remove(&index->entries, pos);
+
+	if (!error) {
+		if (!git_atomic_get(&index->readers))
+			index_entry_free(entry);
+		else
+			error = git_vector_insert(&index->deleted, entry);
+	}
+
+	if (need_lock)
+		git_mutex_unlock(&index->lock);
 
-	git_vector_clear(entries);
+	return error;
 }
 
 int git_index_clear(git_index *index)
 {
+	int error = 0;
+
 	assert(index);
 
 	git_tree_cache_free(index->tree);
 	index->tree = NULL;
 
-	index_entries_free(&index->entries);
+	if (git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock index");
+		return -1;
+	}
+
+	while (!error && index->entries.length > 0)
+		error = index_remove_entry(index, index->entries.length - 1, false);
+	index_free_deleted(index);
+
+	git_mutex_unlock(&index->lock);
+
 	git_index_reuc_clear(index);
 	git_index_name_clear(index);
 
 	git_futils_filestamp_set(&index->stamp, NULL);
 
-	return 0;
+	return error;
 }
 
 static int create_index_error(int error, const char *msg)
@@ -545,7 +625,8 @@ int git_index_write(git_index *index)
 		return create_index_error(-1,
 			"Failed to read index: The index is in-memory only");
 
-	git_vector_sort(&index->entries);
+	if (index_sort_if_needed(index, true) < 0)
+		return -1;
 	git_vector_sort(&index->reuc);
 
 	if ((error = git_filebuf_open(
@@ -593,7 +674,8 @@ int git_index_write_tree(git_oid *oid, git_index *index)
 	return git_tree__write_index(oid, index, repo);
 }
 
-int git_index_write_tree_to(git_oid *oid, git_index *index, git_repository *repo)
+int git_index_write_tree_to(
+	git_oid *oid, git_index *index, git_repository *repo)
 {
 	assert(oid && index && repo);
 	return git_tree__write_index(oid, index, repo);
@@ -609,7 +691,8 @@ const git_index_entry *git_index_get_byindex(
 	git_index *index, size_t n)
 {
 	assert(index);
-	git_vector_sort(&index->entries);
+	if (index_sort_if_needed(index, true) < 0)
+		return NULL;
 	return git_vector_get(&index->entries, n);
 }
 
@@ -695,22 +778,6 @@ static int index_entry_init(
 	return 0;
 }
 
-static int index_remove_entry(git_index *index, size_t pos)
-{
-	int error = 0;
-	git_index_entry *entry = git_vector_get(&index->entries, pos);
-
-	if (entry != NULL)
-		git_tree_cache_invalidate_path(index->tree, entry->path);
-
-	error = git_vector_remove(&index->entries, pos);
-
-	if (!error)
-		index_entry_free(entry);
-
-	return error;
-}
-
 static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
 	const char *path,
 	int ancestor_mode, const git_oid *ancestor_oid,
@@ -793,7 +860,7 @@ static int has_file_name(git_index *index,
 		if (!ok_to_replace)
 			break;
 
-		if (index_remove_entry(index, --pos) < 0)
+		if (index_remove_entry(index, --pos, true) < 0)
 			break;
 	}
 	return retval;
@@ -827,7 +894,7 @@ static int has_dir_name(git_index *index,
 			if (!ok_to_replace)
 				break;
 
-			if (index_remove_entry(index, position) < 0)
+			if (index_remove_entry(index, position, true) < 0)
 				break;
 			continue;
 		}
@@ -924,7 +991,12 @@ static int index_insert(
 	/* if replacing is not requested or no existing entry exists, just
 	 * insert entry at the end; the index is no longer sorted
 	 */
-	error = git_vector_insert(&index->entries, entry);
+	if ((error = git_mutex_lock(&index->lock)) < 0) {
+		giterr_set(GITERR_OS, "Unable to acquire index lock");
+	} else {
+		error = git_vector_insert(&index->entries, entry);
+		git_mutex_unlock(&index->lock);
+	}
 
 done:
 	if (error < 0) {
@@ -1020,7 +1092,7 @@ int git_index_remove(git_index *index, const char *path, int stage)
 		return GIT_ENOTFOUND;
 	}
 
-	return index_remove_entry(index, position);
+	return index_remove_entry(index, position, true);
 }
 
 int git_index_remove_directory(git_index *index, const char *dir, int stage)
@@ -1045,7 +1117,7 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 			continue;
 		}
 
-		if ((error = index_remove_entry(index, pos)) < 0)
+		if ((error = index_remove_entry(index, pos, true)) < 0)
 			break;
 
 		/* removed entry at 'pos' so we don't need to increment it */
@@ -1072,7 +1144,8 @@ int git_index__find(
 {
 	assert(index && path);
 
-	git_vector_sort(&index->entries);
+	if (index_sort_if_needed(index, true) < 0)
+		return -1;
 
 	return git_index__find_in_entries(
 		out, &index->entries, index->entries_search, path, path_len, stage);
@@ -1244,7 +1317,7 @@ int git_index_conflict_remove(git_index *index, const char *path)
 			continue;
 		}
 
-		if ((error = index_remove_entry(index, pos)) < 0)
+		if ((error = index_remove_entry(index, pos, true)) < 0)
 			break;
 	}
 
@@ -1256,12 +1329,9 @@ static int index_conflicts_match(const git_vector *v, size_t idx, void *p)
 	git_index *index = p;
 	git_index_entry *entry = git_vector_get(v, idx);
 
-	GIT_UNUSED(index);
-
-	if (GIT_IDXENTRY_STAGE(entry) > 0) {
-		index_entry_free(entry);
+	if (GIT_IDXENTRY_STAGE(entry) > 0 &&
+		!index_remove_entry(index, idx, false))
 		return 1;
-	}
 
 	return 0;
 }
@@ -1269,7 +1339,12 @@ static int index_conflicts_match(const git_vector *v, size_t idx, void *p)
 void git_index_conflict_cleanup(git_index *index)
 {
 	assert(index);
+
+	if (git_mutex_lock(&index->lock) < 0)
+		return;
 	git_vector_remove_matching(&index->entries, index_conflicts_match, index);
+	index_free_deleted(index);
+	git_mutex_unlock(&index->lock);
 }
 
 int git_index_has_conflicts(const git_index *index)
@@ -1792,6 +1867,11 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 
 	seek_forward(INDEX_HEADER_SIZE);
 
+	if (git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to acquire index lock");
+		return -1;
+	}
+
 	git_vector_clear(&index->entries);
 
 	/* Parse all the entries */
@@ -1860,9 +1940,10 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 	 * in-memory index is supposed to be case-insensitive
 	 */
 	git_vector_set_sorted(&index->entries, !index->ignore_case);
-	git_vector_sort(&index->entries);
+	error = index_sort_if_needed(index, false);
 
 done:
+	git_mutex_unlock(&index->lock);
 	return error;
 }
 
@@ -1951,6 +2032,11 @@ static int write_entries(git_index *index, git_filebuf *file)
 	git_vector case_sorted, *entries;
 	git_index_entry *entry;
 
+	if (git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock index");
+		return -1;
+	}
+
 	/* If index->entries is sorted case-insensitively, then we need
 	 * to re-sort it case-sensitively before writing */
 	if (index->ignore_case) {
@@ -1965,6 +2051,8 @@ static int write_entries(git_index *index, git_filebuf *file)
 		if ((error = write_disk_entry(file, entry)) < 0)
 			break;
 
+	git_mutex_unlock(&index->lock);
+
 	if (index->ignore_case)
 		git_vector_free(&case_sorted);
 
@@ -2136,7 +2224,7 @@ int git_index_entry_stage(const git_index_entry *entry)
 typedef struct read_tree_data {
 	git_vector *old_entries;
 	git_vector *new_entries;
-	git_vector_cmp entries_search;
+	git_vector_cmp entry_cmp;
 } read_tree_data;
 
 static int read_tree_cb(
@@ -2145,6 +2233,7 @@ static int read_tree_cb(
 	read_tree_data *data = payload;
 	git_index_entry *entry = NULL, *old_entry;
 	git_buf path = GIT_BUF_INIT;
+	size_t pos;
 
 	if (git_tree_entry__is_tree(tentry))
 		return 0;
@@ -2159,23 +2248,15 @@ static int read_tree_cb(
 	entry->id = tentry->oid;
 
 	/* look for corresponding old entry and copy data to new entry */
-	if (data->old_entries) {
-		size_t pos;
-		struct entry_srch_key skey;
-
-		skey.path = path.ptr;
-		skey.path_len = strlen(path.ptr);
-		skey.stage = 0;
-
-		if (!git_vector_bsearch2(
-				&pos, data->old_entries, data->entries_search, &skey) &&
-			(old_entry = git_vector_get(data->old_entries, pos)) != NULL &&
-			entry->mode == old_entry->mode &&
-			git_oid_equal(&entry->id, &old_entry->id))
-		{
-			memcpy(entry, old_entry, sizeof(*entry));
-			entry->flags_extended = 0;
-		}
+	if (data->old_entries != NULL &&
+		!git_index__find_in_entries(
+			&pos, data->old_entries, data->entry_cmp, path.ptr, 0, 0) &&
+		(old_entry = git_vector_get(data->old_entries, pos)) != NULL &&
+		entry->mode == old_entry->mode &&
+		git_oid_equal(&entry->id, &old_entry->id))
+	{
+		memcpy(entry, old_entry, sizeof(*entry));
+		entry->flags_extended = 0;
 	}
 
 	if (path.size < GIT_IDXENTRY_NAMEMASK)
@@ -2204,9 +2285,10 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
 
 	data.old_entries = &index->entries;
 	data.new_entries = &entries;
-	data.entries_search = index->entries_search;
+	data.entry_cmp   = index->entries_search;
 
-	git_vector_sort(&index->entries);
+	if (index_sort_if_needed(index, true) < 0)
+		return -1;
 
 	error = git_tree_walk(tree, GIT_TREEWALK_POST, read_tree_cb, &data);
 
@@ -2215,8 +2297,13 @@ int git_index_read_tree(git_index *index, const git_tree *tree)
 
 		if ((error = git_index_clear(index)) < 0)
 			/* well, this isn't good */;
-		else
+		else if (git_mutex_lock(&index->lock) < 0) {
+			giterr_set(GITERR_OS, "Unable to acquire index lock");
+			error = -1;
+		} else {
 			git_vector_swap(&entries, &index->entries);
+			git_mutex_unlock(&index->lock);
+		}
 	}
 
 	git_vector_free(&entries);
@@ -2453,9 +2540,19 @@ int git_index__snapshot(git_vector *entries, git_index *index)
 	int error;
 
 	GIT_REFCOUNT_INC(index);
+
+	if (git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock index");
+		return -1;
+	}
+
+	git_atomic_inc(&index->readers);
 	git_vector_sort(&index->entries);
+
 	error = git_vector_dup(entries, &index->entries, index->entries._cmp);
 
+	git_mutex_unlock(&index->lock);
+
 	if (error < 0)
 		git_index_free(index);
 
@@ -2464,5 +2561,11 @@ int git_index__snapshot(git_vector *entries, git_index *index)
 
 void git_index__release_snapshot(git_index *index)
 {
+	git_atomic_dec(&index->readers);
 	git_index_free(index);
+
+	if (!git_mutex_lock(&index->lock)) {
+		index_free_deleted(index); /* try to free pending deleted items */
+		git_mutex_unlock(&index->lock);
+	}
 }
diff --git a/src/index.h b/src/index.h
index 2b6f5c98b..c2a932218 100644
--- a/src/index.h
+++ b/src/index.h
@@ -21,12 +21,15 @@ struct git_index {
 	git_refcount rc;
 
 	char *index_file_path;
-
 	git_futils_filestamp stamp;
+
 	git_vector entries;
 
-	unsigned int on_disk:1;
+	git_mutex  lock;    /* lock held while entries is being changed */
+	git_vector deleted; /* deleted entries if readers > 0 */
+	git_atomic readers; /* number of active iterators */
 
+	unsigned int on_disk:1;
 	unsigned int ignore_case:1;
 	unsigned int distrust_filemode:1;
 	unsigned int no_symlinks:1;
-- 
cgit v1.2.3


From 3b4c401a38ce912d5be8c9bf4ab1c4912a4f08bd Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 10 Feb 2014 13:20:08 -0800
Subject: Decouple index iterator sort from index

This makes the index iterator honor the GIT_ITERATOR_IGNORE_CASE
and GIT_ITERATOR_DONT_IGNORE_CASE flags without modifying the
index data itself.  To take advantage of this, I had to export a
number of the internal index entry comparison functions.  I also
wrote some new tests to exercise the capability.
---
 src/diff.c            | 79 +++++++++++++++++++++++++--------------------------
 src/index.c           | 73 ++++++++++++++++++-----------------------------
 src/index.h           | 11 +++++--
 src/iterator.c        | 14 +++++----
 src/merge.c           |  2 +-
 src/util.c            |  8 ++++--
 src/util.h            |  1 +
 src/vector.c          |  3 +-
 tests/diff/iterator.c | 58 ++++++++++++++++++++++++++++++++-----
 9 files changed, 142 insertions(+), 107 deletions(-)

diff --git a/src/diff.c b/src/diff.c
index cb05a5faf..0d1aed4ad 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -318,6 +318,31 @@ static const char *diff_mnemonic_prefix(
 	return pfx;
 }
 
+static void diff_set_ignore_case(git_diff *diff, bool ignore_case)
+{
+	if (!ignore_case) {
+		diff->opts.flags &= ~GIT_DIFF_IGNORE_CASE;
+
+		diff->strcomp    = git__strcmp;
+		diff->strncomp   = git__strncmp;
+		diff->pfxcomp    = git__prefixcmp;
+		diff->entrycomp  = git_index_entry_cmp;
+
+		git_vector_set_cmp(&diff->deltas, git_diff_delta__cmp);
+	} else {
+		diff->opts.flags |= GIT_DIFF_IGNORE_CASE;
+
+		diff->strcomp    = git__strcasecmp;
+		diff->strncomp   = git__strncasecmp;
+		diff->pfxcomp    = git__prefixcmp_icase;
+		diff->entrycomp  = git_index_entry_icmp;
+
+		git_vector_set_cmp(&diff->deltas, git_diff_delta__casecmp);
+	}
+
+	git_vector_sort(&diff->deltas);
+}
+
 static git_diff *diff_list_alloc(
 	git_repository *repo,
 	git_iterator *old_iter,
@@ -344,24 +369,10 @@ static git_diff *diff_list_alloc(
 
 	/* Use case-insensitive compare if either iterator has
 	 * the ignore_case bit set */
-	if (!git_iterator_ignore_case(old_iter) &&
-		!git_iterator_ignore_case(new_iter)) {
-		diff->opts.flags &= ~GIT_DIFF_IGNORE_CASE;
-
-		diff->strcomp    = git__strcmp;
-		diff->strncomp   = git__strncmp;
-		diff->pfxcomp    = git__prefixcmp;
-		diff->entrycomp  = git_index_entry__cmp;
-	} else {
-		diff->opts.flags |= GIT_DIFF_IGNORE_CASE;
-
-		diff->strcomp    = git__strcasecmp;
-		diff->strncomp   = git__strncasecmp;
-		diff->pfxcomp    = git__prefixcmp_icase;
-		diff->entrycomp  = git_index_entry__cmp_icase;
-
-		git_vector_set_cmp(&diff->deltas, git_diff_delta__casecmp);
-	}
+	diff_set_ignore_case(
+		diff,
+		git_iterator_ignore_case(old_iter) ||
+		git_iterator_ignore_case(new_iter));
 
 	return diff;
 }
@@ -1183,39 +1194,25 @@ int git_diff_tree_to_index(
 	const git_diff_options *opts)
 {
 	int error = 0;
-	bool reset_index_ignore_case = false;
+	bool index_ignore_case = false;
 
 	assert(diff && repo);
 
 	if (!index && (error = diff_load_index(&index, repo)) < 0)
 		return error;
 
-	if (index->ignore_case) {
-		git_index__set_ignore_case(index, false);
-		reset_index_ignore_case = true;
-	}
+	index_ignore_case = index->ignore_case;
 
 	DIFF_FROM_ITERATORS(
-		git_iterator_for_tree(&a, old_tree, 0, pfx, pfx),
-		git_iterator_for_index(&b, index, 0, pfx, pfx)
+		git_iterator_for_tree(
+			&a, old_tree, GIT_ITERATOR_DONT_IGNORE_CASE, pfx, pfx),
+		git_iterator_for_index(
+			&b, index, GIT_ITERATOR_DONT_IGNORE_CASE, pfx, pfx)
 	);
 
-	if (reset_index_ignore_case) {
-		git_index__set_ignore_case(index, true);
-
-		if (!error) {
-			git_diff *d = *diff;
-
-			d->opts.flags |= GIT_DIFF_IGNORE_CASE;
-			d->strcomp    = git__strcasecmp;
-			d->strncomp   = git__strncasecmp;
-			d->pfxcomp    = git__prefixcmp_icase;
-			d->entrycomp  = git_index_entry__cmp_icase;
-
-			git_vector_set_cmp(&d->deltas, git_diff_delta__casecmp);
-			git_vector_sort(&d->deltas);
-		}
-	}
+	/* if index is in case-insensitive order, re-sort deltas to match */
+	if (!error && index_ignore_case)
+		diff_set_ignore_case(*diff, true);
 
 	return error;
 }
diff --git a/src/index.c b/src/index.c
index f28cbef27..d733e4e48 100644
--- a/src/index.c
+++ b/src/index.c
@@ -106,7 +106,7 @@ static int write_index(git_index *index, git_filebuf *file);
 static void index_entry_free(git_index_entry *entry);
 static void index_entry_reuc_free(git_index_reuc_entry *reuc);
 
-static int index_srch(const void *key, const void *array_member)
+int git_index_entry_srch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
 	const git_index_entry *entry = array_member;
@@ -131,7 +131,7 @@ static int index_srch(const void *key, const void *array_member)
 	return 0;
 }
 
-static int index_isrch(const void *key, const void *array_member)
+int git_index_entry_isrch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
 	const git_index_entry *entry = array_member;
@@ -157,31 +157,21 @@ static int index_isrch(const void *key, const void *array_member)
 	return 0;
 }
 
-static int index_cmp_path(const void *a, const void *b)
-{
-	return strcmp((const char *)a, (const char *)b);
-}
-
-static int index_icmp_path(const void *a, const void *b)
-{
-	return strcasecmp((const char *)a, (const char *)b);
-}
-
-static int index_srch_path(const void *path, const void *array_member)
+static int index_entry_srch_path(const void *path, const void *array_member)
 {
 	const git_index_entry *entry = array_member;
 
 	return strcmp((const char *)path, entry->path);
 }
 
-static int index_isrch_path(const void *path, const void *array_member)
+static int index_entry_isrch_path(const void *path, const void *array_member)
 {
 	const git_index_entry *entry = array_member;
 
 	return strcasecmp((const char *)path, entry->path);
 }
 
-static int index_cmp(const void *a, const void *b)
+int git_index_entry_cmp(const void *a, const void *b)
 {
 	int diff;
 	const git_index_entry *entry_a = a;
@@ -195,7 +185,7 @@ static int index_cmp(const void *a, const void *b)
 	return diff;
 }
 
-static int index_icmp(const void *a, const void *b)
+int git_index_entry_icmp(const void *a, const void *b)
 {
 	int diff;
 	const git_index_entry *entry_a = a;
@@ -351,15 +341,22 @@ void git_index__set_ignore_case(git_index *index, bool ignore_case)
 {
 	index->ignore_case = ignore_case;
 
-	index->entries_cmp_path = ignore_case ? index_icmp_path : index_cmp_path;
-	index->entries_search = ignore_case ? index_isrch : index_srch;
-	index->entries_search_path = ignore_case ? index_isrch_path : index_srch_path;
+	if (ignore_case) {
+		index->entries_cmp_path    = git__strcasecmp_cb;
+		index->entries_search      = git_index_entry_isrch;
+		index->entries_search_path = index_entry_isrch_path;
+		index->reuc_search         = reuc_isrch;
+	} else {
+		index->entries_cmp_path    = git__strcmp_cb;
+		index->entries_search      = git_index_entry_srch;
+		index->entries_search_path = index_entry_srch_path;
+		index->reuc_search         = reuc_srch;
+	}
 
-	git_vector_set_cmp(&index->entries, ignore_case ? index_icmp : index_cmp);
+	git_vector_set_cmp(&index->entries,
+		ignore_case ? git_index_entry_icmp : git_index_entry_cmp);
 	index_sort_if_needed(index, true);
 
-	index->reuc_search = ignore_case ? reuc_isrch : reuc_srch;
-
 	git_vector_set_cmp(&index->reuc, ignore_case ? reuc_icmp : reuc_cmp);
 	git_vector_sort(&index->reuc);
 }
@@ -390,15 +387,15 @@ int git_index_open(git_index **index_out, const char *index_path)
 			index->on_disk = 1;
 	}
 
-	if (git_vector_init(&index->entries, 32, index_cmp) < 0 ||
+	if (git_vector_init(&index->entries, 32, git_index_entry_cmp) < 0 ||
 		git_vector_init(&index->names, 32, conflict_name_cmp) < 0 ||
 		git_vector_init(&index->reuc, 32, reuc_cmp) < 0 ||
-		git_vector_init(&index->deleted, 2, index_cmp) < 0)
+		git_vector_init(&index->deleted, 2, git_index_entry_cmp) < 0)
 		goto fail;
 
-	index->entries_cmp_path = index_cmp_path;
-	index->entries_search = index_srch;
-	index->entries_search_path = index_srch_path;
+	index->entries_cmp_path = git__strcmp_cb;
+	index->entries_search = git_index_entry_srch;
+	index->entries_search_path = index_entry_srch_path;
 	index->reuc_search = reuc_srch;
 
 	if (index_path != NULL && (error = git_index_read(index, true)) < 0)
@@ -727,22 +724,6 @@ void git_index_entry__init_from_stat(
 	entry->file_size = st->st_size;
 }
 
-int git_index_entry__cmp(const void *a, const void *b)
-{
-	const git_index_entry *entry_a = a;
-	const git_index_entry *entry_b = b;
-
-	return strcmp(entry_a->path, entry_b->path);
-}
-
-int git_index_entry__cmp_icase(const void *a, const void *b)
-{
-	const git_index_entry *entry_a = a;
-	const git_index_entry *entry_b = b;
-
-	return strcasecmp(entry_a->path, entry_b->path);
-}
-
 static int index_entry_init(
 	git_index_entry **entry_out, git_index *index, const char *rel_path)
 {
@@ -1129,14 +1110,14 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 }
 
 int git_index__find_in_entries(
-	size_t *out, git_vector *entries, git_vector_cmp entry_cmp,
+	size_t *out, git_vector *entries, git_vector_cmp entry_srch,
 	const char *path, size_t path_len, int stage)
 {
 	struct entry_srch_key srch_key;
 	srch_key.path = path;
 	srch_key.path_len = !path_len ? strlen(path) : path_len;
 	srch_key.stage = stage;
-	return git_vector_bsearch2(out, entries, entry_cmp, &srch_key);
+	return git_vector_bsearch2(out, entries, entry_srch, &srch_key);
 }
 
 int git_index__find(
@@ -2040,7 +2021,7 @@ static int write_entries(git_index *index, git_filebuf *file)
 	/* If index->entries is sorted case-insensitively, then we need
 	 * to re-sort it case-sensitively before writing */
 	if (index->ignore_case) {
-		git_vector_dup(&case_sorted, &index->entries, index_cmp);
+		git_vector_dup(&case_sorted, &index->entries, git_index_entry_cmp);
 		git_vector_sort(&case_sorted);
 		entries = &case_sorted;
 	} else {
diff --git a/src/index.h b/src/index.h
index c2a932218..cb4425885 100644
--- a/src/index.h
+++ b/src/index.h
@@ -53,8 +53,13 @@ struct git_index_conflict_iterator {
 extern void git_index_entry__init_from_stat(
 	git_index_entry *entry, struct stat *st, bool trust_mode);
 
-extern int git_index_entry__cmp(const void *a, const void *b);
-extern int git_index_entry__cmp_icase(const void *a, const void *b);
+/* Index entry comparison functions for array sorting */
+extern int git_index_entry_cmp(const void *a, const void *b);
+extern int git_index_entry_icmp(const void *a, const void *b);
+
+/* Index entry search functions for search using a search spec */
+extern int git_index_entry_srch(const void *a, const void *b);
+extern int git_index_entry_isrch(const void *a, const void *b);
 
 /* Search index for `path`, returning GIT_ENOTFOUND if it does not exist.
  * `at_pos` is set to the position where it is or would be inserted.
@@ -83,7 +88,7 @@ extern void git_index__release_snapshot(git_index *index);
 /* Allow searching in a snapshot; entries must already be sorted! */
 extern int git_index__find_in_entries(
 	size_t *at_pos,
-	git_vector *entries, git_vector_cmp entry_cmp,
+	git_vector *entries, git_vector_cmp entry_srch,
 	const char *path, size_t path_len, int stage);
 
 #endif
diff --git a/src/iterator.c b/src/iterator.c
index a84f4d3db..53ef278d1 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -868,16 +868,20 @@ int git_iterator_for_index(
 		return error;
 	}
 	ii->index = index;
-	ii->entry_srch = index->entries_search;
 
 	ITERATOR_BASE_INIT(ii, index, INDEX, git_index_owner(index));
 
-	if (index->ignore_case) {
-		ii->base.flags |= GIT_ITERATOR_IGNORE_CASE;
-		ii->base.prefixcomp = git__prefixcmp_icase;
+	if ((error = iterator__update_ignore_case((git_iterator *)ii, flags)) < 0) {
+		git_iterator_free((git_iterator *)ii);
+		return error;
 	}
 
-	/* TODO: resort entries to match desired ignore_case behavior */
+	ii->entry_srch = iterator__ignore_case(ii) ?
+		git_index_entry_isrch : git_index_entry_srch;
+
+	git_vector_set_cmp(&ii->entries, iterator__ignore_case(ii) ?
+		git_index_entry_icmp : git_index_entry_cmp);
+	git_vector_sort(&ii->entries);
 
 	git_buf_init(&ii->partial, 0);
 	ii->tree_entry.mode = GIT_FILEMODE_TREE;
diff --git a/src/merge.c b/src/merge.c
index 9c4a07b58..68105d483 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -1332,7 +1332,7 @@ int git_merge_diff_list__find_differences(
 {
 	git_iterator *iterators[3] = {0};
 	const git_index_entry *items[3] = {0}, *best_cur_item, *cur_items[3];
-	git_vector_cmp entry_compare = git_index_entry__cmp;
+	git_vector_cmp entry_compare = git_index_entry_cmp;
 	struct merge_diff_df_data df_data = {0};
 	int cur_item_modified;
 	size_t i, j;
diff --git a/src/util.c b/src/util.c
index 3767b890c..39858254f 100644
--- a/src/util.c
+++ b/src/util.c
@@ -542,10 +542,12 @@ int git__bsearch_r(
  */
 int git__strcmp_cb(const void *a, const void *b)
 {
-	const char *stra = (const char *)a;
-	const char *strb = (const char *)b;
+	return strcmp((const char *)a, (const char *)b);
+}
 
-	return strcmp(stra, strb);
+int git__strcasecmp_cb(const void *a, const void *b)
+{
+	return strcasecmp((const char *)a, (const char *)b);
 }
 
 int git__parse_bool(int *out, const char *value)
diff --git a/src/util.h b/src/util.h
index 5c2c563d6..d94463c65 100644
--- a/src/util.h
+++ b/src/util.h
@@ -196,6 +196,7 @@ extern int git__bsearch_r(
 	size_t *position);
 
 extern int git__strcmp_cb(const void *a, const void *b);
+extern int git__strcasecmp_cb(const void *a, const void *b);
 
 extern int git__strcmp(const char *a, const char *b);
 extern int git__strcasecmp(const char *a, const char *b);
diff --git a/src/vector.c b/src/vector.c
index 9f7eed5a3..c769b696a 100644
--- a/src/vector.c
+++ b/src/vector.c
@@ -177,7 +177,8 @@ void git_vector_sort(git_vector *v)
 	if (git_vector_is_sorted(v) || !v->_cmp)
 		return;
 
-	git__tsort(v->contents, v->length, v->_cmp);
+	if (v->length > 1)
+		git__tsort(v->contents, v->length, v->_cmp);
 	git_vector_set_sorted(v, 1);
 }
 
diff --git a/tests/diff/iterator.c b/tests/diff/iterator.c
index 891d8a6e5..19a9a0077 100644
--- a/tests/diff/iterator.c
+++ b/tests/diff/iterator.c
@@ -355,6 +355,7 @@ static void index_iterator_test(
 	const char *sandbox,
 	const char *start,
 	const char *end,
+	git_iterator_flag_t flags,
 	int expected_count,
 	const char **expected_names,
 	const char **expected_oids)
@@ -364,9 +365,12 @@ static void index_iterator_test(
 	const git_index_entry *entry;
 	int error, count = 0;
 	git_repository *repo = cl_git_sandbox_init(sandbox);
+	unsigned int caps;
 
 	cl_git_pass(git_repository_index(&index, repo));
-	cl_git_pass(git_iterator_for_index(&i, index, 0, start, end));
+	caps = git_index_caps(index);
+
+	cl_git_pass(git_iterator_for_index(&i, index, flags, start, end));
 
 	while (!(error = git_iterator_advance(&entry, i))) {
 		cl_assert(entry);
@@ -388,6 +392,8 @@ static void index_iterator_test(
 	cl_assert_equal_i(expected_count, count);
 
 	git_iterator_free(i);
+
+	cl_assert(caps == git_index_caps(index));
 	git_index_free(index);
 }
 
@@ -446,7 +452,8 @@ static const char *expected_index_oids_0[] = {
 void test_diff_iterator__index_0(void)
 {
 	index_iterator_test(
-		"attr", NULL, NULL, 23, expected_index_0, expected_index_oids_0);
+		"attr", NULL, NULL, 0, ARRAY_SIZE(expected_index_0),
+		expected_index_0, expected_index_oids_0);
 }
 
 static const char *expected_index_range[] = {
@@ -466,25 +473,26 @@ static const char *expected_index_oids_range[] = {
 void test_diff_iterator__index_range(void)
 {
 	index_iterator_test(
-		"attr", "root", "root", 4, expected_index_range, expected_index_oids_range);
+		"attr", "root", "root", 0, ARRAY_SIZE(expected_index_range),
+		expected_index_range, expected_index_oids_range);
 }
 
 void test_diff_iterator__index_range_empty_0(void)
 {
 	index_iterator_test(
-		"attr", "empty", "empty", 0, NULL, NULL);
+		"attr", "empty", "empty", 0, 0, NULL, NULL);
 }
 
 void test_diff_iterator__index_range_empty_1(void)
 {
 	index_iterator_test(
-		"attr", "z_empty_after", NULL, 0, NULL, NULL);
+		"attr", "z_empty_after", NULL, 0, 0, NULL, NULL);
 }
 
 void test_diff_iterator__index_range_empty_2(void)
 {
 	index_iterator_test(
-		"attr", NULL, ".aaa_empty_before", 0, NULL, NULL);
+		"attr", NULL, ".aaa_empty_before", 0, 0, NULL, NULL);
 }
 
 static const char *expected_index_1[] = {
@@ -522,9 +530,45 @@ static const char* expected_index_oids_1[] = {
 void test_diff_iterator__index_1(void)
 {
 	index_iterator_test(
-		"status", NULL, NULL, 13, expected_index_1, expected_index_oids_1);
+		"status", NULL, NULL, 0, ARRAY_SIZE(expected_index_1),
+		expected_index_1, expected_index_oids_1);
 }
 
+static const char *expected_index_cs[] = {
+	"B", "D", "F", "H", "J", "L/1", "L/B", "L/D", "L/a", "L/c",
+	"a", "c", "e", "g", "i", "k/1", "k/B", "k/D", "k/a", "k/c",
+};
+
+static const char *expected_index_ci[] = {
+	"a", "B", "c", "D", "e", "F", "g", "H", "i", "J",
+	"k/1", "k/a", "k/B", "k/c", "k/D", "L/1", "L/a", "L/B", "L/c", "L/D",
+};
+
+void test_diff_iterator__index_case_folding(void)
+{
+	git_buf path = GIT_BUF_INIT;
+	int fs_is_ci = 0;
+
+	cl_git_pass(git_buf_joinpath(&path, cl_fixture("icase"), ".gitted/CoNfIg"));
+	fs_is_ci = git_path_exists(path.ptr);
+	git_buf_free(&path);
+
+	index_iterator_test(
+		"icase", NULL, NULL, 0, ARRAY_SIZE(expected_index_cs),
+		fs_is_ci ? expected_index_ci : expected_index_cs, NULL);
+
+	cl_git_sandbox_cleanup();
+
+	index_iterator_test(
+		"icase", NULL, NULL, GIT_ITERATOR_IGNORE_CASE,
+		ARRAY_SIZE(expected_index_ci), expected_index_ci, NULL);
+
+	cl_git_sandbox_cleanup();
+
+	index_iterator_test(
+		"icase", NULL, NULL, GIT_ITERATOR_DONT_IGNORE_CASE,
+		ARRAY_SIZE(expected_index_cs), expected_index_cs, NULL);
+}
 
 /* -- WORKDIR ITERATOR TESTS -- */
 
-- 
cgit v1.2.3


From 40ed499039f887ebcb0b5badf0157519148398b8 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 11 Feb 2014 14:45:37 -0800
Subject: Add diff threading tests and attr file cache locks

This adds a basic test of doing simultaneous diffs on multiple
threads and adds basic locking for the attr file cache because
that was the immediate problem that arose from these tests.
---
 src/attr.c           | 215 ++++++++++++++++++++++++++++++++-------------------
 src/attr_file.c      |  13 +++-
 src/attr_file.h      |   1 +
 src/attrcache.h      |   8 +-
 src/config_file.c    |  20 +++--
 src/diff_driver.c    |   2 +-
 src/repository.h     |   4 +-
 src/sortedcache.c    |   5 +-
 src/strmap.h         |   4 +-
 src/submodule.c      |   3 +-
 tests/clar_libgit2.h |   2 +-
 tests/core/strmap.c  |  72 +++++++++--------
 tests/threads/diff.c | 152 ++++++++++++++++++++++++++++++++++++
 13 files changed, 361 insertions(+), 140 deletions(-)
 create mode 100644 tests/threads/diff.c

diff --git a/src/attr.c b/src/attr.c
index d8a171d0f..f52a8a97b 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -33,6 +33,7 @@ static int collect_attr_files(
 	const char *path,
 	git_vector *files);
 
+static void release_attr_files(git_vector *files);
 
 int git_attr_get(
 	const char **value,
@@ -76,7 +77,7 @@ int git_attr_get(
 	}
 
 cleanup:
-	git_vector_free(&files);
+	release_attr_files(&files);
 	git_attr_path__free(&path);
 
 	return error;
@@ -152,7 +153,7 @@ int git_attr_get_many(
 	}
 
 cleanup:
-	git_vector_free(&files);
+	release_attr_files(&files);
 	git_attr_path__free(&path);
 	git__free(info);
 
@@ -181,12 +182,10 @@ int git_attr_foreach(
 	if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)
 		return -1;
 
-	if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0)
+	if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0 ||
+		(error = git_strmap_alloc(&seen)) < 0)
 		goto cleanup;
 
-	seen = git_strmap_alloc();
-	GITERR_CHECK_ALLOC(seen);
-
 	git_vector_foreach(&files, i, file) {
 
 		git_attr_file__foreach_matching_rule(file, &path, j, rule) {
@@ -211,7 +210,7 @@ int git_attr_foreach(
 
 cleanup:
 	git_strmap_free(seen);
-	git_vector_free(&files);
+	release_attr_files(&files);
 	git_attr_path__free(&path);
 
 	return error;
@@ -350,12 +349,21 @@ static int load_attr_from_cache(
 	if (git_buf_printf(&cache_key, "%d#%s", (int)source, relative_path) < 0)
 		return -1;
 
-	cache_pos = git_strmap_lookup_index(cache->files, cache_key.ptr);
+	if (git_mutex_lock(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Could not get cache attr lock");
+		git_buf_free(&cache_key);
+		return -1;
+	}
 
-	git_buf_free(&cache_key);
+	cache_pos = git_strmap_lookup_index(cache->files, cache_key.ptr);
 
-	if (git_strmap_valid_index(cache->files, cache_pos))
+	if (git_strmap_valid_index(cache->files, cache_pos)) {
 		*file = git_strmap_value_at(cache->files, cache_pos);
+		GIT_REFCOUNT_INC(*file);
+	}
+
+	git_mutex_unlock(&cache->lock);
+	git_buf_free(&cache_key);
 
 	return 0;
 }
@@ -367,20 +375,26 @@ int git_attr_cache__internal_file(
 {
 	int error = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
-	khiter_t cache_pos = git_strmap_lookup_index(cache->files, filename);
+	khiter_t cache_pos;
+
+	if (git_mutex_lock(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to get attr cache lock");
+		return -1;
+	}
+
+	cache_pos = git_strmap_lookup_index(cache->files, filename);
 
 	if (git_strmap_valid_index(cache->files, cache_pos)) {
 		*file = git_strmap_value_at(cache->files, cache_pos);
-		return 0;
 	}
+	else if (!(error = git_attr_file__new(file, 0, filename, &cache->pool))) {
 
-	if (git_attr_file__new(file, 0, filename, &cache->pool) < 0)
-		return -1;
-
-	git_strmap_insert(cache->files, (*file)->key + 2, *file, error);
-	if (error > 0)
-		error = 0;
+		git_strmap_insert(cache->files, (*file)->key + 2, *file, error);
+		if (error > 0)
+			error = 0;
+	}
 
+	git_mutex_unlock(&cache->lock);
 	return error;
 }
 
@@ -452,9 +466,17 @@ int git_attr_cache__push_file(
 	if (parse && (error = parse(repo, parsedata, content, file)) < 0)
 		goto finish;
 
-	git_strmap_insert(cache->files, file->key, file, error); //-V595
-	if (error > 0)
-		error = 0;
+	if (git_mutex_lock(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to get attr cache lock");
+		error = -1;
+	} else {
+		git_strmap_insert(cache->files, file->key, file, error); /* -V595 */
+		if (error > 0) { /* > 0 means inserting for the first time */
+			error = 0;
+			GIT_REFCOUNT_INC(file);
+		}
+		git_mutex_unlock(&cache->lock);
+	}
 
 	/* remember "cache buster" file signature */
 	if (blob)
@@ -481,7 +503,8 @@ finish:
 }
 
 #define push_attr_file(R,S,B,F) \
-	git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,git_attr_file__parse_buffer,NULL,(S))
+	git_attr_cache__push_file											\
+	((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,git_attr_file__parse_buffer,NULL,(S))
 
 typedef struct {
 	git_repository *repo;
@@ -535,6 +558,18 @@ static int push_one_attr(void *ref, git_buf *path)
 	return error;
 }
 
+static void release_attr_files(git_vector *files)
+{
+	size_t i;
+	git_attr_file *file;
+
+	git_vector_foreach(files, i, file) {
+		git_attr_file__free(file);
+		files->contents[i] = NULL;
+	}
+	git_vector_free(files);
+}
+
 static int collect_attr_files(
 	git_repository *repo,
 	uint32_t flags,
@@ -600,7 +635,7 @@ static int collect_attr_files(
 
  cleanup:
 	if (error < 0)
-		git_vector_free(files);
+		release_attr_files(files);
 	git_buf_free(&dir);
 
 	return error;
@@ -637,61 +672,11 @@ static int attr_cache__lookup_path(
 	return error;
 }
 
-int git_attr_cache__init(git_repository *repo)
-{
-	int ret;
-	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_config *cfg;
-
-	if (cache->initialized)
-		return 0;
-
-	/* cache config settings for attributes and ignores */
-	if (git_repository_config__weakptr(&cfg, repo) < 0)
-		return -1;
-
-	ret = attr_cache__lookup_path(
-		&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG, GIT_ATTR_FILE_XDG);
-	if (ret < 0)
-		return ret;
-
-	ret = attr_cache__lookup_path(
-		&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG, GIT_IGNORE_FILE_XDG);
-	if (ret < 0)
-		return ret;
-
-	/* allocate hashtable for attribute and ignore file contents */
-	if (cache->files == NULL) {
-		cache->files = git_strmap_alloc();
-		GITERR_CHECK_ALLOC(cache->files);
-	}
-
-	/* allocate hashtable for attribute macros */
-	if (cache->macros == NULL) {
-		cache->macros = git_strmap_alloc();
-		GITERR_CHECK_ALLOC(cache->macros);
-	}
-
-	/* allocate string pool */
-	if (git_pool_init(&cache->pool, 1, 0) < 0)
-		return -1;
-
-	cache->initialized = 1;
-
-	/* insert default macros */
-	return git_attr_add_macro(repo, "binary", "-diff -crlf -text");
-}
-
-void git_attr_cache_flush(
-	git_repository *repo)
+static void attr_cache__free(git_attr_cache *cache)
 {
-	git_attr_cache *cache;
-
-	if (!repo)
+	if (!cache)
 		return;
 
-	cache = git_repository_attr_cache(repo);
-
 	if (cache->files != NULL) {
 		git_attr_file *file;
 
@@ -720,19 +705,93 @@ void git_attr_cache_flush(
 	git__free(cache->cfg_excl_file);
 	cache->cfg_excl_file = NULL;
 
-	cache->initialized = 0;
+	git_mutex_free(&cache->lock);
+
+	git__free(cache);
+}
+
+int git_attr_cache__init(git_repository *repo)
+{
+	int ret = 0;
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_config *cfg;
+
+	if (cache)
+		return 0;
+
+	if ((ret = git_repository_config__weakptr(&cfg, repo)) < 0)
+		return ret;
+
+	cache = git__calloc(1, sizeof(git_attr_cache));
+	GITERR_CHECK_ALLOC(cache);
+
+	/* set up lock */
+	if (git_mutex_init(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to initialize lock for attr cache");
+		git__free(cache);
+		return -1;
+	}
+
+	/* cache config settings for attributes and ignores */
+	ret = attr_cache__lookup_path(
+		&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG, GIT_ATTR_FILE_XDG);
+	if (ret < 0)
+		goto cancel;
+
+	ret = attr_cache__lookup_path(
+		&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG, GIT_IGNORE_FILE_XDG);
+	if (ret < 0)
+		goto cancel;
+
+	/* allocate hashtable for attribute and ignore file contents,
+	 * hashtable for attribute macros, and string pool
+	 */
+	if ((ret = git_strmap_alloc(&cache->files)) < 0 ||
+		(ret = git_strmap_alloc(&cache->macros)) < 0 ||
+		(ret = git_pool_init(&cache->pool, 1, 0)) < 0)
+		goto cancel;
+
+	cache = git__compare_and_swap(&repo->attrcache, NULL, cache);
+	if (cache)
+		goto cancel; /* raced with another thread, free this but no error */
+
+	/* insert default macros */
+	return git_attr_add_macro(repo, "binary", "-diff -crlf -text");
+
+cancel:
+	attr_cache__free(cache);
+	return ret;
+}
+
+void git_attr_cache_flush(git_repository *repo)
+{
+	git_attr_cache *cache;
+
+	/* this could be done less expensively, but for now, we'll just free
+	 * the entire attrcache and let the next use reinitialize it...
+	 */
+	if (repo && (cache = git__swap(repo->attrcache, NULL)) != NULL)
+		attr_cache__free(cache);
 }
 
 int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
 {
-	git_strmap *macros = git_repository_attr_cache(repo)->macros;
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_strmap *macros = cache->macros;
 	int error;
 
 	/* TODO: generate warning log if (macro->assigns.length == 0) */
 	if (macro->assigns.length == 0)
 		return 0;
 
-	git_strmap_insert(macros, macro->match.pattern, macro, error);
+	if (git_mutex_lock(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to get attr cache lock");
+		error = -1;
+	} else {
+		git_strmap_insert(macros, macro->match.pattern, macro, error);
+		git_mutex_unlock(&cache->lock);
+	}
+
 	return (error < 0) ? -1 : 0;
 }
 
diff --git a/src/attr_file.c b/src/attr_file.c
index ea92336f7..695f661a8 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -23,6 +23,7 @@ int git_attr_file__new(
 
 	attrs = git__calloc(1, sizeof(git_attr_file));
 	GITERR_CHECK_ALLOC(attrs);
+	GIT_REFCOUNT_INC(attrs);
 
 	if (pool)
 		attrs->pool = pool;
@@ -152,11 +153,8 @@ void git_attr_file__clear_rules(git_attr_file *file)
 	git_vector_free(&file->rules);
 }
 
-void git_attr_file__free(git_attr_file *file)
+static void attr_file_free(git_attr_file *file)
 {
-	if (!file)
-		return;
-
 	git_attr_file__clear_rules(file);
 
 	if (file->pool_is_allocated) {
@@ -168,6 +166,13 @@ void git_attr_file__free(git_attr_file *file)
 	git__free(file);
 }
 
+void git_attr_file__free(git_attr_file *file)
+{
+	if (!file)
+		return;
+	GIT_REFCOUNT_DEC(file, attr_file_free);
+}
+
 uint32_t git_attr_file__name_hash(const char *name)
 {
 	uint32_t h = 5381;
diff --git a/src/attr_file.h b/src/attr_file.h
index 3bc7c6cb8..dbd6696c9 100644
--- a/src/attr_file.h
+++ b/src/attr_file.h
@@ -64,6 +64,7 @@ typedef struct {
 } git_attr_assignment;
 
 typedef struct {
+	git_refcount rc;
 	char *key;				/* cache "source#path" this was loaded from */
 	git_vector rules;		/* vector of <rule*> or <fnmatch*> */
 	git_pool *pool;
diff --git a/src/attrcache.h b/src/attrcache.h
index 077633b87..4f9cff6bb 100644
--- a/src/attrcache.h
+++ b/src/attrcache.h
@@ -11,12 +11,12 @@
 #include "strmap.h"
 
 typedef struct {
-	int initialized;
-	git_pool pool;
-	git_strmap *files;	 /* hash path to git_attr_file of rules */
-	git_strmap *macros;	 /* hash name to vector<git_attr_assignment> */
 	char *cfg_attr_file; /* cached value of core.attributesfile */
 	char *cfg_excl_file; /* cached value of core.excludesfile */
+	git_strmap *files;	 /* hash path to git_attr_file of rules */
+	git_strmap *macros;	 /* hash name to vector<git_attr_assignment> */
+	git_mutex lock;
+	git_pool  pool;
 } git_attr_cache;
 
 extern int git_attr_cache__init(git_repository *repo);
diff --git a/src/config_file.c b/src/config_file.c
index aedf2cb12..bb26aa8a3 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -180,11 +180,15 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 
 	b->level = level;
 
-	b->values = git_strmap_alloc();
-	GITERR_CHECK_ALLOC(b->values);
+	if ((res = git_strmap_alloc(&b->values)) < 0)
+		return res;
 
 	git_array_init(b->readers);
 	reader = git_array_alloc(b->readers);
+	if (!reader) {
+		git_strmap_free(b->values);
+		return -1;
+	}
 	memset(reader, 0, sizeof(struct reader));
 
 	reader->file_path = git__strdup(b->file_path);
@@ -205,6 +209,7 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 
 	reader = git_array_get(b->readers, 0);
 	git_buf_free(&reader->buffer);
+
 	return res;
 }
 
@@ -218,8 +223,10 @@ static int config_refresh(git_config_backend *cfg)
 
 	for (i = 0; i < git_array_size(b->readers); i++) {
 		reader = git_array_get(b->readers, i);
+
 		res = git_futils_readbuffer_updated(
-			&reader->buffer, reader->file_path, &reader->file_mtime, &reader->file_size, &updated);
+			&reader->buffer, reader->file_path,
+			&reader->file_mtime, &reader->file_size, &updated);
 
 		if (res < 0)
 			return (res == GIT_ENOTFOUND) ? 0 : res;
@@ -233,10 +240,9 @@ static int config_refresh(git_config_backend *cfg)
 
 	/* need to reload - store old values and prep for reload */
 	old_values = b->values;
-	b->values = git_strmap_alloc();
-	GITERR_CHECK_ALLOC(b->values);
-
-	if ((res = config_parse(b, reader, b->level, 0)) < 0) {
+	if ((res = git_strmap_alloc(&b->values)) < 0) {
+		b->values = old_values;
+	} else if ((res = config_parse(b, reader, b->level, 0)) < 0) {
 		free_vars(b->values);
 		b->values = old_values;
 	} else {
diff --git a/src/diff_driver.c b/src/diff_driver.c
index 4c9a0af65..8136e0dd9 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -66,7 +66,7 @@ git_diff_driver_registry *git_diff_driver_registry_new()
 	if (!reg)
 		return NULL;
 
-	if ((reg->drivers = git_strmap_alloc()) == NULL) {
+	if (git_strmap_alloc(&reg->drivers) < 0) {
 		git_diff_driver_registry_free(reg);
 		return NULL;
 	}
diff --git a/src/repository.h b/src/repository.h
index 99923b63b..86db488fd 100644
--- a/src/repository.h
+++ b/src/repository.h
@@ -108,7 +108,7 @@ struct git_repository {
 	git_submodule_cache *_submodules;
 
 	git_cache objects;
-	git_attr_cache attrcache;
+	git_attr_cache *attrcache;
 	git_diff_driver_registry *diff_drivers;
 
 	char *path_repository;
@@ -123,7 +123,7 @@ struct git_repository {
 
 GIT_INLINE(git_attr_cache *) git_repository_attr_cache(git_repository *repo)
 {
-	return &repo->attrcache;
+	return repo->attrcache;
 }
 
 int git_repository_head_tree(git_tree **tree, git_repository *repo);
diff --git a/src/sortedcache.c b/src/sortedcache.c
index 13f0921f1..625322034 100644
--- a/src/sortedcache.c
+++ b/src/sortedcache.c
@@ -20,7 +20,7 @@ int git_sortedcache_new(
 
 	if (git_pool_init(&sc->pool, 1, 0) < 0 ||
 		git_vector_init(&sc->items, 4, item_cmp) < 0 ||
-		(sc->map = git_strmap_alloc()) == NULL)
+		git_strmap_alloc(&sc->map) < 0)
 		goto fail;
 
 	if (git_rwlock_init(&sc->lock)) {
@@ -39,8 +39,7 @@ int git_sortedcache_new(
 	return 0;
 
 fail:
-	if (sc->map)
-		git_strmap_free(sc->map);
+	git_strmap_free(sc->map);
 	git_vector_free(&sc->items);
 	git_pool_clear(&sc->pool);
 	git__free(sc);
diff --git a/src/strmap.h b/src/strmap.h
index 8276ab468..8985aaf7e 100644
--- a/src/strmap.h
+++ b/src/strmap.h
@@ -22,7 +22,9 @@ typedef khiter_t git_strmap_iter;
 #define GIT__USE_STRMAP \
 	__KHASH_IMPL(str, static kh_inline, const char *, void *, 1, kh_str_hash_func, kh_str_hash_equal)
 
-#define git_strmap_alloc()  kh_init(str)
+#define git_strmap_alloc(hp) \
+	((*(hp) = kh_init(str)) == NULL) ? giterr_set_oom(), -1 : 0
+
 #define git_strmap_free(h)  kh_destroy(str, h), h = NULL
 #define git_strmap_clear(h) kh_clear(str, h)
 
diff --git a/src/submodule.c b/src/submodule.c
index bea096df5..95d3d0d9c 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -1638,8 +1638,7 @@ static int submodule_cache_alloc(
 		return -1;
 	}
 
-	cache->submodules = git_strmap_alloc();
-	if (!cache->submodules) {
+	if (git_strmap_alloc(&cache->submodules) < 0) {
 		submodule_cache_free(cache);
 		return -1;
 	}
diff --git a/tests/clar_libgit2.h b/tests/clar_libgit2.h
index c2489db38..d395bd66f 100644
--- a/tests/clar_libgit2.h
+++ b/tests/clar_libgit2.h
@@ -11,7 +11,7 @@
  *
  * Use this wrapper around all `git_` library calls that return error codes!
  */
-#define cl_git_pass(expr) cl_git_pass_(expr, __FILE__, __LINE__)
+#define cl_git_pass(expr) cl_git_pass_((expr), __FILE__, __LINE__)
 
 #define cl_git_pass_(expr, file, line) do { \
 	int _lg2_error; \
diff --git a/tests/core/strmap.c b/tests/core/strmap.c
index f34a4f89f..a120f1feb 100644
--- a/tests/core/strmap.c
+++ b/tests/core/strmap.c
@@ -3,12 +3,22 @@
 
 GIT__USE_STRMAP;
 
+git_strmap *g_table;
+
+void test_core_strmap__initialize(void)
+{
+	cl_git_pass(git_strmap_alloc(&g_table));
+	cl_assert(g_table != NULL);
+}
+
+void test_core_strmap__cleanup(void)
+{
+	git_strmap_free(g_table);
+}
+
 void test_core_strmap__0(void)
 {
-	git_strmap *table = git_strmap_alloc();
-	cl_assert(table != NULL);
-	cl_assert(git_strmap_num_entries(table) == 0);
-	git_strmap_free(table);
+	cl_assert(git_strmap_num_entries(g_table) == 0);
 }
 
 static void insert_strings(git_strmap *table, int count)
@@ -37,21 +47,17 @@ void test_core_strmap__1(void)
 {
 	int i;
 	char *str;
-	git_strmap *table = git_strmap_alloc();
-	cl_assert(table != NULL);
 
-	insert_strings(table, 20);
+	insert_strings(g_table, 20);
 
-	cl_assert(git_strmap_exists(table, "aaaaaaaaa"));
-	cl_assert(git_strmap_exists(table, "ggggggggg"));
-	cl_assert(!git_strmap_exists(table, "aaaaaaaab"));
-	cl_assert(!git_strmap_exists(table, "abcdefghi"));
+	cl_assert(git_strmap_exists(g_table, "aaaaaaaaa"));
+	cl_assert(git_strmap_exists(g_table, "ggggggggg"));
+	cl_assert(!git_strmap_exists(g_table, "aaaaaaaab"));
+	cl_assert(!git_strmap_exists(g_table, "abcdefghi"));
 
 	i = 0;
-	git_strmap_foreach_value(table, str, { i++; free(str); });
+	git_strmap_foreach_value(g_table, str, { i++; free(str); });
 	cl_assert(i == 20);
-
-	git_strmap_free(table);
 }
 
 void test_core_strmap__2(void)
@@ -59,44 +65,36 @@ void test_core_strmap__2(void)
 	khiter_t pos;
 	int i;
 	char *str;
-	git_strmap *table = git_strmap_alloc();
-	cl_assert(table != NULL);
 
-	insert_strings(table, 20);
+	insert_strings(g_table, 20);
 
-	cl_assert(git_strmap_exists(table, "aaaaaaaaa"));
-	cl_assert(git_strmap_exists(table, "ggggggggg"));
-	cl_assert(!git_strmap_exists(table, "aaaaaaaab"));
-	cl_assert(!git_strmap_exists(table, "abcdefghi"));
+	cl_assert(git_strmap_exists(g_table, "aaaaaaaaa"));
+	cl_assert(git_strmap_exists(g_table, "ggggggggg"));
+	cl_assert(!git_strmap_exists(g_table, "aaaaaaaab"));
+	cl_assert(!git_strmap_exists(g_table, "abcdefghi"));
 
-	cl_assert(git_strmap_exists(table, "bbbbbbbbb"));
-	pos = git_strmap_lookup_index(table, "bbbbbbbbb");
-	cl_assert(git_strmap_valid_index(table, pos));
-	cl_assert_equal_s(git_strmap_value_at(table, pos), "bbbbbbbbb");
-	free(git_strmap_value_at(table, pos));
-	git_strmap_delete_at(table, pos);
+	cl_assert(git_strmap_exists(g_table, "bbbbbbbbb"));
+	pos = git_strmap_lookup_index(g_table, "bbbbbbbbb");
+	cl_assert(git_strmap_valid_index(g_table, pos));
+	cl_assert_equal_s(git_strmap_value_at(g_table, pos), "bbbbbbbbb");
+	free(git_strmap_value_at(g_table, pos));
+	git_strmap_delete_at(g_table, pos);
 
-	cl_assert(!git_strmap_exists(table, "bbbbbbbbb"));
+	cl_assert(!git_strmap_exists(g_table, "bbbbbbbbb"));
 
 	i = 0;
-	git_strmap_foreach_value(table, str, { i++; free(str); });
+	git_strmap_foreach_value(g_table, str, { i++; free(str); });
 	cl_assert(i == 19);
-
-	git_strmap_free(table);
 }
 
 void test_core_strmap__3(void)
 {
 	int i;
 	char *str;
-	git_strmap *table = git_strmap_alloc();
-	cl_assert(table != NULL);
 
-	insert_strings(table, 10000);
+	insert_strings(g_table, 10000);
 
 	i = 0;
-	git_strmap_foreach_value(table, str, { i++; free(str); });
+	git_strmap_foreach_value(g_table, str, { i++; free(str); });
 	cl_assert(i == 10000);
-
-	git_strmap_free(table);
 }
diff --git a/tests/threads/diff.c b/tests/threads/diff.c
new file mode 100644
index 000000000..33afc58ac
--- /dev/null
+++ b/tests/threads/diff.c
@@ -0,0 +1,152 @@
+#include "clar_libgit2.h"
+#include "thread-utils.h"
+
+static git_repository *g_repo;
+static git_tree *a, *b;
+static git_atomic counts[4];
+
+void test_threads_diff__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+static void run_in_parallel(
+	int repeats, int threads, void *(*func)(void *),
+	void (*before_test)(void), void (*after_test)(void))
+{
+	int r, t, *id = git__calloc(threads, sizeof(int));
+#ifdef GIT_THREADS
+	git_thread *th = git__calloc(threads, sizeof(git_thread));
+#else
+	void *th = NULL;
+#endif
+
+	cl_assert(id != NULL && th != NULL);
+
+	for (r = 0; r < repeats; ++r) {
+		g_repo = cl_git_sandbox_reopen(); /* reopen sandbox to flush caches */
+
+		if (before_test) before_test();
+
+		for (t = 0; t < threads; ++t) {
+			id[t] = t;
+#ifdef GIT_THREADS
+			cl_git_pass(git_thread_create(&th[t], NULL, func, &id[t]));
+#else
+			cl_assert(func(&id[t]) == &id[t]);
+#endif
+		}
+
+#ifdef GIT_THREADS
+		for (t = 0; t < threads; ++t)
+			cl_git_pass(git_thread_join(th[t], NULL));
+		memset(th, 0, threads * sizeof(git_thread));
+#endif
+
+		if (after_test) after_test();
+	}
+
+	git__free(id);
+	git__free(th);
+}
+
+static void setup_trees(void)
+{
+	cl_git_pass(git_revparse_single(
+		(git_object **)&a, g_repo, "0017bd4ab1^{tree}"));
+	cl_git_pass(git_revparse_single(
+		(git_object **)&b, g_repo, "26a125ee1b^{tree}"));
+
+	memset(counts, 0, sizeof(counts));
+}
+
+#define THREADS 20
+
+static void free_trees(void)
+{
+	git_tree_free(a); a = NULL;
+	git_tree_free(b); b = NULL;
+
+	cl_assert_equal_i(288, git_atomic_get(&counts[0]));
+	cl_assert_equal_i(112, git_atomic_get(&counts[1]));
+	cl_assert_equal_i( 80, git_atomic_get(&counts[2]));
+	cl_assert_equal_i( 96, git_atomic_get(&counts[3]));
+}
+
+static void *run_index_diffs(void *arg)
+{
+	int thread = *(int *)arg;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_diff *diff = NULL;
+	size_t i;
+	int exp[4] = { 0, 0, 0, 0 };
+
+//	fprintf(stderr, "%d >>>\n", thread);
+
+	switch (thread & 0x03) {
+	case 0: /* diff index to workdir */;
+		cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+		break;
+	case 1: /* diff tree 'a' to index */;
+		cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
+		break;
+	case 2: /* diff tree 'b' to index */;
+		cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));
+		break;
+	case 3: /* diff index to workdir (explicit index) */;
+		{
+			git_index *idx;
+			cl_git_pass(git_repository_index(&idx, g_repo));
+			cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, idx, &opts));
+			git_index_free(idx);
+			break;
+		}
+	}
+
+//	fprintf(stderr, "%d <<<\n", thread);
+
+	/* keep some diff stats to make sure results are as expected */
+
+	i = git_diff_num_deltas(diff);
+	git_atomic_add(&counts[0], (int32_t)i);
+	exp[0] = (int)i;
+
+	while (i > 0) {
+		switch (git_diff_get_delta(diff, --i)->status) {
+		case GIT_DELTA_MODIFIED: exp[1]++; git_atomic_inc(&counts[1]); break;
+		case GIT_DELTA_ADDED:    exp[2]++; git_atomic_inc(&counts[2]); break;
+		case GIT_DELTA_DELETED:  exp[3]++; git_atomic_inc(&counts[3]); break;
+		default: break;
+		}
+	}
+
+//	fprintf(stderr, "%2d: [%d] total %d (M %d A %d D %d)\n",
+//			thread, (int)(thread & 0x03), exp[0], exp[1], exp[2], exp[3]);
+
+	switch (thread & 0x03) {
+	case 0: case 3:
+		cl_assert_equal_i(8, exp[0]); cl_assert_equal_i(4, exp[1]);
+		cl_assert_equal_i(0, exp[2]); cl_assert_equal_i(4, exp[3]);
+		break;
+	case 1:
+		cl_assert_equal_i(12, exp[0]); cl_assert_equal_i(3, exp[1]);
+		cl_assert_equal_i(7, exp[2]); cl_assert_equal_i(2, exp[3]);
+		break;
+	case 2:
+		cl_assert_equal_i(8, exp[0]); cl_assert_equal_i(3, exp[1]);
+		cl_assert_equal_i(3, exp[2]); cl_assert_equal_i(2, exp[3]);
+		break;
+	}
+
+	git_diff_free(diff);
+
+	return arg;
+}
+
+void test_threads_diff__concurrent_diffs(void)
+{
+	g_repo = cl_git_sandbox_init("status");
+
+	run_in_parallel(
+		20, 32, run_index_diffs, setup_trees, free_trees);
+}
-- 
cgit v1.2.3


From 8a2834d34173220c56bd1898397c0e6d200f327d Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 14 Mar 2014 13:20:51 -0700
Subject: Index locking and entry allocation changes

This makes the lock management on the index a little bit broader,
having a number of routines hold the lock across looking up the
item to be modified and actually making the modification.  Still
not true thread safety, but more pure index modifications are now
safe which allows the simple cases (such as starting up a diff
while index modifications are underway) safe enough to get the
snapshot without hitting allocation problems.

As part of this, I simplified the allocation of index entries to
use a flex array and just put the path at the end of the index
entry.  This makes every entry self-contained and makes it a
little easier to feel sure that pointers to strings aren't
being accidentally copied and freed while other references are
still being held.
---
 src/common.h          |   1 +
 src/index.c           | 369 ++++++++++++++++++++++++++++----------------------
 src/merge.c           |  10 +-
 src/thread-utils.h    |   7 +
 tests/diff/iterator.c |   3 +-
 tests/threads/diff.c  | 121 ++++++++++++-----
 6 files changed, 309 insertions(+), 202 deletions(-)

diff --git a/src/common.h b/src/common.h
index d389cf85d..9c8bdc18a 100644
--- a/src/common.h
+++ b/src/common.h
@@ -46,6 +46,7 @@
 # include <unistd.h>
 # ifdef GIT_THREADS
 #	include <pthread.h>
+#	include <sched.h>
 # endif
 #define GIT_STDLIB_CALL
 
diff --git a/src/index.c b/src/index.c
index d733e4e48..094328b95 100644
--- a/src/index.c
+++ b/src/index.c
@@ -90,13 +90,24 @@ struct entry_long {
 
 struct entry_srch_key {
 	const char *path;
-	size_t path_len;
+	size_t pathlen;
 	int stage;
 };
 
+struct entry_internal {
+	git_index_entry entry;
+	size_t pathlen;
+	char path[GIT_FLEX_ARRAY];
+};
+
+struct reuc_entry_internal {
+	git_index_reuc_entry entry;
+	size_t pathlen;
+	char path[GIT_FLEX_ARRAY];
+};
+
 /* local declarations */
 static size_t read_extension(git_index *index, const char *buffer, size_t buffer_size);
-static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffer_size);
 static int read_header(struct index_header *dest, const void *buffer);
 
 static int parse_index(git_index *index, const char *buffer, size_t buffer_size);
@@ -109,12 +120,12 @@ static void index_entry_reuc_free(git_index_reuc_entry *reuc);
 int git_index_entry_srch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
-	const git_index_entry *entry = array_member;
+	const struct entry_internal *entry = array_member;
 	int cmp;
 	size_t len1, len2, len;
 
-	len1 = srch_key->path_len;
-	len2 = strlen(entry->path);
+	len1 = srch_key->pathlen;
+	len2 = entry->pathlen;
 	len = len1 < len2 ? len1 : len2;
 
 	cmp = memcmp(srch_key->path, entry->path, len);
@@ -126,7 +137,7 @@ int git_index_entry_srch(const void *key, const void *array_member)
 		return 1;
 
 	if (srch_key->stage != GIT_INDEX_STAGE_ANY)
-		return srch_key->stage - GIT_IDXENTRY_STAGE(entry);
+		return srch_key->stage - GIT_IDXENTRY_STAGE(&entry->entry);
 
 	return 0;
 }
@@ -134,12 +145,12 @@ int git_index_entry_srch(const void *key, const void *array_member)
 int git_index_entry_isrch(const void *key, const void *array_member)
 {
 	const struct entry_srch_key *srch_key = key;
-	const git_index_entry *entry = array_member;
+	const struct entry_internal *entry = array_member;
 	int cmp;
 	size_t len1, len2, len;
 
-	len1 = srch_key->path_len;
-	len2 = strlen(entry->path);
+	len1 = srch_key->pathlen;
+	len2 = entry->pathlen;
 	len = len1 < len2 ? len1 : len2;
 
 	cmp = strncasecmp(srch_key->path, entry->path, len);
@@ -152,7 +163,7 @@ int git_index_entry_isrch(const void *key, const void *array_member)
 		return 1;
 
 	if (srch_key->stage != GIT_INDEX_STAGE_ANY)
-		return srch_key->stage - GIT_IDXENTRY_STAGE(entry);
+		return srch_key->stage - GIT_IDXENTRY_STAGE(&entry->entry);
 
 	return 0;
 }
@@ -276,17 +287,11 @@ static int reuc_icmp(const void *a, const void *b)
 
 static void index_entry_reuc_free(git_index_reuc_entry *reuc)
 {
-	if (!reuc)
-		return;
-	git__free(reuc->path);
 	git__free(reuc);
 }
 
 static void index_entry_free(git_index_entry *entry)
 {
-	if (!entry)
-		return;
-	git__free(entry->path);
 	git__free(entry);
 }
 
@@ -447,18 +452,22 @@ void git_index_free(git_index *index)
 /* call with locked index */
 static void index_free_deleted(git_index *index)
 {
+	int readers = (int)git_atomic_get(&index->readers);
 	size_t i;
 
-	if (git_atomic_get(&index->readers) > 0)
+	if (readers > 0)
 		return;
 
-	for (i = 0; i < index->deleted.length; ++i)
-		index_entry_free(git__swap(index->deleted.contents[i], NULL));
+	for (i = 0; i < index->deleted.length; ++i) {
+		git_index_entry *ie = git__swap(index->deleted.contents[i], NULL);
+		index_entry_free(ie);
+	}
 
 	git_vector_clear(&index->deleted);
 }
 
-static int index_remove_entry(git_index *index, size_t pos, bool need_lock)
+/* call with locked index */
+static int index_remove_entry(git_index *index, size_t pos)
 {
 	int error = 0;
 	git_index_entry *entry = git_vector_get(&index->entries, pos);
@@ -466,23 +475,17 @@ static int index_remove_entry(git_index *index, size_t pos, bool need_lock)
 	if (entry != NULL)
 		git_tree_cache_invalidate_path(index->tree, entry->path);
 
-	if (need_lock && git_mutex_lock(&index->lock) < 0) {
-		giterr_set(GITERR_OS, "Unable to lock index");
-		return -1;
-	}
-
 	error = git_vector_remove(&index->entries, pos);
 
 	if (!error) {
-		if (!git_atomic_get(&index->readers))
-			index_entry_free(entry);
-		else
+		int readers = (int)git_atomic_get(&index->readers);
+
+		if (readers > 0)
 			error = git_vector_insert(&index->deleted, entry);
+		else
+			index_entry_free(entry);
 	}
 
-	if (need_lock)
-		git_mutex_unlock(&index->lock);
-
 	return error;
 }
 
@@ -501,7 +504,7 @@ int git_index_clear(git_index *index)
 	}
 
 	while (!error && index->entries.length > 0)
-		error = index_remove_entry(index, index->entries.length - 1, false);
+		error = index_remove_entry(index, index->entries.length - 1);
 	index_free_deleted(index);
 
 	git_mutex_unlock(&index->lock);
@@ -684,6 +687,16 @@ size_t git_index_entrycount(const git_index *index)
 	return index->entries.length;
 }
 
+GIT_INLINE(int) git_index__find_internal(
+	size_t *out, git_index *index, const char *path, size_t path_len, int stage,
+	bool need_lock)
+{
+	if (index_sort_if_needed(index, need_lock) < 0)
+		return -1;
+	return git_index__find_in_entries(
+		out, &index->entries, index->entries_search, path, path_len, stage);
+}
+
 const git_index_entry *git_index_get_byindex(
 	git_index *index, size_t n)
 {
@@ -700,7 +713,7 @@ const git_index_entry *git_index_get_bypath(
 
 	assert(index);
 
-	if (git_index__find(&pos, index, path, 0, stage) < 0) {
+	if (git_index__find_internal(&pos, index, path, 0, stage, true) < 0) {
 		giterr_set(GITERR_INDEX, "Index does not contain %s", path);
 		return NULL;
 	}
@@ -724,6 +737,21 @@ void git_index_entry__init_from_stat(
 	entry->file_size = st->st_size;
 }
 
+static git_index_entry *index_entry_alloc(const char *path)
+{
+	size_t pathlen = strlen(path);
+	struct entry_internal *entry =
+		git__calloc(sizeof(struct entry_internal) + pathlen + 1, 1);
+	if (!entry)
+		return NULL;
+
+	entry->pathlen = pathlen;
+	memcpy(entry->path, path, pathlen);
+	entry->entry.path = entry->path;
+
+	return (git_index_entry *)entry;
+}
+
 static int index_entry_init(
 	git_index_entry **entry_out, git_index *index, const char *rel_path)
 {
@@ -743,22 +771,31 @@ static int index_entry_init(
 	if (error < 0)
 		return error;
 
-	entry = git__calloc(1, sizeof(git_index_entry));
+	entry = index_entry_alloc(rel_path);
 	GITERR_CHECK_ALLOC(entry);
 
-	git_index_entry__init_from_stat(entry, &st, !index->distrust_filemode);
-
 	entry->id = oid;
-	entry->path = git__strdup(rel_path);
-	if (!entry->path) {
-		git__free(entry);
-		return -1;
-	}
+	git_index_entry__init_from_stat(entry, &st, !index->distrust_filemode);
 
-	*entry_out = entry;
+	*entry_out = (git_index_entry *)entry;
 	return 0;
 }
 
+static git_index_reuc_entry *reuc_entry_alloc(const char *path)
+{
+	size_t pathlen = strlen(path);
+	struct reuc_entry_internal *entry =
+		git__calloc(sizeof(struct reuc_entry_internal) + pathlen + 1, 1);
+	if (!entry)
+		return NULL;
+
+	entry->pathlen = pathlen;
+	memcpy(entry->path, path, pathlen);
+	entry->entry.path = entry->path;
+
+	return (git_index_reuc_entry *)entry;
+}
+
 static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
 	const char *path,
 	int ancestor_mode, const git_oid *ancestor_oid,
@@ -769,17 +806,9 @@ static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
 
 	assert(reuc_out && path);
 
-	*reuc_out = NULL;
-
-	reuc = git__calloc(1, sizeof(git_index_reuc_entry));
+	*reuc_out = reuc = reuc_entry_alloc(path);
 	GITERR_CHECK_ALLOC(reuc);
 
-	reuc->path = git__strdup(path);
-	if (reuc->path == NULL) {
-		git__free(reuc);
-		return -1;
-	}
-
 	if ((reuc->mode[0] = ancestor_mode) > 0)
 		git_oid_cpy(&reuc->oid[0], ancestor_oid);
 
@@ -789,10 +818,16 @@ static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
 	if ((reuc->mode[2] = their_mode) > 0)
 		git_oid_cpy(&reuc->oid[2], their_oid);
 
-	*reuc_out = reuc;
 	return 0;
 }
 
+static void index_entry_cpy(git_index_entry *tgt, const git_index_entry *src)
+{
+	char *tgt_path = tgt->path;
+	memcpy(tgt, src, sizeof(*tgt));
+	tgt->path = tgt_path; /* reset to existing path data */
+}
+
 static int index_entry_dup(git_index_entry **out, const git_index_entry *src)
 {
 	git_index_entry *entry;
@@ -802,19 +837,10 @@ static int index_entry_dup(git_index_entry **out, const git_index_entry *src)
 		return 0;
 	}
 
-	entry = git__malloc(sizeof(git_index_entry));
+	*out = entry = index_entry_alloc(src->path);
 	GITERR_CHECK_ALLOC(entry);
 
-	memcpy(entry, src, sizeof(git_index_entry));
-
-	/* duplicate the path string so we own it */
-	entry->path = git__strdup(entry->path);
-	if (!entry->path) {
-		git__free(entry);
-		return -1;
-	}
-
-	*out = entry;
+	index_entry_cpy(entry, src);
 	return 0;
 }
 
@@ -827,13 +853,13 @@ static int has_file_name(git_index *index,
 	const char *name = entry->path;
 
 	while (pos < index->entries.length) {
-		git_index_entry *p = index->entries.contents[pos++];
+		struct entry_internal *p = index->entries.contents[pos++];
 
-		if (len >= strlen(p->path))
+		if (len >= p->pathlen)
 			break;
 		if (memcmp(name, p->path, len))
 			break;
-		if (GIT_IDXENTRY_STAGE(p) != stage)
+		if (GIT_IDXENTRY_STAGE(&p->entry) != stage)
 			continue;
 		if (p->path[len] != '/')
 			continue;
@@ -841,7 +867,7 @@ static int has_file_name(git_index *index,
 		if (!ok_to_replace)
 			break;
 
-		if (index_remove_entry(index, --pos, true) < 0)
+		if (index_remove_entry(index, --pos) < 0)
 			break;
 	}
 	return retval;
@@ -860,7 +886,7 @@ static int has_dir_name(git_index *index,
 	const char *slash = name + strlen(name);
 
 	for (;;) {
-		size_t len, position;
+		size_t len, pos;
 
 		for (;;) {
 			if (*--slash == '/')
@@ -870,12 +896,12 @@ static int has_dir_name(git_index *index,
 		}
 		len = slash - name;
 
-		if (git_index__find(&position, index, name, len, stage) == 0) {
+		if (!git_index__find_internal(&pos, index, name, len, stage, false)) {
 			retval = -1;
 			if (!ok_to_replace)
 				break;
 
-			if (index_remove_entry(index, position, true) < 0)
+			if (index_remove_entry(index, pos) < 0)
 				break;
 			continue;
 		}
@@ -885,20 +911,19 @@ static int has_dir_name(git_index *index,
 		 * already matches the sub-directory, then we know
 		 * we're ok, and we can exit.
 		 */
-		while (position < index->entries.length) {
-			git_index_entry *p = index->entries.contents[position];
+		for (; pos < index->entries.length; ++pos) {
+			struct entry_internal *p = index->entries.contents[pos];
 
-			if ((strlen(p->path) <= len) ||
-			    (p->path[len] != '/') ||
+			if (p->pathlen <= len ||
+			    p->path[len] != '/' ||
 			    memcmp(p->path, name, len))
 				break; /* not our subdirectory */
 
-			if (GIT_IDXENTRY_STAGE(p) == stage)
+			if (GIT_IDXENTRY_STAGE(&p->entry) == stage)
 				return retval;
-
-			position++;
 		}
 	}
+
 	return retval;
 }
 
@@ -909,7 +934,8 @@ static int check_file_directory_collision(git_index *index,
 	retval = retval + has_dir_name(index, entry, ok_to_replace);
 
 	if (retval) {
-		giterr_set(GITERR_INDEX, "'%s' appears as both a file an a directory", entry->path);
+		giterr_set(GITERR_INDEX,
+			"'%s' appears as both a file and a directory", entry->path);
 		return -1;
 	}
 
@@ -931,10 +957,9 @@ static int index_insert(
 	assert(index && entry_ptr);
 
 	entry = *entry_ptr;
-	assert(entry && entry->path);
 
 	/* make sure that the path length flag is correct */
-	path_length = strlen(entry->path);
+	path_length = ((struct entry_internal *)entry)->pathlen;
 
 	entry->flags &= ~GIT_IDXENTRY_NAMEMASK;
 
@@ -943,43 +968,43 @@ static int index_insert(
 	else
 		entry->flags |= GIT_IDXENTRY_NAMEMASK;
 
+	if ((error = git_mutex_lock(&index->lock)) < 0) {
+		giterr_set(GITERR_OS, "Unable to acquire index lock");
+		return error;
+	}
+
+	git_vector_sort(&index->entries);
+
 	/* look if an entry with this path already exists */
-	if (!git_index__find(
-			&position, index, entry->path, 0, GIT_IDXENTRY_STAGE(entry))) {
+	if (!git_index__find_internal(
+			&position, index, entry->path, 0, GIT_IDXENTRY_STAGE(entry), false)) {
 		existing = index->entries.contents[position];
 		/* update filemode to existing values if stat is not trusted */
 		entry->mode = index_merge_mode(index, existing, entry->mode);
 	}
 
+	/* look for tree / blob name collisions, removing conflicts if requested */
 	error = check_file_directory_collision(index, entry, position, replace);
 	if (error < 0)
-		goto done;
+		/* skip changes */;
 
 	/* if we are replacing an existing item, overwrite the existing entry
 	 * and return it in place of the passed in one.
 	 */
-	if (existing && replace) {
-		git__free(entry->path);
-		entry->path = existing->path;
-
-		memcpy(existing, entry, sizeof(*entry));
+	else if (existing && replace) {
+		index_entry_cpy(existing, entry);
+		index_entry_free(entry);
 		*entry_ptr = existing;
-
-		git__free(entry);
-		return 0;
 	}
-
-	/* if replacing is not requested or no existing entry exists, just
-	 * insert entry at the end; the index is no longer sorted
-	 */
-	if ((error = git_mutex_lock(&index->lock)) < 0) {
-		giterr_set(GITERR_OS, "Unable to acquire index lock");
-	} else {
+	else {
+		/* if replacing is not requested or no existing entry exists, just
+		 * insert entry at the end; the index is no longer sorted
+		 */
 		error = git_vector_insert(&index->entries, entry);
-		git_mutex_unlock(&index->lock);
 	}
 
-done:
+	git_mutex_unlock(&index->lock);
+
 	if (error < 0) {
 		index_entry_free(*entry_ptr);
 		*entry_ptr = NULL;
@@ -1053,7 +1078,7 @@ int git_index_add(git_index *index, const git_index_entry *source_entry)
 	git_index_entry *entry = NULL;
 	int ret;
 
-	assert(index && source_entry);
+	assert(index && source_entry && source_entry->path);
 
 	if ((ret = index_entry_dup(&entry, source_entry)) < 0 ||
 		(ret = index_insert(index, &entry, 1)) < 0)
@@ -1065,15 +1090,24 @@ int git_index_add(git_index *index, const git_index_entry *source_entry)
 
 int git_index_remove(git_index *index, const char *path, int stage)
 {
+	int error;
 	size_t position;
 
-	if (git_index__find(&position, index, path, 0, stage) < 0) {
-		giterr_set(GITERR_INDEX, "Index does not contain %s at stage %d",
-			path, stage);
-		return GIT_ENOTFOUND;
+	if (git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock index");
+		return -1;
+	}
+
+	if (git_index__find_internal(&position, index, path, 0, stage, false) < 0) {
+		giterr_set(
+			GITERR_INDEX, "Index does not contain %s at stage %d", path, stage);
+		error = GIT_ENOTFOUND;
+	} else {
+		error = index_remove_entry(index, position);
 	}
 
-	return index_remove_entry(index, position, true);
+	git_mutex_unlock(&index->lock);
+	return error;
 }
 
 int git_index_remove_directory(git_index *index, const char *dir, int stage)
@@ -1083,12 +1117,17 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 	size_t pos;
 	git_index_entry *entry;
 
-	if (git_buf_sets(&pfx, dir) < 0 || git_path_to_dir(&pfx) < 0)
+	if (git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock index");
 		return -1;
+	}
 
-	git_index__find(&pos, index, pfx.ptr, pfx.size, GIT_INDEX_STAGE_ANY);
+	if (!(error = git_buf_sets(&pfx, dir)) &&
+		!(error = git_path_to_dir(&pfx)))
+		git_index__find_internal(
+			&pos, index, pfx.ptr, pfx.size, GIT_INDEX_STAGE_ANY, false);
 
-	while (1) {
+	while (!error) {
 		entry = git_vector_get(&index->entries, pos);
 		if (!entry || git__prefixcmp(entry->path, pfx.ptr) != 0)
 			break;
@@ -1098,12 +1137,12 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 			continue;
 		}
 
-		if ((error = index_remove_entry(index, pos, true)) < 0)
-			break;
+		error = index_remove_entry(index, pos);
 
-		/* removed entry at 'pos' so we don't need to increment it */
+		/* removed entry at 'pos' so we don't need to increment */
 	}
 
+	git_mutex_unlock(&index->lock);
 	git_buf_free(&pfx);
 
 	return error;
@@ -1115,7 +1154,7 @@ int git_index__find_in_entries(
 {
 	struct entry_srch_key srch_key;
 	srch_key.path = path;
-	srch_key.path_len = !path_len ? strlen(path) : path_len;
+	srch_key.pathlen = !path_len ? strlen(path) : path_len;
 	srch_key.stage = stage;
 	return git_vector_bsearch2(out, entries, entry_srch, &srch_key);
 }
@@ -1124,12 +1163,7 @@ int git_index__find(
 	size_t *out, git_index *index, const char *path, size_t path_len, int stage)
 {
 	assert(index && path);
-
-	if (index_sort_if_needed(index, true) < 0)
-		return -1;
-
-	return git_index__find_in_entries(
-		out, &index->entries, index->entries_search, path, path_len, stage);
+	return git_index__find_internal(out, index, path, path_len, stage, true);
 }
 
 int git_index_find(size_t *at_pos, git_index *index, const char *path)
@@ -1138,7 +1172,13 @@ int git_index_find(size_t *at_pos, git_index *index, const char *path)
 
 	assert(index && path);
 
+	if (git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock index");
+		return -1;
+	}
+
 	if (git_vector_bsearch2(&pos, &index->entries, index->entries_search_path, path) < 0) {
+		git_mutex_unlock(&index->lock);
 		giterr_set(GITERR_INDEX, "Index does not contain %s", path);
 		return GIT_ENOTFOUND;
 	}
@@ -1158,6 +1198,7 @@ int git_index_find(size_t *at_pos, git_index *index, const char *path)
 	if (at_pos)
 		*at_pos = pos;
 
+	git_mutex_unlock(&index->lock);
 	return 0;
 }
 
@@ -1288,6 +1329,11 @@ int git_index_conflict_remove(git_index *index, const char *path)
 	if (git_index_find(&pos, index, path) < 0)
 		return GIT_ENOTFOUND;
 
+	if (git_mutex_lock(&index->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to lock index");
+		return -1;
+	}
+
 	while ((conflict_entry = git_vector_get(&index->entries, pos)) != NULL) {
 
 		if (index->entries_cmp_path(conflict_entry->path, path) != 0)
@@ -1298,10 +1344,12 @@ int git_index_conflict_remove(git_index *index, const char *path)
 			continue;
 		}
 
-		if ((error = index_remove_entry(index, pos, true)) < 0)
+		if ((error = index_remove_entry(index, pos)) < 0)
 			break;
 	}
 
+	git_mutex_unlock(&index->lock);
+
 	return error;
 }
 
@@ -1311,7 +1359,7 @@ static int index_conflicts_match(const git_vector *v, size_t idx, void *p)
 	git_index_entry *entry = git_vector_get(v, idx);
 
 	if (GIT_IDXENTRY_STAGE(entry) > 0 &&
-		!index_remove_entry(index, idx, false))
+		!index_remove_entry(index, idx))
 		return 1;
 
 	return 0;
@@ -1488,7 +1536,6 @@ static int index_reuc_insert(
 		return git_vector_insert(&index->reuc, reuc);
 
 	/* exists, replace it */
-	git__free((*existing)->path);
 	git__free(*existing);
 	*existing = reuc;
 
@@ -1596,13 +1643,9 @@ static int read_reuc(git_index *index, const char *buffer, size_t size)
 		if (size <= len)
 			return index_error_invalid("reading reuc entries");
 
-		lost = git__calloc(1, sizeof(git_index_reuc_entry));
+		lost = reuc_entry_alloc(buffer);
 		GITERR_CHECK_ALLOC(lost);
 
-		/* read NUL-terminated pathname for entry */
-		lost->path = git__strdup(buffer);
-		GITERR_CHECK_ALLOC(lost->path);
-
 		size -= len;
 		buffer += len;
 
@@ -1700,41 +1743,41 @@ static int read_conflict_names(git_index *index, const char *buffer, size_t size
 	return 0;
 }
 
-static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffer_size)
+static size_t read_entry(
+	git_index_entry **out, const void *buffer, size_t buffer_size)
 {
 	size_t path_length, entry_size;
 	uint16_t flags_raw;
 	const char *path_ptr;
 	const struct entry_short *source = buffer;
+	git_index_entry entry = {{0}};
 
 	if (INDEX_FOOTER_SIZE + minimal_entry_size > buffer_size)
 		return 0;
 
-	memset(dest, 0x0, sizeof(git_index_entry));
-
-	dest->ctime.seconds = (git_time_t)ntohl(source->ctime.seconds);
-	dest->ctime.nanoseconds = ntohl(source->ctime.nanoseconds);
-	dest->mtime.seconds = (git_time_t)ntohl(source->mtime.seconds);
-	dest->mtime.nanoseconds = ntohl(source->mtime.nanoseconds);
-	dest->dev = ntohl(source->dev);
-	dest->ino = ntohl(source->ino);
-	dest->mode = ntohl(source->mode);
-	dest->uid = ntohl(source->uid);
-	dest->gid = ntohl(source->gid);
-	dest->file_size = ntohl(source->file_size);
-	git_oid_cpy(&dest->id, &source->oid);
-	dest->flags = ntohs(source->flags);
-
-	if (dest->flags & GIT_IDXENTRY_EXTENDED) {
+	entry.ctime.seconds = (git_time_t)ntohl(source->ctime.seconds);
+	entry.ctime.nanoseconds = ntohl(source->ctime.nanoseconds);
+	entry.mtime.seconds = (git_time_t)ntohl(source->mtime.seconds);
+	entry.mtime.nanoseconds = ntohl(source->mtime.nanoseconds);
+	entry.dev = ntohl(source->dev);
+	entry.ino = ntohl(source->ino);
+	entry.mode = ntohl(source->mode);
+	entry.uid = ntohl(source->uid);
+	entry.gid = ntohl(source->gid);
+	entry.file_size = ntohl(source->file_size);
+	git_oid_cpy(&entry.id, &source->oid);
+	entry.flags = ntohs(source->flags);
+
+	if (entry.flags & GIT_IDXENTRY_EXTENDED) {
 		const struct entry_long *source_l = (const struct entry_long *)source;
 		path_ptr = source_l->path;
 
 		flags_raw = ntohs(source_l->flags_extended);
-		memcpy(&dest->flags_extended, &flags_raw, 2);
+		memcpy(&entry.flags_extended, &flags_raw, 2);
 	} else
 		path_ptr = source->path;
 
-	path_length = dest->flags & GIT_IDXENTRY_NAMEMASK;
+	path_length = entry.flags & GIT_IDXENTRY_NAMEMASK;
 
 	/* if this is a very long string, we must find its
 	 * real length without overflowing */
@@ -1748,7 +1791,7 @@ static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffe
 		path_length = path_end - path_ptr;
 	}
 
-	if (dest->flags & GIT_IDXENTRY_EXTENDED)
+	if (entry.flags & GIT_IDXENTRY_EXTENDED)
 		entry_size = long_entry_size(path_length);
 	else
 		entry_size = short_entry_size(path_length);
@@ -1756,8 +1799,10 @@ static size_t read_entry(git_index_entry *dest, const void *buffer, size_t buffe
 	if (INDEX_FOOTER_SIZE + entry_size > buffer_size)
 		return 0;
 
-	dest->path = git__strdup(path_ptr);
-	assert(dest->path);
+	entry.path = (char *)path_ptr;
+
+	if (index_entry_dup(out, &entry) < 0)
+		return 0;
 
 	return entry_size;
 }
@@ -1853,20 +1898,12 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 		return -1;
 	}
 
-	git_vector_clear(&index->entries);
+	assert(!index->entries.length);
 
 	/* Parse all the entries */
 	for (i = 0; i < header.entry_count && buffer_size > INDEX_FOOTER_SIZE; ++i) {
-		size_t entry_size;
 		git_index_entry *entry;
-
-		entry = git__malloc(sizeof(git_index_entry));
-		if (!entry) {
-			error = -1;
-			goto done;
-		}
-
-		entry_size = read_entry(entry, buffer, buffer_size);
+		size_t entry_size = read_entry(&entry, buffer, buffer_size);
 
 		/* 0 bytes read means an object corruption */
 		if (entry_size == 0) {
@@ -1874,8 +1911,10 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 			goto done;
 		}
 
-		if ((error = git_vector_insert(&index->entries, entry)) < 0)
+		if ((error = git_vector_insert(&index->entries, entry)) < 0) {
+			index_entry_free(entry);
 			goto done;
+		}
 
 		seek_forward(entry_size);
 	}
@@ -1953,7 +1992,7 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry)
 	size_t path_len, disk_size;
 	char *path;
 
-	path_len = strlen(entry->path);
+	path_len = ((struct entry_internal *)entry)->pathlen;
 
 	if (entry->flags & GIT_IDXENTRY_EXTENDED)
 		disk_size = long_entry_size(path_len);
@@ -2222,7 +2261,7 @@ static int read_tree_cb(
 	if (git_buf_joinpath(&path, root, tentry->filename) < 0)
 		return -1;
 
-	entry = git__calloc(1, sizeof(git_index_entry));
+	entry = index_entry_alloc(path.ptr);
 	GITERR_CHECK_ALLOC(entry);
 
 	entry->mode = tentry->attr;
@@ -2236,7 +2275,9 @@ static int read_tree_cb(
 		entry->mode == old_entry->mode &&
 		git_oid_equal(&entry->id, &old_entry->id))
 	{
+		char *oldpath = entry->path;
 		memcpy(entry, old_entry, sizeof(*entry));
+		entry->path = oldpath;
 		entry->flags_extended = 0;
 	}
 
@@ -2245,7 +2286,6 @@ static int read_tree_cb(
 	else
 		entry->flags = GIT_IDXENTRY_NAMEMASK;
 
-	entry->path = git_buf_detach(&path);
 	git_buf_free(&path);
 
 	if (git_vector_insert(data->new_entries, entry) < 0) {
@@ -2543,10 +2583,11 @@ int git_index__snapshot(git_vector *entries, git_index *index)
 void git_index__release_snapshot(git_index *index)
 {
 	git_atomic_dec(&index->readers);
-	git_index_free(index);
 
 	if (!git_mutex_lock(&index->lock)) {
 		index_free_deleted(index); /* try to free pending deleted items */
 		git_mutex_unlock(&index->lock);
 	}
+
+	git_index_free(index);
 }
diff --git a/src/merge.c b/src/merge.c
index 68105d483..2e40b6db8 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -1230,7 +1230,7 @@ done:
 	return error;
 }
 
-GIT_INLINE(int) index_entry_dup(
+GIT_INLINE(int) index_entry_dup_pool(
 	git_index_entry *out,
 	git_pool *pool,
 	const git_index_entry *src)
@@ -1276,9 +1276,9 @@ static git_merge_diff *merge_diff_from_index_entries(
 	if ((conflict = git_pool_malloc(pool, sizeof(git_merge_diff))) == NULL)
 		return NULL;
 
-	if (index_entry_dup(&conflict->ancestor_entry, pool, entries[TREE_IDX_ANCESTOR]) < 0 ||
-		index_entry_dup(&conflict->our_entry, pool, entries[TREE_IDX_OURS]) < 0 ||
-		index_entry_dup(&conflict->their_entry, pool, entries[TREE_IDX_THEIRS]) < 0)
+	if (index_entry_dup_pool(&conflict->ancestor_entry, pool, entries[TREE_IDX_ANCESTOR]) < 0 ||
+		index_entry_dup_pool(&conflict->our_entry, pool, entries[TREE_IDX_OURS]) < 0 ||
+		index_entry_dup_pool(&conflict->their_entry, pool, entries[TREE_IDX_THEIRS]) < 0)
 		return NULL;
 
 	conflict->our_status = merge_delta_type_from_index_entries(
@@ -1318,7 +1318,7 @@ static int merge_diff_list_insert_unmodified(
 	entry = git_pool_malloc(&diff_list->pool, sizeof(git_index_entry));
 	GITERR_CHECK_ALLOC(entry);
 
-	if ((error = index_entry_dup(entry, &diff_list->pool, tree_items[0])) >= 0)
+	if ((error = index_entry_dup_pool(entry, &diff_list->pool, tree_items[0])) >= 0)
 		error = git_vector_insert(&diff_list->staged, entry);
 
 	return error;
diff --git a/src/thread-utils.h b/src/thread-utils.h
index 914c1357d..50d8610a3 100644
--- a/src/thread-utils.h
+++ b/src/thread-utils.h
@@ -47,6 +47,12 @@ typedef git_atomic git_atomic_ssize;
 #define git_thread_exit(status)	pthread_exit(status)
 #define git_thread_join(id, status) pthread_join(id, status)
 
+#if defined(GIT_WIN32)
+#define git_thread_yield() Sleep(0)
+#else
+#define git_thread_yield() sched_yield()
+#endif
+
 /* Pthreads Mutex */
 #define git_mutex pthread_mutex_t
 #define git_mutex_init(a)	pthread_mutex_init(a, NULL)
@@ -176,6 +182,7 @@ GIT_INLINE(int64_t) git_atomic64_add(git_atomic64 *a, int64_t addend)
 #define git_thread_kill(thread) (void)0
 #define git_thread_exit(status) (void)0
 #define git_thread_join(id, status) (void)0
+#define git_thread_yield() (void)0
 
 /* Pthreads Mutex */
 #define git_mutex unsigned int
diff --git a/tests/diff/iterator.c b/tests/diff/iterator.c
index 19a9a0077..cdc64eb1d 100644
--- a/tests/diff/iterator.c
+++ b/tests/diff/iterator.c
@@ -363,9 +363,8 @@ static void index_iterator_test(
 	git_index *index;
 	git_iterator *i;
 	const git_index_entry *entry;
-	int error, count = 0;
+	int error, count = 0, caps;
 	git_repository *repo = cl_git_sandbox_init(sandbox);
-	unsigned int caps;
 
 	cl_git_pass(git_repository_index(&index, repo));
 	caps = git_index_caps(index);
diff --git a/tests/threads/diff.c b/tests/threads/diff.c
index 33afc58ac..7f10a699d 100644
--- a/tests/threads/diff.c
+++ b/tests/threads/diff.c
@@ -1,9 +1,10 @@
 #include "clar_libgit2.h"
 #include "thread-utils.h"
 
-static git_repository *g_repo;
-static git_tree *a, *b;
-static git_atomic counts[4];
+static git_repository *_repo;
+static git_tree *_a, *_b;
+static git_atomic _counts[4];
+static int _check_counts;
 
 void test_threads_diff__cleanup(void)
 {
@@ -24,7 +25,7 @@ static void run_in_parallel(
 	cl_assert(id != NULL && th != NULL);
 
 	for (r = 0; r < repeats; ++r) {
-		g_repo = cl_git_sandbox_reopen(); /* reopen sandbox to flush caches */
+		_repo = cl_git_sandbox_reopen(); /* reopen sandbox to flush caches */
 
 		if (before_test) before_test();
 
@@ -53,24 +54,26 @@ static void run_in_parallel(
 static void setup_trees(void)
 {
 	cl_git_pass(git_revparse_single(
-		(git_object **)&a, g_repo, "0017bd4ab1^{tree}"));
+		(git_object **)&_a, _repo, "0017bd4ab1^{tree}"));
 	cl_git_pass(git_revparse_single(
-		(git_object **)&b, g_repo, "26a125ee1b^{tree}"));
+		(git_object **)&_b, _repo, "26a125ee1b^{tree}"));
 
-	memset(counts, 0, sizeof(counts));
+	memset(_counts, 0, sizeof(_counts));
 }
 
 #define THREADS 20
 
 static void free_trees(void)
 {
-	git_tree_free(a); a = NULL;
-	git_tree_free(b); b = NULL;
-
-	cl_assert_equal_i(288, git_atomic_get(&counts[0]));
-	cl_assert_equal_i(112, git_atomic_get(&counts[1]));
-	cl_assert_equal_i( 80, git_atomic_get(&counts[2]));
-	cl_assert_equal_i( 96, git_atomic_get(&counts[3]));
+	git_tree_free(_a); _a = NULL;
+	git_tree_free(_b); _b = NULL;
+
+	if (_check_counts) {
+		cl_assert_equal_i(288, git_atomic_get(&_counts[0]));
+		cl_assert_equal_i(112, git_atomic_get(&_counts[1]));
+		cl_assert_equal_i( 80, git_atomic_get(&_counts[2]));
+		cl_assert_equal_i( 96, git_atomic_get(&_counts[3]));
+	}
 }
 
 static void *run_index_diffs(void *arg)
@@ -81,48 +84,41 @@ static void *run_index_diffs(void *arg)
 	size_t i;
 	int exp[4] = { 0, 0, 0, 0 };
 
-//	fprintf(stderr, "%d >>>\n", thread);
-
 	switch (thread & 0x03) {
 	case 0: /* diff index to workdir */;
-		cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, &opts));
+		cl_git_pass(git_diff_index_to_workdir(&diff, _repo, NULL, &opts));
 		break;
 	case 1: /* diff tree 'a' to index */;
-		cl_git_pass(git_diff_tree_to_index(&diff, g_repo, a, NULL, &opts));
+		cl_git_pass(git_diff_tree_to_index(&diff, _repo, _a, NULL, &opts));
 		break;
 	case 2: /* diff tree 'b' to index */;
-		cl_git_pass(git_diff_tree_to_index(&diff, g_repo, b, NULL, &opts));
+		cl_git_pass(git_diff_tree_to_index(&diff, _repo, _b, NULL, &opts));
 		break;
 	case 3: /* diff index to workdir (explicit index) */;
 		{
 			git_index *idx;
-			cl_git_pass(git_repository_index(&idx, g_repo));
-			cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, idx, &opts));
+			cl_git_pass(git_repository_index(&idx, _repo));
+			cl_git_pass(git_diff_index_to_workdir(&diff, _repo, idx, &opts));
 			git_index_free(idx);
 			break;
 		}
 	}
 
-//	fprintf(stderr, "%d <<<\n", thread);
-
 	/* keep some diff stats to make sure results are as expected */
 
 	i = git_diff_num_deltas(diff);
-	git_atomic_add(&counts[0], (int32_t)i);
+	git_atomic_add(&_counts[0], (int32_t)i);
 	exp[0] = (int)i;
 
 	while (i > 0) {
 		switch (git_diff_get_delta(diff, --i)->status) {
-		case GIT_DELTA_MODIFIED: exp[1]++; git_atomic_inc(&counts[1]); break;
-		case GIT_DELTA_ADDED:    exp[2]++; git_atomic_inc(&counts[2]); break;
-		case GIT_DELTA_DELETED:  exp[3]++; git_atomic_inc(&counts[3]); break;
+		case GIT_DELTA_MODIFIED: exp[1]++; git_atomic_inc(&_counts[1]); break;
+		case GIT_DELTA_ADDED:    exp[2]++; git_atomic_inc(&_counts[2]); break;
+		case GIT_DELTA_DELETED:  exp[3]++; git_atomic_inc(&_counts[3]); break;
 		default: break;
 		}
 	}
 
-//	fprintf(stderr, "%2d: [%d] total %d (M %d A %d D %d)\n",
-//			thread, (int)(thread & 0x03), exp[0], exp[1], exp[2], exp[3]);
-
 	switch (thread & 0x03) {
 	case 0: case 3:
 		cl_assert_equal_i(8, exp[0]); cl_assert_equal_i(4, exp[1]);
@@ -145,8 +141,71 @@ static void *run_index_diffs(void *arg)
 
 void test_threads_diff__concurrent_diffs(void)
 {
-	g_repo = cl_git_sandbox_init("status");
+	_repo = cl_git_sandbox_init("status");
+	_check_counts = 1;
 
 	run_in_parallel(
 		20, 32, run_index_diffs, setup_trees, free_trees);
 }
+
+static void *run_index_diffs_with_modifier(void *arg)
+{
+	int thread = *(int *)arg;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_diff *diff = NULL;
+	git_index *idx = NULL;
+
+	cl_git_pass(git_repository_index(&idx, _repo));
+
+	/* have first thread altering the index as we go */
+	if (thread == 0) {
+		int i;
+
+		for (i = 0; i < 300; ++i) {
+			switch (i & 0x03) {
+			case 0: (void)git_index_add_bypath(idx, "new_file"); break;
+			case 1: (void)git_index_remove_bypath(idx, "modified_file"); break;
+			case 2: (void)git_index_remove_bypath(idx, "new_file"); break;
+			case 3: (void)git_index_add_bypath(idx, "modified_file"); break;
+			}
+			git_thread_yield();
+		}
+
+		git_index_free(idx);
+		return arg;
+	}
+
+	/* only use explicit index in this test to prevent reloading */
+
+	switch (thread & 0x03) {
+	case 0: /* diff index to workdir */;
+		cl_git_pass(git_diff_index_to_workdir(&diff, _repo, idx, &opts));
+		break;
+	case 1: /* diff tree 'a' to index */;
+		cl_git_pass(git_diff_tree_to_index(&diff, _repo, _a, idx, &opts));
+		break;
+	case 2: /* diff tree 'b' to index */;
+		cl_git_pass(git_diff_tree_to_index(&diff, _repo, _b, idx, &opts));
+		break;
+	case 3: /* diff index to workdir reversed */;
+		opts.flags |= GIT_DIFF_REVERSE;
+		cl_git_pass(git_diff_index_to_workdir(&diff, _repo, idx, &opts));
+		break;
+	}
+
+	/* results will be unpredictable with index modifier thread running */
+
+	git_diff_free(diff);
+	git_index_free(idx);
+
+	return arg;
+}
+
+void test_threads_diff__with_concurrent_index_modified(void)
+{
+	_repo = cl_git_sandbox_init("status");
+	_check_counts = 0;
+
+	run_in_parallel(
+		20, 32, run_index_diffs_with_modifier, setup_trees, free_trees);
+}
-- 
cgit v1.2.3


From 52bb0476a8ad462c56b1d2c68b6d5f20f947ee50 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 14 Mar 2014 13:53:15 -0700
Subject: Clean up index snapshot function naming

Clear up some of the various "find" functions and the snapshot
API naming to be things I like more.
---
 src/checkout.c |  6 ++--
 src/index.c    | 86 ++++++++++++++++++++++++++++++++--------------------------
 src/index.h    | 16 ++++++-----
 src/iterator.c |  7 ++---
 src/pathspec.c |  2 +-
 5 files changed, 63 insertions(+), 54 deletions(-)

diff --git a/src/checkout.c b/src/checkout.c
index a251c08c0..0b385226b 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -279,17 +279,17 @@ static int checkout_action_wd_only(
 	if (data->index != NULL) {
 		size_t pos;
 
-		error = git_index__find(
+		error = git_index__find_pos(
 			&pos, data->index, wd->path, 0, GIT_INDEX_STAGE_ANY);
 
 		if (wd->mode != GIT_FILEMODE_TREE) {
-			if (!error) { /* found by git_index__find call */
+			if (!error) { /* found by git_index__find_pos call */
 				notify = GIT_CHECKOUT_NOTIFY_DIRTY;
 				remove = ((data->strategy & GIT_CHECKOUT_FORCE) != 0);
 			} else if (error != GIT_ENOTFOUND)
 				return error;
 			else
-				error = 0; /* git_index__find does not set error msg */
+				error = 0; /* git_index__find_pos does not set error msg */
 		} else {
 			/* for tree entries, we have to see if there are any index
 			 * entries that are contained inside that tree
diff --git a/src/index.c b/src/index.c
index 094328b95..10fb1fea7 100644
--- a/src/index.c
+++ b/src/index.c
@@ -342,6 +342,28 @@ static int index_sort_if_needed(git_index *index, bool need_lock)
 	return 0;
 }
 
+GIT_INLINE(int) index_find_in_entries(
+	size_t *out, git_vector *entries, git_vector_cmp entry_srch,
+	const char *path, size_t path_len, int stage)
+{
+	struct entry_srch_key srch_key;
+	srch_key.path = path;
+	srch_key.pathlen = !path_len ? strlen(path) : path_len;
+	srch_key.stage = stage;
+	return git_vector_bsearch2(out, entries, entry_srch, &srch_key);
+}
+
+GIT_INLINE(int) index_find(
+	size_t *out, git_index *index,
+	const char *path, size_t path_len, int stage, bool need_lock)
+{
+	if (index_sort_if_needed(index, need_lock) < 0)
+		return -1;
+
+	return index_find_in_entries(
+		out, &index->entries, index->entries_search, path, path_len, stage);
+}
+
 void git_index__set_ignore_case(git_index *index, bool ignore_case)
 {
 	index->ignore_case = ignore_case;
@@ -687,16 +709,6 @@ size_t git_index_entrycount(const git_index *index)
 	return index->entries.length;
 }
 
-GIT_INLINE(int) git_index__find_internal(
-	size_t *out, git_index *index, const char *path, size_t path_len, int stage,
-	bool need_lock)
-{
-	if (index_sort_if_needed(index, need_lock) < 0)
-		return -1;
-	return git_index__find_in_entries(
-		out, &index->entries, index->entries_search, path, path_len, stage);
-}
-
 const git_index_entry *git_index_get_byindex(
 	git_index *index, size_t n)
 {
@@ -713,7 +725,7 @@ const git_index_entry *git_index_get_bypath(
 
 	assert(index);
 
-	if (git_index__find_internal(&pos, index, path, 0, stage, true) < 0) {
+	if (index_find(&pos, index, path, 0, stage, true) < 0) {
 		giterr_set(GITERR_INDEX, "Index does not contain %s", path);
 		return NULL;
 	}
@@ -896,7 +908,7 @@ static int has_dir_name(git_index *index,
 		}
 		len = slash - name;
 
-		if (!git_index__find_internal(&pos, index, name, len, stage, false)) {
+		if (!index_find(&pos, index, name, len, stage, false)) {
 			retval = -1;
 			if (!ok_to_replace)
 				break;
@@ -976,7 +988,7 @@ static int index_insert(
 	git_vector_sort(&index->entries);
 
 	/* look if an entry with this path already exists */
-	if (!git_index__find_internal(
+	if (!index_find(
 			&position, index, entry->path, 0, GIT_IDXENTRY_STAGE(entry), false)) {
 		existing = index->entries.contents[position];
 		/* update filemode to existing values if stat is not trusted */
@@ -1098,7 +1110,7 @@ int git_index_remove(git_index *index, const char *path, int stage)
 		return -1;
 	}
 
-	if (git_index__find_internal(&position, index, path, 0, stage, false) < 0) {
+	if (index_find(&position, index, path, 0, stage, false) < 0) {
 		giterr_set(
 			GITERR_INDEX, "Index does not contain %s at stage %d", path, stage);
 		error = GIT_ENOTFOUND;
@@ -1124,8 +1136,7 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 
 	if (!(error = git_buf_sets(&pfx, dir)) &&
 		!(error = git_path_to_dir(&pfx)))
-		git_index__find_internal(
-			&pos, index, pfx.ptr, pfx.size, GIT_INDEX_STAGE_ANY, false);
+		index_find(&pos, index, pfx.ptr, pfx.size, GIT_INDEX_STAGE_ANY, false);
 
 	while (!error) {
 		entry = git_vector_get(&index->entries, pos);
@@ -1148,22 +1159,11 @@ int git_index_remove_directory(git_index *index, const char *dir, int stage)
 	return error;
 }
 
-int git_index__find_in_entries(
-	size_t *out, git_vector *entries, git_vector_cmp entry_srch,
-	const char *path, size_t path_len, int stage)
-{
-	struct entry_srch_key srch_key;
-	srch_key.path = path;
-	srch_key.pathlen = !path_len ? strlen(path) : path_len;
-	srch_key.stage = stage;
-	return git_vector_bsearch2(out, entries, entry_srch, &srch_key);
-}
-
-int git_index__find(
+int git_index__find_pos(
 	size_t *out, git_index *index, const char *path, size_t path_len, int stage)
 {
 	assert(index && path);
-	return git_index__find_internal(out, index, path, path_len, stage, true);
+	return index_find(out, index, path, path_len, stage, true);
 }
 
 int git_index_find(size_t *at_pos, git_index *index, const char *path)
@@ -1177,7 +1177,8 @@ int git_index_find(size_t *at_pos, git_index *index, const char *path)
 		return -1;
 	}
 
-	if (git_vector_bsearch2(&pos, &index->entries, index->entries_search_path, path) < 0) {
+	if (git_vector_bsearch2(
+			&pos, &index->entries, index->entries_search_path, path) < 0) {
 		git_mutex_unlock(&index->lock);
 		giterr_set(GITERR_INDEX, "Index does not contain %s", path);
 		return GIT_ENOTFOUND;
@@ -1186,13 +1187,11 @@ int git_index_find(size_t *at_pos, git_index *index, const char *path)
 	/* Since our binary search only looked at path, we may be in the
 	 * middle of a list of stages.
 	 */
-	while (pos > 0) {
-		const git_index_entry *prev = git_vector_get(&index->entries, pos-1);
+	for (; pos > 0; --pos) {
+		const git_index_entry *prev = git_vector_get(&index->entries, pos - 1);
 
 		if (index->entries_cmp_path(prev->path, path) != 0)
 			break;
-
-		--pos;
 	}
 
 	if (at_pos)
@@ -2269,7 +2268,7 @@ static int read_tree_cb(
 
 	/* look for corresponding old entry and copy data to new entry */
 	if (data->old_entries != NULL &&
-		!git_index__find_in_entries(
+		!index_find_in_entries(
 			&pos, data->old_entries, data->entry_cmp, path.ptr, 0, 0) &&
 		(old_entry = git_vector_get(data->old_entries, pos)) != NULL &&
 		entry->mode == old_entry->mode &&
@@ -2394,7 +2393,7 @@ int git_index_add_all(
 		/* skip ignored items that are not already in the index */
 		if ((flags & GIT_INDEX_ADD_FORCE) == 0 &&
 			git_iterator_current_is_ignored(wditer) &&
-			git_index__find(&existing, index, wd->path, 0, 0) < 0)
+			index_find(&existing, index, wd->path, 0, 0, true) < 0)
 			continue;
 
 		/* issue notification callback if requested */
@@ -2556,7 +2555,7 @@ int git_index_update_all(
 	return error;
 }
 
-int git_index__snapshot(git_vector *entries, git_index *index)
+int git_index_snapshot_new(git_vector *snap, git_index *index)
 {
 	int error;
 
@@ -2570,7 +2569,7 @@ int git_index__snapshot(git_vector *entries, git_index *index)
 	git_atomic_inc(&index->readers);
 	git_vector_sort(&index->entries);
 
-	error = git_vector_dup(entries, &index->entries, index->entries._cmp);
+	error = git_vector_dup(snap, &index->entries, index->entries._cmp);
 
 	git_mutex_unlock(&index->lock);
 
@@ -2580,8 +2579,10 @@ int git_index__snapshot(git_vector *entries, git_index *index)
 	return error;
 }
 
-void git_index__release_snapshot(git_index *index)
+void git_index_snapshot_release(git_vector *snap, git_index *index)
 {
+	git_vector_free(snap);
+
 	git_atomic_dec(&index->readers);
 
 	if (!git_mutex_lock(&index->lock)) {
@@ -2591,3 +2592,10 @@ void git_index__release_snapshot(git_index *index)
 
 	git_index_free(index);
 }
+
+int git_index_snapshot_find(
+	size_t *out, git_vector *entries, git_vector_cmp entry_srch,
+	const char *path, size_t path_len, int stage)
+{
+	return index_find_in_entries(out, entries, entry_srch, path, path_len, stage);
+}
diff --git a/src/index.h b/src/index.h
index cb4425885..50a0b4b6c 100644
--- a/src/index.h
+++ b/src/index.h
@@ -61,11 +61,13 @@ extern int git_index_entry_icmp(const void *a, const void *b);
 extern int git_index_entry_srch(const void *a, const void *b);
 extern int git_index_entry_isrch(const void *a, const void *b);
 
-/* Search index for `path`, returning GIT_ENOTFOUND if it does not exist.
+/* Search index for `path`, returning GIT_ENOTFOUND if it does not exist
+ * (but not setting an error message).
+ *
  * `at_pos` is set to the position where it is or would be inserted.
  * Pass `path_len` as strlen of path or 0 to call strlen internally.
  */
-extern int git_index__find(
+extern int git_index__find_pos(
 	size_t *at_pos, git_index *index, const char *path, size_t path_len, int stage);
 
 extern void git_index__set_ignore_case(git_index *index, bool ignore_case);
@@ -82,13 +84,13 @@ extern int git_index__changed_relative_to(git_index *index, const git_futils_fil
 /* Copy the current entries vector *and* increment the index refcount.
  * Call `git_index__release_snapshot` when done.
  */
-extern int git_index__snapshot(git_vector *entries, git_index *index);
-extern void git_index__release_snapshot(git_index *index);
+extern int git_index_snapshot_new(git_vector *snap, git_index *index);
+extern void git_index_snapshot_release(git_vector *snap, git_index *index);
 
 /* Allow searching in a snapshot; entries must already be sorted! */
-extern int git_index__find_in_entries(
-	size_t *at_pos,
-	git_vector *entries, git_vector_cmp entry_srch,
+extern int git_index_snapshot_find(
+	size_t *at_pos, git_vector *snap, git_vector_cmp entry_srch,
 	const char *path, size_t path_len, int stage);
 
+
 #endif
diff --git a/src/iterator.c b/src/iterator.c
index 53ef278d1..63c14f962 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -820,7 +820,7 @@ static int index_iterator__reset(
 	ii->current = 0;
 
 	if (ii->base.start)
-		git_index__find_in_entries(
+		git_index_snapshot_find(
 			&ii->current, &ii->entries, ii->entry_srch, ii->base.start, 0, 0);
 
 	if ((ie = index_iterator__skip_conflicts(ii)) == NULL)
@@ -846,9 +846,8 @@ static int index_iterator__reset(
 static void index_iterator__free(git_iterator *self)
 {
 	index_iterator *ii = (index_iterator *)self;
-	git_index__release_snapshot(ii->index);
+	git_index_snapshot_release(&ii->entries, ii->index);
 	ii->index = NULL;
-	git_vector_free(&ii->entries);
 	git_buf_free(&ii->partial);
 }
 
@@ -863,7 +862,7 @@ int git_iterator_for_index(
 	index_iterator *ii = git__calloc(1, sizeof(index_iterator));
 	GITERR_CHECK_ALLOC(ii);
 
-	if ((error = git_index__snapshot(&ii->entries, index)) < 0) {
+	if ((error = git_index_snapshot_new(&ii->entries, index)) < 0) {
 		git__free(ii);
 		return error;
 	}
diff --git a/src/pathspec.c b/src/pathspec.c
index 471488495..09650de7c 100644
--- a/src/pathspec.c
+++ b/src/pathspec.c
@@ -445,7 +445,7 @@ static int pathspec_match_from_iterator(
 		/* check if path is ignored and untracked */
 		if (index != NULL &&
 			git_iterator_current_is_ignored(iter) &&
-			git_index__find(NULL, index, entry->path, 0, GIT_INDEX_STAGE_ANY) < 0)
+			git_index__find_pos(NULL, index, entry->path, 0, GIT_INDEX_STAGE_ANY) < 0)
 			continue;
 
 		/* mark the matched pattern as used */
-- 
cgit v1.2.3


From 3816debc13e8d5b96ad40be95a09fe67f6fa5a96 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 14 Mar 2014 14:51:04 -0700
Subject: Fix threading tests when threads disabled

---
 src/global.c         | 20 ++++++++++----------
 tests/threads/diff.c |  3 ++-
 2 files changed, 12 insertions(+), 11 deletions(-)

diff --git a/src/global.c b/src/global.c
index c26b4b311..15baf1eb8 100644
--- a/src/global.c
+++ b/src/global.c
@@ -16,8 +16,9 @@ git_mutex git__mwindow_mutex;
 
 #define MAX_SHUTDOWN_CB 8
 
-git_global_shutdown_fn git__shutdown_callbacks[MAX_SHUTDOWN_CB];
-git_atomic git__n_shutdown_callbacks;
+static git_global_shutdown_fn git__shutdown_callbacks[MAX_SHUTDOWN_CB];
+static git_atomic git__n_shutdown_callbacks;
+static git_atomic git__n_inits;
 
 void git__on_shutdown(git_global_shutdown_fn callback)
 {
@@ -74,7 +75,6 @@ static void git__shutdown(void)
 
 static DWORD _tls_index;
 static DWORD _mutex = 0;
-static DWORD _n_inits = 0;
 
 static int synchronized_threads_init()
 {
@@ -101,7 +101,7 @@ int git_threads_init(void)
 	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }
 
 	/* Only do work on a 0 -> 1 transition of the refcount */
-	if (1 == ++_n_inits)
+	if (1 == git_atomic_inc(&git__n_inits))
 		error = synchronized_threads_init();
 
 	/* Exit the lock */
@@ -124,7 +124,7 @@ void git_threads_shutdown(void)
 	while (InterlockedCompareExchange(&_mutex, 1, 0)) { Sleep(0); }
 
 	/* Only do work on a 1 -> 0 transition of the refcount */
-	if (0 == --_n_inits)
+	if (0 == git_atomic_dec(&git__n_inits))
 		synchronized_threads_shutdown();
 
 	/* Exit the lock */
@@ -135,7 +135,7 @@ git_global_st *git__global_state(void)
 {
 	void *ptr;
 
-	assert(_n_inits);
+	assert(git_atomic_get(&git__n_inits) > 0);
 
 	if ((ptr = TlsGetValue(_tls_index)) != NULL)
 		return ptr;
@@ -153,7 +153,6 @@ git_global_st *git__global_state(void)
 
 static pthread_key_t _tls_key;
 static pthread_once_t _once_init = PTHREAD_ONCE_INIT;
-static git_atomic git__n_inits;
 int init_error = 0;
 
 static void cb__free_status(void *st)
@@ -204,7 +203,7 @@ git_global_st *git__global_state(void)
 {
 	void *ptr;
 
-	assert(git__n_inits.val);
+	assert(git_atomic_get(&git__n_inits) > 0);
 
 	if ((ptr = pthread_getspecific(_tls_key)) != NULL)
 		return ptr;
@@ -224,14 +223,15 @@ static git_global_st __state;
 
 int git_threads_init(void)
 {
-	/* noop */
+	git_atomic_inc(&git__n_inits);
 	return 0;
 }
 
 void git_threads_shutdown(void)
 {
 	/* Shut down any subsystems that have global state */
-	git__shutdown();
+	if (0 == git_atomic_dec(&git__n_inits))
+		git__shutdown();
 }
 
 git_global_st *git__global_state(void)
diff --git a/tests/threads/diff.c b/tests/threads/diff.c
index 7f10a699d..5565c4bf1 100644
--- a/tests/threads/diff.c
+++ b/tests/threads/diff.c
@@ -18,11 +18,12 @@ static void run_in_parallel(
 	int r, t, *id = git__calloc(threads, sizeof(int));
 #ifdef GIT_THREADS
 	git_thread *th = git__calloc(threads, sizeof(git_thread));
+	cl_assert(th != NULL);
 #else
 	void *th = NULL;
 #endif
 
-	cl_assert(id != NULL && th != NULL);
+	cl_assert(id != NULL);
 
 	for (r = 0; r < repeats; ++r) {
 		_repo = cl_git_sandbox_reopen(); /* reopen sandbox to flush caches */
-- 
cgit v1.2.3


From b87776151ad40caaec8bfe1becec4db429c9ea96 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 14 Mar 2014 15:37:42 -0700
Subject: Fix refcount issues with mutex protected ignores

Some ignore files were not being freed from the cache.
---
 src/ignore.c | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/ignore.c b/src/ignore.c
index 5cf4fca5c..9b3c6a8bc 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -204,9 +204,23 @@ int git_ignore__pop_dir(git_ignores *ign)
 
 void git_ignore__free(git_ignores *ignores)
 {
-	/* don't need to free ignores->ign_internal since it is in cache */
+	unsigned int i;
+	git_attr_file *file;
+
+	/* don't need to free ignores->ign_internal it is cached exactly once */
+
+	git_vector_foreach(&ignores->ign_path, i, file) {
+		git_attr_file__free(file);
+		ignores->ign_path.contents[i] = NULL;
+	}
 	git_vector_free(&ignores->ign_path);
+
+	git_vector_foreach(&ignores->ign_global, i, file) {
+		git_attr_file__free(file);
+		ignores->ign_global.contents[i] = NULL;
+	}
 	git_vector_free(&ignores->ign_global);
+
 	git_buf_free(&ignores->dir);
 }
 
-- 
cgit v1.2.3


From cef170abf2704a3e3aa109020f7041e43b5e4f71 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 14 Mar 2014 16:45:46 -0700
Subject: Fix leak when using push and pop with ignores

The iterator pushes and pops ignores incrementally onto a list as
it traverses the directory structure so that it doesn't have to
constantly recheck which ignore files apply.  With the new ref
counting, it wasn't decrementing the refcount on the ignores that
it removed from the vector.
---
 src/ignore.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/ignore.c b/src/ignore.c
index 9b3c6a8bc..0fb042a34 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -191,7 +191,10 @@ int git_ignore__pop_dir(git_ignores *ign)
 
 		if (ign->dir.size >= keylen &&
 			!memcmp(ign->dir.ptr + ign->dir.size - keylen, start, keylen))
+		{
+			git_attr_file__free(git_vector_last(&ign->ign_path));
 			git_vector_pop(&ign->ign_path);
+		}
 	}
 
 	if (--ign->depth > 0) {
-- 
cgit v1.2.3


From aba6b5edbd1d1f999086669eb8e2f553af0ac300 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 14 Mar 2014 21:59:26 -0700
Subject: Fix leak in git_index_conflict_cleanup

I introduced a leak into conflict cleanup by removing items from
inside the git_vector_remove_matching call.  This simplifies the
code to just use one common way for the two conflict cleanup APIs.

When an index has an active snapshot, removing an item can cause
an error (inserting into the deferred deletion vector), so I made
the git_index_conflict_cleanup API return an error code.  I felt
like this wasn't so bad since it is just like the other APIs.

I fixed up a couple of comments while I was changing the header.
---
 include/git2/index.h | 19 ++++++++++++-------
 src/index.c          | 32 ++++++++++----------------------
 2 files changed, 22 insertions(+), 29 deletions(-)

diff --git a/include/git2/index.h b/include/git2/index.h
index 4d33f13d2..05e58a632 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -575,8 +575,7 @@ GIT_EXTERN(int) git_index_update_all(
  * @param at_pos the address to which the position of the index entry is written (optional)
  * @param index an existing index object
  * @param path path to search
- * @return a zero-based position in the index if found;
- * GIT_ENOTFOUND otherwise
+ * @return a zero-based position in the index if found; GIT_ENOTFOUND otherwise
  */
 GIT_EXTERN(int) git_index_find(size_t *at_pos, git_index *index, const char *path);
 
@@ -620,6 +619,7 @@ GIT_EXTERN(int) git_index_conflict_add(
  * @param their_out Pointer to store the their entry
  * @param index an existing index object
  * @param path path to search
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_conflict_get(
 	const git_index_entry **ancestor_out,
@@ -632,16 +632,18 @@ GIT_EXTERN(int) git_index_conflict_get(
  * Removes the index entries that represent a conflict of a single file.
  *
  * @param index an existing index object
- * @param path to search
+ * @param path path to remove conflicts for
+ * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_conflict_remove(git_index *index, const char *path);
 
 /**
- * Remove all conflicts in the index (entries with a stage greater than 0.)
+ * Remove all conflicts in the index (entries with a stage greater than 0).
  *
  * @param index an existing index object
+ * @return 0 or an error code
  */
-GIT_EXTERN(void) git_index_conflict_cleanup(git_index *index);
+GIT_EXTERN(int) git_index_conflict_cleanup(git_index *index);
 
 /**
  * Determine if the index contains entries representing file conflicts.
@@ -651,9 +653,12 @@ GIT_EXTERN(void) git_index_conflict_cleanup(git_index *index);
 GIT_EXTERN(int) git_index_has_conflicts(const git_index *index);
 
 /**
- * Create an iterator for the conflicts in the index.  You may not modify the
- * index while iterating, the results are undefined.
+ * Create an iterator for the conflicts in the index.
+ *
+ * The index must not be modified while iterating; the results are undefined.
  *
+ * @param iterator_out The newly created conflict iterator
+ * @param index The index to scan
  * @return 0 or an error code
  */
 GIT_EXTERN(int) git_index_conflict_iterator_new(
diff --git a/src/index.c b/src/index.c
index 10fb1fea7..27a557cfb 100644
--- a/src/index.c
+++ b/src/index.c
@@ -1317,15 +1317,13 @@ int git_index_conflict_get(
 	return 0;
 }
 
-int git_index_conflict_remove(git_index *index, const char *path)
+static int index_conflict_remove(git_index *index, const char *path)
 {
-	size_t pos;
+	size_t pos = 0;
 	git_index_entry *conflict_entry;
 	int error = 0;
 
-	assert(index && path);
-
-	if (git_index_find(&pos, index, path) < 0)
+	if (path != NULL && git_index_find(&pos, index, path) < 0)
 		return GIT_ENOTFOUND;
 
 	if (git_mutex_lock(&index->lock) < 0) {
@@ -1335,7 +1333,8 @@ int git_index_conflict_remove(git_index *index, const char *path)
 
 	while ((conflict_entry = git_vector_get(&index->entries, pos)) != NULL) {
 
-		if (index->entries_cmp_path(conflict_entry->path, path) != 0)
+		if (path != NULL &&
+			index->entries_cmp_path(conflict_entry->path, path) != 0)
 			break;
 
 		if (GIT_IDXENTRY_STAGE(conflict_entry) == 0) {
@@ -1352,27 +1351,16 @@ int git_index_conflict_remove(git_index *index, const char *path)
 	return error;
 }
 
-static int index_conflicts_match(const git_vector *v, size_t idx, void *p)
+int git_index_conflict_remove(git_index *index, const char *path)
 {
-	git_index *index = p;
-	git_index_entry *entry = git_vector_get(v, idx);
-
-	if (GIT_IDXENTRY_STAGE(entry) > 0 &&
-		!index_remove_entry(index, idx))
-		return 1;
-
-	return 0;
+	assert(index && path);
+	return index_conflict_remove(index, path);
 }
 
-void git_index_conflict_cleanup(git_index *index)
+int git_index_conflict_cleanup(git_index *index)
 {
 	assert(index);
-
-	if (git_mutex_lock(&index->lock) < 0)
-		return;
-	git_vector_remove_matching(&index->entries, index_conflicts_match, index);
-	index_free_deleted(index);
-	git_mutex_unlock(&index->lock);
+	return index_conflict_remove(index, NULL);
 }
 
 int git_index_has_conflicts(const git_index *index)
-- 
cgit v1.2.3


From 1fa17b5c92cb92a2785fba403b87525169b205c0 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 14 Mar 2014 22:01:30 -0700
Subject: Minor tree cache speedups

While I was looking at the conflict cleanup code, I looked over at
the tree cache code, since we clear the tree cache for each entry
that gets removed and there is some redundancy there.  I made some
small tweaks to avoid extra calls to strchr and strlen in a few
circumstances.
---
 src/tree-cache.c | 27 ++++++++++-----------------
 src/tree-cache.h |  1 +
 2 files changed, 11 insertions(+), 17 deletions(-)

diff --git a/src/tree-cache.c b/src/tree-cache.c
index 1d3997154..49afd6e49 100644
--- a/src/tree-cache.c
+++ b/src/tree-cache.c
@@ -7,23 +7,16 @@
 
 #include "tree-cache.h"
 
-static git_tree_cache *find_child(const git_tree_cache *tree, const char *path)
+static git_tree_cache *find_child(
+	const git_tree_cache *tree, const char *path, const char *end)
 {
-	size_t i, dirlen;
-	const char *end;
-
-	end = strchr(path, '/');
-	if (end == NULL) {
-		end = strrchr(path, '\0');
-	}
-
-	dirlen = end - path;
+	size_t i, dirlen = end ? (size_t)(end - path) : strlen(path);
 
 	for (i = 0; i < tree->children_count; ++i) {
-		const char *childname = tree->children[i]->name;
+		git_tree_cache *child = tree->children[i];
 
-		if (strlen(childname) == dirlen && !memcmp(path, childname, dirlen))
-			return tree->children[i];
+		if (child->namelen == dirlen && !memcmp(path, child->name, dirlen))
+			return child;
 	}
 
 	return NULL;
@@ -44,7 +37,7 @@ void git_tree_cache_invalidate_path(git_tree_cache *tree, const char *path)
 		if (end == NULL) /* End of path */
 			break;
 
-		tree = find_child(tree, ptr);
+		tree = find_child(tree, ptr, end);
 		if (tree == NULL) /* We don't have that tree */
 			return;
 
@@ -64,10 +57,9 @@ const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char
 	while (1) {
 		end = strchr(ptr, '/');
 
-		tree = find_child(tree, ptr);
-		if (tree == NULL) { /* Can't find it */
+		tree = find_child(tree, ptr, end);
+		if (tree == NULL) /* Can't find it */
 			return NULL;
-		}
 
 		if (end == NULL || *end + 1 == '\0')
 			return tree;
@@ -100,6 +92,7 @@ static int read_tree_internal(git_tree_cache **out,
 	tree->parent = parent;
 
 	/* NUL-terminated tree name */
+	tree->namelen = name_len;
 	memcpy(tree->name, name_start, name_len);
 	tree->name[name_len] = '\0';
 
diff --git a/src/tree-cache.h b/src/tree-cache.h
index 805483a78..90c82dbbf 100644
--- a/src/tree-cache.h
+++ b/src/tree-cache.h
@@ -18,6 +18,7 @@ struct git_tree_cache {
 
 	ssize_t entries;
 	git_oid oid;
+	size_t namelen;
 	char name[GIT_FLEX_ARRAY];
 };
 
-- 
cgit v1.2.3


From 7d4908724fd7d4d8e096b4faf2c652ba5b77644e Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 10 Apr 2014 22:31:01 -0700
Subject: Attribute file cache refactor

This is a big refactoring of the attribute file cache to be a bit
simpler which in turn makes it easier to enforce a lock around any
updates to the cache so that it can be used in a threaded env.
Tons of changes to the attributes and ignores code.
---
 src/attr.c                     | 478 ++++-------------------------------------
 src/attr.h                     |  34 +--
 src/attr_file.c                | 326 +++++++++++++++++-----------
 src/attr_file.h                |  59 +++--
 src/attrcache.c                | 397 ++++++++++++++++++++++++++++++++++
 src/attrcache.h                |  55 ++++-
 src/fileops.c                  |   4 +-
 src/fileops.h                  |   9 +-
 src/ignore.c                   | 128 ++++++-----
 src/index.c                    |  17 +-
 src/sortedcache.c              |   5 +-
 src/submodule.c                |   2 -
 tests/attr/file.c              |  16 +-
 tests/attr/lookup.c            |  16 +-
 tests/threads/diff.c           |  49 +----
 tests/threads/iterator.c       |  49 +++++
 tests/threads/thread_helpers.c |  44 ++++
 tests/threads/thread_helpers.h |   8 +
 18 files changed, 940 insertions(+), 756 deletions(-)
 create mode 100644 src/attrcache.c
 create mode 100644 tests/threads/iterator.c
 create mode 100644 tests/threads/thread_helpers.c
 create mode 100644 tests/threads/thread_helpers.h

diff --git a/src/attr.c b/src/attr.c
index f52a8a97b..c53a728de 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -2,7 +2,7 @@
 #include "repository.h"
 #include "sysdir.h"
 #include "config.h"
-#include "attr.h"
+#include "attr_file.h"
 #include "ignore.h"
 #include "git2/oid.h"
 #include <ctype.h>
@@ -216,7 +216,6 @@ cleanup:
 	return error;
 }
 
-
 int git_attr_add_macro(
 	git_repository *repo,
 	const char *name,
@@ -251,261 +250,6 @@ int git_attr_add_macro(
 	return error;
 }
 
-bool git_attr_cache__is_cached(
-	git_repository *repo, git_attr_file_source source, const char *path)
-{
-	git_buf cache_key = GIT_BUF_INIT;
-	git_strmap *files = git_repository_attr_cache(repo)->files;
-	const char *workdir = git_repository_workdir(repo);
-	bool rval;
-
-	if (workdir && git__prefixcmp(path, workdir) == 0)
-		path += strlen(workdir);
-	if (git_buf_printf(&cache_key, "%d#%s", (int)source, path) < 0)
-		return false;
-
-	rval = git_strmap_exists(files, git_buf_cstr(&cache_key));
-
-	git_buf_free(&cache_key);
-
-	return rval;
-}
-
-static int load_attr_file(
-	const char **data,
-	git_futils_filestamp *stamp,
-	const char *filename)
-{
-	int error;
-	git_buf content = GIT_BUF_INIT;
-
-	error = git_futils_filestamp_check(stamp, filename);
-	if (error < 0)
-		return error;
-
-	/* if error == 0, then file is up to date. By returning GIT_ENOTFOUND,
-	 * we tell the caller not to reparse this file...
-	 */
-	if (!error)
-		return GIT_ENOTFOUND;
-
-	error = git_futils_readbuffer(&content, filename);
-	if (error < 0) {
-		/* convert error into ENOTFOUND so failed permissions / invalid
-		 * file type don't actually stop the operation in progress.
-		 */
-		return GIT_ENOTFOUND;
-
-		/* TODO: once warnings are available, issue a warning callback */
-	}
-
-	*data = git_buf_detach(&content);
-
-	return 0;
-}
-
-static int load_attr_blob_from_index(
-	const char **content,
-	git_blob **blob,
-	git_repository *repo,
-	const git_oid *old_oid,
-	const char *relfile)
-{
-	int error;
-	size_t pos;
-	git_index *index;
-	const git_index_entry *entry;
-
-	if ((error = git_repository_index__weakptr(&index, repo)) < 0 ||
-		(error = git_index_find(&pos, index, relfile)) < 0)
-		return error;
-
-	entry = git_index_get_byindex(index, pos);
-
-	if (old_oid && git_oid__cmp(old_oid, &entry->id) == 0)
-		return GIT_ENOTFOUND;
-
-	if ((error = git_blob_lookup(blob, repo, &entry->id)) < 0)
-		return error;
-
-	*content = git_blob_rawcontent(*blob);
-	return 0;
-}
-
-static int load_attr_from_cache(
-	git_attr_file **file,
-	git_attr_cache *cache,
-	git_attr_file_source source,
-	const char *relative_path)
-{
-	git_buf  cache_key = GIT_BUF_INIT;
-	khiter_t cache_pos;
-
-	*file = NULL;
-
-	if (!cache || !cache->files)
-		return 0;
-
-	if (git_buf_printf(&cache_key, "%d#%s", (int)source, relative_path) < 0)
-		return -1;
-
-	if (git_mutex_lock(&cache->lock) < 0) {
-		giterr_set(GITERR_OS, "Could not get cache attr lock");
-		git_buf_free(&cache_key);
-		return -1;
-	}
-
-	cache_pos = git_strmap_lookup_index(cache->files, cache_key.ptr);
-
-	if (git_strmap_valid_index(cache->files, cache_pos)) {
-		*file = git_strmap_value_at(cache->files, cache_pos);
-		GIT_REFCOUNT_INC(*file);
-	}
-
-	git_mutex_unlock(&cache->lock);
-	git_buf_free(&cache_key);
-
-	return 0;
-}
-
-int git_attr_cache__internal_file(
-	git_repository *repo,
-	const char *filename,
-	git_attr_file **file)
-{
-	int error = 0;
-	git_attr_cache *cache = git_repository_attr_cache(repo);
-	khiter_t cache_pos;
-
-	if (git_mutex_lock(&cache->lock) < 0) {
-		giterr_set(GITERR_OS, "Unable to get attr cache lock");
-		return -1;
-	}
-
-	cache_pos = git_strmap_lookup_index(cache->files, filename);
-
-	if (git_strmap_valid_index(cache->files, cache_pos)) {
-		*file = git_strmap_value_at(cache->files, cache_pos);
-	}
-	else if (!(error = git_attr_file__new(file, 0, filename, &cache->pool))) {
-
-		git_strmap_insert(cache->files, (*file)->key + 2, *file, error);
-		if (error > 0)
-			error = 0;
-	}
-
-	git_mutex_unlock(&cache->lock);
-	return error;
-}
-
-int git_attr_cache__push_file(
-	git_repository *repo,
-	const char *base,
-	const char *filename,
-	git_attr_file_source source,
-	git_attr_file_parser parse,
-	void* parsedata,
-	git_vector *stack)
-{
-	int error = 0;
-	git_buf path = GIT_BUF_INIT;
-	const char *workdir = git_repository_workdir(repo);
-	const char *relfile, *content = NULL;
-	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_attr_file *file = NULL;
-	git_blob *blob = NULL;
-	git_futils_filestamp stamp;
-
-	assert(filename && stack);
-
-	/* join base and path as needed */
-	if (base != NULL && git_path_root(filename) < 0) {
-		if (git_buf_joinpath(&path, base, filename) < 0)
-			return -1;
-		filename = path.ptr;
-	}
-
-	relfile = filename;
-	if (workdir && git__prefixcmp(relfile, workdir) == 0)
-		relfile += strlen(workdir);
-
-	/* check cache */
-	if (load_attr_from_cache(&file, cache, source, relfile) < 0)
-		return -1;
-
-	/* if not in cache, load data, parse, and cache */
-
-	if (source == GIT_ATTR_FILE_FROM_FILE) {
-		git_futils_filestamp_set(
-			&stamp, file ? &file->cache_data.stamp : NULL);
-
-		error = load_attr_file(&content, &stamp, filename);
-	} else {
-		error = load_attr_blob_from_index(&content, &blob,
-			repo, file ? &file->cache_data.oid : NULL, relfile);
-	}
-
-	if (error) {
-		/* not finding a file is not an error for this function */
-		if (error == GIT_ENOTFOUND) {
-			giterr_clear();
-			error = 0;
-		}
-		goto finish;
-	}
-
-	/* if we got here, we have to parse and/or reparse the file */
-	if (file)
-		git_attr_file__clear_rules(file);
-	else {
-		error = git_attr_file__new(&file, source, relfile, &cache->pool);
-		if (error < 0)
-			goto finish;
-	}
-
-	if (parse && (error = parse(repo, parsedata, content, file)) < 0)
-		goto finish;
-
-	if (git_mutex_lock(&cache->lock) < 0) {
-		giterr_set(GITERR_OS, "Unable to get attr cache lock");
-		error = -1;
-	} else {
-		git_strmap_insert(cache->files, file->key, file, error); /* -V595 */
-		if (error > 0) { /* > 0 means inserting for the first time */
-			error = 0;
-			GIT_REFCOUNT_INC(file);
-		}
-		git_mutex_unlock(&cache->lock);
-	}
-
-	/* remember "cache buster" file signature */
-	if (blob)
-		git_oid_cpy(&file->cache_data.oid, git_object_id((git_object *)blob));
-	else
-		git_futils_filestamp_set(&file->cache_data.stamp, &stamp);
-
-finish:
-	/* push file onto vector if we found one*/
-	if (!error && file != NULL)
-		error = git_vector_insert(stack, file);
-
-	if (error != 0)
-		git_attr_file__free(file);
-
-	if (blob)
-		git_blob_free(blob);
-	else
-		git__free((void *)content);
-
-	git_buf_free(&path);
-
-	return error;
-}
-
-#define push_attr_file(R,S,B,F) \
-	git_attr_cache__push_file											\
-	((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,git_attr_file__parse_buffer,NULL,(S))
-
 typedef struct {
 	git_repository *repo;
 	uint32_t flags;
@@ -514,46 +258,64 @@ typedef struct {
 	git_vector *files;
 } attr_walk_up_info;
 
-int git_attr_cache__decide_sources(
-	uint32_t flags, bool has_wd, bool has_index, git_attr_file_source *srcs)
+static int attr_decide_sources(
+	uint32_t flags, bool has_wd, bool has_index, git_attr_cache_source *srcs)
 {
 	int count = 0;
 
 	switch (flags & 0x03) {
 	case GIT_ATTR_CHECK_FILE_THEN_INDEX:
 		if (has_wd)
-			srcs[count++] = GIT_ATTR_FILE_FROM_FILE;
+			srcs[count++] = GIT_ATTR_CACHE__FROM_FILE;
 		if (has_index)
-			srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;
+			srcs[count++] = GIT_ATTR_CACHE__FROM_INDEX;
 		break;
 	case GIT_ATTR_CHECK_INDEX_THEN_FILE:
 		if (has_index)
-			srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;
+			srcs[count++] = GIT_ATTR_CACHE__FROM_INDEX;
 		if (has_wd)
-			srcs[count++] = GIT_ATTR_FILE_FROM_FILE;
+			srcs[count++] = GIT_ATTR_CACHE__FROM_FILE;
 		break;
 	case GIT_ATTR_CHECK_INDEX_ONLY:
 		if (has_index)
-			srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;
+			srcs[count++] = GIT_ATTR_CACHE__FROM_INDEX;
 		break;
 	}
 
 	return count;
 }
 
+static int push_attr_file(
+	git_repository *repo,
+	git_vector *list,
+	git_attr_cache_source source,
+	const char *base,
+	const char *filename)
+{
+	int error = 0;
+	git_attr_file *file = NULL;
+
+	if ((error = git_attr_cache__get(
+			&file, repo, source, base, filename,
+			git_attr_file__parse_buffer, NULL)) < 0 ||
+		(error = git_vector_insert(list, file)) < 0)
+		git_attr_file__free(file);
+
+	return error;
+}
+
 static int push_one_attr(void *ref, git_buf *path)
 {
 	int error = 0, n_src, i;
 	attr_walk_up_info *info = (attr_walk_up_info *)ref;
-	git_attr_file_source src[2];
+	git_attr_cache_source src[2];
 
-	n_src = git_attr_cache__decide_sources(
+	n_src = attr_decide_sources(
 		info->flags, info->workdir != NULL, info->index != NULL, src);
 
 	for (i = 0; !error && i < n_src; ++i)
-		error = git_attr_cache__push_file(
-			info->repo, path->ptr, GIT_ATTR_FILE, src[i],
-			git_attr_file__parse_buffer, NULL, info->files);
+		error = push_attr_file(
+			info->repo, info->files, src[i], path->ptr, GIT_ATTR_FILE);
 
 	return error;
 }
@@ -601,7 +363,8 @@ static int collect_attr_files(
 	 */
 
 	error = push_attr_file(
-		repo, files, git_repository_path(repo), GIT_ATTR_FILE_INREPO);
+		repo, files, GIT_ATTR_CACHE__FROM_FILE,
+		git_repository_path(repo), GIT_ATTR_FILE_INREPO);
 	if (error < 0)
 		goto cleanup;
 
@@ -618,7 +381,8 @@ static int collect_attr_files(
 
 	if (git_repository_attr_cache(repo)->cfg_attr_file != NULL) {
 		error = push_attr_file(
-			repo, files, NULL, git_repository_attr_cache(repo)->cfg_attr_file);
+			repo, files, GIT_ATTR_CACHE__FROM_FILE,
+			NULL, git_repository_attr_cache(repo)->cfg_attr_file);
 		if (error < 0)
 			goto cleanup;
 	}
@@ -626,7 +390,8 @@ static int collect_attr_files(
 	if ((flags & GIT_ATTR_CHECK_NO_SYSTEM) == 0) {
 		error = git_sysdir_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);
 		if (!error)
-			error = push_attr_file(repo, files, NULL, dir.ptr);
+			error = push_attr_file(
+				repo, files, GIT_ATTR_CACHE__FROM_FILE, NULL, dir.ptr);
 		else if (error == GIT_ENOTFOUND) {
 			giterr_clear();
 			error = 0;
@@ -640,172 +405,3 @@ static int collect_attr_files(
 
 	return error;
 }
-
-static int attr_cache__lookup_path(
-	char **out, git_config *cfg, const char *key, const char *fallback)
-{
-	git_buf buf = GIT_BUF_INIT;
-	int error;
-	const git_config_entry *entry = NULL;
-
-	*out = NULL;
-
-	if ((error = git_config__lookup_entry(&entry, cfg, key, false)) < 0)
-		return error;
-
-	if (entry) {
-		const char *cfgval = entry->value;
-
-		/* expand leading ~/ as needed */
-		if (cfgval && cfgval[0] == '~' && cfgval[1] == '/' &&
-			!git_sysdir_find_global_file(&buf, &cfgval[2]))
-			*out = git_buf_detach(&buf);
-		else if (cfgval)
-			*out = git__strdup(cfgval);
-
-	}
-	else if (!git_sysdir_find_xdg_file(&buf, fallback))
-		*out = git_buf_detach(&buf);
-
-	git_buf_free(&buf);
-
-	return error;
-}
-
-static void attr_cache__free(git_attr_cache *cache)
-{
-	if (!cache)
-		return;
-
-	if (cache->files != NULL) {
-		git_attr_file *file;
-
-		git_strmap_foreach_value(cache->files, file, {
-			git_attr_file__free(file);
-		});
-
-		git_strmap_free(cache->files);
-	}
-
-	if (cache->macros != NULL) {
-		git_attr_rule *rule;
-
-		git_strmap_foreach_value(cache->macros, rule, {
-			git_attr_rule__free(rule);
-		});
-
-		git_strmap_free(cache->macros);
-	}
-
-	git_pool_clear(&cache->pool);
-
-	git__free(cache->cfg_attr_file);
-	cache->cfg_attr_file = NULL;
-
-	git__free(cache->cfg_excl_file);
-	cache->cfg_excl_file = NULL;
-
-	git_mutex_free(&cache->lock);
-
-	git__free(cache);
-}
-
-int git_attr_cache__init(git_repository *repo)
-{
-	int ret = 0;
-	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_config *cfg;
-
-	if (cache)
-		return 0;
-
-	if ((ret = git_repository_config__weakptr(&cfg, repo)) < 0)
-		return ret;
-
-	cache = git__calloc(1, sizeof(git_attr_cache));
-	GITERR_CHECK_ALLOC(cache);
-
-	/* set up lock */
-	if (git_mutex_init(&cache->lock) < 0) {
-		giterr_set(GITERR_OS, "Unable to initialize lock for attr cache");
-		git__free(cache);
-		return -1;
-	}
-
-	/* cache config settings for attributes and ignores */
-	ret = attr_cache__lookup_path(
-		&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG, GIT_ATTR_FILE_XDG);
-	if (ret < 0)
-		goto cancel;
-
-	ret = attr_cache__lookup_path(
-		&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG, GIT_IGNORE_FILE_XDG);
-	if (ret < 0)
-		goto cancel;
-
-	/* allocate hashtable for attribute and ignore file contents,
-	 * hashtable for attribute macros, and string pool
-	 */
-	if ((ret = git_strmap_alloc(&cache->files)) < 0 ||
-		(ret = git_strmap_alloc(&cache->macros)) < 0 ||
-		(ret = git_pool_init(&cache->pool, 1, 0)) < 0)
-		goto cancel;
-
-	cache = git__compare_and_swap(&repo->attrcache, NULL, cache);
-	if (cache)
-		goto cancel; /* raced with another thread, free this but no error */
-
-	/* insert default macros */
-	return git_attr_add_macro(repo, "binary", "-diff -crlf -text");
-
-cancel:
-	attr_cache__free(cache);
-	return ret;
-}
-
-void git_attr_cache_flush(git_repository *repo)
-{
-	git_attr_cache *cache;
-
-	/* this could be done less expensively, but for now, we'll just free
-	 * the entire attrcache and let the next use reinitialize it...
-	 */
-	if (repo && (cache = git__swap(repo->attrcache, NULL)) != NULL)
-		attr_cache__free(cache);
-}
-
-int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
-{
-	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_strmap *macros = cache->macros;
-	int error;
-
-	/* TODO: generate warning log if (macro->assigns.length == 0) */
-	if (macro->assigns.length == 0)
-		return 0;
-
-	if (git_mutex_lock(&cache->lock) < 0) {
-		giterr_set(GITERR_OS, "Unable to get attr cache lock");
-		error = -1;
-	} else {
-		git_strmap_insert(macros, macro->match.pattern, macro, error);
-		git_mutex_unlock(&cache->lock);
-	}
-
-	return (error < 0) ? -1 : 0;
-}
-
-git_attr_rule *git_attr_cache__lookup_macro(
-	git_repository *repo, const char *name)
-{
-	git_strmap *macros = git_repository_attr_cache(repo)->macros;
-	khiter_t pos;
-
-	pos = git_strmap_lookup_index(macros, name);
-
-	if (!git_strmap_valid_index(macros, pos))
-		return NULL;
-
-	return (git_attr_rule *)git_strmap_value_at(macros, pos);
-}
-
diff --git a/src/attr.h b/src/attr.h
index 19c979bcd..f9f216d07 100644
--- a/src/attr.h
+++ b/src/attr.h
@@ -8,38 +8,6 @@
 #define INCLUDE_attr_h__
 
 #include "attr_file.h"
-
-#define GIT_ATTR_CONFIG       "core.attributesfile"
-#define GIT_IGNORE_CONFIG     "core.excludesfile"
-
-typedef int (*git_attr_file_parser)(
-	git_repository *, void *, const char *, git_attr_file *);
-
-extern int git_attr_cache__insert_macro(
-	git_repository *repo, git_attr_rule *macro);
-
-extern git_attr_rule *git_attr_cache__lookup_macro(
-	git_repository *repo, const char *name);
-
-extern int git_attr_cache__push_file(
-	git_repository *repo,
-	const char *base,
-	const char *filename,
-	git_attr_file_source source,
-	git_attr_file_parser parse,
-	void *parsedata, /* passed through to parse function */
-	git_vector *stack);
-
-extern int git_attr_cache__internal_file(
-	git_repository *repo,
-	const char *key,
-	git_attr_file **file_ptr);
-
-/* returns true if path is in cache */
-extern bool git_attr_cache__is_cached(
-	git_repository *repo, git_attr_file_source source, const char *path);
-
-extern int git_attr_cache__decide_sources(
-	uint32_t flags, bool has_wd, bool has_index, git_attr_file_source *srcs);
+#include "attrcache.h"
 
 #endif
diff --git a/src/attr_file.c b/src/attr_file.c
index 695f661a8..86b3448ee 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -1,86 +1,173 @@
 #include "common.h"
 #include "repository.h"
 #include "filebuf.h"
-#include "attr.h"
+#include "attr_file.h"
 #include "git2/blob.h"
 #include "git2/tree.h"
+#include "index.h"
 #include <ctype.h>
 
-static int sort_by_hash_and_name(const void *a_raw, const void *b_raw);
-static void git_attr_rule__clear(git_attr_rule *rule);
-static bool parse_optimized_patterns(
-	git_attr_fnmatch *spec,
-	git_pool *pool,
-	const char *pattern);
+static void attr_file_free(git_attr_file *file)
+{
+	git_attr_file__clear_rules(file);
+	git_pool_clear(&file->pool);
+	git__memzero(file, sizeof(*file));
+	git__free(file);
+}
 
 int git_attr_file__new(
-	git_attr_file **attrs_ptr,
-	git_attr_file_source from,
-	const char *path,
-	git_pool *pool)
+	git_attr_file **out,
+	git_attr_cache_entry *ce,
+	git_attr_cache_source source)
 {
-	git_attr_file *attrs = NULL;
-
-	attrs = git__calloc(1, sizeof(git_attr_file));
+	git_attr_file *attrs = git__calloc(1, sizeof(git_attr_file));
 	GITERR_CHECK_ALLOC(attrs);
-	GIT_REFCOUNT_INC(attrs);
 
-	if (pool)
-		attrs->pool = pool;
-	else {
-		attrs->pool = git__calloc(1, sizeof(git_pool));
-		if (!attrs->pool || git_pool_init(attrs->pool, 1, 0) < 0)
-			goto fail;
-		attrs->pool_is_allocated = true;
+	if (git_pool_init(&attrs->pool, 1, 0) < 0 ||
+		git_vector_init(&attrs->rules, 0, NULL) < 0)
+	{
+		attr_file_free(attrs);
+		return -1;
 	}
 
-	if (path) {
-		size_t len = strlen(path);
+	GIT_REFCOUNT_INC(attrs);
+	attrs->ce = ce;
+	attrs->source = source;
+	*out = attrs;
+	return 0;
+}
 
-		attrs->key = git_pool_malloc(attrs->pool, (uint32_t)len + 3);
-		GITERR_CHECK_ALLOC(attrs->key);
+void git_attr_file__clear_rules(git_attr_file *file)
+{
+	unsigned int i;
+	git_attr_rule *rule;
 
-		attrs->key[0] = '0' + (char)from;
-		attrs->key[1] = '#';
-		memcpy(&attrs->key[2], path, len);
-		attrs->key[len + 2] = '\0';
-	}
+	git_vector_foreach(&file->rules, i, rule)
+		git_attr_rule__free(rule);
+	git_vector_free(&file->rules);
+}
+
+void git_attr_file__free(git_attr_file *file)
+{
+	if (!file)
+		return;
+	GIT_REFCOUNT_DEC(file, attr_file_free);
+}
+
+static int attr_file_oid_from_index(
+	git_oid *oid, git_repository *repo, const char *path)
+{
+	int error;
+	git_index *idx;
+	size_t pos;
+	const git_index_entry *entry;
 
-	if (git_vector_init(&attrs->rules, 4, NULL) < 0)
-		goto fail;
+	if ((error = git_repository_index__weakptr(&idx, repo)) < 0 ||
+		(error = git_index__find_pos(&pos, idx, path, 0, 0)) < 0)
+		return error;
 
-	*attrs_ptr = attrs;
+	if (!(entry = git_index_get_byindex(idx, pos)))
+		return GIT_ENOTFOUND;
+
+	*oid = entry->id;
 	return 0;
+}
+
+int git_attr_file__load(
+	git_attr_file **out,
+	git_repository *repo,
+	git_attr_cache_entry *ce,
+	git_attr_cache_source source,
+	git_attr_cache_parser parser,
+	void *payload)
+{
+	int error = 0;
+	git_blob *blob = NULL;
+	git_buf content = GIT_BUF_INIT;
+	const char *data = NULL;
+	git_attr_file *file;
 
-fail:
-	git_attr_file__free(attrs);
-	attrs_ptr = NULL;
-	return -1;
+	*out = NULL;
+
+	if (source == GIT_ATTR_CACHE__FROM_INDEX) {
+		git_oid id;
+
+		if ((error = attr_file_oid_from_index(&id, repo, ce->path)) < 0 ||
+			(error = git_blob_lookup(&blob, repo, &id)) < 0)
+			return error;
+
+		data = git_blob_rawcontent(blob);
+	} else {
+		if ((error = git_futils_readbuffer(&content, ce->fullpath)) < 0)
+			/* always return ENOTFOUND so item will just be skipped */
+			/* TODO: issue a warning once warnings API is available */
+			return GIT_ENOTFOUND;
+		data = content.ptr;
+	}
+
+	if ((error = git_attr_file__new(&file, ce, source)) < 0)
+		goto cleanup;
+
+	if (parser && (error = parser(repo, file, data, payload)) < 0)
+		git_attr_file__free(file);
+	else
+		*out = file;
+
+cleanup:
+	git_blob_free(blob);
+	git_buf_free(&content);
+
+	return error;
+}
+
+int git_attr_file__out_of_date(git_repository *repo, git_attr_file *file)
+{
+	if (!file)
+		return 1;
+
+	if (file->source == GIT_ATTR_CACHE__FROM_INDEX) {
+		int error;
+		git_oid id;
+
+		if ((error = attr_file_oid_from_index(&id, repo, file->ce->path)) < 0)
+			return error;
+
+		return (git_oid__cmp(&file->cache_data.oid, &id) != 0);
+	}
+
+	return git_futils_filestamp_check(
+		&file->cache_data.stamp, file->ce->fullpath);
 }
 
+static int sort_by_hash_and_name(const void *a_raw, const void *b_raw);
+static void git_attr_rule__clear(git_attr_rule *rule);
+static bool parse_optimized_patterns(
+	git_attr_fnmatch *spec,
+	git_pool *pool,
+	const char *pattern);
+
 int git_attr_file__parse_buffer(
-	git_repository *repo, void *parsedata, const char *buffer, git_attr_file *attrs)
+	git_repository *repo,
+	git_attr_file *attrs,
+	const char *data,
+	void *payload)
 {
 	int error = 0;
-	const char *scan = NULL, *context = NULL;
+	const char *scan = data, *context = NULL;
 	git_attr_rule *rule = NULL;
 
-	GIT_UNUSED(parsedata);
-
-	assert(buffer && attrs);
-
-	scan = buffer;
+	GIT_UNUSED(payload);
 
 	/* if subdir file path, convert context for file paths */
-	if (attrs->key &&
-		git_path_root(attrs->key + 2) < 0 &&
-		git__suffixcmp(attrs->key, "/" GIT_ATTR_FILE) == 0)
-		context = attrs->key + 2;
+	if (attrs->ce &&
+		git_path_root(attrs->ce->path) < 0 &&
+		!git__suffixcmp(attrs->ce->path, "/" GIT_ATTR_FILE))
+		context = attrs->ce->path;
 
 	while (!error && *scan) {
 		/* allocate rule if needed */
 		if (!rule) {
-			if (!(rule = git__calloc(1, sizeof(git_attr_rule)))) {
+			if (!(rule = git__calloc(1, sizeof(*rule)))) {
 				error = -1;
 				break;
 			}
@@ -90,9 +177,9 @@ int git_attr_file__parse_buffer(
 
 		/* parse the next "pattern attr attr attr" line */
 		if (!(error = git_attr_fnmatch__parse(
-				&rule->match, attrs->pool, context, &scan)) &&
+				&rule->match, &attrs->pool, context, &scan)) &&
 			!(error = git_attr_assignment__parse(
-				repo, attrs->pool, &rule->assigns, &scan)))
+				repo, &attrs->pool, &rule->assigns, &scan)))
 		{
 			if (rule->match.flags & GIT_ATTR_FNMATCH_MACRO)
 				/* should generate error/warning if this is coming from any
@@ -118,61 +205,6 @@ int git_attr_file__parse_buffer(
 	return error;
 }
 
-int git_attr_file__new_and_load(
-	git_attr_file **attrs_ptr,
-	const char *path)
-{
-	int error;
-	git_buf content = GIT_BUF_INIT;
-
-	if ((error = git_attr_file__new(attrs_ptr, 0, path, NULL)) < 0)
-		return error;
-
-	if (!(error = git_futils_readbuffer(&content, path)))
-		error = git_attr_file__parse_buffer(
-			NULL, NULL, git_buf_cstr(&content), *attrs_ptr);
-
-	git_buf_free(&content);
-
-	if (error) {
-		git_attr_file__free(*attrs_ptr);
-		*attrs_ptr = NULL;
-	}
-
-	return error;
-}
-
-void git_attr_file__clear_rules(git_attr_file *file)
-{
-	unsigned int i;
-	git_attr_rule *rule;
-
-	git_vector_foreach(&file->rules, i, rule)
-		git_attr_rule__free(rule);
-
-	git_vector_free(&file->rules);
-}
-
-static void attr_file_free(git_attr_file *file)
-{
-	git_attr_file__clear_rules(file);
-
-	if (file->pool_is_allocated) {
-		git_pool_clear(file->pool);
-		git__free(file->pool);
-	}
-	file->pool = NULL;
-
-	git__free(file);
-}
-
-void git_attr_file__free(git_attr_file *file)
-{
-	if (!file)
-		return;
-	GIT_REFCOUNT_DEC(file, attr_file_free);
-}
-
 uint32_t git_attr_file__name_hash(const char *name)
 {
 	uint32_t h = 5381;
@@ -183,7 +215,6 @@ uint32_t git_attr_file__name_hash(const char *name)
 	return h;
 }
 
-
 int git_attr_file__lookup_one(
 	git_attr_file *file,
 	const git_attr_path *path,
@@ -212,25 +243,64 @@ int git_attr_file__lookup_one(
 	return 0;
 }
 
+int git_attr_file__load_standalone(
+	git_attr_file **out,
+	const char *path)
+{
+	int error;
+	git_attr_file *file;
+	git_buf content = GIT_BUF_INIT;
+
+	error = git_attr_file__new(&file, NULL, GIT_ATTR_CACHE__FROM_FILE);
+	if (error < 0)
+		return error;
+
+	error = git_attr_cache_entry__new(&file->ce, NULL, path, &file->pool);
+	if (error < 0) {
+		git_attr_file__free(file);
+		return error;
+	}
+	/* because the cache entry is allocated from the file's own pool, we
+	 * don't have to free it - freeing file+pool will free cache entry, too.
+	 */
+
+	if (!(error = git_futils_readbuffer(&content, path))) {
+		error = git_attr_file__parse_buffer(NULL, file, content.ptr, NULL);
+		git_buf_free(&content);
+	}
+
+	if (error < 0)
+		git_attr_file__free(file);
+	else
+		*out = file;
+
+	return error;
+}
 
 bool git_attr_fnmatch__match(
 	git_attr_fnmatch *match,
 	const git_attr_path *path)
 {
-	int fnm;
-	int icase_flags = (match->flags & GIT_ATTR_FNMATCH_ICASE) ? FNM_CASEFOLD : 0;
+	const char *filename;
+	int flags = 0;
 
-	if (match->flags & GIT_ATTR_FNMATCH_DIRECTORY && !path->is_dir)
+	if ((match->flags & GIT_ATTR_FNMATCH_DIRECTORY) && !path->is_dir)
 		return false;
 
-	if (match->flags & GIT_ATTR_FNMATCH_FULLPATH)
-		fnm = p_fnmatch(match->pattern, path->path, FNM_PATHNAME | icase_flags);
-	else if (path->is_dir)
-		fnm = p_fnmatch(match->pattern, path->basename, FNM_LEADING_DIR | icase_flags);
-	else
-		fnm = p_fnmatch(match->pattern, path->basename, icase_flags);
+	if (match->flags & GIT_ATTR_FNMATCH_ICASE)
+		flags |= FNM_CASEFOLD;
 
-	return (fnm == FNM_NOMATCH) ? false : true;
+	if (match->flags & GIT_ATTR_FNMATCH_FULLPATH) {
+		filename = path->path;
+		flags |= FNM_PATHNAME;
+	} else {
+		filename = path->basename;
+
+		if (path->is_dir)
+			flags |= FNM_LEADING_DIR;
+	}
+
+	return (p_fnmatch(match->pattern, filename, flags) != FNM_NOMATCH);
 }
 
 bool git_attr_rule__match(
@@ -245,7 +315,6 @@ bool git_attr_rule__match(
 	return matched;
 }
 
-
 git_attr_assignment *git_attr_rule__lookup_assignment(
 	git_attr_rule *rule, const char *name)
 {
@@ -344,7 +413,7 @@ void git_attr_path__free(git_attr_path *info)
 int git_attr_fnmatch__parse(
 	git_attr_fnmatch *spec,
 	git_pool *pool,
-	const char *source,
+	const char *context,
 	const char **base)
 {
 	const char *pattern, *scan;
@@ -412,21 +481,21 @@ int git_attr_fnmatch__parse(
 	}
 
 	if ((spec->flags & GIT_ATTR_FNMATCH_FULLPATH) != 0 &&
-		source != NULL && git_path_root(pattern) < 0)
+		context != NULL && git_path_root(pattern) < 0)
 	{
-        /* use context path minus the trailing filename */
-        char *slash = strrchr(source, '/');
-        size_t sourcelen = slash ? slash - source + 1 : 0;
+		/* use context path minus the trailing filename */
+		char *slash = strrchr(context, '/');
+		size_t contextlen = slash ? slash - context + 1 : 0;
 
 		/* given an unrooted fullpath match from a file inside a repo,
 		 * prefix the pattern with the relative directory of the source file
 		 */
 		spec->pattern = git_pool_malloc(
-			pool, (uint32_t)(sourcelen + spec->length + 1));
+			pool, (uint32_t)(contextlen + spec->length + 1));
 		if (spec->pattern) {
-			memcpy(spec->pattern, source, sourcelen);
-			memcpy(spec->pattern + sourcelen, pattern, spec->length);
-			spec->length += sourcelen;
+			memcpy(spec->pattern, context, contextlen);
+			memcpy(spec->pattern + contextlen, pattern, spec->length);
+			spec->length += contextlen;
 			spec->pattern[spec->length] = '\0';
 		}
 	} else {
@@ -439,6 +508,7 @@ int git_attr_fnmatch__parse(
 	} else {
 		/* strip '\' that might have be used for internal whitespace */
 		spec->length = git__unescape(spec->pattern);
+		/* TODO: convert remaining '\' into '/' for POSIX ??? */
 	}
 
 	return 0;
diff --git a/src/attr_file.h b/src/attr_file.h
index dbd6696c9..f92ce3c96 100644
--- a/src/attr_file.h
+++ b/src/attr_file.h
@@ -13,6 +13,7 @@
 #include "pool.h"
 #include "buffer.h"
 #include "fileops.h"
+#include "attrcache.h"
 
 #define GIT_ATTR_FILE			".gitattributes"
 #define GIT_ATTR_FILE_INREPO	"info/attributes"
@@ -45,10 +46,10 @@ typedef struct {
 	unsigned int flags;
 } git_attr_fnmatch;
 
-typedef struct {
+struct git_attr_rule {
 	git_attr_fnmatch match;
 	git_vector assigns;		/* vector of <git_attr_assignment*> */
-} git_attr_rule;
+};
 
 typedef struct {
 	git_refcount unused;
@@ -63,17 +64,17 @@ typedef struct {
 	const char *value;
 } git_attr_assignment;
 
-typedef struct {
+struct git_attr_file {
 	git_refcount rc;
-	char *key;				/* cache "source#path" this was loaded from */
-	git_vector rules;		/* vector of <rule*> or <fnmatch*> */
-	git_pool *pool;
-	bool pool_is_allocated;
+	git_attr_cache_entry *ce;
+	git_attr_cache_source source;
+	git_vector rules;			/* vector of <rule*> or <fnmatch*> */
+	git_pool pool;
 	union {
 		git_oid oid;
 		git_futils_filestamp stamp;
 	} cache_data;
-} git_attr_file;
+};
 
 typedef struct {
 	git_buf  full;
@@ -82,29 +83,41 @@ typedef struct {
 	int      is_dir;
 } git_attr_path;
 
-typedef enum {
-	GIT_ATTR_FILE_FROM_FILE = 0,
-	GIT_ATTR_FILE_FROM_INDEX = 1
-} git_attr_file_source;
-
 /*
  * git_attr_file API
  */
 
-extern int git_attr_file__new(
-	git_attr_file **attrs_ptr, git_attr_file_source src, const char *path, git_pool *pool);
+int git_attr_file__new(
+	git_attr_file **out,
+	git_attr_cache_entry *ce,
+	git_attr_cache_source source);
+
+void git_attr_file__free(git_attr_file *file);
+
+int git_attr_file__load(
+	git_attr_file **out,
+	git_repository *repo,
+	git_attr_cache_entry *ce,
+	git_attr_cache_source source,
+	git_attr_cache_parser parser,
+	void *payload);
 
-extern int git_attr_file__new_and_load(
-	git_attr_file **attrs_ptr, const char *path);
+int git_attr_file__load_standalone(
+	git_attr_file **out,
+	const char *path);
 
-extern void git_attr_file__free(git_attr_file *file);
+int git_attr_file__out_of_date(
+	git_repository *repo, git_attr_file *file);
 
-extern void git_attr_file__clear_rules(git_attr_file *file);
+int git_attr_file__parse_buffer(
+	git_repository *repo,
+	git_attr_file *attrs,
+	const char *data,
+	void *payload);
 
-extern int git_attr_file__parse_buffer(
-	git_repository *repo, void *parsedata, const char *buf, git_attr_file *file);
+void git_attr_file__clear_rules(git_attr_file *file);
 
-extern int git_attr_file__lookup_one(
+int git_attr_file__lookup_one(
 	git_attr_file *file,
 	const git_attr_path *path,
 	const char *attr,
@@ -115,7 +128,7 @@ extern int git_attr_file__lookup_one(
 	git_vector_rforeach(&(file)->rules, (iter), (rule)) \
 		if (git_attr_rule__match((rule), (path)))
 
-extern uint32_t git_attr_file__name_hash(const char *name);
+uint32_t git_attr_file__name_hash(const char *name);
 
 
 /*
diff --git a/src/attrcache.c b/src/attrcache.c
new file mode 100644
index 000000000..6d097234c
--- /dev/null
+++ b/src/attrcache.c
@@ -0,0 +1,397 @@
+#include "common.h"
+#include "repository.h"
+#include "attr_file.h"
+#include "config.h"
+#include "sysdir.h"
+#include "ignore.h"
+
+GIT__USE_STRMAP;
+
+GIT_INLINE(int) attr_cache_lock(git_attr_cache *cache)
+{
+	GIT_UNUSED(cache); /* avoid warning if threading is off */
+
+	if (git_mutex_lock(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to get attr cache lock");
+		return -1;
+	}
+	return 0;
+}
+
+GIT_INLINE(void) attr_cache_unlock(git_attr_cache *cache)
+{
+	GIT_UNUSED(cache); /* avoid warning if threading is off */
+	git_mutex_unlock(&cache->lock);
+}
+
+GIT_INLINE(git_attr_cache_entry *) attr_cache_lookup_entry(
+	git_attr_cache *cache, const char *path)
+{
+	khiter_t pos = git_strmap_lookup_index(cache->files, path);
+
+	if (git_strmap_valid_index(cache->files, pos))
+		return git_strmap_value_at(cache->files, pos);
+	else
+		return NULL;
+}
+
+int git_attr_cache_entry__new(
+	git_attr_cache_entry **out,
+	const char *base,
+	const char *path,
+	git_pool *pool)
+{
+	size_t baselen = base ? strlen(base) : 0, pathlen = strlen(path);
+	size_t cachesize = sizeof(git_attr_cache_entry) + baselen + pathlen + 1;
+	git_attr_cache_entry *ce;
+
+	ce = git_pool_mallocz(pool, cachesize);
+	GITERR_CHECK_ALLOC(ce);
+
+	if (baselen)
+		memcpy(ce->fullpath, base, baselen);
+	memcpy(&ce->fullpath[baselen], path, pathlen);
+	ce->path = &ce->fullpath[baselen];
+	*out = ce;
+
+	return 0;
+}
+
+/* call with attrcache locked */
+static int attr_cache_make_entry(
+	git_attr_cache_entry **out, git_repository *repo, const char *path)
+{
+	int error = 0;
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_attr_cache_entry *ce = NULL;
+
+	error = git_attr_cache_entry__new(
+		&ce, git_repository_workdir(repo), path, &cache->pool);
+
+	if (!error) {
+		git_strmap_insert(cache->files, ce->path, ce, error);
+		if (error > 0)
+			error = 0;
+	}
+
+	*out = ce;
+	return error;
+}
+
+/* insert entry or replace existing if we raced with another thread */
+static int attr_cache_upsert(git_attr_cache *cache, git_attr_file *file)
+{
+	git_attr_cache_entry *ce;
+	git_attr_file *old;
+
+	if (attr_cache_lock(cache) < 0)
+		return -1;
+
+	ce = attr_cache_lookup_entry(cache, file->ce->path);
+
+	old = ce->file[file->source];
+
+	GIT_REFCOUNT_OWN(file, ce);
+	GIT_REFCOUNT_INC(file);
+	ce->file[file->source] = file;
+
+	if (old) {
+		GIT_REFCOUNT_OWN(old, NULL);
+		git_attr_file__free(old);
+	}
+
+	attr_cache_unlock(cache);
+	return 0;
+}
+
+static int attr_cache_remove(git_attr_cache *cache, git_attr_file *file)
+{
+	int error = 0;
+	git_attr_cache_entry *ce;
+	bool found = false;
+
+	if (!file)
+		return 0;
+	if ((error = attr_cache_lock(cache)) < 0)
+		return error;
+
+	if ((ce = attr_cache_lookup_entry(cache, file->ce->path)) != NULL &&
+		ce->file[file->source] == file)
+	{
+		ce->file[file->source] = NULL;
+		found = true;
+	}
+
+	attr_cache_unlock(cache);
+
+	if (found)
+		git_attr_file__free(file);
+
+	return error;
+}
+
+int git_attr_cache__get(
+	git_attr_file **out,
+	git_repository *repo,
+	git_attr_cache_source source,
+	const char *base,
+	const char *filename,
+	git_attr_cache_parser parser,
+	void *payload)
+{
+	int error = 0;
+	git_buf path = GIT_BUF_INIT;
+	const char *wd = git_repository_workdir(repo), *relfile;
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_attr_cache_entry *ce = NULL;
+	git_attr_file *file = NULL;
+
+	/* join base and path as needed */
+	if (base != NULL && git_path_root(filename) < 0) {
+		if (git_buf_joinpath(&path, base, filename) < 0)
+			return -1;
+		filename = path.ptr;
+	}
+
+	relfile = filename;
+	if (wd && !git__prefixcmp(relfile, wd))
+		relfile += strlen(wd);
+
+	/* check cache for existing entry */
+	if ((error = attr_cache_lock(cache)) < 0)
+		goto cleanup;
+
+	ce = attr_cache_lookup_entry(cache, relfile);
+	if (!ce) {
+		if ((error = attr_cache_make_entry(&ce, repo, relfile)) < 0)
+			goto cleanup;
+	} else if (ce->file[source] != NULL) {
+		file = ce->file[source];
+		GIT_REFCOUNT_INC(file);
+	}
+
+	attr_cache_unlock(cache);
+
+	/* if this is not a file backed entry, just create a new empty one */
+	if (!parser) {
+		error = git_attr_file__new(&file, ce, source);
+		goto cleanup;
+	}
+
+	/* otherwise load and/or reload as needed */
+	switch (git_attr_file__out_of_date(repo, file)) {
+	case 1:
+		if (!(error = git_attr_file__load(
+				  &file, repo, ce, source, parser, payload)))
+			error = attr_cache_upsert(cache, file);
+		break;
+	case 0:
+		/* just use the file */
+		break;
+	case GIT_ENOTFOUND:
+		/* did exist and now does not - remove from cache */
+		error = attr_cache_remove(cache, file);
+		file = NULL;
+		break;
+	default:
+		/* other error (e.g. out of memory, can't read index) */
+		giterr_clear();
+		break;
+	}
+
+cleanup:
+	*out = error ? NULL : file;
+	git_buf_free(&path);
+	return error;
+}
+
+bool git_attr_cache__is_cached(
+	git_repository *repo,
+	git_attr_cache_source source,
+	const char *filename)
+{
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_strmap *files;
+	khiter_t pos;
+	git_attr_cache_entry *ce;
+
+	if (!(cache = git_repository_attr_cache(repo)) ||
+		!(files = cache->files))
+		return false;
+
+	pos = git_strmap_lookup_index(files, filename);
+	if (!git_strmap_valid_index(files, pos))
+		return false;
+
+	ce = git_strmap_value_at(files, pos);
+
+	return ce && (ce->file[source] != NULL);
+}
+
+
+static int attr_cache__lookup_path(
+	char **out, git_config *cfg, const char *key, const char *fallback)
+{
+	git_buf buf = GIT_BUF_INIT;
+	int error;
+	const git_config_entry *entry = NULL;
+
+	*out = NULL;
+
+	if ((error = git_config__lookup_entry(&entry, cfg, key, false)) < 0)
+		return error;
+
+	if (entry) {
+		const char *cfgval = entry->value;
+
+		/* expand leading ~/ as needed */
+		if (cfgval && cfgval[0] == '~' && cfgval[1] == '/' &&
+			!git_sysdir_find_global_file(&buf, &cfgval[2]))
+			*out = git_buf_detach(&buf);
+		else if (cfgval)
+			*out = git__strdup(cfgval);
+
+	}
+	else if (!git_sysdir_find_xdg_file(&buf, fallback))
+		*out = git_buf_detach(&buf);
+
+	git_buf_free(&buf);
+
+	return error;
+}
+
+static void attr_cache__free(git_attr_cache *cache)
+{
+	if (!cache)
+		return;
+
+	if (cache->files != NULL) {
+		git_attr_file *file;
+
+		git_strmap_foreach_value(cache->files, file, {
+			git_attr_file__free(file);
+		});
+		git_strmap_free(cache->files);
+	}
+
+	if (cache->macros != NULL) {
+		git_attr_rule *rule;
+
+		git_strmap_foreach_value(cache->macros, rule, {
+			git_attr_rule__free(rule);
+		});
+		git_strmap_free(cache->macros);
+	}
+
+	git_pool_clear(&cache->pool);
+
+	git__free(cache->cfg_attr_file);
+	cache->cfg_attr_file = NULL;
+
+	git__free(cache->cfg_excl_file);
+	cache->cfg_excl_file = NULL;
+
+	git_mutex_free(&cache->lock);
+
+	git__free(cache);
+}
+
+int git_attr_cache__init(git_repository *repo)
+{
+	int ret = 0;
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_config *cfg;
+
+	if (cache)
+		return 0;
+
+	if ((ret = git_repository_config__weakptr(&cfg, repo)) < 0)
+		return ret;
+
+	cache = git__calloc(1, sizeof(git_attr_cache));
+	GITERR_CHECK_ALLOC(cache);
+
+	/* set up lock */
+	if (git_mutex_init(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to initialize lock for attr cache");
+		git__free(cache);
+		return -1;
+	}
+
+	/* cache config settings for attributes and ignores */
+	ret = attr_cache__lookup_path(
+		&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG, GIT_ATTR_FILE_XDG);
+	if (ret < 0)
+		goto cancel;
+
+	ret = attr_cache__lookup_path(
+		&cache->cfg_excl_file, cfg, GIT_IGNORE_CONFIG, GIT_IGNORE_FILE_XDG);
+	if (ret < 0)
+		goto cancel;
+
+	/* allocate hashtable for attribute and ignore file contents,
+	 * hashtable for attribute macros, and string pool
+	 */
+	if ((ret = git_strmap_alloc(&cache->files)) < 0 ||
+		(ret = git_strmap_alloc(&cache->macros)) < 0 ||
+		(ret = git_pool_init(&cache->pool, 1, 0)) < 0)
+		goto cancel;
+
+	cache = git__compare_and_swap(&repo->attrcache, NULL, cache);
+	if (cache)
+		goto cancel; /* raced with another thread, free this but no error */
+
+	/* insert default macros */
+	return git_attr_add_macro(repo, "binary", "-diff -crlf -text");
+
+cancel:
+	attr_cache__free(cache);
+	return ret;
+}
+
+void git_attr_cache_flush(git_repository *repo)
+{
+	git_attr_cache *cache;
+
+	/* this could be done less expensively, but for now, we'll just free
+	 * the entire attrcache and let the next use reinitialize it...
+	 */
+	if (repo && (cache = git__swap(repo->attrcache, NULL)) != NULL)
+		attr_cache__free(cache);
+}
+
+int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
+{
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_strmap *macros = cache->macros;
+	int error;
+
+	/* TODO: generate warning log if (macro->assigns.length == 0) */
+	if (macro->assigns.length == 0)
+		return 0;
+
+	if (git_mutex_lock(&cache->lock) < 0) {
+		giterr_set(GITERR_OS, "Unable to get attr cache lock");
+		error = -1;
+	} else {
+		git_strmap_insert(macros, macro->match.pattern, macro, error);
+		git_mutex_unlock(&cache->lock);
+	}
+
+	return (error < 0) ? -1 : 0;
+}
+
+git_attr_rule *git_attr_cache__lookup_macro(
+	git_repository *repo, const char *name)
+{
+	git_strmap *macros = git_repository_attr_cache(repo)->macros;
+	khiter_t pos;
+
+	pos = git_strmap_lookup_index(macros, name);
+
+	if (!git_strmap_valid_index(macros, pos))
+		return NULL;
+
+	return (git_attr_rule *)git_strmap_value_at(macros, pos);
+}
+
diff --git a/src/attrcache.h b/src/attrcache.h
index 4f9cff6bb..8e7f022b0 100644
--- a/src/attrcache.h
+++ b/src/attrcache.h
@@ -9,11 +9,15 @@
 
 #include "pool.h"
 #include "strmap.h"
+#include "buffer.h"
+
+#define GIT_ATTR_CONFIG       "core.attributesfile"
+#define GIT_IGNORE_CONFIG     "core.excludesfile"
 
 typedef struct {
 	char *cfg_attr_file; /* cached value of core.attributesfile */
 	char *cfg_excl_file; /* cached value of core.excludesfile */
-	git_strmap *files;	 /* hash path to git_attr_file of rules */
+	git_strmap *files;	 /* hash path to git_attr_cache_entry records */
 	git_strmap *macros;	 /* hash name to vector<git_attr_assignment> */
 	git_mutex lock;
 	git_pool  pool;
@@ -21,4 +25,53 @@ typedef struct {
 
 extern int git_attr_cache__init(git_repository *repo);
 
+typedef enum {
+	GIT_ATTR_CACHE__FROM_FILE = 0,
+	GIT_ATTR_CACHE__FROM_INDEX = 1,
+
+	GIT_ATTR_CACHE_NUM_SOURCES = 2
+} git_attr_cache_source;
+
+typedef struct git_attr_file git_attr_file;
+typedef struct git_attr_rule git_attr_rule;
+
+typedef struct {
+	git_attr_file *file[GIT_ATTR_CACHE_NUM_SOURCES];
+	const char *path; /* points into fullpath */
+	char fullpath[GIT_FLEX_ARRAY];
+} git_attr_cache_entry;
+
+typedef int (*git_attr_cache_parser)(
+	git_repository *repo,
+	git_attr_file *file,
+	const char *data,
+	void *payload);
+
+/* get file - loading and reload as needed */
+extern int git_attr_cache__get(
+	git_attr_file **file,
+	git_repository *repo,
+	git_attr_cache_source source,
+	const char *base,
+	const char *filename,
+	git_attr_cache_parser parser,
+	void *payload);
+
+extern bool git_attr_cache__is_cached(
+	git_repository *repo,
+	git_attr_cache_source source,
+	const char *path);
+
+extern int git_attr_cache__insert_macro(
+	git_repository *repo, git_attr_rule *macro);
+
+extern git_attr_rule *git_attr_cache__lookup_macro(
+	git_repository *repo, const char *name);
+
+extern int git_attr_cache_entry__new(
+	git_attr_cache_entry **out,
+	const char *base,
+	const char *path,
+	git_pool *pool);
+
 #endif
diff --git a/src/fileops.c b/src/fileops.c
index 5709499b0..d8d819151 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -804,10 +804,8 @@ int git_futils_filestamp_check(
 	if (stamp == NULL)
 		return 1;
 
-	if (p_stat(path, &st) < 0) {
-		giterr_set(GITERR_OS, "Could not stat '%s'", path);
+	if (p_stat(path, &st) < 0)
 		return GIT_ENOTFOUND;
-	}
 
 	if (stamp->mtime == (git_time_t)st.st_mtime &&
 		stamp->size  == (git_off_t)st.st_size   &&
diff --git a/src/fileops.h b/src/fileops.h
index 6a65235de..cfc2ce701 100644
--- a/src/fileops.h
+++ b/src/fileops.h
@@ -292,13 +292,14 @@ typedef struct {
  * Compare stat information for file with reference info.
  *
  * This function updates the file stamp to current data for the given path
- * and returns 0 if the file is up-to-date relative to the prior setting or
- * 1 if the file has been changed.  (This also may return GIT_ENOTFOUND if
- * the file doesn't exist.)
+ * and returns 0 if the file is up-to-date relative to the prior setting,
+ * 1 if the file has been changed, or GIT_ENOTFOUND if the file doesn't
+ * exist.  This will not call giterr_set, so you must set the error if you
+ * plan to return an error.
  *
  * @param stamp File stamp to be checked
  * @param path Path to stat and check if changed
- * @return 0 if up-to-date, 1 if out-of-date, <0 on error
+ * @return 0 if up-to-date, 1 if out-of-date, GIT_ENOTFOUND if cannot stat
  */
 extern int git_futils_filestamp_check(
 	git_futils_filestamp *stamp, const char *path);
diff --git a/src/ignore.c b/src/ignore.c
index 0fb042a34..3ee7ba03a 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -1,7 +1,7 @@
 #include "git2/ignore.h"
 #include "common.h"
 #include "ignore.h"
-#include "attr.h"
+#include "attr_file.h"
 #include "path.h"
 #include "config.h"
 
@@ -10,26 +10,27 @@
 #define GIT_IGNORE_DEFAULT_RULES ".\n..\n.git\n"
 
 static int parse_ignore_file(
-	git_repository *repo, void *parsedata, const char *buffer, git_attr_file *ignores)
+	git_repository *repo,
+	git_attr_file *attrs,
+	const char *data,
+	void *payload)
 {
 	int error = 0;
-	git_attr_fnmatch *match = NULL;
-	const char *scan = NULL, *context = NULL;
 	int ignore_case = false;
+	const char *scan = data, *context = NULL;
+	git_attr_fnmatch *match = NULL;
 
-	/* Prefer to have the caller pass in a git_ignores as the parsedata
-	 * object.  If they did not, then look up the value of ignore_case */
-	if (parsedata != NULL)
-		ignore_case = ((git_ignores *)parsedata)->ignore_case;
+	/* either read ignore_case from ignores structure or use repo config */
+	if (payload != NULL)
+		ignore_case = ((git_ignores *)payload)->ignore_case;
 	else if (git_repository__cvar(&ignore_case, repo, GIT_CVAR_IGNORECASE) < 0)
-		return error;
-
-	if (ignores->key &&
-		git_path_root(ignores->key + 2) < 0 &&
-		git__suffixcmp(ignores->key, "/" GIT_IGNORE_FILE) == 0)
-		context = ignores->key + 2;
+		giterr_clear();
 
-	scan = buffer;
+	/* if subdir file path, convert context for file paths */
+	if (attrs->ce &&
+		git_path_root(attrs->ce->path) < 0 &&
+		!git__suffixcmp(attrs->ce->path, "/" GIT_IGNORE_FILE))
+		context = attrs->ce->path;
 
 	while (!error && *scan) {
 		if (!match) {
@@ -40,7 +41,7 @@ static int parse_ignore_file(
 		match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG;
 
 		if (!(error = git_attr_fnmatch__parse(
-			match, ignores->pool, context, &scan)))
+			match, &attrs->pool, context, &scan)))
 		{
 			match->flags |= GIT_ATTR_FNMATCH_IGNORE;
 
@@ -48,7 +49,7 @@ static int parse_ignore_file(
 				match->flags |= GIT_ATTR_FNMATCH_ICASE;
 
 			scan = git__next_line(scan);
-			error = git_vector_insert(&ignores->rules, match);
+			error = git_vector_insert(&attrs->rules, match);
 		}
 
 		if (error != 0) {
@@ -67,28 +68,46 @@ static int parse_ignore_file(
 	return error;
 }
 
-#define push_ignore_file(R,IGN,S,B,F) \
-	git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,parse_ignore_file,(IGN),(S))
+static int push_ignore_file(
+	git_ignores *ignores,
+	git_vector *which_list,
+	const char *base,
+	const char *filename)
+{
+	int error = 0;
+	git_attr_file *file = NULL;
+
+	if ((error = git_attr_cache__get(
+			&file, ignores->repo, GIT_ATTR_CACHE__FROM_FILE,
+			base, filename, parse_ignore_file, ignores)) < 0 ||
+		(error = git_vector_insert(which_list, file)) < 0)
+		git_attr_file__free(file);
+
+	return error;
+}
 
 static int push_one_ignore(void *payload, git_buf *path)
 {
 	git_ignores *ign = payload;
-
 	ign->depth++;
-
-	return push_ignore_file(
-		ign->repo, ign, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
+	return push_ignore_file(ign, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
 }
 
-static int get_internal_ignores(git_attr_file **ign, git_repository *repo)
+static int get_internal_ignores(git_attr_file **out, git_repository *repo)
 {
 	int error;
 
-	if (!(error = git_attr_cache__init(repo)))
-		error = git_attr_cache__internal_file(repo, GIT_IGNORE_INTERNAL, ign);
+	if ((error = git_attr_cache__init(repo)) < 0)
+		return error;
+
+	/* get with NULL parser, gives existing or empty git_attr_file */
+	error = git_attr_cache__get(
+		out, repo, GIT_ATTR_CACHE__FROM_FILE,
+		NULL, GIT_IGNORE_INTERNAL, NULL, NULL);
 
-	if (!error && !(*ign)->rules.length)
-		error = parse_ignore_file(repo, NULL, GIT_IGNORE_DEFAULT_RULES, *ign);
+	/* if internal rules list is empty, insert default rules */
+	if (!error && !(*out)->rules.length)
+		error = parse_ignore_file(repo, *out, GIT_IGNORE_DEFAULT_RULES, NULL);
 
 	return error;
 }
@@ -127,8 +146,7 @@ int git_ignore__for_path(
 		goto cleanup;
 
 	/* set up internals */
-	error = get_internal_ignores(&ignores->ign_internal, repo);
-	if (error < 0)
+	if ((error = get_internal_ignores(&ignores->ign_internal, repo)) < 0)
 		goto cleanup;
 
 	/* load .gitignore up the path */
@@ -140,14 +158,16 @@ int git_ignore__for_path(
 	}
 
 	/* load .git/info/exclude */
-	error = push_ignore_file(repo, ignores, &ignores->ign_global,
+	error = push_ignore_file(
+		ignores, &ignores->ign_global,
 		git_repository_path(repo), GIT_IGNORE_FILE_INREPO);
 	if (error < 0)
 		goto cleanup;
 
 	/* load core.excludesfile */
 	if (git_repository_attr_cache(repo)->cfg_excl_file != NULL)
-		error = push_ignore_file(repo, ignores, &ignores->ign_global, NULL,
+		error = push_ignore_file(
+			ignores, &ignores->ign_global, NULL,
 			git_repository_attr_cache(repo)->cfg_excl_file);
 
 cleanup:
@@ -165,35 +185,33 @@ int git_ignore__push_dir(git_ignores *ign, const char *dir)
 	ign->depth++;
 
 	return push_ignore_file(
-		ign->repo, ign, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE);
+		ign, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE);
 }
 
 int git_ignore__pop_dir(git_ignores *ign)
 {
 	if (ign->ign_path.length > 0) {
 		git_attr_file *file = git_vector_last(&ign->ign_path);
-		const char *start, *end, *scan;
-		size_t keylen;
+		const char *start = file->ce->path, *end;
 
-		/* - ign->dir looks something like "a/b/" (or "a/b/c/d/")
-		 * - file->key looks something like "0#a/b/.gitignore
+		/* - ign->dir looks something like "/home/user/a/b/" (or "a/b/c/d/")
+		 * - file->path looks something like "a/b/.gitignore
 		 *
-		 * We are popping the last directory off ign->dir.  We also want to
-		 * remove the file from the vector if the directory part of the key
-		 * matches the ign->dir path.  We need to test if the "a/b" part of
+		 * We are popping the last directory off ign->dir.  We also want
+		 * to remove the file from the vector if the popped directory
+		 * matches the ignore path.  We need to test if the "a/b" part of
 		 * the file key matches the path we are about to pop.
 		 */
 
-		for (start = end = scan = &file->key[2]; *scan; ++scan)
-			if (*scan == '/')
-				end = scan; /* point 'end' to last '/' in key */
-		keylen = (end - start) + 1;
+		if ((end = strrchr(start, '/')) != NULL) {
+			size_t dirlen = (end - start) + 1;
 
-		if (ign->dir.size >= keylen &&
-			!memcmp(ign->dir.ptr + ign->dir.size - keylen, start, keylen))
-		{
-			git_attr_file__free(git_vector_last(&ign->ign_path));
-			git_vector_pop(&ign->ign_path);
+			if (ign->dir.size >= dirlen &&
+				!memcmp(ign->dir.ptr + ign->dir.size - dirlen, start, dirlen))
+			{
+				git_vector_pop(&ign->ign_path);
+				git_attr_file__free(file);
+			}
 		}
 	}
 
@@ -210,7 +228,7 @@ void git_ignore__free(git_ignores *ignores)
 	unsigned int i;
 	git_attr_file *file;
 
-	/* don't need to free ignores->ign_internal it is cached exactly once */
+	git_attr_file__free(ignores->ign_internal);
 
 	git_vector_foreach(&ignores->ign_path, i, file) {
 		git_attr_file__free(file);
@@ -283,10 +301,12 @@ int git_ignore_add_rule(
 	const char *rules)
 {
 	int error;
-	git_attr_file *ign_internal;
+	git_attr_file *ign_internal = NULL;
 
-	if (!(error = get_internal_ignores(&ign_internal, repo)))
+	if (!(error = get_internal_ignores(&ign_internal, repo))) {
 		error = parse_ignore_file(repo, NULL, rules, ign_internal);
+		git_attr_file__free(ign_internal);
+	}
 
 	return error;
 }
@@ -300,8 +320,10 @@ int git_ignore_clear_internal_rules(
 	if (!(error = get_internal_ignores(&ign_internal, repo))) {
 		git_attr_file__clear_rules(ign_internal);
 
-		return parse_ignore_file(
+		error = parse_ignore_file(
 			repo, NULL, GIT_IGNORE_DEFAULT_RULES, ign_internal);
+
+		git_attr_file__free(ign_internal);
 	}
 
 	return error;
diff --git a/src/index.c b/src/index.c
index 27a557cfb..d7d937f63 100644
--- a/src/index.c
+++ b/src/index.c
@@ -607,8 +607,15 @@ int git_index_read(git_index *index, int force)
 	}
 
 	updated = git_futils_filestamp_check(&stamp, index->index_file_path);
-	if (updated < 0 || (!updated && !force))
+	if (updated < 0) {
+		giterr_set(
+			GITERR_INDEX,
+			"Failed to read index: '%s' no longer exists",
+			index->index_file_path);
 		return updated;
+	}
+	if (!updated && !force)
+		return 0;
 
 	error = git_futils_readbuffer(&buffer, index->index_file_path);
 	if (error < 0)
@@ -667,11 +674,11 @@ int git_index_write(git_index *index)
 	if ((error = git_filebuf_commit(&file)) < 0)
 		return error;
 
-	error = git_futils_filestamp_check(&index->stamp, index->index_file_path);
-	if (error < 0)
-		return error;
+	if (git_futils_filestamp_check(&index->stamp, index->index_file_path) < 0)
+		/* index could not be read from disk! */;
+	else
+		index->on_disk = 1;
 
-	index->on_disk = 1;
 	return 0;
 }
 
diff --git a/src/sortedcache.c b/src/sortedcache.c
index 625322034..c6b226153 100644
--- a/src/sortedcache.c
+++ b/src/sortedcache.c
@@ -232,9 +232,8 @@ unlock:
 
 void git_sortedcache_updated(git_sortedcache *sc)
 {
-	 /* update filestamp to latest value */
-	if (git_futils_filestamp_check(&sc->stamp, sc->path) < 0)
-		giterr_clear();
+	/* update filestamp to latest value */
+	git_futils_filestamp_check(&sc->stamp, sc->path);
 }
 
 /* release all items in sorted cache */
diff --git a/src/submodule.c b/src/submodule.c
index 95d3d0d9c..5ddbfe828 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -1693,8 +1693,6 @@ static int submodule_cache_refresh(git_submodule_cache *cache, int refresh)
 		update_gitmod = (wd != NULL) ?
 			git_futils_filestamp_check(&cache->gitmodules_stamp, path.ptr) :
 			(cache->gitmodules_stamp.mtime != 0);
-		if (update_gitmod < 0)
-			giterr_clear();
 	}
 
 	/* clear submodule flags that are to be refreshed */
diff --git a/tests/attr/file.c b/tests/attr/file.c
index 4eb1d22fe..e35957b51 100644
--- a/tests/attr/file.c
+++ b/tests/attr/file.c
@@ -11,9 +11,9 @@ void test_attr_file__simple_read(void)
 	git_attr_assignment *assign;
 	git_attr_rule *rule;
 
-	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr0")));
+	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr0")));
 
-	cl_assert_equal_s(cl_fixture("attr/attr0"), file->key + 2);
+	cl_assert_equal_s(cl_fixture("attr/attr0"), file->ce->path);
 	cl_assert(file->rules.length == 1);
 
 	rule = get_rule(0);
@@ -37,9 +37,9 @@ void test_attr_file__match_variants(void)
 	git_attr_rule *rule;
 	git_attr_assignment *assign;
 
-	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr1")));
+	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr1")));
 
-	cl_assert_equal_s(cl_fixture("attr/attr1"), file->key + 2);
+	cl_assert_equal_s(cl_fixture("attr/attr1"), file->ce->path);
 	cl_assert(file->rules.length == 10);
 
 	/* let's do a thorough check of this rule, then just verify
@@ -121,9 +121,9 @@ void test_attr_file__assign_variants(void)
 	git_attr_rule *rule;
 	git_attr_assignment *assign;
 
-	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr2")));
+	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr2")));
 
-	cl_assert_equal_s(cl_fixture("attr/attr2"), file->key + 2);
+	cl_assert_equal_s(cl_fixture("attr/attr2"), file->ce->path);
 	cl_assert(file->rules.length == 11);
 
 	check_one_assign(file, 0, 0, "pat0", "simple", EXPECT_TRUE, NULL);
@@ -187,8 +187,8 @@ void test_attr_file__check_attr_examples(void)
 	git_attr_rule *rule;
 	git_attr_assignment *assign;
 
-	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr3")));
-	cl_assert_equal_s(cl_fixture("attr/attr3"), file->key + 2);
+	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr3")));
+	cl_assert_equal_s(cl_fixture("attr/attr3"), file->ce->path);
 	cl_assert(file->rules.length == 3);
 
 	rule = get_rule(0);
diff --git a/tests/attr/lookup.c b/tests/attr/lookup.c
index 200bdd2c7..099597efc 100644
--- a/tests/attr/lookup.c
+++ b/tests/attr/lookup.c
@@ -9,8 +9,8 @@ void test_attr_lookup__simple(void)
 	git_attr_path path;
 	const char *value = NULL;
 
-	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr0")));
-	cl_assert_equal_s(cl_fixture("attr/attr0"), file->key + 2);
+	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr0")));
+	cl_assert_equal_s(cl_fixture("attr/attr0"), file->ce->path);
 	cl_assert(file->rules.length == 1);
 
 	cl_git_pass(git_attr_path__init(&path, "test", NULL));
@@ -129,8 +129,8 @@ void test_attr_lookup__match_variants(void)
 		{ NULL, NULL, 0, NULL }
 	};
 
-	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr1")));
-	cl_assert_equal_s(cl_fixture("attr/attr1"), file->key + 2);
+	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr1")));
+	cl_assert_equal_s(cl_fixture("attr/attr1"), file->ce->path);
 	cl_assert(file->rules.length == 10);
 
 	cl_git_pass(git_attr_path__init(&path, "/testing/for/pat0", NULL));
@@ -190,7 +190,7 @@ void test_attr_lookup__assign_variants(void)
 		{ NULL, NULL, 0, NULL }
 	};
 
-	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr2")));
+	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr2")));
 	cl_assert(file->rules.length == 11);
 
 	run_test_cases(file, cases, 0);
@@ -225,7 +225,7 @@ void test_attr_lookup__check_attr_examples(void)
 		{ NULL, NULL, 0, NULL }
 	};
 
-	cl_git_pass(git_attr_file__new_and_load(&file, cl_fixture("attr/attr3")));
+	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr3")));
 	cl_assert(file->rules.length == 3);
 
 	run_test_cases(file, cases, 0);
@@ -250,9 +250,9 @@ void test_attr_lookup__from_buffer(void)
 		{ NULL, NULL, 0, NULL }
 	};
 
-	cl_git_pass(git_attr_file__new(&file, 0, NULL, NULL));
+	cl_git_pass(git_attr_file__new(&file, NULL, 0));
 
-	cl_git_pass(git_attr_file__parse_buffer(NULL, NULL, "a* foo\nabc bar\n* baz", file));
+	cl_git_pass(git_attr_file__parse_buffer(NULL, file, "a* foo\nabc bar\n* baz", NULL));
 
 	cl_assert(file->rules.length == 3);
 
diff --git a/tests/threads/diff.c b/tests/threads/diff.c
index 5565c4bf1..562eec71c 100644
--- a/tests/threads/diff.c
+++ b/tests/threads/diff.c
@@ -1,59 +1,22 @@
 #include "clar_libgit2.h"
-#include "thread-utils.h"
+#include "thread_helpers.h"
 
 static git_repository *_repo;
 static git_tree *_a, *_b;
 static git_atomic _counts[4];
 static int _check_counts;
 
+#define THREADS 20
+
 void test_threads_diff__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
 }
 
-static void run_in_parallel(
-	int repeats, int threads, void *(*func)(void *),
-	void (*before_test)(void), void (*after_test)(void))
-{
-	int r, t, *id = git__calloc(threads, sizeof(int));
-#ifdef GIT_THREADS
-	git_thread *th = git__calloc(threads, sizeof(git_thread));
-	cl_assert(th != NULL);
-#else
-	void *th = NULL;
-#endif
-
-	cl_assert(id != NULL);
-
-	for (r = 0; r < repeats; ++r) {
-		_repo = cl_git_sandbox_reopen(); /* reopen sandbox to flush caches */
-
-		if (before_test) before_test();
-
-		for (t = 0; t < threads; ++t) {
-			id[t] = t;
-#ifdef GIT_THREADS
-			cl_git_pass(git_thread_create(&th[t], NULL, func, &id[t]));
-#else
-			cl_assert(func(&id[t]) == &id[t]);
-#endif
-		}
-
-#ifdef GIT_THREADS
-		for (t = 0; t < threads; ++t)
-			cl_git_pass(git_thread_join(th[t], NULL));
-		memset(th, 0, threads * sizeof(git_thread));
-#endif
-
-		if (after_test) after_test();
-	}
-
-	git__free(id);
-	git__free(th);
-}
-
 static void setup_trees(void)
 {
+	_repo = cl_git_sandbox_reopen(); /* reopen sandbox to flush caches */
+
 	cl_git_pass(git_revparse_single(
 		(git_object **)&_a, _repo, "0017bd4ab1^{tree}"));
 	cl_git_pass(git_revparse_single(
@@ -62,8 +25,6 @@ static void setup_trees(void)
 	memset(_counts, 0, sizeof(_counts));
 }
 
-#define THREADS 20
-
 static void free_trees(void)
 {
 	git_tree_free(_a); _a = NULL;
diff --git a/tests/threads/iterator.c b/tests/threads/iterator.c
new file mode 100644
index 000000000..4dd251fa5
--- /dev/null
+++ b/tests/threads/iterator.c
@@ -0,0 +1,49 @@
+#include "clar_libgit2.h"
+#include "thread_helpers.h"
+#include "iterator.h"
+
+static git_repository *_repo;
+
+void test_threads_iterator__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+static void *run_workdir_iterator(void *arg)
+{
+	int error = 0, thread = *(int *)arg;
+	git_iterator *iter;
+	const git_index_entry *entry = NULL;
+
+	cl_git_pass(git_iterator_for_workdir(
+		&iter, _repo, GIT_ITERATOR_DONT_AUTOEXPAND, NULL, NULL));
+
+	while (!error) {
+		if (entry && entry->mode == GIT_FILEMODE_TREE) {
+			error = git_iterator_advance_into(&entry, iter);
+
+			if (error == GIT_ENOTFOUND)
+				error = git_iterator_advance(&entry, iter);
+		} else {
+			error = git_iterator_advance(&entry, iter);
+		}
+
+		if (!error)
+			(void)git_iterator_current_is_ignored(iter);
+	}
+
+	cl_assert_equal_i(GIT_ITEROVER, error);
+
+	git_iterator_free(iter);
+
+	return arg;
+}
+
+
+void test_threads_iterator__workdir(void)
+{
+	_repo = cl_git_sandbox_init("status");
+
+	run_in_parallel(
+		1, 20, run_workdir_iterator, NULL, NULL);
+}
diff --git a/tests/threads/thread_helpers.c b/tests/threads/thread_helpers.c
new file mode 100644
index 000000000..25370dddb
--- /dev/null
+++ b/tests/threads/thread_helpers.c
@@ -0,0 +1,44 @@
+#include "clar_libgit2.h"
+#include "thread_helpers.h"
+
+void run_in_parallel(
+	int repeats,
+	int threads,
+	void *(*func)(void *),
+	void (*before_test)(void),
+	void (*after_test)(void))
+{
+	int r, t, *id = git__calloc(threads, sizeof(int));
+#ifdef GIT_THREADS
+	git_thread *th = git__calloc(threads, sizeof(git_thread));
+	cl_assert(th != NULL);
+#else
+	void *th = NULL;
+#endif
+
+	cl_assert(id != NULL);
+
+	for (r = 0; r < repeats; ++r) {
+		if (before_test) before_test();
+
+		for (t = 0; t < threads; ++t) {
+			id[t] = t;
+#ifdef GIT_THREADS
+			cl_git_pass(git_thread_create(&th[t], NULL, func, &id[t]));
+#else
+			cl_assert(func(&id[t]) == &id[t]);
+#endif
+		}
+
+#ifdef GIT_THREADS
+		for (t = 0; t < threads; ++t)
+			cl_git_pass(git_thread_join(th[t], NULL));
+		memset(th, 0, threads * sizeof(git_thread));
+#endif
+
+		if (after_test) after_test();
+	}
+
+	git__free(id);
+	git__free(th);
+}
diff --git a/tests/threads/thread_helpers.h b/tests/threads/thread_helpers.h
new file mode 100644
index 000000000..3c13cfb6b
--- /dev/null
+++ b/tests/threads/thread_helpers.h
@@ -0,0 +1,8 @@
+#include "thread-utils.h"
+
+void run_in_parallel(
+	int repeats,
+	int threads,
+	void *(*func)(void *),
+	void (*before_test)(void),
+	void (*after_test)(void));
-- 
cgit v1.2.3


From 2e9d813bd69ab014b970a75b5a4f7d24f241cc05 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 11 Apr 2014 12:12:47 -0700
Subject: Fix tests with new attr cache code

---
 src/attr.c      |  20 ++++++----
 src/attr_file.c |   4 +-
 src/attrcache.c | 115 ++++++++++++++++++++++++++++++++++++++++----------------
 src/ignore.c    |  27 ++++++-------
 4 files changed, 109 insertions(+), 57 deletions(-)

diff --git a/src/attr.c b/src/attr.c
index c53a728de..2e314998f 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -60,6 +60,7 @@ int git_attr_get(
 	if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0)
 		goto cleanup;
 
+	memset(&attr, 0, sizeof(attr));
 	attr.name = name;
 	attr.name_hash = git_attr_file__name_hash(name);
 
@@ -295,11 +296,15 @@ static int push_attr_file(
 	int error = 0;
 	git_attr_file *file = NULL;
 
-	if ((error = git_attr_cache__get(
-			&file, repo, source, base, filename,
-			git_attr_file__parse_buffer, NULL)) < 0 ||
-		(error = git_vector_insert(list, file)) < 0)
-		git_attr_file__free(file);
+	error = git_attr_cache__get(
+		&file, repo, source, base, filename, git_attr_file__parse_buffer, NULL);
+	if (error < 0)
+		return error;
+
+	if (file != NULL) {
+		if ((error = git_vector_insert(list, file)) < 0)
+			git_attr_file__free(file);
+	}
 
 	return error;
 }
@@ -343,9 +348,8 @@ static int collect_attr_files(
 	const char *workdir = git_repository_workdir(repo);
 	attr_walk_up_info info = { NULL };
 
-	if (git_attr_cache__init(repo) < 0 ||
-		git_vector_init(files, 4, NULL) < 0)
-		return -1;
+	if ((error = git_attr_cache__init(repo)) < 0)
+		return error;
 
 	/* Resolve path in a non-bare repo */
 	if (workdir != NULL)
diff --git a/src/attr_file.c b/src/attr_file.c
index 86b3448ee..66f71ad19 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -23,9 +23,7 @@ int git_attr_file__new(
 	git_attr_file *attrs = git__calloc(1, sizeof(git_attr_file));
 	GITERR_CHECK_ALLOC(attrs);
 
-	if (git_pool_init(&attrs->pool, 1, 0) < 0 ||
-		git_vector_init(&attrs->rules, 0, NULL) < 0)
-	{
+	if (git_pool_init(&attrs->pool, 1, 0) < 0) {
 		attr_file_free(attrs);
 		return -1;
 	}
diff --git a/src/attrcache.c b/src/attrcache.c
index 6d097234c..a7dc0c887 100644
--- a/src/attrcache.c
+++ b/src/attrcache.c
@@ -41,16 +41,29 @@ int git_attr_cache_entry__new(
 	const char *path,
 	git_pool *pool)
 {
-	size_t baselen = base ? strlen(base) : 0, pathlen = strlen(path);
-	size_t cachesize = sizeof(git_attr_cache_entry) + baselen + pathlen + 1;
+	size_t baselen = 0, pathlen = strlen(path);
+	size_t cachesize = sizeof(git_attr_cache_entry) + pathlen + 1;
 	git_attr_cache_entry *ce;
 
+	if (base != NULL && git_path_root(path) < 0) {
+		baselen = strlen(base);
+		cachesize += baselen;
+
+		if (baselen && base[baselen - 1] != '/')
+			cachesize++;
+	}
+
 	ce = git_pool_mallocz(pool, cachesize);
 	GITERR_CHECK_ALLOC(ce);
 
-	if (baselen)
+	if (baselen) {
 		memcpy(ce->fullpath, base, baselen);
+
+		if (base[baselen - 1] != '/')
+			ce->fullpath[baselen++] = '/';
+	}
 	memcpy(&ce->fullpath[baselen], path, pathlen);
+
 	ce->path = &ce->fullpath[baselen];
 	*out = ce;
 
@@ -119,6 +132,7 @@ static int attr_cache_remove(git_attr_cache *cache, git_attr_file *file)
 		ce->file[file->source] == file)
 	{
 		ce->file[file->source] = NULL;
+		GIT_REFCOUNT_OWN(file, NULL);
 		found = true;
 	}
 
@@ -130,14 +144,13 @@ static int attr_cache_remove(git_attr_cache *cache, git_attr_file *file)
 	return error;
 }
 
-int git_attr_cache__get(
-	git_attr_file **out,
+static int attr_cache_lookup(
+	git_attr_file **out_file,
+	git_attr_cache_entry **out_ce,
 	git_repository *repo,
 	git_attr_cache_source source,
 	const char *base,
-	const char *filename,
-	git_attr_cache_parser parser,
-	void *payload)
+	const char *filename)
 {
 	int error = 0;
 	git_buf path = GIT_BUF_INIT;
@@ -172,36 +185,61 @@ int git_attr_cache__get(
 
 	attr_cache_unlock(cache);
 
+cleanup:
+	*out_file = file;
+	*out_ce = ce;
+
+	git_buf_free(&path);
+	return error;
+}
+
+int git_attr_cache__get(
+	git_attr_file **out,
+	git_repository *repo,
+	git_attr_cache_source source,
+	const char *base,
+	const char *filename,
+	git_attr_cache_parser parser,
+	void *payload)
+{
+	int error = 0;
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_attr_cache_entry *ce = NULL;
+	git_attr_file *file = NULL;
+
+	if ((error = attr_cache_lookup(&file, &ce, repo, source, base, filename)) < 0)
+		goto cleanup;
+
 	/* if this is not a file backed entry, just create a new empty one */
 	if (!parser) {
-		error = git_attr_file__new(&file, ce, source);
-		goto cleanup;
+		if (!file && !(error = git_attr_file__new(&file, ce, source)))
+			error = attr_cache_upsert(cache, file);
 	}
-
 	/* otherwise load and/or reload as needed */
-	switch (git_attr_file__out_of_date(repo, file)) {
-	case 1:
+	else if (!file || (error = git_attr_file__out_of_date(repo, file)) > 0) {
 		if (!(error = git_attr_file__load(
-				  &file, repo, ce, source, parser, payload)))
+				&file, repo, ce, source, parser, payload)))
 			error = attr_cache_upsert(cache, file);
-		break;
-	case 0:
-		/* just use the file */
-		break;
-	case GIT_ENOTFOUND:
-		/* did exist and now does not - remove from cache */
-		error = attr_cache_remove(cache, file);
-		file = NULL;
-		break;
-	default:
-		/* other error (e.g. out of memory, can't read index) */
+	}
+
+	/* GIT_ENOTFOUND is okay when probing for the file.  If the file did
+	 * exist and now does not, we have to remove it from cache, however.
+	 */
+	if (error == GIT_ENOTFOUND) {
 		giterr_clear();
-		break;
+		error = 0;
+
+		if (file != NULL)
+			error = attr_cache_remove(cache, file);
 	}
 
 cleanup:
-	*out = error ? NULL : file;
-	git_buf_free(&path);
+	if (error < 0 && file != NULL) {
+		git_attr_file__free(file);
+		file = NULL;
+	}
+	*out = file;
+
 	return error;
 }
 
@@ -250,7 +288,6 @@ static int attr_cache__lookup_path(
 			*out = git_buf_detach(&buf);
 		else if (cfgval)
 			*out = git__strdup(cfgval);
-
 	}
 	else if (!git_sysdir_find_xdg_file(&buf, fallback))
 		*out = git_buf_detach(&buf);
@@ -262,14 +299,24 @@ static int attr_cache__lookup_path(
 
 static void attr_cache__free(git_attr_cache *cache)
 {
+	bool unlock;
+
 	if (!cache)
 		return;
 
-	if (cache->files != NULL) {
-		git_attr_file *file;
+	unlock = (git_mutex_lock(&cache->lock) == 0);
 
-		git_strmap_foreach_value(cache->files, file, {
-			git_attr_file__free(file);
+	if (cache->files != NULL) {
+		git_attr_cache_entry *ce;
+		int i;
+
+		git_strmap_foreach_value(cache->files, ce, {
+			for (i = 0; i < GIT_ATTR_CACHE_NUM_SOURCES; ++i) {
+				if (ce->file[i]) {
+					GIT_REFCOUNT_OWN(ce->file[i], NULL);
+					git_attr_file__free(ce->file[i]);
+				}
+			}
 		});
 		git_strmap_free(cache->files);
 	}
@@ -291,6 +338,8 @@ static void attr_cache__free(git_attr_cache *cache)
 	git__free(cache->cfg_excl_file);
 	cache->cfg_excl_file = NULL;
 
+	if (unlock)
+		git_mutex_unlock(&cache->lock);
 	git_mutex_free(&cache->lock);
 
 	git__free(cache);
diff --git a/src/ignore.c b/src/ignore.c
index 3ee7ba03a..1f9df8ab4 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -77,11 +77,16 @@ static int push_ignore_file(
 	int error = 0;
 	git_attr_file *file = NULL;
 
-	if ((error = git_attr_cache__get(
-			&file, ignores->repo, GIT_ATTR_CACHE__FROM_FILE,
-			base, filename, parse_ignore_file, ignores)) < 0 ||
-		(error = git_vector_insert(which_list, file)) < 0)
-		git_attr_file__free(file);
+	error = git_attr_cache__get(
+		&file, ignores->repo, GIT_ATTR_CACHE__FROM_FILE,
+		base, filename, parse_ignore_file, ignores);
+	if (error < 0)
+		return error;
+
+	if (file != NULL) {
+		if ((error = git_vector_insert(which_list, file)) < 0)
+			git_attr_file__free(file);
+	}
 
 	return error;
 }
@@ -122,19 +127,15 @@ int git_ignore__for_path(
 
 	assert(ignores);
 
+	memset(ignores, 0, sizeof(*ignores));
 	ignores->repo = repo;
-	git_buf_init(&ignores->dir, 0);
-	ignores->ign_internal = NULL;
-	ignores->depth = 0;
 
 	/* Read the ignore_case flag */
 	if ((error = git_repository__cvar(
 			&ignores->ignore_case, repo, GIT_CVAR_IGNORECASE)) < 0)
 		goto cleanup;
 
-	if ((error = git_vector_init(&ignores->ign_path, 8, NULL)) < 0 ||
-		(error = git_vector_init(&ignores->ign_global, 2, NULL)) < 0 ||
-		(error = git_attr_cache__init(repo)) < 0)
+	if ((error = git_attr_cache__init(repo)) < 0)
 		goto cleanup;
 
 	/* given a unrooted path in a non-bare repo, resolve it */
@@ -304,7 +305,7 @@ int git_ignore_add_rule(
 	git_attr_file *ign_internal = NULL;
 
 	if (!(error = get_internal_ignores(&ign_internal, repo))) {
-		error = parse_ignore_file(repo, NULL, rules, ign_internal);
+		error = parse_ignore_file(repo, ign_internal, rules, NULL);
 		git_attr_file__free(ign_internal);
 	}
 
@@ -321,7 +322,7 @@ int git_ignore_clear_internal_rules(
 		git_attr_file__clear_rules(ign_internal);
 
 		error = parse_ignore_file(
-			repo, NULL, GIT_IGNORE_DEFAULT_RULES, ign_internal);
+			repo, ign_internal, GIT_IGNORE_DEFAULT_RULES, NULL);
 
 		git_attr_file__free(ign_internal);
 	}
-- 
cgit v1.2.3


From ea642d61f9b3dd3d9e1670621198483541cf4f0d Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 14 Apr 2014 12:29:27 -0700
Subject: Fix race checking for existing index items

In the threading tests, I was still seeing a race condition where
the same item could end up being inserted multiple times into the
index.  Preserving the sorted-ness of the index outside of the
`index_insert` call fixes the issue.
---
 src/index.c          | 52 ++++++++++++++++++++++++++++++++--------------------
 tests/threads/diff.c | 10 ++++++++--
 2 files changed, 40 insertions(+), 22 deletions(-)

diff --git a/src/index.c b/src/index.c
index d7d937f63..083c01fe4 100644
--- a/src/index.c
+++ b/src/index.c
@@ -292,6 +292,7 @@ static void index_entry_reuc_free(git_index_reuc_entry *reuc)
 
 static void index_entry_free(git_index_entry *entry)
 {
+	memset(&entry->id, 0, sizeof(entry->id));
 	git__free(entry);
 }
 
@@ -415,9 +416,9 @@ int git_index_open(git_index **index_out, const char *index_path)
 	}
 
 	if (git_vector_init(&index->entries, 32, git_index_entry_cmp) < 0 ||
-		git_vector_init(&index->names, 32, conflict_name_cmp) < 0 ||
-		git_vector_init(&index->reuc, 32, reuc_cmp) < 0 ||
-		git_vector_init(&index->deleted, 2, git_index_entry_cmp) < 0)
+		git_vector_init(&index->names, 8, conflict_name_cmp) < 0 ||
+		git_vector_init(&index->reuc, 8, reuc_cmp) < 0 ||
+		git_vector_init(&index->deleted, 8, git_index_entry_cmp) < 0)
 		goto fail;
 
 	index->entries_cmp_path = git__strcmp_cb;
@@ -477,7 +478,7 @@ static void index_free_deleted(git_index *index)
 	int readers = (int)git_atomic_get(&index->readers);
 	size_t i;
 
-	if (readers > 0)
+	if (readers > 0 || !index->deleted.length)
 		return;
 
 	for (i = 0; i < index->deleted.length; ++i) {
@@ -500,12 +501,11 @@ static int index_remove_entry(git_index *index, size_t pos)
 	error = git_vector_remove(&index->entries, pos);
 
 	if (!error) {
-		int readers = (int)git_atomic_get(&index->readers);
-
-		if (readers > 0)
+		if (git_atomic_get(&index->readers) > 0) {
 			error = git_vector_insert(&index->deleted, entry);
-		else
+		} else {
 			index_entry_free(entry);
+		}
 	}
 
 	return error;
@@ -529,13 +529,13 @@ int git_index_clear(git_index *index)
 		error = index_remove_entry(index, index->entries.length - 1);
 	index_free_deleted(index);
 
-	git_mutex_unlock(&index->lock);
-
 	git_index_reuc_clear(index);
 	git_index_name_clear(index);
 
 	git_futils_filestamp_set(&index->stamp, NULL);
 
+	git_mutex_unlock(&index->lock);
+
 	return error;
 }
 
@@ -860,6 +860,7 @@ static int index_entry_dup(git_index_entry **out, const git_index_entry *src)
 	GITERR_CHECK_ALLOC(entry);
 
 	index_entry_cpy(entry, src);
+
 	return 0;
 }
 
@@ -961,6 +962,15 @@ static int check_file_directory_collision(git_index *index,
 	return 0;
 }
 
+static int index_no_dups(void **old, void *new)
+{
+	const git_index_entry *entry = new;
+	GIT_UNUSED(old);
+	giterr_set(GITERR_INDEX, "'%s' appears multiple times at stage %d",
+		entry->path, GIT_IDXENTRY_STAGE(entry));
+	return GIT_EEXISTS;
+}
+
 /* index_insert takes ownership of the new entry - if it can't insert
  * it, then it will return an error **and also free the entry**.  When
  * it replaces an existing entry, it will update the entry_ptr with the
@@ -987,9 +997,9 @@ static int index_insert(
 	else
 		entry->flags |= GIT_IDXENTRY_NAMEMASK;
 
-	if ((error = git_mutex_lock(&index->lock)) < 0) {
+	if (git_mutex_lock(&index->lock) < 0) {
 		giterr_set(GITERR_OS, "Unable to acquire index lock");
-		return error;
+		return -1;
 	}
 
 	git_vector_sort(&index->entries);
@@ -1010,25 +1020,27 @@ static int index_insert(
 	/* if we are replacing an existing item, overwrite the existing entry
 	 * and return it in place of the passed in one.
 	 */
-	else if (existing && replace) {
-		index_entry_cpy(existing, entry);
+	else if (existing) {
+		if (replace)
+			index_entry_cpy(existing, entry);
 		index_entry_free(entry);
-		*entry_ptr = existing;
+		*entry_ptr = entry = existing;
 	}
 	else {
-		/* if replacing is not requested or no existing entry exists, just
-		 * insert entry at the end; the index is no longer sorted
+		/* if replace is not requested or no existing entry exists, insert
+		 * at the sorted position.  (Since we re-sort after each insert to
+		 * check for dups, this is actually cheaper in the long run.)
 		 */
-		error = git_vector_insert(&index->entries, entry);
+		error = git_vector_insert_sorted(&index->entries, entry, index_no_dups);
 	}
 
-	git_mutex_unlock(&index->lock);
-
 	if (error < 0) {
 		index_entry_free(*entry_ptr);
 		*entry_ptr = NULL;
 	}
 
+	git_mutex_unlock(&index->lock);
+
 	return error;
 }
 
diff --git a/tests/threads/diff.c b/tests/threads/diff.c
index 562eec71c..d33e75f2c 100644
--- a/tests/threads/diff.c
+++ b/tests/threads/diff.c
@@ -15,8 +15,14 @@ void test_threads_diff__cleanup(void)
 
 static void setup_trees(void)
 {
+	git_index *idx;
+
 	_repo = cl_git_sandbox_reopen(); /* reopen sandbox to flush caches */
 
+	/* avoid competing to load initial index */
+	cl_git_pass(git_repository_index(&idx, _repo));
+	git_index_free(idx);
+
 	cl_git_pass(git_revparse_single(
 		(git_object **)&_a, _repo, "0017bd4ab1^{tree}"));
 	cl_git_pass(git_revparse_single(
@@ -107,7 +113,7 @@ void test_threads_diff__concurrent_diffs(void)
 	_check_counts = 1;
 
 	run_in_parallel(
-		20, 32, run_index_diffs, setup_trees, free_trees);
+		5, 32, run_index_diffs, setup_trees, free_trees);
 }
 
 static void *run_index_diffs_with_modifier(void *arg)
@@ -169,5 +175,5 @@ void test_threads_diff__with_concurrent_index_modified(void)
 	_check_counts = 0;
 
 	run_in_parallel(
-		20, 32, run_index_diffs_with_modifier, setup_trees, free_trees);
+		5, 16, run_index_diffs_with_modifier, setup_trees, free_trees);
 }
-- 
cgit v1.2.3


From e6e8530aa6c8773dd523fd6fe07629b9481a8fee Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 14 Apr 2014 12:31:17 -0700
Subject: Lock attribute file while reparsing data

I don't love this approach, but achieving thread-safety for
attribute and ignore data while reloading files would require a
larger rewrite in order to avoid this.  If an attribute or ignore
file is out of date, this holds a lock on the file while we are
reloading the data so that another thread won't try to reload the
data at the same time.
---
 src/attr_file.c | 31 +++++++++++++++++++++++++++++--
 src/attr_file.h |  4 +++-
 src/ignore.c    | 31 +++++++++++++++++--------------
 3 files changed, 49 insertions(+), 17 deletions(-)

diff --git a/src/attr_file.c b/src/attr_file.c
index 66f71ad19..574de25bb 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -9,8 +9,13 @@
 
 static void attr_file_free(git_attr_file *file)
 {
-	git_attr_file__clear_rules(file);
+	bool unlock = !git_mutex_lock(&file->lock);
+	git_attr_file__clear_rules(file, false);
 	git_pool_clear(&file->pool);
+	if (unlock)
+		git_mutex_unlock(&file->lock);
+	git_mutex_free(&file->lock);
+
 	git__memzero(file, sizeof(*file));
 	git__free(file);
 }
@@ -23,6 +28,12 @@ int git_attr_file__new(
 	git_attr_file *attrs = git__calloc(1, sizeof(git_attr_file));
 	GITERR_CHECK_ALLOC(attrs);
 
+	if (git_mutex_init(&attrs->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to initialize lock");
+		git__free(attrs);
+		return -1;
+	}
+
 	if (git_pool_init(&attrs->pool, 1, 0) < 0) {
 		attr_file_free(attrs);
 		return -1;
@@ -35,14 +46,24 @@ int git_attr_file__new(
 	return 0;
 }
 
-void git_attr_file__clear_rules(git_attr_file *file)
+int git_attr_file__clear_rules(git_attr_file *file, bool need_lock)
 {
 	unsigned int i;
 	git_attr_rule *rule;
 
+	if (need_lock && git_mutex_lock(&file->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock attribute file");
+		return -1;
+	}
+
 	git_vector_foreach(&file->rules, i, rule)
 		git_attr_rule__free(rule);
 	git_vector_free(&file->rules);
+
+	if (need_lock)
+		git_mutex_unlock(&file->lock);
+
+	return 0;
 }
 
 void git_attr_file__free(git_attr_file *file)
@@ -162,6 +183,11 @@ int git_attr_file__parse_buffer(
 		!git__suffixcmp(attrs->ce->path, "/" GIT_ATTR_FILE))
 		context = attrs->ce->path;
 
+	if (git_mutex_lock(&attrs->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock attribute file");
+		return -1;
+	}
+
 	while (!error && *scan) {
 		/* allocate rule if needed */
 		if (!rule) {
@@ -198,6 +224,7 @@ int git_attr_file__parse_buffer(
 		}
 	}
 
+	git_mutex_unlock(&attrs->lock);
 	git_attr_rule__free(rule);
 
 	return error;
diff --git a/src/attr_file.h b/src/attr_file.h
index f92ce3c96..9b4b8724b 100644
--- a/src/attr_file.h
+++ b/src/attr_file.h
@@ -66,6 +66,7 @@ typedef struct {
 
 struct git_attr_file {
 	git_refcount rc;
+	git_mutex lock;
 	git_attr_cache_entry *ce;
 	git_attr_cache_source source;
 	git_vector rules;			/* vector of <rule*> or <fnmatch*> */
@@ -115,7 +116,8 @@ int git_attr_file__parse_buffer(
 	const char *data,
 	void *payload);
 
-void git_attr_file__clear_rules(git_attr_file *file);
+int git_attr_file__clear_rules(
+	git_attr_file *file, bool need_lock);
 
 int git_attr_file__lookup_one(
 	git_attr_file *file,
diff --git a/src/ignore.c b/src/ignore.c
index 1f9df8ab4..fbebd9ad3 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -32,6 +32,11 @@ static int parse_ignore_file(
 		!git__suffixcmp(attrs->ce->path, "/" GIT_IGNORE_FILE))
 		context = attrs->ce->path;
 
+	if (git_mutex_lock(&attrs->lock) < 0) {
+		giterr_set(GITERR_OS, "Failed to lock attribute file");
+		return -1;
+	}
+
 	while (!error && *scan) {
 		if (!match) {
 			match = git__calloc(1, sizeof(*match));
@@ -63,6 +68,7 @@ static int parse_ignore_file(
 		}
 	}
 
+	git_mutex_unlock(&attrs->lock);
 	git__free(match);
 
 	return error;
@@ -247,12 +253,12 @@ void git_ignore__free(git_ignores *ignores)
 }
 
 static bool ignore_lookup_in_rules(
-	git_vector *rules, git_attr_path *path, int *ignored)
+	git_attr_file *file, git_attr_path *path, int *ignored)
 {
 	size_t j;
 	git_attr_fnmatch *match;
 
-	git_vector_rforeach(rules, j, match) {
+	git_vector_rforeach(&file->rules, j, match) {
 		if (git_attr_fnmatch__match(match, path)) {
 			*ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0);
 			return true;
@@ -274,19 +280,18 @@ int git_ignore__lookup(
 		return -1;
 
 	/* first process builtins - success means path was found */
-	if (ignore_lookup_in_rules(
-			&ignores->ign_internal->rules, &path, ignored))
+	if (ignore_lookup_in_rules(ignores->ign_internal, &path, ignored))
 		goto cleanup;
 
 	/* next process files in the path */
 	git_vector_foreach(&ignores->ign_path, i, file) {
-		if (ignore_lookup_in_rules(&file->rules, &path, ignored))
+		if (ignore_lookup_in_rules(file, &path, ignored))
 			goto cleanup;
 	}
 
 	/* last process global ignores */
 	git_vector_foreach(&ignores->ign_global, i, file) {
-		if (ignore_lookup_in_rules(&file->rules, &path, ignored))
+		if (ignore_lookup_in_rules(file, &path, ignored))
 			goto cleanup;
 	}
 
@@ -319,10 +324,9 @@ int git_ignore_clear_internal_rules(
 	git_attr_file *ign_internal;
 
 	if (!(error = get_internal_ignores(&ign_internal, repo))) {
-		git_attr_file__clear_rules(ign_internal);
-
-		error = parse_ignore_file(
-			repo, ign_internal, GIT_IGNORE_DEFAULT_RULES, NULL);
+		if (!(error = git_attr_file__clear_rules(ign_internal, true)))
+			error = parse_ignore_file(
+				repo, ign_internal, GIT_IGNORE_DEFAULT_RULES, NULL);
 
 		git_attr_file__free(ign_internal);
 	}
@@ -371,19 +375,18 @@ int git_ignore_path_is_ignored(
 			break;
 
 		/* first process builtins - success means path was found */
-		if (ignore_lookup_in_rules(
-				&ignores.ign_internal->rules, &path, ignored))
+		if (ignore_lookup_in_rules(ignores.ign_internal, &path, ignored))
 			goto cleanup;
 
 		/* next process files in the path */
 		git_vector_foreach(&ignores.ign_path, i, file) {
-			if (ignore_lookup_in_rules(&file->rules, &path, ignored))
+			if (ignore_lookup_in_rules(file, &path, ignored))
 				goto cleanup;
 		}
 
 		/* last process global ignores */
 		git_vector_foreach(&ignores.ign_global, i, file) {
-			if (ignore_lookup_in_rules(&file->rules, &path, ignored))
+			if (ignore_lookup_in_rules(file, &path, ignored))
 				goto cleanup;
 		}
 
-- 
cgit v1.2.3


From 823c0e9cc142529912976f2e6abff3db456cb204 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 17 Apr 2014 11:53:13 -0700
Subject: Fix broken logic for attr cache invalidation

The checks to see if files were out of date in the attibute cache
was wrong because the cache-breaker data wasn't getting stored
correctly.  Additionally, when the cache-breaker triggered, the
old file data was being leaked.
---
 CMakeLists.txt        |   5 +++
 src/attr.c            |  24 +++++-----
 src/attr_file.c       | 115 ++++++++++++++++++++++++++++++++---------------
 src/attr_file.h       |  51 +++++++++++++--------
 src/attrcache.c       | 122 +++++++++++++++++++++++++-------------------------
 src/attrcache.h       |  47 ++++++-------------
 src/fileops.c         |  14 ++++++
 src/fileops.h         |   6 +++
 src/ignore.c          |  62 +++++++++++--------------
 tests/attr/file.c     |   8 ++--
 tests/attr/lookup.c   |   6 +--
 tests/attr/repo.c     |   9 ++--
 tests/status/ignore.c |   6 ++-
 13 files changed, 265 insertions(+), 210 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 23c5af1fc..918e5b8f7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -305,6 +305,11 @@ ELSE ()
 	ENDIF ()
 	IF (APPLE) # Apple deprecated OpenSSL
 		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
+
+		# With clang, disable some annoying extra warnings
+		IF (NOT CMAKE_COMPILER_IS_GNUCC)
+			SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-const-variable -Wno-unused-function")
+		ENDIF()
 	ENDIF ()
 	IF (PROFILE)
 		SET(CMAKE_C_FLAGS "-pg ${CMAKE_C_FLAGS}")
diff --git a/src/attr.c b/src/attr.c
index 2e314998f..622874348 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -260,26 +260,26 @@ typedef struct {
 } attr_walk_up_info;
 
 static int attr_decide_sources(
-	uint32_t flags, bool has_wd, bool has_index, git_attr_cache_source *srcs)
+	uint32_t flags, bool has_wd, bool has_index, git_attr_file_source *srcs)
 {
 	int count = 0;
 
 	switch (flags & 0x03) {
 	case GIT_ATTR_CHECK_FILE_THEN_INDEX:
 		if (has_wd)
-			srcs[count++] = GIT_ATTR_CACHE__FROM_FILE;
+			srcs[count++] = GIT_ATTR_FILE__FROM_FILE;
 		if (has_index)
-			srcs[count++] = GIT_ATTR_CACHE__FROM_INDEX;
+			srcs[count++] = GIT_ATTR_FILE__FROM_INDEX;
 		break;
 	case GIT_ATTR_CHECK_INDEX_THEN_FILE:
 		if (has_index)
-			srcs[count++] = GIT_ATTR_CACHE__FROM_INDEX;
+			srcs[count++] = GIT_ATTR_FILE__FROM_INDEX;
 		if (has_wd)
-			srcs[count++] = GIT_ATTR_CACHE__FROM_FILE;
+			srcs[count++] = GIT_ATTR_FILE__FROM_FILE;
 		break;
 	case GIT_ATTR_CHECK_INDEX_ONLY:
 		if (has_index)
-			srcs[count++] = GIT_ATTR_CACHE__FROM_INDEX;
+			srcs[count++] = GIT_ATTR_FILE__FROM_INDEX;
 		break;
 	}
 
@@ -289,7 +289,7 @@ static int attr_decide_sources(
 static int push_attr_file(
 	git_repository *repo,
 	git_vector *list,
-	git_attr_cache_source source,
+	git_attr_file_source source,
 	const char *base,
 	const char *filename)
 {
@@ -297,7 +297,7 @@ static int push_attr_file(
 	git_attr_file *file = NULL;
 
 	error = git_attr_cache__get(
-		&file, repo, source, base, filename, git_attr_file__parse_buffer, NULL);
+		&file, repo, source, base, filename, git_attr_file__parse_buffer);
 	if (error < 0)
 		return error;
 
@@ -313,7 +313,7 @@ static int push_one_attr(void *ref, git_buf *path)
 {
 	int error = 0, n_src, i;
 	attr_walk_up_info *info = (attr_walk_up_info *)ref;
-	git_attr_cache_source src[2];
+	git_attr_file_source src[2];
 
 	n_src = attr_decide_sources(
 		info->flags, info->workdir != NULL, info->index != NULL, src);
@@ -367,7 +367,7 @@ static int collect_attr_files(
 	 */
 
 	error = push_attr_file(
-		repo, files, GIT_ATTR_CACHE__FROM_FILE,
+		repo, files, GIT_ATTR_FILE__FROM_FILE,
 		git_repository_path(repo), GIT_ATTR_FILE_INREPO);
 	if (error < 0)
 		goto cleanup;
@@ -385,7 +385,7 @@ static int collect_attr_files(
 
 	if (git_repository_attr_cache(repo)->cfg_attr_file != NULL) {
 		error = push_attr_file(
-			repo, files, GIT_ATTR_CACHE__FROM_FILE,
+			repo, files, GIT_ATTR_FILE__FROM_FILE,
 			NULL, git_repository_attr_cache(repo)->cfg_attr_file);
 		if (error < 0)
 			goto cleanup;
@@ -395,7 +395,7 @@ static int collect_attr_files(
 		error = git_sysdir_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);
 		if (!error)
 			error = push_attr_file(
-				repo, files, GIT_ATTR_CACHE__FROM_FILE, NULL, dir.ptr);
+				repo, files, GIT_ATTR_FILE__FROM_FILE, NULL, dir.ptr);
 		else if (error == GIT_ENOTFOUND) {
 			giterr_clear();
 			error = 0;
diff --git a/src/attr_file.c b/src/attr_file.c
index 574de25bb..65bbf78e8 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -2,6 +2,7 @@
 #include "repository.h"
 #include "filebuf.h"
 #include "attr_file.h"
+#include "attrcache.h"
 #include "git2/blob.h"
 #include "git2/tree.h"
 #include "index.h"
@@ -22,8 +23,8 @@ static void attr_file_free(git_attr_file *file)
 
 int git_attr_file__new(
 	git_attr_file **out,
-	git_attr_cache_entry *ce,
-	git_attr_cache_source source)
+	git_attr_file_entry *entry,
+	git_attr_file_source source)
 {
 	git_attr_file *attrs = git__calloc(1, sizeof(git_attr_file));
 	GITERR_CHECK_ALLOC(attrs);
@@ -40,7 +41,7 @@ int git_attr_file__new(
 	}
 
 	GIT_REFCOUNT_INC(attrs);
-	attrs->ce = ce;
+	attrs->entry  = entry;
 	attrs->source = source;
 	*out = attrs;
 	return 0;
@@ -95,42 +96,77 @@ static int attr_file_oid_from_index(
 int git_attr_file__load(
 	git_attr_file **out,
 	git_repository *repo,
-	git_attr_cache_entry *ce,
-	git_attr_cache_source source,
-	git_attr_cache_parser parser,
-	void *payload)
+	git_attr_file_entry *entry,
+	git_attr_file_source source,
+	git_attr_file_parser parser)
 {
 	int error = 0;
 	git_blob *blob = NULL;
 	git_buf content = GIT_BUF_INIT;
 	const char *data = NULL;
 	git_attr_file *file;
+	struct stat st;
 
 	*out = NULL;
 
-	if (source == GIT_ATTR_CACHE__FROM_INDEX) {
+	switch (source) {
+	case GIT_ATTR_FILE__IN_MEMORY:
+		/* in-memory attribute file doesn't need data */
+		break;
+	case GIT_ATTR_FILE__FROM_INDEX: {
 		git_oid id;
 
-		if ((error = attr_file_oid_from_index(&id, repo, ce->path)) < 0 ||
+		if ((error = attr_file_oid_from_index(&id, repo, entry->path)) < 0 ||
 			(error = git_blob_lookup(&blob, repo, &id)) < 0)
 			return error;
 
 		data = git_blob_rawcontent(blob);
-	} else {
-		if ((error = git_futils_readbuffer(&content, ce->fullpath)) < 0)
-			/* always return ENOTFOUND so item will just be skipped */
-			/* TODO: issue a warning once warnings API is available */
+		break;
+	}
+	case GIT_ATTR_FILE__FROM_FILE: {
+		int fd;
+
+		if (p_stat(entry->fullpath, &st) < 0)
+			return git_path_set_error(errno, entry->fullpath, "stat");
+		if (S_ISDIR(st.st_mode))
 			return GIT_ENOTFOUND;
+
+		/* For open or read errors, return ENOTFOUND to skip item */
+		/* TODO: issue warning when warning API is available */
+
+		if ((fd = git_futils_open_ro(entry->fullpath)) < 0)
+			return GIT_ENOTFOUND;
+
+		error = git_futils_readbuffer_fd(&content, fd, (size_t)st.st_size);
+		p_close(fd);
+
+		if (error < 0)
+			return GIT_ENOTFOUND;
+
 		data = content.ptr;
+		break;
+	}
+	default:
+		giterr_set(GITERR_INVALID, "Unknown file source %d", source);
+		return -1;
 	}
 
-	if ((error = git_attr_file__new(&file, ce, source)) < 0)
+	if ((error = git_attr_file__new(&file, entry, source)) < 0)
 		goto cleanup;
 
-	if (parser && (error = parser(repo, file, data, payload)) < 0)
+	if (parser && (error = parser(repo, file, data)) < 0) {
 		git_attr_file__free(file);
-	else
-		*out = file;
+		goto cleanup;
+	}
+
+	/* write cache breaker */
+	if (source == GIT_ATTR_FILE__FROM_INDEX)
+		git_oid_cpy(&file->cache_data.oid, git_blob_id(blob));
+	else if (source == GIT_ATTR_FILE__FROM_FILE)
+		git_futils_filestamp_set_from_stat(&file->cache_data.stamp, &st);
+	/* else always cacheable */
+
+	*out = file;
 
 cleanup:
 	git_blob_free(blob);
@@ -144,18 +180,29 @@ int git_attr_file__out_of_date(git_repository *repo, git_attr_file *file)
 	if (!file)
 		return 1;
 
-	if (file->source == GIT_ATTR_CACHE__FROM_INDEX) {
+	switch (file->source) {
+	case GIT_ATTR_FILE__IN_MEMORY:
+		return 0;
+
+	case GIT_ATTR_FILE__FROM_FILE:
+		return git_futils_filestamp_check(
+			&file->cache_data.stamp, file->entry->fullpath);
+
+	case GIT_ATTR_FILE__FROM_INDEX: {
 		int error;
 		git_oid id;
 
-		if ((error = attr_file_oid_from_index(&id, repo, file->ce->path)) < 0)
+		if ((error = attr_file_oid_from_index(
+				&id, repo, file->entry->path)) < 0)
 			return error;
 
 		return (git_oid__cmp(&file->cache_data.oid, &id) != 0);
 	}
 
-	return git_futils_filestamp_check(
-		&file->cache_data.stamp, file->ce->fullpath);
+	default:
+		giterr_set(GITERR_INVALID, "Invalid file type %d", file->source);
+		return -1;
+	}
 }
 
 static int sort_by_hash_and_name(const void *a_raw, const void *b_raw);
@@ -166,22 +213,17 @@ static bool parse_optimized_patterns(
 	const char *pattern);
 
 int git_attr_file__parse_buffer(
-	git_repository *repo,
-	git_attr_file *attrs,
-	const char *data,
-	void *payload)
+	git_repository *repo, git_attr_file *attrs, const char *data)
 {
 	int error = 0;
 	const char *scan = data, *context = NULL;
 	git_attr_rule *rule = NULL;
 
-	GIT_UNUSED(payload);
-
 	/* if subdir file path, convert context for file paths */
-	if (attrs->ce &&
-		git_path_root(attrs->ce->path) < 0 &&
-		!git__suffixcmp(attrs->ce->path, "/" GIT_ATTR_FILE))
-		context = attrs->ce->path;
+	if (attrs->entry &&
+		git_path_root(attrs->entry->path) < 0 &&
+		!git__suffixcmp(attrs->entry->path, "/" GIT_ATTR_FILE))
+		context = attrs->entry->path;
 
 	if (git_mutex_lock(&attrs->lock) < 0) {
 		giterr_set(GITERR_OS, "Failed to lock attribute file");
@@ -268,19 +310,18 @@ int git_attr_file__lookup_one(
 	return 0;
 }
 
-int git_attr_file__load_standalone(
-	git_attr_file **out,
-	const char *path)
+int git_attr_file__load_standalone(git_attr_file **out, const char *path)
 {
 	int error;
 	git_attr_file *file;
 	git_buf content = GIT_BUF_INIT;
 
-	error = git_attr_file__new(&file, NULL, GIT_ATTR_CACHE__FROM_FILE);
+	error = git_attr_file__new(&file, NULL, GIT_ATTR_FILE__FROM_FILE);
 	if (error < 0)
 		return error;
 
-	error = git_attr_cache_entry__new(&file->ce, NULL, path, &file->pool);
+	error = git_attr_cache__alloc_file_entry(
+		&file->entry, NULL, path, &file->pool);
 	if (error < 0) {
 		git_attr_file__free(file);
 		return error;
@@ -290,7 +331,7 @@ int git_attr_file__load_standalone(
 	 */
 
 	if (!(error = git_futils_readbuffer(&content, path))) {
-		error = git_attr_file__parse_buffer(NULL, file, content.ptr, NULL);
+		error = git_attr_file__parse_buffer(NULL, file, content.ptr);
 		git_buf_free(&content);
 	}
 
diff --git a/src/attr_file.h b/src/attr_file.h
index 9b4b8724b..c906be44d 100644
--- a/src/attr_file.h
+++ b/src/attr_file.h
@@ -13,7 +13,6 @@
 #include "pool.h"
 #include "buffer.h"
 #include "fileops.h"
-#include "attrcache.h"
 
 #define GIT_ATTR_FILE			".gitattributes"
 #define GIT_ATTR_FILE_INREPO	"info/attributes"
@@ -36,6 +35,14 @@
 	(GIT_ATTR_FNMATCH_ALLOWSPACE | \
 	 GIT_ATTR_FNMATCH_ALLOWNEG | GIT_ATTR_FNMATCH_ALLOWMACRO)
 
+typedef enum {
+	GIT_ATTR_FILE__IN_MEMORY  = 0,
+	GIT_ATTR_FILE__FROM_FILE  = 1,
+	GIT_ATTR_FILE__FROM_INDEX = 2,
+
+	GIT_ATTR_FILE_NUM_SOURCES = 3
+} git_attr_file_source;
+
 extern const char *git_attr__true;
 extern const char *git_attr__false;
 extern const char *git_attr__unset;
@@ -46,10 +53,10 @@ typedef struct {
 	unsigned int flags;
 } git_attr_fnmatch;
 
-struct git_attr_rule {
+typedef struct {
 	git_attr_fnmatch match;
 	git_vector assigns;		/* vector of <git_attr_assignment*> */
-};
+} git_attr_rule;
 
 typedef struct {
 	git_refcount unused;
@@ -64,19 +71,32 @@ typedef struct {
 	const char *value;
 } git_attr_assignment;
 
-struct git_attr_file {
+typedef struct git_attr_file_entry git_attr_file_entry;
+
+typedef struct {
 	git_refcount rc;
 	git_mutex lock;
-	git_attr_cache_entry *ce;
-	git_attr_cache_source source;
+	git_attr_file_entry *entry;
+	git_attr_file_source source;
 	git_vector rules;			/* vector of <rule*> or <fnmatch*> */
 	git_pool pool;
 	union {
 		git_oid oid;
 		git_futils_filestamp stamp;
 	} cache_data;
+} git_attr_file;
+
+struct git_attr_file_entry {
+	git_attr_file *file[GIT_ATTR_FILE_NUM_SOURCES];
+	const char *path; /* points into fullpath */
+	char fullpath[GIT_FLEX_ARRAY];
 };
 
+typedef int (*git_attr_file_parser)(
+	git_repository *repo,
+	git_attr_file *file,
+	const char *data);
+
 typedef struct {
 	git_buf  full;
 	char    *path;
@@ -90,31 +110,26 @@ typedef struct {
 
 int git_attr_file__new(
 	git_attr_file **out,
-	git_attr_cache_entry *ce,
-	git_attr_cache_source source);
+	git_attr_file_entry *entry,
+	git_attr_file_source source);
 
 void git_attr_file__free(git_attr_file *file);
 
 int git_attr_file__load(
 	git_attr_file **out,
 	git_repository *repo,
-	git_attr_cache_entry *ce,
-	git_attr_cache_source source,
-	git_attr_cache_parser parser,
-	void *payload);
+	git_attr_file_entry *ce,
+	git_attr_file_source source,
+	git_attr_file_parser parser);
 
 int git_attr_file__load_standalone(
-	git_attr_file **out,
-	const char *path);
+	git_attr_file **out, const char *path);
 
 int git_attr_file__out_of_date(
 	git_repository *repo, git_attr_file *file);
 
 int git_attr_file__parse_buffer(
-	git_repository *repo,
-	git_attr_file *attrs,
-	const char *data,
-	void *payload);
+	git_repository *repo, git_attr_file *attrs, const char *data);
 
 int git_attr_file__clear_rules(
 	git_attr_file *file, bool need_lock);
diff --git a/src/attrcache.c b/src/attrcache.c
index a7dc0c887..925abb57f 100644
--- a/src/attrcache.c
+++ b/src/attrcache.c
@@ -24,7 +24,7 @@ GIT_INLINE(void) attr_cache_unlock(git_attr_cache *cache)
 	git_mutex_unlock(&cache->lock);
 }
 
-GIT_INLINE(git_attr_cache_entry *) attr_cache_lookup_entry(
+GIT_INLINE(git_attr_file_entry *) attr_cache_lookup_entry(
 	git_attr_cache *cache, const char *path)
 {
 	khiter_t pos = git_strmap_lookup_index(cache->files, path);
@@ -35,15 +35,15 @@ GIT_INLINE(git_attr_cache_entry *) attr_cache_lookup_entry(
 		return NULL;
 }
 
-int git_attr_cache_entry__new(
-	git_attr_cache_entry **out,
+int git_attr_cache__alloc_file_entry(
+	git_attr_file_entry **out,
 	const char *base,
 	const char *path,
 	git_pool *pool)
 {
 	size_t baselen = 0, pathlen = strlen(path);
-	size_t cachesize = sizeof(git_attr_cache_entry) + pathlen + 1;
-	git_attr_cache_entry *ce;
+	size_t cachesize = sizeof(git_attr_file_entry) + pathlen + 1;
+	git_attr_file_entry *ce;
 
 	if (base != NULL && git_path_root(path) < 0) {
 		baselen = strlen(base);
@@ -72,41 +72,41 @@ int git_attr_cache_entry__new(
 
 /* call with attrcache locked */
 static int attr_cache_make_entry(
-	git_attr_cache_entry **out, git_repository *repo, const char *path)
+	git_attr_file_entry **out, git_repository *repo, const char *path)
 {
 	int error = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_attr_cache_entry *ce = NULL;
+	git_attr_file_entry *entry = NULL;
 
-	error = git_attr_cache_entry__new(
-		&ce, git_repository_workdir(repo), path, &cache->pool);
+	error = git_attr_cache__alloc_file_entry(
+		&entry, git_repository_workdir(repo), path, &cache->pool);
 
 	if (!error) {
-		git_strmap_insert(cache->files, ce->path, ce, error);
+		git_strmap_insert(cache->files, entry->path, entry, error);
 		if (error > 0)
 			error = 0;
 	}
 
-	*out = ce;
+	*out = entry;
 	return error;
 }
 
 /* insert entry or replace existing if we raced with another thread */
 static int attr_cache_upsert(git_attr_cache *cache, git_attr_file *file)
 {
-	git_attr_cache_entry *ce;
+	git_attr_file_entry *entry;
 	git_attr_file *old;
 
 	if (attr_cache_lock(cache) < 0)
 		return -1;
 
-	ce = attr_cache_lookup_entry(cache, file->ce->path);
-
-	old = ce->file[file->source];
+	entry = attr_cache_lookup_entry(cache, file->entry->path);
 
-	GIT_REFCOUNT_OWN(file, ce);
+	GIT_REFCOUNT_OWN(file, entry);
 	GIT_REFCOUNT_INC(file);
-	ce->file[file->source] = file;
+
+	old = git__compare_and_swap(
+		&entry->file[file->source], entry->file[file->source], file);
 
 	if (old) {
 		GIT_REFCOUNT_OWN(old, NULL);
@@ -120,7 +120,7 @@ static int attr_cache_upsert(git_attr_cache *cache, git_attr_file *file)
 static int attr_cache_remove(git_attr_cache *cache, git_attr_file *file)
 {
 	int error = 0;
-	git_attr_cache_entry *ce;
+	git_attr_file_entry *entry;
 	bool found = false;
 
 	if (!file)
@@ -128,27 +128,29 @@ static int attr_cache_remove(git_attr_cache *cache, git_attr_file *file)
 	if ((error = attr_cache_lock(cache)) < 0)
 		return error;
 
-	if ((ce = attr_cache_lookup_entry(cache, file->ce->path)) != NULL &&
-		ce->file[file->source] == file)
-	{
-		ce->file[file->source] = NULL;
-		GIT_REFCOUNT_OWN(file, NULL);
-		found = true;
-	}
+	if ((entry = attr_cache_lookup_entry(cache, file->entry->path)) != NULL)
+		file = git__compare_and_swap(&entry->file[file->source], file, NULL);
 
 	attr_cache_unlock(cache);
 
-	if (found)
+	if (found) {
+		GIT_REFCOUNT_OWN(file, NULL);
 		git_attr_file__free(file);
+	}
 
 	return error;
 }
 
+/* Look up cache entry and file.
+ * - If entry is not present, create it while the cache is locked.
+ * - If file is present, increment refcount before returning it, so the
+ *   cache can be unlocked and it won't go away.
+ */
 static int attr_cache_lookup(
 	git_attr_file **out_file,
-	git_attr_cache_entry **out_ce,
+	git_attr_file_entry **out_entry,
 	git_repository *repo,
-	git_attr_cache_source source,
+	git_attr_file_source source,
 	const char *base,
 	const char *filename)
 {
@@ -156,7 +158,7 @@ static int attr_cache_lookup(
 	git_buf path = GIT_BUF_INIT;
 	const char *wd = git_repository_workdir(repo), *relfile;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_attr_cache_entry *ce = NULL;
+	git_attr_file_entry *entry = NULL;
 	git_attr_file *file = NULL;
 
 	/* join base and path as needed */
@@ -174,20 +176,20 @@ static int attr_cache_lookup(
 	if ((error = attr_cache_lock(cache)) < 0)
 		goto cleanup;
 
-	ce = attr_cache_lookup_entry(cache, relfile);
-	if (!ce) {
-		if ((error = attr_cache_make_entry(&ce, repo, relfile)) < 0)
+	entry = attr_cache_lookup_entry(cache, relfile);
+	if (!entry) {
+		if ((error = attr_cache_make_entry(&entry, repo, relfile)) < 0)
 			goto cleanup;
-	} else if (ce->file[source] != NULL) {
-		file = ce->file[source];
+	} else if (entry->file[source] != NULL) {
+		file = entry->file[source];
 		GIT_REFCOUNT_INC(file);
 	}
 
 	attr_cache_unlock(cache);
 
 cleanup:
-	*out_file = file;
-	*out_ce = ce;
+	*out_file  = file;
+	*out_entry = entry;
 
 	git_buf_free(&path);
 	return error;
@@ -196,29 +198,26 @@ cleanup:
 int git_attr_cache__get(
 	git_attr_file **out,
 	git_repository *repo,
-	git_attr_cache_source source,
+	git_attr_file_source source,
 	const char *base,
 	const char *filename,
-	git_attr_cache_parser parser,
-	void *payload)
+	git_attr_file_parser parser)
 {
 	int error = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_attr_cache_entry *ce = NULL;
+	git_attr_file_entry *entry = NULL;
 	git_attr_file *file = NULL;
 
-	if ((error = attr_cache_lookup(&file, &ce, repo, source, base, filename)) < 0)
+	if ((error = attr_cache_lookup(
+			&file, &entry, repo, source, base, filename)) < 0)
 		goto cleanup;
 
-	/* if this is not a file backed entry, just create a new empty one */
-	if (!parser) {
-		if (!file && !(error = git_attr_file__new(&file, ce, source)))
-			error = attr_cache_upsert(cache, file);
-	}
-	/* otherwise load and/or reload as needed */
-	else if (!file || (error = git_attr_file__out_of_date(repo, file)) > 0) {
-		if (!(error = git_attr_file__load(
-				&file, repo, ce, source, parser, payload)))
+	/* if file not found or out of date, load up-to-date data and replace */
+	if (!file || (error = git_attr_file__out_of_date(repo, file)) > 0) {
+		/* decrement refcount (if file was found) b/c we will not return it */
+		git_attr_file__free(file);
+
+		if (!(error = git_attr_file__load(&file, repo, entry, source, parser)))
 			error = attr_cache_upsert(cache, file);
 	}
 
@@ -245,13 +244,13 @@ cleanup:
 
 bool git_attr_cache__is_cached(
 	git_repository *repo,
-	git_attr_cache_source source,
+	git_attr_file_source source,
 	const char *filename)
 {
 	git_attr_cache *cache = git_repository_attr_cache(repo);
 	git_strmap *files;
 	khiter_t pos;
-	git_attr_cache_entry *ce;
+	git_attr_file_entry *entry;
 
 	if (!(cache = git_repository_attr_cache(repo)) ||
 		!(files = cache->files))
@@ -261,9 +260,9 @@ bool git_attr_cache__is_cached(
 	if (!git_strmap_valid_index(files, pos))
 		return false;
 
-	ce = git_strmap_value_at(files, pos);
+	entry = git_strmap_value_at(files, pos);
 
-	return ce && (ce->file[source] != NULL);
+	return entry && (entry->file[source] != NULL);
 }
 
 
@@ -307,14 +306,15 @@ static void attr_cache__free(git_attr_cache *cache)
 	unlock = (git_mutex_lock(&cache->lock) == 0);
 
 	if (cache->files != NULL) {
-		git_attr_cache_entry *ce;
+		git_attr_file_entry *entry;
+		git_attr_file *file;
 		int i;
 
-		git_strmap_foreach_value(cache->files, ce, {
-			for (i = 0; i < GIT_ATTR_CACHE_NUM_SOURCES; ++i) {
-				if (ce->file[i]) {
-					GIT_REFCOUNT_OWN(ce->file[i], NULL);
-					git_attr_file__free(ce->file[i]);
+		git_strmap_foreach_value(cache->files, entry, {
+			for (i = 0; i < GIT_ATTR_FILE_NUM_SOURCES; ++i) {
+				if ((file = git__swap(entry->file[i], NULL)) != NULL) {
+					GIT_REFCOUNT_OWN(file, NULL);
+					git_attr_file__free(file);
 				}
 			}
 		});
@@ -345,7 +345,7 @@ static void attr_cache__free(git_attr_cache *cache)
 	git__free(cache);
 }
 
-int git_attr_cache__init(git_repository *repo)
+int git_attr_cache__do_init(git_repository *repo)
 {
 	int ret = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
diff --git a/src/attrcache.h b/src/attrcache.h
index 8e7f022b0..be0a22f5c 100644
--- a/src/attrcache.h
+++ b/src/attrcache.h
@@ -7,9 +7,8 @@
 #ifndef INCLUDE_attrcache_h__
 #define INCLUDE_attrcache_h__
 
-#include "pool.h"
+#include "attr_file.h"
 #include "strmap.h"
-#include "buffer.h"
 
 #define GIT_ATTR_CONFIG       "core.attributesfile"
 #define GIT_IGNORE_CONFIG     "core.excludesfile"
@@ -23,55 +22,35 @@ typedef struct {
 	git_pool  pool;
 } git_attr_cache;
 
-extern int git_attr_cache__init(git_repository *repo);
+extern int git_attr_cache__do_init(git_repository *repo);
 
-typedef enum {
-	GIT_ATTR_CACHE__FROM_FILE = 0,
-	GIT_ATTR_CACHE__FROM_INDEX = 1,
-
-	GIT_ATTR_CACHE_NUM_SOURCES = 2
-} git_attr_cache_source;
-
-typedef struct git_attr_file git_attr_file;
-typedef struct git_attr_rule git_attr_rule;
-
-typedef struct {
-	git_attr_file *file[GIT_ATTR_CACHE_NUM_SOURCES];
-	const char *path; /* points into fullpath */
-	char fullpath[GIT_FLEX_ARRAY];
-} git_attr_cache_entry;
-
-typedef int (*git_attr_cache_parser)(
-	git_repository *repo,
-	git_attr_file *file,
-	const char *data,
-	void *payload);
+#define git_attr_cache__init(REPO) \
+	(git_repository_attr_cache(REPO) ? 0 : git_attr_cache__do_init(REPO))
 
 /* get file - loading and reload as needed */
 extern int git_attr_cache__get(
 	git_attr_file **file,
 	git_repository *repo,
-	git_attr_cache_source source,
+	git_attr_file_source source,
 	const char *base,
 	const char *filename,
-	git_attr_cache_parser parser,
-	void *payload);
+	git_attr_file_parser parser);
 
 extern bool git_attr_cache__is_cached(
 	git_repository *repo,
-	git_attr_cache_source source,
+	git_attr_file_source source,
 	const char *path);
 
+extern int git_attr_cache__alloc_file_entry(
+	git_attr_file_entry **out,
+	const char *base,
+	const char *path,
+	git_pool *pool);
+
 extern int git_attr_cache__insert_macro(
 	git_repository *repo, git_attr_rule *macro);
 
 extern git_attr_rule *git_attr_cache__lookup_macro(
 	git_repository *repo, const char *name);
 
-extern int git_attr_cache_entry__new(
-	git_attr_cache_entry **out,
-	const char *base,
-	const char *path,
-	git_pool *pool);
-
 #endif
diff --git a/src/fileops.c b/src/fileops.c
index d8d819151..13b8f6a39 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -132,6 +132,7 @@ int git_futils_readbuffer_fd(git_buf *buf, git_file fd, size_t len)
 
 	if (read_size != (ssize_t)len) {
 		giterr_set(GITERR_OS, "Failed to read descriptor");
+		git_buf_free(buf);
 		return -1;
 	}
 
@@ -829,3 +830,16 @@ void git_futils_filestamp_set(
 	else
 		memset(target, 0, sizeof(*target));
 }
+
+
+void git_futils_filestamp_set_from_stat(
+	git_futils_filestamp *stamp, struct stat *st)
+{
+	if (st) {
+		stamp->mtime = (git_time_t)st->st_mtime;
+		stamp->size  = (git_off_t)st->st_size;
+		stamp->ino   = (unsigned int)st->st_ino;
+	} else {
+		memset(stamp, 0, sizeof(*stamp));
+	}
+}
diff --git a/src/fileops.h b/src/fileops.h
index cfc2ce701..62227abae 100644
--- a/src/fileops.h
+++ b/src/fileops.h
@@ -317,4 +317,10 @@ extern int git_futils_filestamp_check(
 extern void git_futils_filestamp_set(
 	git_futils_filestamp *tgt, const git_futils_filestamp *src);
 
+/**
+ * Set file stamp data from stat structure
+ */
+extern void git_futils_filestamp_set_from_stat(
+	git_futils_filestamp *stamp, struct stat *st);
+
 #endif /* INCLUDE_fileops_h__ */
diff --git a/src/ignore.c b/src/ignore.c
index fbebd9ad3..deae204f8 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -1,7 +1,7 @@
 #include "git2/ignore.h"
 #include "common.h"
 #include "ignore.h"
-#include "attr_file.h"
+#include "attrcache.h"
 #include "path.h"
 #include "config.h"
 
@@ -10,30 +10,24 @@
 #define GIT_IGNORE_DEFAULT_RULES ".\n..\n.git\n"
 
 static int parse_ignore_file(
-	git_repository *repo,
-	git_attr_file *attrs,
-	const char *data,
-	void *payload)
+	git_repository *repo, git_attr_file *attrs, const char *data)
 {
 	int error = 0;
 	int ignore_case = false;
 	const char *scan = data, *context = NULL;
 	git_attr_fnmatch *match = NULL;
 
-	/* either read ignore_case from ignores structure or use repo config */
-	if (payload != NULL)
-		ignore_case = ((git_ignores *)payload)->ignore_case;
-	else if (git_repository__cvar(&ignore_case, repo, GIT_CVAR_IGNORECASE) < 0)
+	if (git_repository__cvar(&ignore_case, repo, GIT_CVAR_IGNORECASE) < 0)
 		giterr_clear();
 
 	/* if subdir file path, convert context for file paths */
-	if (attrs->ce &&
-		git_path_root(attrs->ce->path) < 0 &&
-		!git__suffixcmp(attrs->ce->path, "/" GIT_IGNORE_FILE))
-		context = attrs->ce->path;
+	if (attrs->entry &&
+		git_path_root(attrs->entry->path) < 0 &&
+		!git__suffixcmp(attrs->entry->path, "/" GIT_IGNORE_FILE))
+		context = attrs->entry->path;
 
 	if (git_mutex_lock(&attrs->lock) < 0) {
-		giterr_set(GITERR_OS, "Failed to lock attribute file");
+		giterr_set(GITERR_OS, "Failed to lock ignore file");
 		return -1;
 	}
 
@@ -84,8 +78,8 @@ static int push_ignore_file(
 	git_attr_file *file = NULL;
 
 	error = git_attr_cache__get(
-		&file, ignores->repo, GIT_ATTR_CACHE__FROM_FILE,
-		base, filename, parse_ignore_file, ignores);
+		&file, ignores->repo, GIT_ATTR_FILE__FROM_FILE,
+		base, filename, parse_ignore_file);
 	if (error < 0)
 		return error;
 
@@ -111,14 +105,12 @@ static int get_internal_ignores(git_attr_file **out, git_repository *repo)
 	if ((error = git_attr_cache__init(repo)) < 0)
 		return error;
 
-	/* get with NULL parser, gives existing or empty git_attr_file */
 	error = git_attr_cache__get(
-		out, repo, GIT_ATTR_CACHE__FROM_FILE,
-		NULL, GIT_IGNORE_INTERNAL, NULL, NULL);
+		out, repo, GIT_ATTR_FILE__IN_MEMORY, NULL, GIT_IGNORE_INTERNAL, NULL);
 
 	/* if internal rules list is empty, insert default rules */
 	if (!error && !(*out)->rules.length)
-		error = parse_ignore_file(repo, *out, GIT_IGNORE_DEFAULT_RULES, NULL);
+		error = parse_ignore_file(repo, *out, GIT_IGNORE_DEFAULT_RULES);
 
 	return error;
 }
@@ -199,7 +191,7 @@ int git_ignore__pop_dir(git_ignores *ign)
 {
 	if (ign->ign_path.length > 0) {
 		git_attr_file *file = git_vector_last(&ign->ign_path);
-		const char *start = file->ce->path, *end;
+		const char *start = file->entry->path, *end;
 
 		/* - ign->dir looks something like "/home/user/a/b/" (or "a/b/c/d/")
 		 * - file->path looks something like "a/b/.gitignore
@@ -302,35 +294,33 @@ cleanup:
 	return 0;
 }
 
-int git_ignore_add_rule(
-	git_repository *repo,
-	const char *rules)
+int git_ignore_add_rule(git_repository *repo, const char *rules)
 {
 	int error;
 	git_attr_file *ign_internal = NULL;
 
-	if (!(error = get_internal_ignores(&ign_internal, repo))) {
-		error = parse_ignore_file(repo, ign_internal, rules, NULL);
-		git_attr_file__free(ign_internal);
-	}
+	if ((error = get_internal_ignores(&ign_internal, repo)) < 0)
+		return error;
+
+	error = parse_ignore_file(repo, ign_internal, rules);
+	git_attr_file__free(ign_internal);
 
 	return error;
 }
 
-int git_ignore_clear_internal_rules(
-	git_repository *repo)
+int git_ignore_clear_internal_rules(git_repository *repo)
 {
 	int error;
 	git_attr_file *ign_internal;
 
-	if (!(error = get_internal_ignores(&ign_internal, repo))) {
-		if (!(error = git_attr_file__clear_rules(ign_internal, true)))
-			error = parse_ignore_file(
-				repo, ign_internal, GIT_IGNORE_DEFAULT_RULES, NULL);
+	if ((error = get_internal_ignores(&ign_internal, repo)) < 0)
+		return error;
 
-		git_attr_file__free(ign_internal);
-	}
+	if (!(error = git_attr_file__clear_rules(ign_internal, true)))
+		error = parse_ignore_file(
+			repo, ign_internal, GIT_IGNORE_DEFAULT_RULES);
 
+	git_attr_file__free(ign_internal);
 	return error;
 }
 
diff --git a/tests/attr/file.c b/tests/attr/file.c
index e35957b51..1f4108c3c 100644
--- a/tests/attr/file.c
+++ b/tests/attr/file.c
@@ -13,7 +13,7 @@ void test_attr_file__simple_read(void)
 
 	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr0")));
 
-	cl_assert_equal_s(cl_fixture("attr/attr0"), file->ce->path);
+	cl_assert_equal_s(cl_fixture("attr/attr0"), file->entry->path);
 	cl_assert(file->rules.length == 1);
 
 	rule = get_rule(0);
@@ -39,7 +39,7 @@ void test_attr_file__match_variants(void)
 
 	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr1")));
 
-	cl_assert_equal_s(cl_fixture("attr/attr1"), file->ce->path);
+	cl_assert_equal_s(cl_fixture("attr/attr1"), file->entry->path);
 	cl_assert(file->rules.length == 10);
 
 	/* let's do a thorough check of this rule, then just verify
@@ -123,7 +123,7 @@ void test_attr_file__assign_variants(void)
 
 	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr2")));
 
-	cl_assert_equal_s(cl_fixture("attr/attr2"), file->ce->path);
+	cl_assert_equal_s(cl_fixture("attr/attr2"), file->entry->path);
 	cl_assert(file->rules.length == 11);
 
 	check_one_assign(file, 0, 0, "pat0", "simple", EXPECT_TRUE, NULL);
@@ -188,7 +188,7 @@ void test_attr_file__check_attr_examples(void)
 	git_attr_assignment *assign;
 
 	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr3")));
-	cl_assert_equal_s(cl_fixture("attr/attr3"), file->ce->path);
+	cl_assert_equal_s(cl_fixture("attr/attr3"), file->entry->path);
 	cl_assert(file->rules.length == 3);
 
 	rule = get_rule(0);
diff --git a/tests/attr/lookup.c b/tests/attr/lookup.c
index 099597efc..030ea075d 100644
--- a/tests/attr/lookup.c
+++ b/tests/attr/lookup.c
@@ -10,7 +10,7 @@ void test_attr_lookup__simple(void)
 	const char *value = NULL;
 
 	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr0")));
-	cl_assert_equal_s(cl_fixture("attr/attr0"), file->ce->path);
+	cl_assert_equal_s(cl_fixture("attr/attr0"), file->entry->path);
 	cl_assert(file->rules.length == 1);
 
 	cl_git_pass(git_attr_path__init(&path, "test", NULL));
@@ -130,7 +130,7 @@ void test_attr_lookup__match_variants(void)
 	};
 
 	cl_git_pass(git_attr_file__load_standalone(&file, cl_fixture("attr/attr1")));
-	cl_assert_equal_s(cl_fixture("attr/attr1"), file->ce->path);
+	cl_assert_equal_s(cl_fixture("attr/attr1"), file->entry->path);
 	cl_assert(file->rules.length == 10);
 
 	cl_git_pass(git_attr_path__init(&path, "/testing/for/pat0", NULL));
@@ -252,7 +252,7 @@ void test_attr_lookup__from_buffer(void)
 
 	cl_git_pass(git_attr_file__new(&file, NULL, 0));
 
-	cl_git_pass(git_attr_file__parse_buffer(NULL, file, "a* foo\nabc bar\n* baz", NULL));
+	cl_git_pass(git_attr_file__parse_buffer(NULL, file, "a* foo\nabc bar\n* baz"));
 
 	cl_assert(file->rules.length == 3);
 
diff --git a/tests/attr/repo.c b/tests/attr/repo.c
index 49cccdc5a..71dc7a5b5 100644
--- a/tests/attr/repo.c
+++ b/tests/attr/repo.c
@@ -68,9 +68,12 @@ void test_attr_repo__get_one(void)
 		attr_check_expected(scan->expected, scan->expected_str, scan->attr, value);
 	}
 
-	cl_assert(git_attr_cache__is_cached(g_repo, 0, ".git/info/attributes"));
-	cl_assert(git_attr_cache__is_cached(g_repo, 0, ".gitattributes"));
-	cl_assert(git_attr_cache__is_cached(g_repo, 0, "sub/.gitattributes"));
+	cl_assert(git_attr_cache__is_cached(
+		g_repo, GIT_ATTR_FILE__FROM_FILE, ".git/info/attributes"));
+	cl_assert(git_attr_cache__is_cached(
+		g_repo, GIT_ATTR_FILE__FROM_FILE, ".gitattributes"));
+	cl_assert(git_attr_cache__is_cached(
+		g_repo, GIT_ATTR_FILE__FROM_FILE, "sub/.gitattributes"));
 }
 
 void test_attr_repo__get_many(void)
diff --git a/tests/status/ignore.c b/tests/status/ignore.c
index d6c26a847..052a8eae8 100644
--- a/tests/status/ignore.c
+++ b/tests/status/ignore.c
@@ -54,8 +54,10 @@ void test_status_ignore__0(void)
 	}
 
 	/* confirm that ignore files were cached */
-	cl_assert(git_attr_cache__is_cached(g_repo, 0, ".git/info/exclude"));
-	cl_assert(git_attr_cache__is_cached(g_repo, 0, ".gitignore"));
+	cl_assert(git_attr_cache__is_cached(
+		g_repo, GIT_ATTR_FILE__FROM_FILE, ".git/info/exclude"));
+	cl_assert(git_attr_cache__is_cached(
+		g_repo, GIT_ATTR_FILE__FROM_FILE, ".gitignore"));
 }
 
 
-- 
cgit v1.2.3


From 8303827226db114a1157e6173e731f316c217851 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 17 Apr 2014 14:35:29 -0700
Subject: Some memory leak fixes

---
 src/attrcache.c          | 54 +++++++++++++++++++++++++-----------------------
 tests/threads/diff.c     |  7 +++++--
 tests/threads/iterator.c |  4 ++--
 tests/threads/refdb.c    |  3 +++
 4 files changed, 38 insertions(+), 30 deletions(-)

diff --git a/src/attrcache.c b/src/attrcache.c
index 925abb57f..88b68ebb9 100644
--- a/src/attrcache.c
+++ b/src/attrcache.c
@@ -121,7 +121,6 @@ static int attr_cache_remove(git_attr_cache *cache, git_attr_file *file)
 {
 	int error = 0;
 	git_attr_file_entry *entry;
-	bool found = false;
 
 	if (!file)
 		return 0;
@@ -133,7 +132,7 @@ static int attr_cache_remove(git_attr_cache *cache, git_attr_file *file)
 
 	attr_cache_unlock(cache);
 
-	if (found) {
+	if (file) {
 		GIT_REFCOUNT_OWN(file, NULL);
 		git_attr_file__free(file);
 	}
@@ -206,39 +205,42 @@ int git_attr_cache__get(
 	int error = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
 	git_attr_file_entry *entry = NULL;
-	git_attr_file *file = NULL;
+	git_attr_file *file = NULL, *updated = NULL;
 
 	if ((error = attr_cache_lookup(
 			&file, &entry, repo, source, base, filename)) < 0)
-		goto cleanup;
-
-	/* if file not found or out of date, load up-to-date data and replace */
-	if (!file || (error = git_attr_file__out_of_date(repo, file)) > 0) {
-		/* decrement refcount (if file was found) b/c we will not return it */
-		git_attr_file__free(file);
+		return error;
 
-		if (!(error = git_attr_file__load(&file, repo, entry, source, parser)))
-			error = attr_cache_upsert(cache, file);
+	/* load file if we don't have one or if existing one is out of date */
+	if (!file || (error = git_attr_file__out_of_date(repo, file)) > 0)
+		error = git_attr_file__load(&updated, repo, entry, source, parser);
+
+	/* if we loaded the file, insert into and/or update cache */
+	if (updated) {
+		if ((error = attr_cache_upsert(cache, updated)) < 0)
+			git_attr_file__free(updated);
+		else {
+			git_attr_file__free(file); /* offset incref from lookup */
+			file = updated;
+		}
 	}
 
-	/* GIT_ENOTFOUND is okay when probing for the file.  If the file did
-	 * exist and now does not, we have to remove it from cache, however.
-	 */
-	if (error == GIT_ENOTFOUND) {
-		giterr_clear();
-		error = 0;
-
-		if (file != NULL)
-			error = attr_cache_remove(cache, file);
+	/* if file could not be loaded */
+	if (error < 0) {
+		/* remove existing entry */
+		if (file) {
+			git_attr_file__free(file); /* offset incref from lookup */
+			attr_cache_remove(cache, file);
+			file = NULL;
+		}
+		/* no error if file simply doesn't exist */
+		if (error == GIT_ENOTFOUND) {
+			giterr_clear();
+			error = 0;
+		}
 	}
 
-cleanup:
-	if (error < 0 && file != NULL) {
-		git_attr_file__free(file);
-		file = NULL;
-	}
 	*out = file;
-
 	return error;
 }
 
diff --git a/tests/threads/diff.c b/tests/threads/diff.c
index d33e75f2c..79b85800b 100644
--- a/tests/threads/diff.c
+++ b/tests/threads/diff.c
@@ -103,6 +103,7 @@ static void *run_index_diffs(void *arg)
 	}
 
 	git_diff_free(diff);
+	giterr_clear();
 
 	return arg;
 }
@@ -139,8 +140,7 @@ static void *run_index_diffs_with_modifier(void *arg)
 			git_thread_yield();
 		}
 
-		git_index_free(idx);
-		return arg;
+		goto done;
 	}
 
 	/* only use explicit index in this test to prevent reloading */
@@ -164,7 +164,10 @@ static void *run_index_diffs_with_modifier(void *arg)
 	/* results will be unpredictable with index modifier thread running */
 
 	git_diff_free(diff);
+
+done:
 	git_index_free(idx);
+	giterr_clear();
 
 	return arg;
 }
diff --git a/tests/threads/iterator.c b/tests/threads/iterator.c
index 4dd251fa5..8aeae1a6c 100644
--- a/tests/threads/iterator.c
+++ b/tests/threads/iterator.c
@@ -11,7 +11,7 @@ void test_threads_iterator__cleanup(void)
 
 static void *run_workdir_iterator(void *arg)
 {
-	int error = 0, thread = *(int *)arg;
+	int error = 0;
 	git_iterator *iter;
 	const git_index_entry *entry = NULL;
 
@@ -35,7 +35,7 @@ static void *run_workdir_iterator(void *arg)
 	cl_assert_equal_i(GIT_ITEROVER, error);
 
 	git_iterator_free(iter);
-
+	giterr_clear();
 	return arg;
 }
 
diff --git a/tests/threads/refdb.c b/tests/threads/refdb.c
index fbf6ac09b..3b35b45e3 100644
--- a/tests/threads/refdb.c
+++ b/tests/threads/refdb.c
@@ -37,6 +37,7 @@ static void *iterate_refs(void *arg)
 
 	git_reference_iterator_free(i);
 
+	giterr_clear();
 	return arg;
 }
 
@@ -115,6 +116,7 @@ static void *create_refs(void *arg)
 	for (i = 0; i < 10; ++i)
 		git_reference_free(ref[i]);
 
+	giterr_clear();
 	return arg;
 }
 
@@ -141,6 +143,7 @@ static void *delete_refs(void *arg)
 		}
 	}
 
+	giterr_clear();
 	return arg;
 }
 
-- 
cgit v1.2.3


From 2bed3553f4595a42d9a6884edc66b991e21f881e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 18 Apr 2014 00:34:04 +0200
Subject: cherry-pick: terminate the commit id string

We treat this as a NUL-terminated string, so make sure that we add the
terminator.
---
 src/cherrypick.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cherrypick.c b/src/cherrypick.c
index 67a2c6af3..6a5ca834c 100644
--- a/src/cherrypick.c
+++ b/src/cherrypick.c
@@ -187,7 +187,7 @@ int git_cherry_pick(
 		goto on_error;
 	}
 
-	git_oid_fmt(commit_oidstr, git_commit_id(commit));
+	git_oid_nfmt(commit_oidstr, sizeof(commit_oidstr), git_commit_id(commit));
 
 	if ((error = write_merge_msg(repo, commit_msg)) < 0 ||
 		(error = git_buf_printf(&their_label, "%.7s... %s", commit_oidstr, commit_summary)) < 0 ||
-- 
cgit v1.2.3


From 36913b8cb497487728ee9bab383d4c1205685927 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 6 Mar 2014 15:11:11 +0100
Subject: config: document current write behaviour in a test

On set, we set/add the value written to the config's internal values,
but we do not refresh old values.

Document this in a test in preparation for the refresh changes.
---
 tests/config/write.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/tests/config/write.c b/tests/config/write.c
index 922d75557..f269c9571 100644
--- a/tests/config/write.c
+++ b/tests/config/write.c
@@ -304,3 +304,30 @@ void test_config_write__updating_a_locked_config_file_returns_ELOCKED(void)
 	git_config_free(cfg);
 }
 
+void test_config_write__outside_change(void)
+{
+	int32_t tmp;
+	git_config *cfg;
+	const char *filename = "config-ext-change";
+
+	cl_git_mkfile(filename, "[old]\nvalue = 5\n");
+
+	cl_git_pass(git_config_open_ondisk(&cfg, filename));
+
+	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
+
+	/* Change the value on the file itself (simulate external process) */
+	cl_git_mkfile(filename, "[old]\nvalue = 6\n");
+
+	cl_git_pass(git_config_set_int32(cfg, "new.value", 7));
+
+	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
+	cl_assert_equal_i(5, tmp);
+
+	cl_git_pass(git_config_refresh(cfg));
+
+	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
+	cl_assert_equal_i(6, tmp);
+
+	git_config_free(cfg);
+}
-- 
cgit v1.2.3


From 55ebd7d369a789f27fe1ad6b8ec8965aa1335d08 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 13 Mar 2014 17:11:34 +0100
Subject: config: implement config snapshotting

In order to have consistent views of the config files for remotes,
submodules et al. and a configuration that represents what is currently
stored on-disk, we need a way to provide a view of the configuration
that does not change.

The goal here is to provide the snapshotting part by creating a
read-only copy of the state of the configuration at a particular point
in time, which does not change when a repository's main config changes.
---
 include/git2/config.h     |  13 ++
 include/git2/sys/config.h |   2 +
 src/config.c              |  32 +++++
 src/config_file.c         | 330 ++++++++++++++++++++++++++++++++++++----------
 tests/config/snapshot.c   |  69 ++++++++++
 5 files changed, 379 insertions(+), 67 deletions(-)
 create mode 100644 tests/config/snapshot.c

diff --git a/include/git2/config.h b/include/git2/config.h
index 663b4f6ba..86c4012ed 100644
--- a/include/git2/config.h
+++ b/include/git2/config.h
@@ -226,6 +226,19 @@ GIT_EXTERN(int) git_config_open_level(
  */
 GIT_EXTERN(int) git_config_open_global(git_config **out, git_config *config);
 
+/**
+ * Create a snapshot of the configuration
+ *
+ * Create a snapshot of the current state of a configuration, which
+ * allows you to look into a consistent view of the configuration for
+ * looking up complex values (e.g. a remote, submodule).
+ *
+ * @param out pointer in which to store the snapshot config object
+ * @param config configuration to snapshot
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_config_snapshot(git_config **out, git_config *config);
+
 
 /**
  * Reload changed config files
diff --git a/include/git2/sys/config.h b/include/git2/sys/config.h
index 3df2ba327..090588999 100644
--- a/include/git2/sys/config.h
+++ b/include/git2/sys/config.h
@@ -64,6 +64,8 @@ struct git_config_backend {
 	int (*del_multivar)(struct git_config_backend *, const char *key, const char *regexp);
 	int (*iterator)(git_config_iterator **, struct git_config_backend *);
 	int (*refresh)(struct git_config_backend *);
+	/** Produce a read-only version of this backend */
+	int (*snapshot)(struct git_config_backend **, struct git_config_backend *);
 	void (*free)(struct git_config_backend *);
 };
 #define GIT_CONFIG_BACKEND_VERSION 1
diff --git a/src/config.c b/src/config.c
index b3168f735..01a1f7d33 100644
--- a/src/config.c
+++ b/src/config.c
@@ -137,6 +137,38 @@ int git_config_open_ondisk(git_config **out, const char *path)
 	return error;
 }
 
+int git_config_snapshot(git_config **out, git_config *in)
+{
+	int error;
+	size_t i;
+	file_internal *internal;
+	git_config *config;
+
+	*out = NULL;
+
+	if (git_config_new(&config) < 0)
+		return -1;
+
+	git_vector_foreach(&in->files, i, internal) {
+		git_config_backend *b;
+
+		if ((error = internal->file->snapshot(&b, internal->file)) < 0)
+			goto on_error;
+
+		if ((error = git_config_add_backend(config, b, internal->level, 0)) < 0) {
+			b->free(b);
+			goto on_error;
+		}
+	}
+
+	*out = config;
+	return error;
+
+on_error:
+	git_config_free(config);
+	return error;
+}
+
 static int find_internal_file_by_level(
 	file_internal **internal_out,
 	const git_config *cfg,
diff --git a/src/config_file.c b/src/config_file.c
index bb26aa8a3..fcf9cab04 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -88,27 +88,44 @@ struct reader {
 
 typedef struct {
 	git_config_backend parent;
-
 	git_strmap *values;
+} diskfile_header;
+
+typedef struct {
+	diskfile_header header;
+
+	git_config_level_t level;
 
 	git_array_t(struct reader) readers;
 
 	char  *file_path;
-
-	git_config_level_t level;
 } diskfile_backend;
 
+typedef struct {
+	diskfile_header header;
+
+	diskfile_backend *snapshot_from;
+} diskfile_readonly_backend;
+
 static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth);
 static int parse_variable(struct reader *reader, char **var_name, char **var_value);
 static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char *value);
 static char *escape_value(const char *ptr);
 
+int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in);
+
 static void set_parse_error(struct reader *reader, int col, const char *error_str)
 {
 	giterr_set(GITERR_CONFIG, "Failed to parse config file: %s (in %s:%d, column %d)",
 		error_str, reader->file_path, reader->line_number, col);
 }
 
+static int config_error_readonly(void)
+{
+	giterr_set(GITERR_CONFIG, "this backend is read-only");
+	return -1;
+}
+
 static void cvar_free(cvar_t *var)
 {
 	if (var == NULL)
@@ -155,6 +172,30 @@ int git_config_file_normalize_section(char *start, char *end)
 	return 0;
 }
 
+/* Add or append the new config option */
+static int append_entry(git_strmap *values, cvar_t *var)
+{
+	git_strmap_iter pos;
+	cvar_t *existing;
+	int error = 0;
+
+	pos = git_strmap_lookup_index(values, var->entry->name);
+	if (!git_strmap_valid_index(values, pos)) {
+		git_strmap_insert(values, var->entry->name, var, error);
+	} else {
+		existing = git_strmap_value_at(values, pos);
+		while (existing->next != NULL) {
+			existing = existing->next;
+		}
+		existing->next = var;
+	}
+
+	if (error > 0)
+		error = 0;
+
+	return error;
+}
+
 static void free_vars(git_strmap *values)
 {
 	cvar_t *var = NULL;
@@ -180,13 +221,13 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 
 	b->level = level;
 
-	if ((res = git_strmap_alloc(&b->values)) < 0)
+	if ((res = git_strmap_alloc(&b->header.values)) < 0)
 		return res;
 
 	git_array_init(b->readers);
 	reader = git_array_alloc(b->readers);
 	if (!reader) {
-		git_strmap_free(b->values);
+		git_strmap_free(b->header.values);
 		return -1;
 	}
 	memset(reader, 0, sizeof(struct reader));
@@ -203,8 +244,8 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 		return 0;
 
 	if (res < 0 || (res = config_parse(b, reader, level, 0)) < 0) {
-		free_vars(b->values);
-		b->values = NULL;
+		free_vars(b->header.values);
+		b->header.values = NULL;
 	}
 
 	reader = git_array_get(b->readers, 0);
@@ -239,16 +280,21 @@ static int config_refresh(git_config_backend *cfg)
 		return (res == GIT_ENOTFOUND) ? 0 : res;
 
 	/* need to reload - store old values and prep for reload */
-	old_values = b->values;
-	if ((res = git_strmap_alloc(&b->values)) < 0) {
-		b->values = old_values;
-	} else if ((res = config_parse(b, reader, b->level, 0)) < 0) {
-		free_vars(b->values);
-		b->values = old_values;
-	} else {
-		free_vars(old_values);
+	old_values = b->header.values;
+	if ((res = git_strmap_alloc(&b->header.values)) < 0) {
+		b->header.values = old_values;
+		goto cleanup;
 	}
 
+	if ((res = config_parse(b, reader, b->level, 0)) < 0) {
+		free_vars(b->header.values);
+		b->header.values = old_values;
+		goto cleanup;
+	}
+
+	free_vars(old_values);
+
+cleanup:
 	git_buf_free(&reader->buffer);
 	return res;
 }
@@ -268,7 +314,7 @@ static void backend_free(git_config_backend *_backend)
 	git_array_clear(backend->readers);
 
 	git__free(backend->file_path);
-	free_vars(backend->values);
+	free_vars(backend->header.values);
 	git__free(backend);
 }
 
@@ -283,12 +329,13 @@ static int config_iterator_next(
 	git_config_iterator *iter)
 {
 	git_config_file_iter *it = (git_config_file_iter *) iter;
-	diskfile_backend *b = (diskfile_backend *) it->parent.backend;
+	diskfile_header *h = (diskfile_header *) it->parent.backend;
+	git_strmap *values = h->values;
 	int err = 0;
 	cvar_t * var;
 
 	if (it->next_var == NULL) {
-		err = git_strmap_next((void**) &var, &(it->iter), b->values);
+		err = git_strmap_next((void**) &var, &(it->iter), values);
 	} else {
 		var = it->next_var;
 	}
@@ -308,15 +355,16 @@ static int config_iterator_new(
 	git_config_iterator **iter,
 	struct git_config_backend* backend)
 {
-	diskfile_backend *b = (diskfile_backend *)backend;
+	diskfile_header *h = (diskfile_header *)backend;
 	git_config_file_iter *it = git__calloc(1, sizeof(git_config_file_iter));
 
-	GIT_UNUSED(b);
-
 	GITERR_CHECK_ALLOC(it);
 
+	/* strmap_begin() is currently a macro returning 0 */
+	GIT_UNUSED(h);
+
 	it->parent.backend = backend;
-	it->iter = git_strmap_begin(b->values);
+	it->iter = git_strmap_begin(h->values);
 	it->next_var = NULL;
 
 	it->parent.next = config_iterator_next;
@@ -330,6 +378,7 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 {
 	cvar_t *var = NULL, *old_var = NULL;
 	diskfile_backend *b = (diskfile_backend *)cfg;
+	git_strmap *values = b->header.values;
 	char *key, *esc_value = NULL;
 	khiter_t pos;
 	int rval, ret;
@@ -341,9 +390,9 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 	 * Try to find it in the existing values and update it if it
 	 * only has one value.
 	 */
-	pos = git_strmap_lookup_index(b->values, key);
-	if (git_strmap_valid_index(b->values, pos)) {
-		cvar_t *existing = git_strmap_value_at(b->values, pos);
+	pos = git_strmap_lookup_index(values, key);
+	if (git_strmap_valid_index(values, pos)) {
+		cvar_t *existing = git_strmap_value_at(values, pos);
 		char *tmp = NULL;
 
 		git__free(key);
@@ -398,7 +447,7 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 	}
 
 	git__free(esc_value);
-	git_strmap_insert2(b->values, key, var, old_var, rval);
+	git_strmap_insert2(values, key, var, old_var, rval);
 	if (rval < 0)
 		return -1;
 	if (old_var != NULL)
@@ -412,15 +461,16 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
  */
 static int config_get(const git_config_backend *cfg, const char *key, const git_config_entry **out)
 {
-	diskfile_backend *b = (diskfile_backend *)cfg;
-	khiter_t pos = git_strmap_lookup_index(b->values, key);
+	diskfile_header *h = (diskfile_header *)cfg;
+	git_strmap *values = h->values;
+	khiter_t pos = git_strmap_lookup_index(values, key);
 	cvar_t *var;
 
 	/* no error message; the config system will write one */
-	if (!git_strmap_valid_index(b->values, pos))
+	if (!git_strmap_valid_index(values, pos))
 		return GIT_ENOTFOUND;
 
-	var = git_strmap_value_at(b->values, pos);
+	var = git_strmap_value_at(values, pos);
 	while (var->next)
 		var = var->next;
 
@@ -434,6 +484,7 @@ static int config_set_multivar(
 	int replaced = 0;
 	cvar_t *var, *newvar;
 	diskfile_backend *b = (diskfile_backend *)cfg;
+	git_strmap *values = b->header.values;
 	char *key;
 	regex_t preg;
 	int result;
@@ -444,15 +495,15 @@ static int config_set_multivar(
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	pos = git_strmap_lookup_index(b->values, key);
-	if (!git_strmap_valid_index(b->values, pos)) {
+	pos = git_strmap_lookup_index(values, key);
+	if (!git_strmap_valid_index(values, pos)) {
 		/* If we don't have it, behave like a normal set */
 		result = config_set(cfg, name, value);
 		git__free(key);
 		return result;
 	}
 
-	var = git_strmap_value_at(b->values, pos);
+	var = git_strmap_value_at(values, pos);
 
 	result = regcomp(&preg, regexp, REG_EXTENDED);
 	if (result < 0) {
@@ -510,6 +561,7 @@ static int config_delete(git_config_backend *cfg, const char *name)
 {
 	cvar_t *var;
 	diskfile_backend *b = (diskfile_backend *)cfg;
+	git_strmap *values = b->header.values;
 	char *key;
 	int result;
 	khiter_t pos;
@@ -517,22 +569,22 @@ static int config_delete(git_config_backend *cfg, const char *name)
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	pos = git_strmap_lookup_index(b->values, key);
+	pos = git_strmap_lookup_index(values, key);
 	git__free(key);
 
-	if (!git_strmap_valid_index(b->values, pos)) {
+	if (!git_strmap_valid_index(values, pos)) {
 		giterr_set(GITERR_CONFIG, "Could not find key '%s' to delete", name);
 		return GIT_ENOTFOUND;
 	}
 
-	var = git_strmap_value_at(b->values, pos);
+	var = git_strmap_value_at(values, pos);
 
 	if (var->next != NULL) {
 		giterr_set(GITERR_CONFIG, "Cannot delete multivar with a single delete");
 		return -1;
 	}
 
-	git_strmap_delete_at(b->values, pos);
+	git_strmap_delete_at(values, pos);
 
 	result = config_write(b, var->entry->name, NULL, NULL);
 
@@ -546,6 +598,7 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	cvar_t **to_delete;
 	int to_delete_idx;
 	diskfile_backend *b = (diskfile_backend *)cfg;
+	git_strmap *values = b->header.values;
 	char *key;
 	regex_t preg;
 	int result;
@@ -554,15 +607,15 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
-	pos = git_strmap_lookup_index(b->values, key);
+	pos = git_strmap_lookup_index(values, key);
 
-	if (!git_strmap_valid_index(b->values, pos)) {
+	if (!git_strmap_valid_index(values, pos)) {
 		giterr_set(GITERR_CONFIG, "Could not find key '%s' to delete", name);
 		git__free(key);
 		return GIT_ENOTFOUND;
 	}
 
-	var = git_strmap_value_at(b->values, pos);
+	var = git_strmap_value_at(values, pos);
 
 	result = regcomp(&preg, regexp, REG_EXTENDED);
 	if (result < 0) {
@@ -597,9 +650,9 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	}
 
 	if (new_head != NULL) {
-		git_strmap_set_value_at(b->values, pos, new_head);
+		git_strmap_set_value_at(values, pos, new_head);
 	} else {
-		git_strmap_delete_at(b->values, pos);
+		git_strmap_delete_at(values, pos);
 	}
 
 	if (to_delete_idx > 0)
@@ -614,6 +667,13 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	return result;
 }
 
+static int config_snapshot(git_config_backend **out, git_config_backend *in)
+{
+	diskfile_backend *b = (diskfile_backend *) in;
+
+	return git_config_file__snapshot(out, b);
+}
+
 int git_config_file__ondisk(git_config_backend **out, const char *path)
 {
 	diskfile_backend *backend;
@@ -621,20 +681,164 @@ int git_config_file__ondisk(git_config_backend **out, const char *path)
 	backend = git__calloc(1, sizeof(diskfile_backend));
 	GITERR_CHECK_ALLOC(backend);
 
-	backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
+	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
 
 	backend->file_path = git__strdup(path);
 	GITERR_CHECK_ALLOC(backend->file_path);
 
-	backend->parent.open = config_open;
-	backend->parent.get = config_get;
-	backend->parent.set = config_set;
-	backend->parent.set_multivar = config_set_multivar;
-	backend->parent.del = config_delete;
-	backend->parent.del_multivar = config_delete_multivar;
-	backend->parent.iterator = config_iterator_new;
-	backend->parent.refresh = config_refresh;
-	backend->parent.free = backend_free;
+	backend->header.parent.open = config_open;
+	backend->header.parent.get = config_get;
+	backend->header.parent.set = config_set;
+	backend->header.parent.set_multivar = config_set_multivar;
+	backend->header.parent.del = config_delete;
+	backend->header.parent.del_multivar = config_delete_multivar;
+	backend->header.parent.iterator = config_iterator_new;
+	backend->header.parent.refresh = config_refresh;
+	backend->header.parent.snapshot = config_snapshot;
+	backend->header.parent.free = backend_free;
+
+	*out = (git_config_backend *)backend;
+
+	return 0;
+}
+
+static int config_set_readonly(git_config_backend *cfg, const char *name, const char *value)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(value);
+
+	return config_error_readonly();
+}
+
+static int config_set_multivar_readonly(
+	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+	GIT_UNUSED(value);
+
+	return config_error_readonly();
+}
+
+static int config_delete_multivar_readonly(git_config_backend *cfg, const char *name, const char *regexp)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+	GIT_UNUSED(regexp);
+
+	return config_error_readonly();
+}
+
+static int config_delete_readonly(git_config_backend *cfg, const char *name)
+{
+	GIT_UNUSED(cfg);
+	GIT_UNUSED(name);
+
+	return config_error_readonly();
+}
+
+static int config_refresh_readonly(git_config_backend *cfg)
+{
+	GIT_UNUSED(cfg);
+
+	return config_error_readonly();
+}
+
+static void backend_readonly_free(git_config_backend *_backend)
+{
+	diskfile_backend *backend = (diskfile_backend *)_backend;
+
+	if (backend == NULL)
+		return;
+
+	free_vars(backend->header.values);
+	git__free(backend);
+}
+
+static int config_entry_dup(git_config_entry **out, git_config_entry *src)
+{
+	git_config_entry *entry;
+
+	entry = git__calloc(1, sizeof(git_config_entry));
+	GITERR_CHECK_ALLOC(entry);
+
+	entry->level = src->level;
+	entry->name = git__strdup(src->name);
+	GITERR_CHECK_ALLOC(entry->name);
+	entry->value = git__strdup(src->value);
+	GITERR_CHECK_ALLOC(entry->value);
+
+	*out = entry;
+
+	return 0;
+}
+
+static int config_readonly_open(git_config_backend *cfg, git_config_level_t level)
+{
+	diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;
+	diskfile_backend *src = b->snapshot_from;
+	git_strmap *src_values = src->header.values;
+	git_strmap *values;
+	git_strmap_iter i;
+	cvar_t *src_var;
+	int error;
+
+	/* We're just copying data, don't care about the level */
+	GIT_UNUSED(level);
+
+	if ((error = git_strmap_alloc(&b->header.values)) < 0)
+		return error;
+
+	values = b->header.values;
+
+	i = git_strmap_begin(src_values);
+	while ((error = git_strmap_next((void **) &src_var, &i, src_values)) == 0) {
+		do {
+			git_config_entry *entry;
+			cvar_t *var;
+
+			var = git__calloc(1, sizeof(cvar_t));
+			GITERR_CHECK_ALLOC(var);
+
+			if (config_entry_dup(&entry, src_var->entry) < 0)
+				return -1;
+
+			var->entry = entry;
+
+			error = append_entry(values, var);
+			src_var = CVAR_LIST_NEXT(src_var);
+		} while (src_var != NULL && error == 0);
+	}
+
+	if (error == GIT_ITEROVER)
+		error = 0;
+
+	return error;
+}
+
+int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)
+{
+	diskfile_readonly_backend *backend;
+
+	backend = git__calloc(1, sizeof(diskfile_readonly_backend));
+	GITERR_CHECK_ALLOC(backend);
+
+	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+
+	backend->snapshot_from = in;
+
+	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+	backend->header.parent.open = config_readonly_open;
+	backend->header.parent.get = config_get;
+	backend->header.parent.set = config_set_readonly;
+	backend->header.parent.set_multivar = config_set_multivar_readonly;
+	backend->header.parent.del = config_delete_readonly;
+	backend->header.parent.del_multivar = config_delete_multivar_readonly;
+	backend->header.parent.iterator = config_iterator_new;
+	backend->header.parent.refresh = config_refresh_readonly;
+	backend->header.parent.free = backend_readonly_free;
 
 	*out = (git_config_backend *)backend;
 
@@ -1020,11 +1224,11 @@ static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_c
 	char *current_section = NULL;
 	char *var_name;
 	char *var_value;
-	cvar_t *var, *existing;
+	cvar_t *var;
 	git_buf buf = GIT_BUF_INIT;
 	int result = 0;
-	khiter_t pos;
 	uint32_t reader_idx;
+	git_strmap *values = cfg_file->header.values;
 
 	if (depth >= MAX_INCLUDE_DEPTH) {
 		giterr_set(GITERR_CONFIG, "Maximum config include depth reached");
@@ -1088,21 +1292,13 @@ static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_c
 			var->entry->level = level;
 			var->included = !!depth;
 
-			/* Add or append the new config option */
-			pos = git_strmap_lookup_index(cfg_file->values, var->entry->name);
-			if (!git_strmap_valid_index(cfg_file->values, pos)) {
-				git_strmap_insert(cfg_file->values, var->entry->name, var, result);
-				if (result < 0)
-					break;
+
+			if ((result = append_entry(values, var)) < 0)
+				break;
+			else
 				result = 0;
-			} else {
-				existing = git_strmap_value_at(cfg_file->values, pos);
-				while (existing->next != NULL) {
-					existing = existing->next;
-				}
-				existing->next = var;
-			}
 
+			/* Add or append the new config option */
 			if (!git__strcmp(var->entry->name, "include.path")) {
 				struct reader *r;
 				git_buf path = GIT_BUF_INIT;
diff --git a/tests/config/snapshot.c b/tests/config/snapshot.c
new file mode 100644
index 000000000..a9d3eadd3
--- /dev/null
+++ b/tests/config/snapshot.c
@@ -0,0 +1,69 @@
+#include "clar_libgit2.h"
+
+void test_config_snapshot__create_snapshot(void)
+{
+	int32_t tmp;
+	git_config *cfg, *snapshot;
+	const char *filename = "config-ext-change";
+
+	cl_git_mkfile(filename, "[old]\nvalue = 5\n");
+
+	cl_git_pass(git_config_open_ondisk(&cfg, filename));
+
+	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
+	cl_assert_equal_i(5, tmp);
+
+	cl_git_pass(git_config_snapshot(&snapshot, cfg));
+
+	/* Change the value on the file itself (simulate external process) */
+	cl_git_mkfile(filename, "[old]\nvalue = 56\n");
+
+	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
+	cl_assert_equal_i(5, tmp);
+
+	cl_git_pass(git_config_refresh(cfg));
+
+	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
+	cl_assert_equal_i(56, tmp);
+
+	cl_git_pass(git_config_get_int32(&tmp, snapshot, "old.value"));
+	cl_assert_equal_i(5, tmp);
+	
+	git_config_free(snapshot);
+	git_config_free(cfg);
+}
+
+static int count_me(const git_config_entry *entry, void *payload)
+{
+	int *n = (int *) payload;
+
+	GIT_UNUSED(entry);
+
+	(*n)++;
+
+	return 0;
+}
+
+void test_config_snapshot__multivar(void)
+{
+	int count = 0;
+	git_config *cfg, *snapshot;
+	const char *filename = "config-file";
+
+	cl_git_mkfile(filename, "[old]\nvalue = 5\nvalue = 6\n");
+
+	cl_git_pass(git_config_open_ondisk(&cfg, filename));
+	cl_git_pass(git_config_get_multivar_foreach(cfg, "old.value", NULL, count_me, &count));
+
+	cl_assert_equal_i(2, count);
+
+	cl_git_pass(git_config_snapshot(&snapshot, cfg));
+	git_config_free(cfg);
+
+	count = 0;
+	cl_git_pass(git_config_get_multivar_foreach(snapshot, "old.value", NULL, count_me, &count));
+
+	cl_assert_equal_i(2, count);
+
+	git_config_free(snapshot);
+}
-- 
cgit v1.2.3


From 29c4cb0965b67ad1ae7f640dfee67cf3ce358c26 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 15 Mar 2014 03:53:36 +0100
Subject: Use config snapshotting

This way we can assume we have a consistent view of the config situation
when we're looking up remote, branch, pack-objects, etc.
---
 src/branch.c       | 18 +++++++++++-------
 src/diff_driver.c  |  8 ++++++--
 src/pack-objects.c | 11 ++++++++---
 src/remote.c       |  8 ++++++--
 src/repository.c   | 25 +++++++++++++------------
 src/signature.c    |  7 +++++--
 6 files changed, 49 insertions(+), 28 deletions(-)

diff --git a/src/branch.c b/src/branch.c
index 63c6ec110..d8c82b73e 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -306,17 +306,13 @@ int git_branch_name(
 
 static int retrieve_upstream_configuration(
 	const char **out,
-	git_repository *repo,
+	const git_config *config,
 	const char *canonical_branch_name,
 	const char *format)
 {
-	git_config *config;
 	git_buf buf = GIT_BUF_INIT;
 	int error;
 
-	if (git_repository_config__weakptr(&config, repo) < 0)
-		return -1;
-
 	if (git_buf_printf(&buf, format,
 		canonical_branch_name + strlen(GIT_REFS_HEADS_DIR)) < 0)
 			return -1;
@@ -336,6 +332,7 @@ int git_branch_upstream_name(
 	int error = -1;
 	git_remote *remote = NULL;
 	const git_refspec *refspec;
+	git_config *config, *repo_config;
 
 	assert(out && refname);
 
@@ -344,12 +341,18 @@ int git_branch_upstream_name(
 	if (!git_reference__is_branch(refname))
 		return not_a_local_branch(refname);
 
+	if ((error = git_repository_config__weakptr(&repo_config, repo)) < 0)
+		return error;
+
+	if ((error = git_config_snapshot(&config, repo_config)) < 0)
+		return error;
+
 	if ((error = retrieve_upstream_configuration(
-		&remote_name, repo, refname, "branch.%s.remote")) < 0)
+		&remote_name, config, refname, "branch.%s.remote")) < 0)
 			goto cleanup;
 
 	if ((error = retrieve_upstream_configuration(
-		&merge_name, repo, refname, "branch.%s.merge")) < 0)
+		&merge_name, config, refname, "branch.%s.merge")) < 0)
 			goto cleanup;
 
 	if (!*remote_name || !*merge_name) {
@@ -378,6 +381,7 @@ int git_branch_upstream_name(
 	error = git_buf_set(out, git_buf_cstr(&buf), git_buf_len(&buf));
 
 cleanup:
+	git_config_free(config);
 	git_remote_free(remote);
 	git_buf_free(&buf);
 	return error;
diff --git a/src/diff_driver.c b/src/diff_driver.c
index 8136e0dd9..6e87fd6f8 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -219,7 +219,7 @@ static int git_diff_driver_load(
 	git_diff_driver *drv = NULL;
 	size_t namelen = strlen(driver_name);
 	khiter_t pos;
-	git_config *cfg;
+	git_config *cfg, *repo_cfg;
 	git_buf name = GIT_BUF_INIT;
 	const git_config_entry *ce;
 	bool found_driver = false;
@@ -234,11 +234,14 @@ static int git_diff_driver_load(
 	}
 
 	/* if you can't read config for repo, just use default driver */
-	if (git_repository_config__weakptr(&cfg, repo) < 0) {
+	if (git_repository_config__weakptr(&repo_cfg, repo) < 0) {
 		giterr_clear();
 		goto done;
 	}
 
+	if ((error = git_config_snapshot(&cfg, repo_cfg)) < 0)
+		return error;
+
 	drv = git__calloc(1, sizeof(git_diff_driver) + namelen + 1);
 	GITERR_CHECK_ALLOC(drv);
 	drv->type = DIFF_DRIVER_AUTO;
@@ -321,6 +324,7 @@ static int git_diff_driver_load(
 
 done:
 	git_buf_free(&name);
+	git_config_free(cfg);
 
 	if (!*out) {
 		int error2 = git_diff_driver_builtin(out, reg, driver_name);
diff --git a/src/pack-objects.c b/src/pack-objects.c
index c881e6d99..e7c7f391f 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -86,12 +86,15 @@ static unsigned name_hash(const char *name)
 
 static int packbuilder_config(git_packbuilder *pb)
 {
-	git_config *config;
+	git_config *config, *repo_config;
 	int ret;
 	int64_t val;
 
-	if (git_repository_config__weakptr(&config, pb->repo) < 0)
-		return -1;
+	if ((ret = git_repository_config__weakptr(&repo_config, pb->repo)) < 0)
+		return ret;
+
+	if ((ret = git_config_snapshot(&config, repo_config)) < 0)
+		return ret;
 
 #define config_get(KEY,DST,DFLT) do { \
 	ret = git_config_get_int64(&val, config, KEY); \
@@ -109,6 +112,8 @@ static int packbuilder_config(git_packbuilder *pb)
 
 #undef config_get
 
+	git_config_free(config);
+
 	return 0;
 }
 
diff --git a/src/remote.c b/src/remote.c
index 243086bf9..3a754d4bd 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -347,7 +347,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	git_buf buf = GIT_BUF_INIT;
 	const char *val;
 	int error = 0;
-	git_config *config;
+	git_config *config, *repo_config;
 	struct refspec_cb_data data = { NULL };
 	bool optional_setting_found = false, found;
 
@@ -356,9 +356,12 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	if ((error = ensure_remote_name_is_valid(name)) < 0)
 		return error;
 
-	if (git_repository_config__weakptr(&config, repo) < 0)
+	if (git_repository_config__weakptr(&repo_config, repo) < 0)
 		return -1;
 
+	if ((error = git_config_snapshot(&config, repo_config)) < 0)
+		return error;
+
 	remote = git__malloc(sizeof(git_remote));
 	GITERR_CHECK_ALLOC(remote);
 
@@ -437,6 +440,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	*out = remote;
 
 cleanup:
+	git_config_free(config);
 	git_buf_free(&buf);
 
 	if (error < 0)
diff --git a/src/repository.c b/src/repository.c
index 6b2705bfa..c1d98300c 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -165,13 +165,9 @@ int git_repository_new(git_repository **out)
 	return 0;
 }
 
-static int load_config_data(git_repository *repo)
+static int load_config_data(git_repository *repo, const git_config *config)
 {
 	int is_bare;
-	git_config *config;
-
-	if (git_repository_config__weakptr(&config, repo) < 0)
-		return -1;
 
 	/* Try to figure out if it's bare, default to non-bare if it's not set */
 	if (git_config_get_bool(&is_bare, config, "core.bare") < 0)
@@ -182,19 +178,15 @@ static int load_config_data(git_repository *repo)
 	return 0;
 }
 
-static int load_workdir(git_repository *repo, git_buf *parent_path)
+static int load_workdir(git_repository *repo, git_config *config, git_buf *parent_path)
 {
 	int         error;
-	git_config *config;
 	const git_config_entry *ce;
 	git_buf     worktree = GIT_BUF_INIT;
 
 	if (repo->is_bare)
 		return 0;
 
-	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
-		return error;
-
 	if ((error = git_config__lookup_entry(
 			&ce, config, "core.worktree", false)) < 0)
 		return error;
@@ -447,6 +439,7 @@ int git_repository_open_ext(
 	int error;
 	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT;
 	git_repository *repo;
+	git_config *repo_config, *config;
 
 	if (repo_ptr)
 		*repo_ptr = NULL;
@@ -461,15 +454,23 @@ int git_repository_open_ext(
 	repo->path_repository = git_buf_detach(&path);
 	GITERR_CHECK_ALLOC(repo->path_repository);
 
+	if ((error = git_repository_config__weakptr(&repo_config, repo)) < 0)
+		return error;
+
+	if ((error = git_config_snapshot(&config, repo_config)) < 0)
+		return error;
+
 	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
 		repo->is_bare = 1;
-	else if ((error = load_config_data(repo)) < 0 ||
-		(error = load_workdir(repo, &parent)) < 0)
+	else if ((error = load_config_data(repo, config)) < 0 ||
+		 (error = load_workdir(repo, config, &parent)) < 0)
 	{
+		git_config_free(config);
 		git_repository_free(repo);
 		return error;
 	}
 
+	git_config_free(config);
 	git_buf_free(&parent);
 	*repo_ptr = repo;
 	return 0;
diff --git a/src/signature.c b/src/signature.c
index f501cd8b6..b0ee0da74 100644
--- a/src/signature.c
+++ b/src/signature.c
@@ -141,10 +141,13 @@ int git_signature_now(git_signature **sig_out, const char *name, const char *ema
 int git_signature_default(git_signature **out, git_repository *repo)
 {
 	int error;
-	git_config *cfg;
+	git_config *cfg, *repo_cfg;
 	const char *user_name, *user_email;
 
-	if ((error = git_repository_config(&cfg, repo)) < 0)
+	if ((error = git_repository_config__weakptr(&repo_cfg, repo)) < 0)
+		return error;
+
+	if ((error = git_config_snapshot(&cfg, repo_cfg)) < 0)
 		return error;
 
 	if (!(error = git_config_get_string(&user_name, cfg, "user.name")) &&
-- 
cgit v1.2.3


From c047317e400efc75b07aa0fff61ee1fcd794e74e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 18 Mar 2014 17:54:32 +0100
Subject: config: make refresh atomic

Current code sets the active map to a new one and builds it whilst it's
active. This is a race condition with someone else trying to access the
same config.

Instead, let's build up our new map and swap the active and new one.
---
 src/config_file.c | 39 ++++++++++++++++-----------------------
 1 file changed, 16 insertions(+), 23 deletions(-)

diff --git a/src/config_file.c b/src/config_file.c
index fcf9cab04..437a5c592 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -107,7 +107,7 @@ typedef struct {
 	diskfile_backend *snapshot_from;
 } diskfile_readonly_backend;
 
-static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth);
+static int config_parse(git_strmap *values, diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth);
 static int parse_variable(struct reader *reader, char **var_name, char **var_value);
 static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char *value);
 static char *escape_value(const char *ptr);
@@ -243,7 +243,7 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 	if (res == GIT_ENOTFOUND)
 		return 0;
 
-	if (res < 0 || (res = config_parse(b, reader, level, 0)) < 0) {
+	if (res < 0 || (res = config_parse(b->header.values, b, reader, level, 0)) < 0) {
 		free_vars(b->header.values);
 		b->header.values = NULL;
 	}
@@ -256,47 +256,41 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 
 static int config_refresh(git_config_backend *cfg)
 {
-	int res = 0, updated = 0, any_updated = 0;
+	int error = 0, updated = 0, any_updated = 0;
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	git_strmap *old_values;
+	git_strmap *values = NULL;
 	struct reader *reader = NULL;
 	uint32_t i;
 
 	for (i = 0; i < git_array_size(b->readers); i++) {
 		reader = git_array_get(b->readers, i);
-
-		res = git_futils_readbuffer_updated(
+		error = git_futils_readbuffer_updated(
 			&reader->buffer, reader->file_path,
 			&reader->file_mtime, &reader->file_size, &updated);
 
-		if (res < 0)
-			return (res == GIT_ENOTFOUND) ? 0 : res;
+		if (error < 0)
+			return (error == GIT_ENOTFOUND) ? 0 : error;
 
 		if (updated)
 			any_updated = 1;
 	}
 
 	if (!any_updated)
-		return (res == GIT_ENOTFOUND) ? 0 : res;
+		return (error == GIT_ENOTFOUND) ? 0 : error;
 
-	/* need to reload - store old values and prep for reload */
-	old_values = b->header.values;
-	if ((res = git_strmap_alloc(&b->header.values)) < 0) {
-		b->header.values = old_values;
+	     
+	if ((error = git_strmap_alloc(&values)) < 0)
 		goto cleanup;
-	}
 
-	if ((res = config_parse(b, reader, b->level, 0)) < 0) {
-		free_vars(b->header.values);
-		b->header.values = old_values;
+	if ((error = config_parse(values, b, reader, b->level, 0)) < 0)
 		goto cleanup;
-	}
 
-	free_vars(old_values);
+	values = git__swap(b->header.values, values);
 
 cleanup:
+	free_vars(values);
 	git_buf_free(&reader->buffer);
-	return res;
+	return error;
 }
 
 static void backend_free(git_config_backend *_backend)
@@ -1218,7 +1212,7 @@ static int included_path(git_buf *out, const char *dir, const char *path)
 	return git_path_join_unrooted(out, path, dir, NULL);
 }
 
-static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth)
+static int config_parse(git_strmap *values, diskfile_backend *cfg_file, struct reader *reader, git_config_level_t level, int depth)
 {
 	int c;
 	char *current_section = NULL;
@@ -1228,7 +1222,6 @@ static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_c
 	git_buf buf = GIT_BUF_INIT;
 	int result = 0;
 	uint32_t reader_idx;
-	git_strmap *values = cfg_file->header.values;
 
 	if (depth >= MAX_INCLUDE_DEPTH) {
 		giterr_set(GITERR_CONFIG, "Maximum config include depth reached");
@@ -1327,7 +1320,7 @@ static int config_parse(diskfile_backend *cfg_file, struct reader *reader, git_c
 									    &r->file_size, NULL)) < 0)
 					break;
 
-				result = config_parse(cfg_file, r, level, depth+1);
+				result = config_parse(values, cfg_file, r, level, depth+1);
 				r = git_array_get(cfg_file->readers, index);
 				git_buf_free(&r->buffer);
 
-- 
cgit v1.2.3


From bd95f836f51804011b8a8c532471733f92f3e119 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 31 Mar 2014 08:08:17 +0200
Subject: config: split out the refresh step

This will be used by the writing commands in a later step.
---
 src/config_file.c | 39 +++++++++++++++++++++++++--------------
 1 file changed, 25 insertions(+), 14 deletions(-)

diff --git a/src/config_file.c b/src/config_file.c
index 437a5c592..24ace6039 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -254,11 +254,34 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 	return res;
 }
 
+/* The meat of the refresh, as we want to use it in different places */
+static int config__refresh(git_config_backend *cfg)
+{
+	git_strmap *values = NULL;
+	diskfile_backend *b = (diskfile_backend *)cfg;
+	struct reader *reader = NULL;
+	int error = 0;
+
+	if ((error = git_strmap_alloc(&values)) < 0)
+		goto out;
+
+	reader = git_array_get(b->readers, git_array_size(b->readers) - 1);
+
+	if ((error = config_parse(values, b, reader, b->level, 0)) < 0)
+		goto out;
+
+	values = git__swap(b->header.values, values);
+
+out:
+	free_vars(values);
+	git_buf_free(&reader->buffer);
+	return error;
+}
+
 static int config_refresh(git_config_backend *cfg)
 {
 	int error = 0, updated = 0, any_updated = 0;
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	git_strmap *values = NULL;
 	struct reader *reader = NULL;
 	uint32_t i;
 
@@ -278,19 +301,7 @@ static int config_refresh(git_config_backend *cfg)
 	if (!any_updated)
 		return (error == GIT_ENOTFOUND) ? 0 : error;
 
-	     
-	if ((error = git_strmap_alloc(&values)) < 0)
-		goto cleanup;
-
-	if ((error = config_parse(values, b, reader, b->level, 0)) < 0)
-		goto cleanup;
-
-	values = git__swap(b->header.values, values);
-
-cleanup:
-	free_vars(values);
-	git_buf_free(&reader->buffer);
-	return error;
+	return config__refresh(cfg);
 }
 
 static void backend_free(git_config_backend *_backend)
-- 
cgit v1.2.3


From 0500a1ef4e61449a7ad375c1f42d3bd25a4e36bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 31 Mar 2014 08:32:45 +0200
Subject: config: use a snapshot for the iterator

---
 src/config_file.c | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/src/config_file.c b/src/config_file.c
index 24ace6039..81828ef23 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -113,6 +113,7 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
 static char *escape_value(const char *ptr);
 
 int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in);
+static int config_snapshot(git_config_backend **out, git_config_backend *in);
 
 static void set_parse_error(struct reader *reader, int col, const char *error_str)
 {
@@ -326,6 +327,7 @@ static void backend_free(git_config_backend *_backend)
 static void config_iterator_free(
 	git_config_iterator* iter)
 {
+	iter->backend->free(iter->backend);
 	git__free(iter);
 }
 
@@ -360,15 +362,27 @@ static int config_iterator_new(
 	git_config_iterator **iter,
 	struct git_config_backend* backend)
 {
-	diskfile_header *h = (diskfile_header *)backend;
-	git_config_file_iter *it = git__calloc(1, sizeof(git_config_file_iter));
+	diskfile_header *h;
+	git_config_file_iter *it;
+	git_config_backend *snapshot;
+	diskfile_backend *b = (diskfile_backend *) backend;
+	int error;
+
+	if ((error = config_snapshot(&snapshot, backend)) < 0)
+		return error;
 
+	if ((error = snapshot->open(snapshot, b->level)) < 0)
+		return error;
+
+	it = git__calloc(1, sizeof(git_config_file_iter));
 	GITERR_CHECK_ALLOC(it);
 
+	h = (diskfile_header *)snapshot;
+
 	/* strmap_begin() is currently a macro returning 0 */
 	GIT_UNUSED(h);
 
-	it->parent.backend = backend;
+	it->parent.backend = snapshot;
 	it->iter = git_strmap_begin(h->values);
 	it->next_var = NULL;
 
-- 
cgit v1.2.3


From eaf3703401a64d59fd8bf2609449343d739ef056 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 31 Mar 2014 08:53:56 +0200
Subject: config: refresh the values on write

When writing out, parse the resulting file instead of adding or
replacing the value locally. This has the effect of reading external
changes as well.
---
 src/config_file.c    | 99 +++++++++-------------------------------------------
 tests/config/write.c |  2 +-
 2 files changed, 18 insertions(+), 83 deletions(-)

diff --git a/src/config_file.c b/src/config_file.c
index 81828ef23..621a7c3e2 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -395,7 +395,6 @@ static int config_iterator_new(
 
 static int config_set(git_config_backend *cfg, const char *name, const char *value)
 {
-	cvar_t *var = NULL, *old_var = NULL;
 	diskfile_backend *b = (diskfile_backend *)cfg;
 	git_strmap *values = b->header.values;
 	char *key, *esc_value = NULL;
@@ -412,67 +411,38 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 	pos = git_strmap_lookup_index(values, key);
 	if (git_strmap_valid_index(values, pos)) {
 		cvar_t *existing = git_strmap_value_at(values, pos);
-		char *tmp = NULL;
-
-		git__free(key);
 
 		if (existing->next != NULL) {
+			git__free(key);
 			giterr_set(GITERR_CONFIG, "Multivar incompatible with simple set");
 			return -1;
 		}
 
 		/* don't update if old and new values already match */
 		if ((!existing->entry->value && !value) ||
-			(existing->entry->value && value && !strcmp(existing->entry->value, value)))
+			(existing->entry->value && value &&
+			 !strcmp(existing->entry->value, value))) {
+			git__free(key);
 			return 0;
-
-		if (value) {
-			tmp = git__strdup(value);
-			GITERR_CHECK_ALLOC(tmp);
-			esc_value = escape_value(value);
-			GITERR_CHECK_ALLOC(esc_value);
 		}
-
-		git__free((void *)existing->entry->value);
-		existing->entry->value = tmp;
-
-		ret = config_write(b, existing->entry->name, NULL, esc_value);
-
-		git__free(esc_value);
-		return ret;
 	}
 
-	var = git__malloc(sizeof(cvar_t));
-	GITERR_CHECK_ALLOC(var);
-	memset(var, 0x0, sizeof(cvar_t));
-	var->entry = git__malloc(sizeof(git_config_entry));
-	GITERR_CHECK_ALLOC(var->entry);
-	memset(var->entry, 0x0, sizeof(git_config_entry));
-
-	var->entry->name = key;
-	var->entry->value = NULL;
+	/* No early returns due to sanity checks, let's write it out and refresh */
 
 	if (value) {
-		var->entry->value = git__strdup(value);
-		GITERR_CHECK_ALLOC(var->entry->value);
 		esc_value = escape_value(value);
 		GITERR_CHECK_ALLOC(esc_value);
 	}
 
-	if ((ret = config_write(b, key, NULL, esc_value)) < 0) {
-		git__free(esc_value);
-		cvar_free(var);
-		return ret;
-	}
+	if ((ret = config_write(b, key, NULL, esc_value)) < 0)
+		goto out;
 
-	git__free(esc_value);
-	git_strmap_insert2(values, key, var, old_var, rval);
-	if (rval < 0)
-		return -1;
-	if (old_var != NULL)
-		cvar_free(old_var);
+	ret = config_refresh(cfg);
 
-	return 0;
+out:
+	git__free(esc_value);
+	git__free(key);
+	return ret;
 }
 
 /*
@@ -500,8 +470,6 @@ static int config_get(const git_config_backend *cfg, const char *key, const git_
 static int config_set_multivar(
 	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
 {
-	int replaced = 0;
-	cvar_t *var, *newvar;
 	diskfile_backend *b = (diskfile_backend *)cfg;
 	git_strmap *values = b->header.values;
 	char *key;
@@ -522,8 +490,6 @@ static int config_set_multivar(
 		return result;
 	}
 
-	var = git_strmap_value_at(values, pos);
-
 	result = regcomp(&preg, regexp, REG_EXTENDED);
 	if (result < 0) {
 		git__free(key);
@@ -532,44 +498,13 @@ static int config_set_multivar(
 		return -1;
 	}
 
-	for (;;) {
-		if (regexec(&preg, var->entry->value, 0, NULL, 0) == 0) {
-			char *tmp = git__strdup(value);
-			GITERR_CHECK_ALLOC(tmp);
-
-			git__free((void *)var->entry->value);
-			var->entry->value = tmp;
-			replaced = 1;
-		}
-
-		if (var->next == NULL)
-			break;
-
-		var = var->next;
-	}
-
-	/* If we've reached the end of the variables and we haven't found it yet, we need to append it */
-	if (!replaced) {
-		newvar = git__malloc(sizeof(cvar_t));
-		GITERR_CHECK_ALLOC(newvar);
-		memset(newvar, 0x0, sizeof(cvar_t));
-		newvar->entry = git__malloc(sizeof(git_config_entry));
-		GITERR_CHECK_ALLOC(newvar->entry);
-		memset(newvar->entry, 0x0, sizeof(git_config_entry));
-
-		newvar->entry->name = git__strdup(var->entry->name);
-		GITERR_CHECK_ALLOC(newvar->entry->name);
-
-		newvar->entry->value = git__strdup(value);
-		GITERR_CHECK_ALLOC(newvar->entry->value);
-
-		newvar->entry->level = var->entry->level;
-
-		var->next = newvar;
-	}
+	/* If we do have it, set call config_write() and reload */
+	if ((result = config_write(b, key, &preg, value)) < 0)
+		goto out;
 
-	result = config_write(b, key, &preg, value);
+	result = config_refresh(cfg);
 
+out:
 	git__free(key);
 	regfree(&preg);
 
diff --git a/tests/config/write.c b/tests/config/write.c
index f269c9571..402be9317 100644
--- a/tests/config/write.c
+++ b/tests/config/write.c
@@ -322,7 +322,7 @@ void test_config_write__outside_change(void)
 	cl_git_pass(git_config_set_int32(cfg, "new.value", 7));
 
 	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
-	cl_assert_equal_i(5, tmp);
+	cl_assert_equal_i(6, tmp);
 
 	cl_git_pass(git_config_refresh(cfg));
 
-- 
cgit v1.2.3


From 523032cd24e5b238752394bd1b691a3e28ba321e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 31 Mar 2014 09:58:44 +0200
Subject: config: refresh before reading a value

With the isolation of complex reads, we can now try to refresh the
on-disk file before reading a value from it.

This changes the semantics a bit, as before we could be sure that a
string we got from the configuration was valid until we wrote or
refreshed. This is no longer the case, as a read can also invalidate the
pointer.
---
 include/git2/sys/config.h |  2 +-
 src/config_file.c         | 15 ++++++++++++---
 tests/config/refresh.c    |  9 +++------
 tests/config/snapshot.c   |  5 -----
 4 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/include/git2/sys/config.h b/include/git2/sys/config.h
index 090588999..5d606ed06 100644
--- a/include/git2/sys/config.h
+++ b/include/git2/sys/config.h
@@ -57,7 +57,7 @@ struct git_config_backend {
 
 	/* Open means open the file/database and parse if necessary */
 	int (*open)(struct git_config_backend *, git_config_level_t level);
-	int (*get)(const struct git_config_backend *, const char *key, const git_config_entry **entry);
+	int (*get)(struct git_config_backend *, const char *key, const git_config_entry **entry);
 	int (*set)(struct git_config_backend *, const char *key, const char *value);
 	int (*set_multivar)(git_config_backend *cfg, const char *name, const char *regexp, const char *value);
 	int (*del)(struct git_config_backend *, const char *key);
diff --git a/src/config_file.c b/src/config_file.c
index 621a7c3e2..227ec82e9 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -89,6 +89,7 @@ struct reader {
 typedef struct {
 	git_config_backend parent;
 	git_strmap *values;
+	int readonly;
 } diskfile_header;
 
 typedef struct {
@@ -448,12 +449,19 @@ out:
 /*
  * Internal function that actually gets the value in string form
  */
-static int config_get(const git_config_backend *cfg, const char *key, const git_config_entry **out)
+static int config_get(git_config_backend *cfg, const char *key, const git_config_entry **out)
 {
 	diskfile_header *h = (diskfile_header *)cfg;
-	git_strmap *values = h->values;
-	khiter_t pos = git_strmap_lookup_index(values, key);
+	git_strmap *values;
+	khiter_t pos;
 	cvar_t *var;
+	int error;
+
+	if (!h->readonly && ((error = config_refresh(cfg)) < 0))
+		return error;
+
+	values = h->values;
+	pos = git_strmap_lookup_index(values, key);
 
 	/* no error message; the config system will write one */
 	if (!git_strmap_valid_index(values, pos))
@@ -783,6 +791,7 @@ int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)
 
 	backend->snapshot_from = in;
 
+	backend->header.readonly = 1;
 	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
 	backend->header.parent.open = config_readonly_open;
 	backend->header.parent.get = config_get;
diff --git a/tests/config/refresh.c b/tests/config/refresh.c
index 99d677f0e..08cd45b95 100644
--- a/tests/config/refresh.c
+++ b/tests/config/refresh.c
@@ -26,9 +26,6 @@ void test_config_refresh__update_value(void)
 
 	cl_git_rewritefile(TEST_FILE, "[section]\n\tvalue = 10\n\n");
 
-	cl_git_pass(git_config_get_int32(&v, cfg, "section.value"));
-	cl_assert_equal_i(1, v);
-
 	cl_git_pass(git_config_refresh(cfg));
 
 	cl_git_pass(git_config_get_int32(&v, cfg, "section.value"));
@@ -53,9 +50,9 @@ void test_config_refresh__delete_value(void)
 
 	cl_git_rewritefile(TEST_FILE, "[section]\n\tnewval = 10\n\n");
 
-	cl_git_pass(git_config_get_int32(&v, cfg, "section.value"));
-	cl_assert_equal_i(1, v);
-	cl_git_fail(git_config_get_int32(&v, cfg, "section.newval"));
+	cl_git_fail_with(GIT_ENOTFOUND, git_config_get_int32(&v, cfg, "section.value"));
+
+	cl_git_pass(git_config_get_int32(&v, cfg, "section.newval"));
 
 	cl_git_pass(git_config_refresh(cfg));
 
diff --git a/tests/config/snapshot.c b/tests/config/snapshot.c
index a9d3eadd3..c9f15921a 100644
--- a/tests/config/snapshot.c
+++ b/tests/config/snapshot.c
@@ -18,11 +18,6 @@ void test_config_snapshot__create_snapshot(void)
 	/* Change the value on the file itself (simulate external process) */
 	cl_git_mkfile(filename, "[old]\nvalue = 56\n");
 
-	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
-	cl_assert_equal_i(5, tmp);
-
-	cl_git_pass(git_config_refresh(cfg));
-
 	cl_git_pass(git_config_get_int32(&tmp, cfg, "old.value"));
 	cl_assert_equal_i(56, tmp);
 
-- 
cgit v1.2.3


From c20d71eac928fef34a89ced3cbb6502ab2763dc9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 31 Mar 2014 10:13:40 +0200
Subject: config: document the how long the pointers are valid for

---
 include/git2/config.h | 15 ++++++++++++++-
 1 file changed, 14 insertions(+), 1 deletion(-)

diff --git a/include/git2/config.h b/include/git2/config.h
index 86c4012ed..21a5825a5 100644
--- a/include/git2/config.h
+++ b/include/git2/config.h
@@ -233,6 +233,9 @@ GIT_EXTERN(int) git_config_open_global(git_config **out, git_config *config);
  * allows you to look into a consistent view of the configuration for
  * looking up complex values (e.g. a remote, submodule).
  *
+ * The string returned when querying such a config object is valid
+ * until it is freed.
+ *
  * @param out pointer in which to store the snapshot config object
  * @param config configuration to snapshot
  * @return 0 or an error code
@@ -325,7 +328,8 @@ GIT_EXTERN(int) git_config_get_bool(int *out, const git_config *cfg, const char
  * Get the value of a string config variable.
  *
  * The string is owned by the variable and should not be freed by the
- * user.
+ * user. The pointer will be valid until the next operation on this
+ * config object.
  *
  * All config files will be looked into, in the order of their
  * defined level. A higher level means a higher priority. The
@@ -366,6 +370,9 @@ GIT_EXTERN(int) git_config_multivar_iterator_new(git_config_iterator **out, cons
 /**
  * Return the current entry and advance the iterator
  *
+ * The pointers returned by this function are valid until the iterator
+ * is freed.
+ *
  * @param entry pointer to store the entry
  * @param iter the iterator
  * @return 0 or an error code. GIT_ITEROVER if the iteration has completed
@@ -464,6 +471,9 @@ GIT_EXTERN(int) git_config_delete_multivar(git_config *cfg, const char *name, co
  * If the callback returns a non-zero value, the function stops iterating
  * and returns that value to the caller.
  *
+ * The pointers passed to the callback are only valid as long as the
+ * iteration is ongoing.
+ *
  * @param cfg where to get the variables from
  * @param callback the function to call on each variable
  * @param payload the data to pass to the callback
@@ -504,6 +514,9 @@ GIT_EXTERN(int) git_config_iterator_glob_new(git_config_iterator **out, const gi
  * regular expression that filters which config keys are passed to the
  * callback.
  *
+ * The pointers passed to the callback are only valid as long as the
+ * iteration is ongoing.
+ *
  * @param cfg where to get the variables from
  * @param regexp regular expression to match against config names
  * @param callback the function to call on each variable
-- 
cgit v1.2.3


From 8c1f4ab4abdb47c7926fa678577973272be6e2df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 9 Apr 2014 12:26:53 +0200
Subject: config: refresh on delete

When we delete an entry, we also want to refresh the configuration to
catch any changes that happened externally.

This allows us to simplify the logic, as we no longer need to delete
these variables internally. The whole state will be refreshed and the
deleted entries won't be there.
---
 src/config_file.c       | 63 ++++++++++---------------------------------------
 tests/config/multivar.c |  6 ++---
 2 files changed, 15 insertions(+), 54 deletions(-)

diff --git a/src/config_file.c b/src/config_file.c
index 227ec82e9..e5b5655fc 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -26,7 +26,7 @@ GIT__USE_STRMAP;
 typedef struct cvar_t {
 	struct cvar_t *next;
 	git_config_entry *entry;
-	int included; /* whether this is part of [include] */
+	bool included; /* whether this is part of [include] */
 } cvar_t;
 
 typedef struct git_config_file_iter {
@@ -546,19 +546,14 @@ static int config_delete(git_config_backend *cfg, const char *name)
 		return -1;
 	}
 
-	git_strmap_delete_at(values, pos);
-
-	result = config_write(b, var->entry->name, NULL, NULL);
+	if ((result = config_write(b, var->entry->name, NULL, NULL)) < 0)
+		return result;
 
-	cvar_free(var);
-	return result;
+	return config_refresh(cfg);
 }
 
 static int config_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
 {
-	cvar_t *var, *prev = NULL, *new_head = NULL;
-	cvar_t **to_delete;
-	int to_delete_idx;
 	diskfile_backend *b = (diskfile_backend *)cfg;
 	git_strmap *values = b->header.values;
 	char *key;
@@ -572,59 +567,25 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	pos = git_strmap_lookup_index(values, key);
 
 	if (!git_strmap_valid_index(values, pos)) {
-		giterr_set(GITERR_CONFIG, "Could not find key '%s' to delete", name);
 		git__free(key);
+		giterr_set(GITERR_CONFIG, "Could not find key '%s' to delete", name);
 		return GIT_ENOTFOUND;
 	}
 
-	var = git_strmap_value_at(values, pos);
-
 	result = regcomp(&preg, regexp, REG_EXTENDED);
 	if (result < 0) {
-		git__free(key);
 		giterr_set_regex(&preg, result);
-		regfree(&preg);
-		return -1;
-	}
-
-	to_delete = git__calloc(cvar_length(var), sizeof(cvar_t *));
-	GITERR_CHECK_ALLOC(to_delete);
-	to_delete_idx = 0;
-
-	while (var != NULL) {
-		cvar_t *next = var->next;
-
-		if (regexec(&preg, var->entry->value, 0, NULL, 0) == 0) {
-			// If we are past the head, reattach previous node to next one,
-			// otherwise set the new head for the strmap.
-			if (prev != NULL) {
-				prev->next = next;
-			} else {
-				new_head = next;
-			}
-
-			to_delete[to_delete_idx++] = var;
-		} else {
-			prev = var;
-		}
-
-		var = next;
-	}
-
-	if (new_head != NULL) {
-		git_strmap_set_value_at(values, pos, new_head);
-	} else {
-		git_strmap_delete_at(values, pos);
+		result = -1;
+		goto out;
 	}
 
-	if (to_delete_idx > 0)
-		result = config_write(b, key, &preg, NULL);
+	if ((result = config_write(b, key, &preg, NULL)) < 0)
+		goto out;
 
-	while (to_delete_idx-- > 0)
-		cvar_free(to_delete[to_delete_idx]);
+	result = config_refresh(cfg);
 
+out:
 	git__free(key);
-	git__free(to_delete);
 	regfree(&preg);
 	return result;
 }
@@ -1532,7 +1493,7 @@ static int config_write(diskfile_backend *cfg, const char *key, const regex_t *p
 			 * this, but instead we'll handle it gracefully with an error. */
 			if (value == NULL) {
 				giterr_set(GITERR_CONFIG,
-					"Race condition when writing a config file (a cvar has been removed)");
+					"race condition when writing a config file (a cvar has been removed)");
 				goto rewrite_fail;
 			}
 
diff --git a/tests/config/multivar.c b/tests/config/multivar.c
index afdb1e5f4..015008992 100644
--- a/tests/config/multivar.c
+++ b/tests/config/multivar.c
@@ -231,13 +231,13 @@ void test_config_multivar__delete(void)
 
 	n = 0;
 	cl_git_pass(git_config_get_multivar_foreach(cfg, _name, NULL, cb, &n));
-	cl_assert(n == 2);
+	cl_assert_equal_i(2, n);
 
 	cl_git_pass(git_config_delete_multivar(cfg, _name, "github"));
 
 	n = 0;
 	cl_git_pass(git_config_get_multivar_foreach(cfg, _name, NULL, cb, &n));
-	cl_assert(n == 1);
+	cl_assert_equal_i(1, n);
 
 	git_config_free(cfg);
 
@@ -245,7 +245,7 @@ void test_config_multivar__delete(void)
 
 	n = 0;
 	cl_git_pass(git_config_get_multivar_foreach(cfg, _name, NULL, cb, &n));
-	cl_assert(n == 1);
+	cl_assert_equal_i(1, n);
 
 	git_config_free(cfg);
 }
-- 
cgit v1.2.3


From 4b99b8f52844cb66b2b61b9e88b37b5f98515d50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 9 Apr 2014 13:08:01 +0200
Subject: config: refcount the values map

This is mostly groundwork to let us re-use the map in the snapshots.
---
 src/config_file.c | 174 ++++++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 131 insertions(+), 43 deletions(-)

diff --git a/src/config_file.c b/src/config_file.c
index e5b5655fc..c53ec015f 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -87,8 +87,15 @@ struct reader {
 };
 
 typedef struct {
-	git_config_backend parent;
+	git_atomic refcount;
 	git_strmap *values;
+} refcounted_strmap;
+
+typedef struct {
+	git_config_backend parent;
+	/* mutex to coordinate accessing the values */
+	git_mutex values_mutex;
+	refcounted_strmap *values;
 	int readonly;
 } diskfile_header;
 
@@ -139,18 +146,6 @@ static void cvar_free(cvar_t *var)
 	git__free(var);
 }
 
-static int cvar_length(cvar_t *var)
-{
-	int length = 0;
-
-	while (var) {
-		length++;
-		var = var->next;
-	}
-
-	return length;
-}
-
 int git_config_file_normalize_section(char *start, char *end)
 {
 	char *scan;
@@ -215,6 +210,58 @@ static void free_vars(git_strmap *values)
 	git_strmap_free(values);
 }
 
+static void refcounted_strmap_free(refcounted_strmap *map)
+{
+	if (!map)
+		return;
+
+	if (git_atomic_dec(&map->refcount) != 0)
+		return;
+
+	free_vars(map->values);
+	git__free(map);
+}
+
+/**
+ * Take the current values map from the backend and increase its
+ * refcount. This is its own function to make sure we use the mutex to
+ * avoid the map pointer from changing under us.
+ */
+static refcounted_strmap *refcounted_strmap_take(diskfile_header *h)
+{
+	refcounted_strmap *map;
+
+	git_mutex_lock(&h->values_mutex);
+
+	map = h->values;
+	git_atomic_inc(&map->refcount);
+
+	git_mutex_unlock(&h->values_mutex);
+
+	return map;
+}
+
+static int refcounted_strmap_alloc(refcounted_strmap **out)
+{
+	refcounted_strmap *map;
+	int error;
+
+	map = git__calloc(1, sizeof(refcounted_strmap));
+	if (!map) {
+		giterr_set_oom();
+		return -1;
+	}
+
+	git_atomic_set(&map->refcount, 1);
+	if ((error = git_strmap_alloc(&map->values)) < 0) {
+		git__free(map);
+		return error;
+	}
+
+	*out = map;
+	return error;
+}
+
 static int config_open(git_config_backend *cfg, git_config_level_t level)
 {
 	int res;
@@ -223,13 +270,14 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 
 	b->level = level;
 
-	if ((res = git_strmap_alloc(&b->header.values)) < 0)
+	if ((res = refcounted_strmap_alloc(&b->header.values)) < 0)
 		return res;
 
+	git_mutex_init(&b->header.values_mutex);
 	git_array_init(b->readers);
 	reader = git_array_alloc(b->readers);
 	if (!reader) {
-		git_strmap_free(b->header.values);
+		refcounted_strmap_free(b->header.values);
 		return -1;
 	}
 	memset(reader, 0, sizeof(struct reader));
@@ -245,8 +293,8 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 	if (res == GIT_ENOTFOUND)
 		return 0;
 
-	if (res < 0 || (res = config_parse(b->header.values, b, reader, level, 0)) < 0) {
-		free_vars(b->header.values);
+	if (res < 0 || (res = config_parse(b->header.values->values, b, reader, level, 0)) < 0) {
+		refcounted_strmap_free(b->header.values);
 		b->header.values = NULL;
 	}
 
@@ -259,23 +307,29 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 /* The meat of the refresh, as we want to use it in different places */
 static int config__refresh(git_config_backend *cfg)
 {
-	git_strmap *values = NULL;
+	refcounted_strmap *values = NULL, *tmp;
 	diskfile_backend *b = (diskfile_backend *)cfg;
 	struct reader *reader = NULL;
 	int error = 0;
 
-	if ((error = git_strmap_alloc(&values)) < 0)
+	if ((error = refcounted_strmap_alloc(&values)) < 0)
 		goto out;
 
 	reader = git_array_get(b->readers, git_array_size(b->readers) - 1);
 
-	if ((error = config_parse(values, b, reader, b->level, 0)) < 0)
+	if ((error = config_parse(values->values, b, reader, b->level, 0)) < 0)
 		goto out;
 
-	values = git__swap(b->header.values, values);
+	git_mutex_lock(&b->header.values_mutex);
+
+	tmp = b->header.values;
+	b->header.values = values;
+	values = tmp;
+
+	git_mutex_unlock(&b->header.values_mutex);
 
 out:
-	free_vars(values);
+	refcounted_strmap_free(values);
 	git_buf_free(&reader->buffer);
 	return error;
 }
@@ -321,7 +375,7 @@ static void backend_free(git_config_backend *_backend)
 	git_array_clear(backend->readers);
 
 	git__free(backend->file_path);
-	free_vars(backend->header.values);
+	refcounted_strmap_free(backend->header.values);
 	git__free(backend);
 }
 
@@ -338,7 +392,7 @@ static int config_iterator_next(
 {
 	git_config_file_iter *it = (git_config_file_iter *) iter;
 	diskfile_header *h = (diskfile_header *) it->parent.backend;
-	git_strmap *values = h->values;
+	git_strmap *values = h->values->values;
 	int err = 0;
 	cvar_t * var;
 
@@ -397,7 +451,8 @@ static int config_iterator_new(
 static int config_set(git_config_backend *cfg, const char *name, const char *value)
 {
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	git_strmap *values = b->header.values;
+	refcounted_strmap *map;
+	git_strmap *values;
 	char *key, *esc_value = NULL;
 	khiter_t pos;
 	int rval, ret;
@@ -405,6 +460,9 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 	if ((rval = git_config__normalize_name(name, &key)) < 0)
 		return rval;
 
+	map = refcounted_strmap_take(&b->header);
+	values = map->values;
+
 	/*
 	 * Try to find it in the existing values and update it if it
 	 * only has one value.
@@ -414,17 +472,17 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 		cvar_t *existing = git_strmap_value_at(values, pos);
 
 		if (existing->next != NULL) {
-			git__free(key);
 			giterr_set(GITERR_CONFIG, "Multivar incompatible with simple set");
-			return -1;
+			ret = -1;
+			goto out;
 		}
 
 		/* don't update if old and new values already match */
 		if ((!existing->entry->value && !value) ||
 			(existing->entry->value && value &&
 			 !strcmp(existing->entry->value, value))) {
-			git__free(key);
-			return 0;
+			ret = 0;
+			goto out;
 		}
 	}
 
@@ -441,6 +499,7 @@ static int config_set(git_config_backend *cfg, const char *name, const char *val
 	ret = config_refresh(cfg);
 
 out:
+	refcounted_strmap_free(map);
 	git__free(esc_value);
 	git__free(key);
 	return ret;
@@ -452,6 +511,7 @@ out:
 static int config_get(git_config_backend *cfg, const char *key, const git_config_entry **out)
 {
 	diskfile_header *h = (diskfile_header *)cfg;
+	refcounted_strmap *map;
 	git_strmap *values;
 	khiter_t pos;
 	cvar_t *var;
@@ -460,17 +520,22 @@ static int config_get(git_config_backend *cfg, const char *key, const git_config
 	if (!h->readonly && ((error = config_refresh(cfg)) < 0))
 		return error;
 
-	values = h->values;
+	map = refcounted_strmap_take(h);
+	values = map->values;
+
 	pos = git_strmap_lookup_index(values, key);
 
 	/* no error message; the config system will write one */
-	if (!git_strmap_valid_index(values, pos))
+	if (!git_strmap_valid_index(values, pos)) {
+		refcounted_strmap_free(map);
 		return GIT_ENOTFOUND;
+	}
 
 	var = git_strmap_value_at(values, pos);
 	while (var->next)
 		var = var->next;
 
+	refcounted_strmap_free(map);
 	*out = var->entry;
 	return 0;
 }
@@ -479,7 +544,8 @@ static int config_set_multivar(
 	git_config_backend *cfg, const char *name, const char *regexp, const char *value)
 {
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	git_strmap *values = b->header.values;
+	refcounted_strmap *map;
+	git_strmap *values;
 	char *key;
 	regex_t preg;
 	int result;
@@ -490,20 +556,23 @@ static int config_set_multivar(
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
+	map = refcounted_strmap_take(&b->header);
+	values = b->header.values->values;
+
 	pos = git_strmap_lookup_index(values, key);
 	if (!git_strmap_valid_index(values, pos)) {
 		/* If we don't have it, behave like a normal set */
 		result = config_set(cfg, name, value);
+		refcounted_strmap_free(map);
 		git__free(key);
 		return result;
 	}
 
 	result = regcomp(&preg, regexp, REG_EXTENDED);
 	if (result < 0) {
-		git__free(key);
 		giterr_set_regex(&preg, result);
-		regfree(&preg);
-		return -1;
+		result = -1;
+		goto out;
 	}
 
 	/* If we do have it, set call config_write() and reload */
@@ -513,6 +582,7 @@ static int config_set_multivar(
 	result = config_refresh(cfg);
 
 out:
+	refcounted_strmap_free(map);
 	git__free(key);
 	regfree(&preg);
 
@@ -523,7 +593,7 @@ static int config_delete(git_config_backend *cfg, const char *name)
 {
 	cvar_t *var;
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	git_strmap *values = b->header.values;
+	refcounted_strmap *map;	git_strmap *values;
 	char *key;
 	int result;
 	khiter_t pos;
@@ -531,15 +601,20 @@ static int config_delete(git_config_backend *cfg, const char *name)
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
+	map = refcounted_strmap_take(&b->header);
+	values = b->header.values->values;
+
 	pos = git_strmap_lookup_index(values, key);
 	git__free(key);
 
 	if (!git_strmap_valid_index(values, pos)) {
+		refcounted_strmap_free(map);
 		giterr_set(GITERR_CONFIG, "Could not find key '%s' to delete", name);
 		return GIT_ENOTFOUND;
 	}
 
 	var = git_strmap_value_at(values, pos);
+	refcounted_strmap_free(map);
 
 	if (var->next != NULL) {
 		giterr_set(GITERR_CONFIG, "Cannot delete multivar with a single delete");
@@ -555,7 +630,8 @@ static int config_delete(git_config_backend *cfg, const char *name)
 static int config_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
 {
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	git_strmap *values = b->header.values;
+	refcounted_strmap *map;
+	git_strmap *values;
 	char *key;
 	regex_t preg;
 	int result;
@@ -564,14 +640,20 @@ static int config_delete_multivar(git_config_backend *cfg, const char *name, con
 	if ((result = git_config__normalize_name(name, &key)) < 0)
 		return result;
 
+	map = refcounted_strmap_take(&b->header);
+	values = b->header.values->values;
+
 	pos = git_strmap_lookup_index(values, key);
 
 	if (!git_strmap_valid_index(values, pos)) {
+		refcounted_strmap_free(map);
 		git__free(key);
 		giterr_set(GITERR_CONFIG, "Could not find key '%s' to delete", name);
 		return GIT_ENOTFOUND;
 	}
 
+	refcounted_strmap_free(map);
+
 	result = regcomp(&preg, regexp, REG_EXTENDED);
 	if (result < 0) {
 		giterr_set_regex(&preg, result);
@@ -676,7 +758,7 @@ static void backend_readonly_free(git_config_backend *_backend)
 	if (backend == NULL)
 		return;
 
-	free_vars(backend->header.values);
+	refcounted_strmap_free(backend->header.values);
 	git__free(backend);
 }
 
@@ -702,8 +784,8 @@ static int config_readonly_open(git_config_backend *cfg, git_config_level_t leve
 {
 	diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;
 	diskfile_backend *src = b->snapshot_from;
-	git_strmap *src_values = src->header.values;
-	git_strmap *values;
+	refcounted_strmap *src_map;
+	git_strmap *src_values, *values;
 	git_strmap_iter i;
 	cvar_t *src_var;
 	int error;
@@ -711,10 +793,12 @@ static int config_readonly_open(git_config_backend *cfg, git_config_level_t leve
 	/* We're just copying data, don't care about the level */
 	GIT_UNUSED(level);
 
-	if ((error = git_strmap_alloc(&b->header.values)) < 0)
+	if ((error = refcounted_strmap_alloc(&b->header.values)) < 0)
 		return error;
 
-	values = b->header.values;
+	src_map = refcounted_strmap_take(&src->header);
+	src_values = src->header.values->values;
+	values = b->header.values->values;
 
 	i = git_strmap_begin(src_values);
 	while ((error = git_strmap_next((void **) &src_var, &i, src_values)) == 0) {
@@ -725,8 +809,11 @@ static int config_readonly_open(git_config_backend *cfg, git_config_level_t leve
 			var = git__calloc(1, sizeof(cvar_t));
 			GITERR_CHECK_ALLOC(var);
 
-			if (config_entry_dup(&entry, src_var->entry) < 0)
+			if (config_entry_dup(&entry, src_var->entry) < 0) {
+				refcounted_strmap_free(b->header.values);
+				refcounted_strmap_free(src_map);
 				return -1;
+			}
 
 			var->entry = entry;
 
@@ -738,6 +825,7 @@ static int config_readonly_open(git_config_backend *cfg, git_config_level_t leve
 	if (error == GIT_ITEROVER)
 		error = 0;
 
+	refcounted_strmap_free(src_map);
 	return error;
 }
 
-- 
cgit v1.2.3


From 2280b388c913cbc4eee35ce99c760316206e2703 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 9 Apr 2014 13:17:51 +0200
Subject: config: share the strmap on snapshot

Now that our strmap is no longer modified but replaced, we can use the
same strmap for the snapshot's values and it will be freed when we don't
need it anymore.
---
 src/config_file.c | 56 ++-----------------------------------------------------
 1 file changed, 2 insertions(+), 54 deletions(-)

diff --git a/src/config_file.c b/src/config_file.c
index c53ec015f..c09a032be 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -762,71 +762,19 @@ static void backend_readonly_free(git_config_backend *_backend)
 	git__free(backend);
 }
 
-static int config_entry_dup(git_config_entry **out, git_config_entry *src)
-{
-	git_config_entry *entry;
-
-	entry = git__calloc(1, sizeof(git_config_entry));
-	GITERR_CHECK_ALLOC(entry);
-
-	entry->level = src->level;
-	entry->name = git__strdup(src->name);
-	GITERR_CHECK_ALLOC(entry->name);
-	entry->value = git__strdup(src->value);
-	GITERR_CHECK_ALLOC(entry->value);
-
-	*out = entry;
-
-	return 0;
-}
-
 static int config_readonly_open(git_config_backend *cfg, git_config_level_t level)
 {
 	diskfile_readonly_backend *b = (diskfile_readonly_backend *) cfg;
 	diskfile_backend *src = b->snapshot_from;
 	refcounted_strmap *src_map;
-	git_strmap *src_values, *values;
-	git_strmap_iter i;
-	cvar_t *src_var;
-	int error;
 
 	/* We're just copying data, don't care about the level */
 	GIT_UNUSED(level);
 
-	if ((error = refcounted_strmap_alloc(&b->header.values)) < 0)
-		return error;
-
 	src_map = refcounted_strmap_take(&src->header);
-	src_values = src->header.values->values;
-	values = b->header.values->values;
+	b->header.values = src_map;
 
-	i = git_strmap_begin(src_values);
-	while ((error = git_strmap_next((void **) &src_var, &i, src_values)) == 0) {
-		do {
-			git_config_entry *entry;
-			cvar_t *var;
-
-			var = git__calloc(1, sizeof(cvar_t));
-			GITERR_CHECK_ALLOC(var);
-
-			if (config_entry_dup(&entry, src_var->entry) < 0) {
-				refcounted_strmap_free(b->header.values);
-				refcounted_strmap_free(src_map);
-				return -1;
-			}
-
-			var->entry = entry;
-
-			error = append_entry(values, var);
-			src_var = CVAR_LIST_NEXT(src_var);
-		} while (src_var != NULL && error == 0);
-	}
-
-	if (error == GIT_ITEROVER)
-		error = 0;
-
-	refcounted_strmap_free(src_map);
-	return error;
+	return 0;
 }
 
 int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)
-- 
cgit v1.2.3


From bd270b70f9f1339ac26bbf6e483b3ebf64814d50 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 18 Apr 2014 17:08:10 +0200
Subject: cred: tighten username rules

The ssh-specific credentials allow the username to be missing. The idea
being that the ssh transport will then use the username provided in the
url, if it's available. There are two main issues with this.

The credential callback already knows what username was provided by the
url and needs to figure out whether it wants to ask the user for it or
it can reuse it, so passing NULL as the username means the credential
callback is suspicious.

The username provided in the url is not in fact used by the
transport. The only time it even considers it is for the user/pass
credential, which asserts the existence of a username in its
constructor. For the ssh-specific ones, it passes in the username stored
in the credential, which is NULL. The libssh2 macro we use runs strlen()
against this value (which is no different from what we would be doing
ourselves), so we then crash.

As the documentation doesn't suggest to leave out the username, assert
the need for a username in the code, which removes this buggy behavior
and removes implicit state.

git_cred_has_username() becomes a blacklist of credential types that do
not have a username. The only one at the moment is the 'default' one,
which is meant to call up some Microsoft magic.
---
 src/transports/cred.c | 51 ++++++++++++---------------------------------------
 src/transports/ssh.c  | 13 ++-----------
 2 files changed, 14 insertions(+), 50 deletions(-)

diff --git a/src/transports/cred.c b/src/transports/cred.c
index abae70b51..460ed04a2 100644
--- a/src/transports/cred.c
+++ b/src/transports/cred.c
@@ -11,31 +11,10 @@
 
 int git_cred_has_username(git_cred *cred)
 {
-	int ret = 0;
+	if (cred->credtype == GIT_CREDTYPE_DEFAULT)
+		return 0;
 
-	switch (cred->credtype) {
-	case GIT_CREDTYPE_USERPASS_PLAINTEXT: {
-		git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
-		ret = !!c->username;
-		break;
-	}
-	case GIT_CREDTYPE_SSH_KEY: {
-		git_cred_ssh_key *c = (git_cred_ssh_key *)cred;
-		ret = !!c->username;
-		break;
-	}
-	case GIT_CREDTYPE_SSH_CUSTOM: {
-		git_cred_ssh_custom *c = (git_cred_ssh_custom *)cred;
-		ret = !!c->username;
-		break;
-	}
-	case GIT_CREDTYPE_DEFAULT: {
-		ret = 0;
-		break;
-	}
-	}
-
-	return ret;
+	return 1;
 }
 
 static void plaintext_free(struct git_cred *cred)
@@ -135,7 +114,7 @@ int git_cred_ssh_key_new(
 {
 	git_cred_ssh_key *c;
 
-	assert(cred && privatekey);
+	assert(username && cred && privatekey);
 
 	c = git__calloc(1, sizeof(git_cred_ssh_key));
 	GITERR_CHECK_ALLOC(c);
@@ -143,10 +122,8 @@ int git_cred_ssh_key_new(
 	c->parent.credtype = GIT_CREDTYPE_SSH_KEY;
 	c->parent.free = ssh_key_free;
 
-	if (username) {
-		c->username = git__strdup(username);
-		GITERR_CHECK_ALLOC(c->username);
-	}
+	c->username = git__strdup(username);
+	GITERR_CHECK_ALLOC(c->username);
 
 	c->privatekey = git__strdup(privatekey);
 	GITERR_CHECK_ALLOC(c->privatekey);
@@ -168,7 +145,7 @@ int git_cred_ssh_key_new(
 int git_cred_ssh_key_from_agent(git_cred **cred, const char *username) {
 	git_cred_ssh_key *c;
 
-	assert(cred);
+	assert(username && cred);
 
 	c = git__calloc(1, sizeof(git_cred_ssh_key));
 	GITERR_CHECK_ALLOC(c);
@@ -176,10 +153,8 @@ int git_cred_ssh_key_from_agent(git_cred **cred, const char *username) {
 	c->parent.credtype = GIT_CREDTYPE_SSH_KEY;
 	c->parent.free = ssh_key_free;
 
-	if (username) {
-		c->username = git__strdup(username);
-		GITERR_CHECK_ALLOC(c->username);
-	}
+	c->username = git__strdup(username);
+	GITERR_CHECK_ALLOC(c->username);
 
 	c->privatekey = NULL;
 
@@ -197,7 +172,7 @@ int git_cred_ssh_custom_new(
 {
 	git_cred_ssh_custom *c;
 
-	assert(cred);
+	assert(username && cred);
 
 	c = git__calloc(1, sizeof(git_cred_ssh_custom));
 	GITERR_CHECK_ALLOC(c);
@@ -205,10 +180,8 @@ int git_cred_ssh_custom_new(
 	c->parent.credtype = GIT_CREDTYPE_SSH_CUSTOM;
 	c->parent.free = ssh_custom_free;
 
-	if (username) {
-		c->username = git__strdup(username);
-		GITERR_CHECK_ALLOC(c->username);
-	}
+	c->username = git__strdup(username);
+	GITERR_CHECK_ALLOC(c->username);
 
 	if (publickey_len > 0) {
 		c->publickey = git__malloc(publickey_len);
diff --git a/src/transports/ssh.c b/src/transports/ssh.c
index bece0b45d..879af9059 100644
--- a/src/transports/ssh.c
+++ b/src/transports/ssh.c
@@ -282,7 +282,6 @@ shutdown:
 
 static int _git_ssh_authenticate_session(
 	LIBSSH2_SESSION* session,
-	const char *user,
 	git_cred* cred)
 {
 	int rc;
@@ -291,13 +290,11 @@ static int _git_ssh_authenticate_session(
 		switch (cred->credtype) {
 		case GIT_CREDTYPE_USERPASS_PLAINTEXT: {
 			git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
-			user = c->username ? c->username : user;
-			rc = libssh2_userauth_password(session, user, c->password);
+			rc = libssh2_userauth_password(session, c->username, c->password);
 			break;
 		}
 		case GIT_CREDTYPE_SSH_KEY: {
 			git_cred_ssh_key *c = (git_cred_ssh_key *)cred;
-			user = c->username ? c->username : user;
 
 			if (c->privatekey)
 				rc = libssh2_userauth_publickey_fromfile(
@@ -311,7 +308,6 @@ static int _git_ssh_authenticate_session(
 		case GIT_CREDTYPE_SSH_CUSTOM: {
 			git_cred_ssh_custom *c = (git_cred_ssh_custom *)cred;
 
-			user = c->username ? c->username : user;
 			rc = libssh2_userauth_publickey(
 				session, c->username, (const unsigned char *)c->publickey,
 				c->publickey_len, c->sign_callback, &c->sign_data);
@@ -415,15 +411,10 @@ static int _git_ssh_setup_conn(
 	}
 	assert(t->cred);
 
-	if (!user && !git_cred_has_username(t->cred)) {
-		giterr_set_str(GITERR_NET, "Cannot authenticate without a username");
-		goto on_error;
-	}
-
 	if (_git_ssh_session_create(&session, s->socket) < 0)
 		goto on_error;
 
-	if (_git_ssh_authenticate_session(session, user, t->cred) < 0)
+	if (_git_ssh_authenticate_session(session, t->cred) < 0)
 		goto on_error;
 
 	channel = libssh2_channel_open_session(session);
-- 
cgit v1.2.3


From 478408c01006f39ab916675bc84b8a7340bae086 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Thu, 17 Apr 2014 23:03:44 +0200
Subject: Introduce git_cred_ssh_interactive_new()

This allows for keyboard-interactive based SSH authentication
---
 include/git2/transport.h | 30 ++++++++++++++++++++++++++++++
 src/transports/cred.c    | 36 ++++++++++++++++++++++++++++++++++++
 src/transports/ssh.c     | 22 ++++++++++++++++++++++
 3 files changed, 88 insertions(+)

diff --git a/include/git2/transport.h b/include/git2/transport.h
index 1f4d03eea..eba08cd27 100644
--- a/include/git2/transport.h
+++ b/include/git2/transport.h
@@ -41,6 +41,9 @@ typedef enum {
 
 	/* git_cred_default */
 	GIT_CREDTYPE_DEFAULT = (1u << 3),
+
+	/* git_cred_ssh_interactive */
+	GIT_CREDTYPE_SSH_INTERACTIVE = (1u << 4),
 } git_credtype_t;
 
 /* The base structure for all credential types */
@@ -60,8 +63,10 @@ typedef struct {
 
 #ifdef GIT_SSH
 typedef LIBSSH2_USERAUTH_PUBLICKEY_SIGN_FUNC((*git_cred_sign_callback));
+typedef LIBSSH2_USERAUTH_KBDINT_RESPONSE_FUNC((*git_cred_ssh_interactive_callback));
 #else
 typedef int (*git_cred_sign_callback)(void *, ...);
+typedef int (*git_cred_ssh_interactive_callback)(void *, ...);
 #endif
 
 /**
@@ -75,6 +80,16 @@ typedef struct git_cred_ssh_key {
 	char *passphrase;
 } git_cred_ssh_key;
 
+/**
+ * Keyboard-interactive based ssh authentication
+ */
+typedef struct git_cred_ssh_interactive {
+	git_cred parent;
+	char *username;
+	void *prompt_callback;
+	void *payload;
+} git_cred_ssh_interactive;
+
 /**
  * A key with a custom signature function
  */
@@ -130,6 +145,21 @@ GIT_EXTERN(int) git_cred_ssh_key_new(
 	const char *privatekey,
 	const char *passphrase);
 
+/**
+ * Create a new ssh keyboard-interactive based credential object.
+ * The supplied credential parameter will be internally duplicated.
+ *
+ * @param username Username to use to authenticate.
+ * @param prompt_callback The callback method used for prompts.
+ * @param payload Additional data to pass to the callback.
+ * @return 0 for success or an error code for failure.
+ */
+GIT_EXTERN(int) git_cred_ssh_interactive_new(
+	git_cred **out,
+	const char *username,
+	git_cred_ssh_interactive_callback prompt_callback,
+	void *payload);
+
 /**
  * Create a new ssh key credential object used for querying an ssh-agent.
  * The supplied credential parameter will be internally duplicated.
diff --git a/src/transports/cred.c b/src/transports/cred.c
index 460ed04a2..528d6af73 100644
--- a/src/transports/cred.c
+++ b/src/transports/cred.c
@@ -87,6 +87,16 @@ static void ssh_key_free(struct git_cred *cred)
 	git__free(c);
 }
 
+static void ssh_interactive_free(struct git_cred *cred)
+{
+	git_cred_ssh_interactive *c = (git_cred_ssh_interactive *)cred;
+
+	git__free(c->username);
+
+	git__memzero(c, sizeof(*c));
+	git__free(c);
+}
+
 static void ssh_custom_free(struct git_cred *cred)
 {
 	git_cred_ssh_custom *c = (git_cred_ssh_custom *)cred;
@@ -142,6 +152,32 @@ int git_cred_ssh_key_new(
 	return 0;
 }
 
+int git_cred_ssh_interactive_new(
+	git_cred **out,
+	const char *username,
+	git_cred_ssh_interactive_callback prompt_callback,
+	void *payload)
+{
+	git_cred_ssh_interactive *c;
+
+	assert(out && username && prompt_callback);
+
+	c = git__calloc(1, sizeof(git_cred_ssh_interactive));
+	GITERR_CHECK_ALLOC(c);
+
+	c->parent.credtype = GIT_CREDTYPE_SSH_INTERACTIVE;
+	c->parent.free = ssh_interactive_free;
+
+	c->username = git__strdup(username);
+	GITERR_CHECK_ALLOC(c->username);
+
+	c->prompt_callback = prompt_callback;
+	c->payload = payload;
+
+	*out = &c->parent;
+	return 0;
+}
+
 int git_cred_ssh_key_from_agent(git_cred **cred, const char *username) {
 	git_cred_ssh_key *c;
 
diff --git a/src/transports/ssh.c b/src/transports/ssh.c
index 879af9059..48e51f2ae 100644
--- a/src/transports/ssh.c
+++ b/src/transports/ssh.c
@@ -313,6 +313,27 @@ static int _git_ssh_authenticate_session(
 				c->publickey_len, c->sign_callback, &c->sign_data);
 			break;
 		}
+		case GIT_CREDTYPE_SSH_INTERACTIVE: {
+			void **abstract = libssh2_session_abstract(session);
+			git_cred_ssh_interactive *c = (git_cred_ssh_interactive *)cred;
+
+			/* ideally, we should be able to set this by calling
+			 * libssh2_session_init_ex() instead of libssh2_session_init().
+			 * libssh2's API is inconsistent here i.e. libssh2_userauth_publickey()
+			 * allows you to pass the `abstract` as part of the call, whereas
+			 * libssh2_userauth_keyboard_interactive() does not!
+			 *
+			 * The only way to set the `abstract` pointer is by calling
+			 * libssh2_session_abstract(), which will replace the existing
+			 * pointer as is done below. This is safe for now (at time of writing),
+			 * but may not be valid in future.
+			 */
+			*abstract = c->payload;
+
+			rc = libssh2_userauth_keyboard_interactive(
+				session, c->username, c->prompt_callback);
+			break;
+		}
 		default:
 			rc = LIBSSH2_ERROR_AUTHENTICATION_FAILED;
 		}
@@ -397,6 +418,7 @@ static int _git_ssh_setup_conn(
 				&t->cred, t->owner->url, user,
 				GIT_CREDTYPE_USERPASS_PLAINTEXT |
 				GIT_CREDTYPE_SSH_KEY |
+				GIT_CREDTYPE_SSH_INTERACTIVE |
 				GIT_CREDTYPE_SSH_CUSTOM,
 				t->owner->cred_acquire_payload) < 0)
 			goto on_error;
-- 
cgit v1.2.3


From 8ec0a5527333afeca3f4ff3bf36fb8e1ac1c5939 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 18 Apr 2014 00:49:07 +0200
Subject: Make git_cred_ssh_custom_new() naming more consistent

---
 include/git2/transport.h | 10 +++++-----
 src/transports/cred.c    |  4 ++--
 src/transports/ssh.c     |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/include/git2/transport.h b/include/git2/transport.h
index eba08cd27..80299c41c 100644
--- a/include/git2/transport.h
+++ b/include/git2/transport.h
@@ -99,7 +99,7 @@ typedef struct git_cred_ssh_custom {
 	char *publickey;
 	size_t publickey_len;
 	void *sign_callback;
-	void *sign_data;
+	void *payload;
 } git_cred_ssh_custom;
 
 /** A key for NTLM/Kerberos "default" credentials */
@@ -186,8 +186,8 @@ GIT_EXTERN(int) git_cred_ssh_key_from_agent(
  * @param username username to use to authenticate
  * @param publickey The bytes of the public key.
  * @param publickey_len The length of the public key in bytes.
- * @param sign_fn The callback method to sign the data during the challenge.
- * @param sign_data The data to pass to the sign function.
+ * @param sign_callback The callback method to sign the data during the challenge.
+ * @param payload Additional data to pass to the callback.
  * @return 0 for success or an error code for failure
  */
 GIT_EXTERN(int) git_cred_ssh_custom_new(
@@ -195,8 +195,8 @@ GIT_EXTERN(int) git_cred_ssh_custom_new(
 	const char *username,
 	const char *publickey,
 	size_t publickey_len,
-	git_cred_sign_callback sign_fn,
-	void *sign_data);
+	git_cred_sign_callback sign_callback,
+	void *payload);
 
 /**
  * Create a "default" credential usable for Negotiate mechanisms like NTLM
diff --git a/src/transports/cred.c b/src/transports/cred.c
index 528d6af73..05090ba8a 100644
--- a/src/transports/cred.c
+++ b/src/transports/cred.c
@@ -204,7 +204,7 @@ int git_cred_ssh_custom_new(
 	const char *publickey,
 	size_t publickey_len,
 	git_cred_sign_callback sign_callback,
-	void *sign_data)
+	void *payload)
 {
 	git_cred_ssh_custom *c;
 
@@ -228,7 +228,7 @@ int git_cred_ssh_custom_new(
 
 	c->publickey_len = publickey_len;
 	c->sign_callback = sign_callback;
-	c->sign_data = sign_data;
+	c->payload = payload;
 
 	*cred = &c->parent;
 	return 0;
diff --git a/src/transports/ssh.c b/src/transports/ssh.c
index 48e51f2ae..dea990275 100644
--- a/src/transports/ssh.c
+++ b/src/transports/ssh.c
@@ -310,7 +310,7 @@ static int _git_ssh_authenticate_session(
 
 			rc = libssh2_userauth_publickey(
 				session, c->username, (const unsigned char *)c->publickey,
-				c->publickey_len, c->sign_callback, &c->sign_data);
+				c->publickey_len, c->sign_callback, &c->payload);
 			break;
 		}
 		case GIT_CREDTYPE_SSH_INTERACTIVE: {
-- 
cgit v1.2.3


From 043112dc1c87433f92e1ea3b3ab76efe62edc448 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 18 Apr 2014 17:57:39 +0200
Subject: Replace void * with proper callback types

---
 include/git2/transport.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/git2/transport.h b/include/git2/transport.h
index 80299c41c..1665f97b3 100644
--- a/include/git2/transport.h
+++ b/include/git2/transport.h
@@ -86,7 +86,7 @@ typedef struct git_cred_ssh_key {
 typedef struct git_cred_ssh_interactive {
 	git_cred parent;
 	char *username;
-	void *prompt_callback;
+	git_cred_ssh_interactive_callback prompt_callback;
 	void *payload;
 } git_cred_ssh_interactive;
 
@@ -98,7 +98,7 @@ typedef struct git_cred_ssh_custom {
 	char *username;
 	char *publickey;
 	size_t publickey_len;
-	void *sign_callback;
+	git_cred_sign_callback sign_callback;
 	void *payload;
 } git_cred_ssh_custom;
 
-- 
cgit v1.2.3


From 48ce93e08fb48cafdd86f626c6a1d4a728942cc8 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 18 Apr 2014 18:58:57 +0200
Subject: Fix inconsistent use of lower-case and upper-case names for macros

---
 CMakeLists.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 918e5b8f7..ebd55b9b9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -335,7 +335,7 @@ ENDIF()
 
 IF (THREADSAFE)
 	IF (NOT WIN32)
-		find_package(Threads REQUIRED)
+		FIND_PACKAGE(Threads REQUIRED)
 	ENDIF()
 
 	ADD_DEFINITIONS(-DGIT_THREADS)
@@ -366,7 +366,7 @@ IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
 ELSEIF (CMAKE_SIZEOF_VOID_P EQUAL 4)
 	ADD_DEFINITIONS(-DGIT_ARCH_32)
 ELSE()
-	message(FATAL_ERROR "Unsupported architecture")
+	MESSAGE(FATAL_ERROR "Unsupported architecture")
 ENDIF()
 
 # Compile and link libgit2
@@ -455,7 +455,7 @@ ENDIF ()
 IF (TAGS)
 	FIND_PROGRAM(CTAGS ctags)
 	IF (NOT CTAGS)
-		message(FATAL_ERROR "Could not find ctags command")
+		MESSAGE(FATAL_ERROR "Could not find ctags command")
 	ENDIF ()
 
 	FILE(GLOB_RECURSE SRC_ALL *.[ch])
-- 
cgit v1.2.3


From c6cd3f8bde4aeaad60139dd41a3ed5542dd2ab4f Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 18 Apr 2014 18:32:06 +0200
Subject: Use CHECK_C_COMPILER_FLAG to determine if the compiler supports a
 flag

This simplifies platform/compiler dependent checks where we optionally
enable features or disable warnings.
---
 CMakeLists.txt | 50 ++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 42 insertions(+), 8 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ebd55b9b9..5a87181b4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,6 +18,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/Modules/")
 
 INCLUDE(CheckLibraryExists)
+INCLUDE(CheckCCompilerFlag)
 
 # Build options
 #
@@ -287,7 +288,7 @@ IF (MSVC)
    # Precompiled headers
 
 ELSE ()
-	SET(CMAKE_C_FLAGS "-D_GNU_SOURCE -Wall -Wextra -Wno-missing-field-initializers -Wstrict-aliasing=2 -Wstrict-prototypes -Wdeclaration-after-statement ${CMAKE_C_FLAGS}")
+	SET(CMAKE_C_FLAGS "-D_GNU_SOURCE -Wall -Wextra ${CMAKE_C_FLAGS}")
 
 	IF (WIN32 AND NOT CYGWIN)
 		SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG")
@@ -301,16 +302,49 @@ ELSE ()
 		ADD_DEFINITIONS(-D__USE_MINGW_ANSI_STDIO=1)
 
 	ELSEIF (BUILD_SHARED_LIBS)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden -fPIC")
+		CHECK_C_COMPILER_FLAG(-fvisibility=hidden HIDDEN_VISIBILITY_FLAG)
+		IF(HIDDEN_VISIBILITY_FLAG)
+			SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
+		ENDIF()
+
+		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
 	ENDIF ()
-	IF (APPLE) # Apple deprecated OpenSSL
+
+	CHECK_C_COMPILER_FLAG(-Wno-missing-field-initializers NO_MISSING_FIELD_INIT_WARNING)
+	IF(NO_MISSING_FIELD_INIT_WARNING)
+		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-missing-field-initializers")
+	ENDIF()
+
+	CHECK_C_COMPILER_FLAG(-Wstrict-aliasing STRICT_ALIASING_WARNING)
+	IF(STRICT_ALIASING_WARNING)
+		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-aliasing=2")
+	ENDIF()
+
+	CHECK_C_COMPILER_FLAG(-Wstrict-prototypes STRICT_PROTOTYPES_WARNING)
+	IF(STRICT_PROTOTYPES_WARNING)
+		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-prototypes")
+	ENDIF()
+
+	CHECK_C_COMPILER_FLAG(-Wdeclaration-after-statement DECLARATION_AFTER_STATEMENT_WARNING)
+	IF(DECLARATION_AFTER_STATEMENT_WARNING)
+		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wdeclaration-after-statement")
+	ENDIF()
+
+	CHECK_C_COMPILER_FLAG(-Wno-unused-const-variable UNUSED_CONST_VAR_WARNING)
+	IF(UNUSED_CONST_VAR_WARNING)
+		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-const-variable")
+	ENDIF()
+
+	CHECK_C_COMPILER_FLAG(-Wno-unused-function UNUSED_FUNCTION_WARNING)
+	IF(UNUSED_FUNCTION_WARNING)
+		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function")
+	ENDIF()
+
+	CHECK_C_COMPILER_FLAG(-Wno-deprecated-declarations DEPRECATED_DECLARATIONS_WARNING)
+	IF(DEPRECATED_DECLARATIONS_WARNING)
 		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
+	ENDIF()
 
-		# With clang, disable some annoying extra warnings
-		IF (NOT CMAKE_COMPILER_IS_GNUCC)
-			SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-const-variable -Wno-unused-function")
-		ENDIF()
-	ENDIF ()
 	IF (PROFILE)
 		SET(CMAKE_C_FLAGS "-pg ${CMAKE_C_FLAGS}")
 		SET(CMAKE_EXE_LINKER_FLAGS "-pg ${CMAKE_EXE_LINKER_FLAGS}")
-- 
cgit v1.2.3


From 364ef52881f98293a5e454aab447bc7c2a3d3725 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 18 Apr 2014 19:13:18 +0200
Subject: Only disable deprecation warnings on Apple for OpenSSL

---
 CMakeLists.txt | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5a87181b4..6305be824 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -340,9 +340,11 @@ ELSE ()
 		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function")
 	ENDIF()
 
-	CHECK_C_COMPILER_FLAG(-Wno-deprecated-declarations DEPRECATED_DECLARATIONS_WARNING)
-	IF(DEPRECATED_DECLARATIONS_WARNING)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
+	IF (APPLE) # Apple deprecated OpenSSL
+		CHECK_C_COMPILER_FLAG(-Wno-deprecated-declarations DEPRECATED_DECLARATIONS_WARNING)
+		IF(DEPRECATED_DECLARATIONS_WARNING)
+			SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
+		ENDIF()
 	ENDIF()
 
 	IF (PROFILE)
-- 
cgit v1.2.3


From 6a0956e504328f6584af971e840c202ecb21b5b6 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 18 Apr 2014 10:32:35 -0700
Subject: Pop ignore only if whole relative path matches

When traversing the directory structure, the iterator pushes and
pops ignore files using a vector.  Some directories don't have
ignore files, so it uses a path comparison to decide when it is
right to actually pop the last ignore file.  This was only
comparing directory suffixes, though, so a subdirectory with the
same name as a parent could result in the parent's .gitignore
being popped off the list ignores too early.  This changes the
logic to compare the entire relative path of the ignore file.
---
 src/ignore.c                  | 13 ++++---
 src/ignore.h                  |  1 +
 src/path.c                    |  2 +-
 tests/status/ignore.c         | 86 +++++++++++++++++++++++++++++++++----------
 tests/status/status_helpers.c | 13 ++-----
 5 files changed, 80 insertions(+), 35 deletions(-)

diff --git a/src/ignore.c b/src/ignore.c
index deae204f8..b08ff2200 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -123,7 +123,7 @@ int git_ignore__for_path(
 	int error = 0;
 	const char *workdir = git_repository_workdir(repo);
 
-	assert(ignores);
+	assert(ignores && path);
 
 	memset(ignores, 0, sizeof(*ignores));
 	ignores->repo = repo;
@@ -140,10 +140,13 @@ int git_ignore__for_path(
 	if (workdir && git_path_root(path) < 0)
 		error = git_path_find_dir(&ignores->dir, path, workdir);
 	else
-		error = git_buf_sets(&ignores->dir, path);
+		error = git_buf_joinpath(&ignores->dir, path, "");
 	if (error < 0)
 		goto cleanup;
 
+	if (workdir && !git__prefixcmp(ignores->dir.ptr, workdir))
+		ignores->dir_root = strlen(workdir);
+
 	/* set up internals */
 	if ((error = get_internal_ignores(&ignores->ign_internal, repo)) < 0)
 		goto cleanup;
@@ -204,10 +207,10 @@ int git_ignore__pop_dir(git_ignores *ign)
 
 		if ((end = strrchr(start, '/')) != NULL) {
 			size_t dirlen = (end - start) + 1;
+			const char *relpath = ign->dir.ptr + ign->dir_root;
+			size_t pathlen = ign->dir.size - ign->dir_root;
 
-			if (ign->dir.size >= dirlen &&
-				!memcmp(ign->dir.ptr + ign->dir.size - dirlen, start, dirlen))
-			{
+			if (pathlen == dirlen && !memcmp(relpath, start, dirlen)) {
 				git_vector_pop(&ign->ign_path);
 				git_attr_file__free(file);
 			}
diff --git a/src/ignore.h b/src/ignore.h
index 46172c72f..ff9369000 100644
--- a/src/ignore.h
+++ b/src/ignore.h
@@ -28,6 +28,7 @@ typedef struct {
 	git_attr_file *ign_internal;
 	git_vector ign_path;
 	git_vector ign_global;
+	size_t dir_root; /* offset in dir to repo root */
 	int ignore_case;
 	int depth;
 } git_ignores;
diff --git a/src/path.c b/src/path.c
index 7cad28d45..a990b005f 100644
--- a/src/path.c
+++ b/src/path.c
@@ -624,7 +624,7 @@ int git_path_find_dir(git_buf *dir, const char *path, const char *base)
 
 	/* call dirname if this is not a directory */
 	if (!error) /* && git_path_isdir(dir->ptr) == false) */
-		error = git_path_dirname_r(dir, dir->ptr);
+		error = (git_path_dirname_r(dir, dir->ptr) < 0) ? -1 : 0;
 
 	if (!error)
 		error = git_path_to_dir(dir);
diff --git a/tests/status/ignore.c b/tests/status/ignore.c
index 052a8eae8..eb171deb6 100644
--- a/tests/status/ignore.c
+++ b/tests/status/ignore.c
@@ -230,32 +230,34 @@ void test_status_ignore__subdirectories(void)
 	cl_assert(ignored);
 }
 
-static void make_test_data(void)
+static void make_test_data(const char *reponame, const char **files)
 {
-	static const char *files[] = {
-		"empty_standard_repo/dir/a/ignore_me",
-		"empty_standard_repo/dir/b/ignore_me",
-		"empty_standard_repo/dir/ignore_me",
-		"empty_standard_repo/ignore_also/file",
-		"empty_standard_repo/ignore_me",
-		"empty_standard_repo/test/ignore_me/file",
-		"empty_standard_repo/test/ignore_me/file2",
-		"empty_standard_repo/test/ignore_me/and_me/file",
-		NULL
-	};
-	static const char *repo = "empty_standard_repo";
 	const char **scan;
-	size_t repolen = strlen(repo) + 1;
+	size_t repolen = strlen(reponame) + 1;
 
-	g_repo = cl_git_sandbox_init(repo);
+	g_repo = cl_git_sandbox_init(reponame);
 
 	for (scan = files; *scan != NULL; ++scan) {
 		cl_git_pass(git_futils_mkdir(
-			*scan + repolen, repo, 0777, GIT_MKDIR_PATH | GIT_MKDIR_SKIP_LAST));
+			*scan + repolen, reponame,
+			0777, GIT_MKDIR_PATH | GIT_MKDIR_SKIP_LAST));
 		cl_git_mkfile(*scan, "contents");
 	}
 }
 
+static const char *test_repo_1 = "empty_standard_repo";
+static const char *test_files_1[] = {
+	"empty_standard_repo/dir/a/ignore_me",
+	"empty_standard_repo/dir/b/ignore_me",
+	"empty_standard_repo/dir/ignore_me",
+	"empty_standard_repo/ignore_also/file",
+	"empty_standard_repo/ignore_me",
+	"empty_standard_repo/test/ignore_me/file",
+	"empty_standard_repo/test/ignore_me/file2",
+	"empty_standard_repo/test/ignore_me/and_me/file",
+	NULL
+};
+
 void test_status_ignore__subdirectories_recursion(void)
 {
 	/* Let's try again with recursing into ignored dirs turned on */
@@ -292,7 +294,7 @@ void test_status_ignore__subdirectories_recursion(void)
 		GIT_STATUS_IGNORED, GIT_STATUS_IGNORED, GIT_STATUS_IGNORED,
 	};
 
-	make_test_data();
+	make_test_data(test_repo_1, test_files_1);
 	cl_git_rewritefile("empty_standard_repo/.gitignore", "ignore_me\n/ignore_also\n");
 
 	memset(&counts, 0x0, sizeof(status_entry_counts));
@@ -347,7 +349,7 @@ void test_status_ignore__subdirectories_not_at_root(void)
 		GIT_STATUS_WT_NEW, GIT_STATUS_IGNORED, GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW,
 	};
 
-	make_test_data();
+	make_test_data(test_repo_1, test_files_1);
 	cl_git_rewritefile("empty_standard_repo/dir/.gitignore", "ignore_me\n/ignore_also\n");
 	cl_git_rewritefile("empty_standard_repo/test/.gitignore", "and_me\n");
 
@@ -389,7 +391,7 @@ void test_status_ignore__leading_slash_ignores(void)
 		GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW, GIT_STATUS_WT_NEW,
 	};
 
-	make_test_data();
+	make_test_data(test_repo_1, test_files_1);
 
 	cl_fake_home(&home);
 	cl_git_mkfile("home/.gitignore", "/ignore_me\n");
@@ -422,6 +424,52 @@ void test_status_ignore__leading_slash_ignores(void)
 	cl_fake_home_cleanup(&home);
 }
 
+void test_status_ignore__contained_dir_with_matching_name(void)
+{
+	static const char *test_files[] = {
+		"empty_standard_repo/subdir_match/aaa/subdir_match/file",
+		"empty_standard_repo/subdir_match/zzz_ignoreme",
+		NULL
+	};
+	static const char *expected_paths[] = {
+		"subdir_match/.gitignore",
+		"subdir_match/aaa/subdir_match/file",
+		"subdir_match/zzz_ignoreme",
+	};
+	static const unsigned int expected_statuses[] = {
+		GIT_STATUS_WT_NEW,  GIT_STATUS_WT_NEW,  GIT_STATUS_IGNORED
+	};
+	int ignored;
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	status_entry_counts counts;
+
+	make_test_data("empty_standard_repo", test_files);
+	cl_git_mkfile(
+		"empty_standard_repo/subdir_match/.gitignore", "*_ignoreme\n");
+
+	cl_git_pass(git_status_should_ignore(
+		&ignored, g_repo, "subdir_match/aaa/subdir_match/file"));
+	cl_assert(!ignored);
+
+	cl_git_pass(git_status_should_ignore(
+		&ignored, g_repo, "subdir_match/zzz_ignoreme"));
+	cl_assert(ignored);
+
+	memset(&counts, 0x0, sizeof(status_entry_counts));
+	counts.expected_entry_count = 3;
+	counts.expected_paths = expected_paths;
+	counts.expected_statuses = expected_statuses;
+
+	opts.flags = GIT_STATUS_OPT_DEFAULTS | GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
+
+	cl_git_pass(git_status_foreach_ext(
+		g_repo, &opts, cb_status__normal, &counts));
+
+	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
+	cl_assert_equal_i(0, counts.wrong_status_flags_count);
+	cl_assert_equal_i(0, counts.wrong_sorted_path);
+}
+
 void test_status_ignore__adding_internal_ignores(void)
 {
 	int ignored;
diff --git a/tests/status/status_helpers.c b/tests/status/status_helpers.c
index 902b65c4f..088279252 100644
--- a/tests/status/status_helpers.c
+++ b/tests/status/status_helpers.c
@@ -9,20 +9,13 @@ int cb_status__normal(
 	if (counts->debug)
 		cb_status__print(path, status_flags, NULL);
 
-	if (counts->entry_count >= counts->expected_entry_count) {
+	if (counts->entry_count >= counts->expected_entry_count)
 		counts->wrong_status_flags_count++;
-		goto exit;
-	}
-
-	if (strcmp(path, counts->expected_paths[counts->entry_count])) {
+	else if (strcmp(path, counts->expected_paths[counts->entry_count]))
 		counts->wrong_sorted_path++;
-		goto exit;
-	}
-
-	if (status_flags != counts->expected_statuses[counts->entry_count])
+	else if (status_flags != counts->expected_statuses[counts->entry_count])
 		counts->wrong_status_flags_count++;
 
-exit:
 	counts->entry_count++;
 	return 0;
 }
-- 
cgit v1.2.3


From 50e46d6018ede64e3e4b177baa4ad8156d928fbd Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 18 Apr 2014 10:58:01 -0700
Subject: Cleanup tests with helper functions

---
 tests/attr/ignore.c   |   2 +-
 tests/status/ignore.c | 235 ++++++++++++++++++--------------------------------
 2 files changed, 83 insertions(+), 154 deletions(-)

diff --git a/tests/attr/ignore.c b/tests/attr/ignore.c
index a83c5bd74..68875194d 100644
--- a/tests/attr/ignore.c
+++ b/tests/attr/ignore.c
@@ -16,7 +16,7 @@ void test_attr_ignore__cleanup(void)
 	g_repo = NULL;
 }
 
-void assert_is_ignored_(
+static void assert_is_ignored_(
 	bool expected, const char *filepath, const char *file, int line)
 {
 	int is_ignored = 0;
diff --git a/tests/status/ignore.c b/tests/status/ignore.c
index eb171deb6..15c85e262 100644
--- a/tests/status/ignore.c
+++ b/tests/status/ignore.c
@@ -16,6 +16,23 @@ void test_status_ignore__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
+static void assert_ignored_(
+	bool expected, const char *filepath, const char *file, int line)
+{
+	int is_ignored = 0;
+	cl_git_pass_(
+		git_status_should_ignore(&is_ignored, g_repo, filepath), file, line);
+	clar__assert(
+		(expected != 0) == (is_ignored != 0),
+		file, line, "expected != is_ignored", filepath, 1);
+}
+#define assert_ignored(expected, filepath) \
+	assert_ignored_(expected, filepath, __FILE__, __LINE__)
+#define assert_is_ignored(filepath) \
+	assert_ignored_(true, filepath, __FILE__, __LINE__)
+#define refute_is_ignored(filepath) \
+	assert_ignored_(false, filepath, __FILE__, __LINE__)
+
 void test_status_ignore__0(void)
 {
 	struct {
@@ -47,11 +64,8 @@ void test_status_ignore__0(void)
 
 	g_repo = cl_git_sandbox_init("attr");
 
-	for (one_test = test_cases; one_test->path != NULL; one_test++) {
-		int ignored;
-		cl_git_pass(git_status_should_ignore(&ignored, g_repo, one_test->path));
-		cl_assert_(ignored == one_test->expected, one_test->path);
-	}
+	for (one_test = test_cases; one_test->path != NULL; one_test++)
+		assert_ignored(one_test->expected, one_test->path);
 
 	/* confirm that ignore files were cached */
 	cl_assert(git_attr_cache__is_cached(
@@ -63,37 +77,22 @@ void test_status_ignore__0(void)
 
 void test_status_ignore__1(void)
 {
-	int ignored;
-
 	g_repo = cl_git_sandbox_init("attr");
 
 	cl_git_rewritefile("attr/.gitignore", "/*.txt\n/dir/\n");
 	git_attr_cache_flush(g_repo);
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "root_test4.txt"));
-	cl_assert(ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "sub/subdir_test2.txt"));
-	cl_assert(!ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "dir"));
-	cl_assert(ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "dir/"));
-	cl_assert(ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "sub/dir"));
-	cl_assert(!ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "sub/dir/"));
-	cl_assert(!ignored);
+	assert_is_ignored("root_test4.txt");
+	refute_is_ignored("sub/subdir_test2.txt");
+	assert_is_ignored("dir");
+	assert_is_ignored("dir/");
+	refute_is_ignored("sub/dir");
+	refute_is_ignored("sub/dir/");
 }
 
-
 void test_status_ignore__empty_repo_with_gitignore_rewrite(void)
 {
 	status_entry_single st;
-	int ignored;
 
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
 
@@ -108,8 +107,7 @@ void test_status_ignore__empty_repo_with_gitignore_rewrite(void)
 	cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt"));
 	cl_assert(st.status == GIT_STATUS_WT_NEW);
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt"));
-	cl_assert(!ignored);
+	refute_is_ignored("look-ma.txt");
 
 	cl_git_rewritefile("empty_standard_repo/.gitignore", "*.nomatch\n");
 
@@ -121,8 +119,7 @@ void test_status_ignore__empty_repo_with_gitignore_rewrite(void)
 	cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt"));
 	cl_assert(st.status == GIT_STATUS_WT_NEW);
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt"));
-	cl_assert(!ignored);
+	refute_is_ignored("look-ma.txt");
 
 	cl_git_rewritefile("empty_standard_repo/.gitignore", "*.txt\n");
 
@@ -134,8 +131,7 @@ void test_status_ignore__empty_repo_with_gitignore_rewrite(void)
 	cl_git_pass(git_status_file(&st.status, g_repo, "look-ma.txt"));
 	cl_assert(st.status == GIT_STATUS_IGNORED);
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "look-ma.txt"));
-	cl_assert(ignored);
+	assert_is_ignored("look-ma.txt");
 }
 
 void test_status_ignore__ignore_pattern_contains_space(void)
@@ -181,7 +177,6 @@ void test_status_ignore__ignore_pattern_ignorecase(void)
 void test_status_ignore__subdirectories(void)
 {
 	status_entry_single st;
-	int ignored;
 
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
 
@@ -198,8 +193,7 @@ void test_status_ignore__subdirectories(void)
 	cl_git_pass(git_status_file(&st.status, g_repo, "ignore_me"));
 	cl_assert(st.status == GIT_STATUS_IGNORED);
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "ignore_me"));
-	cl_assert(ignored);
+	assert_is_ignored("ignore_me");
 
 	/* I've changed libgit2 so that the behavior here now differs from
 	 * core git but seems to make more sense.  In core git, the following
@@ -225,9 +219,7 @@ void test_status_ignore__subdirectories(void)
 	cl_git_pass(git_status_file(&st.status, g_repo, "test/ignore_me/file"));
 	cl_assert(st.status == GIT_STATUS_IGNORED);
 
-	cl_git_pass(
-		git_status_should_ignore(&ignored, g_repo, "test/ignore_me/file"));
-	cl_assert(ignored);
+	assert_is_ignored("test/ignore_me/file");
 }
 
 static void make_test_data(const char *reponame, const char **files)
@@ -439,7 +431,6 @@ void test_status_ignore__contained_dir_with_matching_name(void)
 	static const unsigned int expected_statuses[] = {
 		GIT_STATUS_WT_NEW,  GIT_STATUS_WT_NEW,  GIT_STATUS_IGNORED
 	};
-	int ignored;
 	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
 	status_entry_counts counts;
 
@@ -447,13 +438,8 @@ void test_status_ignore__contained_dir_with_matching_name(void)
 	cl_git_mkfile(
 		"empty_standard_repo/subdir_match/.gitignore", "*_ignoreme\n");
 
-	cl_git_pass(git_status_should_ignore(
-		&ignored, g_repo, "subdir_match/aaa/subdir_match/file"));
-	cl_assert(!ignored);
-
-	cl_git_pass(git_status_should_ignore(
-		&ignored, g_repo, "subdir_match/zzz_ignoreme"));
-	cl_assert(ignored);
+	refute_is_ignored("subdir_match/aaa/subdir_match/file");
+	assert_is_ignored("subdir_match/zzz_ignoreme");
 
 	memset(&counts, 0x0, sizeof(status_entry_counts));
 	counts.expected_entry_count = 3;
@@ -472,149 +458,102 @@ void test_status_ignore__contained_dir_with_matching_name(void)
 
 void test_status_ignore__adding_internal_ignores(void)
 {
-	int ignored;
-
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
-	cl_assert(!ignored);
+	refute_is_ignored("one.txt");
+	refute_is_ignored("two.bar");
 
 	cl_git_pass(git_ignore_add_rule(g_repo, "*.nomatch\n"));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
-	cl_assert(!ignored);
+	refute_is_ignored("one.txt");
+	refute_is_ignored("two.bar");
 
 	cl_git_pass(git_ignore_add_rule(g_repo, "*.txt\n"));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
-	cl_assert(!ignored);
+	assert_is_ignored("one.txt");
+	refute_is_ignored("two.bar");
 
 	cl_git_pass(git_ignore_add_rule(g_repo, "*.bar\n"));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
-	cl_assert(ignored);
+	assert_is_ignored("one.txt");
+	assert_is_ignored("two.bar");
 
 	cl_git_pass(git_ignore_clear_internal_rules(g_repo));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
-	cl_assert(!ignored);
+	refute_is_ignored("one.txt");
+	refute_is_ignored("two.bar");
 
 	cl_git_pass(git_ignore_add_rule(
 		g_repo, "multiple\n*.rules\n# comment line\n*.bar\n"));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.txt"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
-	cl_assert(ignored);
+	refute_is_ignored("one.txt");
+	assert_is_ignored("two.bar");
 }
 
 void test_status_ignore__add_internal_as_first_thing(void)
 {
-	int ignored;
 	const char *add_me = "\n#################\n## Eclipse\n#################\n\n*.pydevproject\n.project\n.metadata\nbin/\ntmp/\n*.tmp\n\n";
 
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
 
 	cl_git_pass(git_ignore_add_rule(g_repo, add_me));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "one.tmp"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "two.bar"));
-	cl_assert(!ignored);
+	assert_is_ignored("one.tmp");
+	refute_is_ignored("two.bar");
 }
 
 void test_status_ignore__internal_ignores_inside_deep_paths(void)
 {
-	int ignored;
 	const char *add_me = "Debug\nthis/is/deep\npatterned*/dir\n";
 
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
 
 	cl_git_pass(git_ignore_add_rule(g_repo, add_me));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "Debug"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "and/Debug"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "really/Debug/this/file"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "Debug/what/I/say"));
-	cl_assert(ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "and/NoDebug"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "NoDebug/this"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "please/NoDebug/this"));
-	cl_assert(!ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/is/deep"));
-	cl_assert(ignored);
+	assert_is_ignored("Debug");
+	assert_is_ignored("and/Debug");
+	assert_is_ignored("really/Debug/this/file");
+	assert_is_ignored("Debug/what/I/say");
+
+	refute_is_ignored("and/NoDebug");
+	refute_is_ignored("NoDebug/this");
+	refute_is_ignored("please/NoDebug/this");
+
+	assert_is_ignored("this/is/deep");
 	/* pattern containing slash gets FNM_PATHNAME so all slashes must match */
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "and/this/is/deep"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/is/deep/too"));
-	cl_assert(ignored);
+	refute_is_ignored("and/this/is/deep");
+	assert_is_ignored("this/is/deep/too");
 	/* pattern containing slash gets FNM_PATHNAME so all slashes must match */
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "but/this/is/deep/and/ignored"));
-	cl_assert(!ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/is/not/deep"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "is/this/not/as/deep"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/is/deepish"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "xthis/is/deep"));
-	cl_assert(!ignored);
+	refute_is_ignored("but/this/is/deep/and/ignored");
+
+	refute_is_ignored("this/is/not/deep");
+	refute_is_ignored("is/this/not/as/deep");
+	refute_is_ignored("this/is/deepish");
+	refute_is_ignored("xthis/is/deep");
 }
 
 void test_status_ignore__automatically_ignore_bad_files(void)
 {
-	int ignored;
-
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, ".git"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/file/."));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/../funky"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/whatever.c"));
-	cl_assert(!ignored);
+	assert_is_ignored(".git");
+	assert_is_ignored("this/file/.");
+	assert_is_ignored("path/../funky");
+	refute_is_ignored("path/whatever.c");
 
 	cl_git_pass(git_ignore_add_rule(g_repo, "*.c\n"));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, ".git"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/file/."));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/../funky"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/whatever.c"));
-	cl_assert(ignored);
+	assert_is_ignored(".git");
+	assert_is_ignored("this/file/.");
+	assert_is_ignored("path/../funky");
+	assert_is_ignored("path/whatever.c");
 
 	cl_git_pass(git_ignore_clear_internal_rules(g_repo));
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, ".git"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "this/file/."));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/../funky"));
-	cl_assert(ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "path/whatever.c"));
-	cl_assert(!ignored);
+	assert_is_ignored(".git");
+	assert_is_ignored("this/file/.");
+	assert_is_ignored("path/../funky");
+	refute_is_ignored("path/whatever.c");
 }
 
 void test_status_ignore__filenames_with_special_prefixes_do_not_interfere_with_status_retrieval(void)
@@ -653,7 +592,6 @@ void test_status_ignore__filenames_with_special_prefixes_do_not_interfere_with_s
 
 void test_status_ignore__issue_1766_negated_ignores(void)
 {
-	int ignored = 0;
 	unsigned int status;
 
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
@@ -665,11 +603,8 @@ void test_status_ignore__issue_1766_negated_ignores(void)
 	cl_git_mkfile(
 		"empty_standard_repo/a/ignoreme", "I should be ignored\n");
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "a/.gitignore"));
-	cl_assert(!ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "a/ignoreme"));
-	cl_assert(ignored);
+	refute_is_ignored("a/.gitignore");
+	assert_is_ignored("a/ignoreme");
 
 	cl_git_pass(git_futils_mkdir_r(
 		"empty_standard_repo/b", NULL, 0775));
@@ -678,18 +613,12 @@ void test_status_ignore__issue_1766_negated_ignores(void)
 	cl_git_mkfile(
 		"empty_standard_repo/b/ignoreme", "I should be ignored\n");
 
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "b/.gitignore"));
-	cl_assert(!ignored);
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "b/ignoreme"));
-	cl_assert(ignored);
+	refute_is_ignored("b/.gitignore");
+	assert_is_ignored("b/ignoreme");
 
 	/* shouldn't have changed results from first couple either */
-
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "a/.gitignore"));
-	cl_assert(!ignored);
-	cl_git_pass(git_status_should_ignore(&ignored, g_repo, "a/ignoreme"));
-	cl_assert(ignored);
+	refute_is_ignored("a/.gitignore");
+	assert_is_ignored("a/ignoreme");
 
 	/* status should find the two ignore files and nothing else */
 
-- 
cgit v1.2.3


From a622ff17a1d4c70686959eefd03214898794c792 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Fri, 18 Apr 2014 20:05:28 +0200
Subject: Only zero sensitive information on destruction (and memory actually
 allocated by us)

---
 src/transports/cred.c | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/transports/cred.c b/src/transports/cred.c
index 05090ba8a..913ec36cc 100644
--- a/src/transports/cred.c
+++ b/src/transports/cred.c
@@ -30,7 +30,6 @@ static void plaintext_free(struct git_cred *cred)
 		git__free(c->password);
 	}
 
-	git__memzero(c, sizeof(*c));
 	git__free(c);
 }
 
@@ -73,8 +72,13 @@ static void ssh_key_free(struct git_cred *cred)
 		(git_cred_ssh_key *)cred;
 
 	git__free(c->username);
-	git__free(c->publickey);
-	git__free(c->privatekey);
+
+	if (c->privatekey) {
+		/* Zero the memory which previously held the private key */
+		size_t key_len = strlen(c->privatekey);
+		git__memzero(c->privatekey, key_len);
+		git__free(c->privatekey);
+	}
 
 	if (c->passphrase) {
 		/* Zero the memory which previously held the passphrase */
@@ -83,7 +87,13 @@ static void ssh_key_free(struct git_cred *cred)
 		git__free(c->passphrase);
 	}
 
-	git__memzero(c, sizeof(*c));
+	if (c->publickey) {
+		/* Zero the memory which previously held the public key */
+		size_t key_len = strlen(c->publickey);
+		git__memzero(c->publickey, key_len);
+		git__free(c->publickey);
+	}
+
 	git__free(c);
 }
 
@@ -93,7 +103,6 @@ static void ssh_interactive_free(struct git_cred *cred)
 
 	git__free(c->username);
 
-	git__memzero(c, sizeof(*c));
 	git__free(c);
 }
 
@@ -102,9 +111,14 @@ static void ssh_custom_free(struct git_cred *cred)
 	git_cred_ssh_custom *c = (git_cred_ssh_custom *)cred;
 
 	git__free(c->username);
-	git__free(c->publickey);
 
-	git__memzero(c, sizeof(*c));
+	if (c->publickey) {
+		/* Zero the memory which previously held the publickey */
+		size_t key_len = strlen(c->publickey);
+		git__memzero(c->publickey, key_len);
+		git__free(c->publickey);
+	}
+
 	git__free(c);
 }
 
-- 
cgit v1.2.3


From e3a2a04ceff1d3657629fd6a7245d9a9fc53f24b Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 18 Apr 2014 14:29:58 -0700
Subject: Preload attribute files that may contain macros

There was a latent bug where files that use macro definitions
could be parsed before the macro definitions were loaded.  Because
of attribute file caching, preloading files that are going to be
used doesn't add a significant amount of overhead, so let's always
preload any files that could contain macros before we assemble the
actual vector of files to scan for attributes.
---
 src/attr.c        |  74 +++++++++++++++++++++++++++++++++++++--
 src/attr_file.c   |   4 +--
 tests/attr/repo.c | 103 +++++++++++++++++++++++++++++++++---------------------
 3 files changed, 136 insertions(+), 45 deletions(-)

diff --git a/src/attr.c b/src/attr.c
index 622874348..6b9a3d614 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -217,6 +217,74 @@ cleanup:
 	return error;
 }
 
+static int preload_attr_file(
+	git_repository *repo,
+	git_attr_file_source source,
+	const char *base,
+	const char *file)
+{
+	int error;
+	git_attr_file *preload = NULL;
+
+	if (!file)
+		return 0;
+	if (!(error = git_attr_cache__get(
+			&preload, repo, source, base, file, git_attr_file__parse_buffer)))
+		git_attr_file__free(preload);
+
+	return error;
+}
+
+static int attr_setup(git_repository *repo)
+{
+	int error = 0;
+	const char *workdir = git_repository_workdir(repo);
+	git_index *idx = NULL;
+	git_buf sys = GIT_BUF_INIT;
+
+	if ((error = git_attr_cache__init(repo)) < 0)
+		return error;
+
+	/* preload attribute files that could contain macros so the
+	 * definitions will be available for later file parsing
+	 */
+
+	if (!(error = git_sysdir_find_system_file(&sys, GIT_ATTR_FILE_SYSTEM))) {
+		error = preload_attr_file(
+			repo, GIT_ATTR_FILE__FROM_FILE, NULL, sys.ptr);
+		git_buf_free(&sys);
+	}
+	if (error < 0) {
+		if (error == GIT_ENOTFOUND) {
+			giterr_clear();
+			error = 0;
+		} else
+			return error;
+	}
+
+	if ((error = preload_attr_file(
+			repo, GIT_ATTR_FILE__FROM_FILE,
+			NULL, git_repository_attr_cache(repo)->cfg_attr_file)) < 0)
+		return error;
+
+	if ((error = preload_attr_file(
+			repo, GIT_ATTR_FILE__FROM_FILE,
+			git_repository_path(repo), GIT_ATTR_FILE_INREPO)) < 0)
+		return error;
+
+	if (workdir != NULL &&
+		(error = preload_attr_file(
+			repo, GIT_ATTR_FILE__FROM_FILE, workdir, GIT_ATTR_FILE)) < 0)
+		return error;
+
+	if ((error = git_repository_index__weakptr(&idx, repo)) < 0 ||
+		(error = preload_attr_file(
+			repo, GIT_ATTR_FILE__FROM_INDEX, NULL, GIT_ATTR_FILE)) < 0)
+		return error;
+
+	return error;
+}
+
 int git_attr_add_macro(
 	git_repository *repo,
 	const char *name,
@@ -226,8 +294,8 @@ int git_attr_add_macro(
 	git_attr_rule *macro = NULL;
 	git_pool *pool;
 
-	if (git_attr_cache__init(repo) < 0)
-		return -1;
+	if ((error = attr_setup(repo)) < 0)
+		return error;
 
 	macro = git__calloc(1, sizeof(git_attr_rule));
 	GITERR_CHECK_ALLOC(macro);
@@ -348,7 +416,7 @@ static int collect_attr_files(
 	const char *workdir = git_repository_workdir(repo);
 	attr_walk_up_info info = { NULL };
 
-	if ((error = git_attr_cache__init(repo)) < 0)
+	if ((error = attr_setup(repo)) < 0)
 		return error;
 
 	/* Resolve path in a non-bare repo */
diff --git a/src/attr_file.c b/src/attr_file.c
index 65bbf78e8..8a8d86a2d 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -248,9 +248,7 @@ int git_attr_file__parse_buffer(
 				repo, &attrs->pool, &rule->assigns, &scan)))
 		{
 			if (rule->match.flags & GIT_ATTR_FNMATCH_MACRO)
-				/* should generate error/warning if this is coming from any
-				 * file other than .gitattributes at repo root.
-				 */
+				/* TODO: warning if macro found in file below repo root */
 				error = git_attr_cache__insert_macro(repo, rule);
 			else
 				error = git_vector_insert(&attrs->rules, rule);
diff --git a/tests/attr/repo.c b/tests/attr/repo.c
index 71dc7a5b5..9aab7ed96 100644
--- a/tests/attr/repo.c
+++ b/tests/attr/repo.c
@@ -23,49 +23,74 @@ void test_attr_repo__cleanup(void)
 	g_repo = NULL;
 }
 
+static struct attr_expected get_one_test_cases[] = {
+	{ "root_test1", "repoattr", EXPECT_TRUE, NULL },
+	{ "root_test1", "rootattr", EXPECT_TRUE, NULL },
+	{ "root_test1", "missingattr", EXPECT_UNDEFINED, NULL },
+	{ "root_test1", "subattr", EXPECT_UNDEFINED, NULL },
+	{ "root_test1", "negattr", EXPECT_UNDEFINED, NULL },
+	{ "root_test2", "repoattr", EXPECT_TRUE, NULL },
+	{ "root_test2", "rootattr", EXPECT_FALSE, NULL },
+	{ "root_test2", "missingattr", EXPECT_UNDEFINED, NULL },
+	{ "root_test2", "multiattr", EXPECT_FALSE, NULL },
+	{ "root_test3", "repoattr", EXPECT_TRUE, NULL },
+	{ "root_test3", "rootattr", EXPECT_UNDEFINED, NULL },
+	{ "root_test3", "multiattr", EXPECT_STRING, "3" },
+	{ "root_test3", "multi2", EXPECT_UNDEFINED, NULL },
+	{ "sub/subdir_test1", "repoattr", EXPECT_TRUE, NULL },
+	{ "sub/subdir_test1", "rootattr", EXPECT_TRUE, NULL },
+	{ "sub/subdir_test1", "missingattr", EXPECT_UNDEFINED, NULL },
+	{ "sub/subdir_test1", "subattr", EXPECT_STRING, "yes" },
+	{ "sub/subdir_test1", "negattr", EXPECT_FALSE, NULL },
+	{ "sub/subdir_test1", "another", EXPECT_UNDEFINED, NULL },
+	{ "sub/subdir_test2.txt", "repoattr", EXPECT_TRUE, NULL },
+	{ "sub/subdir_test2.txt", "rootattr", EXPECT_TRUE, NULL },
+	{ "sub/subdir_test2.txt", "missingattr", EXPECT_UNDEFINED, NULL },
+	{ "sub/subdir_test2.txt", "subattr", EXPECT_STRING, "yes" },
+	{ "sub/subdir_test2.txt", "negattr", EXPECT_FALSE, NULL },
+	{ "sub/subdir_test2.txt", "another", EXPECT_STRING, "zero" },
+	{ "sub/subdir_test2.txt", "reposub", EXPECT_TRUE, NULL },
+	{ "sub/sub/subdir.txt", "another", EXPECT_STRING, "one" },
+	{ "sub/sub/subdir.txt", "reposubsub", EXPECT_TRUE, NULL },
+	{ "sub/sub/subdir.txt", "reposub", EXPECT_UNDEFINED, NULL },
+	{ "does-not-exist", "foo", EXPECT_STRING, "yes" },
+	{ "sub/deep/file", "deepdeep", EXPECT_TRUE, NULL },
+	{ "sub/sub/d/no", "test", EXPECT_STRING, "a/b/d/*" },
+	{ "sub/sub/d/yes", "test", EXPECT_UNDEFINED, NULL },
+};
+
 void test_attr_repo__get_one(void)
 {
-	struct attr_expected test_cases[] = {
-		{ "root_test1", "repoattr", EXPECT_TRUE, NULL },
-		{ "root_test1", "rootattr", EXPECT_TRUE, NULL },
-		{ "root_test1", "missingattr", EXPECT_UNDEFINED, NULL },
-		{ "root_test1", "subattr", EXPECT_UNDEFINED, NULL },
-		{ "root_test1", "negattr", EXPECT_UNDEFINED, NULL },
-		{ "root_test2", "repoattr", EXPECT_TRUE, NULL },
-		{ "root_test2", "rootattr", EXPECT_FALSE, NULL },
-		{ "root_test2", "missingattr", EXPECT_UNDEFINED, NULL },
-		{ "root_test2", "multiattr", EXPECT_FALSE, NULL },
-		{ "root_test3", "repoattr", EXPECT_TRUE, NULL },
-		{ "root_test3", "rootattr", EXPECT_UNDEFINED, NULL },
-		{ "root_test3", "multiattr", EXPECT_STRING, "3" },
-		{ "root_test3", "multi2", EXPECT_UNDEFINED, NULL },
-		{ "sub/subdir_test1", "repoattr", EXPECT_TRUE, NULL },
-		{ "sub/subdir_test1", "rootattr", EXPECT_TRUE, NULL },
-		{ "sub/subdir_test1", "missingattr", EXPECT_UNDEFINED, NULL },
-		{ "sub/subdir_test1", "subattr", EXPECT_STRING, "yes" },
-		{ "sub/subdir_test1", "negattr", EXPECT_FALSE, NULL },
-		{ "sub/subdir_test1", "another", EXPECT_UNDEFINED, NULL },
-		{ "sub/subdir_test2.txt", "repoattr", EXPECT_TRUE, NULL },
-		{ "sub/subdir_test2.txt", "rootattr", EXPECT_TRUE, NULL },
-		{ "sub/subdir_test2.txt", "missingattr", EXPECT_UNDEFINED, NULL },
-		{ "sub/subdir_test2.txt", "subattr", EXPECT_STRING, "yes" },
-		{ "sub/subdir_test2.txt", "negattr", EXPECT_FALSE, NULL },
-		{ "sub/subdir_test2.txt", "another", EXPECT_STRING, "zero" },
-		{ "sub/subdir_test2.txt", "reposub", EXPECT_TRUE, NULL },
-		{ "sub/sub/subdir.txt", "another", EXPECT_STRING, "one" },
-		{ "sub/sub/subdir.txt", "reposubsub", EXPECT_TRUE, NULL },
-		{ "sub/sub/subdir.txt", "reposub", EXPECT_UNDEFINED, NULL },
-		{ "does-not-exist", "foo", EXPECT_STRING, "yes" },
-		{ "sub/deep/file", "deepdeep", EXPECT_TRUE, NULL },
-		{ "sub/sub/d/no", "test", EXPECT_STRING, "a/b/d/*" },
-		{ "sub/sub/d/yes", "test", EXPECT_UNDEFINED, NULL },
-		{ NULL, NULL, 0, NULL }
-	}, *scan;
-
-	for (scan = test_cases; scan->path != NULL; scan++) {
+	int i;
+
+	for (i = 0; i < (int)ARRAY_SIZE(get_one_test_cases); ++i) {
+		struct attr_expected *scan = &get_one_test_cases[i];
+		const char *value;
+
+		cl_git_pass(git_attr_get(&value, g_repo, 0, scan->path, scan->attr));
+		attr_check_expected(
+			scan->expected, scan->expected_str, scan->attr, value);
+	}
+
+	cl_assert(git_attr_cache__is_cached(
+		g_repo, GIT_ATTR_FILE__FROM_FILE, ".git/info/attributes"));
+	cl_assert(git_attr_cache__is_cached(
+		g_repo, GIT_ATTR_FILE__FROM_FILE, ".gitattributes"));
+	cl_assert(git_attr_cache__is_cached(
+		g_repo, GIT_ATTR_FILE__FROM_FILE, "sub/.gitattributes"));
+}
+
+void test_attr_repo__get_one_start_deep(void)
+{
+	int i;
+
+	for (i = (int)ARRAY_SIZE(get_one_test_cases) - 1; i >= 0; --i) {
+		struct attr_expected *scan = &get_one_test_cases[i];
 		const char *value;
+
 		cl_git_pass(git_attr_get(&value, g_repo, 0, scan->path, scan->attr));
-		attr_check_expected(scan->expected, scan->expected_str, scan->attr, value);
+		attr_check_expected(
+			scan->expected, scan->expected_str, scan->attr, value);
 	}
 
 	cl_assert(git_attr_cache__is_cached(
-- 
cgit v1.2.3


From 916fcbd61754f74b350ca689e27563cdbded2d30 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 18 Apr 2014 14:42:40 -0700
Subject: Fix ignore difference from git with trailing /*

Ignore patterns that ended with a trailing '/*' were still needing
to match against another actual '/' character in the full path.
This is not the same behavior as core Git.

Instead, we strip a trailing '/*' off of any patterns that were
matching and just take it to imply the FNM_LEADING_DIR behavior.
---
 src/attr_file.c       |  9 +++++++++
 src/attr_file.h       |  1 +
 tests/status/ignore.c | 18 ++++++++++++++++++
 3 files changed, 28 insertions(+)

diff --git a/src/attr_file.c b/src/attr_file.c
index 8a8d86a2d..57b4da7dd 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -353,6 +353,8 @@ bool git_attr_fnmatch__match(
 
 	if (match->flags & GIT_ATTR_FNMATCH_ICASE)
 		flags |= FNM_CASEFOLD;
+	if (match->flags & GIT_ATTR_FNMATCH_LEADINGDIR)
+		flags |= FNM_LEADING_DIR;
 
 	if (match->flags & GIT_ATTR_FNMATCH_FULLPATH) {
 		filename = path->path;
@@ -543,6 +545,13 @@ int git_attr_fnmatch__parse(
 		if (--slash_count <= 0)
 			spec->flags = spec->flags & ~GIT_ATTR_FNMATCH_FULLPATH;
 	}
+	if (spec->length >= 2 &&
+		pattern[spec->length - 1] == '*' &&
+		pattern[spec->length - 2] == '/') {
+		spec->length -= 2;
+		spec->flags = spec->flags | GIT_ATTR_FNMATCH_LEADINGDIR;
+		/* leave FULLPATH match on, however */
+	}
 
 	if ((spec->flags & GIT_ATTR_FNMATCH_FULLPATH) != 0 &&
 		context != NULL && git_path_root(pattern) < 0)
diff --git a/src/attr_file.h b/src/attr_file.h
index c906be44d..09afa5bd4 100644
--- a/src/attr_file.h
+++ b/src/attr_file.h
@@ -30,6 +30,7 @@
 #define GIT_ATTR_FNMATCH_MATCH_ALL	(1U << 8)
 #define GIT_ATTR_FNMATCH_ALLOWNEG   (1U << 9)
 #define GIT_ATTR_FNMATCH_ALLOWMACRO (1U << 10)
+#define GIT_ATTR_FNMATCH_LEADINGDIR (1U << 11)
 
 #define GIT_ATTR_FNMATCH__INCOMING \
 	(GIT_ATTR_FNMATCH_ALLOWSPACE | \
diff --git a/tests/status/ignore.c b/tests/status/ignore.c
index 15c85e262..d88b2eb6b 100644
--- a/tests/status/ignore.c
+++ b/tests/status/ignore.c
@@ -456,6 +456,24 @@ void test_status_ignore__contained_dir_with_matching_name(void)
 	cl_assert_equal_i(0, counts.wrong_sorted_path);
 }
 
+void test_status_ignore__trailing_slash_star(void)
+{
+	static const char *test_files[] = {
+		"empty_standard_repo/file",
+		"empty_standard_repo/subdir/file",
+		"empty_standard_repo/subdir/sub2/sub3/file",
+		NULL
+	};
+
+	make_test_data("empty_standard_repo", test_files);
+	cl_git_mkfile(
+		"empty_standard_repo/subdir/.gitignore", "/**/*\n");
+
+	refute_is_ignored("file");
+	assert_is_ignored("subdir/sub2/sub3/file");
+	assert_is_ignored("subdir/file");
+}
+
 void test_status_ignore__adding_internal_ignores(void)
 {
 	g_repo = cl_git_sandbox_init("empty_standard_repo");
-- 
cgit v1.2.3


From ac16bd0a94e1f7254112c7585b843bdc2d0659c1 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 18 Apr 2014 15:45:59 -0700
Subject: Minor fixes

Only apply LEADING_DIR pattern munging to patterns in ignore and
attribute files, not to pathspecs used to select files to operate
on.  Also, allow internal macro definitions to be evaluated before
loading all external ones (important so that external ones can
make use of internal `binary` definition).
---
 src/attr.c      | 2 +-
 src/attr_file.c | 3 ++-
 src/attr_file.h | 5 +++--
 src/pathspec.c  | 3 ++-
 4 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/attr.c b/src/attr.c
index 6b9a3d614..05b0c1b3c 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -294,7 +294,7 @@ int git_attr_add_macro(
 	git_attr_rule *macro = NULL;
 	git_pool *pool;
 
-	if ((error = attr_setup(repo)) < 0)
+	if ((error = git_attr_cache__init(repo)) < 0)
 		return error;
 
 	macro = git__calloc(1, sizeof(git_attr_rule));
diff --git a/src/attr_file.c b/src/attr_file.c
index 57b4da7dd..d107b5ab0 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -545,7 +545,8 @@ int git_attr_fnmatch__parse(
 		if (--slash_count <= 0)
 			spec->flags = spec->flags & ~GIT_ATTR_FNMATCH_FULLPATH;
 	}
-	if (spec->length >= 2 &&
+	if ((spec->flags & GIT_ATTR_FNMATCH_NOLEADINGDIR) == 0 &&
+		spec->length >= 2 &&
 		pattern[spec->length - 1] == '*' &&
 		pattern[spec->length - 2] == '/') {
 		spec->length -= 2;
diff --git a/src/attr_file.h b/src/attr_file.h
index 09afa5bd4..e50aec07c 100644
--- a/src/attr_file.h
+++ b/src/attr_file.h
@@ -31,10 +31,11 @@
 #define GIT_ATTR_FNMATCH_ALLOWNEG   (1U << 9)
 #define GIT_ATTR_FNMATCH_ALLOWMACRO (1U << 10)
 #define GIT_ATTR_FNMATCH_LEADINGDIR (1U << 11)
+#define GIT_ATTR_FNMATCH_NOLEADINGDIR (1U << 12)
 
 #define GIT_ATTR_FNMATCH__INCOMING \
-	(GIT_ATTR_FNMATCH_ALLOWSPACE | \
-	 GIT_ATTR_FNMATCH_ALLOWNEG | GIT_ATTR_FNMATCH_ALLOWMACRO)
+	(GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG | \
+	 GIT_ATTR_FNMATCH_ALLOWMACRO | GIT_ATTR_FNMATCH_NOLEADINGDIR)
 
 typedef enum {
 	GIT_ATTR_FILE__IN_MEMORY  = 0,
diff --git a/src/pathspec.c b/src/pathspec.c
index 09650de7c..a01d74f07 100644
--- a/src/pathspec.c
+++ b/src/pathspec.c
@@ -83,7 +83,8 @@ int git_pathspec__vinit(
 		if (!match)
 			return -1;
 
-		match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG;
+		match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE |
+			GIT_ATTR_FNMATCH_ALLOWNEG | GIT_ATTR_FNMATCH_NOLEADINGDIR;
 
 		ret = git_attr_fnmatch__parse(match, strpool, NULL, &pattern);
 		if (ret == GIT_ENOTFOUND) {
-- 
cgit v1.2.3


From 5c8d5eac35794391c935e273612744a0684beb29 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sat, 19 Apr 2014 23:07:50 +0200
Subject: Introduce AddCFlagIfSupported CMake macro

---
 CMakeLists.txt                          | 47 +++++++--------------------------
 cmake/Modules/AddCFlagIfSupported.cmake | 16 +++++++++++
 2 files changed, 25 insertions(+), 38 deletions(-)
 create mode 100644 cmake/Modules/AddCFlagIfSupported.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6305be824..704770b29 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,7 +18,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/Modules/")
 
 INCLUDE(CheckLibraryExists)
-INCLUDE(CheckCCompilerFlag)
+INCLUDE(AddCFlagIfSupported)
 
 # Build options
 #
@@ -302,49 +302,20 @@ ELSE ()
 		ADD_DEFINITIONS(-D__USE_MINGW_ANSI_STDIO=1)
 
 	ELSEIF (BUILD_SHARED_LIBS)
-		CHECK_C_COMPILER_FLAG(-fvisibility=hidden HIDDEN_VISIBILITY_FLAG)
-		IF(HIDDEN_VISIBILITY_FLAG)
-			SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
-		ENDIF()
+		ADD_C_FLAG_IF_SUPPORTED(-fvisibility=hidden)
 
 		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
 	ENDIF ()
 
-	CHECK_C_COMPILER_FLAG(-Wno-missing-field-initializers NO_MISSING_FIELD_INIT_WARNING)
-	IF(NO_MISSING_FIELD_INIT_WARNING)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-missing-field-initializers")
-	ENDIF()
-
-	CHECK_C_COMPILER_FLAG(-Wstrict-aliasing STRICT_ALIASING_WARNING)
-	IF(STRICT_ALIASING_WARNING)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-aliasing=2")
-	ENDIF()
-
-	CHECK_C_COMPILER_FLAG(-Wstrict-prototypes STRICT_PROTOTYPES_WARNING)
-	IF(STRICT_PROTOTYPES_WARNING)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-prototypes")
-	ENDIF()
-
-	CHECK_C_COMPILER_FLAG(-Wdeclaration-after-statement DECLARATION_AFTER_STATEMENT_WARNING)
-	IF(DECLARATION_AFTER_STATEMENT_WARNING)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wdeclaration-after-statement")
-	ENDIF()
-
-	CHECK_C_COMPILER_FLAG(-Wno-unused-const-variable UNUSED_CONST_VAR_WARNING)
-	IF(UNUSED_CONST_VAR_WARNING)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-const-variable")
-	ENDIF()
-
-	CHECK_C_COMPILER_FLAG(-Wno-unused-function UNUSED_FUNCTION_WARNING)
-	IF(UNUSED_FUNCTION_WARNING)
-		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-function")
-	ENDIF()
+	ADD_C_FLAG_IF_SUPPORTED(-Wno-missing-field-initializers)
+	ADD_C_FLAG_IF_SUPPORTED(-Wstrict-aliasing=2)
+	ADD_C_FLAG_IF_SUPPORTED(-Wstrict-prototypes)
+	ADD_C_FLAG_IF_SUPPORTED(-Wdeclaration-after-statement)
+	ADD_C_FLAG_IF_SUPPORTED(-Wno-unused-const-variable)
+	ADD_C_FLAG_IF_SUPPORTED(-Wno-unused-function)
 
 	IF (APPLE) # Apple deprecated OpenSSL
-		CHECK_C_COMPILER_FLAG(-Wno-deprecated-declarations DEPRECATED_DECLARATIONS_WARNING)
-		IF(DEPRECATED_DECLARATIONS_WARNING)
-			SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-deprecated-declarations")
-		ENDIF()
+		ADD_C_FLAG_IF_SUPPORTED(-Wno-deprecated-declarations)
 	ENDIF()
 
 	IF (PROFILE)
diff --git a/cmake/Modules/AddCFlagIfSupported.cmake b/cmake/Modules/AddCFlagIfSupported.cmake
new file mode 100644
index 000000000..67fc89510
--- /dev/null
+++ b/cmake/Modules/AddCFlagIfSupported.cmake
@@ -0,0 +1,16 @@
+# - Append compiler flag to CMAKE_C_FLAGS if compiler supports it
+# ADD_C_FLAG_IF_SUPPORTED(<flag>)
+#  <flag> - the compiler flag to test
+# This internally calls the CHECK_C_COMPILER_FLAG macro.
+
+INCLUDE(CheckCCompilerFlag)
+
+MACRO(ADD_C_FLAG_IF_SUPPORTED _FLAG)
+	STRING(TOUPPER ${_FLAG} UPCASE)
+	STRING(REGEX REPLACE "^-" "" UPCASE_PRETTY ${UPCASE}) 
+	CHECK_C_COMPILER_FLAG(${_FLAG} IS_${UPCASE_PRETTY}_SUPPORTED)
+
+	IF(IS_${UPCASE_PRETTY}_SUPPORTED)
+		SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${_FLAG}")
+	ENDIF()
+ENDMACRO()
-- 
cgit v1.2.3


From c2c8161541e54689926ec1f463569d5d1b975503 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Sat, 19 Apr 2014 18:05:31 -0400
Subject: Win32: UTF-8 <-> WCHAR conversion overhaul

---
 src/path.c               |  51 +++----
 src/repository.c         |  10 +-
 src/transports/winhttp.c | 125 +++++++----------
 src/unix/posix.h         |   1 -
 src/win32/dir.c          |  27 +---
 src/win32/dir.h          |   3 +-
 src/win32/error.c        |  36 +----
 src/win32/findfile.c     |  93 +++++--------
 src/win32/findfile.h     |  11 --
 src/win32/mingw-compat.h |   2 +
 src/win32/posix.h        |  11 +-
 src/win32/posix_w32.c    | 356 +++++++++++++++++++++++++++--------------------
 src/win32/utf-conv.c     | 133 +++++++++++++++++-
 src/win32/utf-conv.h     |  76 ++++++++--
 src/win32/w32_util.c     |  69 +++++++++
 src/win32/w32_util.h     |  31 +++++
 tests/clar_libgit2.c     |  53 +++----
 tests/core/env.c         |   2 +-
 18 files changed, 659 insertions(+), 431 deletions(-)
 create mode 100644 src/win32/w32_util.c
 create mode 100644 src/win32/w32_util.h

diff --git a/src/path.c b/src/path.c
index a990b005f..b2845466b 100644
--- a/src/path.c
+++ b/src/path.c
@@ -9,6 +9,7 @@
 #include "posix.h"
 #ifdef GIT_WIN32
 #include "win32/posix.h"
+#include "win32/w32_util.h"
 #else
 #include <dirent.h>
 #endif
@@ -486,33 +487,33 @@ bool git_path_isfile(const char *path)
 
 bool git_path_is_empty_dir(const char *path)
 {
-	HANDLE hFind = INVALID_HANDLE_VALUE;
-	git_win32_path wbuf;
-	int wbufsz;
-	WIN32_FIND_DATAW ffd;
-	bool retval = true;
-
-	if (!git_path_isdir(path))
-		return false;
-
-	wbufsz = git_win32_path_from_c(wbuf, path);
-	if (!wbufsz || wbufsz + 2 > GIT_WIN_PATH_UTF16)
-		return false;
-	memcpy(&wbuf[wbufsz - 1], L"\\*", 3 * sizeof(wchar_t));
-
-	hFind = FindFirstFileW(wbuf, &ffd);
-	if (INVALID_HANDLE_VALUE == hFind)
-		return false;
-
-	do {
-		if (!git_path_is_dot_or_dotdotW(ffd.cFileName)) {
-			retval = false;
-			break;
+	git_win32_path filter_w;
+	bool empty = false;
+
+	if (git_win32__findfirstfile_filter(filter_w, path)) {
+		WIN32_FIND_DATAW findData;
+		HANDLE hFind = FindFirstFileW(filter_w, &findData);
+
+		/* If the find handle was created successfully, then it's a directory */
+		if (INVALID_HANDLE_VALUE != hFind) {
+			empty = true;
+
+			do {
+				/* Allow the enumeration to return . and .. and still be considered
+				 * empty. In the special case of drive roots (i.e. C:\) where . and
+				 * .. do not occur, we can still consider the path to be an empty
+				 * directory if there's nothing there. */
+				if (!git_path_is_dot_or_dotdotW(findData.cFileName)) {
+					empty = false;
+					break;
+				}
+			} while (FindNextFileW(hFind, &findData));
+
+			FindClose(hFind);
 		}
-	} while (FindNextFileW(hFind, &ffd) != 0);
+	}
 
-	FindClose(hFind);
-	return retval;
+	return empty;
 }
 
 #else
diff --git a/src/repository.c b/src/repository.c
index 6b2705bfa..8daa04d5d 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -27,6 +27,10 @@
 #include "merge.h"
 #include "diff_driver.h"
 
+#ifdef GIT_WIN32
+# include "win32/w32_util.h"
+#endif
+
 #define GIT_FILE_CONTENT_PREFIX "gitdir:"
 
 #define GIT_BRANCH_MASTER "master"
@@ -1149,7 +1153,7 @@ static int repo_write_template(
 
 #ifdef GIT_WIN32
 	if (!error && hidden) {
-		if (p_hide_directory__w32(path.ptr) < 0)
+		if (git_win32__sethidden(path.ptr) < 0)
 			error = -1;
 	}
 #else
@@ -1234,8 +1238,8 @@ static int repo_init_structure(
 	/* Hide the ".git" directory */
 #ifdef GIT_WIN32
 	if ((opts->flags & GIT_REPOSITORY_INIT__HAS_DOTGIT) != 0) {
-		if (p_hide_directory__w32(repo_dir) < 0) {
-			giterr_set(GITERR_REPOSITORY,
+		if (git_win32__sethidden(repo_dir) < 0) {
+			giterr_set(GITERR_OS,
 				"Failed to mark Git repository folder as hidden");
 			return -1;
 		}
diff --git a/src/transports/winhttp.c b/src/transports/winhttp.c
index 7ad2a1636..bd9509cd4 100644
--- a/src/transports/winhttp.c
+++ b/src/transports/winhttp.c
@@ -91,7 +91,7 @@ static int apply_basic_credential(HINTERNET request, git_cred *cred)
 	git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
 	git_buf buf = GIT_BUF_INIT, raw = GIT_BUF_INIT;
 	wchar_t *wide = NULL;
-	int error = -1, wide_len = 0;
+	int error = -1, wide_len;
 
 	git_buf_printf(&raw, "%s:%s", c->username, c->password);
 
@@ -100,21 +100,7 @@ static int apply_basic_credential(HINTERNET request, git_cred *cred)
 		git_buf_put_base64(&buf, git_buf_cstr(&raw), raw.size) < 0)
 		goto on_error;
 
-	wide_len = MultiByteToWideChar(CP_UTF8,	MB_ERR_INVALID_CHARS,
-		git_buf_cstr(&buf),	-1, NULL, 0);
-
-	if (!wide_len) {
-		giterr_set(GITERR_OS, "Failed to measure string for wide conversion");
-		goto on_error;
-	}
-
-	wide = git__malloc(wide_len * sizeof(wchar_t));
-
-	if (!wide)
-		goto on_error;
-
-	if (!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
-		git_buf_cstr(&buf), -1, wide, wide_len)) {
+	if ((wide_len = git__utf8_to_16_alloc(&wide, git_buf_cstr(&buf))) < 0) {
 		giterr_set(GITERR_OS, "Failed to convert string to wide form");
 		goto on_error;
 	}
@@ -171,23 +157,11 @@ static int fallback_cred_acquire_cb(
 	/* If the target URI supports integrated Windows authentication
 	 * as an authentication mechanism */
 	if (GIT_CREDTYPE_DEFAULT & allowed_types) {
-		LPWSTR wide_url;
-		DWORD wide_len;
+		wchar_t *wide_url;
 
 		/* Convert URL to wide characters */
-		wide_len = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, url, -1, NULL, 0);
-
-		if (!wide_len) {
-			giterr_set(GITERR_OS, "Failed to measure string for wide conversion");
-			return -1;
-		}
-
-		wide_url = git__malloc(wide_len * sizeof(WCHAR));
-		GITERR_CHECK_ALLOC(wide_url);
-
-		if (!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, url, -1, wide_url, wide_len)) {
+		if (git__utf8_to_16_alloc(&wide_url, url) < 0) {
 			giterr_set(GITERR_OS, "Failed to convert string to wide form");
-			git__free(wide_url);
 			return -1;
 		}
 
@@ -232,7 +206,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
 	wchar_t ct[MAX_CONTENT_TYPE_LEN];
 	wchar_t *types[] = { L"*/*", NULL };
 	BOOL peerdist = FALSE;
-	int error = -1, wide_len;
+	int error = -1;
 	unsigned long disable_redirects = WINHTTP_DISABLE_REDIRECTS;
 
 	/* Prepare URL */
@@ -242,21 +216,7 @@ static int winhttp_stream_connect(winhttp_stream *s)
 		return -1;
 
 	/* Convert URL to wide characters */
-	wide_len = MultiByteToWideChar(CP_UTF8,	MB_ERR_INVALID_CHARS,
-		git_buf_cstr(&buf),	-1, NULL, 0);
-
-	if (!wide_len) {
-		giterr_set(GITERR_OS, "Failed to measure string for wide conversion");
-		goto on_error;
-	}
-
-	s->request_uri = git__malloc(wide_len * sizeof(wchar_t));
-
-	if (!s->request_uri)
-		goto on_error;
-
-	if (!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
-		git_buf_cstr(&buf), -1, s->request_uri, wide_len)) {
+	if (git__utf8_to_16_alloc(&s->request_uri, git_buf_cstr(&buf)) < 0) {
 		giterr_set(GITERR_OS, "Failed to convert string to wide form");
 		goto on_error;
 	}
@@ -285,30 +245,17 @@ static int winhttp_stream_connect(winhttp_stream *s)
 		wchar_t *proxy_wide;
 
 		/* Convert URL to wide characters */
-		wide_len = MultiByteToWideChar(CP_UTF8,	MB_ERR_INVALID_CHARS,
-			proxy_url, -1, NULL, 0);
-
-		if (!wide_len) {
-			giterr_set(GITERR_OS, "Failed to measure string for wide conversion");
-			goto on_error;
-		}
-
-		proxy_wide = git__malloc(wide_len * sizeof(wchar_t));
-
-		if (!proxy_wide)
-			goto on_error;
+		int proxy_wide_len = git__utf8_to_16_alloc(&proxy_wide, proxy_url);
 
-		if (!MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS,
-			proxy_url, -1, proxy_wide, wide_len)) {
+		if (proxy_wide_len < 0) {
 			giterr_set(GITERR_OS, "Failed to convert string to wide form");
-			git__free(proxy_wide);
 			goto on_error;
 		}
 
 		/* Strip any trailing forward slash on the proxy URL;
 		 * WinHTTP doesn't like it if one is present */
-		if (wide_len > 1 && L'/' == proxy_wide[wide_len - 2])
-			proxy_wide[wide_len - 2] = L'\0';
+		if (proxy_wide_len > 1 && L'/' == proxy_wide[proxy_wide_len - 2])
+			proxy_wide[proxy_wide_len - 2] = L'\0';
 
 		proxy_info.dwAccessType = WINHTTP_ACCESS_TYPE_NAMED_PROXY;
 		proxy_info.lpszProxy = proxy_wide;
@@ -359,7 +306,10 @@ static int winhttp_stream_connect(winhttp_stream *s)
 			s->service) < 0)
 			goto on_error;
 
-		git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_buf_cstr(&buf));
+		if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_buf_cstr(&buf)) < 0) {
+			giterr_set(GITERR_OS, "Failed to convert content-type to wide characters");
+			goto on_error;
+		}
 
 		if (!WinHttpAddRequestHeaders(s->request, ct, (ULONG)-1L,
 			WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE)) {
@@ -373,7 +323,10 @@ static int winhttp_stream_connect(winhttp_stream *s)
 			s->service) < 0)
 			goto on_error;
 
-		git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_buf_cstr(&buf));
+		if (git__utf8_to_16(ct, MAX_CONTENT_TYPE_LEN, git_buf_cstr(&buf)) < 0) {
+			giterr_set(GITERR_OS, "Failed to convert accept header to wide characters");
+			goto on_error;
+		}
 
 		if (!WinHttpAddRequestHeaders(s->request, ct, (ULONG)-1L,
 			WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE)) {
@@ -506,16 +459,20 @@ static int winhttp_connect(
 	const char *url)
 {
 	wchar_t *ua = L"git/1.0 (libgit2 " WIDEN(LIBGIT2_VERSION) L")";
-	git_win32_path host;
+	wchar_t *wide_host;
 	int32_t port;
 	const char *default_port = "80";
+	int error = -1;
 
 	/* Prepare port */
 	if (git__strtol32(&port, t->connection_data.port, NULL, 10) < 0)
 		return -1;
 
 	/* Prepare host */
-	git_win32_path_from_c(host, t->connection_data.host);
+	if (git__utf8_to_16_alloc(&wide_host, t->connection_data.host) < 0) {
+		giterr_set(GITERR_OS, "Unable to convert host to wide characters");
+		return -1;
+	}
 
 	/* Establish session */
 	t->session = WinHttpOpen(
@@ -527,22 +484,27 @@ static int winhttp_connect(
 
 	if (!t->session) {
 		giterr_set(GITERR_OS, "Failed to init WinHTTP");
-		return -1;
+		goto on_error;
 	}
 
 	/* Establish connection */
 	t->connection = WinHttpConnect(
 		t->session,
-		host,
+		wide_host,
 		(INTERNET_PORT) port,
 		0);
 
 	if (!t->connection) {
 		giterr_set(GITERR_OS, "Failed to connect to host");
-		return -1;
+		goto on_error;
 	}
 
-	return 0;
+	error = 0;
+
+on_error:
+	git__free(wide_host);
+
+	return error;
 }
 
 static int winhttp_stream_read(
@@ -693,7 +655,6 @@ replay:
 			}
 
 			location = git__malloc(location_length);
-			location8 = git__malloc(location_length);
 			GITERR_CHECK_ALLOC(location);
 
 			if (!WinHttpQueryHeaders(s->request,
@@ -706,7 +667,14 @@ replay:
 				git__free(location);
 				return -1;
 			}
-			git__utf16_to_8(location8, location_length, location);
+
+			/* Convert the Location header to UTF-8 */
+			if (git__utf16_to_8_alloc(&location8, location) < 0) {
+				giterr_set(GITERR_OS, "Failed to convert Location header to UTF-8");
+				git__free(location);
+				return -1;
+			}
+
 			git__free(location);
 
 			/* Replay the request */
@@ -716,8 +684,11 @@ replay:
 
 			if (!git__prefixcmp_icase(location8, prefix_https)) {
 				/* Upgrade to secure connection; disconnect and start over */
-				if (gitno_connection_data_from_url(&t->connection_data, location8, s->service_url) < 0)
+				if (gitno_connection_data_from_url(&t->connection_data, location8, s->service_url) < 0) {
+					git__free(location8);
 					return -1;
+				}
+
 				winhttp_connect(t, location8);
 			}
 
@@ -778,7 +749,11 @@ replay:
 		else
 			snprintf(expected_content_type_8, MAX_CONTENT_TYPE_LEN, "application/x-git-%s-advertisement", s->service);
 
-		git__utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8);
+		if (git__utf8_to_16(expected_content_type, MAX_CONTENT_TYPE_LEN, expected_content_type_8) < 0) {
+			giterr_set(GITERR_OS, "Failed to convert expected content-type to wide characters");
+			return -1;
+		}
+
 		content_type_length = sizeof(content_type);
 
 		if (!WinHttpQueryHeaders(s->request,
diff --git a/src/unix/posix.h b/src/unix/posix.h
index 9c9f837b9..1e41bcf18 100644
--- a/src/unix/posix.h
+++ b/src/unix/posix.h
@@ -28,7 +28,6 @@ char *p_realpath(const char *, char *);
 #define p_vsnprintf(b, c, f, a) vsnprintf(b, c, f, a)
 #define p_snprintf(b, c, f, ...) snprintf(b, c, f, __VA_ARGS__)
 #define p_mkstemp(p) mkstemp(p)
-#define p_setenv(n,v,o) setenv(n,v,o)
 #define p_inet_pton(a, b, c) inet_pton(a, b, c)
 
 /* see win32/posix.h for explanation about why this exists */
diff --git a/src/win32/dir.c b/src/win32/dir.c
index f7859b73f..c7427ea54 100644
--- a/src/win32/dir.c
+++ b/src/win32/dir.c
@@ -7,29 +7,13 @@
 #define GIT__WIN32_NO_WRAP_DIR
 #include "posix.h"
 
-static int init_filter(char *filter, size_t n, const char *dir)
-{
-	size_t len = strlen(dir);
-
-	if (len+3 >= n)
-		return 0;
-
-	strcpy(filter, dir);
-	if (len && dir[len-1] != '/')
-		strcat(filter, "/");
-	strcat(filter, "*");
-
-	return 1;
-}
-
 git__DIR *git__opendir(const char *dir)
 {
-	git_win32_path_as_utf8 filter;
 	git_win32_path filter_w;
 	git__DIR *new = NULL;
 	size_t dirlen;
 
-	if (!dir || !init_filter(filter, sizeof(filter), dir))
+	if (!dir || !git_win32__findfirstfile_filter(filter_w, dir))
 		return NULL;
 
 	dirlen = strlen(dir);
@@ -39,7 +23,6 @@ git__DIR *git__opendir(const char *dir)
 		return NULL;
 	memcpy(new->dir, dir, dirlen);
 
-	git_win32_path_from_c(filter_w, filter);
 	new->h = FindFirstFileW(filter_w, &new->f);
 
 	if (new->h == INVALID_HANDLE_VALUE) {
@@ -72,10 +55,10 @@ int git__readdir_ext(
 		return -1;
 	}
 
-	if (wcslen(d->f.cFileName) >= sizeof(entry->d_name))
+	/* Convert the path to UTF-8 */
+	if (git_win32_path_to_utf8(entry->d_name, d->f.cFileName) < 0)
 		return -1;
 
-	git_win32_path_to_c(entry->d_name, d->f.cFileName);
 	entry->d_ino = 0;
 
 	*result = entry;
@@ -96,7 +79,6 @@ struct git__dirent *git__readdir(git__DIR *d)
 
 void git__rewinddir(git__DIR *d)
 {
-	git_win32_path_as_utf8 filter;
 	git_win32_path filter_w;
 
 	if (!d)
@@ -108,10 +90,9 @@ void git__rewinddir(git__DIR *d)
 		d->first = 0;
 	}
 
-	if (!init_filter(filter, sizeof(filter), d->dir))
+	if (!git_win32__findfirstfile_filter(filter_w, d->dir))
 		return;
 
-	git_win32_path_from_c(filter_w, filter);
 	d->h = FindFirstFileW(filter_w, &d->f);
 
 	if (d->h == INVALID_HANDLE_VALUE)
diff --git a/src/win32/dir.h b/src/win32/dir.h
index 24d48f6ba..bef39d774 100644
--- a/src/win32/dir.h
+++ b/src/win32/dir.h
@@ -8,10 +8,11 @@
 #define INCLUDE_dir_h__
 
 #include "common.h"
+#include "w32_util.h"
 
 struct git__dirent {
 	int d_ino;
-	git_win32_path_as_utf8 d_name;
+	git_win32_utf8_path d_name;
 };
 
 typedef struct {
diff --git a/src/win32/error.c b/src/win32/error.c
index bc598ae32..6b450093f 100644
--- a/src/win32/error.c
+++ b/src/win32/error.c
@@ -7,21 +7,17 @@
 
 #include "common.h"
 #include "error.h"
+#include "utf-conv.h"
 
 #ifdef GIT_WINHTTP
 # include <winhttp.h>
 #endif
 
-#ifndef WC_ERR_INVALID_CHARS
-#define WC_ERR_INVALID_CHARS	0x80
-#endif
-
 char *git_win32_get_error_message(DWORD error_code)
 {
 	LPWSTR lpMsgBuf = NULL;
 	HMODULE hModule = NULL;
 	char *utf8_msg = NULL;
-	int utf8_size;
 	DWORD dwFlags =
 		FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS;
 
@@ -45,33 +41,11 @@ char *git_win32_get_error_message(DWORD error_code)
 	if (FormatMessageW(dwFlags, hModule, error_code,
 		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 		(LPWSTR)&lpMsgBuf, 0, NULL)) {
+		/* Convert the message to UTF-8. If this fails, we will
+		 * return NULL, which is a condition expected by the caller */
+		if (git__utf16_to_8_alloc(&utf8_msg, lpMsgBuf) < 0)
+			utf8_msg = NULL;
 
-		/* Invalid code point check supported on Vista+ only */
-		if (git_has_win32_version(6, 0, 0))
-			dwFlags = WC_ERR_INVALID_CHARS;
-		else
-			dwFlags = 0;
-
-		utf8_size = WideCharToMultiByte(CP_UTF8, dwFlags,
-			lpMsgBuf, -1, NULL, 0, NULL, NULL);
-
-		if (!utf8_size) {
-			assert(0);
-			goto on_error;
-		}
-
-		utf8_msg = git__malloc(utf8_size);
-
-		if (!utf8_msg)
-			goto on_error;
-
-		if (!WideCharToMultiByte(CP_UTF8, dwFlags,
-			lpMsgBuf, -1, utf8_msg, utf8_size, NULL, NULL)) {
-			git__free(utf8_msg);
-			goto on_error;
-		}
-
-on_error:
 		LocalFree(lpMsgBuf);
 	}
 
diff --git a/src/win32/findfile.c b/src/win32/findfile.c
index a9e812e28..bd06d9232 100644
--- a/src/win32/findfile.c
+++ b/src/win32/findfile.c
@@ -17,54 +17,34 @@
 #define REG_MSYSGIT_INSTALL L"SOFTWARE\\Wow6432Node\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Git_is1"
 #endif
 
-int git_win32__expand_path(struct git_win32__path *s_root, const wchar_t *templ)
-{
-	s_root->len = ExpandEnvironmentStringsW(templ, s_root->path, MAX_PATH);
-	return s_root->len ? 0 : -1;
-}
+typedef struct {
+	git_win32_path path;
+	DWORD len;
+} _findfile_path;
 
-static int win32_path_to_8(git_buf *path_utf8, const wchar_t *path)
+static int git_win32__expand_path(_findfile_path *dest, const wchar_t *src)
 {
-	char temp_utf8[GIT_PATH_MAX];
+	dest->len = ExpandEnvironmentStringsW(src, dest->path, ARRAY_SIZE(dest->path));
 
-	git__utf16_to_8(temp_utf8, GIT_PATH_MAX, path);
-	git_path_mkposix(temp_utf8);
+	if (!dest->len || dest->len > ARRAY_SIZE(dest->path))
+		return -1;
 
-	return git_buf_sets(path_utf8, temp_utf8);
+	return 0;
 }
 
-int git_win32__find_file(
-	git_buf *path, const struct git_win32__path *root, const char *filename)
+static int win32_path_to_8(git_buf *dest, const wchar_t *src)
 {
-	size_t len, alloc_len;
-	wchar_t *file_utf16 = NULL;
-
-	if (!root || !filename || (len = strlen(filename)) == 0)
-		return GIT_ENOTFOUND;
-
-	/* allocate space for wchar_t path to file */
-	alloc_len = root->len + len + 2;
-	file_utf16 = git__calloc(alloc_len, sizeof(wchar_t));
-	GITERR_CHECK_ALLOC(file_utf16);
+	git_win32_utf8_path utf8_path;
 
-	/* append root + '\\' + filename as wchar_t */
-	memcpy(file_utf16, root->path, root->len * sizeof(wchar_t));
-
-	if (*filename == '/' || *filename == '\\')
-		filename++;
-
-	git__utf8_to_16(file_utf16 + root->len - 1, alloc_len - root->len, filename);
-
-	/* check access */
-	if (_waccess(file_utf16, F_OK) < 0) {
-		git__free(file_utf16);
-		return GIT_ENOTFOUND;
+	if (git_win32_path_to_utf8(utf8_path, src) < 0) {
+		giterr_set(GITERR_OS, "Unable to convert path to UTF-8");
+		return -1;
 	}
 
-	win32_path_to_8(path, file_utf16);
-	git__free(file_utf16);
+	/* Convert backslashes to forward slashes */
+	git_path_mkposix(utf8_path);
 
-	return 0;
+	return git_buf_sets(dest, utf8_path);
 }
 
 static wchar_t* win32_walkpath(wchar_t *path, wchar_t *buf, size_t buflen)
@@ -89,7 +69,7 @@ static wchar_t* win32_walkpath(wchar_t *path, wchar_t *buf, size_t buflen)
 static int win32_find_git_in_path(git_buf *buf, const wchar_t *gitexe, const wchar_t *subdir)
 {
 	wchar_t *env = _wgetenv(L"PATH"), lastch;
-	struct git_win32__path root;
+	_findfile_path root;
 	size_t gitexe_len = wcslen(gitexe);
 
 	if (!env)
@@ -122,43 +102,44 @@ static int win32_find_git_in_path(git_buf *buf, const wchar_t *gitexe, const wch
 }
 
 static int win32_find_git_in_registry(
-	git_buf *buf, const HKEY hieve, const wchar_t *key, const wchar_t *subdir)
+	git_buf *buf, const HKEY hive, const wchar_t *key, const wchar_t *subdir)
 {
 	HKEY hKey;
-	DWORD dwType = REG_SZ;
-	struct git_win32__path path16;
+	int error = GIT_ENOTFOUND;
 
 	assert(buf);
 
-	path16.len = MAX_PATH;
+	if (!RegOpenKeyExW(hive, key, 0, KEY_READ, &hKey)) {
+		DWORD dwType, cbData;
+		git_win32_path path;
 
-	if (RegOpenKeyExW(hieve, key, 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
-		if (RegQueryValueExW(hKey, L"InstallLocation", NULL, &dwType,
-			(LPBYTE)&path16.path, &path16.len) == ERROR_SUCCESS)
-		{
-			/* InstallLocation points to the root of the git directory */
+		/* Ensure that the buffer is big enough to have the suffix attached
+		 * after we receive the result. */
+		cbData = (DWORD)(sizeof(path) - wcslen(subdir) * sizeof(wchar_t));
 
-			if (path16.len + 4 > MAX_PATH) { /* 4 = wcslen(L"etc\\") */
-				giterr_set(GITERR_OS, "Cannot locate git - path too long");
-				return -1;
-			}
+		/* InstallLocation points to the root of the git directory */
+		if (!RegQueryValueExW(hKey, L"InstallLocation", NULL, &dwType, (LPBYTE)path, &cbData) &&
+			REG_SZ == dwType) {
 
-			wcscat(path16.path, subdir);
-			path16.len += 4;
+			/* Append the suffix */
+			wcscat(path, subdir);
 
-			win32_path_to_8(buf, path16.path);
+			/* Convert to UTF-8, with forward slashes, and output the path
+			 * to the provided buffer */
+			if (!win32_path_to_8(buf, path))
+				error = 0;
 		}
 
 		RegCloseKey(hKey);
 	}
 
-	return path16.len ? 0 : GIT_ENOTFOUND;
+	return error;
 }
 
 static int win32_find_existing_dirs(
 	git_buf *out, const wchar_t *tmpl[])
 {
-	struct git_win32__path path16;
+	_findfile_path path16;
 	git_buf buf = GIT_BUF_INIT;
 
 	git_buf_clear(out);
diff --git a/src/win32/findfile.h b/src/win32/findfile.h
index 11bf7e620..a50319b9a 100644
--- a/src/win32/findfile.h
+++ b/src/win32/findfile.h
@@ -8,17 +8,6 @@
 #ifndef INCLUDE_git_findfile_h__
 #define INCLUDE_git_findfile_h__
 
-struct git_win32__path {
-	wchar_t path[MAX_PATH];
-	DWORD len;
-};
-
-extern int git_win32__expand_path(
-	struct git_win32__path *s_root, const wchar_t *templ);
-
-extern int git_win32__find_file(
-	git_buf *path, const struct git_win32__path *root, const char *filename);
-
 extern int git_win32__find_system_dirs(git_buf *out, const wchar_t *subpath);
 extern int git_win32__find_global_dirs(git_buf *out);
 extern int git_win32__find_xdg_dirs(git_buf *out);
diff --git a/src/win32/mingw-compat.h b/src/win32/mingw-compat.h
index 7b97b48db..8f51d6f5a 100644
--- a/src/win32/mingw-compat.h
+++ b/src/win32/mingw-compat.h
@@ -11,7 +11,9 @@
 
 /* use a 64-bit file offset type */
 # define lseek _lseeki64
+# undef stat
 # define stat _stati64
+# undef fstat
 # define fstat _fstati64
 
 /* stat: file mode type testing macros */
diff --git a/src/win32/posix.h b/src/win32/posix.h
index 24cba23e0..e5a32b510 100644
--- a/src/win32/posix.h
+++ b/src/win32/posix.h
@@ -27,24 +27,15 @@ GIT_INLINE(int) p_link(const char *old, const char *new)
 	return -1;
 }
 
-GIT_INLINE(int) p_mkdir(const char *path, mode_t mode)
-{
-	git_win32_path buf;
-	GIT_UNUSED(mode);
-	git_win32_path_from_c(buf, path);
-	return _wmkdir(buf);
-}
-
+extern int p_mkdir(const char *path, mode_t mode);
 extern int p_unlink(const char *path);
 extern int p_lstat(const char *file_name, struct stat *buf);
 extern int p_readlink(const char *link, char *target, size_t target_len);
 extern int p_symlink(const char *old, const char *new);
-extern int p_hide_directory__w32(const char *path);
 extern char *p_realpath(const char *orig_path, char *buffer);
 extern int p_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr);
 extern int p_snprintf(char *buffer, size_t count, const char *format, ...) GIT_FORMAT_PRINTF(3, 4);
 extern int p_mkstemp(char *tmp_path);
-extern int p_setenv(const char* name, const char* value, int overwrite);
 extern int p_stat(const char* path, struct stat* buf);
 extern int p_chdir(const char* path);
 extern int p_chmod(const char* path, mode_t mode);
diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c
index 6f2931880..868be6017 100644
--- a/src/win32/posix_w32.c
+++ b/src/win32/posix_w32.c
@@ -14,12 +14,59 @@
 #include <fcntl.h>
 #include <ws2tcpip.h>
 
+#if defined(__MINGW32__)
+# define FILE_NAME_NORMALIZED 0
+#endif
+
+/* GetFinalPathNameByHandleW signature */
+typedef DWORD(WINAPI *PFGetFinalPathNameByHandleW)(HANDLE, LPWSTR, DWORD, DWORD);
+
+/* Helper function which converts UTF-8 paths to UTF-16.
+ * On failure, errno is set. */
+static int utf8_to_16_with_errno(git_win32_path dest, const char *src)
+{
+	int len = git_win32_path_from_utf8(dest, src);
+
+	if (len < 0) {
+		if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+			errno = ENAMETOOLONG;
+		else
+			errno = EINVAL; /* Bad code point, presumably */
+	}
+
+	return len;
+}
+
+int p_mkdir(const char *path, mode_t mode)
+{
+	git_win32_path buf;
+
+	GIT_UNUSED(mode);
+
+	if (utf8_to_16_with_errno(buf, path) < 0)
+		return -1;
+
+	return _wmkdir(buf);
+}
+
 int p_unlink(const char *path)
 {
 	git_win32_path buf;
-	git_win32_path_from_c(buf, path);
-	_wchmod(buf, 0666);
-	return _wunlink(buf);
+	int error;
+
+	if (utf8_to_16_with_errno(buf, path) < 0)
+		return -1;
+
+	error = _wunlink(buf);
+
+	/* If the file could not be deleted because it was
+	 * read-only, clear the bit and try again */
+	if (-1 == error && EACCES == errno) {
+		_wchmod(buf, 0666);
+		error = _wunlink(buf);
+	}
+
+	return error;
 }
 
 int p_fsync(int fd)
@@ -63,7 +110,8 @@ static int do_lstat(
 	wchar_t lastch;
 	int flen;
 
-	flen = git_win32_path_from_c(fbuf, file_name);
+	if ((flen = utf8_to_16_with_errno(fbuf, file_name)) < 0)
+		return -1;
 
 	/* truncate trailing slashes */
 	for (; flen > 0; --flen) {
@@ -109,12 +157,9 @@ static int do_lstat(
 		 * the length of the path pointed to, which we expect everywhere else
 		 */
 		if (S_ISLNK(fMode)) {
-			git_win32_path_as_utf8 target;
-			int readlink_result;
+			git_win32_utf8_path target;
 
-			readlink_result = p_readlink(file_name, target, sizeof(target));
-
-			if (readlink_result == -1)
+			if (p_readlink(file_name, target, GIT_WIN_PATH_UTF8) == -1)
 				return -1;
 
 			buf->st_size = strlen(target);
@@ -160,6 +205,28 @@ int p_lstat_posixly(const char *filename, struct stat *buf)
 	return do_lstat(filename, buf, 1);
 }
 
+/*
+ * Returns the address of the GetFinalPathNameByHandleW function.
+ * This function is available on Windows Vista and higher.
+ */
+static PFGetFinalPathNameByHandleW get_fpnbyhandle(void)
+{
+	static PFGetFinalPathNameByHandleW pFunc = NULL;
+	PFGetFinalPathNameByHandleW toReturn = pFunc;
+
+	if (!toReturn) {
+		HMODULE hModule = GetModuleHandleW(L"kernel32");
+
+		if (hModule)
+			toReturn = (PFGetFinalPathNameByHandleW)GetProcAddress(hModule, "GetFinalPathNameByHandleW");
+
+		pFunc = toReturn;
+	}
+
+	assert(toReturn);
+
+	return toReturn;
+}
 
 /*
  * Parts of the The p_readlink function are heavily inspired by the php 
@@ -171,87 +238,62 @@ int p_lstat_posixly(const char *filename, struct stat *buf)
  */
 int p_readlink(const char *link, char *target, size_t target_len)
 {
-	typedef DWORD (WINAPI *fpath_func)(HANDLE, LPWSTR, DWORD, DWORD);
-	static fpath_func pGetFinalPath = NULL;
-	HANDLE hFile;
-	DWORD dwRet;
+	static const wchar_t prefix[] = L"\\\\?\\";
+	PFGetFinalPathNameByHandleW pgfp = get_fpnbyhandle();
+	HANDLE hFile = NULL;
+	wchar_t *target_w = NULL;
+	bool trim_prefix;
 	git_win32_path link_w;
-	wchar_t* target_w;
-	int error = 0;
+	DWORD dwChars, dwLastError;
+	int error = -1;
 
-	assert(link && target && target_len > 0);
+	/* Check that we found the function, and convert to UTF-16 */
+	if (!pgfp || utf8_to_16_with_errno(link_w, link) < 0)
+		goto on_error;
 
-	/*
-	 * Try to load the pointer to pGetFinalPath dynamically, because
-	 * it is not available in platforms older than Vista
-	 */
-	if (pGetFinalPath == NULL) {
-		HMODULE module = GetModuleHandle("kernel32");
+	/* Use FILE_FLAG_BACKUP_SEMANTICS so we can open a directory. Do not
+	 * specify FILE_FLAG_OPEN_REPARSE_POINT; we want to open a handle to the
+	 * target of the link. */
+	hFile = CreateFileW(link_w, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE,
+		NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 
-		if (module != NULL)
-			pGetFinalPath = (fpath_func)GetProcAddress(module, "GetFinalPathNameByHandleW");
+	if (hFile == INVALID_HANDLE_VALUE)
+		goto on_error;
 
-		if (pGetFinalPath == NULL) {
-			giterr_set(GITERR_OS,
-				"'GetFinalPathNameByHandleW' is not available in this platform");
-			return -1;
-		}
-	}
+	/* Find out how large the buffer should be to hold the result */
+	if (!(dwChars = pgfp(hFile, NULL, 0, FILE_NAME_NORMALIZED)))
+		goto on_error;
 
-	git_win32_path_from_c(link_w, link);
+	if (!(target_w = git__malloc(dwChars * sizeof(wchar_t))))
+		goto on_error;
 
-	hFile = CreateFileW(link_w,			// file to open
-			GENERIC_READ,			// open for reading
-			FILE_SHARE_READ,		// share for reading
-			NULL,					// default security
-			OPEN_EXISTING,			// existing file only
-			FILE_FLAG_BACKUP_SEMANTICS, // normal file
-			NULL);					// no attr. template
+	/* Call a second time */
+	dwChars = pgfp(hFile, target_w, dwChars, FILE_NAME_NORMALIZED);
 
-	if (hFile == INVALID_HANDLE_VALUE) {
-		giterr_set(GITERR_OS, "Cannot open '%s' for reading", link);
-		return -1;
-	}
+	if (!dwChars)
+		goto on_error;
 
-	target_w = (wchar_t*)git__malloc(target_len * sizeof(wchar_t));
-	GITERR_CHECK_ALLOC(target_w);
-
-	dwRet = pGetFinalPath(hFile, target_w, (DWORD)target_len, 0x0);
-	if (dwRet == 0 ||
-		dwRet >= target_len ||
-		!WideCharToMultiByte(CP_UTF8, 0, target_w, -1, target,
-			(int)(target_len * sizeof(char)), NULL, NULL))
-		error = -1;
-
-	git__free(target_w);
-	CloseHandle(hFile);
-
-	if (error)
-		return error;
-
-	/* Skip first 4 characters if they are "\\?\" */
-	if (dwRet > 4 &&
-		target[0] == '\\' && target[1] == '\\' &&
-		target[2] == '?' && target[3] == '\\')
-	{
-		unsigned int offset = 4;
-		dwRet -= 4;
-
-		/* \??\UNC\ */
-		if (dwRet > 7 &&
-			target[4] == 'U' && target[5] == 'N' && target[6] == 'C')
-		{
-			offset += 2;
-			dwRet -= 2;
-			target[offset] = '\\';
-		}
+	/* Do we need to trim off a \\?\ from the start of the path? */
+	trim_prefix = (dwChars >= ARRAY_SIZE(prefix)) &&
+		!wcsncmp(prefix, target_w, ARRAY_SIZE(prefix));
 
-		memmove(target, target + offset, dwRet);
-	}
+	/* Convert the result to UTF-8 */
+	if (git__utf16_to_8(target, target_len, trim_prefix ? target_w + 4 : target_w) < 0)
+		goto on_error;
+
+	error = 0;
 
-	target[dwRet] = '\0';
+on_error:
+	dwLastError = GetLastError();
 
-	return dwRet;
+	if (hFile && INVALID_HANDLE_VALUE != hFile)
+		CloseHandle(hFile);
+
+	if (target_w)
+		git__free(target_w);
+
+	SetLastError(dwLastError);
+	return error;
 }
 
 int p_symlink(const char *old, const char *new)
@@ -267,7 +309,8 @@ int p_open(const char *path, int flags, ...)
 	git_win32_path buf;
 	mode_t mode = 0;
 
-	git_win32_path_from_c(buf, path);
+	if (utf8_to_16_with_errno(buf, path) < 0)
+		return -1;
 
 	if (flags & O_CREAT) {
 		va_list arg_list;
@@ -283,33 +326,39 @@ int p_open(const char *path, int flags, ...)
 int p_creat(const char *path, mode_t mode)
 {
 	git_win32_path buf;
-	git_win32_path_from_c(buf, path);
+
+	if (utf8_to_16_with_errno(buf, path) < 0)
+		return -1;
+
 	return _wopen(buf, _O_WRONLY | _O_CREAT | _O_TRUNC | _O_BINARY, mode);
 }
 
 int p_getcwd(char *buffer_out, size_t size)
 {
-	int ret;
-	wchar_t *buf;
+	git_win32_path buf;
+	wchar_t *cwd = _wgetcwd(buf, GIT_WIN_PATH_UTF16);
 
-	if ((size_t)((int)size) != size)
+	if (!cwd)
 		return -1;
 
-	buf = (wchar_t*)git__malloc(sizeof(wchar_t) * (int)size);
-	GITERR_CHECK_ALLOC(buf);
+	/* Convert the working directory back to UTF-8 */
+	if (git__utf16_to_8(buffer_out, size, cwd) < 0) {
+		DWORD code = GetLastError();
 
-	_wgetcwd(buf, (int)size);
+		if (code == ERROR_INSUFFICIENT_BUFFER)
+			errno = ERANGE;
+		else
+			errno = EINVAL;
 
-	ret = WideCharToMultiByte(
-		CP_UTF8, 0, buf, -1, buffer_out, (int)size, NULL, NULL);
+		return -1;
+	}
 
-	git__free(buf);
-	return !ret ? -1 : 0;
+	return 0;
 }
 
 int p_stat(const char* path, struct stat* buf)
 {
-	git_win32_path_as_utf8 target;
+	git_win32_utf8_path target;
 	int error = 0;
 
 	error = do_lstat(path, buf, 0);
@@ -317,7 +366,7 @@ int p_stat(const char* path, struct stat* buf)
 	/* We need not do this in a loop to unwind chains of symlinks since
 	 * p_readlink calls GetFinalPathNameByHandle which does it for us. */
 	if (error >= 0 && S_ISLNK(buf->st_mode) &&
-		(error = p_readlink(path, target, sizeof(target))) >= 0)
+		(error = p_readlink(path, target, GIT_WIN_PATH_UTF8)) >= 0)
 		error = do_lstat(target, buf, 0);
 
 	return error;
@@ -326,82 +375,93 @@ int p_stat(const char* path, struct stat* buf)
 int p_chdir(const char* path)
 {
 	git_win32_path buf;
-	git_win32_path_from_c(buf, path);
+
+	if (utf8_to_16_with_errno(buf, path) < 0)
+		return -1;
+
 	return _wchdir(buf);
 }
 
 int p_chmod(const char* path, mode_t mode)
 {
 	git_win32_path buf;
-	git_win32_path_from_c(buf, path);
+
+	if (utf8_to_16_with_errno(buf, path) < 0)
+		return -1;
+
 	return _wchmod(buf, mode);
 }
 
 int p_rmdir(const char* path)
 {
-	int error;
 	git_win32_path buf;
-	git_win32_path_from_c(buf, path);
+	int error;
+
+	if (utf8_to_16_with_errno(buf, path) < 0)
+		return -1;
 
 	error = _wrmdir(buf);
 
-	/* _wrmdir() is documented to return EACCES if "A program has an open
-	 * handle to the directory."  This sounds like what everybody else calls
-	 * EBUSY.  Let's convert appropriate error codes.
-	 */
-	if (GetLastError() == ERROR_SHARING_VIOLATION)
-		errno = EBUSY;
+	if (-1 == error) {
+		switch (GetLastError()) {
+			/* _wrmdir() is documented to return EACCES if "A program has an open
+			 * handle to the directory."  This sounds like what everybody else calls
+			 * EBUSY.  Let's convert appropriate error codes.
+			 */
+			case ERROR_SHARING_VIOLATION:
+				errno = EBUSY;
+				break;
 
-	return error;
-}
+			/* This error can be returned when trying to rmdir an extant file. */
+			case ERROR_DIRECTORY:
+				errno = ENOTDIR;
+				break;
+		}
+	}
 
-int p_hide_directory__w32(const char *path)
-{
-	git_win32_path buf;
-	git_win32_path_from_c(buf, path);
-	return (SetFileAttributesW(buf, FILE_ATTRIBUTE_HIDDEN) != 0) ? 0 : -1;
+	return error;
 }
 
 char *p_realpath(const char *orig_path, char *buffer)
 {
-	int ret;
-	git_win32_path orig_path_w;
-	git_win32_path buffer_w;
+	git_win32_path orig_path_w, buffer_w;
 
-	git_win32_path_from_c(orig_path_w, orig_path);
+	if (utf8_to_16_with_errno(orig_path_w, orig_path) < 0)
+		return NULL;
 
-	/* Implicitly use GetCurrentDirectory which can be a threading issue */
-	ret = GetFullPathNameW(orig_path_w, GIT_WIN_PATH_UTF16, buffer_w, NULL);
+	/* Note that if the path provided is a relative path, then the current directory
+	 * is used to resolve the path -- which is a concurrency issue because the current
+	 * directory is a process-wide variable. */
+	if (!GetFullPathNameW(orig_path_w, GIT_WIN_PATH_UTF16, buffer_w, NULL)) {
+		if (GetLastError() == ERROR_INSUFFICIENT_BUFFER)
+			errno = ENAMETOOLONG;
+		else
+			errno = EINVAL;
 
-	/* According to MSDN, a return value equals to zero means a failure. */
-	if (ret == 0 || ret > GIT_WIN_PATH_UTF16)
-		buffer = NULL;
+		return NULL;
+	}
 
-	else if (GetFileAttributesW(buffer_w) == INVALID_FILE_ATTRIBUTES) {
-		buffer = NULL;
+	/* The path must exist. */
+	if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(buffer_w)) {
 		errno = ENOENT;
+		return NULL;
 	}
 
-	else if (buffer == NULL) {
-		int buffer_sz = WideCharToMultiByte(
-			CP_UTF8, 0, buffer_w, -1, NULL, 0, NULL, NULL);
-
-		if (!buffer_sz ||
-			!(buffer = (char *)git__malloc(buffer_sz)) ||
-			!WideCharToMultiByte(
-				CP_UTF8, 0, buffer_w, -1, buffer, buffer_sz, NULL, NULL))
-		{
-			git__free(buffer);
-			buffer = NULL;
-		}
+	/* Convert the path to UTF-8. */
+	if (buffer) {
+		/* If the caller provided a buffer, then it is assumed to be GIT_WIN_PATH_UTF8
+		 * characters in size. If it isn't, then we may overflow. */
+		if (git__utf16_to_8(buffer, GIT_WIN_PATH_UTF8, buffer_w) < 0)
+			return NULL;
+	} else {
+		/* If the caller did not provide a buffer, then we allocate one for the caller
+		 * from the heap. */
+		if (git__utf16_to_8_alloc(&buffer, buffer_w) < 0)
+			return NULL;
 	}
 
-	else if (!WideCharToMultiByte(
-		CP_UTF8, 0, buffer_w, -1, buffer, GIT_PATH_MAX, NULL, NULL))
-		buffer = NULL;
-
-	if (buffer)
-		git_path_mkposix(buffer);
+	/* Convert backslashes to forward slashes */
+	git_path_mkposix(buffer);
 
 	return buffer;
 }
@@ -433,8 +493,6 @@ int p_snprintf(char *buffer, size_t count, const char *format, ...)
 	return r;
 }
 
-extern int p_creat(const char *path, mode_t mode);
-
 int p_mkstemp(char *tmp_path)
 {
 #if defined(_MSC_VER)
@@ -448,18 +506,13 @@ int p_mkstemp(char *tmp_path)
 	return p_creat(tmp_path, 0744); //-V536
 }
 
-int p_setenv(const char* name, const char* value, int overwrite)
-{
-	if (overwrite != 1)
-		return -1;
-
-	return (SetEnvironmentVariableA(name, value) == 0 ? -1 : 0);
-}
-
 int p_access(const char* path, mode_t mode)
 {
 	git_win32_path buf;
-	git_win32_path_from_c(buf, path);
+
+	if (utf8_to_16_with_errno(buf, path) < 0)
+		return -1;
+
 	return _waccess(buf, mode);
 }
 
@@ -471,8 +524,9 @@ int p_rename(const char *from, const char *to)
 	int rename_succeeded;
 	int error;
 
-	git_win32_path_from_c(wfrom, from);
-	git_win32_path_from_c(wto, to);
+	if (utf8_to_16_with_errno(wfrom, from) < 0 ||
+		utf8_to_16_with_errno(wto, to) < 0)
+		return -1;
 	
 	/* wait up to 50ms if file is locked by another thread or process */
 	rename_tries = 0;
diff --git a/src/win32/utf-conv.c b/src/win32/utf-conv.c
index a96385f10..fe94701a8 100644
--- a/src/win32/utf-conv.c
+++ b/src/win32/utf-conv.c
@@ -8,12 +8,139 @@
 #include "common.h"
 #include "utf-conv.h"
 
-int git__utf8_to_16(wchar_t * dest, size_t dest_size, const char *src)
+#ifndef WC_ERR_INVALID_CHARS
+#define WC_ERR_INVALID_CHARS	0x80
+#endif
+
+GIT_INLINE(DWORD) get_wc_flags(void)
 {
-	return MultiByteToWideChar(CP_UTF8, 0, src, -1, dest, (int)dest_size);
+	static char inited = 0;
+	static DWORD flags;
+
+	/* Invalid code point check supported on Vista+ only */
+	if (!inited) {
+		flags = git_has_win32_version(6, 0, 0) ? WC_ERR_INVALID_CHARS : 0;
+		inited = 1;
+	}
+
+	return flags;
 }
 
+/**
+ * Converts a UTF-8 string to wide characters.
+ *
+ * @param dest The buffer to receive the wide string.
+ * @param dest_size The size of the buffer, in characters.
+ * @param src The UTF-8 string to convert.
+ * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
+ */
+int git__utf8_to_16(wchar_t *dest, size_t dest_size, const char *src)
+{
+	/* Length of -1 indicates NULL termination of the input string. Subtract 1 from the result to
+	* turn 0 into -1 (an error code) and to not count the NULL terminator as part of the string's
+	* length. MultiByteToWideChar never returns int's minvalue, so underflow is not possible */
+	return MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, dest, (int)dest_size) - 1;
+}
+
+/**
+ * Converts a wide string to UTF-8.
+ *
+ * @param dest The buffer to receive the UTF-8 string.
+ * @param dest_size The size of the buffer, in bytes.
+ * @param src The wide string to convert.
+ * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
+ */
 int git__utf16_to_8(char *dest, size_t dest_size, const wchar_t *src)
 {
-	return WideCharToMultiByte(CP_UTF8, 0, src, -1, dest, (int)dest_size, NULL, NULL);
+	/* Length of -1 indicates NULL termination of the input string. Subtract 1 from the result to
+	 * turn 0 into -1 (an error code) and to not count the NULL terminator as part of the string's
+	 * length. WideCharToMultiByte never returns int's minvalue, so underflow is not possible */
+	return WideCharToMultiByte(CP_UTF8, get_wc_flags(), src, -1, dest, (int)dest_size, NULL, NULL) - 1;
+}
+
+/**
+ * Converts a UTF-8 string to wide characters.
+ * Memory is allocated to hold the converted string.
+ * The caller is responsible for freeing the string with git__free.
+ *
+ * @param dest Receives a pointer to the wide string.
+ * @param src The UTF-8 string to convert.
+ * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
+ */
+int git__utf8_to_16_alloc(wchar_t **dest, const char *src)
+{
+	int utf16_size;
+
+	*dest = NULL;
+
+	/* Length of -1 indicates NULL termination of the input string */
+	utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, NULL, 0);
+
+	if (!utf16_size)
+		return -1;
+
+	*dest = git__malloc(utf16_size * sizeof(wchar_t));
+
+	if (!*dest)
+		return -1;
+
+	utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, *dest, utf16_size);
+
+	if (!utf16_size) {
+		/* Don't let git__free stomp on the thread-local last error code,
+		* so that the caller can call giterr_set(GITERR_OS, ...) */
+		DWORD last_error = GetLastError();
+		git__free(*dest);
+		*dest = NULL;
+		SetLastError(last_error);
+	}
+
+	/* Subtract 1 from the result to turn 0 into -1 (an error code) and to not count the NULL
+	 * terminator as part of the string's length. MultiByteToWideChar never returns int's minvalue,
+	 * so underflow is not possible */
+	return utf16_size - 1;
+}
+
+/**
+ * Converts a wide string to UTF-8.
+ * Memory is allocated to hold the converted string.
+ * The caller is responsible for freeing the string with git__free.
+ *
+ * @param dest Receives a pointer to the UTF-8 string.
+ * @param src The wide string to convert.
+ * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
+ */
+int git__utf16_to_8_alloc(char **dest, const wchar_t *src)
+{
+	int utf8_size;
+	DWORD dwFlags = get_wc_flags();
+
+	*dest = NULL;
+
+	/* Length of -1 indicates NULL termination of the input string */
+	utf8_size = WideCharToMultiByte(CP_UTF8, dwFlags, src, -1, NULL, 0, NULL, NULL);
+
+	if (!utf8_size)
+		return -1;
+
+	*dest = git__malloc(utf8_size);
+
+	if (!*dest)
+		return -1;
+
+	utf8_size = WideCharToMultiByte(CP_UTF8, dwFlags, src, -1, *dest, utf8_size, NULL, NULL);
+
+	if (!utf8_size) {
+		/* Don't let git__free stomp on the thread-local last error code,
+		 * so that the caller can call giterr_set(GITERR_OS, ...) */
+		DWORD last_error = GetLastError();
+		git__free(*dest);
+		*dest = NULL;
+		SetLastError(last_error);
+	}
+
+	/* Subtract 1 from the result to turn 0 into -1 (an error code) and to not count the NULL
+	 * terminator as part of the string's length. MultiByteToWideChar never returns int's minvalue,
+	 * so underflow is not possible */
+	return utf8_size - 1;
 }
diff --git a/src/win32/utf-conv.h b/src/win32/utf-conv.h
index 3af77580e..a480cd93e 100644
--- a/src/win32/utf-conv.h
+++ b/src/win32/utf-conv.h
@@ -10,27 +10,83 @@
 #include <wchar.h>
 #include "common.h"
 
-/* Maximum characters in a Windows path plus one for NUL byte */
-#define GIT_WIN_PATH_UTF16 (260 + 1)
+/* Equal to the Win32 MAX_PATH constant. The maximum path length is 259
+ * characters plus a NULL terminator. */
+#define GIT_WIN_PATH_UTF16		260
 
-/* Maximum bytes necessary to convert a full-length UTF16 path to UTF8 */
-#define GIT_WIN_PATH_UTF8  (260 * 4 + 1)
+/* Maximum size of a UTF-8 Win32 path. UTF-8 does have 4-byte sequences,
+ * but they are encoded in UTF-16 using surrogate pairs, which takes up
+ * the space of two characters. Two characters in the range U+0800 ->
+ * U+FFFF take up more space in UTF-8 (6 bytes) than one surrogate pair
+ * (4 bytes). */
+#define GIT_WIN_PATH_UTF8		(259 * 3 + 1)
 
+/* Win32 path types */
 typedef wchar_t git_win32_path[GIT_WIN_PATH_UTF16];
+typedef char git_win32_utf8_path[GIT_WIN_PATH_UTF8];
 
-typedef char git_win32_path_as_utf8[GIT_WIN_PATH_UTF8];
+/**
+ * Converts a UTF-8 string to wide characters.
+ *
+ * @param dest The buffer to receive the wide string.
+ * @param dest_size The size of the buffer, in characters.
+ * @param src The UTF-8 string to convert.
+ * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
+ */
+int git__utf8_to_16(wchar_t *dest, size_t dest_size, const char *src);
 
-/* dest_size is the size of dest in wchar_t's */
-int git__utf8_to_16(wchar_t * dest, size_t dest_size, const char *src);
-/* dest_size is the size of dest in char's */
+/**
+ * Converts a wide string to UTF-8.
+ *
+ * @param dest The buffer to receive the UTF-8 string.
+ * @param dest_size The size of the buffer, in bytes.
+ * @param src The wide string to convert.
+ * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
+ */
 int git__utf16_to_8(char *dest, size_t dest_size, const wchar_t *src);
 
-GIT_INLINE(int) git_win32_path_from_c(git_win32_path dest, const char *src)
+/**
+ * Converts a UTF-8 string to wide characters.
+ * Memory is allocated to hold the converted string.
+ * The caller is responsible for freeing the string with git__free.
+ *
+ * @param dest Receives a pointer to the wide string.
+ * @param src The UTF-8 string to convert.
+ * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
+ */
+int git__utf8_to_16_alloc(wchar_t **dest, const char *src);
+
+/**
+ * Converts a wide string to UTF-8.
+ * Memory is allocated to hold the converted string.
+ * The caller is responsible for freeing the string with git__free.
+ *
+ * @param dest Receives a pointer to the UTF-8 string.
+ * @param src The wide string to convert.
+ * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
+ */
+int git__utf16_to_8_alloc(char **dest, const wchar_t *src);
+
+/**
+ * Converts a UTF-8 Win32 path to wide characters.
+ *
+ * @param dest The buffer to receive the wide string.
+ * @param src The UTF-8 string to convert.
+ * @return The length of the wide string, in characters (not counting the NULL terminator), or < 0 for failure
+ */
+GIT_INLINE(int) git_win32_path_from_utf8(git_win32_path dest, const char *src)
 {
 	return git__utf8_to_16(dest, GIT_WIN_PATH_UTF16, src);
 }
 
-GIT_INLINE(int) git_win32_path_to_c(git_win32_path_as_utf8 dest, const wchar_t *src)
+/**
+ * Converts a wide Win32 path to UTF-8.
+ *
+ * @param dest The buffer to receive the UTF-8 string.
+ * @param src The wide string to convert.
+ * @return The length of the UTF-8 string, in bytes (not counting the NULL terminator), or < 0 for failure
+ */
+GIT_INLINE(int) git_win32_path_to_utf8(git_win32_utf8_path dest, const wchar_t *src)
 {
 	return git__utf16_to_8(dest, GIT_WIN_PATH_UTF8, src);
 }
diff --git a/src/win32/w32_util.c b/src/win32/w32_util.c
new file mode 100644
index 000000000..246b30a6b
--- /dev/null
+++ b/src/win32/w32_util.c
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "w32_util.h"
+
+/**
+ * Creates a FindFirstFile(Ex) filter string from a UTF-8 path.
+ * The filter string enumerates all items in the directory.
+ *
+ * @param dest The buffer to receive the filter string.
+ * @param src The UTF-8 path of the directory to enumerate.
+ * @return True if the filter string was created successfully; false otherwise
+ */
+bool git_win32__findfirstfile_filter(git_win32_path dest, const char *src)
+{
+	static const wchar_t suffix[] = L"\\*";
+	int len = git_win32_path_from_utf8(dest, src);
+
+	/* Ensure the path was converted */
+	if (len < 0)
+		return false;
+
+	/* Ensure that the path does not end with a trailing slash --
+	 * because we're about to add one! */
+	if (len > 0 &&
+		(dest[len - 1] == L'/' || dest[len - 1] == L'\\')) {
+		dest[len - 1] = L'\0';
+		len--;
+	}
+
+	/* Ensure we have enough room to add the suffix */
+	if ((size_t)len > GIT_WIN_PATH_UTF16 - ARRAY_SIZE(suffix))
+		return false;
+
+	wcscat(dest, suffix);
+	return true;
+}
+
+/**
+ * Ensures the given path (file or folder) has the +H (hidden) attribute set.
+ *
+ * @param path The path which should receive the +H bit.
+ * @return 0 on success; -1 on failure
+ */
+int git_win32__sethidden(const char *path)
+{
+	git_win32_path buf;
+	DWORD attrs;
+
+	if (git_win32_path_from_utf8(buf, path) < 0)
+		return -1;
+
+	attrs = GetFileAttributesW(buf);
+
+	/* Ensure the path exists */
+	if (INVALID_FILE_ATTRIBUTES == attrs)
+		return -1;
+
+	/* If the item isn't already +H, add the bit */
+	if (0 == (attrs & FILE_ATTRIBUTE_HIDDEN) &&
+		!SetFileAttributesW(buf, attrs | FILE_ATTRIBUTE_HIDDEN))
+		return -1;
+
+	return 0;
+}
diff --git a/src/win32/w32_util.h b/src/win32/w32_util.h
new file mode 100644
index 000000000..cd02bd7b2
--- /dev/null
+++ b/src/win32/w32_util.h
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#ifndef INCLUDE_w32_util_h__
+#define INCLUDE_w32_util_h__
+
+#include "utf-conv.h"
+
+/**
+ * Creates a FindFirstFile(Ex) filter string from a UTF-8 path.
+ * The filter string enumerates all items in the directory.
+ *
+ * @param dest The buffer to receive the filter string.
+ * @param src The UTF-8 path of the directory to enumerate.
+ * @return True if the filter string was created successfully; false otherwise
+ */
+bool git_win32__findfirstfile_filter(git_win32_path dest, const char *src);
+
+/**
+ * Ensures the given path (file or folder) has the +H (hidden) attribute set.
+ *
+ * @param path The path which should receive the +H bit.
+ * @return 0 on success; -1 on failure
+ */
+int git_win32__sethidden(const char *path);
+
+#endif
diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c
index 90e53c5e6..6f6143dad 100644
--- a/tests/clar_libgit2.c
+++ b/tests/clar_libgit2.c
@@ -59,47 +59,40 @@ void cl_git_rewritefile(const char *path, const char *content)
 
 char *cl_getenv(const char *name)
 {
-	git_win32_path name_utf16;
-	DWORD alloc_len;
-	wchar_t *value_utf16;
-	char *value_utf8;
+	wchar_t *wide_name, *wide_value;
+	char *utf8_value = NULL;
+	DWORD value_len;
 
-	git_win32_path_from_c(name_utf16, name);
-	alloc_len = GetEnvironmentVariableW(name_utf16, NULL, 0);
-	if (alloc_len <= 0)
-		return NULL;
+	cl_assert(git__utf8_to_16_alloc(&wide_name, name) >= 0);
 
-	cl_assert(value_utf16 = git__calloc(alloc_len, sizeof(wchar_t)));
+	value_len = GetEnvironmentVariableW(wide_name, NULL, 0);
 
-	GetEnvironmentVariableW(name_utf16, value_utf16, alloc_len);
-
-	alloc_len = alloc_len * 4 + 1; /* worst case UTF16->UTF8 growth */
-	cl_assert(value_utf8 = git__calloc(alloc_len, 1));
-
-	git__utf16_to_8(value_utf8, alloc_len, value_utf16);
-
-	git__free(value_utf16);
+	if (value_len) {
+		cl_assert(wide_value = git__malloc(value_len * sizeof(wchar_t)));
+		cl_assert(GetEnvironmentVariableW(wide_name, wide_value, value_len));
+		cl_assert(git__utf16_to_8_alloc(&utf8_value, wide_value) >= 0);
+		git__free(wide_value);
+	}
 
-	return value_utf8;
+	git__free(wide_name);
+	return utf8_value;
 }
 
 int cl_setenv(const char *name, const char *value)
 {
-	git_win32_path name_utf16;
-	git_win32_path value_utf16;
+	wchar_t *wide_name, *wide_value;
 
-	git_win32_path_from_c(name_utf16, name);
+	cl_assert(git__utf8_to_16_alloc(&wide_name, name) >= 0);
 
 	if (value) {
-		git_win32_path_from_c(value_utf16, value);
-		cl_assert(SetEnvironmentVariableW(name_utf16, value_utf16));
+		cl_assert(git__utf8_to_16_alloc(&wide_value, value) >= 0);
+		cl_assert(SetEnvironmentVariableW(wide_name, wide_value));
 	} else {
 		/* Windows XP returns 0 (failed) when passing NULL for lpValue when
-		 * lpName does not exist in the environment block. This behavior
-		 * seems to have changed in later versions. Don't check return value
-		 * of SetEnvironmentVariable when passing NULL for lpValue.
-		 */
-		SetEnvironmentVariableW(name_utf16, NULL);
+		* lpName does not exist in the environment block. This behavior
+		* seems to have changed in later versions. Don't check the return value
+		* of SetEnvironmentVariable when passing NULL for lpValue. */
+		SetEnvironmentVariableW(wide_name, NULL);
 	}
 
 	return 0;
@@ -115,8 +108,8 @@ int cl_rename(const char *source, const char *dest)
 	git_win32_path dest_utf16;
 	unsigned retries = 1;
 
-	git_win32_path_from_c(source_utf16, source);
-	git_win32_path_from_c(dest_utf16, dest);
+	cl_assert(git_win32_path_from_utf8(source_utf16, source) >= 0);
+	cl_assert(git_win32_path_from_utf8(dest_utf16, dest) >= 0);
 
 	while (!MoveFileW(source_utf16, dest_utf16)) {
 		/* Only retry if the error is ERROR_ACCESS_DENIED;
diff --git a/tests/core/env.c b/tests/core/env.c
index b01ad1c24..df1d92a02 100644
--- a/tests/core/env.c
+++ b/tests/core/env.c
@@ -21,7 +21,7 @@ static char *home_values[] = {
 	"f\xc4\x80ke_\xc4\xa4ome", /* latin extended */
 	"f\xce\xb1\xce\xba\xce\xb5_h\xce\xbfm\xce\xad",  /* having fun with greek */
 	"fa\xe0" "\xb8" "\x87" "e_\xe0" "\xb8" "\x99" "ome", /* thai characters */
-	"f\xe1\x9cx80ke_\xe1\x9c\x91ome", /* tagalog characters */
+	"f\xe1\x9c\x80ke_\xe1\x9c\x91ome", /* tagalog characters */
 	"\xe1\xb8\x9f\xe1\xba\xa2" "ke_ho" "\xe1" "\xb9" "\x81" "e", /* latin extended additional */
 	"\xf0\x9f\x98\x98\xf0\x9f\x98\x82", /* emoticons */
 	NULL
-- 
cgit v1.2.3


From 9effa2fb72f20332c2c8a83540bb224a32e0265b Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sun, 20 Apr 2014 19:19:13 +0200
Subject: Fire progress callbacks also for pushes.

It's not very useful to only know that a pre-receive hook has declined
a push, you probably want to know why.
---
 include/git2/remote.h           |  3 +-
 src/transports/smart_protocol.c | 71 ++++++++++++++++++++---------------------
 2 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index d57321f03..88040d49c 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -455,7 +455,8 @@ struct git_remote_callbacks {
 	/**
 	 * Textual progress from the remote. Text send over the
 	 * progress side-band will be passed to this function (this is
-	 * the 'counting objects' output.
+	 * the 'counting objects' output. This callback should return a value less
+	 * than zero to cancel the operation.
 	 */
 	int (*progress)(const char *str, int len, void *data);
 
diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index 7e8fcdd92..e5b56eaff 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -478,7 +478,7 @@ int git_smart__download_pack(
 	git_transport *transport,
 	git_repository *repo,
 	git_transfer_progress *stats,
-	git_transfer_progress_callback progress_cb,
+	git_transfer_progress_callback transfer_progress_cb,
 	void *progress_payload)
 {
 	transport_smart *t = (transport_smart *)transport;
@@ -490,8 +490,8 @@ int git_smart__download_pack(
 
 	memset(stats, 0, sizeof(git_transfer_progress));
 
-	if (progress_cb) {
-		npp.callback = progress_cb;
+	if (transfer_progress_cb) {
+		npp.callback = transfer_progress_cb;
 		npp.payload = progress_payload;
 		npp.stats = stats;
 		t->packetsize_cb = &network_packetsize;
@@ -504,7 +504,7 @@ int git_smart__download_pack(
 	}
 
 	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0 ||
-		((error = git_odb_write_pack(&writepack, odb, progress_cb, progress_payload)) != 0))
+		((error = git_odb_write_pack(&writepack, odb, transfer_progress_cb, progress_payload)) != 0))
 		goto done;
 
 	/*
@@ -518,7 +518,7 @@ int git_smart__download_pack(
 	}
 
 	do {
-		git_pkt *pkt;
+		git_pkt *pkt = NULL;
 
 		/* Check cancellation before network call */
 		if (t->cancelled.val) {
@@ -527,40 +527,34 @@ int git_smart__download_pack(
 			goto done;
 		}
 
-		if ((error = recv_pkt(&pkt, buf)) < 0)
-			goto done;
-
-		/* Check cancellation after network call */
-		if (t->cancelled.val) {
-			giterr_clear();
-			error = GIT_EUSER;
-			goto done;
+		if ((error = recv_pkt(&pkt, buf)) >= 0) {
+			/* Check cancellation after network call */
+			if (t->cancelled.val) {
+				giterr_clear();
+				error = GIT_EUSER;
+			} else if (pkt->type == GIT_PKT_PROGRESS) {
+				if (t->progress_cb) {
+					git_pkt_progress *p = (git_pkt_progress *) pkt;
+					error = t->progress_cb(p->data, p->len, t->message_cb_payload);
+				}
+			} else if (pkt->type == GIT_PKT_DATA) {
+				git_pkt_data *p = (git_pkt_data *) pkt;
+				error = writepack->append(writepack, p->data, p->len, stats);
+			} else if (pkt->type == GIT_PKT_FLUSH) {
+				/* A flush indicates the end of the packfile */
+				git__free(pkt);
+				break;
+			}
 		}
 
-		if (pkt->type == GIT_PKT_PROGRESS) {
-			if (t->progress_cb) {
-				git_pkt_progress *p = (git_pkt_progress *) pkt;
-				error = t->progress_cb(p->data, p->len, t->message_cb_payload);
-				if (error)
-					goto done;
-			}
-			git__free(pkt);
-		} else if (pkt->type == GIT_PKT_DATA) {
-			git_pkt_data *p = (git_pkt_data *) pkt;
-			error = writepack->append(writepack, p->data, p->len, stats);
+		git__free(pkt);
+		if (error < 0)
+			goto done;
 
-			git__free(pkt);
-			if (error != 0)
-				goto done;
-		} else if (pkt->type == GIT_PKT_FLUSH) {
-			/* A flush indicates the end of the packfile */
-			git__free(pkt);
-			break;
-		}
 	} while (1);
 
 	/*
-	 * Trailing execution of progress_cb, if necessary...
+	 * Trailing execution of transfer_progress_cb, if necessary...
 	 * Only the callback through the npp datastructure currently
 	 * updates the last_fired_bytes value. It is possible that
 	 * progress has already been reported with the correct
@@ -579,7 +573,7 @@ int git_smart__download_pack(
 done:
 	if (writepack)
 		writepack->free(writepack);
-	if (progress_cb) {
+	if (transfer_progress_cb) {
 		t->packetsize_cb = NULL;
 		t->packetsize_payload = NULL;
 	}
@@ -696,10 +690,11 @@ static int add_push_report_sideband_pkt(git_push *push, git_pkt_data *data_pkt)
 	return 0;
 }
 
-static int parse_report(gitno_buffer *buf, git_push *push)
+static int parse_report(transport_smart *transport, git_push *push)
 {
 	git_pkt *pkt = NULL;
 	const char *line_end = NULL;
+	gitno_buffer *buf = &transport->buffer;
 	int error, recvd;
 
 	for (;;) {
@@ -738,6 +733,10 @@ static int parse_report(gitno_buffer *buf, git_push *push)
 				error = -1;
 				break;
 			case GIT_PKT_PROGRESS:
+				if (transport->progress_cb) {
+					git_pkt_progress *p = (git_pkt_progress *) pkt;
+					error = transport->progress_cb(p->data, p->len, transport->message_cb_payload);
+				}
 				break;
 			default:
 				error = add_push_report_pkt(push, pkt);
@@ -953,7 +952,7 @@ int git_smart__push(git_transport *transport, git_push *push)
 	 * we consider the pack to have been unpacked successfully */
 	if (!push->specs.length || !push->report_status)
 		push->unpack_ok = 1;
-	else if ((error = parse_report(&t->buffer, push)) < 0)
+	else if ((error = parse_report(t, push)) < 0)
 		goto done;
 
 	/* If progress is being reported write the final report */
-- 
cgit v1.2.3


From 4f62163ead2bde1af3cd7d0c0b8990e1831d3ffd Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sun, 20 Apr 2014 22:06:05 +0200
Subject: Check the return codes of remote callbacks.

The user may have requested that the operation be cancelled.
---
 include/git2/remote.h           |  3 +--
 src/transports/smart_protocol.c | 14 +++++++++-----
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index 88040d49c..d57321f03 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -455,8 +455,7 @@ struct git_remote_callbacks {
 	/**
 	 * Textual progress from the remote. Text send over the
 	 * progress side-band will be passed to this function (this is
-	 * the 'counting objects' output. This callback should return a value less
-	 * than zero to cancel the operation.
+	 * the 'counting objects' output.
 	 */
 	int (*progress)(const char *str, int len, void *data);
 
diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index e5b56eaff..6f935173a 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -882,10 +882,7 @@ static int stream_thunk(void *buf, size_t size, void *data)
 
 		if ((current_time - payload->last_progress_report_time) >= MIN_PROGRESS_UPDATE_INTERVAL) {
 			payload->last_progress_report_time = current_time;
-			if (payload->cb(payload->pb->nr_written, payload->pb->nr_objects, payload->last_bytes, payload->cb_payload)) {
-				giterr_clear();
-				error = GIT_EUSER;
-			}
+			error = payload->cb(payload->pb->nr_written, payload->pb->nr_objects, payload->last_bytes, payload->cb_payload);
 		}
 	}
 
@@ -957,7 +954,14 @@ int git_smart__push(git_transport *transport, git_push *push)
 
 	/* If progress is being reported write the final report */
 	if (push->transfer_progress_cb) {
-		push->transfer_progress_cb(push->pb->nr_written, push->pb->nr_objects, packbuilder_payload.last_bytes, push->transfer_progress_cb_payload);
+		error = push->transfer_progress_cb(
+					push->pb->nr_written,
+					push->pb->nr_objects,
+					packbuilder_payload.last_bytes,
+					push->transfer_progress_cb_payload);
+
+		if (error < 0)
+			goto done;
 	}
 
 	if (push->status.length) {
-- 
cgit v1.2.3


From 98020d3a73743d79c6acd380339b1d743205a86b Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 21 Apr 2014 10:55:37 +0200
Subject: Rename progress callback to sideband_progress

---
 include/git2/remote.h      | 2 +-
 src/remote.c               | 4 ++--
 src/transports/smart_pkt.c | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index d57321f03..06fc8e90d 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -457,7 +457,7 @@ struct git_remote_callbacks {
 	 * progress side-band will be passed to this function (this is
 	 * the 'counting objects' output.
 	 */
-	int (*progress)(const char *str, int len, void *data);
+	int (*sideband_progress)(const char *str, int len, void *data);
 
 	/**
 	 * Completion is called when different parts of the download
diff --git a/src/remote.c b/src/remote.c
index 243086bf9..17104836b 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -663,7 +663,7 @@ int git_remote_connect(git_remote *remote, git_direction direction)
 		return error;
 
 	if (t->set_callbacks &&
-		(error = t->set_callbacks(t, remote->callbacks.progress, NULL, remote->callbacks.payload)) < 0)
+		(error = t->set_callbacks(t, remote->callbacks.sideband_progress, NULL, remote->callbacks.payload)) < 0)
 		goto on_error;
 
 	if (!remote->check_cert)
@@ -1246,7 +1246,7 @@ int git_remote_set_callbacks(git_remote *remote, const git_remote_callbacks *cal
 
 	if (remote->transport && remote->transport->set_callbacks)
 		return remote->transport->set_callbacks(remote->transport,
-			remote->callbacks.progress,
+			remote->callbacks.sideband_progress,
 			NULL,
 			remote->callbacks.payload);
 
diff --git a/src/transports/smart_pkt.c b/src/transports/smart_pkt.c
index 2bb09c750..e9376ae6f 100644
--- a/src/transports/smart_pkt.c
+++ b/src/transports/smart_pkt.c
@@ -153,7 +153,7 @@ static int data_pkt(git_pkt **out, const char *line, size_t len)
 	return 0;
 }
 
-static int progress_pkt(git_pkt **out, const char *line, size_t len)
+static int sideband_progress_pkt(git_pkt **out, const char *line, size_t len)
 {
 	git_pkt_progress *pkt;
 
@@ -403,7 +403,7 @@ int git_pkt_parse_line(
 	if (*line == GIT_SIDE_BAND_DATA)
 		ret = data_pkt(head, line, len);
 	else if (*line == GIT_SIDE_BAND_PROGRESS)
-		ret = progress_pkt(head, line, len);
+		ret = sideband_progress_pkt(head, line, len);
 	else if (*line == GIT_SIDE_BAND_ERROR)
 		ret = sideband_error_pkt(head, line, len);
 	else if (!git__prefixcmp(line, "ACK"))
-- 
cgit v1.2.3


From 48e60ae75e78bc58aeb3c7ecf6be4653152182f4 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 21 Apr 2014 11:23:29 +0200
Subject: Don't redefine the same callback types, their signatures may change

---
 examples/network/fetch.c        | 2 +-
 include/git2/indexer.h          | 2 +-
 include/git2/odb.h              | 2 +-
 include/git2/pack.h             | 2 +-
 include/git2/remote.h           | 6 +++---
 include/git2/sys/odb_backend.h  | 2 +-
 include/git2/transport.h        | 2 +-
 include/git2/types.h            | 2 +-
 src/fetch.h                     | 2 +-
 src/indexer.c                   | 4 ++--
 src/odb.c                       | 2 +-
 src/odb_pack.c                  | 2 +-
 src/pack-objects.c              | 2 +-
 src/transports/local.c          | 4 ++--
 src/transports/smart.h          | 2 +-
 src/transports/smart_protocol.c | 4 ++--
 16 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/examples/network/fetch.c b/examples/network/fetch.c
index fdd82a1f7..03f1541a4 100644
--- a/examples/network/fetch.c
+++ b/examples/network/fetch.c
@@ -97,7 +97,7 @@ int fetch(git_repository *repo, int argc, char **argv)
 
 	// Set up the callbacks (only update_tips for now)
 	callbacks.update_tips = &update_cb;
-	callbacks.progress = &progress_cb;
+	callbacks.sideband_progress = &progress_cb;
 	callbacks.credentials = cred_acquire_cb;
 	git_remote_set_callbacks(remote, &callbacks);
 
diff --git a/include/git2/indexer.h b/include/git2/indexer.h
index e4c03ad06..d2d315e47 100644
--- a/include/git2/indexer.h
+++ b/include/git2/indexer.h
@@ -32,7 +32,7 @@ GIT_EXTERN(int) git_indexer_new(
 		const char *path,
 		unsigned int mode,
 		git_odb *odb,
-		git_transfer_progress_callback progress_cb,
+		git_transfer_progress_cb progress_cb,
 		void *progress_cb_payload);
 
 /**
diff --git a/include/git2/odb.h b/include/git2/odb.h
index c71e30648..114f6b317 100644
--- a/include/git2/odb.h
+++ b/include/git2/odb.h
@@ -338,7 +338,7 @@ GIT_EXTERN(int) git_odb_open_rstream(git_odb_stream **out, git_odb *db, const gi
 GIT_EXTERN(int) git_odb_write_pack(
 	git_odb_writepack **out,
 	git_odb *db,
-	git_transfer_progress_callback progress_cb,
+	git_transfer_progress_cb progress_cb,
 	void *progress_payload);
 
 /**
diff --git a/include/git2/pack.h b/include/git2/pack.h
index 29c926c65..e7f060d12 100644
--- a/include/git2/pack.h
+++ b/include/git2/pack.h
@@ -140,7 +140,7 @@ GIT_EXTERN(int) git_packbuilder_write(
 	git_packbuilder *pb,
 	const char *path,
 	unsigned int mode,
-	git_transfer_progress_callback progress_cb,
+	git_transfer_progress_cb progress_cb,
 	void *progress_cb_payload);
 
 /**
diff --git a/include/git2/remote.h b/include/git2/remote.h
index 06fc8e90d..ebd83c05a 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -457,7 +457,7 @@ struct git_remote_callbacks {
 	 * progress side-band will be passed to this function (this is
 	 * the 'counting objects' output.
 	 */
-	int (*sideband_progress)(const char *str, int len, void *data);
+	git_transport_message_cb sideband_progress;
 
 	/**
 	 * Completion is called when different parts of the download
@@ -469,14 +469,14 @@ struct git_remote_callbacks {
 	 * This will be called if the remote host requires
 	 * authentication in order to connect to it.
 	 */
-	int (*credentials)(git_cred **cred, const char *url, const char *username_from_url, unsigned int allowed_types,	void *data);
+	git_cred_acquire_cb credentials;
 
 	/**
 	 * During the download of new data, this will be regularly
 	 * called with the current count of progress done by the
 	 * indexer.
 	 */
-	int (*transfer_progress)(const git_transfer_progress *stats, void *data);
+	git_transfer_progress_cb transfer_progress;
 
 	/**
 	 * Each time a reference is updated locally, this function
diff --git a/include/git2/sys/odb_backend.h b/include/git2/sys/odb_backend.h
index 81bb082e6..77fe0dd31 100644
--- a/include/git2/sys/odb_backend.h
+++ b/include/git2/sys/odb_backend.h
@@ -81,7 +81,7 @@ struct git_odb_backend {
 
 	int (* writepack)(
 		git_odb_writepack **, git_odb_backend *, git_odb *odb,
-		git_transfer_progress_callback progress_cb, void *progress_payload);
+		git_transfer_progress_cb progress_cb, void *progress_payload);
 
 	void (* free)(git_odb_backend *);
 };
diff --git a/include/git2/transport.h b/include/git2/transport.h
index 1665f97b3..a33146ca8 100644
--- a/include/git2/transport.h
+++ b/include/git2/transport.h
@@ -287,7 +287,7 @@ struct git_transport {
 		git_transport *transport,
 		git_repository *repo,
 		git_transfer_progress *stats,
-		git_transfer_progress_callback progress_cb,
+		git_transfer_progress_cb progress_cb,
 		void *progress_payload);
 
 	/* Checks to see if the transport is connected */
diff --git a/include/git2/types.h b/include/git2/types.h
index 9db59b16b..1b6f4cca1 100644
--- a/include/git2/types.h
+++ b/include/git2/types.h
@@ -241,7 +241,7 @@ typedef struct git_transfer_progress {
  * @param stats Structure containing information about the state of the transfer
  * @param payload Payload provided by caller
  */
-typedef int (*git_transfer_progress_callback)(const git_transfer_progress *stats, void *payload);
+typedef int (*git_transfer_progress_cb)(const git_transfer_progress *stats, void *payload);
 
 /**
  * Opaque structure representing a submodule.
diff --git a/src/fetch.h b/src/fetch.h
index 9605da1b5..f66e44663 100644
--- a/src/fetch.h
+++ b/src/fetch.h
@@ -17,7 +17,7 @@ int git_fetch__download_pack(
 		git_transport *t,
 		git_repository *repo,
 		git_transfer_progress *stats,
-		git_transfer_progress_callback progress_cb,
+		git_transfer_progress_cb progress_cb,
 		void *progress_payload);
 
 int git_fetch_setup_walk(git_revwalk **out, git_repository *repo);
diff --git a/src/indexer.c b/src/indexer.c
index 346870faa..adf5ceaa7 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -45,7 +45,7 @@ struct git_indexer {
 	unsigned int fanout[256];
 	git_hash_ctx hash_ctx;
 	git_oid hash;
-	git_transfer_progress_callback progress_cb;
+	git_transfer_progress_cb progress_cb;
 	void *progress_payload;
 	char objbuf[8*1024];
 
@@ -120,7 +120,7 @@ int git_indexer_new(
 		const char *prefix,
 		unsigned int mode,
 		git_odb *odb,
-		git_transfer_progress_callback progress_cb,
+		git_transfer_progress_cb progress_cb,
 		void *progress_payload)
 {
 	git_indexer *idx;
diff --git a/src/odb.c b/src/odb.c
index 72d150658..00740d2e2 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -1051,7 +1051,7 @@ int git_odb_open_rstream(git_odb_stream **stream, git_odb *db, const git_oid *oi
 	return error;
 }
 
-int git_odb_write_pack(struct git_odb_writepack **out, git_odb *db, git_transfer_progress_callback progress_cb, void *progress_payload)
+int git_odb_write_pack(struct git_odb_writepack **out, git_odb *db, git_transfer_progress_cb progress_cb, void *progress_payload)
 {
 	size_t i, writes = 0;
 	int error = GIT_ERROR;
diff --git a/src/odb_pack.c b/src/odb_pack.c
index 9ab683882..3750da37f 100644
--- a/src/odb_pack.c
+++ b/src/odb_pack.c
@@ -563,7 +563,7 @@ static void pack_backend__writepack_free(struct git_odb_writepack *_writepack)
 static int pack_backend__writepack(struct git_odb_writepack **out,
 	git_odb_backend *_backend,
         git_odb *odb,
-	git_transfer_progress_callback progress_cb,
+	git_transfer_progress_cb progress_cb,
 	void *progress_payload)
 {
 	struct pack_backend *backend;
diff --git a/src/pack-objects.c b/src/pack-objects.c
index c881e6d99..7e5f667f4 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -1288,7 +1288,7 @@ int git_packbuilder_write(
 	git_packbuilder *pb,
 	const char *path,
 	unsigned int mode,
-	git_transfer_progress_callback progress_cb,
+	git_transfer_progress_cb progress_cb,
 	void *progress_cb_payload)
 {
 	git_indexer *indexer;
diff --git a/src/transports/local.c b/src/transports/local.c
index f8d511ed6..2c17e6271 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -472,7 +472,7 @@ on_error:
 
 typedef struct foreach_data {
 	git_transfer_progress *stats;
-	git_transfer_progress_callback progress_cb;
+	git_transfer_progress_cb progress_cb;
 	void *progress_payload;
 	git_odb_writepack *writepack;
 } foreach_data;
@@ -489,7 +489,7 @@ static int local_download_pack(
 		git_transport *transport,
 		git_repository *repo,
 		git_transfer_progress *stats,
-		git_transfer_progress_callback progress_cb,
+		git_transfer_progress_cb progress_cb,
 		void *progress_payload)
 {
 	transport_local *t = (transport_local*)transport;
diff --git a/src/transports/smart.h b/src/transports/smart.h
index 32f0be7f2..a2b6b2a71 100644
--- a/src/transports/smart.h
+++ b/src/transports/smart.h
@@ -167,7 +167,7 @@ int git_smart__download_pack(
 	git_transport *transport,
 	git_repository *repo,
 	git_transfer_progress *stats,
-	git_transfer_progress_callback progress_cb,
+	git_transfer_progress_cb progress_cb,
 	void *progress_payload);
 
 /* smart.c */
diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index 6f935173a..cf67f9078 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -450,7 +450,7 @@ static int no_sideband(transport_smart *t, struct git_odb_writepack *writepack,
 
 struct network_packetsize_payload
 {
-	git_transfer_progress_callback callback;
+	git_transfer_progress_cb callback;
 	void *payload;
 	git_transfer_progress *stats;
 	size_t last_fired_bytes;
@@ -478,7 +478,7 @@ int git_smart__download_pack(
 	git_transport *transport,
 	git_repository *repo,
 	git_transfer_progress *stats,
-	git_transfer_progress_callback transfer_progress_cb,
+	git_transfer_progress_cb transfer_progress_cb,
 	void *progress_payload)
 {
 	transport_smart *t = (transport_smart *)transport;
-- 
cgit v1.2.3


From a15d3537bb52450f75ad63642b6bcbbcc6fdc374 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 21 Apr 2014 15:48:05 +0200
Subject: sysdir: free the path if we cannot find the file

Returning an error cleared the buf, but this operation does not free the
memory associated with it. Use git_buf_free() instead.
---
 src/sysdir.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/sysdir.c b/src/sysdir.c
index 2e6304e35..aebf23135 100644
--- a/src/sysdir.c
+++ b/src/sysdir.c
@@ -213,7 +213,7 @@ static int git_sysdir_find_in_dirlist(
 			return 0;
 	}
 
-	git_buf_clear(path);
+	git_buf_free(path);
 	giterr_set(GITERR_OS, "The %s file '%s' doesn't exist", label, name);
 	return GIT_ENOTFOUND;
 }
-- 
cgit v1.2.3


From be6996b792cea7a7371e07fb4efc86e5216f4f40 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 21 Apr 2014 15:25:02 +0200
Subject: It is safe to free() a NULL pointer

---
 src/push.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/push.c b/src/push.c
index 5c8de3339..bd4d872c5 100644
--- a/src/push.c
+++ b/src/push.c
@@ -677,9 +677,7 @@ void git_push_status_free(push_status *status)
 	if (status == NULL)
 		return;
 
-	if (status->msg)
-		git__free(status->msg);
-
+	git__free(status->msg);
 	git__free(status->ref);
 	git__free(status);
 }
-- 
cgit v1.2.3


From 8b686b318b60e39ef36aae14311c07e5b72a5a5a Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 21 Apr 2014 15:25:19 +0200
Subject: Correct argument order of git__calloc()

---
 src/transports/smart_protocol.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index cf67f9078..5dd6bab24 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -628,7 +628,7 @@ static int add_push_report_pkt(git_push *push, git_pkt *pkt)
 
 	switch (pkt->type) {
 		case GIT_PKT_OK:
-			status = git__calloc(1, sizeof(push_status));
+			status = git__calloc(sizeof(push_status), 1);
 			GITERR_CHECK_ALLOC(status);
 			status->msg = NULL;
 			status->ref = git__strdup(((git_pkt_ok *)pkt)->ref);
-- 
cgit v1.2.3


From 783993101949040865ea933eb73e35df806249b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 21 Apr 2014 16:38:52 +0200
Subject: attrcache: fix use-after-free

Reported by coverity.
---
 src/attrcache.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/attrcache.c b/src/attrcache.c
index 88b68ebb9..a750154ce 100644
--- a/src/attrcache.c
+++ b/src/attrcache.c
@@ -229,8 +229,8 @@ int git_attr_cache__get(
 	if (error < 0) {
 		/* remove existing entry */
 		if (file) {
-			git_attr_file__free(file); /* offset incref from lookup */
 			attr_cache_remove(cache, file);
+			git_attr_file__free(file); /* offset incref from lookup */
 			file = NULL;
 		}
 		/* no error if file simply doesn't exist */
-- 
cgit v1.2.3


From 321d377a6ad3528f38ab99dacf22a51f721fa57b Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 21 Apr 2014 17:02:05 +0200
Subject: Fire update_tips callback also for pushes.

---
 src/push.c | 46 +++++++++++++++++++++++++++++-----------------
 1 file changed, 29 insertions(+), 17 deletions(-)

diff --git a/src/push.c b/src/push.c
index bd4d872c5..9943f215c 100644
--- a/src/push.c
+++ b/src/push.c
@@ -208,9 +208,7 @@ int git_push_update_tips(
 	int error = 0;
 
 	git_vector_foreach(&push->status, i, status) {
-		/* If this ref update was successful (ok, not ng), it will have an empty message */
-		if (status->msg)
-			continue;
+		int fire_callback = 1;
 
 		/* Find the corresponding remote ref */
 		fetch_spec = git_remote__matching_refspec(push->remote, status->ref);
@@ -230,24 +228,38 @@ int git_push_update_tips(
 		if (j == push->specs.length)
 			continue;
 
-		/* Update the remote ref */
-		if (git_oid_iszero(&push_spec->loid)) {
-			error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name));
+		/* If this ref update was successful (ok, not ng), it will have an empty message */
+		if (status->msg == NULL) {
+			/* Update the remote ref */
+			if (git_oid_iszero(&push_spec->loid)) {
+				error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name));
 
-			if (!error) {
-				if ((error = git_reference_delete(remote_ref)) < 0) {
+				if (error >= 0) {
+					error = git_reference_delete(remote_ref);
 					git_reference_free(remote_ref);
-					goto on_error;
 				}
-				git_reference_free(remote_ref);
-			} else if (error == GIT_ENOTFOUND)
-				giterr_clear();
-			else
+			} else {
+				error = git_reference_create(NULL, push->remote->repo,
+							git_buf_cstr(&remote_ref_name), &push_spec->loid, 1, signature,
+							reflog_message ? reflog_message : "update by push");
+			}
+		}
+
+		if (error < 0) {
+			if (error != GIT_ENOTFOUND)
 				goto on_error;
-		} else if ((error = git_reference_create(NULL, push->remote->repo,
-						git_buf_cstr(&remote_ref_name), &push_spec->loid, 1, signature,
-						reflog_message ? reflog_message : "update by push")) < 0)
-			goto on_error;
+
+			giterr_clear();
+			fire_callback = 0;
+		}
+
+		if (fire_callback && push->remote->callbacks.update_tips) {
+			error = push->remote->callbacks.update_tips(git_buf_cstr(&remote_ref_name),
+						&push_spec->roid, &push_spec->loid, push->remote->callbacks.payload);
+
+			if (error < 0)
+				goto on_error;
+		}
 	}
 
 	error = 0;
-- 
cgit v1.2.3


From f70cfd34f5c20c447feb19c2e616315764ea7260 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Mon, 21 Apr 2014 17:49:38 +0200
Subject: Verify update_tips callbacks in push test cases

---
 tests/online/push.c | 118 ++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 83 insertions(+), 35 deletions(-)

diff --git a/tests/online/push.c b/tests/online/push.c
index 716e2e993..6da27bb96 100644
--- a/tests/online/push.c
+++ b/tests/online/push.c
@@ -254,8 +254,7 @@ static void verify_tracking_branches(git_remote *remote, expected_ref expected_r
 	}
 
 failed:
-
-	if(failed)
+	if (failed)
 		cl_fail(git_buf_cstr(&msg));
 
 	git_vector_foreach(&actual_refs, i, actual_ref)
@@ -264,7 +263,52 @@ failed:
 	git_vector_free(&actual_refs);
 	git_buf_free(&msg);
 	git_buf_free(&ref_name);
-	return;
+}
+
+static void verify_update_tips_callback(git_remote *remote, expected_ref expected_refs[], size_t expected_refs_len)
+{
+	git_refspec *fetch_spec;
+	git_buf msg = GIT_BUF_INIT;
+	git_buf ref_name = GIT_BUF_INIT;
+	updated_tip *tip = NULL;
+	size_t i, j;
+	int failed = 0;
+
+	for (i = 0; i < expected_refs_len; ++i) {
+		/* Convert remote reference name into tracking branch name.
+		 * If the spec is not under refs/heads/, then skip.
+		 */
+		fetch_spec = git_remote__matching_refspec(remote, expected_refs[i].name);
+		if (!fetch_spec)
+			continue;
+
+		cl_git_pass(git_refspec_transform(&ref_name, fetch_spec, expected_refs[i].name));
+
+		/* Find matching update_tip entry */
+		git_vector_foreach(&_record_cbs_data.updated_tips, j, tip) {
+			if (!strcmp(git_buf_cstr(&ref_name), tip->name))
+				break;
+		}
+
+		if (j == _record_cbs_data.updated_tips.length) {
+			git_buf_printf(&msg, "Did not find expected updated tip entry for branch '%s'.", git_buf_cstr(&ref_name));
+			failed = 1;
+			goto failed;
+		}
+
+		if (git_oid_cmp(expected_refs[i].oid, tip->new_oid) != 0) {
+			git_buf_printf(&msg, "Updated tip ID does not match expected ID");
+			failed = 1;
+			goto failed;
+		}
+	}
+
+failed:
+	if (failed)
+		cl_fail(git_buf_cstr(&msg));
+
+	git_buf_free(&ref_name);
+	git_buf_free(&msg);
 }
 
 void test_online_push__initialize(void)
@@ -409,7 +453,7 @@ static void do_push(
 	const char *refspecs[], size_t refspecs_len,
 	push_status expected_statuses[], size_t expected_statuses_len,
 	expected_ref expected_refs[], size_t expected_refs_len,
-	int expected_ret, int check_progress_cb)
+	int expected_ret, int check_progress_cb, int check_update_tips_cb)
 {
 	git_push *push;
 	git_push_options opts = GIT_PUSH_OPTIONS_INIT;
@@ -461,6 +505,9 @@ static void do_push(
 		cl_git_pass(git_push_update_tips(push, pusher, "test push"));
 		verify_tracking_branches(_remote, expected_refs, expected_refs_len);
 
+		if (check_update_tips_cb)
+			verify_update_tips_callback(_remote, expected_refs, expected_refs_len);
+
 		git_push_free(push);
 
 		git_remote_disconnect(_remote);
@@ -472,7 +519,7 @@ static void do_push(
 /* Call push_finish() without ever calling git_push_add_refspec() */
 void test_online_push__noop(void)
 {
-	do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0);
+	do_push(NULL, 0, NULL, 0, NULL, 0, 0, 0, 1);
 }
 
 void test_online_push__b1(void)
@@ -482,7 +529,7 @@ void test_online_push__b1(void)
 	expected_ref exp_refs[] = { { "refs/heads/b1", &_oid_b1 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__b2(void)
@@ -492,7 +539,7 @@ void test_online_push__b2(void)
 	expected_ref exp_refs[] = { { "refs/heads/b2", &_oid_b2 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__b3(void)
@@ -502,7 +549,7 @@ void test_online_push__b3(void)
 	expected_ref exp_refs[] = { { "refs/heads/b3", &_oid_b3 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__b4(void)
@@ -512,7 +559,7 @@ void test_online_push__b4(void)
 	expected_ref exp_refs[] = { { "refs/heads/b4", &_oid_b4 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__b5(void)
@@ -522,13 +569,13 @@ void test_online_push__b5(void)
 	expected_ref exp_refs[] = { { "refs/heads/b5", &_oid_b5 } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__b5_cancel(void)
 {
 	const char *specs[] = { "refs/heads/b5:refs/heads/b5" };
-	do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1);
+	do_push(specs, ARRAY_SIZE(specs), NULL, 0, NULL, 0, GIT_EUSER, 1, 1);
 }
 
 void test_online_push__multi(void)
@@ -559,7 +606,7 @@ void test_online_push__multi(void)
 	};
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 
 	cl_git_pass(git_reflog_read(&log, _repo, "refs/remotes/test/b1"));
 	entry = git_reflog_entry_byindex(log, 0);
@@ -586,10 +633,10 @@ void test_online_push__implicit_tgt(void)
 
 	do_push(specs1, ARRAY_SIZE(specs1),
 		exp_stats1, ARRAY_SIZE(exp_stats1),
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1);
 	do_push(specs2, ARRAY_SIZE(specs2),
 		exp_stats2, ARRAY_SIZE(exp_stats2),
-		exp_refs2, ARRAY_SIZE(exp_refs2), 0, 0);
+		exp_refs2, ARRAY_SIZE(exp_refs2), 0, 0, 0);
 }
 
 void test_online_push__fast_fwd(void)
@@ -611,19 +658,19 @@ void test_online_push__fast_fwd(void)
 
 	do_push(specs_init, ARRAY_SIZE(specs_init),
 		exp_stats_init, ARRAY_SIZE(exp_stats_init),
-		exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 1);
+		exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 1, 1);
 
 	do_push(specs_ff, ARRAY_SIZE(specs_ff),
 		exp_stats_ff, ARRAY_SIZE(exp_stats_ff),
-		exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0);
+		exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0);
 
 	do_push(specs_reset, ARRAY_SIZE(specs_reset),
 		exp_stats_init, ARRAY_SIZE(exp_stats_init),
-		exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 0);
+		exp_refs_init, ARRAY_SIZE(exp_refs_init), 0, 0, 0);
 
 	do_push(specs_ff_force, ARRAY_SIZE(specs_ff_force),
 		exp_stats_ff, ARRAY_SIZE(exp_stats_ff),
-		exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0);
+		exp_refs_ff, ARRAY_SIZE(exp_refs_ff), 0, 0, 0);
 }
 
 void test_online_push__tag_commit(void)
@@ -633,7 +680,7 @@ void test_online_push__tag_commit(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-commit", &_tag_commit } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__tag_tree(void)
@@ -643,7 +690,7 @@ void test_online_push__tag_tree(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-tree", &_tag_tree } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__tag_blob(void)
@@ -653,7 +700,7 @@ void test_online_push__tag_blob(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-blob", &_tag_blob } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__tag_lightweight(void)
@@ -663,7 +710,7 @@ void test_online_push__tag_lightweight(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-lightweight", &_tag_lightweight } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 }
 
 void test_online_push__tag_to_tag(void)
@@ -673,7 +720,7 @@ void test_online_push__tag_to_tag(void)
 	expected_ref exp_refs[] = { { "refs/tags/tag-tag", &_tag_tag } };
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 0);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 0, 0);
 }
 
 void test_online_push__force(void)
@@ -690,16 +737,17 @@ void test_online_push__force(void)
 
 	do_push(specs1, ARRAY_SIZE(specs1),
 		exp_stats1, ARRAY_SIZE(exp_stats1),
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1);
 
 	do_push(specs2, ARRAY_SIZE(specs2),
 		NULL, 0,
-		exp_refs1, ARRAY_SIZE(exp_refs1), GIT_ENONFASTFORWARD, 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), GIT_ENONFASTFORWARD, 0, 0);
 
 	/* Non-fast-forward update with force should pass. */
+	record_callbacks_data_clear(&_record_cbs_data);
 	do_push(specs2_force, ARRAY_SIZE(specs2_force),
 		exp_stats2_force, ARRAY_SIZE(exp_stats2_force),
-		exp_refs2_force, ARRAY_SIZE(exp_refs2_force), 0, 1);
+		exp_refs2_force, ARRAY_SIZE(exp_refs2_force), 0, 1, 1);
 }
 
 void test_online_push__delete(void)
@@ -730,7 +778,7 @@ void test_online_push__delete(void)
 
 	do_push(specs1, ARRAY_SIZE(specs1),
 		exp_stats1, ARRAY_SIZE(exp_stats1),
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 1, 1);
 
 	/* When deleting a non-existent branch, the git client sends zero for both
 	 * the old and new commit id.  This should succeed on the server with the
@@ -740,23 +788,23 @@ void test_online_push__delete(void)
 	 */
 	do_push(specs_del_fake, ARRAY_SIZE(specs_del_fake),
 		exp_stats_fake, 1,
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0);
 	do_push(specs_del_fake_force, ARRAY_SIZE(specs_del_fake_force),
 		exp_stats_fake, 1,
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0);
 
 	/* Delete one of the pushed branches. */
 	do_push(specs_delete, ARRAY_SIZE(specs_delete),
 		exp_stats_delete, ARRAY_SIZE(exp_stats_delete),
-		exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0);
+		exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0);
 
 	/* Re-push branches and retry delete with force. */
 	do_push(specs1, ARRAY_SIZE(specs1),
 		exp_stats1, ARRAY_SIZE(exp_stats1),
-		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0);
+		exp_refs1, ARRAY_SIZE(exp_refs1), 0, 0, 0);
 	do_push(specs_delete_force, ARRAY_SIZE(specs_delete_force),
 		exp_stats_delete, ARRAY_SIZE(exp_stats_delete),
-		exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0);
+		exp_refs_delete, ARRAY_SIZE(exp_refs_delete), 0, 0, 0);
 }
 
 void test_online_push__bad_refspecs(void)
@@ -790,11 +838,11 @@ void test_online_push__expressions(void)
 	/* TODO: Find a more precise way of checking errors than a exit code of -1. */
 	do_push(specs_left_expr, ARRAY_SIZE(specs_left_expr),
 		NULL, 0,
-		NULL, 0, -1, 0);
+		NULL, 0, -1, 0, 0);
 
 	do_push(specs_right_expr, ARRAY_SIZE(specs_right_expr),
 		exp_stats_right_expr, ARRAY_SIZE(exp_stats_right_expr),
-		NULL, 0, 0, 1);
+		NULL, 0, 0, 1, 1);
 }
 
 void test_online_push__notes(void)
@@ -814,7 +862,7 @@ void test_online_push__notes(void)
 
 	do_push(specs, ARRAY_SIZE(specs),
 		exp_stats, ARRAY_SIZE(exp_stats),
-		exp_refs, ARRAY_SIZE(exp_refs), 0, 1);
+		exp_refs, ARRAY_SIZE(exp_refs), 0, 1, 1);
 
 	git_signature_free(signature);
 }
-- 
cgit v1.2.3


From bd101a7eca6907ab1dd57ae693059466df0da124 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 21 Apr 2014 11:54:54 -0700
Subject: Fix reset for staged deletes

---
 src/reset.c           | 11 ++++++++---
 tests/reset/default.c | 39 +++++++++++++++++++++++++++++++++++++--
 2 files changed, 45 insertions(+), 5 deletions(-)

diff --git a/src/reset.c b/src/reset.c
index e403e2a9a..248c91d3a 100644
--- a/src/reset.c
+++ b/src/reset.c
@@ -60,13 +60,18 @@ int git_reset_default(
 	for (i = 0, max_i = git_diff_num_deltas(diff); i < max_i; ++i) {
 		const git_diff_delta *delta = git_diff_get_delta(diff, i);
 
-		if ((error = git_index_conflict_remove(index, delta->old_file.path)) < 0)
-			goto cleanup;
-
 		assert(delta->status == GIT_DELTA_ADDED ||
 			delta->status == GIT_DELTA_MODIFIED ||
 			delta->status == GIT_DELTA_DELETED);
 
+		error = git_index_conflict_remove(index, delta->old_file.path);
+		if (error < 0) {
+			if (delta->status == GIT_DELTA_ADDED && error == GIT_ENOTFOUND)
+				giterr_clear();
+			else
+				goto cleanup;
+		}
+
 		if (delta->status == GIT_DELTA_DELETED) {
 			if ((error = git_index_remove(index, delta->old_file.path, 0)) < 0)
 				goto cleanup;
diff --git a/tests/reset/default.c b/tests/reset/default.c
index 57a3f7c51..ecb3e7f9f 100644
--- a/tests/reset/default.c
+++ b/tests/reset/default.c
@@ -21,7 +21,6 @@ static void initialize(const char *repo_name)
 
 void test_reset_default__initialize(void)
 {
-	initialize("status");
 }
 
 void test_reset_default__cleanup(void)
@@ -67,6 +66,8 @@ void test_reset_default__resetting_filepaths_against_a_null_target_removes_them_
 {
 	char *paths[] = { "staged_changes", "staged_new_file" };
 
+	initialize("status");
+
 	_pathspecs.strings = paths;
 	_pathspecs.count = 2;
 
@@ -102,6 +103,8 @@ void test_reset_default__resetting_filepaths_replaces_their_corresponding_index_
 	char *after_shas[] = { "32504b727382542f9f089e24fddac5e78533e96c",
 		"061d42a44cacde5726057b67558821d95db96f19" };
 
+	initialize("status");
+
 	_pathspecs.strings = paths;
 	_pathspecs.count = 2;
 	before.strings = before_shas;
@@ -139,7 +142,6 @@ void test_reset_default__resetting_filepaths_clears_previous_conflicts(void)
 	char *paths[] = { "conflicts-one.txt" };
 	char *after_shas[] = { "1f85ca51b8e0aac893a621b61a9c2661d6aa6d81" };
 
-	test_reset_default__cleanup();
 	initialize("mergedrepo");
 
 	_pathspecs.strings = paths;
@@ -168,6 +170,8 @@ void test_reset_default__resetting_unknown_filepaths_does_not_fail(void)
 {
 	char *paths[] = { "I_am_not_there.txt", "me_neither.txt" };
 
+	initialize("status");
+
 	_pathspecs.strings = paths;
 	_pathspecs.count = 2;
 
@@ -178,3 +182,34 @@ void test_reset_default__resetting_unknown_filepaths_does_not_fail(void)
 
 	assert_content_in_index(&_pathspecs, false, NULL);
 }
+
+void test_reset_default__staged_rename_reset_delete(void)
+{
+	git_index *idx;
+	git_index_entry entry;
+	const git_index_entry *existing;
+	char *paths[] = { "new.txt" };
+
+	initialize("testrepo2");
+
+	cl_git_pass(git_repository_index(&idx, _repo));
+
+	existing = git_index_get_bypath(idx, "new.txt", 0);
+	cl_assert(existing);
+	memcpy(&entry, existing, sizeof(entry));
+
+	cl_git_pass(git_index_remove_bypath(idx, "new.txt"));
+
+	entry.path = "renamed.txt";
+	cl_git_pass(git_index_add(idx, &entry));
+
+	_pathspecs.strings = paths;
+	_pathspecs.count = 1;
+
+	assert_content_in_index(&_pathspecs, false, NULL);
+
+	cl_git_pass(git_revparse_single(&_target, _repo, "HEAD"));
+	cl_git_pass(git_reset_default(_repo, _target, &_pathspecs));
+
+	assert_content_in_index(&_pathspecs, true, NULL);
+}
-- 
cgit v1.2.3


From 17ef678ca543d8b56035e36039ee319c12d0d249 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 21 Apr 2014 11:55:57 -0700
Subject: Fix some coverity-found issues

---
 src/attr_file.c | 13 ++++++-------
 src/attrcache.c | 10 ++++------
 src/ignore.c    |  6 +++---
 src/index.c     |  5 +++--
 4 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/src/attr_file.c b/src/attr_file.c
index d107b5ab0..156a23d91 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -232,15 +232,14 @@ int git_attr_file__parse_buffer(
 
 	while (!error && *scan) {
 		/* allocate rule if needed */
-		if (!rule) {
-			if (!(rule = git__calloc(1, sizeof(*rule)))) {
-				error = -1;
-				break;
-			}
-			rule->match.flags = GIT_ATTR_FNMATCH_ALLOWNEG |
-				GIT_ATTR_FNMATCH_ALLOWMACRO;
+		if (!rule && !(rule = git__calloc(1, sizeof(*rule)))) {
+			error = -1;
+			break;
 		}
 
+		rule->match.flags =
+			GIT_ATTR_FNMATCH_ALLOWNEG | GIT_ATTR_FNMATCH_ALLOWMACRO;
+
 		/* parse the next "pattern attr attr attr" line */
 		if (!(error = git_attr_fnmatch__parse(
 				&rule->match, &attrs->pool, context, &scan)) &&
diff --git a/src/attrcache.c b/src/attrcache.c
index a750154ce..f1bc70467 100644
--- a/src/attrcache.c
+++ b/src/attrcache.c
@@ -176,10 +176,9 @@ static int attr_cache_lookup(
 		goto cleanup;
 
 	entry = attr_cache_lookup_entry(cache, relfile);
-	if (!entry) {
-		if ((error = attr_cache_make_entry(&entry, repo, relfile)) < 0)
-			goto cleanup;
-	} else if (entry->file[source] != NULL) {
+	if (!entry)
+		error = attr_cache_make_entry(&entry, repo, relfile);
+	else if (entry->file[source] != NULL) {
 		file = entry->file[source];
 		GIT_REFCOUNT_INC(file);
 	}
@@ -254,8 +253,7 @@ bool git_attr_cache__is_cached(
 	khiter_t pos;
 	git_attr_file_entry *entry;
 
-	if (!(cache = git_repository_attr_cache(repo)) ||
-		!(files = cache->files))
+	if (!cache || !(files = cache->files))
 		return false;
 
 	pos = git_strmap_lookup_index(files, filename);
diff --git a/src/ignore.c b/src/ignore.c
index b08ff2200..f373c9482 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -32,9 +32,9 @@ static int parse_ignore_file(
 	}
 
 	while (!error && *scan) {
-		if (!match) {
-			match = git__calloc(1, sizeof(*match));
-			GITERR_CHECK_ALLOC(match);
+		if (!match && !(match = git__calloc(1, sizeof(*match)))) {
+			error = -1;
+			break;
 		}
 
 		match->flags = GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG;
diff --git a/src/index.c b/src/index.c
index 083c01fe4..c044af402 100644
--- a/src/index.c
+++ b/src/index.c
@@ -1880,8 +1880,9 @@ static int parse_index(git_index *index, const char *buffer, size_t buffer_size)
 	git_oid checksum_calculated, checksum_expected;
 
 #define seek_forward(_increase) { \
-	if (_increase >= buffer_size) \
-		return index_error_invalid("ran out of data while parsing"); \
+	if (_increase >= buffer_size) { \
+		error = index_error_invalid("ran out of data while parsing"); \
+		goto done; } \
 	buffer += _increase; \
 	buffer_size -= _increase;\
 }
-- 
cgit v1.2.3


From 65477db1660273c453c590b8e3b97a4f7c41df61 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Mon, 21 Apr 2014 23:32:31 -0400
Subject: Handle win32 reparse points properly

---
 src/win32/posix.h     |   2 +-
 src/win32/posix_w32.c | 333 +++++++++++++++++-----------
 src/win32/reparse.h   |  57 +++++
 src/win32/w32_util.c  |  70 ++++++
 src/win32/w32_util.h  |  23 ++
 tests/clar_libgit2.h  |  11 +
 tests/core/link.c     | 602 ++++++++++++++++++++++++++++++++++++++++++++++++++
 7 files changed, 966 insertions(+), 132 deletions(-)
 create mode 100644 src/win32/reparse.h
 create mode 100644 tests/core/link.c

diff --git a/src/win32/posix.h b/src/win32/posix.h
index e5a32b510..7f9d57cc3 100644
--- a/src/win32/posix.h
+++ b/src/win32/posix.h
@@ -30,7 +30,7 @@ GIT_INLINE(int) p_link(const char *old, const char *new)
 extern int p_mkdir(const char *path, mode_t mode);
 extern int p_unlink(const char *path);
 extern int p_lstat(const char *file_name, struct stat *buf);
-extern int p_readlink(const char *link, char *target, size_t target_len);
+extern int p_readlink(const char *path, char *buf, size_t bufsiz);
 extern int p_symlink(const char *old, const char *new);
 extern char *p_realpath(const char *orig_path, char *buffer);
 extern int p_vsnprintf(char *buffer, size_t count, const char *format, va_list argptr);
diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c
index 868be6017..bef65a354 100644
--- a/src/win32/posix_w32.c
+++ b/src/win32/posix_w32.c
@@ -9,12 +9,13 @@
 #include "path.h"
 #include "utf-conv.h"
 #include "repository.h"
+#include "reparse.h"
 #include <errno.h>
 #include <io.h>
 #include <fcntl.h>
 #include <ws2tcpip.h>
 
-#if defined(__MINGW32__)
+#ifndef FILE_NAME_NORMALIZED
 # define FILE_NAME_NORMALIZED 0
 #endif
 
@@ -100,29 +101,79 @@ GIT_INLINE(time_t) filetime_to_time_t(const FILETIME *ft)
 	return (time_t)winTime;
 }
 
-#define WIN32_IS_WSEP(CH) ((CH) == L'/' || (CH) == L'\\')
-
-static int do_lstat(
-	const char *file_name, struct stat *buf, int posix_enotdir)
+/* On success, returns the length, in characters, of the path stored in dest.
+ * On failure, returns a negative value. */
+static int readlink_w(
+	git_win32_path dest,
+	const git_win32_path path)
 {
-	WIN32_FILE_ATTRIBUTE_DATA fdata;
-	git_win32_path fbuf;
-	wchar_t lastch;
-	int flen;
+	BYTE buf[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
+	GIT_REPARSE_DATA_BUFFER *reparse_buf = (GIT_REPARSE_DATA_BUFFER *)buf;
+	HANDLE handle = NULL;
+	DWORD ioctl_ret;
+	wchar_t *target;
+	size_t target_len;
+
+	int error = -1;
 
-	if ((flen = utf8_to_16_with_errno(fbuf, file_name)) < 0)
+	handle = CreateFileW(path, GENERIC_READ,
+		FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING,
+		FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);
+
+	if (INVALID_HANDLE_VALUE == handle) {
+		errno = ENOENT;
 		return -1;
+	}
 
-	/* truncate trailing slashes */
-	for (; flen > 0; --flen) {
-		lastch = fbuf[flen - 1];
-		if (WIN32_IS_WSEP(lastch))
-			fbuf[flen - 1] = L'\0';
-		else if (lastch != L'\0')
-			break;
+	if (!DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, NULL, 0,
+		reparse_buf, sizeof(buf), &ioctl_ret, NULL)) {
+		errno = EINVAL;
+		goto on_error;
 	}
 
-	if (GetFileAttributesExW(fbuf, GetFileExInfoStandard, &fdata)) {
+	switch (reparse_buf->ReparseTag) {
+	case IO_REPARSE_TAG_SYMLINK:
+		target = reparse_buf->SymbolicLinkReparseBuffer.PathBuffer +
+			(reparse_buf->SymbolicLinkReparseBuffer.SubstituteNameOffset / sizeof(WCHAR));
+		target_len = reparse_buf->SymbolicLinkReparseBuffer.SubstituteNameLength / sizeof(WCHAR);
+		break;
+	case IO_REPARSE_TAG_MOUNT_POINT:
+		target = reparse_buf->MountPointReparseBuffer.PathBuffer +
+			(reparse_buf->MountPointReparseBuffer.SubstituteNameOffset / sizeof(WCHAR));
+		target_len = reparse_buf->MountPointReparseBuffer.SubstituteNameLength / sizeof(WCHAR);
+		break;
+	default:
+		errno = EINVAL;
+		goto on_error;
+	}
+
+	if (target_len) {
+		/* The path may need to have a prefix removed. */
+		target_len = git_win32__to_dos(target, target_len);
+
+		/* Need one additional character in the target buffer
+		 * for the terminating NULL. */
+		if (GIT_WIN_PATH_UTF16 > target_len) {
+			wcscpy(dest, target);
+			error = (int)target_len;
+		}
+	}
+
+on_error:
+	CloseHandle(handle);
+	return error;
+}
+
+#define WIN32_IS_WSEP(CH) ((CH) == L'/' || (CH) == L'\\')
+
+static int lstat_w(
+	wchar_t *path,
+	struct stat *buf,
+	bool posix_enotdir)
+{
+	WIN32_FILE_ATTRIBUTE_DATA fdata;
+
+	if (GetFileAttributesExW(path, GetFileExInfoStandard, &fdata)) {
 		int fMode = S_IREAD;
 
 		if (!buf)
@@ -136,12 +187,6 @@ static int do_lstat(
 		if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_READONLY))
 			fMode |= S_IWRITE;
 
-		if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
-			fMode |= S_IFLNK;
-
-		if ((fMode & (S_IFDIR | S_IFLNK)) == (S_IFDIR | S_IFLNK)) // junction
-			fMode ^= S_IFLNK;
-
 		buf->st_ino = 0;
 		buf->st_gid = 0;
 		buf->st_uid = 0;
@@ -153,16 +198,17 @@ static int do_lstat(
 		buf->st_mtime = filetime_to_time_t(&(fdata.ftLastWriteTime));
 		buf->st_ctime = filetime_to_time_t(&(fdata.ftCreationTime));
 
-		/* Windows symlinks have zero file size, call readlink to determine
-		 * the length of the path pointed to, which we expect everywhere else
-		 */
-		if (S_ISLNK(fMode)) {
-			git_win32_utf8_path target;
+		if (fdata.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) {
+			git_win32_path target;
 
-			if (p_readlink(file_name, target, GIT_WIN_PATH_UTF8) == -1)
-				return -1;
+			if (readlink_w(target, path) >= 0) {
+				buf->st_mode = (buf->st_mode & ~S_IFMT) | S_IFLNK;
 
-			buf->st_size = strlen(target);
+				/* st_size gets the UTF-8 length of the target name, in bytes,
+				 * not counting the NULL terminator */
+				if ((buf->st_size = git__utf16_to_8(NULL, 0, target)) < 0)
+					return -1;
+			}
 		}
 
 		return 0;
@@ -174,18 +220,23 @@ static int do_lstat(
 	 * file path is a regular file, otherwise set ENOENT.
 	 */
 	if (posix_enotdir) {
+		size_t path_len = wcslen(path);
+
 		/* scan up path until we find an existing item */
 		while (1) {
+			DWORD attrs;
+
 			/* remove last directory component */
-			for (--flen; flen > 0 && !WIN32_IS_WSEP(fbuf[flen]); --flen);
+			for (path_len--; path_len > 0 && !WIN32_IS_WSEP(path[path_len]); path_len--);
 
-			if (flen <= 0)
+			if (path_len <= 0)
 				break;
 
-			fbuf[flen] = L'\0';
+			path[path_len] = L'\0';
+			attrs = GetFileAttributesW(path);
 
-			if (GetFileAttributesExW(fbuf, GetFileExInfoStandard, &fdata)) {
-				if (!(fdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+			if (INVALID_FILE_ATTRIBUTES != attrs) {
+				if (!(attrs & FILE_ATTRIBUTE_DIRECTORY))
 					errno = ENOTDIR;
 				break;
 			}
@@ -195,105 +246,51 @@ static int do_lstat(
 	return -1;
 }
 
-int p_lstat(const char *filename, struct stat *buf)
+static int do_lstat(const char *path, struct stat *buf, bool posixly_correct)
 {
-	return do_lstat(filename, buf, 0);
+	git_win32_path path_w;
+	int len;
+
+	if ((len = utf8_to_16_with_errno(path_w, path)) < 0)
+		return -1;
+
+	git_win32__path_trim_end(path_w, len);
+
+	return lstat_w(path_w, buf, posixly_correct);
 }
 
-int p_lstat_posixly(const char *filename, struct stat *buf)
+int p_lstat(const char *filename, struct stat *buf)
 {
-	return do_lstat(filename, buf, 1);
+	return do_lstat(filename, buf, false);
 }
 
-/*
- * Returns the address of the GetFinalPathNameByHandleW function.
- * This function is available on Windows Vista and higher.
- */
-static PFGetFinalPathNameByHandleW get_fpnbyhandle(void)
+int p_lstat_posixly(const char *filename, struct stat *buf)
 {
-	static PFGetFinalPathNameByHandleW pFunc = NULL;
-	PFGetFinalPathNameByHandleW toReturn = pFunc;
-
-	if (!toReturn) {
-		HMODULE hModule = GetModuleHandleW(L"kernel32");
-
-		if (hModule)
-			toReturn = (PFGetFinalPathNameByHandleW)GetProcAddress(hModule, "GetFinalPathNameByHandleW");
-
-		pFunc = toReturn;
-	}
-
-	assert(toReturn);
-
-	return toReturn;
+	return do_lstat(filename, buf, true);
 }
 
-/*
- * Parts of the The p_readlink function are heavily inspired by the php 
- * readlink function in link_win32.c
- *
- * Copyright (c) 1999 - 2012 The PHP Group. All rights reserved.
- *
- * For details of the PHP license see http://www.php.net/license/3_01.txt
- */
-int p_readlink(const char *link, char *target, size_t target_len)
+int p_readlink(const char *path, char *buf, size_t bufsiz)
 {
-	static const wchar_t prefix[] = L"\\\\?\\";
-	PFGetFinalPathNameByHandleW pgfp = get_fpnbyhandle();
-	HANDLE hFile = NULL;
-	wchar_t *target_w = NULL;
-	bool trim_prefix;
-	git_win32_path link_w;
-	DWORD dwChars, dwLastError;
-	int error = -1;
-
-	/* Check that we found the function, and convert to UTF-16 */
-	if (!pgfp || utf8_to_16_with_errno(link_w, link) < 0)
-		goto on_error;
-
-	/* Use FILE_FLAG_BACKUP_SEMANTICS so we can open a directory. Do not
-	 * specify FILE_FLAG_OPEN_REPARSE_POINT; we want to open a handle to the
-	 * target of the link. */
-	hFile = CreateFileW(link_w, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE,
-		NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
-
-	if (hFile == INVALID_HANDLE_VALUE)
-		goto on_error;
-
-	/* Find out how large the buffer should be to hold the result */
-	if (!(dwChars = pgfp(hFile, NULL, 0, FILE_NAME_NORMALIZED)))
-		goto on_error;
-
-	if (!(target_w = git__malloc(dwChars * sizeof(wchar_t))))
-		goto on_error;
-
-	/* Call a second time */
-	dwChars = pgfp(hFile, target_w, dwChars, FILE_NAME_NORMALIZED);
-
-	if (!dwChars)
-		goto on_error;
-
-	/* Do we need to trim off a \\?\ from the start of the path? */
-	trim_prefix = (dwChars >= ARRAY_SIZE(prefix)) &&
-		!wcsncmp(prefix, target_w, ARRAY_SIZE(prefix));
-
-	/* Convert the result to UTF-8 */
-	if (git__utf16_to_8(target, target_len, trim_prefix ? target_w + 4 : target_w) < 0)
-		goto on_error;
+	git_win32_path path_w, target_w;
+	git_win32_utf8_path target;
+	int len;
 
-	error = 0;
+	/* readlink(2) does not NULL-terminate the string written
+	 * to the target buffer. Furthermore, the target buffer need
+	 * not be large enough to hold the entire result. A truncated
+	 * result should be written in this case. Since this truncation
+	 * could occur in the middle of the encoding of a code point,
+	 * we need to buffer the result on the stack. */
 
-on_error:
-	dwLastError = GetLastError();
-
-	if (hFile && INVALID_HANDLE_VALUE != hFile)
-		CloseHandle(hFile);
+	if (utf8_to_16_with_errno(path_w, path) < 0 ||
+		readlink_w(target_w, path_w) < 0 ||
+		(len = git_win32_path_to_utf8(target, target_w)) < 0)
+		return -1;
 
-	if (target_w)
-		git__free(target_w);
+	bufsiz = min((size_t)len, bufsiz);
+	memcpy(buf, target, bufsiz);
 
-	SetLastError(dwLastError);
-	return error;
+	return (int)bufsiz;
 }
 
 int p_symlink(const char *old, const char *new)
@@ -356,20 +353,94 @@ int p_getcwd(char *buffer_out, size_t size)
 	return 0;
 }
 
+/*
+ * Returns the address of the GetFinalPathNameByHandleW function.
+ * This function is available on Windows Vista and higher.
+ */
+static PFGetFinalPathNameByHandleW get_fpnbyhandle(void)
+{
+	static PFGetFinalPathNameByHandleW pFunc = NULL;
+	PFGetFinalPathNameByHandleW toReturn = pFunc;
+
+	if (!toReturn) {
+		HMODULE hModule = GetModuleHandleW(L"kernel32");
+
+		if (hModule)
+			toReturn = (PFGetFinalPathNameByHandleW)GetProcAddress(hModule, "GetFinalPathNameByHandleW");
+
+		pFunc = toReturn;
+	}
+
+	assert(toReturn);
+
+	return toReturn;
+}
+
+static int getfinalpath_w(
+	git_win32_path dest,
+	const wchar_t *path)
+{
+	PFGetFinalPathNameByHandleW pgfp = get_fpnbyhandle();
+	HANDLE hFile;
+	DWORD dwChars;
+
+	if (!pgfp)
+		return -1;
+
+	/* Use FILE_FLAG_BACKUP_SEMANTICS so we can open a directory. Do not
+	* specify FILE_FLAG_OPEN_REPARSE_POINT; we want to open a handle to the
+	* target of the link. */
+	hFile = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE,
+		NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+
+	if (hFile == INVALID_HANDLE_VALUE)
+		return -1;
+
+	/* Call GetFinalPathNameByHandle */
+	dwChars = pgfp(hFile, dest, GIT_WIN_PATH_UTF16, FILE_NAME_NORMALIZED);
+
+	if (!dwChars || dwChars >= GIT_WIN_PATH_UTF16) {
+		DWORD error = GetLastError();
+		CloseHandle(hFile);
+		SetLastError(error);
+		return -1;
+	}
+
+	CloseHandle(hFile);
+
+	/* The path may be delivered to us with a prefix; canonicalize */
+	return (int)git_win32__to_dos(dest, dwChars);
+}
+
+static int follow_and_lstat_link(git_win32_path path, struct stat* buf)
+{
+	git_win32_path target_w;
+
+	if (getfinalpath_w(target_w, path) < 0)
+		return -1;
+
+	return lstat_w(target_w, buf, false);
+}
+
 int p_stat(const char* path, struct stat* buf)
 {
-	git_win32_utf8_path target;
-	int error = 0;
+	git_win32_path path_w;
+	int len;
 
-	error = do_lstat(path, buf, 0);
+	if ((len = utf8_to_16_with_errno(path_w, path)) < 0)
+		return -1;
 
-	/* We need not do this in a loop to unwind chains of symlinks since
-	 * p_readlink calls GetFinalPathNameByHandle which does it for us. */
-	if (error >= 0 && S_ISLNK(buf->st_mode) &&
-		(error = p_readlink(path, target, GIT_WIN_PATH_UTF8)) >= 0)
-		error = do_lstat(target, buf, 0);
+	git_win32__path_trim_end(path_w, len);
 
-	return error;
+	if (lstat_w(path_w, buf, false) < 0)
+		return -1;
+
+	/* The item is a symbolic link or mount point. No need to iterate
+	 * to follow multiple links; use GetFinalPathNameFromHandle. */
+	if (S_ISLNK(buf->st_mode))
+		return follow_and_lstat_link(path_w, buf);
+
+	return 0;
 }
 
 int p_chdir(const char* path)
diff --git a/src/win32/reparse.h b/src/win32/reparse.h
new file mode 100644
index 000000000..4f56ed055
--- /dev/null
+++ b/src/win32/reparse.h
@@ -0,0 +1,57 @@
+/*
+* Copyright (C) the libgit2 contributors. All rights reserved.
+*
+* This file is part of libgit2, distributed under the GNU GPL v2 with
+* a Linking Exception. For full terms see the included COPYING file.
+*/
+
+#ifndef INCLUDE_git_win32_reparse_h__
+#define INCLUDE_git_win32_reparse_h__
+
+/* This structure is defined on MSDN at
+* http://msdn.microsoft.com/en-us/library/windows/hardware/ff552012(v=vs.85).aspx
+*
+* It was formerly included in the Windows 2000 SDK and remains defined in
+* MinGW, so we must define it with a silly name to avoid conflicting.
+*/
+typedef struct _GIT_REPARSE_DATA_BUFFER {
+	ULONG  ReparseTag;
+	USHORT ReparseDataLength;
+	USHORT Reserved;
+	union {
+		struct {
+			USHORT SubstituteNameOffset;
+			USHORT SubstituteNameLength;
+			USHORT PrintNameOffset;
+			USHORT PrintNameLength;
+			ULONG  Flags;
+			WCHAR  PathBuffer[1];
+		} SymbolicLinkReparseBuffer;
+		struct {
+			USHORT SubstituteNameOffset;
+			USHORT SubstituteNameLength;
+			USHORT PrintNameOffset;
+			USHORT PrintNameLength;
+			WCHAR  PathBuffer[1];
+		} MountPointReparseBuffer;
+		struct {
+			UCHAR DataBuffer[1];
+		} GenericReparseBuffer;
+	};
+} GIT_REPARSE_DATA_BUFFER;
+
+#define REPARSE_DATA_HEADER_SIZE			8
+#define REPARSE_DATA_MOUNTPOINT_HEADER_SIZE	8
+#define REPARSE_DATA_UNION_SIZE				12
+
+/* Missing in MinGW */
+#ifndef FSCTL_GET_REPARSE_POINT
+# define FSCTL_GET_REPARSE_POINT			0x000900a8
+#endif
+
+/* Missing in MinGW */
+#ifndef FSCTL_SET_REPARSE_POINT
+# define FSCTL_SET_REPARSE_POINT			0x000900a4
+#endif
+
+#endif
\ No newline at end of file
diff --git a/src/win32/w32_util.c b/src/win32/w32_util.c
index 246b30a6b..50b85a334 100644
--- a/src/win32/w32_util.c
+++ b/src/win32/w32_util.c
@@ -7,6 +7,8 @@
 
 #include "w32_util.h"
 
+#define CONST_STRLEN(x) ((sizeof(x)/sizeof(x[0])) - 1)
+
 /**
  * Creates a FindFirstFile(Ex) filter string from a UTF-8 path.
  * The filter string enumerates all items in the directory.
@@ -67,3 +69,71 @@ int git_win32__sethidden(const char *path)
 
 	return 0;
 }
+
+/**
+ * Removes any trailing backslashes from a path, except in the case of a drive
+ * letter path (C:\, D:\, etc.). This function cannot fail.
+ *
+ * @param path The path which should be trimmed.
+ * @return The length of the modified string (<= the input length)
+ */
+size_t git_win32__path_trim_end(wchar_t *str, size_t len)
+{
+	while (1) {
+		if (!len || str[len - 1] != L'\\')
+			break;
+
+		/* Don't trim backslashes from drive letter paths, which
+		 * are 3 characters long and of the form C:\, D:\, etc. */
+		if (3 == len && git_win32__isalpha(str[0]) && str[1] == ':')
+			break;
+
+		len--;
+	}
+
+	str[len] = L'\0';
+
+	return len;
+}
+
+/**
+ * Removes any of the following namespace prefixes from a path,
+ * if found: "\??\", "\\?\", "\\?\UNC\". This function cannot fail.
+ *
+ * @param path The path which should be converted.
+ * @return The length of the modified string (<= the input length)
+ */
+size_t git_win32__to_dos(wchar_t *str, size_t len)
+{
+	static const wchar_t dosdevices_prefix[] = L"\\\?\?\\";
+	static const wchar_t nt_prefix[] = L"\\\\?\\";
+	static const wchar_t unc_prefix[] = L"UNC\\";
+	size_t to_advance = 0;
+
+	/* "\??\" -- DOS Devices prefix */
+	if (len >= CONST_STRLEN(dosdevices_prefix) &&
+		!wcsncmp(str, dosdevices_prefix, CONST_STRLEN(dosdevices_prefix))) {
+		to_advance += CONST_STRLEN(dosdevices_prefix);
+		len -= CONST_STRLEN(dosdevices_prefix);
+	}
+	/* "\\?\" -- NT namespace prefix */
+	else if (len >= CONST_STRLEN(nt_prefix) &&
+		!wcsncmp(str, nt_prefix, CONST_STRLEN(nt_prefix))) {
+		to_advance += CONST_STRLEN(nt_prefix);
+		len -= CONST_STRLEN(nt_prefix);
+	}
+
+	/* "\??\UNC\", "\\?\UNC\" -- UNC prefix */
+	if (to_advance && len >= CONST_STRLEN(unc_prefix) &&
+		!wcsncmp(str + to_advance, unc_prefix, CONST_STRLEN(unc_prefix))) {
+		to_advance += CONST_STRLEN(unc_prefix);
+		len -= CONST_STRLEN(unc_prefix);
+	}
+
+	if (to_advance) {
+		memmove(str, str + to_advance, len * sizeof(wchar_t));
+		str[len] = L'\0';
+	}
+
+	return git_win32__path_trim_end(str, len);
+}
\ No newline at end of file
diff --git a/src/win32/w32_util.h b/src/win32/w32_util.h
index cd02bd7b2..acdee3d69 100644
--- a/src/win32/w32_util.h
+++ b/src/win32/w32_util.h
@@ -10,6 +10,11 @@
 
 #include "utf-conv.h"
 
+GIT_INLINE(bool) git_win32__isalpha(wchar_t c)
+{
+	return ((c >= L'A' && c <= L'Z') || (c >= L'a' && c <= L'z'));
+}
+
 /**
  * Creates a FindFirstFile(Ex) filter string from a UTF-8 path.
  * The filter string enumerates all items in the directory.
@@ -28,4 +33,22 @@ bool git_win32__findfirstfile_filter(git_win32_path dest, const char *src);
  */
 int git_win32__sethidden(const char *path);
 
+/**
+ * Removes any trailing backslashes from a path, except in the case of a drive
+ * letter path (C:\, D:\, etc.). This function cannot fail.
+ *
+ * @param path The path which should be trimmed.
+ * @return The length of the modified string (<= the input length)
+ */
+size_t git_win32__path_trim_end(wchar_t *str, size_t len);
+
+/**
+ * Removes any of the following namespace prefixes from a path,
+ * if found: "\??\", "\\?\", "\\?\UNC\". This function cannot fail.
+ *
+ * @param path The path which should be converted.
+ * @return The length of the modified string (<= the input length)
+ */
+size_t git_win32__to_dos(wchar_t *str, size_t len);
+
 #endif
diff --git a/tests/clar_libgit2.h b/tests/clar_libgit2.h
index d395bd66f..082fa9f4a 100644
--- a/tests/clar_libgit2.h
+++ b/tests/clar_libgit2.h
@@ -29,6 +29,17 @@
 
 #define cl_git_fail_with(expr, error) cl_assert_equal_i(error,expr)
 
+/**
+ * Like cl_git_pass, only for Win32 error code conventions
+ */
+#define cl_win32_pass(expr) do { \
+	int _win32_res; \
+	if ((_win32_res = (expr)) == 0) { \
+		giterr_set(GITERR_OS, "Returned: %d, system error code: %d", _win32_res, GetLastError()); \
+		cl_git_report_failure(_win32_res, __FILE__, __LINE__, "System call failed: " #expr); \
+	} \
+	} while(0)
+
 void cl_git_report_failure(int, const char *, int, const char *);
 
 #define cl_assert_at_line(expr,file,line) \
diff --git a/tests/core/link.c b/tests/core/link.c
new file mode 100644
index 000000000..20d2706f7
--- /dev/null
+++ b/tests/core/link.c
@@ -0,0 +1,602 @@
+#include "clar_libgit2.h"
+#include "posix.h"
+#include "buffer.h"
+#include "path.h"
+
+#ifdef GIT_WIN32
+# include "win32/reparse.h"
+#endif
+
+void test_core_link__cleanup(void)
+{
+#ifdef GIT_WIN32
+	RemoveDirectory("lstat_junction");
+	RemoveDirectory("lstat_dangling");
+	RemoveDirectory("lstat_dangling_dir");
+	RemoveDirectory("lstat_dangling_junction");
+
+	RemoveDirectory("stat_junction");
+	RemoveDirectory("stat_dangling");
+	RemoveDirectory("stat_dangling_dir");
+	RemoveDirectory("stat_dangling_junction");
+#endif
+}
+
+#ifdef GIT_WIN32
+static bool is_administrator(void)
+{
+	static SID_IDENTIFIER_AUTHORITY authority = { SECURITY_NT_AUTHORITY };
+	PSID admin_sid;
+	BOOL is_admin;
+
+	cl_win32_pass(AllocateAndInitializeSid(&authority, 2, SECURITY_BUILTIN_DOMAIN_RID, DOMAIN_ALIAS_RID_ADMINS, 0, 0, 0, 0, 0, 0, &admin_sid));
+	cl_win32_pass(CheckTokenMembership(NULL, admin_sid, &is_admin));
+	FreeSid(admin_sid);
+
+	return is_admin ? true : false;
+}
+#endif
+
+static void do_symlink(const char *old, const char *new, int is_dir)
+{
+#ifndef GIT_WIN32
+	GIT_UNUSED(is_dir);
+
+	cl_must_pass(symlink(old, new));
+#else
+	typedef DWORD (WINAPI *create_symlink_func)(LPCTSTR, LPCTSTR, DWORD);
+	HMODULE module;
+	create_symlink_func pCreateSymbolicLink;
+
+	if (!is_administrator())
+		clar__skip();
+
+	cl_assert(module = GetModuleHandle("kernel32"));
+	cl_assert(pCreateSymbolicLink = (create_symlink_func)GetProcAddress(module, "CreateSymbolicLinkA"));
+
+	cl_win32_pass(pCreateSymbolicLink(new, old, is_dir));
+#endif
+}
+
+static void do_hardlink(const char *old, const char *new)
+{
+#ifndef GIT_WIN32
+	cl_must_pass(link(old, new));
+#else
+	typedef DWORD (WINAPI *create_hardlink_func)(LPCTSTR, LPCTSTR, LPSECURITY_ATTRIBUTES);
+	HMODULE module;
+	create_hardlink_func pCreateHardLink;
+
+	if (!is_administrator())
+		clar__skip();
+
+	cl_assert(module = GetModuleHandle("kernel32"));
+	cl_assert(pCreateHardLink = (create_hardlink_func)GetProcAddress(module, "CreateHardLinkA"));
+
+	cl_win32_pass(pCreateHardLink(new, old, 0));
+#endif
+}
+
+#ifdef GIT_WIN32
+
+static void do_junction(const char *old, const char *new)
+{
+	GIT_REPARSE_DATA_BUFFER *reparse_buf;
+	HANDLE handle;
+	git_buf unparsed_buf = GIT_BUF_INIT;
+	wchar_t *subst_utf16, *print_utf16;
+	DWORD ioctl_ret;
+	int subst_utf16_len, subst_byte_len, print_utf16_len, print_byte_len, ret;
+	USHORT reparse_buflen;
+	size_t i;
+
+	/* Junction targets must be the unparsed name, starting with \??\, using
+	 * backslashes instead of forward, and end in a trailing backslash.
+	 * eg: \??\C:\Foo\
+	 */
+	git_buf_puts(&unparsed_buf, "\\??\\");
+
+	for (i = 0; i < strlen(old); i++)
+		git_buf_putc(&unparsed_buf, old[i] == '/' ? '\\' : old[i]);
+
+	git_buf_putc(&unparsed_buf, '\\');
+
+	subst_utf16_len = git__utf8_to_16(NULL, 0, git_buf_cstr(&unparsed_buf));
+	subst_byte_len = subst_utf16_len * sizeof(WCHAR);
+
+	print_utf16_len = subst_utf16_len - 4;
+	print_byte_len = subst_byte_len - (4 * sizeof(WCHAR));
+
+	/* The junction must be an empty directory before the junction attribute
+	 * can be added.
+	 */
+	cl_win32_pass(CreateDirectoryA(new, NULL));
+
+	handle = CreateFileA(new, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+		FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);
+	cl_win32_pass(handle != INVALID_HANDLE_VALUE);
+
+	reparse_buflen = (USHORT)(REPARSE_DATA_HEADER_SIZE +
+		REPARSE_DATA_MOUNTPOINT_HEADER_SIZE +
+		subst_byte_len + sizeof(WCHAR) +
+		print_byte_len + sizeof(WCHAR));
+
+	reparse_buf = LocalAlloc(LMEM_FIXED|LMEM_ZEROINIT, reparse_buflen);
+	cl_assert(reparse_buf);
+
+	subst_utf16 = reparse_buf->MountPointReparseBuffer.PathBuffer;
+	print_utf16 = subst_utf16 + subst_utf16_len + 1;
+
+	ret = git__utf8_to_16(subst_utf16, subst_utf16_len + 1,
+		git_buf_cstr(&unparsed_buf));
+	cl_assert_equal_i(subst_utf16_len, ret);
+
+	ret = git__utf8_to_16(print_utf16,
+		print_utf16_len + 1, git_buf_cstr(&unparsed_buf) + 4);
+	cl_assert_equal_i(print_utf16_len, ret);
+
+	reparse_buf->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
+	reparse_buf->MountPointReparseBuffer.SubstituteNameOffset = 0;
+	reparse_buf->MountPointReparseBuffer.SubstituteNameLength =	subst_byte_len;
+	reparse_buf->MountPointReparseBuffer.PrintNameOffset = (USHORT)(subst_byte_len + sizeof(WCHAR));
+	reparse_buf->MountPointReparseBuffer.PrintNameLength = print_byte_len;
+	reparse_buf->ReparseDataLength = reparse_buflen - REPARSE_DATA_HEADER_SIZE;
+
+	cl_win32_pass(DeviceIoControl(handle, FSCTL_SET_REPARSE_POINT,
+		reparse_buf, reparse_buflen, NULL, 0, &ioctl_ret, NULL));
+
+	CloseHandle(handle);
+	LocalFree(reparse_buf);
+}
+
+static void do_custom_reparse(const char *path)
+{
+	REPARSE_GUID_DATA_BUFFER *reparse_buf;
+	HANDLE handle;
+	DWORD ioctl_ret;
+
+	const char *reparse_data = "Reparse points are silly.";
+	size_t reparse_buflen = REPARSE_GUID_DATA_BUFFER_HEADER_SIZE +
+		strlen(reparse_data) + 1;
+
+	reparse_buf = LocalAlloc(LMEM_FIXED|LMEM_ZEROINIT, reparse_buflen);
+	cl_assert(reparse_buf);
+
+	reparse_buf->ReparseTag = 42;
+	reparse_buf->ReparseDataLength = (WORD)(strlen(reparse_data) + 1);
+
+	reparse_buf->ReparseGuid.Data1 = 0xdeadbeef;
+	reparse_buf->ReparseGuid.Data2 = 0xdead;
+	reparse_buf->ReparseGuid.Data3 = 0xbeef;
+	reparse_buf->ReparseGuid.Data4[0] = 42;
+	reparse_buf->ReparseGuid.Data4[1] = 42;
+	reparse_buf->ReparseGuid.Data4[2] = 42;
+	reparse_buf->ReparseGuid.Data4[3] = 42;
+	reparse_buf->ReparseGuid.Data4[4] = 42;
+	reparse_buf->ReparseGuid.Data4[5] = 42;
+	reparse_buf->ReparseGuid.Data4[6] = 42;
+	reparse_buf->ReparseGuid.Data4[7] = 42;
+	reparse_buf->ReparseGuid.Data4[8] = 42;
+
+	memcpy(reparse_buf->GenericReparseBuffer.DataBuffer,
+		reparse_data, strlen(reparse_data) + 1);
+
+	handle = CreateFileA(path, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+		FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);
+	cl_win32_pass(handle != INVALID_HANDLE_VALUE);
+
+	cl_win32_pass(DeviceIoControl(handle, FSCTL_SET_REPARSE_POINT,
+		reparse_buf,
+		reparse_buf->ReparseDataLength + REPARSE_GUID_DATA_BUFFER_HEADER_SIZE,
+		NULL, 0, &ioctl_ret, NULL));
+
+	CloseHandle(handle);
+	LocalFree(reparse_buf);
+}
+
+#endif
+
+git_buf *unslashify(git_buf *buf)
+{
+#ifdef GIT_WIN32
+	size_t i;
+
+	for (i = 0; i < buf->size; i++)
+		if (buf->ptr[i] == '/')
+			buf->ptr[i] = '\\';
+#endif
+
+	return buf;
+}
+
+void test_core_link__stat_regular_file(void)
+{
+	struct stat st;
+
+	cl_git_rewritefile("stat_regfile", "This is a regular file!\n");
+
+	cl_must_pass(p_stat("stat_regfile", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(24, st.st_size);
+}
+
+void test_core_link__lstat_regular_file(void)
+{
+	struct stat st;
+
+	cl_git_rewritefile("lstat_regfile", "This is a regular file!\n");
+
+	cl_must_pass(p_stat("lstat_regfile", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(24, st.st_size);
+}
+
+void test_core_link__stat_symlink(void)
+{
+	struct stat st;
+
+	cl_git_rewritefile("stat_target", "This is the target of a symbolic link.\n");
+	do_symlink("stat_target", "stat_symlink", 0);
+
+	cl_must_pass(p_stat("stat_target", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(39, st.st_size);
+
+	cl_must_pass(p_stat("stat_symlink", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(39, st.st_size);
+}
+
+void test_core_link__stat_symlink_directory(void)
+{
+	struct stat st;
+
+	p_mkdir("stat_dirtarget", 0777);
+	do_symlink("stat_dirtarget", "stat_dirlink", 1);
+
+	cl_must_pass(p_stat("stat_dirtarget", &st));
+	cl_assert(S_ISDIR(st.st_mode));
+
+	cl_must_pass(p_stat("stat_dirlink", &st));
+	cl_assert(S_ISDIR(st.st_mode));
+}
+
+void test_core_link__stat_symlink_chain(void)
+{
+	struct stat st;
+
+	cl_git_rewritefile("stat_final_target", "Final target of some symbolic links...\n");
+	do_symlink("stat_final_target", "stat_chain_3", 0);
+	do_symlink("stat_chain_3", "stat_chain_2", 0);
+	do_symlink("stat_chain_2", "stat_chain_1", 0);
+
+	cl_must_pass(p_stat("stat_chain_1", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(39, st.st_size);
+}
+
+void test_core_link__stat_dangling_symlink(void)
+{
+	struct stat st;
+
+	do_symlink("stat_nonexistent", "stat_dangling", 0);
+
+	cl_must_fail(p_stat("stat_nonexistent", &st));
+	cl_must_fail(p_stat("stat_dangling", &st));
+}
+
+void test_core_link__stat_dangling_symlink_directory(void)
+{
+	struct stat st;
+
+	do_symlink("stat_nonexistent", "stat_dangling_dir", 1);
+
+	cl_must_fail(p_stat("stat_nonexistent_dir", &st));
+	cl_must_fail(p_stat("stat_dangling", &st));
+}
+
+void test_core_link__lstat_symlink(void)
+{
+	git_buf target_path = GIT_BUF_INIT;
+	struct stat st;
+
+	/* Windows always writes the canonical path as the link target, so
+	 * write the full path on all platforms.
+	 */
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "lstat_target");
+
+	cl_git_rewritefile("lstat_target", "This is the target of a symbolic link.\n");
+	do_symlink(git_buf_cstr(&target_path), "lstat_symlink", 0);
+
+	cl_must_pass(p_lstat("lstat_target", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(39, st.st_size);
+
+	cl_must_pass(p_lstat("lstat_symlink", &st));
+	cl_assert(S_ISLNK(st.st_mode));
+	cl_assert_equal_i(git_buf_len(&target_path), st.st_size);
+
+	git_buf_free(&target_path);
+}
+
+void test_core_link__lstat_symlink_directory(void)
+{
+	git_buf target_path = GIT_BUF_INIT;
+	struct stat st;
+
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "lstat_dirtarget");
+
+	p_mkdir("lstat_dirtarget", 0777);
+	do_symlink(git_buf_cstr(&target_path), "lstat_dirlink", 1);
+
+	cl_must_pass(p_lstat("lstat_dirtarget", &st));
+	cl_assert(S_ISDIR(st.st_mode));
+
+	cl_must_pass(p_lstat("lstat_dirlink", &st));
+	cl_assert(S_ISLNK(st.st_mode));
+	cl_assert_equal_i(git_buf_len(&target_path), st.st_size);
+
+	git_buf_free(&target_path);
+}
+
+void test_core_link__lstat_dangling_symlink(void)
+{
+	struct stat st;
+
+	do_symlink("lstat_nonexistent", "lstat_dangling", 0);
+
+	cl_must_fail(p_lstat("lstat_nonexistent", &st));
+
+	cl_must_pass(p_lstat("lstat_dangling", &st));
+	cl_assert(S_ISLNK(st.st_mode));
+	cl_assert_equal_i(strlen("lstat_nonexistent"), st.st_size);
+}
+
+void test_core_link__lstat_dangling_symlink_directory(void)
+{
+	struct stat st;
+
+	do_symlink("lstat_nonexistent", "lstat_dangling_dir", 1);
+
+	cl_must_fail(p_lstat("lstat_nonexistent", &st));
+
+	cl_must_pass(p_lstat("lstat_dangling_dir", &st));
+	cl_assert(S_ISLNK(st.st_mode));
+	cl_assert_equal_i(strlen("lstat_nonexistent"), st.st_size);
+}
+
+void test_core_link__stat_junction(void)
+{
+#ifdef GIT_WIN32
+	git_buf target_path = GIT_BUF_INIT;
+	struct stat st;
+
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "stat_junctarget");
+
+	p_mkdir("stat_junctarget", 0777);
+	do_junction(git_buf_cstr(&target_path), "stat_junction");
+
+	cl_must_pass(p_stat("stat_junctarget", &st));
+	cl_assert(S_ISDIR(st.st_mode));
+
+	cl_must_pass(p_stat("stat_junction", &st));
+	cl_assert(S_ISDIR(st.st_mode));
+
+	git_buf_free(&target_path);
+#endif
+}
+
+void test_core_link__stat_dangling_junction(void)
+{
+#ifdef GIT_WIN32
+	git_buf target_path = GIT_BUF_INIT;
+	struct stat st;
+
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "stat_nonexistent_junctarget");
+
+	p_mkdir("stat_nonexistent_junctarget", 0777);
+	do_junction(git_buf_cstr(&target_path), "stat_dangling_junction");
+
+	RemoveDirectory("stat_nonexistent_junctarget");
+
+	cl_must_fail(p_stat("stat_nonexistent_junctarget", &st));
+	cl_must_fail(p_stat("stat_dangling_junction", &st));
+
+	git_buf_free(&target_path);
+#endif
+}
+
+void test_core_link__lstat_junction(void)
+{
+#ifdef GIT_WIN32
+	git_buf target_path = GIT_BUF_INIT;
+	struct stat st;
+
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "lstat_junctarget");
+
+	p_mkdir("lstat_junctarget", 0777);
+	do_junction(git_buf_cstr(&target_path), "lstat_junction");
+
+	cl_must_pass(p_lstat("lstat_junctarget", &st));
+	cl_assert(S_ISDIR(st.st_mode));
+
+	cl_must_pass(p_lstat("lstat_junction", &st));
+	cl_assert(S_ISLNK(st.st_mode));
+
+	git_buf_free(&target_path);
+#endif
+}
+
+void test_core_link__lstat_dangling_junction(void)
+{
+#ifdef GIT_WIN32
+	git_buf target_path = GIT_BUF_INIT;
+	struct stat st;
+
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "lstat_nonexistent_junctarget");
+
+	p_mkdir("lstat_nonexistent_junctarget", 0777);
+	do_junction(git_buf_cstr(&target_path), "lstat_dangling_junction");
+
+	RemoveDirectory("lstat_nonexistent_junctarget");
+
+	cl_must_fail(p_lstat("lstat_nonexistent_junctarget", &st));
+
+	cl_must_pass(p_lstat("lstat_dangling_junction", &st));
+	cl_assert(S_ISLNK(st.st_mode));
+	cl_assert_equal_i(git_buf_len(&target_path), st.st_size);
+
+	git_buf_free(&target_path);
+#endif
+}
+
+void test_core_link__stat_hardlink(void)
+{
+	struct stat st;
+
+	cl_git_rewritefile("stat_hardlink1", "This file has many names!\n");
+	do_hardlink("stat_hardlink1", "stat_hardlink2");
+
+	cl_must_pass(p_stat("stat_hardlink1", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(26, st.st_size);
+
+	cl_must_pass(p_stat("stat_hardlink2", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(26, st.st_size);
+}
+
+void test_core_link__lstat_hardlink(void)
+{
+	struct stat st;
+
+	cl_git_rewritefile("lstat_hardlink1", "This file has many names!\n");
+	do_hardlink("lstat_hardlink1", "lstat_hardlink2");
+
+	cl_must_pass(p_lstat("lstat_hardlink1", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(26, st.st_size);
+
+	cl_must_pass(p_lstat("lstat_hardlink2", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(26, st.st_size);
+}
+
+void test_core_link__stat_reparse_point(void)
+{
+#ifdef GIT_WIN32
+	struct stat st;
+
+	/* Generic reparse points should be treated as regular files, only
+	 * symlinks and junctions should be treated as links.
+	 */
+
+	cl_git_rewritefile("stat_reparse", "This is a reparse point!\n");
+	do_custom_reparse("stat_reparse");
+
+	cl_must_pass(p_lstat("stat_reparse", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(25, st.st_size);
+#endif
+}
+
+void test_core_link__lstat_reparse_point(void)
+{
+#ifdef GIT_WIN32
+	struct stat st;
+
+	cl_git_rewritefile("lstat_reparse", "This is a reparse point!\n");
+	do_custom_reparse("lstat_reparse");
+
+	cl_must_pass(p_lstat("lstat_reparse", &st));
+	cl_assert(S_ISREG(st.st_mode));
+	cl_assert_equal_i(25, st.st_size);
+#endif
+}
+
+void test_core_link__readlink_nonexistent_file(void)
+{
+	char buf[2048];
+
+	cl_must_fail(p_readlink("readlink_nonexistent", buf, 2048));
+	cl_assert_equal_i(ENOENT, errno);
+}
+
+void test_core_link__readlink_normal_file(void)
+{
+	char buf[2048];
+
+	cl_git_rewritefile("readlink_regfile", "This is a regular file!\n");
+	cl_must_fail(p_readlink("readlink_regfile", buf, 2048));
+	cl_assert_equal_i(EINVAL, errno);
+}
+
+void test_core_link__readlink_symlink(void)
+{
+	git_buf target_path = GIT_BUF_INIT;
+	int len;
+	char buf[2048];
+
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "readlink_target");
+
+	cl_git_rewritefile("readlink_target", "This is the target of a symlink\n");
+	do_symlink(git_buf_cstr(&target_path), "readlink_link", 0);
+
+	len = p_readlink("readlink_link", buf, 2048);
+	cl_must_pass(len);
+
+	buf[len] = 0;
+
+	cl_assert_equal_s(git_buf_cstr(unslashify(&target_path)), buf);
+
+	git_buf_free(&target_path);
+}
+
+void test_core_link__readlink_dangling(void)
+{
+	git_buf target_path = GIT_BUF_INIT;
+	int len;
+	char buf[2048];
+
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "readlink_nonexistent");
+
+	do_symlink(git_buf_cstr(&target_path), "readlink_dangling", 0);
+
+	len = p_readlink("readlink_dangling", buf, 2048);
+	cl_must_pass(len);
+
+	buf[len] = 0;
+
+	cl_assert_equal_s(git_buf_cstr(unslashify(&target_path)), buf);
+
+	git_buf_free(&target_path);
+}
+
+void test_core_link__readlink_multiple(void)
+{
+	git_buf target_path = GIT_BUF_INIT,
+		path3 = GIT_BUF_INIT, path2 = GIT_BUF_INIT, path1 = GIT_BUF_INIT;
+	int len;
+	char buf[2048];
+
+	git_buf_join(&target_path, '/', clar_sandbox_path(), "readlink_final");
+	git_buf_join(&path3, '/', clar_sandbox_path(), "readlink_3");
+	git_buf_join(&path2, '/', clar_sandbox_path(), "readlink_2");
+	git_buf_join(&path1, '/', clar_sandbox_path(), "readlink_1");
+
+	do_symlink(git_buf_cstr(&target_path), git_buf_cstr(&path3), 0);
+	do_symlink(git_buf_cstr(&path3), git_buf_cstr(&path2), 0);
+	do_symlink(git_buf_cstr(&path2), git_buf_cstr(&path1), 0);
+
+	len = p_readlink("readlink_1", buf, 2048);
+	cl_must_pass(len);
+
+	buf[len] = 0;
+
+	cl_assert_equal_s(git_buf_cstr(unslashify(&path2)), buf);
+
+	git_buf_free(&path1);
+	git_buf_free(&path2);
+	git_buf_free(&path3);
+	git_buf_free(&target_path);
+}
-- 
cgit v1.2.3


From 2efd7df6b11e8c646d05870965bb4588d6b6d425 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 19 Apr 2014 15:34:12 +0200
Subject: remote: provide read access to the callback structure

This should make it easier for bindings to dynamically override their
own callbacks.
---
 include/git2/remote.h | 11 +++++++++++
 src/remote.c          |  7 +++++++
 2 files changed, 18 insertions(+)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index d57321f03..578fcf51b 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -519,6 +519,17 @@ GIT_EXTERN(int) git_remote_init_callbacks(
  */
 GIT_EXTERN(int) git_remote_set_callbacks(git_remote *remote, const git_remote_callbacks *callbacks);
 
+/**
+ * Retrieve the current callback structure
+ *
+ * This provides read access to the callbacks structure as the remote
+ * sees it.
+ *
+ * @param remote the remote to query
+ * @return a pointer to the callbacks structure
+ */
+GIT_EXTERN(const git_remote_callbacks *) git_remote_get_callbacks(git_remote *remote);
+
 /**
  * Get the statistics structure that is filled in by the fetch operation.
  */
diff --git a/src/remote.c b/src/remote.c
index 243086bf9..c23a4643e 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1253,6 +1253,13 @@ int git_remote_set_callbacks(git_remote *remote, const git_remote_callbacks *cal
 	return 0;
 }
 
+const git_remote_callbacks *git_remote_get_callbacks(git_remote *remote)
+{
+	assert(remote);
+
+	return &remote->callbacks;
+}
+
 int git_remote_set_transport(git_remote *remote, git_transport *transport)
 {
 	assert(remote && transport);
-- 
cgit v1.2.3


From bc0a61986745b89258a98773f88bd98c44ef88d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 19 Apr 2014 15:52:58 +0200
Subject: transports: allow the creds callback to say it doesn't exist

Allow the credentials callback to return GIT_PASSTHROUGH to make the
transports code behave as though none was set.

This should make it easier for bindings to behave closer to the C code
when there is no credentials callback set at their level.
---
 include/git2/remote.h |  3 +++
 src/transports/http.c | 55 ++++++++++++++++++++++++++++++++-------------------
 src/transports/ssh.c  | 32 +++++++++++++++++++-----------
 3 files changed, 58 insertions(+), 32 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index 578fcf51b..ddde3e85e 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -468,6 +468,9 @@ struct git_remote_callbacks {
 	/**
 	 * This will be called if the remote host requires
 	 * authentication in order to connect to it.
+	 *
+	 * Returning GIT_PASSTHROUGH will make libgit2 behave as
+	 * though this field isn't set.
 	 */
 	int (*credentials)(git_cred **cred, const char *url, const char *username_from_url, unsigned int allowed_types,	void *data);
 
diff --git a/src/transports/http.c b/src/transports/http.c
index c6aaeb9cf..a7eff7365 100644
--- a/src/transports/http.c
+++ b/src/transports/http.c
@@ -248,6 +248,7 @@ static int on_headers_complete(http_parser *parser)
 	http_subtransport *t = ctx->t;
 	http_stream *s = ctx->s;
 	git_buf buf = GIT_BUF_INIT;
+	int error = 0, no_callback = 0;
 
 	/* Both parse_header_name and parse_header_value are populated
 	 * and ready for consumption. */
@@ -256,29 +257,43 @@ static int on_headers_complete(http_parser *parser)
 			return t->parse_error = PARSE_ERROR_GENERIC;
 
 	/* Check for an authentication failure. */
+
 	if (parser->status_code == 401 &&
-		get_verb == s->verb &&
-		t->owner->cred_acquire_cb) {
-		int allowed_types = 0;
+	    get_verb == s->verb) {
+		if (!t->owner->cred_acquire_payload) {
+			no_callback = 1;
+		} else {
+			int allowed_types = 0;
+
+			if (parse_unauthorized_response(&t->www_authenticate,
+							&allowed_types, &t->auth_mechanism) < 0)
+				return t->parse_error = PARSE_ERROR_GENERIC;
+
+			if (allowed_types &&
+			    (!t->cred || 0 == (t->cred->credtype & allowed_types))) {
+
+				error = t->owner->cred_acquire_cb(&t->cred,
+								  t->owner->url,
+								  t->connection_data.user,
+								  allowed_types,
+								  t->owner->cred_acquire_payload);
+
+				if (error == GIT_PASSTHROUGH) {
+					no_callback = 1;
+				} else if (error < 0) {
+					return PARSE_ERROR_GENERIC;
+				} else {
+					assert(t->cred);
+
+					/* Successfully acquired a credential. */
+					return t->parse_error = PARSE_ERROR_REPLAY;
+				}
+			}
+		}
 
-		if (parse_unauthorized_response(&t->www_authenticate,
-			&allowed_types, &t->auth_mechanism) < 0)
+		if (no_callback) {
+			giterr_set(GITERR_NET, "authentication required but no callback set");
 			return t->parse_error = PARSE_ERROR_GENERIC;
-
-		if (allowed_types &&
-			(!t->cred || 0 == (t->cred->credtype & allowed_types))) {
-
-			if (t->owner->cred_acquire_cb(&t->cred,
-					t->owner->url,
-					t->connection_data.user,
-					allowed_types,
-					t->owner->cred_acquire_payload) < 0)
-				return PARSE_ERROR_GENERIC;
-
-			assert(t->cred);
-
-			/* Successfully acquired a credential. */
-			return t->parse_error = PARSE_ERROR_REPLAY;
 		}
 	}
 
diff --git a/src/transports/ssh.c b/src/transports/ssh.c
index dea990275..b403727c9 100644
--- a/src/transports/ssh.c
+++ b/src/transports/ssh.c
@@ -387,6 +387,7 @@ static int _git_ssh_setup_conn(
 {
 	char *host=NULL, *port=NULL, *path=NULL, *user=NULL, *pass=NULL;
 	const char *default_port="22";
+	int no_callback = 0;
 	ssh_stream *s;
 	LIBSSH2_SESSION* session=NULL;
 	LIBSSH2_CHANNEL* channel=NULL;
@@ -413,24 +414,31 @@ static int _git_ssh_setup_conn(
 	if (user && pass) {
 		if (git_cred_userpass_plaintext_new(&t->cred, user, pass) < 0)
 			goto on_error;
-	} else if (t->owner->cred_acquire_cb) {
-		if (t->owner->cred_acquire_cb(
-				&t->cred, t->owner->url, user,
-				GIT_CREDTYPE_USERPASS_PLAINTEXT |
-				GIT_CREDTYPE_SSH_KEY |
-				GIT_CREDTYPE_SSH_INTERACTIVE |
-				GIT_CREDTYPE_SSH_CUSTOM,
-				t->owner->cred_acquire_payload) < 0)
+	} else if (!t->owner->cred_acquire_cb) {
+		no_callback = 1;
+	} else {
+		int error;
+		error = t->owner->cred_acquire_cb(&t->cred, t->owner->url, user,
+			GIT_CREDTYPE_USERPASS_PLAINTEXT |
+			GIT_CREDTYPE_SSH_KEY | GIT_CREDTYPE_SSH_CUSTOM |
+			GIT_CREDTYPE_SSH_INTERACTIVE,
+			t->owner->cred_acquire_payload);
+
+		if (error == GIT_PASSTHROUGH)
+			no_callback = 1;
+		else if (error < 0)
 			goto on_error;
-
-		if (!t->cred) {
+		else if (!t->cred) {
 			giterr_set(GITERR_SSH, "Callback failed to initialize SSH credentials");
 			goto on_error;
 		}
-	} else {
-		giterr_set(GITERR_SSH, "Cannot set up SSH connection without credentials");
+	}
+
+	if (no_callback) {
+		giterr_set(GITERR_SSH, "authentication required but no callback set");
 		goto on_error;
 	}
+
 	assert(t->cred);
 
 	if (_git_ssh_session_create(&session, s->socket) < 0)
-- 
cgit v1.2.3


From 12e422a0562de2aebb05f5f414dbcde7caf85886 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 21 Apr 2014 16:08:05 -0700
Subject: Some doc and examples/diff.c changes

I was playing with "git diff-index" and wanted to be able to
emulate that behavior a little more closely with the diff example.

Also, I wanted to play with running `git_diff_tree_to_workdir`
directly even though core Git doesn't exactly have the equivalent,
so I added a command line option for that and tweaked some other
things in the example code.

This changes a minor output thing in that the "raw" print helper
function will no longer add ellipses (...) if the OID is not
actually abbreviated.
---
 examples/diff.c     | 151 ++++++++++++++++++++++++++++++----------------------
 include/git2/diff.h |  29 ++++------
 src/diff_print.c    |   3 +-
 3 files changed, 99 insertions(+), 84 deletions(-)

diff --git a/examples/diff.c b/examples/diff.c
index 6f68e8305..1dbf85f61 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -33,14 +33,26 @@ static const char *colors[] = {
 	"\033[36m" /* cyan */
 };
 
+enum {
+	OUTPUT_DIFF = 0,
+	OUTPUT_STAT = 1,
+	OUTPUT_SHORTSTAT = 2,
+	OUTPUT_NUMSTAT = 3
+};
+
+enum {
+	CACHE_NORMAL = 0,
+	CACHE_ONLY = 1,
+	CACHE_NONE = 2
+};
+
 /** The 'opts' struct captures all the various parsed command line options. */
 struct opts {
 	git_diff_options diffopts;
 	git_diff_find_options findopts;
 	int color;
-	int cached;
-	int numstat;
-	int shortstat;
+	int cache;
+	int output;
 	git_diff_format_t format;
 	const char *treeish1;
 	const char *treeish2;
@@ -48,11 +60,11 @@ struct opts {
 };
 
 /** These functions are implemented at the end */
+static void usage(const char *message, const char *arg);
 static void parse_opts(struct opts *o, int argc, char *argv[]);
 static int color_printer(
 	const git_diff_delta*, const git_diff_hunk*, const git_diff_line*, void*);
-static void diff_print_numstat(git_diff *diff);
-static void diff_print_shortstat(git_diff *diff);
+static void diff_print_stats(git_diff *diff, struct opts *o);
 
 int main(int argc, char *argv[])
 {
@@ -61,7 +73,7 @@ int main(int argc, char *argv[])
 	git_diff *diff;
 	struct opts o = {
 		GIT_DIFF_OPTIONS_INIT, GIT_DIFF_FIND_OPTIONS_INIT,
-		-1, 0, 0, 0, GIT_DIFF_FORMAT_PATCH, NULL, NULL, "."
+		-1, 0, 0, GIT_DIFF_FORMAT_PATCH, NULL, NULL, "."
 	};
 
 	git_threads_init();
@@ -78,6 +90,7 @@ int main(int argc, char *argv[])
 	 *  * &lt;sha1&gt; --cached
 	 *  * &lt;sha1&gt;
 	 *  * --cached
+	 *  * --nocache (don't use index data in diff at all)
 	 *  * nothing
 	 *
 	 * Currently ranged arguments like &lt;sha1&gt;..&lt;sha2&gt; and &lt;sha1&gt;...&lt;sha2&gt;
@@ -93,20 +106,23 @@ int main(int argc, char *argv[])
 		check_lg2(
 			git_diff_tree_to_tree(&diff, repo, t1, t2, &o.diffopts),
 			"diff trees", NULL);
-	else if (t1 && o.cached)
-		check_lg2(
-			git_diff_tree_to_index(&diff, repo, t1, NULL, &o.diffopts),
-			"diff tree to index", NULL);
+	else if (o.cache != CACHE_NORMAL) {
+		if (!t1)
+			treeish_to_tree(&t1, repo, "HEAD");
+
+		if (o.cache == CACHE_NONE)
+			check_lg2(
+				git_diff_tree_to_workdir(&diff, repo, t1, &o.diffopts),
+				"diff tree to working directory", NULL);
+		else
+			check_lg2(
+				git_diff_tree_to_index(&diff, repo, t1, NULL, &o.diffopts),
+				"diff tree to index", NULL);
+	}
 	else if (t1)
 		check_lg2(
 			git_diff_tree_to_workdir_with_index(&diff, repo, t1, &o.diffopts),
 			"diff tree to working directory", NULL);
-	else if (o.cached) {
-		treeish_to_tree(&t1, repo, "HEAD");
-		check_lg2(
-			git_diff_tree_to_index(&diff, repo, t1, NULL, &o.diffopts),
-			"diff tree to index", NULL);
-	}
 	else
 		check_lg2(
 			git_diff_index_to_workdir(&diff, repo, NULL, &o.diffopts),
@@ -121,11 +137,14 @@ int main(int argc, char *argv[])
 
 	/** Generate simple output using libgit2 display helper. */
 
-	if (o.numstat == 1)
-		diff_print_numstat(diff);
-	else if (o.shortstat == 1)
-		diff_print_shortstat(diff);
-	else {
+	switch (o.output) {
+	case OUTPUT_STAT:
+	case OUTPUT_NUMSTAT:
+	case OUTPUT_SHORTSTAT:
+		diff_print_stats(diff, &o);
+		break;
+
+	case OUTPUT_DIFF:
 		if (o.color >= 0)
 			fputs(colors[0], stdout);
 
@@ -135,6 +154,10 @@ int main(int argc, char *argv[])
 
 		if (o.color >= 0)
 			fputs(colors[0], stdout);
+		break;
+
+	default:
+		usage("Unknown output format", "programmer error");
 	}
 
 	/** Cleanup before exiting. */
@@ -213,13 +236,20 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 			!strcmp(a, "--patch"))
 			o->format = GIT_DIFF_FORMAT_PATCH;
 		else if (!strcmp(a, "--cached"))
-			o->cached = 1;
-		else if (!strcmp(a, "--name-only"))
+			o->cache = CACHE_ONLY;
+		else if (!strcmp(a, "--nocache"))
+			o->cache = CACHE_NONE;
+		else if (!strcmp(a, "--name-only") || !strcmp(a, "--format=name"))
 			o->format = GIT_DIFF_FORMAT_NAME_ONLY;
-		else if (!strcmp(a, "--name-status"))
+		else if (!strcmp(a, "--name-status") ||
+				!strcmp(a, "--format=name-status"))
 			o->format = GIT_DIFF_FORMAT_NAME_STATUS;
-		else if (!strcmp(a, "--raw"))
+		else if (!strcmp(a, "--raw") || !strcmp(a, "--format=raw"))
 			o->format = GIT_DIFF_FORMAT_RAW;
+		else if (!strcmp(a, "--format=diff-index")) {
+			o->format = GIT_DIFF_FORMAT_RAW;
+			o->diffopts.id_abbrev = 40;
+		}
 		else if (!strcmp(a, "--color"))
 			o->color = 0;
 		else if (!strcmp(a, "--no-color"))
@@ -242,10 +272,12 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 			o->diffopts.flags |= GIT_DIFF_PATIENCE;
 		else if (!strcmp(a, "--minimal"))
 			o->diffopts.flags |= GIT_DIFF_MINIMAL;
+		else if (!strcmp(a, "--stat"))
+			o->output = OUTPUT_STAT;
 		else if (!strcmp(a, "--numstat"))
-			o->numstat = 1;
+			o->output = OUTPUT_NUMSTAT;
 		else if (!strcmp(a, "--shortstat"))
-			o->shortstat = 1;
+			o->output = OUTPUT_SHORTSTAT;
 		else if (match_uint16_arg(
 				&o->findopts.rename_threshold, &args, "-M") ||
 			match_uint16_arg(
@@ -267,6 +299,8 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 				&o->diffopts.context_lines, &args, "--unified") &&
 			!match_uint16_arg(
 				&o->diffopts.interhunk_lines, &args, "--inter-hunk-context") &&
+			!match_uint16_arg(
+				&o->diffopts.id_abbrev, &args, "--abbrev") &&
 			!match_str_arg(&o->diffopts.old_prefix, &args, "--src-prefix") &&
 			!match_str_arg(&o->diffopts.new_prefix, &args, "--dst-prefix") &&
 			!match_str_arg(&o->dir, &args, "--git-dir"))
@@ -274,34 +308,8 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 	}
 }
 
-/** Display diff output with "--numstat".*/
-static void diff_print_numstat(git_diff *diff)
-{
-	git_patch *patch;
-	const git_diff_delta *delta;
-	size_t d, ndeltas = git_diff_num_deltas(diff);
-	size_t nadditions, ndeletions;
-
-	for (d = 0; d < ndeltas; d++){
-		check_lg2(
-			git_patch_from_diff(&patch, diff, d),
-			"generating patch from diff", NULL);
-
-		check_lg2(
-			git_patch_line_stats(NULL, &nadditions, &ndeletions, patch),
-			"generating the number of additions and deletions", NULL);
-
-		delta = git_patch_get_delta(patch);
-
-		printf("%ld\t%ld\t%s\n",
-			   (long)nadditions, (long)ndeletions, delta->new_file.path);
-
-		git_patch_free(patch);
-	}
-}
-
-/** Display diff output with "--shortstat".*/
-static void diff_print_shortstat(git_diff *diff)
+/** Display diff output with "--numstat" or "--shortstat" */
+static void diff_print_stats(git_diff *diff, struct opts *o)
 {
 	git_patch *patch;
 	size_t d, ndeltas = git_diff_num_deltas(diff);
@@ -320,26 +328,39 @@ static void diff_print_shortstat(git_diff *diff)
 			git_patch_line_stats(NULL, &nadditions, &ndeletions, patch),
 			"generating the number of additions and deletions", NULL);
 
+		if (o->output == OUTPUT_NUMSTAT) {
+			const git_diff_delta *delta = git_patch_get_delta(patch);
+			printf("%ld\t%ld\t%s\n",
+				   (long)nadditions, (long)ndeletions, delta->new_file.path);
+		}
+		else if (o->output == OUTPUT_STAT) {
+			const git_diff_delta *delta = git_patch_get_delta(patch);
+			printf(" %s\t| %ld\t(%ld+ %ld-)\n",
+				   delta->new_file.path, (long)nadditions + (long)ndeletions,
+				   (long)nadditions, (long)ndeletions);
+		}
+
 		nadditions_sum += nadditions;
 		ndeletions_sum += ndeletions;
 
 		git_patch_free(patch);
 	}
 
-	if (ndeltas) {
-
-	    printf(" %ld ", (long)ndeltas);
-	    printf("%s", 1==ndeltas ? "file changed" : "files changed");
+	if (o->output != OUTPUT_NUMSTAT && ndeltas > 0) {
+	    printf(" %ld %s", (long)ndeltas,
+			1 == ndeltas ? "file changed" : "files changed");
 
-	    if(nadditions_sum) {
-		printf(", %ld ",nadditions_sum);
-		printf("%s", 1==nadditions_sum ? "insertion(+)" : "insertions(+)");
+	    if (nadditions_sum) {
+			printf(", %ld ",nadditions_sum);
+			printf("%s", 1 == nadditions_sum ? "insertion(+)" : "insertions(+)");
 	    }
 
-	    if(ndeletions_sum) {
-		printf(", %ld ",ndeletions_sum);
-		printf("%s", 1==ndeletions_sum ? "deletion(-)" : "deletions(-)");
+	    if (ndeletions_sum) {
+			printf(", %ld ",ndeletions_sum);
+			printf("%s", 1 == ndeletions_sum ? "deletion(-)" : "deletions(-)");
 	    }
+
 	    printf("\n");
 	}
 }
+
diff --git a/include/git2/diff.h b/include/git2/diff.h
index a0cfbc918..c8e1ad143 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -725,24 +725,17 @@ GIT_EXTERN(int) git_diff_index_to_workdir(
  * The tree you provide will be used for the "old_file" side of the delta,
  * and the working directory will be used for the "new_file" side.
  *
- * Please note: this is *NOT* the same as `git diff <treeish>`.  Running
- * `git diff HEAD` or the like actually uses information from the index,
- * along with the tree and working directory info.
- *
- * This function returns strictly the differences between the tree and the
- * files contained in the working directory, regardless of the state of
- * files in the index.  It may come as a surprise, but there is no direct
- * equivalent in core git.
- *
- * To emulate `git diff <tree>`, use `git_diff_tree_to_workdir_with_index`
- * (or `git_diff_tree_to_index` and `git_diff_index_to_workdir`, then call
- * `git_diff_merge` on the results).  That will yield a `git_diff` that
- * matches the git output.
- *
- * If this seems confusing, take the case of a file with a staged deletion
- * where the file has then been put back into the working dir and modified.
- * The tree-to-workdir diff for that file is 'modified', but core git would
- * show status 'deleted' since there is a pending deletion in the index.
+ * This is not the same as `git diff <treeish>` or `git diff-index
+ * <treeish>`.  Those commands use information from the index, whereas this
+ * function strictly returns the differences between the tree and the files
+ * in the working directory, regardless of the state of the index.  Use
+ * `git_diff_tree_to_workdir_with_index` to emulate those commands.
+ *
+ * To see difference between this and `git_diff_tree_to_workdir_with_index`,
+ * consider the example of a staged file deletion where the file has then
+ * been put back into the working dir and further modified.  The
+ * tree-to-workdir diff for that file is 'modified', but `git diff` would
+ * show status 'deleted' since there is a staged delete.
  *
  * @param diff A pointer to a git_diff pointer that will be allocated.
  * @param repo The repository containing the tree.
diff --git a/src/diff_print.c b/src/diff_print.c
index a7f7b6fe8..ee5cd8dfb 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -175,7 +175,8 @@ static int diff_print_one_raw(
 	git_oid_tostr(end_oid, pi->oid_strlen, &delta->new_file.id);
 
 	git_buf_printf(
-		out, ":%06o %06o %s... %s... %c",
+		out, (pi->oid_strlen <= GIT_OID_HEXSZ) ?
+			":%06o %06o %s... %s... %c" : ":%06o %06o %s %s %c",
 		delta->old_file.mode, delta->new_file.mode, start_oid, end_oid, code);
 
 	if (delta->similarity > 0)
-- 
cgit v1.2.3


From 8d09efa24ee01e9e4b14672978bfd1bb1ca2436a Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 22 Apr 2014 12:33:27 -0700
Subject: Use git_diff_get_stats in example/diff + refactor

This takes the `--stat` and related example options in the example
diff.c program and converts them to use the `git_diff_get_stats`
API which nicely formats stats for you.

I went to add bar-graph scaling to the stats formatter and noticed
that the `git_diff_stats` structure was holding on to all of the
`git_patch` objects.  Unfortunately, each of these objects keeps
the full text of the diff in memory, so this is very expensive.  I
ended up modifying `git_diff_stats` to keep just the data that it
needs to keep and allowed it to release the patches.  Then, I added
width scaling to the output on top of that.

In making the diff example program match 'git diff' output, I ended
up removing an newline from the sumamry output which I then had to
compensate for in the email formatting to match the expectations.

Lastly, I went through and refactored the tests to use a couple of
helper functions and reduce the overall amount of code there.
---
 examples/diff.c           | 103 +++++--------
 include/git2/diff.h       |   4 +-
 src/diff.c                |   3 +-
 src/diff_stats.c          | 299 ++++++++++++++++++--------------------
 tests/diff/format_email.c | 193 +++++++------------------
 tests/diff/stats.c        | 357 ++++++++++++++--------------------------------
 6 files changed, 340 insertions(+), 619 deletions(-)

diff --git a/examples/diff.c b/examples/diff.c
index 1dbf85f61..76ac2f311 100644
--- a/examples/diff.c
+++ b/examples/diff.c
@@ -34,10 +34,11 @@ static const char *colors[] = {
 };
 
 enum {
-	OUTPUT_DIFF = 0,
-	OUTPUT_STAT = 1,
-	OUTPUT_SHORTSTAT = 2,
-	OUTPUT_NUMSTAT = 3
+	OUTPUT_DIFF = (1 << 0),
+	OUTPUT_STAT = (1 << 1),
+	OUTPUT_SHORTSTAT = (1 << 2),
+	OUTPUT_NUMSTAT = (1 << 3),
+	OUTPUT_SUMMARY = (1 << 4)
 };
 
 enum {
@@ -137,14 +138,13 @@ int main(int argc, char *argv[])
 
 	/** Generate simple output using libgit2 display helper. */
 
-	switch (o.output) {
-	case OUTPUT_STAT:
-	case OUTPUT_NUMSTAT:
-	case OUTPUT_SHORTSTAT:
+	if (!o.output)
+		o.output = OUTPUT_DIFF;
+
+	if (o.output != OUTPUT_DIFF)
 		diff_print_stats(diff, &o);
-		break;
 
-	case OUTPUT_DIFF:
+	if ((o.output & OUTPUT_DIFF) != 0) {
 		if (o.color >= 0)
 			fputs(colors[0], stdout);
 
@@ -154,10 +154,6 @@ int main(int argc, char *argv[])
 
 		if (o.color >= 0)
 			fputs(colors[0], stdout);
-		break;
-
-	default:
-		usage("Unknown output format", "programmer error");
 	}
 
 	/** Cleanup before exiting. */
@@ -233,8 +229,10 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 				usage("Only one or two tree identifiers can be provided", NULL);
 		}
 		else if (!strcmp(a, "-p") || !strcmp(a, "-u") ||
-			!strcmp(a, "--patch"))
+				 !strcmp(a, "--patch")) {
+			o->output |= OUTPUT_DIFF;
 			o->format = GIT_DIFF_FORMAT_PATCH;
+		}
 		else if (!strcmp(a, "--cached"))
 			o->cache = CACHE_ONLY;
 		else if (!strcmp(a, "--nocache"))
@@ -273,11 +271,13 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 		else if (!strcmp(a, "--minimal"))
 			o->diffopts.flags |= GIT_DIFF_MINIMAL;
 		else if (!strcmp(a, "--stat"))
-			o->output = OUTPUT_STAT;
+			o->output |= OUTPUT_STAT;
 		else if (!strcmp(a, "--numstat"))
-			o->output = OUTPUT_NUMSTAT;
+			o->output |= OUTPUT_NUMSTAT;
 		else if (!strcmp(a, "--shortstat"))
-			o->output = OUTPUT_SHORTSTAT;
+			o->output |= OUTPUT_SHORTSTAT;
+		else if (!strcmp(a, "--summary"))
+			o->output |= OUTPUT_SUMMARY;
 		else if (match_uint16_arg(
 				&o->findopts.rename_threshold, &args, "-M") ||
 			match_uint16_arg(
@@ -308,59 +308,30 @@ static void parse_opts(struct opts *o, int argc, char *argv[])
 	}
 }
 
-/** Display diff output with "--numstat" or "--shortstat" */
+/** Display diff output with "--stat", "--numstat", or "--shortstat" */
 static void diff_print_stats(git_diff *diff, struct opts *o)
 {
-	git_patch *patch;
-	size_t d, ndeltas = git_diff_num_deltas(diff);
-	size_t nadditions, ndeletions;
-	long nadditions_sum, ndeletions_sum;
-
-	nadditions_sum = 0;
-	ndeletions_sum = 0;
+	git_diff_stats *stats;
+	git_buf b = GIT_BUF_INIT_CONST(NULL, 0);
+	git_diff_stats_format_t format = 0;
 
-	for (d = 0; d < ndeltas; d++){
-		check_lg2(
-			git_patch_from_diff(&patch, diff, d),
-			"generating patch from diff", NULL);
+	check_lg2(
+		git_diff_get_stats(&stats, diff), "generating stats for diff", NULL);
 
-		check_lg2(
-			git_patch_line_stats(NULL, &nadditions, &ndeletions, patch),
-			"generating the number of additions and deletions", NULL);
+	if (o->output & OUTPUT_STAT)
+		format |= GIT_DIFF_STATS_FULL;
+	if (o->output & OUTPUT_SHORTSTAT)
+		format |= GIT_DIFF_STATS_SHORT;
+	if (o->output & OUTPUT_NUMSTAT)
+		format |= GIT_DIFF_STATS_NUMBER;
+	if (o->output & OUTPUT_SUMMARY)
+		format |= GIT_DIFF_STATS_INCLUDE_SUMMARY;
 
-		if (o->output == OUTPUT_NUMSTAT) {
-			const git_diff_delta *delta = git_patch_get_delta(patch);
-			printf("%ld\t%ld\t%s\n",
-				   (long)nadditions, (long)ndeletions, delta->new_file.path);
-		}
-		else if (o->output == OUTPUT_STAT) {
-			const git_diff_delta *delta = git_patch_get_delta(patch);
-			printf(" %s\t| %ld\t(%ld+ %ld-)\n",
-				   delta->new_file.path, (long)nadditions + (long)ndeletions,
-				   (long)nadditions, (long)ndeletions);
-		}
+	check_lg2(
+		git_diff_stats_to_buf(&b, stats, format, 80), "formatting stats", NULL);
 
-		nadditions_sum += nadditions;
-		ndeletions_sum += ndeletions;
+	fputs(b.ptr, stdout);
 
-		git_patch_free(patch);
-	}
-
-	if (o->output != OUTPUT_NUMSTAT && ndeltas > 0) {
-	    printf(" %ld %s", (long)ndeltas,
-			1 == ndeltas ? "file changed" : "files changed");
-
-	    if (nadditions_sum) {
-			printf(", %ld ",nadditions_sum);
-			printf("%s", 1 == nadditions_sum ? "insertion(+)" : "insertions(+)");
-	    }
-
-	    if (ndeletions_sum) {
-			printf(", %ld ",ndeletions_sum);
-			printf("%s", 1 == ndeletions_sum ? "deletion(-)" : "deletions(-)");
-	    }
-
-	    printf("\n");
-	}
+	git_buf_free(&b);
+	git_diff_stats_free(stats);
 }
-
diff --git a/include/git2/diff.h b/include/git2/diff.h
index c8e1ad143..e5e641a2a 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -1136,12 +1136,14 @@ GIT_EXTERN(size_t) git_diff_stats_deletions(
  * @param out buffer to store the formatted diff statistics in.
  * @param stats A `git_diff_stats` generated by one of the above functions.
  * @param format Formatting option.
+ * @param width Target width for output (only affects GIT_DIFF_STATS_FULL)
  * @return 0 on success; non-zero on error
  */
 GIT_EXTERN(int) git_diff_stats_to_buf(
 	git_buf *out,
 	const git_diff_stats *stats,
-	git_diff_stats_format_t format);
+	git_diff_stats_format_t format,
+	size_t width);
 
 /**
  * Deallocate a `git_diff_stats`.
diff --git a/src/diff.c b/src/diff.c
index 0d1aed4ad..fd881c6f6 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -1590,7 +1590,8 @@ int git_diff_format_email(
 
 	if ((error = git_buf_puts(out, "---\n")) < 0 ||
 		(error = git_diff_get_stats(&stats, diff)) < 0 ||
-		(error = git_diff_stats_to_buf(out, stats, format_flags)) < 0 ||
+		(error = git_diff_stats_to_buf(out, stats, format_flags, 0)) < 0 ||
+		(error = git_buf_putc(out, '\n')) < 0 ||
 		(error = git_diff_format_email__append_patches_tobuf(out, diff)) < 0)
 			goto on_error;
 
diff --git a/src/diff_stats.c b/src/diff_stats.c
index bb436bf7b..8a71be894 100644
--- a/src/diff_stats.c
+++ b/src/diff_stats.c
@@ -8,151 +8,123 @@
 #include "vector.h"
 #include "diff.h"
 #include "diff_patch.h"
+#include <math.h>
 
 #define DIFF_RENAME_FILE_SEPARATOR " => "
+#define STATS_FULL_MIN_SCALE 7
+
+typedef struct {
+	size_t insertions;
+	size_t deletions;
+} diff_file_stats;
 
 struct git_diff_stats {
-	git_vector patches;
+	git_diff *diff;
+	diff_file_stats *filestats;
 
 	size_t files_changed;
 	size_t insertions;
 	size_t deletions;
-};
-
-static size_t diff_get_filename_padding(
-	int has_renames,
-	const git_diff_stats *stats)
-{
-	const git_patch *patch = NULL;
-	size_t i, max_padding = 0;
-
-	if (has_renames) {
-		git_vector_foreach(&stats->patches, i, patch) {
-			const git_diff_delta *delta = NULL;
-			size_t len;
-
-			delta = git_patch_get_delta(patch);
-			if (strcmp(delta->old_file.path, delta->new_file.path) == 0)
-				continue;
-
-			if ((len = strlen(delta->old_file.path) + strlen(delta->new_file.path)) > max_padding)
-				max_padding = len;
-		}
-	}
-
-	git_vector_foreach(&stats->patches, i, patch) {
-		const git_diff_delta *delta = NULL;
-		size_t len;
-
-		delta = git_patch_get_delta(patch);
-		len = strlen(delta->new_file.path);
-
-		if (strcmp(delta->old_file.path, delta->new_file.path) != 0)
-			continue;
-
-		if (len > max_padding)
-			max_padding = len;
-	}
+	size_t renames;
 
-	return max_padding;
-}
+	size_t max_name;
+	size_t max_filestat;
+	int max_digits;
+};
 
 int git_diff_file_stats__full_to_buf(
 	git_buf *out,
-	size_t max_padding,
-	int has_renames,
-	const git_patch *patch)
+	const git_diff_delta *delta,
+	const diff_file_stats *filestat,
+	const git_diff_stats *stats,
+	double scale_to)
 {
 	const char *old_path = NULL, *new_path = NULL;
-	const git_diff_delta *delta = NULL;
 	size_t padding, old_size, new_size;
-	int error;
-
-	delta = git_patch_get_delta(patch);
 
 	old_path = delta->old_file.path;
 	new_path = delta->new_file.path;
 	old_size = delta->old_file.size;
 	new_size = delta->new_file.size;
 
-	if ((error = git_buf_printf(out, " %s", old_path)) < 0)
+	if (git_buf_printf(out, " %s", old_path) < 0)
 		goto on_error;
 
 	if (strcmp(old_path, new_path) != 0) {
-		padding = max_padding - strlen(old_path) - strlen(new_path);
+		padding = stats->max_name - strlen(old_path) - strlen(new_path);
 
-		if ((error = git_buf_printf(out, DIFF_RENAME_FILE_SEPARATOR "%s", new_path)) < 0)
+		if (git_buf_printf(out, DIFF_RENAME_FILE_SEPARATOR "%s", new_path) < 0)
 			goto on_error;
-	}
-	else {
-		padding = max_padding - strlen(old_path);
+	} else {
+		padding = stats->max_name - strlen(old_path);
 
-		if (has_renames)
+		if (stats->renames > 0)
 			padding += strlen(DIFF_RENAME_FILE_SEPARATOR);
 	}
 
-	if ((error = git_buf_putcn(out, ' ', padding)) < 0 ||
-		(error = git_buf_puts(out, " | ")) < 0)
-			goto on_error;
+	if (git_buf_putcn(out, ' ', padding) < 0 ||
+		git_buf_puts(out, " | ") < 0)
+		goto on_error;
 
 	if (delta->flags & GIT_DIFF_FLAG_BINARY) {
-		if ((error = git_buf_printf(out, "Bin %" PRIuZ " -> %" PRIuZ " bytes", old_size, new_size)) < 0)
+		if (git_buf_printf(out,
+				"Bin %" PRIuZ " -> %" PRIuZ " bytes", old_size, new_size) < 0)
 			goto on_error;
 	}
 	else {
-		size_t insertions, deletions;
-
-		if ((error = git_patch_line_stats(NULL, &insertions, &deletions, patch)) < 0)
+		if (git_buf_printf(out,
+				"%*" PRIuZ, stats->max_digits,
+				filestat->insertions + filestat->deletions) < 0)
 			goto on_error;
 
-		if ((error = git_buf_printf(out, "%" PRIuZ, insertions + deletions)) < 0)
-			goto on_error;
+		if (filestat->insertions || filestat->deletions) {
+			if (git_buf_putc(out, ' ') < 0)
+				goto on_error;
 
-		if (insertions || deletions) {
-			if ((error = git_buf_putc(out, ' ')) < 0 ||
-				(error = git_buf_putcn(out, '+', insertions)) < 0 ||
-				(error = git_buf_putcn(out, '-', deletions)) < 0)
+			if (scale_to <= 0) {
+				if (git_buf_putcn(out, '+', filestat->insertions) < 0 ||
+					git_buf_putcn(out, '-', filestat->deletions) < 0)
 					goto on_error;
+			} else {
+				size_t total = filestat->insertions + filestat->deletions;
+				double full = round(total * scale_to / stats->max_filestat);
+				size_t plus = full * filestat->insertions / total;
+				size_t minus = (size_t)full - plus;
+
+				if (git_buf_putcn(out, '+', max(plus,  1)) < 0 ||
+					git_buf_putcn(out, '-', max(minus, 1)) < 0)
+					goto on_error;
+			}
 		}
 	}
 
-	error = git_buf_putc(out, '\n');
+	git_buf_putc(out, '\n');
 
 on_error:
-	return error;
+	return (git_buf_oom(out) ? -1 : 0);
 }
 
 int git_diff_file_stats__number_to_buf(
 	git_buf *out,
-	const git_patch *patch)
+	const git_diff_delta *delta,
+	const diff_file_stats *filestats)
 {
-	const git_diff_delta *delta = NULL;
-	const char *path = NULL;
-	size_t insertions, deletions;
 	int error;
-
-	delta = git_patch_get_delta(patch);
-	path = delta->new_file.path;
-
-	if ((error = git_patch_line_stats(NULL, &insertions, &deletions, patch)) < 0)
-		return error;
+	const char *path = delta->new_file.path;
 
 	if (delta->flags & GIT_DIFF_FLAG_BINARY)
 		error = git_buf_printf(out, "%-8c" "%-8c" "%s\n", '-', '-', path);
 	else
-		error = git_buf_printf(out, "%-8" PRIuZ "%-8" PRIuZ "%s\n", insertions, deletions, path);
+		error = git_buf_printf(out, "%-8" PRIuZ "%-8" PRIuZ "%s\n",
+			filestats->insertions, filestats->deletions, path);
 
 	return error;
 }
 
 int git_diff_file_stats__summary_to_buf(
 	git_buf *out,
-	const git_patch *patch)
+	const git_diff_delta *delta)
 {
-	const git_diff_delta *delta = NULL;
-
-	delta = git_patch_get_delta(patch);
-
 	if (delta->old_file.mode != delta->new_file.mode) {
 		if (delta->old_file.mode == 0) {
 			git_buf_printf(out, " create mode %06o %s\n",
@@ -171,39 +143,6 @@ int git_diff_file_stats__summary_to_buf(
 	return 0;
 }
 
-int git_diff_stats__has_renames(
-	const git_diff_stats *stats)
-{
-	git_patch *patch = NULL;
-	size_t i;
-
-	git_vector_foreach(&stats->patches, i, patch) {
-		const git_diff_delta *delta = git_patch_get_delta(patch);
-
-		if (strcmp(delta->old_file.path, delta->new_file.path) != 0) {
-			return 1;
-		}
-	}
-
-	return 0;
-}
-
-int git_diff_stats__add_file_stats(
-	git_diff_stats *stats,
-	git_patch *patch)
-{
-	const git_diff_delta *delta = NULL;
-	int error = 0;
-
-	if ((delta = git_patch_get_delta(patch)) == NULL)
-		return -1;
-
-	if ((error = git_vector_insert(&stats->patches, patch)) < 0)
-		return error;
-
-	return error;
-}
-
 int git_diff_get_stats(
 	git_diff_stats **out,
 	git_diff *diff)
@@ -220,35 +159,60 @@ int git_diff_get_stats(
 
 	deltas = git_diff_num_deltas(diff);
 
-	for (i = 0; i < deltas; ++i) {
+	stats->filestats = git__calloc(deltas, sizeof(diff_file_stats));
+	if (!stats->filestats) {
+		git__free(stats);
+		return -1;
+	}
+
+	stats->diff = diff;
+	GIT_REFCOUNT_INC(diff);
+
+	for (i = 0; i < deltas && !error; ++i) {
 		git_patch *patch = NULL;
-		size_t add, remove;
+		size_t add = 0, remove = 0, namelen;
+		const git_diff_delta *delta;
 
 		if ((error = git_patch_from_diff(&patch, diff, i)) < 0)
-			goto on_error;
+			break;
 
-		if ((error = git_patch_line_stats(NULL, &add, &remove, patch)) < 0 ||
-			(error = git_diff_stats__add_file_stats(stats, patch)) < 0) {
-			git_patch_free(patch);
-			goto on_error;
+		/* keep a count of renames because it will affect formatting */
+		delta = git_patch_get_delta(patch);
+
+		namelen = strlen(delta->new_file.path);
+		if (strcmp(delta->old_file.path, delta->new_file.path) != 0) {
+			namelen += strlen(delta->old_file.path);
+			stats->renames++;
 		}
 
+		/* and, of course, count the line stats */
+		error = git_patch_line_stats(NULL, &add, &remove, patch);
+
+		git_patch_free(patch);
+
+		stats->filestats[i].insertions = add;
+		stats->filestats[i].deletions = remove;
+
 		total_insertions += add;
 		total_deletions += remove;
+
+		if (stats->max_name < namelen)
+			stats->max_name = namelen;
+		if (stats->max_filestat < add + remove)
+			stats->max_filestat = add + remove;
 	}
 
 	stats->files_changed = deltas;
 	stats->insertions = total_insertions;
 	stats->deletions = total_deletions;
+	stats->max_digits = (int)ceil(log10(stats->max_filestat + 1));
 
-	*out = stats;
-
-	goto done;
-
-on_error:
-	git_diff_stats_free(stats);
+	if (error < 0) {
+		git_diff_stats_free(stats);
+		stats = NULL;
+	}
 
-done:
+	*out = stats;
 	return error;
 }
 
@@ -279,48 +243,68 @@ size_t git_diff_stats_deletions(
 int git_diff_stats_to_buf(
 	git_buf *out,
 	const git_diff_stats *stats,
-	git_diff_stats_format_t format)
+	git_diff_stats_format_t format,
+	size_t width)
 {
-	git_patch *patch = NULL;
+	int error = 0;
 	size_t i;
-	int has_renames = 0, error = 0;
+	const git_diff_delta *delta;
 
 	assert(out && stats);
 
-	/* check if we have renames, it affects the padding */
-	has_renames = git_diff_stats__has_renames(stats);
-
-	git_vector_foreach(&stats->patches, i, patch) {
-		if (format & GIT_DIFF_STATS_FULL) {
-			size_t max_padding = diff_get_filename_padding(has_renames, stats);
+	if (format & GIT_DIFF_STATS_NUMBER) {
+		for (i = 0; i < stats->files_changed; ++i) {
+			if ((delta = git_diff_get_delta(stats->diff, i)) == NULL)
+				continue;
 
-			error = git_diff_file_stats__full_to_buf(out, max_padding, has_renames, patch);
+			error = git_diff_file_stats__number_to_buf(
+				out, delta, &stats->filestats[i]);
+			if (error < 0)
+				return error;
 		}
-		else if (format & GIT_DIFF_STATS_NUMBER) {
-			error = git_diff_file_stats__number_to_buf(out, patch);
+	}
+
+	if (format & GIT_DIFF_STATS_FULL) {
+		double scale_to = -1;
+		if (width > 0) {
+			if (width > stats->max_name + stats->max_digits + 5)
+				scale_to = width - (stats->max_name + stats->max_digits + 5);
+			if (scale_to < STATS_FULL_MIN_SCALE)
+				scale_to = STATS_FULL_MIN_SCALE;
 		}
 
-		if (error < 0)
-			return error;
+		for (i = 0; i < stats->files_changed; ++i) {
+			if ((delta = git_diff_get_delta(stats->diff, i)) == NULL)
+				continue;
+
+			error = git_diff_file_stats__full_to_buf(
+				out, delta, &stats->filestats[i], stats, scale_to);
+			if (error < 0)
+				return error;
+		}
 	}
 
 	if (format & GIT_DIFF_STATS_FULL || format & GIT_DIFF_STATS_SHORT) {
-		error = git_buf_printf(out, " %" PRIuZ " file%s changed, %" PRIuZ " insertions(+), %" PRIuZ " deletions(-)\n",
-					stats->files_changed, stats->files_changed > 1 ? "s" : "",
-					stats->insertions, stats->deletions);
+		error = git_buf_printf(
+			out, " %" PRIuZ " file%s changed, %" PRIuZ
+			" insertion%s(+), %" PRIuZ " deletion%s(-)\n",
+			stats->files_changed, stats->files_changed != 1 ? "s" : "",
+			stats->insertions, stats->insertions != 1 ? "s" : "",
+			stats->deletions, stats->deletions != 1 ? "s" : "");
 
 		if (error < 0)
 			return error;
 	}
 
 	if (format & GIT_DIFF_STATS_INCLUDE_SUMMARY) {
-		git_vector_foreach(&stats->patches, i, patch) {
-			if ((error = git_diff_file_stats__summary_to_buf(out, patch)) < 0)
+		for (i = 0; i < stats->files_changed; ++i) {
+			if ((delta = git_diff_get_delta(stats->diff, i)) == NULL)
+				continue;
+
+			error = git_diff_file_stats__summary_to_buf(out, delta);
+			if (error < 0)
 				return error;
 		}
-
-		if (git_vector_length(&stats->patches) > 0)
-			git_buf_putc(out, '\n');
 	}
 
 	return error;
@@ -328,16 +312,11 @@ int git_diff_stats_to_buf(
 
 void git_diff_stats_free(git_diff_stats *stats)
 {
-	size_t i;
-	git_patch *patch;
-
 	if (stats == NULL)
 		return;
 
-	git_vector_foreach(&stats->patches, i, patch)
-		git_patch_free(patch);
-
-	git_vector_free(&stats->patches);
+	git_diff_free(stats->diff); /* bumped refcount in constructor */
+	git__free(stats->filestats);
 	git__free(stats);
 }
 
diff --git a/tests/diff/format_email.c b/tests/diff/format_email.c
index 3260fdea8..18ad99bd5 100644
--- a/tests/diff/format_email.c
+++ b/tests/diff/format_email.c
@@ -17,15 +17,44 @@ void test_diff_format_email__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-void test_diff_format_email__simple(void)
+static void assert_email_match(
+	const char *expected,
+	const char *oidstr,
+	git_diff_format_email_options *opts)
 {
 	git_oid oid;
 	git_commit *commit = NULL;
 	git_diff *diff = NULL;
-	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
 	git_buf buf = GIT_BUF_INIT;
 
-	const char *email = 
+	git_oid_fromstr(&oid, oidstr);
+
+	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
+
+	opts->id = git_commit_id(commit);
+	opts->author = git_commit_author(commit);
+	if (!opts->summary)
+		opts->summary = git_commit_summary(commit);
+
+	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_git_pass(git_diff_format_email(&buf, diff, opts));
+
+	cl_assert_equal_s(expected, git_buf_cstr(&buf));
+	git_buf_clear(&buf);
+
+	cl_git_pass(git_diff_commit_as_email(
+		&buf, repo, commit, 1, 1, opts->flags, NULL));
+	cl_assert_equal_s(expected, git_buf_cstr(&buf));
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+	git_buf_free(&buf);
+}
+
+void test_diff_format_email__simple(void)
+{
+	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	const char *email =
 	"From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \
 	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
 	"Date: Wed, 9 Apr 2014 20:57:01 +0200\n" \
@@ -64,25 +93,8 @@ void test_diff_format_email__simple(void)
 	"libgit2 " LIBGIT2_VERSION "\n" \
 	"\n";
 
-	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-
-	opts.id = git_commit_id(commit);
-	opts.author = git_commit_author(commit);
-	opts.summary = git_commit_summary(commit);
-
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_buf_clear(&buf);
-	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1, 0, NULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_diff_free(diff);
-	git_commit_free(commit);
-	git_buf_free(&buf);
+	assert_email_match(
+		email, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts);
 }
 
 void test_diff_format_email__multiple(void)
@@ -90,10 +102,10 @@ void test_diff_format_email__multiple(void)
 	git_oid oid;
 	git_commit *commit = NULL;
 	git_diff *diff = NULL;
-	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+ 	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
 	git_buf buf = GIT_BUF_INIT;
 
-	const char *email = 
+	const char *email =
 	"From 10808fe9c9be5a190c0ba68d1a002233fb363508 Mon Sep 17 00:00:00 2001\n" \
 	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
 	"Date: Thu, 10 Apr 2014 19:37:05 +0200\n" \
@@ -167,6 +179,7 @@ void test_diff_format_email__multiple(void)
 	"libgit2 " LIBGIT2_VERSION "\n" \
 	"\n";
 
+
 	git_oid_fromstr(&oid, "10808fe9c9be5a190c0ba68d1a002233fb363508");
 	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
 
@@ -196,7 +209,7 @@ void test_diff_format_email__multiple(void)
 	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
 	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
 
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
+	cl_assert_equal_s(email, git_buf_cstr(&buf));
 
 	git_diff_free(diff);
 	git_commit_free(commit);
@@ -205,13 +218,8 @@ void test_diff_format_email__multiple(void)
 
 void test_diff_format_email__exclude_marker(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
 	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
-	git_buf buf = GIT_BUF_INIT;
-
-	const char *email = 
+	const char *email =
 	"From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \
 	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
 	"Date: Wed, 9 Apr 2014 20:57:01 +0200\n" \
@@ -250,27 +258,10 @@ void test_diff_format_email__exclude_marker(void)
 	"libgit2 " LIBGIT2_VERSION "\n" \
 	"\n";
 
-	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-
-	opts.id = git_commit_id(commit);
-	opts.author = git_commit_author(commit);
-	opts.summary = git_commit_summary(commit);
-
 	opts.flags |= GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER;
 
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_buf_clear(&buf);
-	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1,
-		GIT_DIFF_FORMAT_EMAIL_EXCLUDE_SUBJECT_PATCH_MARKER, NULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_diff_free(diff);
-	git_commit_free(commit);
-	git_buf_free(&buf);
+	assert_email_match(
+		email, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts);
 }
 
 void test_diff_format_email__invalid_no(void)
@@ -303,13 +294,8 @@ void test_diff_format_email__invalid_no(void)
 
 void test_diff_format_email__mode_change(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
 	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
-	git_buf buf = GIT_BUF_INIT;
-
-	const char *email = 
+	const char *email =
 	"From 7ade76dd34bba4733cf9878079f9fd4a456a9189 Mon Sep 17 00:00:00 2001\n" \
 	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
 	"Date: Thu, 10 Apr 2014 10:05:03 +0200\n" \
@@ -330,36 +316,14 @@ void test_diff_format_email__mode_change(void)
 	"libgit2 " LIBGIT2_VERSION "\n" \
 	"\n";
 
-	git_oid_fromstr(&oid, "7ade76dd34bba4733cf9878079f9fd4a456a9189");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-
-	opts.id = git_commit_id(commit);
-	opts.author = git_commit_author(commit);
-	opts.summary = git_commit_summary(commit);
-
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_buf_clear(&buf);
-	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1, 0, NULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_diff_free(diff);
-	git_commit_free(commit);
-	git_buf_free(&buf);
+	assert_email_match(
+		email, "7ade76dd34bba4733cf9878079f9fd4a456a9189", &opts);
 }
 
 void test_diff_format_email__rename_add_remove(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
 	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
-	git_buf buf = GIT_BUF_INIT;
-
-	const char *email = 
+	const char *email =
 	"From 6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d Mon Sep 17 00:00:00 2001\n" \
 	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
 	"Date: Wed, 9 Apr 2014 21:15:56 +0200\n" \
@@ -422,35 +386,13 @@ void test_diff_format_email__rename_add_remove(void)
 	"libgit2 " LIBGIT2_VERSION "\n" \
 	"\n";
 
-	git_oid_fromstr(&oid, "6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-
-	opts.id = git_commit_id(commit);
-	opts.author = git_commit_author(commit);
-	opts.summary = git_commit_summary(commit);
-
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_buf_clear(&buf);
-	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1, 0, NULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_diff_free(diff);
-	git_commit_free(commit);
-	git_buf_free(&buf);
+	assert_email_match(
+		email, "6e05acc5a5dab507d91a0a0cc0fb05a3dd98892d", &opts);
 }
 
 void test_diff_format_email__multiline_summary(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
 	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
-	git_buf buf = GIT_BUF_INIT;
-
 	const char *email =
 	"From 9264b96c6d104d0e07ae33d3007b6a48246c6f92 Mon Sep 17 00:00:00 2001\n" \
 	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
@@ -490,36 +432,15 @@ void test_diff_format_email__multiline_summary(void)
 	"libgit2 " LIBGIT2_VERSION "\n" \
 	"\n";
 
-	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-
-	opts.id = git_commit_id(commit);
-	opts.author = git_commit_author(commit);
 	opts.summary = "Modify some content\nSome extra stuff here";
 
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_buf_clear(&buf);
-	cl_git_pass(git_diff_commit_as_email(&buf, repo, commit, 1, 1, 0, NULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_diff_free(diff);
-	git_commit_free(commit);
-	git_buf_free(&buf);
+	assert_email_match(
+		email, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", &opts);
 }
 
 void test_diff_format_email__binary(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
 	git_diff_format_email_options opts = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
-	git_buf buf = GIT_BUF_INIT;
-
-	/* TODO: Actually 0 bytes here should be 5!. Seems like we don't load the new content for binary files? */
 	const char *email =
 	"From 8d7523f6fcb2404257889abe0d96f093d9f524f9 Mon Sep 17 00:00:00 2001\n" \
 	"From: Jacques Germishuys <jacquesg@striata.com>\n" \
@@ -536,21 +457,11 @@ void test_diff_format_email__binary(void)
 	"--\n" \
 	"libgit2 " LIBGIT2_VERSION "\n" \
 	"\n";
+	/* TODO: Actually 0 bytes here should be 5!. Seems like we don't load the new content for binary files? */
 
-	git_oid_fromstr(&oid, "8d7523f6fcb2404257889abe0d96f093d9f524f9");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-
-	opts.id = git_commit_id(commit);
-	opts.author = git_commit_author(commit);
 	opts.summary = "Modified binary file";
 
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_format_email(&buf, diff, &opts));
-	cl_assert(strcmp(git_buf_cstr(&buf), email) == 0);
-
-	git_diff_free(diff);
-	git_commit_free(commit);
-	git_buf_free(&buf);
+	assert_email_match(
+		email, "8d7523f6fcb2404257889abe0d96f093d9f524f9", &opts);
 }
 
diff --git a/tests/diff/stats.c b/tests/diff/stats.c
index 131b7681d..055019f69 100644
--- a/tests/diff/stats.c
+++ b/tests/diff/stats.c
@@ -5,246 +5,173 @@
 #include "commit.h"
 #include "diff.h"
 
-static git_repository *repo;
+static git_repository *_repo;
+static git_diff_stats *_stats;
 
 void test_diff_stats__initialize(void)
 {
-	repo = cl_git_sandbox_init("diff_format_email");
+	_repo = cl_git_sandbox_init("diff_format_email");
 }
 
 void test_diff_stats__cleanup(void)
 {
+	git_diff_stats_free(_stats); _stats = NULL;
 	cl_git_sandbox_cleanup();
 }
 
-void test_diff_stats__stat(void)
+static void diff_stats_from_commit_oid(
+	git_diff_stats **stats, const char *oidstr, bool rename)
 {
 	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
-	git_buf buf = GIT_BUF_INIT;
+	git_commit *commit;
+	git_diff *diff;
+
+	git_oid_fromstr(&oid, oidstr);
+	cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
+	cl_git_pass(git_diff__commit(&diff, _repo, commit, NULL));
+	if (rename)
+		cl_git_pass(git_diff_find_similar(diff, NULL));
+	cl_git_pass(git_diff_get_stats(stats, diff));
+
+	git_diff_free(diff);
+	git_commit_free(commit);
+}
 
+void test_diff_stats__stat(void)
+{
+	git_buf buf = GIT_BUF_INIT;
 	const char *stat =
 	" file1.txt | 8 +++++---\n" \
 	" 1 file changed, 5 insertions(+), 3 deletions(-)\n";
 
-	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
+	diff_stats_from_commit_oid(
+		&_stats, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", false);
 
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_assert_equal_sz(1, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(5, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(3, git_diff_stats_deletions(_stats));
 
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 1);
-	cl_assert(git_diff_stats_insertions(stats) == 5);
-	cl_assert(git_diff_stats_deletions(stats) == 3);
-
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
 	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__multiple_hunks(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" file2.txt | 5 +++--\n" \
 	" file3.txt | 6 ++++--\n" \
 	" 2 files changed, 7 insertions(+), 4 deletions(-)\n";
 
-	git_oid_fromstr(&oid, "cd471f0d8770371e1bc78bcbb38db4c7e4106bd2");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	diff_stats_from_commit_oid(
+		&_stats, "cd471f0d8770371e1bc78bcbb38db4c7e4106bd2", false);
 
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 2);
-	cl_assert(git_diff_stats_insertions(stats) == 7);
-	cl_assert(git_diff_stats_deletions(stats) == 4);
+	cl_assert_equal_sz(2, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(7, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(4, git_diff_stats_deletions(_stats));
 
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__numstat(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	"3       2       file2.txt\n"
 	"4       2       file3.txt\n";
 
-	git_oid_fromstr(&oid, "cd471f0d8770371e1bc78bcbb38db4c7e4106bd2");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_NUMBER));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+	diff_stats_from_commit_oid(
+		&_stats, "cd471f0d8770371e1bc78bcbb38db4c7e4106bd2", false);
 
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_NUMBER, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__shortstat(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" 1 file changed, 5 insertions(+), 3 deletions(-)\n";
 
-	git_oid_fromstr(&oid, "9264b96c6d104d0e07ae33d3007b6a48246c6f92");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	diff_stats_from_commit_oid(
+		&_stats, "9264b96c6d104d0e07ae33d3007b6a48246c6f92", false);
 
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 1);
-	cl_assert(git_diff_stats_insertions(stats) == 5);
-	cl_assert(git_diff_stats_deletions(stats) == 3);
+	cl_assert_equal_sz(1, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(5, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(3, git_diff_stats_deletions(_stats));
 
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_SHORT));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_SHORT, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__rename(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" file2.txt => file2.txt.renamed | 1 +\n"
 	" file3.txt => file3.txt.renamed | 4 +++-\n"
-	" 2 files changed, 4 insertions(+), 1 deletions(-)\n";
-
-	git_oid_fromstr(&oid, "8947a46e2097638ca6040ad4877246f4186ec3bd");
+	" 2 files changed, 4 insertions(+), 1 deletion(-)\n";
 
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_find_similar(diff, NULL));
+	diff_stats_from_commit_oid(
+		&_stats, "8947a46e2097638ca6040ad4877246f4186ec3bd", true);
 
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 2);
-	cl_assert(git_diff_stats_insertions(stats) == 4);
-	cl_assert(git_diff_stats_deletions(stats) == 1);
+	cl_assert_equal_sz(2, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(4, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(1, git_diff_stats_deletions(_stats));
 
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__rename_nochanges(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" file2.txt.renamed => file2.txt.renamed2 | 0\n"
 	" file3.txt.renamed => file3.txt.renamed2 | 0\n"
 	" 2 files changed, 0 insertions(+), 0 deletions(-)\n";
 
-	git_oid_fromstr(&oid, "3991dce9e71a0641ca49a6a4eea6c9e7ff402ed4");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_find_similar(diff, NULL));
+	diff_stats_from_commit_oid(
+		&_stats, "3991dce9e71a0641ca49a6a4eea6c9e7ff402ed4", true);
 
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 2);
-	cl_assert(git_diff_stats_insertions(stats) == 0);
-	cl_assert(git_diff_stats_deletions(stats) == 0);
+	cl_assert_equal_sz(2, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(0, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(0, git_diff_stats_deletions(_stats));
 
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__rename_and_modifiy(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" file2.txt.renamed2                      | 2 +-\n"
 	" file3.txt.renamed2 => file3.txt.renamed | 0\n"
-	" 2 files changed, 1 insertions(+), 1 deletions(-)\n";
+	" 2 files changed, 1 insertion(+), 1 deletion(-)\n";
 
-	git_oid_fromstr(&oid, "4ca10087e696d2ba78d07b146a118e9a7096ed4f");
+	diff_stats_from_commit_oid(
+		&_stats, "4ca10087e696d2ba78d07b146a118e9a7096ed4f", true);
 
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-	cl_git_pass(git_diff_find_similar(diff, NULL));
+	cl_assert_equal_sz(2, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(1, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(1, git_diff_stats_deletions(_stats));
 
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 2);
-	cl_assert(git_diff_stats_insertions(stats) == 1);
-	cl_assert(git_diff_stats_deletions(stats) == 1);
-
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__rename_no_find(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" file2.txt         | 5 -----\n"
 	" file2.txt.renamed | 6 ++++++\n"
@@ -252,33 +179,21 @@ void test_diff_stats__rename_no_find(void)
 	" file3.txt.renamed | 7 +++++++\n"
 	" 4 files changed, 13 insertions(+), 10 deletions(-)\n";
 
-	git_oid_fromstr(&oid, "8947a46e2097638ca6040ad4877246f4186ec3bd");
+	diff_stats_from_commit_oid(
+		&_stats, "8947a46e2097638ca6040ad4877246f4186ec3bd", false);
 
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	cl_assert_equal_sz(4, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(13, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(10, git_diff_stats_deletions(_stats));
 
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 4);
-	cl_assert(git_diff_stats_insertions(stats) == 13);
-	cl_assert(git_diff_stats_deletions(stats) == 10);
-
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__rename_nochanges_no_find(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" file2.txt.renamed  | 6 ------\n"
 	" file2.txt.renamed2 | 6 ++++++\n"
@@ -286,143 +201,85 @@ void test_diff_stats__rename_nochanges_no_find(void)
 	" file3.txt.renamed2 | 7 +++++++\n"
 	" 4 files changed, 13 insertions(+), 13 deletions(-)\n";
 
-	git_oid_fromstr(&oid, "3991dce9e71a0641ca49a6a4eea6c9e7ff402ed4");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
+	diff_stats_from_commit_oid(
+		&_stats, "3991dce9e71a0641ca49a6a4eea6c9e7ff402ed4", false);
 
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 4);
-	cl_assert(git_diff_stats_insertions(stats) == 13);
-	cl_assert(git_diff_stats_deletions(stats) == 13);
-
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+	cl_assert_equal_sz(4, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(13, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(13, git_diff_stats_deletions(_stats));
 
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__rename_and_modifiy_no_find(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" file2.txt.renamed2 | 2 +-\n"
 	" file3.txt.renamed  | 7 +++++++\n"
 	" file3.txt.renamed2 | 7 -------\n"
 	" 3 files changed, 8 insertions(+), 8 deletions(-)\n";
 
-	git_oid_fromstr(&oid, "4ca10087e696d2ba78d07b146a118e9a7096ed4f");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 3);
-	cl_assert(git_diff_stats_insertions(stats) == 8);
-	cl_assert(git_diff_stats_deletions(stats) == 8);
+	diff_stats_from_commit_oid(
+		&_stats, "4ca10087e696d2ba78d07b146a118e9a7096ed4f", false);
 
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+	cl_assert_equal_sz(3, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(8, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(8, git_diff_stats_deletions(_stats));
 
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__binary(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
-	/* TODO: Actually 0 bytes here should be 5!. Seems like we don't load the new content for binary files? */
 	const char *stat =
 	" binary.bin | Bin 3 -> 0 bytes\n"
 	" 1 file changed, 0 insertions(+), 0 deletions(-)\n";
+	/* TODO: Actually 0 bytes here should be 5!. Seems like we don't load the new content for binary files? */
 
-	git_oid_fromstr(&oid, "8d7523f6fcb2404257889abe0d96f093d9f524f9");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-	cl_assert(git_diff_stats_files_changed(stats) == 1);
-	cl_assert(git_diff_stats_insertions(stats) == 0);
-	cl_assert(git_diff_stats_deletions(stats) == 0);
+	diff_stats_from_commit_oid(
+		&_stats, "8d7523f6fcb2404257889abe0d96f093d9f524f9", false);
 
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+	cl_assert_equal_sz(1, git_diff_stats_files_changed(_stats));
+	cl_assert_equal_sz(0, git_diff_stats_insertions(_stats));
+	cl_assert_equal_sz(0, git_diff_stats_deletions(_stats));
 
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__binary_numstat(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	"-       -       binary.bin\n";
 
-	git_oid_fromstr(&oid, "8d7523f6fcb2404257889abe0d96f093d9f524f9");
-
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-
-	cl_git_pass(git_diff_get_stats(&stats, diff));
+	diff_stats_from_commit_oid(
+		&_stats, "8d7523f6fcb2404257889abe0d96f093d9f524f9", false);
 
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_NUMBER));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_NUMBER, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
 
 void test_diff_stats__mode_change(void)
 {
-	git_oid oid;
-	git_commit *commit = NULL;
-	git_diff *diff = NULL;
-	git_diff_stats *stats = NULL;
 	git_buf buf = GIT_BUF_INIT;
-
 	const char *stat =
 	" file1.txt.renamed | 0\n" \
 	" 1 file changed, 0 insertions(+), 0 deletions(-)\n" \
-	" mode change 100644 => 100755 file1.txt.renamed\n" \
-	"\n";
+		" mode change 100644 => 100755 file1.txt.renamed\n";
 
-	git_oid_fromstr(&oid, "7ade76dd34bba4733cf9878079f9fd4a456a9189");
+	diff_stats_from_commit_oid(
+		&_stats, "7ade76dd34bba4733cf9878079f9fd4a456a9189", false);
 
-	cl_git_pass(git_commit_lookup(&commit, repo, &oid));
-	cl_git_pass(git_diff__commit(&diff, repo, commit, NULL));
-
-	cl_git_pass(git_diff_get_stats(&stats, diff));
-
-	cl_git_pass(git_diff_stats_to_buf(&buf, stats, GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY));
-	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
-
-	git_diff_stats_free(stats);
-	git_diff_free(diff);
-	git_commit_free(commit);
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL | GIT_DIFF_STATS_INCLUDE_SUMMARY, 0));
+	cl_assert_equal_s(stat, git_buf_cstr(&buf));
 	git_buf_free(&buf);
 }
-- 
cgit v1.2.3


From e60883c82f1c4d44be856e545b4cbeea27522416 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 22 Apr 2014 12:59:31 -0700
Subject: Replace math fns with simpler integer math

---
 src/diff_stats.c | 34 +++++++++++++++++++++++-----------
 1 file changed, 23 insertions(+), 11 deletions(-)

diff --git a/src/diff_stats.c b/src/diff_stats.c
index 8a71be894..6ad670c42 100644
--- a/src/diff_stats.c
+++ b/src/diff_stats.c
@@ -8,7 +8,6 @@
 #include "vector.h"
 #include "diff.h"
 #include "diff_patch.h"
-#include <math.h>
 
 #define DIFF_RENAME_FILE_SEPARATOR " => "
 #define STATS_FULL_MIN_SCALE 7
@@ -32,12 +31,25 @@ struct git_diff_stats {
 	int max_digits;
 };
 
+static int digits_for_value(size_t val)
+{
+	int count = 1;
+	size_t placevalue = 10;
+
+	while (val >= placevalue) {
+		++count;
+		placevalue *= 10;
+	}
+
+	return count;
+}
+
 int git_diff_file_stats__full_to_buf(
 	git_buf *out,
 	const git_diff_delta *delta,
 	const diff_file_stats *filestat,
 	const git_diff_stats *stats,
-	double scale_to)
+	size_t width)
 {
 	const char *old_path = NULL, *new_path = NULL;
 	size_t padding, old_size, new_size;
@@ -81,15 +93,16 @@ int git_diff_file_stats__full_to_buf(
 			if (git_buf_putc(out, ' ') < 0)
 				goto on_error;
 
-			if (scale_to <= 0) {
+			if (!width) {
 				if (git_buf_putcn(out, '+', filestat->insertions) < 0 ||
 					git_buf_putcn(out, '-', filestat->deletions) < 0)
 					goto on_error;
 			} else {
 				size_t total = filestat->insertions + filestat->deletions;
-				double full = round(total * scale_to / stats->max_filestat);
+				size_t full = (total * width + stats->max_filestat / 2) /
+					stats->max_filestat;
 				size_t plus = full * filestat->insertions / total;
-				size_t minus = (size_t)full - plus;
+				size_t minus = full - plus;
 
 				if (git_buf_putcn(out, '+', max(plus,  1)) < 0 ||
 					git_buf_putcn(out, '-', max(minus, 1)) < 0)
@@ -205,7 +218,7 @@ int git_diff_get_stats(
 	stats->files_changed = deltas;
 	stats->insertions = total_insertions;
 	stats->deletions = total_deletions;
-	stats->max_digits = (int)ceil(log10(stats->max_filestat + 1));
+	stats->max_digits = digits_for_value(stats->max_filestat + 1);
 
 	if (error < 0) {
 		git_diff_stats_free(stats);
@@ -265,12 +278,11 @@ int git_diff_stats_to_buf(
 	}
 
 	if (format & GIT_DIFF_STATS_FULL) {
-		double scale_to = -1;
 		if (width > 0) {
 			if (width > stats->max_name + stats->max_digits + 5)
-				scale_to = width - (stats->max_name + stats->max_digits + 5);
-			if (scale_to < STATS_FULL_MIN_SCALE)
-				scale_to = STATS_FULL_MIN_SCALE;
+				width -= (stats->max_name + stats->max_digits + 5);
+			if (width < STATS_FULL_MIN_SCALE)
+				width = STATS_FULL_MIN_SCALE;
 		}
 
 		for (i = 0; i < stats->files_changed; ++i) {
@@ -278,7 +290,7 @@ int git_diff_stats_to_buf(
 				continue;
 
 			error = git_diff_file_stats__full_to_buf(
-				out, delta, &stats->filestats[i], stats, scale_to);
+				out, delta, &stats->filestats[i], stats, width);
 			if (error < 0)
 				return error;
 		}
-- 
cgit v1.2.3


From 24d17de255caa57b01c0c758e6fc81aad493806e Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 2 Apr 2014 12:07:27 -0700
Subject: Make stash and checkout ignore contained repos

To emulate git, stash should not remove untracked git repositories
inside the parent repo, and checkout's REMOVE_UNTRACKED should
also skip over these items.

`git stash` actually prints a warning message for these items.
That should be possible with a checkout notify callback if you
wanted to, although it would require a bit of extra logic as things
are at the moment.
---
 src/checkout.c              | 17 +++++++++++++++--
 src/stash.c                 |  3 ++-
 tests/stash/save.c          | 17 ++++++++++++++++-
 tests/stash/stash_helpers.c | 13 +++++--------
 4 files changed, 38 insertions(+), 12 deletions(-)

diff --git a/src/checkout.c b/src/checkout.c
index 0b385226b..04b2a66b2 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -259,6 +259,17 @@ static int checkout_action_no_wd(
 	return checkout_action_common(action, data, delta, NULL);
 }
 
+static bool wd_item_is_removable(git_iterator *iter, const git_index_entry *wd)
+{
+	git_buf *full = NULL;
+
+	if (wd->mode != GIT_FILEMODE_TREE)
+		return true;
+	if (git_iterator_current_workdir_path(&full, iter) < 0)
+		return true;
+	return !full || !git_path_contains(full, DOT_GIT);
+}
+
 static int checkout_action_wd_only(
 	checkout_data *data,
 	git_iterator *workdir,
@@ -307,11 +318,13 @@ static int checkout_action_wd_only(
 		/* found in index */;
 	else if (git_iterator_current_is_ignored(workdir)) {
 		notify = GIT_CHECKOUT_NOTIFY_IGNORED;
-		remove = ((data->strategy & GIT_CHECKOUT_REMOVE_IGNORED) != 0);
+		remove = ((data->strategy & GIT_CHECKOUT_REMOVE_IGNORED) != 0) &&
+			wd_item_is_removable(workdir, wd);
 	}
 	else {
 		notify = GIT_CHECKOUT_NOTIFY_UNTRACKED;
-		remove = ((data->strategy & GIT_CHECKOUT_REMOVE_UNTRACKED) != 0);
+		remove = ((data->strategy & GIT_CHECKOUT_REMOVE_UNTRACKED) != 0) &&
+			wd_item_is_removable(workdir, wd);
 	}
 
 	error = checkout_notify(data, notify, NULL, wd);
diff --git a/src/stash.c b/src/stash.c
index d20e29b80..86e0a627c 100644
--- a/src/stash.c
+++ b/src/stash.c
@@ -178,7 +178,8 @@ static int stash_update_index_from_diff(
 			break;
 
 		case GIT_DELTA_UNTRACKED:
-			if (data->include_untracked)
+			if (data->include_untracked &&
+				delta->new_file.mode != GIT_FILEMODE_TREE)
 				add_path = delta->new_file.path;
 			break;
 
diff --git a/tests/stash/save.c b/tests/stash/save.c
index f06c1fb71..5165eeadf 100644
--- a/tests/stash/save.c
+++ b/tests/stash/save.c
@@ -342,7 +342,7 @@ void test_stash_save__can_stage_normal_then_stage_untracked(void)
 
 void test_stash_save__including_untracked_without_any_untracked_file_creates_an_empty_tree(void)
 {
-	cl_git_pass(p_unlink("stash/when"));
+	cl_must_pass(p_unlink("stash/when"));
 
 	assert_status(repo, "what", GIT_STATUS_WT_MODIFIED | GIT_STATUS_INDEX_MODIFIED);
 	assert_status(repo, "how", GIT_STATUS_INDEX_MODIFIED);
@@ -354,3 +354,18 @@ void test_stash_save__including_untracked_without_any_untracked_file_creates_an_
 
 	assert_object_oid("stash^3^{tree}", EMPTY_TREE, GIT_OBJ_TREE);
 }
+
+void test_stash_save__skip_submodules(void)
+{
+	git_repository *untracked_repo;
+	cl_git_pass(git_repository_init(&untracked_repo, "stash/untracked_repo", false));
+	cl_git_mkfile("stash/untracked_repo/content", "stuff");
+	git_repository_free(untracked_repo);
+
+	assert_status(repo, "untracked_repo/", GIT_STATUS_WT_NEW);
+
+	cl_git_pass(git_stash_save(
+		&stash_tip_oid, repo, signature, NULL, GIT_STASH_INCLUDE_UNTRACKED));
+
+	assert_status(repo, "untracked_repo/", GIT_STATUS_WT_NEW);
+}
diff --git a/tests/stash/stash_helpers.c b/tests/stash/stash_helpers.c
index 8b7d685f8..29cb25c5f 100644
--- a/tests/stash/stash_helpers.c
+++ b/tests/stash/stash_helpers.c
@@ -44,13 +44,10 @@ void assert_status(
 	unsigned int status;
 	int error;
 
-	error = git_status_file(&status, repo, path);
-
-	if (status_flags < 0) {
-		cl_assert_equal_i(status_flags, error);
-		return;
+	if (status_flags < 0)
+		cl_assert_equal_i(status_flags, git_status_file(&status, repo, path));
+	else {
+		cl_git_pass(git_status_file(&status, repo, path));
+		cl_assert_equal_i((unsigned int)status_flags, status);
 	}
-
-	cl_assert_equal_i(0, error);
-	cl_assert_equal_i((unsigned int)status_flags, status);
 }
-- 
cgit v1.2.3


From 3c1aa4c110d2d4c8c3d941b0e4ba66357172da2e Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 22 Apr 2014 15:23:39 -0700
Subject: Failing test for stashing a buried ignored file

---
 tests/stash/save.c | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/tests/stash/save.c b/tests/stash/save.c
index 5165eeadf..7bbd4c8dc 100644
--- a/tests/stash/save.c
+++ b/tests/stash/save.c
@@ -148,6 +148,19 @@ void test_stash_save__can_include_untracked_files(void)
 	assert_blob_oid("refs/stash^3:just.ignore", NULL);
 }
 
+void test_stash_save__untracked_skips_ignored(void)
+{
+	cl_git_append2file("stash/.gitignore", "bundle/vendor/\n");
+	cl_must_pass(p_mkdir("stash/bundle", 0777));
+	cl_must_pass(p_mkdir("stash/bundle/vendor", 0777));
+	cl_git_mkfile("stash/bundle/vendor/blah", "contents\n");
+
+	cl_git_pass(git_stash_save(
+		&stash_tip_oid, repo, signature, NULL, GIT_STASH_INCLUDE_UNTRACKED));
+
+	cl_assert(git_path_exists("stash/bundle/vendor/blah"));
+}
+
 void test_stash_save__can_include_untracked_and_ignored_files(void)
 {
 	cl_git_pass(git_stash_save(&stash_tip_oid, repo, signature, NULL, GIT_STASH_INCLUDE_UNTRACKED | GIT_STASH_INCLUDE_IGNORED));
-- 
cgit v1.2.3


From e349ed500b75349b1a525fce60dc08c8d8927ba0 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 22 Apr 2014 14:58:33 -0400
Subject: patch: emit binary patches (optionally)

---
 include/git2/diff.h |   4 +
 src/buffer.c        |  36 +++++++
 src/buffer.h        |   3 +
 src/diff_print.c    | 131 ++++++++++++++++++++++++--
 tests/core/buffer.c |  20 ++++
 tests/diff/binary.c | 263 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 tests/diff/patch.c  |   1 +
 7 files changed, 452 insertions(+), 6 deletions(-)
 create mode 100644 tests/diff/binary.c

diff --git a/include/git2/diff.h b/include/git2/diff.h
index a0cfbc918..bc8b250c3 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -180,6 +180,10 @@ typedef enum {
 	/** Take extra time to find minimal diff */
 	GIT_DIFF_MINIMAL = (1 << 29),
 
+	/** Include the necessary deflate / delta information so that `git-apply`
+	 *  can apply given diff information to binary files.
+	 */
+	GIT_DIFF_SHOW_BINARY = (1 << 30),
 } git_diff_option_t;
 
 /**
diff --git a/src/buffer.c b/src/buffer.c
index f6e34a445..5169c3e09 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -212,6 +212,42 @@ int git_buf_put_base64(git_buf *buf, const char *data, size_t len)
 	return 0;
 }
 
+static const char b85str[] =
+	"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
+
+int git_buf_put_base85(git_buf *buf, const char *data, size_t len)
+{
+	ENSURE_SIZE(buf, buf->size + (5 * ((len / 4) + !!(len % 4))) + 1);
+
+	while (len) {
+		uint32_t acc = 0;
+		char b85[5];
+		int i;
+
+		for (i = 24; i >= 0; i -= 8) {
+			uint8_t ch = *data++;
+			acc |= ch << i;
+
+			if (--len == 0)
+				break;
+		}
+
+		for (i = 4; i >= 0; i--) {
+			int val = acc % 85;
+			acc /= 85;
+
+			b85[i] = b85str[val];
+		}
+
+		for (i = 0; i < 5; i++)
+			buf->ptr[buf->size++] = b85[i];
+	}
+
+	buf->ptr[buf->size] = '\0';
+
+	return 0;
+}
+
 int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
 {
 	int len;
diff --git a/src/buffer.h b/src/buffer.h
index 398aec9b7..70d6d73b3 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -158,6 +158,9 @@ int git_buf_cmp(const git_buf *a, const git_buf *b);
 /* Write data as base64 encoded in buffer */
 int git_buf_put_base64(git_buf *buf, const char *data, size_t len);
 
+/* Write data as "base85" encoded in buffer */
+int git_buf_put_base85(git_buf *buf, const char *data, size_t len);
+
 /*
  * Insert, remove or replace a portion of the buffer.
  *
diff --git a/src/diff_print.c b/src/diff_print.c
index a7f7b6fe8..e54155458 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -8,6 +8,9 @@
 #include "diff.h"
 #include "diff_patch.h"
 #include "fileops.h"
+#include "zstream.h"
+#include "blob.h"
+#include "delta.h"
 #include "git2/sys/diff.h"
 
 typedef struct {
@@ -37,6 +40,8 @@ static int diff_print_info_init(
 
 	if (diff)
 		pi->flags = diff->opts.flags;
+	else
+		pi->flags = 0;
 
 	if (diff && diff->opts.id_abbrev != 0)
 		pi->oid_strlen = diff->opts.id_abbrev;
@@ -276,6 +281,118 @@ int git_diff_delta__format_file_header(
 	return git_buf_oom(out) ? -1 : 0;
 }
 
+static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
+{
+	git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT, *out = NULL;
+	const void *old_data, *new_data;
+	size_t old_data_len, new_data_len, delta_data_len, inflated_len, remain;
+	const char *out_type = "literal";
+	char *ptr;
+	int error;
+
+	old_data = old ? git_blob_rawcontent(old) : NULL;
+	new_data = new ? git_blob_rawcontent(new) : NULL;
+
+	old_data_len = old ? (size_t)git_blob_rawsize(old) : 0;
+	new_data_len = new ? (size_t)git_blob_rawsize(new) : 0;
+
+	out = &deflate;
+	inflated_len = new_data_len;
+
+	if ((error = git_zstream_deflatebuf(
+		&deflate, new_data, new_data_len)) < 0)
+		goto done;
+
+	if (old && new) {
+		void *delta_data;
+
+		delta_data = git_delta(old_data, old_data_len, new_data,
+			new_data_len, &delta_data_len, deflate.size);
+
+		if (delta_data) {
+			error = git_zstream_deflatebuf(&delta, delta_data, delta_data_len);
+			free(delta_data);
+
+			if (error < 0)
+				goto done;
+
+			if (delta.size < deflate.size) {
+				out = &delta;
+				out_type = "delta";
+				inflated_len = delta_data_len;
+			}
+		}
+	}
+
+	git_buf_printf(pi->buf, "%s %" PRIuZ "\n", out_type, inflated_len);
+	pi->line.num_lines++;
+
+	for (ptr = out->ptr, remain = out->size; remain > 0; ) {
+		size_t chunk_len = (52 < remain) ? 52 : remain;
+
+		if (chunk_len <= 26)
+			git_buf_putc(pi->buf, chunk_len + 'A' - 1);
+		else
+			git_buf_putc(pi->buf, chunk_len - 26 + 'a' - 1);
+
+		git_buf_put_base85(pi->buf, ptr, chunk_len);
+		git_buf_putc(pi->buf, '\n');
+
+		if (git_buf_oom(pi->buf)) {
+			error = -1;
+			goto done;
+		}
+
+		ptr += chunk_len;
+		remain -= chunk_len;
+		pi->line.num_lines++;
+	}
+
+done:
+	git_buf_free(&deflate);
+	git_buf_free(&delta);
+
+	return error;
+}
+
+/* git diff --binary 8d7523f~2 8d7523f~1 */
+static int diff_print_patch_file_binary(
+	diff_print_info *pi, const git_diff_delta *delta,
+	const char *oldpfx, const char *newpfx)
+{
+	git_blob *old = NULL, *new = NULL;
+	const git_oid *old_id, *new_id;
+	int error;
+
+	if ((pi->flags & GIT_DIFF_SHOW_BINARY) == 0) {
+		pi->line.num_lines = 1;
+		return diff_delta_format_with_paths(
+			pi->buf, delta, oldpfx, newpfx,
+				"Binary files %s%s and %s%s differ\n");
+	}
+
+	git_buf_printf(pi->buf, "GIT binary patch\n");
+	pi->line.num_lines++;
+
+	old_id = (delta->status != GIT_DELTA_ADDED) ? &delta->old_file.id : NULL;
+	new_id = (delta->status != GIT_DELTA_DELETED) ? &delta->new_file.id : NULL;
+
+	if ((old_id && (error = git_blob_lookup(&old, pi->diff->repo, old_id)) < 0) ||
+		(new_id && (error = git_blob_lookup(&new, pi->diff->repo,new_id)) < 0) ||
+		(error = print_binary_hunk(pi, old, new)) < 0 ||
+		(error = git_buf_putc(pi->buf, '\n')) < 0 ||
+		(error = print_binary_hunk(pi, new, old)) < 0)
+		goto done;
+
+	pi->line.num_lines++;
+
+done:
+	git_blob_free(old);
+	git_blob_free(new);
+
+	return error;
+}
+
 static int diff_print_patch_file(
 	const git_diff_delta *delta, float progress, void *data)
 {
@@ -286,6 +403,11 @@ static int diff_print_patch_file(
 	const char *newpfx =
 		pi->diff ? pi->diff->opts.new_prefix : DIFF_NEW_PREFIX_DEFAULT;
 
+	bool binary = !!(delta->flags & GIT_DIFF_FLAG_BINARY);
+	bool show_binary = !!(pi->flags & GIT_DIFF_SHOW_BINARY);
+	int oid_strlen = binary && show_binary ?
+		GIT_OID_HEXSZ + 1 : pi->oid_strlen;
+
 	GIT_UNUSED(progress);
 
 	if (S_ISDIR(delta->new_file.mode) ||
@@ -296,7 +418,7 @@ static int diff_print_patch_file(
 		return 0;
 
 	if ((error = git_diff_delta__format_file_header(
-			pi->buf, delta, oldpfx, newpfx, pi->oid_strlen)) < 0)
+			pi->buf, delta, oldpfx, newpfx, oid_strlen)) < 0)
 		return error;
 
 	pi->line.origin      = GIT_DIFF_LINE_FILE_HDR;
@@ -306,20 +428,17 @@ static int diff_print_patch_file(
 	if ((error = pi->print_cb(delta, NULL, &pi->line, pi->payload)) != 0)
 		return error;
 
-	if ((delta->flags & GIT_DIFF_FLAG_BINARY) == 0)
+	if (!binary)
 		return 0;
 
 	git_buf_clear(pi->buf);
 
-	if ((error = diff_delta_format_with_paths(
-			pi->buf, delta, oldpfx, newpfx,
-			"Binary files %s%s and %s%s differ\n")) < 0)
+	if ((error = diff_print_patch_file_binary(pi, delta, oldpfx, newpfx)) < 0)
 		return error;
 
 	pi->line.origin      = GIT_DIFF_LINE_BINARY;
 	pi->line.content     = git_buf_cstr(pi->buf);
 	pi->line.content_len = git_buf_len(pi->buf);
-	pi->line.num_lines   = 1;
 
 	return pi->print_cb(delta, NULL, &pi->line, pi->payload);
 }
diff --git a/tests/core/buffer.c b/tests/core/buffer.c
index eb1d95a95..da5ec605c 100644
--- a/tests/core/buffer.c
+++ b/tests/core/buffer.c
@@ -773,6 +773,26 @@ void test_core_buffer__base64(void)
 	git_buf_free(&buf);
 }
 
+void test_core_buffer__base85(void)
+{
+	git_buf buf = GIT_BUF_INIT;
+
+	cl_git_pass(git_buf_put_base85(&buf, "this", 4));
+	cl_assert_equal_s("bZBXF", buf.ptr);
+	git_buf_clear(&buf);
+
+	cl_git_pass(git_buf_put_base85(&buf, "two rnds", 8));
+	cl_assert_equal_s("ba!tca&BaE", buf.ptr);
+	git_buf_clear(&buf);
+
+	cl_git_pass(git_buf_put_base85(&buf, "this is base 85 encoded",
+		strlen("this is base 85 encoded")));
+	cl_assert_equal_s("bZBXFAZc?TVqtS-AUHK3Wo~0{WMyOk", buf.ptr);
+	git_buf_clear(&buf);
+
+	git_buf_free(&buf);
+}
+
 void test_core_buffer__classify_with_utf8(void)
 {
 	char *data0 = "Simple text\n";
diff --git a/tests/diff/binary.c b/tests/diff/binary.c
new file mode 100644
index 000000000..cb574a588
--- /dev/null
+++ b/tests/diff/binary.c
@@ -0,0 +1,263 @@
+#include "clar_libgit2.h"
+
+#include "buffer.h"
+#include "filebuf.h"
+
+static git_repository *repo;
+
+void test_diff_binary__initialize(void)
+{
+}
+
+void test_diff_binary__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_patch(
+	const char *one,
+	const char *two,
+	const git_diff_options *opts,
+	const char *expected)
+{
+	git_oid id_one, id_two;
+	git_index *index = NULL;
+	git_commit *commit_one, *commit_two = NULL;
+	git_tree *tree_one, *tree_two;
+	git_diff *diff;
+	git_patch *patch;
+	git_buf actual = GIT_BUF_INIT;
+
+	cl_git_pass(git_oid_fromstr(&id_one, one));
+	cl_git_pass(git_commit_lookup(&commit_one, repo, &id_one));
+	cl_git_pass(git_commit_tree(&tree_one, commit_one));
+
+	if (two) {
+		cl_git_pass(git_oid_fromstr(&id_two, two));
+		cl_git_pass(git_commit_lookup(&commit_two, repo, &id_two));
+		cl_git_pass(git_commit_tree(&tree_two, commit_two));
+	} else {
+		cl_git_pass(git_repository_index(&index, repo));
+		cl_git_pass(git_index_write_tree(&id_two, index));
+		cl_git_pass(git_tree_lookup(&tree_two, repo, &id_two));
+	}
+
+	cl_git_pass(git_diff_tree_to_tree(&diff, repo, tree_one, tree_two, opts));
+
+	cl_git_pass(git_patch_from_diff(&patch, diff, 0));
+	cl_git_pass(git_patch_to_buf(&actual, patch));
+
+	cl_assert_equal_s(expected, actual.ptr);
+
+	git_buf_free(&actual);
+	git_patch_free(patch);
+	git_diff_free(diff);
+	git_tree_free(tree_one);
+	git_tree_free(tree_two);
+	git_commit_free(commit_one);
+	git_commit_free(commit_two);
+	git_index_free(index);
+}
+
+void test_diff_binary__add_normal(void)
+{
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *expected =
+		"diff --git a/binary.bin b/binary.bin\n" \
+		"new file mode 100644\n" \
+		"index 0000000..bd474b2\n" \
+		"Binary files /dev/null and b/binary.bin differ\n";
+
+	repo = cl_git_sandbox_init("diff_format_email");
+	test_patch(
+		"873806f6f27e631eb0b23e4b56bea2bfac14a373",
+		"897d3af16ca9e420cd071b1c4541bd2b91d04c8c",
+		&opts,
+		expected);
+}
+
+void test_diff_binary__add(void)
+{
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *expected =
+		"diff --git a/binary.bin b/binary.bin\n" \
+		"new file mode 100644\n" \
+		"index 0000000000000000000000000000000000000000..bd474b2519cc15eab801ff851cc7d50f0dee49a1\n" \
+		"GIT binary patch\n" \
+		"literal 3\n" \
+		"Kc${Nk-~s>u4FC%O\n"
+		"\n" \
+		"literal 0\n" \
+		"Hc$@<O00001\n";
+
+	opts.flags = GIT_DIFF_SHOW_BINARY;
+	opts.id_abbrev = GIT_OID_HEXSZ;
+
+	repo = cl_git_sandbox_init("diff_format_email");
+	test_patch(
+		"873806f6f27e631eb0b23e4b56bea2bfac14a373",
+		"897d3af16ca9e420cd071b1c4541bd2b91d04c8c",
+		&opts,
+		expected);
+}
+
+void test_diff_binary__modify_normal(void)
+{
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *expected =
+		"diff --git a/binary.bin b/binary.bin\n" \
+		"index bd474b2..9ac35ff 100644\n" \
+		"Binary files a/binary.bin and b/binary.bin differ\n";
+
+	repo = cl_git_sandbox_init("diff_format_email");
+	test_patch(
+		"897d3af16ca9e420cd071b1c4541bd2b91d04c8c",
+		"8d7523f6fcb2404257889abe0d96f093d9f524f9",
+		&opts,
+		expected);
+}
+
+void test_diff_binary__modify(void)
+{
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *expected =
+		"diff --git a/binary.bin b/binary.bin\n" \
+		"index bd474b2519cc15eab801ff851cc7d50f0dee49a1..9ac35ff15cd8864aeafd889e4826a3150f0b06c4 100644\n" \
+		"GIT binary patch\n" \
+		"literal 5\n" \
+		"Mc${NkU}WL~000&M4gdfE\n" \
+		"\n" \
+		"literal 3\n" \
+		"Kc${Nk-~s>u4FC%O\n";
+
+	opts.flags = GIT_DIFF_SHOW_BINARY;
+
+	repo = cl_git_sandbox_init("diff_format_email");
+	test_patch(
+		"897d3af16ca9e420cd071b1c4541bd2b91d04c8c",
+		"8d7523f6fcb2404257889abe0d96f093d9f524f9",
+		&opts,
+		expected);
+}
+
+void test_diff_binary__delete_normal(void)
+{
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *expected =
+		"diff --git a/binary.bin b/binary.bin\n" \
+		"deleted file mode 100644\n" \
+		"index bd474b2..0000000\n" \
+		"Binary files a/binary.bin and /dev/null differ\n";
+
+	repo = cl_git_sandbox_init("diff_format_email");
+	test_patch(
+		"897d3af16ca9e420cd071b1c4541bd2b91d04c8c",
+		"873806f6f27e631eb0b23e4b56bea2bfac14a373",
+		&opts,
+		expected);
+}
+
+void test_diff_binary__delete(void)
+{
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *expected =
+		"diff --git a/binary.bin b/binary.bin\n" \
+		"deleted file mode 100644\n" \
+		"index bd474b2519cc15eab801ff851cc7d50f0dee49a1..0000000000000000000000000000000000000000\n" \
+		"GIT binary patch\n" \
+		"literal 0\n" \
+		"Hc$@<O00001\n" \
+		"\n" \
+		"literal 3\n" \
+		"Kc${Nk-~s>u4FC%O\n";
+
+	opts.flags = GIT_DIFF_SHOW_BINARY;
+	opts.id_abbrev = GIT_OID_HEXSZ;
+
+	repo = cl_git_sandbox_init("diff_format_email");
+	test_patch(
+		"897d3af16ca9e420cd071b1c4541bd2b91d04c8c",
+		"873806f6f27e631eb0b23e4b56bea2bfac14a373",
+		&opts,
+		expected);
+}
+
+void test_diff_binary__delta(void)
+{
+	git_index *index;
+	git_buf contents = GIT_BUF_INIT;
+	size_t i;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *expected =
+		"diff --git a/songof7cities.txt b/songof7cities.txt\n" \
+		"index 4210ffd5c390b21dd5483375e75288dea9ede512..cc84ec183351c9944ed90a619ca08911924055b5 100644\n" \
+		"GIT binary patch\n" \
+		"delta 198\n" \
+		"zc$}LmI8{(0BqLQJI6p64AwNwaIJGP_Pa)Ye#M3o+qJ$<Jl;sX*mF<MGCYv&*L7AHu\n" \
+		"zGA1*^gt?gYVN82wTbPO_W)+x<&1+cP;HrPHR>PQ;Y(X&QMK*C5^Br3bjG4d=XI^5@\n" \
+		"JfH567LIG)KJdFSV\n" \
+		"\n" \
+		"delta 198\n" \
+		"zc$}LmI8{(0BqLQJI6p64AwNwaIJGP_Pr*5}Br~;mqJ$<Jl;sX*mF<MGCYv&*L7AHu\n" \
+		"zGA1*^gt?gYVN82wTbPO_W)+x<&1+cP;HrPHR>PQ;Y(X&QMK*C5^Br3bjG4d=XI^5@\n" \
+		"JfH567LIF3FM2!Fd\n";
+
+	opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY;
+	opts.id_abbrev = GIT_OID_HEXSZ;
+
+	repo = cl_git_sandbox_init("renames");
+	cl_git_pass(git_repository_index(&index, repo));
+
+	cl_git_pass(git_futils_readbuffer(&contents, "renames/songof7cities.txt"));
+
+	for (i = 0; i < contents.size - 6; i++) {
+		if (strncmp(&contents.ptr[i], "Cities", 6) == 0)
+			memcpy(&contents.ptr[i], "cITIES", 6);
+	}
+
+	cl_git_rewritefile("renames/songof7cities.txt", contents.ptr);
+	cl_git_pass(git_index_add_bypath(index, "songof7cities.txt"));
+	cl_git_pass(git_index_write(index));
+
+	test_patch(
+		"19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13",
+		NULL,
+		&opts,
+		expected);
+
+	git_index_free(index);
+	git_buf_free(&contents);
+}
+
+void test_diff_binary__delta_append(void)
+{
+	git_index *index;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	const char *expected =
+		"diff --git a/untimely.txt b/untimely.txt\n" \
+		"index 9a69d960ae94b060f56c2a8702545e2bb1abb935..1111d4f11f4b35bf6759e0fb714fe09731ef0840 100644\n" \
+		"GIT binary patch\n" \
+		"delta 32\n" \
+		"nc%1vf+QYWt3zLL@hC)e3Vu?a>QDRl4f_G*?PG(-ZA}<#J$+QbW\n" \
+		"\n" \
+		"delta 7\n" \
+		"Oc%18D`@*{63ljhg(E~C7\n";
+
+	opts.flags = GIT_DIFF_SHOW_BINARY | GIT_DIFF_FORCE_BINARY;
+	opts.id_abbrev = GIT_OID_HEXSZ;
+
+	repo = cl_git_sandbox_init("renames");
+	cl_git_pass(git_repository_index(&index, repo));
+
+	cl_git_append2file("renames/untimely.txt", "Oh that crazy Kipling!\r\n");
+	cl_git_pass(git_index_add_bypath(index, "untimely.txt"));
+	cl_git_pass(git_index_write(index));
+
+	test_patch(
+		"19dd32dfb1520a64e5bbaae8dce6ef423dfa2f13",
+		NULL,
+		&opts,
+		expected);
+
+	git_index_free(index);
+}
diff --git a/tests/diff/patch.c b/tests/diff/patch.c
index 76d7fcde3..1184d1968 100644
--- a/tests/diff/patch.c
+++ b/tests/diff/patch.c
@@ -2,6 +2,7 @@
 #include "git2/sys/repository.h"
 
 #include "diff_helpers.h"
+#include "diff.h"
 #include "repository.h"
 #include "buf_text.h"
 
-- 
cgit v1.2.3


From 37da368545b28157e625212e8009ec041cc4a4ea Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 22 Apr 2014 21:51:54 -0700
Subject: Make checkout match diff for untracked/ignored dir

When diff finds an untracked directory, it emulates Git behavior
by looking inside the directory to see if there are any untracked
items inside it. If there are only ignored items inside the dir,
then diff considers it ignored, even if there is no direct ignore
rule for it.

Checkout was not copying this behavior - when it found an untracked
directory, it just treated it as untracked.  Unfortunately, when
combined with GIT_CHECKOUT_REMOVE_UNTRACKED, this made is seem that
checkout (and stash, which uses checkout) was removing ignored
items when you had only asked it to remove untracked ones.

This commit moves the logic for advancing past an untracked dir
while scanning for non-ignored items into an iterator helper fn,
and uses that for both diff and checkout.
---
 src/checkout.c              | 85 ++++++++++++++++++++++++++++++---------------
 src/diff.c                  | 77 ++++------------------------------------
 src/iterator.c              | 68 ++++++++++++++++++++++++++++++++++++
 src/iterator.h              |  8 +++++
 tests/stash/save.c          |  6 ++++
 tests/stash/stash_helpers.c |  1 -
 6 files changed, 146 insertions(+), 99 deletions(-)

diff --git a/src/checkout.c b/src/checkout.c
index 04b2a66b2..a412c4c4e 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -56,6 +56,7 @@ typedef struct {
 	git_vector conflicts;
 	git_buf path;
 	size_t workdir_len;
+	git_buf tmp;
 	unsigned int strategy;
 	int can_symlink;
 	bool reload_submodules;
@@ -270,21 +271,30 @@ static bool wd_item_is_removable(git_iterator *iter, const git_index_entry *wd)
 	return !full || !git_path_contains(full, DOT_GIT);
 }
 
+static int checkout_queue_remove(checkout_data *data, const char *path)
+{
+	char *copy = git_pool_strdup(&data->pool, path);
+	GITERR_CHECK_ALLOC(copy);
+	return git_vector_insert(&data->removes, copy);
+}
+
+/* note that this advances the iterator over the wd item */
 static int checkout_action_wd_only(
 	checkout_data *data,
 	git_iterator *workdir,
-	const git_index_entry *wd,
+	const git_index_entry **wditem,
 	git_vector *pathspec)
 {
 	int error = 0;
 	bool remove = false;
 	git_checkout_notify_t notify = GIT_CHECKOUT_NOTIFY_NONE;
+	const git_index_entry *wd = *wditem;
 
 	if (!git_pathspec__match(
 			pathspec, wd->path,
 			(data->strategy & GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH) != 0,
 			git_iterator_ignore_case(workdir), NULL, NULL))
-		return 0;
+		return git_iterator_advance(wditem, workdir);
 
 	/* check if item is tracked in the index but not in the checkout diff */
 	if (data->index != NULL) {
@@ -314,26 +324,49 @@ static int checkout_action_wd_only(
 		}
 	}
 
-	if (notify != GIT_CHECKOUT_NOTIFY_NONE)
-		/* found in index */;
-	else if (git_iterator_current_is_ignored(workdir)) {
-		notify = GIT_CHECKOUT_NOTIFY_IGNORED;
-		remove = ((data->strategy & GIT_CHECKOUT_REMOVE_IGNORED) != 0) &&
-			wd_item_is_removable(workdir, wd);
-	}
-	else {
-		notify = GIT_CHECKOUT_NOTIFY_UNTRACKED;
-		remove = ((data->strategy & GIT_CHECKOUT_REMOVE_UNTRACKED) != 0) &&
-			wd_item_is_removable(workdir, wd);
-	}
+	if (notify != GIT_CHECKOUT_NOTIFY_NONE) {
+		/* if we found something in the index, notify and advance */
+		if ((error = checkout_notify(data, notify, NULL, wd)) != 0)
+			return error;
+
+		if (remove && wd_item_is_removable(workdir, wd))
+			error = checkout_queue_remove(data, wd->path);
 
-	error = checkout_notify(data, notify, NULL, wd);
+		if (!error)
+			error = git_iterator_advance(wditem, workdir);
+	} else {
+		/* untracked or ignored - can't know which until we advance through */
+		bool ignored, over = false;
+		bool removable = wd_item_is_removable(workdir, wd);
 
-	if (!error && remove) {
-		char *path = git_pool_strdup(&data->pool, wd->path);
-		GITERR_CHECK_ALLOC(path);
+		/* copy the entry for issuing notification callback later */
+		git_index_entry saved_wd = *wd;
+		git_buf_sets(&data->tmp, wd->path);
+		saved_wd.path = data->tmp.ptr;
 
-		error = git_vector_insert(&data->removes, path);
+		error = git_iterator_advance_over_and_check_ignored(
+			wditem, &ignored, workdir);
+		if (error == GIT_ITEROVER)
+			over = true;
+		else if (error < 0)
+			return error;
+
+		if (ignored) {
+			notify = GIT_CHECKOUT_NOTIFY_IGNORED;
+			remove = ((data->strategy & GIT_CHECKOUT_REMOVE_IGNORED) != 0);
+		} else {
+			notify = GIT_CHECKOUT_NOTIFY_UNTRACKED;
+			remove = ((data->strategy & GIT_CHECKOUT_REMOVE_UNTRACKED) != 0);
+		}
+
+		if ((error = checkout_notify(data, notify, NULL, &saved_wd)) != 0)
+			return error;
+
+		if (remove && removable)
+			error = checkout_queue_remove(data, saved_wd.path);
+
+		if (!error && over) /* restore ITEROVER if needed */
+			error = GIT_ITEROVER;
 	}
 
 	return error;
@@ -567,11 +600,8 @@ static int checkout_action(
 			}
 
 			/* case 1 - handle wd item (if it matches pathspec) */
-			error = checkout_action_wd_only(data, workdir, wd, pathspec);
-			if (error)
-				goto done;
-			if ((error = git_iterator_advance(wditem, workdir)) < 0 &&
-				error != GIT_ITEROVER)
+			error = checkout_action_wd_only(data, workdir, wditem, pathspec);
+			if (error && error != GIT_ITEROVER)
 				goto done;
 			continue;
 		}
@@ -632,10 +662,8 @@ static int checkout_remaining_wd_items(
 {
 	int error = 0;
 
-	while (wd && !error) {
-		if (!(error = checkout_action_wd_only(data, workdir, wd, spec)))
-			error = git_iterator_advance(&wd, workdir);
-	}
+	while (wd && !error)
+		error = checkout_action_wd_only(data, workdir, &wd, spec);
 
 	if (error == GIT_ITEROVER)
 		error = 0;
@@ -1866,6 +1894,7 @@ static void checkout_data_clear(checkout_data *data)
 	data->pfx = NULL;
 
 	git_buf_free(&data->path);
+	git_buf_free(&data->tmp);
 
 	git_index_free(data->index);
 	data->index = NULL;
diff --git a/src/diff.c b/src/diff.c
index 0d1aed4ad..f1c1b0543 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -784,72 +784,6 @@ static bool entry_is_prefixed(
 			item->path[pathlen] == '/');
 }
 
-static int diff_scan_inside_untracked_dir(
-	git_diff *diff, diff_in_progress *info, git_delta_t *delta_type)
-{
-	int error = 0;
-	git_buf base = GIT_BUF_INIT;
-	bool is_ignored;
-
-	*delta_type = GIT_DELTA_IGNORED;
-	git_buf_sets(&base, info->nitem->path);
-
-	/* advance into untracked directory */
-	if ((error = git_iterator_advance_into(&info->nitem, info->new_iter)) < 0) {
-
-		/* skip ahead if empty */
-		if (error == GIT_ENOTFOUND) {
-			giterr_clear();
-			error = git_iterator_advance(&info->nitem, info->new_iter);
-		}
-
-		goto done;
-	}
-
-	/* look for actual untracked file */
-	while (info->nitem != NULL &&
-		   !diff->pfxcomp(info->nitem->path, git_buf_cstr(&base))) {
-		is_ignored = git_iterator_current_is_ignored(info->new_iter);
-
-		/* need to recurse into non-ignored directories */
-		if (!is_ignored && S_ISDIR(info->nitem->mode)) {
-			error = git_iterator_advance_into(&info->nitem, info->new_iter);
-
-			if (!error)
-				continue;
-			else if (error == GIT_ENOTFOUND) {
-				error = 0;
-				is_ignored = true; /* treat empty as ignored */
-			} else
-				break; /* real error, must stop */
-		}
-
-		/* found a non-ignored item - treat parent dir as untracked */
-		if (!is_ignored) {
-			*delta_type = GIT_DELTA_UNTRACKED;
-			break;
-		}
-
-		if ((error = git_iterator_advance(&info->nitem, info->new_iter)) < 0)
-			break;
-	}
-
-	/* finish off scan */
-	while (info->nitem != NULL &&
-		   !diff->pfxcomp(info->nitem->path, git_buf_cstr(&base))) {
-		if ((error = git_iterator_advance(&info->nitem, info->new_iter)) < 0)
-			break;
-	}
-
-done:
-	git_buf_free(&base);
-
-	if (error == GIT_ITEROVER)
-		error = 0;
-
-	return error;
-}
-
 static int handle_unmatched_new_item(
 	git_diff *diff, diff_in_progress *info)
 {
@@ -905,6 +839,7 @@ static int handle_unmatched_new_item(
 			DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS))
 		{
 			git_diff_delta *last;
+			bool ignored;
 
 			/* attempt to insert record for this directory */
 			if ((error = diff_delta__from_one(diff, delta_type, nitem)) != 0)
@@ -916,11 +851,13 @@ static int handle_unmatched_new_item(
 				return git_iterator_advance(&info->nitem, info->new_iter);
 
 			/* iterate into dir looking for an actual untracked file */
-			if (diff_scan_inside_untracked_dir(diff, info, &delta_type) < 0)
-				return -1;
+			if ((error = git_iterator_advance_over_and_check_ignored(
+					&info->nitem, &ignored, info->new_iter)) < 0 &&
+				error != GIT_ITEROVER)
+				return error;
 
-			/* it iteration changed delta type, the update the record */
-			if (delta_type == GIT_DELTA_IGNORED) {
+			/* it iteration only found ignored items, update the record */
+			if (ignored) {
 				last->status = GIT_DELTA_IGNORED;
 
 				/* remove the record if we don't want ignored records */
diff --git a/src/iterator.c b/src/iterator.c
index 63c14f962..1a24dad10 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -1528,3 +1528,71 @@ int git_iterator_current_workdir_path(git_buf **path, git_iterator *iter)
 
 	return 0;
 }
+
+int git_iterator_advance_over_and_check_ignored(
+	const git_index_entry **entryptr, bool *ignored, git_iterator *iter)
+{
+	int error = 0;
+	workdir_iterator *wi = (workdir_iterator *)iter;
+	char *base = NULL;
+	const git_index_entry *entry;
+
+	*ignored = false;
+
+	if (iter->type != GIT_ITERATOR_TYPE_WORKDIR)
+		return git_iterator_advance(entryptr, iter);
+	if ((error = git_iterator_current(&entry, iter)) < 0)
+		return error;
+
+	if (!S_ISDIR(entry->mode)) {
+		if (git_ignore__lookup(
+				&wi->ignores, wi->fi.entry.path, &wi->is_ignored) < 0)
+			wi->is_ignored = true;
+		*ignored = wi->is_ignored;
+		return git_iterator_advance(entryptr, iter);
+	}
+
+	*ignored = true;
+
+	base = git__strdup(entry->path);
+	GITERR_CHECK_ALLOC(base);
+
+	/* scan inside directory looking for a non-ignored item */
+	while (entry && !iter->prefixcomp(entry->path, base)) {
+		if (git_ignore__lookup(
+				&wi->ignores, wi->fi.entry.path, &wi->is_ignored) < 0)
+			wi->is_ignored = true;
+
+		if (!wi->is_ignored && S_ISDIR(entry->mode)) {
+			error = git_iterator_advance_into(&entry, iter);
+
+			if (!error)
+				continue;
+			else if (error == GIT_ENOTFOUND) {
+				error = 0;
+				wi->is_ignored = true; /* treat empty directories as ignored */
+			} else
+				break; /* real error, stop here */
+		}
+
+		/* if we found a non-ignored item, treat parent as untracked */
+		if (!wi->is_ignored) {
+			*ignored = false;
+			break;
+		}
+
+		if ((error = git_iterator_advance(&entry, iter)) < 0)
+			break;
+	}
+
+	/* wrap up scan back to base directory */
+	while (entry && !iter->prefixcomp(entry->path, base))
+		if ((error = git_iterator_advance(&entry, iter)) < 0)
+			break;
+
+	*entryptr = entry;
+	git__free(base);
+
+	return error;
+}
+
diff --git a/src/iterator.h b/src/iterator.h
index 751e139d0..dcedbd530 100644
--- a/src/iterator.h
+++ b/src/iterator.h
@@ -258,4 +258,12 @@ extern int git_iterator_current_workdir_path(
 /* Return index pointer if index iterator, else NULL */
 extern git_index *git_iterator_get_index(git_iterator *iter);
 
+/* Special type of advance that can be called when looking at a tree in
+ * the working directory that leaves the iterator on the next item after
+ * the tree, but also scans the tree contents looking for any items that
+ * are not ignored.
+ */
+extern int git_iterator_advance_over_and_check_ignored(
+	const git_index_entry **entry, bool *ignored, git_iterator *iter);
+
 #endif
diff --git a/tests/stash/save.c b/tests/stash/save.c
index 7bbd4c8dc..87c6d7e0f 100644
--- a/tests/stash/save.c
+++ b/tests/stash/save.c
@@ -155,10 +155,16 @@ void test_stash_save__untracked_skips_ignored(void)
 	cl_must_pass(p_mkdir("stash/bundle/vendor", 0777));
 	cl_git_mkfile("stash/bundle/vendor/blah", "contents\n");
 
+	cl_assert(git_path_exists("stash/when")); /* untracked */
+	cl_assert(git_path_exists("stash/just.ignore")); /* ignored */
+	cl_assert(git_path_exists("stash/bundle/vendor/blah")); /* ignored */
+
 	cl_git_pass(git_stash_save(
 		&stash_tip_oid, repo, signature, NULL, GIT_STASH_INCLUDE_UNTRACKED));
 
+	cl_assert(!git_path_exists("stash/when"));
 	cl_assert(git_path_exists("stash/bundle/vendor/blah"));
+	cl_assert(git_path_exists("stash/just.ignore"));
 }
 
 void test_stash_save__can_include_untracked_and_ignored_files(void)
diff --git a/tests/stash/stash_helpers.c b/tests/stash/stash_helpers.c
index 29cb25c5f..ff683eced 100644
--- a/tests/stash/stash_helpers.c
+++ b/tests/stash/stash_helpers.c
@@ -42,7 +42,6 @@ void assert_status(
 	int status_flags)
 {
 	unsigned int status;
-	int error;
 
 	if (status_flags < 0)
 		cl_assert_equal_i(status_flags, git_status_file(&status, repo, path));
-- 
cgit v1.2.3


From 7110000dd5b82c86863633ee37f72ac876a44476 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Tue, 22 Apr 2014 10:21:19 -0400
Subject: React to feedback for UTF-8 <-> WCHAR and reparse work

---
 src/path.c            |  2 +-
 src/util.h            |  9 +++++++++
 src/win32/findfile.c  |  2 +-
 src/win32/posix_w32.c | 25 ++++++++++---------------
 src/win32/reparse.h   |  2 +-
 src/win32/utf-conv.c  | 10 +---------
 src/win32/w32_util.c  | 20 ++++++++++----------
 src/win32/w32_util.h  |  2 +-
 tests/core/link.c     |  2 +-
 9 files changed, 35 insertions(+), 39 deletions(-)

diff --git a/src/path.c b/src/path.c
index b2845466b..2690cd8e8 100644
--- a/src/path.c
+++ b/src/path.c
@@ -495,7 +495,7 @@ bool git_path_is_empty_dir(const char *path)
 		HANDLE hFind = FindFirstFileW(filter_w, &findData);
 
 		/* If the find handle was created successfully, then it's a directory */
-		if (INVALID_HANDLE_VALUE != hFind) {
+		if (hFind != INVALID_HANDLE_VALUE) {
 			empty = true;
 
 			do {
diff --git a/src/util.h b/src/util.h
index d94463c65..6fb2dc0f4 100644
--- a/src/util.h
+++ b/src/util.h
@@ -22,6 +22,15 @@
 
 #define GIT_DATE_RFC2822_SZ  32
 
+/**
+ * Return the length of a constant string.
+ * We are aware that `strlen` performs the same task and is usually
+ * optimized away by the compiler, whilst being safer because it returns
+ * valid values when passed a pointer instead of a constant string; however
+ * this macro will transparently work with wide-char and single-char strings.
+ */
+#define CONST_STRLEN(x) ((sizeof(x)/sizeof(x[0])) - 1)
+
 /*
  * Custom memory allocation wrappers
  * that set error code and error message
diff --git a/src/win32/findfile.c b/src/win32/findfile.c
index bd06d9232..86d4ef5bd 100644
--- a/src/win32/findfile.c
+++ b/src/win32/findfile.c
@@ -119,7 +119,7 @@ static int win32_find_git_in_registry(
 
 		/* InstallLocation points to the root of the git directory */
 		if (!RegQueryValueExW(hKey, L"InstallLocation", NULL, &dwType, (LPBYTE)path, &cbData) &&
-			REG_SZ == dwType) {
+			dwType == REG_SZ) {
 
 			/* Append the suffix */
 			wcscat(path, subdir);
diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c
index bef65a354..0d070f6b5 100644
--- a/src/win32/posix_w32.c
+++ b/src/win32/posix_w32.c
@@ -62,7 +62,7 @@ int p_unlink(const char *path)
 
 	/* If the file could not be deleted because it was
 	 * read-only, clear the bit and try again */
-	if (-1 == error && EACCES == errno) {
+	if (error == -1 && errno == EACCES) {
 		_wchmod(buf, 0666);
 		error = _wunlink(buf);
 	}
@@ -120,7 +120,7 @@ static int readlink_w(
 		FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING,
 		FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, NULL);
 
-	if (INVALID_HANDLE_VALUE == handle) {
+	if (handle == INVALID_HANDLE_VALUE) {
 		errno = ENOENT;
 		return -1;
 	}
@@ -149,7 +149,7 @@ static int readlink_w(
 
 	if (target_len) {
 		/* The path may need to have a prefix removed. */
-		target_len = git_win32__to_dos(target, target_len);
+		target_len = git_win32__canonicalize_path(target, target_len);
 
 		/* Need one additional character in the target buffer
 		 * for the terminating NULL. */
@@ -235,7 +235,7 @@ static int lstat_w(
 			path[path_len] = L'\0';
 			attrs = GetFileAttributesW(path);
 
-			if (INVALID_FILE_ATTRIBUTES != attrs) {
+			if (attrs != INVALID_FILE_ATTRIBUTES) {
 				if (!(attrs & FILE_ATTRIBUTE_DIRECTORY))
 					errno = ENOTDIR;
 				break;
@@ -393,23 +393,18 @@ static int getfinalpath_w(
 	hFile = CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_DELETE,
 		NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
 
-	if (hFile == INVALID_HANDLE_VALUE)
+	if (INVALID_HANDLE_VALUE == hFile)
 		return -1;
 
 	/* Call GetFinalPathNameByHandle */
 	dwChars = pgfp(hFile, dest, GIT_WIN_PATH_UTF16, FILE_NAME_NORMALIZED);
+	CloseHandle(hFile);
 
-	if (!dwChars || dwChars >= GIT_WIN_PATH_UTF16) {
-		DWORD error = GetLastError();
-		CloseHandle(hFile);
-		SetLastError(error);
+	if (!dwChars || dwChars >= GIT_WIN_PATH_UTF16)
 		return -1;
-	}
-
-	CloseHandle(hFile);
 
 	/* The path may be delivered to us with a prefix; canonicalize */
-	return (int)git_win32__to_dos(dest, dwChars);
+	return (int)git_win32__canonicalize_path(dest, dwChars);
 }
 
 static int follow_and_lstat_link(git_win32_path path, struct stat* buf)
@@ -473,7 +468,7 @@ int p_rmdir(const char* path)
 
 	error = _wrmdir(buf);
 
-	if (-1 == error) {
+	if (error == -1) {
 		switch (GetLastError()) {
 			/* _wrmdir() is documented to return EACCES if "A program has an open
 			 * handle to the directory."  This sounds like what everybody else calls
@@ -513,7 +508,7 @@ char *p_realpath(const char *orig_path, char *buffer)
 	}
 
 	/* The path must exist. */
-	if (INVALID_FILE_ATTRIBUTES == GetFileAttributesW(buffer_w)) {
+	if (GetFileAttributesW(buffer_w) == INVALID_FILE_ATTRIBUTES) {
 		errno = ENOENT;
 		return NULL;
 	}
diff --git a/src/win32/reparse.h b/src/win32/reparse.h
index 4f56ed055..70f9fd652 100644
--- a/src/win32/reparse.h
+++ b/src/win32/reparse.h
@@ -54,4 +54,4 @@ typedef struct _GIT_REPARSE_DATA_BUFFER {
 # define FSCTL_SET_REPARSE_POINT			0x000900a4
 #endif
 
-#endif
\ No newline at end of file
+#endif
diff --git a/src/win32/utf-conv.c b/src/win32/utf-conv.c
index fe94701a8..b9ccfb5e5 100644
--- a/src/win32/utf-conv.c
+++ b/src/win32/utf-conv.c
@@ -9,7 +9,7 @@
 #include "utf-conv.h"
 
 #ifndef WC_ERR_INVALID_CHARS
-#define WC_ERR_INVALID_CHARS	0x80
+# define WC_ERR_INVALID_CHARS	0x80
 #endif
 
 GIT_INLINE(DWORD) get_wc_flags(void)
@@ -87,12 +87,8 @@ int git__utf8_to_16_alloc(wchar_t **dest, const char *src)
 	utf16_size = MultiByteToWideChar(CP_UTF8, MB_ERR_INVALID_CHARS, src, -1, *dest, utf16_size);
 
 	if (!utf16_size) {
-		/* Don't let git__free stomp on the thread-local last error code,
-		* so that the caller can call giterr_set(GITERR_OS, ...) */
-		DWORD last_error = GetLastError();
 		git__free(*dest);
 		*dest = NULL;
-		SetLastError(last_error);
 	}
 
 	/* Subtract 1 from the result to turn 0 into -1 (an error code) and to not count the NULL
@@ -131,12 +127,8 @@ int git__utf16_to_8_alloc(char **dest, const wchar_t *src)
 	utf8_size = WideCharToMultiByte(CP_UTF8, dwFlags, src, -1, *dest, utf8_size, NULL, NULL);
 
 	if (!utf8_size) {
-		/* Don't let git__free stomp on the thread-local last error code,
-		 * so that the caller can call giterr_set(GITERR_OS, ...) */
-		DWORD last_error = GetLastError();
 		git__free(*dest);
 		*dest = NULL;
-		SetLastError(last_error);
 	}
 
 	/* Subtract 1 from the result to turn 0 into -1 (an error code) and to not count the NULL
diff --git a/src/win32/w32_util.c b/src/win32/w32_util.c
index 50b85a334..2e52525d5 100644
--- a/src/win32/w32_util.c
+++ b/src/win32/w32_util.c
@@ -7,8 +7,6 @@
 
 #include "w32_util.h"
 
-#define CONST_STRLEN(x) ((sizeof(x)/sizeof(x[0])) - 1)
-
 /**
  * Creates a FindFirstFile(Ex) filter string from a UTF-8 path.
  * The filter string enumerates all items in the directory.
@@ -26,8 +24,10 @@ bool git_win32__findfirstfile_filter(git_win32_path dest, const char *src)
 	if (len < 0)
 		return false;
 
-	/* Ensure that the path does not end with a trailing slash --
-	 * because we're about to add one! */
+	/* Ensure that the path does not end with a trailing slash,
+	 * because we're about to add one. Don't rely our trim_end
+	 * helper, because we want to remove the backslash even for
+	 * drive letter paths, in this case. */
 	if (len > 0 &&
 		(dest[len - 1] == L'/' || dest[len - 1] == L'\\')) {
 		dest[len - 1] = L'\0';
@@ -35,7 +35,7 @@ bool git_win32__findfirstfile_filter(git_win32_path dest, const char *src)
 	}
 
 	/* Ensure we have enough room to add the suffix */
-	if ((size_t)len > GIT_WIN_PATH_UTF16 - ARRAY_SIZE(suffix))
+	if ((size_t)len >= GIT_WIN_PATH_UTF16 - CONST_STRLEN(suffix))
 		return false;
 
 	wcscat(dest, suffix);
@@ -59,11 +59,11 @@ int git_win32__sethidden(const char *path)
 	attrs = GetFileAttributesW(buf);
 
 	/* Ensure the path exists */
-	if (INVALID_FILE_ATTRIBUTES == attrs)
+	if (attrs == INVALID_FILE_ATTRIBUTES)
 		return -1;
 
 	/* If the item isn't already +H, add the bit */
-	if (0 == (attrs & FILE_ATTRIBUTE_HIDDEN) &&
+	if ((attrs & FILE_ATTRIBUTE_HIDDEN) == 0 &&
 		!SetFileAttributesW(buf, attrs | FILE_ATTRIBUTE_HIDDEN))
 		return -1;
 
@@ -85,7 +85,7 @@ size_t git_win32__path_trim_end(wchar_t *str, size_t len)
 
 		/* Don't trim backslashes from drive letter paths, which
 		 * are 3 characters long and of the form C:\, D:\, etc. */
-		if (3 == len && git_win32__isalpha(str[0]) && str[1] == ':')
+		if (len == 3 && git_win32__isalpha(str[0]) && str[1] == ':')
 			break;
 
 		len--;
@@ -103,7 +103,7 @@ size_t git_win32__path_trim_end(wchar_t *str, size_t len)
  * @param path The path which should be converted.
  * @return The length of the modified string (<= the input length)
  */
-size_t git_win32__to_dos(wchar_t *str, size_t len)
+size_t git_win32__canonicalize_path(wchar_t *str, size_t len)
 {
 	static const wchar_t dosdevices_prefix[] = L"\\\?\?\\";
 	static const wchar_t nt_prefix[] = L"\\\\?\\";
@@ -136,4 +136,4 @@ size_t git_win32__to_dos(wchar_t *str, size_t len)
 	}
 
 	return git_win32__path_trim_end(str, len);
-}
\ No newline at end of file
+}
diff --git a/src/win32/w32_util.h b/src/win32/w32_util.h
index acdee3d69..a1d388af5 100644
--- a/src/win32/w32_util.h
+++ b/src/win32/w32_util.h
@@ -49,6 +49,6 @@ size_t git_win32__path_trim_end(wchar_t *str, size_t len);
  * @param path The path which should be converted.
  * @return The length of the modified string (<= the input length)
  */
-size_t git_win32__to_dos(wchar_t *str, size_t len);
+size_t git_win32__canonicalize_path(wchar_t *str, size_t len);
 
 #endif
diff --git a/tests/core/link.c b/tests/core/link.c
index 20d2706f7..1794a3893 100644
--- a/tests/core/link.c
+++ b/tests/core/link.c
@@ -137,7 +137,7 @@ static void do_junction(const char *old, const char *new)
 
 	reparse_buf->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT;
 	reparse_buf->MountPointReparseBuffer.SubstituteNameOffset = 0;
-	reparse_buf->MountPointReparseBuffer.SubstituteNameLength =	subst_byte_len;
+	reparse_buf->MountPointReparseBuffer.SubstituteNameLength = subst_byte_len;
 	reparse_buf->MountPointReparseBuffer.PrintNameOffset = (USHORT)(subst_byte_len + sizeof(WCHAR));
 	reparse_buf->MountPointReparseBuffer.PrintNameLength = print_byte_len;
 	reparse_buf->ReparseDataLength = reparse_buflen - REPARSE_DATA_HEADER_SIZE;
-- 
cgit v1.2.3


From 219c89d19d7e18a336faa094b0c29cb7bb0d22c6 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 23 Apr 2014 16:28:45 -0700
Subject: Treat ignored, empty, and untracked dirs different

In the iterator, distinguish between ignores and empty directories
so that diff and status can ignore empty directories, but checkout
and stash can treat them as untracked items.
---
 src/checkout.c | 10 +++++-----
 src/diff.c     | 11 ++++++-----
 src/iterator.c | 17 +++++++++++------
 src/iterator.h | 23 +++++++++++++++++------
 4 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/src/checkout.c b/src/checkout.c
index a412c4c4e..bc976b854 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -336,22 +336,22 @@ static int checkout_action_wd_only(
 			error = git_iterator_advance(wditem, workdir);
 	} else {
 		/* untracked or ignored - can't know which until we advance through */
-		bool ignored, over = false;
-		bool removable = wd_item_is_removable(workdir, wd);
+		bool over = false, removable = wd_item_is_removable(workdir, wd);
+		git_iterator_status_t untracked_state;
 
 		/* copy the entry for issuing notification callback later */
 		git_index_entry saved_wd = *wd;
 		git_buf_sets(&data->tmp, wd->path);
 		saved_wd.path = data->tmp.ptr;
 
-		error = git_iterator_advance_over_and_check_ignored(
-			wditem, &ignored, workdir);
+		error = git_iterator_advance_over_with_status(
+			wditem, &untracked_state, workdir);
 		if (error == GIT_ITEROVER)
 			over = true;
 		else if (error < 0)
 			return error;
 
-		if (ignored) {
+		if (untracked_state == GIT_ITERATOR_STATUS_IGNORED) {
 			notify = GIT_CHECKOUT_NOTIFY_IGNORED;
 			remove = ((data->strategy & GIT_CHECKOUT_REMOVE_IGNORED) != 0);
 		} else {
diff --git a/src/diff.c b/src/diff.c
index f1c1b0543..18cd52c55 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -839,7 +839,7 @@ static int handle_unmatched_new_item(
 			DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS))
 		{
 			git_diff_delta *last;
-			bool ignored;
+			git_iterator_status_t untracked_state;
 
 			/* attempt to insert record for this directory */
 			if ((error = diff_delta__from_one(diff, delta_type, nitem)) != 0)
@@ -851,13 +851,14 @@ static int handle_unmatched_new_item(
 				return git_iterator_advance(&info->nitem, info->new_iter);
 
 			/* iterate into dir looking for an actual untracked file */
-			if ((error = git_iterator_advance_over_and_check_ignored(
-					&info->nitem, &ignored, info->new_iter)) < 0 &&
+			if ((error = git_iterator_advance_over_with_status(
+					&info->nitem, &untracked_state, info->new_iter)) < 0 &&
 				error != GIT_ITEROVER)
 				return error;
 
-			/* it iteration only found ignored items, update the record */
-			if (ignored) {
+			/* if we found nothing or just ignored items, update the record */
+			if (untracked_state == GIT_ITERATOR_STATUS_IGNORED ||
+				untracked_state == GIT_ITERATOR_STATUS_EMPTY) {
 				last->status = GIT_DELTA_IGNORED;
 
 				/* remove the record if we don't want ignored records */
diff --git a/src/iterator.c b/src/iterator.c
index 1a24dad10..dfa79977d 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -1529,15 +1529,17 @@ int git_iterator_current_workdir_path(git_buf **path, git_iterator *iter)
 	return 0;
 }
 
-int git_iterator_advance_over_and_check_ignored(
-	const git_index_entry **entryptr, bool *ignored, git_iterator *iter)
+int git_iterator_advance_over_with_status(
+	const git_index_entry **entryptr,
+	git_iterator_status_t *status,
+	git_iterator *iter)
 {
 	int error = 0;
 	workdir_iterator *wi = (workdir_iterator *)iter;
 	char *base = NULL;
 	const git_index_entry *entry;
 
-	*ignored = false;
+	*status = GIT_ITERATOR_STATUS_NORMAL;
 
 	if (iter->type != GIT_ITERATOR_TYPE_WORKDIR)
 		return git_iterator_advance(entryptr, iter);
@@ -1548,11 +1550,12 @@ int git_iterator_advance_over_and_check_ignored(
 		if (git_ignore__lookup(
 				&wi->ignores, wi->fi.entry.path, &wi->is_ignored) < 0)
 			wi->is_ignored = true;
-		*ignored = wi->is_ignored;
+		if (wi->is_ignored)
+			*status = GIT_ITERATOR_STATUS_IGNORED;
 		return git_iterator_advance(entryptr, iter);
 	}
 
-	*ignored = true;
+	*status = GIT_ITERATOR_STATUS_EMPTY;
 
 	base = git__strdup(entry->path);
 	GITERR_CHECK_ALLOC(base);
@@ -1577,9 +1580,11 @@ int git_iterator_advance_over_and_check_ignored(
 
 		/* if we found a non-ignored item, treat parent as untracked */
 		if (!wi->is_ignored) {
-			*ignored = false;
+			*status = GIT_ITERATOR_STATUS_NORMAL;
 			break;
 		}
+		if (entry && !S_ISDIR(entry->mode))
+			*status = GIT_ITERATOR_STATUS_IGNORED;
 
 		if ((error = git_iterator_advance(&entry, iter)) < 0)
 			break;
diff --git a/src/iterator.h b/src/iterator.h
index dcedbd530..ba9c1e486 100644
--- a/src/iterator.h
+++ b/src/iterator.h
@@ -258,12 +258,23 @@ extern int git_iterator_current_workdir_path(
 /* Return index pointer if index iterator, else NULL */
 extern git_index *git_iterator_get_index(git_iterator *iter);
 
-/* Special type of advance that can be called when looking at a tree in
- * the working directory that leaves the iterator on the next item after
- * the tree, but also scans the tree contents looking for any items that
- * are not ignored.
+typedef enum {
+	GIT_ITERATOR_STATUS_NORMAL = 0,
+	GIT_ITERATOR_STATUS_IGNORED = 1,
+	GIT_ITERATOR_STATUS_EMPTY = 2
+} git_iterator_status_t;
+
+/* Advance over a directory and check if it contains no files or just
+ * ignored files.
+ *
+ * In a tree or the index, all directories will contain files, but in the
+ * working directory it is possible to have an empty directory tree or a
+ * tree that only contains ignored files.  Many Git operations treat these
+ * cases specially.  This advances over a directory (presumably an
+ * untracked directory) but checks during the scan if there are any files
+ * and any non-ignored files.
  */
-extern int git_iterator_advance_over_and_check_ignored(
-	const git_index_entry **entry, bool *ignored, git_iterator *iter);
+extern int git_iterator_advance_over_with_status(
+	const git_index_entry **entry, git_iterator_status_t *status, git_iterator *iter);
 
 #endif
-- 
cgit v1.2.3


From 26564d80aa7b340f07e9c5b96457928ebadcc606 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 23 Apr 2014 19:26:58 -0400
Subject: merge: default checkout strategy for should be SAFE

---
 src/merge.c                 |  2 +-
 tests/merge/workdir/dirty.c | 17 +++++++++++++++++
 2 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/src/merge.c b/src/merge.c
index 2e40b6db8..0b73d2b91 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2186,7 +2186,7 @@ static int merge_normalize_checkout_opts(
 	const git_merge_head **their_heads)
 {
 	int error = 0;
-	unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE_CREATE |
+	unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE |
 		GIT_CHECKOUT_ALLOW_CONFLICTS;
 
 	GIT_UNUSED(repo);
diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
index 1d596c51a..6c21c2a6a 100644
--- a/tests/merge/workdir/dirty.c
+++ b/tests/merge/workdir/dirty.c
@@ -260,6 +260,23 @@ void test_merge_workdir_dirty__unaffected_dirty_files_allowed(void)
 		cl_git_pass(merge_dirty_files(files));
 }
 
+void test_merge_workdir_dirty__unstaged_deletes_maintained(void)
+{
+	git_reference *head;
+	git_object *head_object;
+
+	cl_git_pass(git_repository_head(&head, repo));
+	cl_git_pass(git_reference_peel(&head_object, head, GIT_OBJ_COMMIT));
+	cl_git_pass(git_reset(repo, head_object, GIT_RESET_HARD, NULL, NULL));
+
+	cl_git_pass(p_unlink("merge-resolve/unchanged.txt"));
+
+	cl_git_pass(merge_branch(0, 0));
+
+	git_object_free(head_object);
+	git_reference_free(head);
+}
+
 void test_merge_workdir_dirty__affected_dirty_files_disallowed(void)
 {
 	char **files;
-- 
cgit v1.2.3


From a4e2c36a66eca49ae4d7bdf0fdba8d4b3c900ab9 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 23 Apr 2014 19:40:21 -0400
Subject: merge: checkout default shouldn't clobber given

---
 src/merge.c                  |  8 +++-----
 tests/merge/workdir/dirty.c  | 15 +++++++--------
 tests/merge/workdir/simple.c |  6 ++++--
 3 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/merge.c b/src/merge.c
index 0b73d2b91..69c42bc0c 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2186,8 +2186,6 @@ static int merge_normalize_checkout_opts(
 	const git_merge_head **their_heads)
 {
 	int error = 0;
-	unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE |
-		GIT_CHECKOUT_ALLOW_CONFLICTS;
 
 	GIT_UNUSED(repo);
 
@@ -2195,12 +2193,12 @@ static int merge_normalize_checkout_opts(
 		memcpy(checkout_opts, given_checkout_opts, sizeof(git_checkout_options));
 	else {
 		git_checkout_options default_checkout_opts = GIT_CHECKOUT_OPTIONS_INIT;
+		default_checkout_opts.checkout_strategy =  GIT_CHECKOUT_SAFE |
+			GIT_CHECKOUT_ALLOW_CONFLICTS;
+
 		memcpy(checkout_opts, &default_checkout_opts, sizeof(git_checkout_options));
 	}
 
-	if (!checkout_opts->checkout_strategy)
-		checkout_opts->checkout_strategy = default_checkout_strategy;
-
 	/* TODO: for multiple ancestors in merge-recursive, this is "merged common ancestors" */
 	if (!checkout_opts->ancestor_label) {
 		if (ancestor_head && ancestor_head->commit)
diff --git a/tests/merge/workdir/dirty.c b/tests/merge/workdir/dirty.c
index 6c21c2a6a..776e4ea69 100644
--- a/tests/merge/workdir/dirty.c
+++ b/tests/merge/workdir/dirty.c
@@ -86,7 +86,7 @@ static void set_core_autocrlf_to(git_repository *repo, bool value)
 	git_config_free(cfg);
 }
 
-static int merge_branch(int merge_file_favor, int checkout_strategy)
+static int merge_branch(void)
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
@@ -97,8 +97,7 @@ static int merge_branch(int merge_file_favor, int checkout_strategy)
 	cl_git_pass(git_oid_fromstr(&their_oids[0], MERGE_BRANCH_OID));
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
-	merge_opts.file_favor = merge_file_favor;
-	checkout_opts.checkout_strategy = checkout_strategy;
+	checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_ALLOW_CONFLICTS;
 	error = git_merge(repo, (const git_merge_head **)their_heads, 1, &merge_opts, &checkout_opts);
 
 	git_merge_head_free(their_heads[0]);
@@ -214,7 +213,7 @@ static int merge_dirty_files(char *dirty_files[])
 
 	write_files(dirty_files);
 
-	error = merge_branch(0, 0);
+	error = merge_branch();
 
 	git_object_free(head_object);
 	git_reference_free(head);
@@ -237,7 +236,7 @@ static int merge_differently_filtered_files(char *files[])
 
 	cl_git_pass(git_index_write(repo_index));
 
-	error = merge_branch(0, 0);
+	error = merge_branch();
 
 	git_object_free(head_object);
 	git_reference_free(head);
@@ -248,7 +247,7 @@ static int merge_differently_filtered_files(char *files[])
 static int merge_staged_files(char *staged_files[])
 {	
 	stage_random_files(staged_files);
-	return merge_branch(0, 0);
+	return merge_branch();
 }
 
 void test_merge_workdir_dirty__unaffected_dirty_files_allowed(void)
@@ -271,7 +270,7 @@ void test_merge_workdir_dirty__unstaged_deletes_maintained(void)
 
 	cl_git_pass(p_unlink("merge-resolve/unchanged.txt"));
 
-	cl_git_pass(merge_branch(0, 0));
+	cl_git_pass(merge_branch());
 
 	git_object_free(head_object);
 	git_reference_free(head);
@@ -309,7 +308,7 @@ void test_merge_workdir_dirty__identical_staged_files_allowed(void)
 		stage_content(content);
 
 		git_index_write(repo_index);
-		cl_git_pass(merge_branch(0, 0));
+		cl_git_pass(merge_branch());
 	}
 }
 
diff --git a/tests/merge/workdir/simple.c b/tests/merge/workdir/simple.c
index cf5b16e7a..327408dc9 100644
--- a/tests/merge/workdir/simple.c
+++ b/tests/merge/workdir/simple.c
@@ -92,7 +92,7 @@ void test_merge_workdir_simple__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-static void merge_simple_branch(int merge_file_favor, int checkout_strategy)
+static void merge_simple_branch(int merge_file_favor, int addl_checkout_strategy)
 {
 	git_oid their_oids[1];
 	git_merge_head *their_heads[1];
@@ -103,7 +103,9 @@ static void merge_simple_branch(int merge_file_favor, int checkout_strategy)
 	cl_git_pass(git_merge_head_from_id(&their_heads[0], repo, &their_oids[0]));
 
 	merge_opts.file_favor = merge_file_favor;
-	checkout_opts.checkout_strategy = checkout_strategy;
+	checkout_opts.checkout_strategy = GIT_CHECKOUT_SAFE | GIT_CHECKOUT_ALLOW_CONFLICTS |
+		addl_checkout_strategy;
+
 	cl_git_pass(git_merge(repo, (const git_merge_head **)their_heads, 1, &merge_opts, &checkout_opts));
 
 	git_merge_head_free(their_heads[0]);
-- 
cgit v1.2.3


From bdc82e1c00776229b19688abaf08d6701f2dc41f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 24 Apr 2014 14:08:29 +0200
Subject: fetchhead: deal with quotes in branch names

The current FETCH_HEAD parsing code assumes that a quote must end the
branch name. Git however allows for quotes as part of a branch name,
which causes us to consider the FETCH_HEAD file as invalid.

Instead of searching for a single quote char, search for a quote char
followed by SP, which is not a valid part of a ref name.
---
 src/fetchhead.c                  | 2 +-
 tests/fetchhead/fetchhead_data.h | 3 +++
 tests/fetchhead/nonetwork.c      | 9 +++++++++
 3 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/src/fetchhead.c b/src/fetchhead.c
index 4435454ef..a95ea4ca4 100644
--- a/src/fetchhead.c
+++ b/src/fetchhead.c
@@ -210,7 +210,7 @@ static int fetchhead_ref_parse(
 			name = desc + 1;
 
 		if (name) {
-			if ((desc = strchr(name, '\'')) == NULL ||
+			if ((desc = strstr(name, "' ")) == NULL ||
 				git__prefixcmp(desc, "' of ") != 0) {
 				giterr_set(GITERR_FETCHHEAD,
 					"Invalid description in FETCH_HEAD line %d", line_num);
diff --git a/tests/fetchhead/fetchhead_data.h b/tests/fetchhead/fetchhead_data.h
index 34adb3d08..94402abd5 100644
--- a/tests/fetchhead/fetchhead_data.h
+++ b/tests/fetchhead/fetchhead_data.h
@@ -28,3 +28,6 @@
 
 #define FETCH_HEAD_EXPLICIT_DATA \
 	"0966a434eb1a025db6b71485ab63a3bfbea520b6\t\tbranch 'first-merge' of git://github.com/libgit2/TestGitRepository\n"
+
+#define FETCH_HEAD_QUOTE_DATA \
+	"0966a434eb1a025db6b71485ab63a3bfbea520b6\t\tbranch 'first's-merge' of git://github.com/libgit2/TestGitRepository\n"
diff --git a/tests/fetchhead/nonetwork.c b/tests/fetchhead/nonetwork.c
index d8c70e8b2..e7ff2ca30 100644
--- a/tests/fetchhead/nonetwork.c
+++ b/tests/fetchhead/nonetwork.c
@@ -343,3 +343,12 @@ void test_fetchhead_nonetwork__unborn_with_upstream(void)
 	git_repository_free(repo);
 	cl_fixture_cleanup("./repowithunborn");
 }
+
+void test_fetchhead_nonetwork__quote_in_branch_name(void)
+{
+	cl_set_cleanup(&cleanup_repository, "./test1");
+	cl_git_pass(git_repository_init(&g_repo, "./test1", 0));
+
+	cl_git_rewritefile("./test1/.git/FETCH_HEAD", FETCH_HEAD_QUOTE_DATA);
+	cl_git_pass(git_repository_fetchhead_foreach(g_repo, read_noop, NULL));
+}
-- 
cgit v1.2.3


From a409acefbbadeb607e4d6dde681bff5aed6ae9fc Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 24 Apr 2014 11:59:50 -0700
Subject: Handle explicitly ignored dir slightly differently

When considering status of untracked directories, if we find an
explicitly ignored item, even if it is a directory, treat the
parent as an IGNORED item.  It was accidentally being treated as
an EMPTY item because we were not looking into the ignored subdir.
---
 src/iterator.c | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/iterator.c b/src/iterator.c
index dfa79977d..ef27fa71f 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -1566,25 +1566,26 @@ int git_iterator_advance_over_with_status(
 				&wi->ignores, wi->fi.entry.path, &wi->is_ignored) < 0)
 			wi->is_ignored = true;
 
-		if (!wi->is_ignored && S_ISDIR(entry->mode)) {
+		/* if we found an explicitly ignored item, then update from
+		 * EMPTY to IGNORED
+		 */
+		if (wi->is_ignored)
+			*status = GIT_ITERATOR_STATUS_IGNORED;
+		else if (S_ISDIR(entry->mode)) {
 			error = git_iterator_advance_into(&entry, iter);
 
 			if (!error)
 				continue;
 			else if (error == GIT_ENOTFOUND) {
 				error = 0;
-				wi->is_ignored = true; /* treat empty directories as ignored */
+				wi->is_ignored = true; /* mark empty directories as ignored */
 			} else
 				break; /* real error, stop here */
-		}
-
-		/* if we found a non-ignored item, treat parent as untracked */
-		if (!wi->is_ignored) {
+		} else {
+			/* we found a non-ignored item, treat parent as untracked */
 			*status = GIT_ITERATOR_STATUS_NORMAL;
 			break;
 		}
-		if (entry && !S_ISDIR(entry->mode))
-			*status = GIT_ITERATOR_STATUS_IGNORED;
 
 		if ((error = git_iterator_advance(&entry, iter)) < 0)
 			break;
-- 
cgit v1.2.3


From 2334e3d8c33c639732e586ae8adfb65370523ab2 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 24 Apr 2014 14:46:59 -0700
Subject: Test decomposed unicode renames work as expected

---
 tests/status/renames.c | 129 +++++++++++++++++++++++++++++++++++--------------
 1 file changed, 92 insertions(+), 37 deletions(-)

diff --git a/tests/status/renames.c b/tests/status/renames.c
index df5e23087..ab9cd7445 100644
--- a/tests/status/renames.c
+++ b/tests/status/renames.c
@@ -20,40 +20,36 @@ void test_status_renames__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-static void rename_file(git_repository *repo, const char *oldname, const char *newname)
+static void _rename_helper(
+	git_repository *repo, const char *from, const char *to, const char *extra)
 {
 	git_buf oldpath = GIT_BUF_INIT, newpath = GIT_BUF_INIT;
 
-	git_buf_joinpath(&oldpath, git_repository_workdir(repo), oldname);
-	git_buf_joinpath(&newpath, git_repository_workdir(repo), newname);
+	cl_git_pass(git_buf_joinpath(
+		&oldpath, git_repository_workdir(repo), from));
+	cl_git_pass(git_buf_joinpath(
+		&newpath, git_repository_workdir(repo), to));
 
 	cl_git_pass(p_rename(oldpath.ptr, newpath.ptr));
 
-	git_buf_free(&oldpath);
-	git_buf_free(&newpath);
-}
-
-static void rename_and_edit_file(git_repository *repo, const char *oldname, const char *newname)
-{
-	git_buf oldpath = GIT_BUF_INIT, newpath = GIT_BUF_INIT;
-
-	git_buf_joinpath(&oldpath, git_repository_workdir(repo), oldname);
-	git_buf_joinpath(&newpath, git_repository_workdir(repo), newname);
-
-	cl_git_pass(p_rename(oldpath.ptr, newpath.ptr));
-	cl_git_append2file(newpath.ptr, "Added at the end to keep similarity!");
+	if (extra)
+		cl_git_append2file(newpath.ptr, extra);
 
 	git_buf_free(&oldpath);
 	git_buf_free(&newpath);
 }
 
+#define rename_file(R,O,N) _rename_helper((R), (O), (N), NULL)
+#define rename_and_edit_file(R,O,N) \
+	_rename_helper((R), (O), (N), "Added at the end to keep similarity!")
+
 struct status_entry {
 	git_status_t status;
 	const char *oldname;
 	const char *newname;
 };
 
-static void test_status(
+static void check_status(
 	git_status_list *status_list,
 	struct status_entry *expected_list,
 	size_t expected_len)
@@ -61,9 +57,9 @@ static void test_status(
 	const git_status_entry *actual;
 	const struct status_entry *expected;
 	const char *oldname, *newname;
-	size_t i;
+	size_t i, files_in_status = git_status_list_entrycount(status_list);
 
-	cl_assert_equal_sz(expected_len, git_status_list_entrycount(status_list));
+	cl_assert_equal_sz(expected_len, files_in_status);
 
 	for (i = 0; i < expected_len; i++) {
 		actual = git_status_byindex(status_list, i);
@@ -82,10 +78,12 @@ static void test_status(
 		else
 			cl_assert(expected->oldname == NULL);
 
-		if (newname)
-			cl_assert(git__strcmp(newname, expected->newname) == 0);
-		else
-			cl_assert(expected->newname == NULL);
+		if (actual->status & (GIT_STATUS_INDEX_RENAMED|GIT_STATUS_WT_RENAMED)) {
+			if (newname)
+				cl_assert(git__strcmp(newname, expected->newname) == 0);
+			else
+				cl_assert(expected->newname == NULL);
+		}
 	}
 }
 
@@ -109,7 +107,7 @@ void test_status_renames__head2index_one(void)
 	cl_git_pass(git_index_write(index));
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 1);
+	check_status(statuslist, expected, 1);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -149,7 +147,7 @@ void test_status_renames__head2index_two(void)
 	cl_git_pass(git_index_write(index));
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 4);
+	check_status(statuslist, expected, 4);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -178,7 +176,7 @@ void test_status_renames__head2index_no_rename_from_rewrite(void)
 	cl_git_pass(git_index_write(index));
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 2);
+	check_status(statuslist, expected, 2);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -208,7 +206,7 @@ void test_status_renames__head2index_rename_from_rewrite(void)
 	cl_git_pass(git_index_write(index));
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 2);
+	check_status(statuslist, expected, 2);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -228,7 +226,7 @@ void test_status_renames__index2workdir_one(void)
 	rename_file(g_repo, "ikeepsix.txt", "newname.txt");
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 1);
+	check_status(statuslist, expected, 1);
 	git_status_list_free(statuslist);
 }
 
@@ -254,7 +252,7 @@ void test_status_renames__index2workdir_two(void)
 	rename_and_edit_file(g_repo, "untimely.txt", "bbb.txt");
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 4);
+	check_status(statuslist, expected, 4);
 	git_status_list_free(statuslist);
 }
 
@@ -278,7 +276,7 @@ void test_status_renames__index2workdir_rename_from_rewrite(void)
 	rename_file(g_repo, "_temp_.txt", "sixserving.txt");
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 2);
+	check_status(statuslist, expected, 2);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -309,7 +307,7 @@ void test_status_renames__both_one(void)
 	rename_file(g_repo, "newname-index.txt", "newname-workdir.txt");
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 1);
+	check_status(statuslist, expected, 1);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -355,7 +353,7 @@ void test_status_renames__both_two(void)
 	rename_file(g_repo, "untimely-index.txt", "untimely-both.txt");
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 4);
+	check_status(statuslist, expected, 4);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -399,7 +397,7 @@ void test_status_renames__both_rename_from_rewrite(void)
 	rename_file(g_repo, "_temp_.txt", "sixserving.txt");
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 3);
+	check_status(statuslist, expected, 3);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -440,7 +438,7 @@ void test_status_renames__rewrites_only_for_renames(void)
 		"This is enough content for the file to be rewritten.\n");
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 1);
+	check_status(statuslist, expected, 1);
 	git_status_list_free(statuslist);
 
 	git_index_free(index);
@@ -481,7 +479,7 @@ void test_status_renames__both_casechange_one(void)
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
 
-	test_status(statuslist, (index_caps & GIT_INDEXCAP_IGNORE_CASE) ?
+	check_status(statuslist, (index_caps & GIT_INDEXCAP_IGNORE_CASE) ?
 		expected_icase : expected_case, 1);
 
 	git_status_list_free(statuslist);
@@ -548,7 +546,7 @@ void test_status_renames__both_casechange_two(void)
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
 
-	test_status(statuslist, (index_caps & GIT_INDEXCAP_IGNORE_CASE) ?
+	check_status(statuslist, (index_caps & GIT_INDEXCAP_IGNORE_CASE) ?
 		expected_icase : expected_case, 4);
 
 	git_status_list_free(statuslist);
@@ -579,6 +577,63 @@ void test_status_renames__zero_byte_file_does_not_fail(void)
 	cl_git_mkfile("renames/zerobyte.txt", "");
 
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
-	test_status(statuslist, expected, 2);
+	check_status(statuslist, expected, 2);
 	git_status_list_free(statuslist);
 }
+
+#ifdef GIT_USE_ICONV
+
+static char *nfc = "\xC3\x85\x73\x74\x72\xC3\xB6\x6D";
+static char *nfd = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D";
+
+void test_status_renames__precomposed_unicode_rename(void)
+{
+	git_status_list *statuslist;
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	struct status_entry expected0[] = {
+		{ GIT_STATUS_WT_NEW, nfd, NULL },
+		{ GIT_STATUS_WT_DELETED, "sixserving.txt", NULL },
+	};
+	struct status_entry expected1[] = {
+		{ GIT_STATUS_WT_RENAMED, "sixserving.txt", nfd },
+	};
+	struct status_entry expected2[] = {
+		{ GIT_STATUS_WT_DELETED, "sixserving.txt", NULL },
+		{ GIT_STATUS_WT_NEW, nfc, NULL },
+	};
+	struct status_entry expected3[] = {
+		{ GIT_STATUS_WT_RENAMED, "sixserving.txt", nfc },
+	};
+
+	rename_file(g_repo, "sixserving.txt", nfc);
+
+	opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED;
+
+	cl_repo_set_bool(g_repo, "core.precomposeunicode", false);
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	check_status(statuslist, expected0, ARRAY_SIZE(expected0));
+	git_status_list_free(statuslist);
+
+	opts.flags |= GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR;
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	check_status(statuslist, expected1, ARRAY_SIZE(expected1));
+	git_status_list_free(statuslist);
+
+	cl_repo_set_bool(g_repo, "core.precomposeunicode", true);
+
+	opts.flags &= ~GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR;
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	check_status(statuslist, expected2, ARRAY_SIZE(expected2));
+	git_status_list_free(statuslist);
+
+	opts.flags |= GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR;
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	check_status(statuslist, expected3, ARRAY_SIZE(expected3));
+	git_status_list_free(statuslist);
+}
+
+#endif
-- 
cgit v1.2.3


From f608f3bb274dbf413127ba352f48021ed538139e Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 24 Apr 2014 15:25:01 -0700
Subject: Test toggling core.precomposeunicode yields rename

There is an interesting difference with core Git here, though.
Because libgit2 will do rename detection with the working directory,
in the last case where the HEAD and the working directory both
have the decomposed data and the index has the composed data, we
generate a single status record with two renames whereas Git will
generate one rename (head to index) and one untracked file.
---
 tests/status/renames.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/tests/status/renames.c b/tests/status/renames.c
index ab9cd7445..39fb801e2 100644
--- a/tests/status/renames.c
+++ b/tests/status/renames.c
@@ -636,4 +636,73 @@ void test_status_renames__precomposed_unicode_rename(void)
 	git_status_list_free(statuslist);
 }
 
+void test_status_renames__precomposed_unicode_toggle_is_rename(void)
+{
+	git_status_list *statuslist;
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	struct status_entry expected0[] = {
+		{ GIT_STATUS_INDEX_RENAMED, "ikeepsix.txt", nfd },
+	};
+	struct status_entry expected1[] = {
+		{ GIT_STATUS_WT_RENAMED, nfd, nfc },
+	};
+	struct status_entry expected2[] = {
+		{ GIT_STATUS_INDEX_RENAMED, nfd, nfc },
+	};
+	struct status_entry expected3[] = {
+		{ GIT_STATUS_INDEX_RENAMED | GIT_STATUS_WT_RENAMED, nfd, nfd },
+	};
+
+	cl_repo_set_bool(g_repo, "core.precomposeunicode", false);
+	rename_file(g_repo, "ikeepsix.txt", nfd);
+
+	{
+		git_index *index;
+		cl_git_pass(git_repository_index(&index, g_repo));
+		cl_git_pass(git_index_remove_bypath(index, "ikeepsix.txt"));
+		cl_git_pass(git_index_add_bypath(index, nfd));
+		cl_git_pass(git_index_write(index));
+		git_index_free(index);
+	}
+
+	opts.flags |= GIT_STATUS_OPT_INCLUDE_UNTRACKED |
+		GIT_STATUS_OPT_RENAMES_HEAD_TO_INDEX |
+		GIT_STATUS_OPT_RENAMES_INDEX_TO_WORKDIR;
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	check_status(statuslist, expected0, ARRAY_SIZE(expected0));
+	git_status_list_free(statuslist);
+
+	cl_repo_commit_from_index(NULL, g_repo, NULL, 0, "commit nfd");
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	cl_assert_equal_sz(0, git_status_list_entrycount(statuslist));
+	git_status_list_free(statuslist);
+
+	cl_repo_set_bool(g_repo, "core.precomposeunicode", true);
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	check_status(statuslist, expected1, ARRAY_SIZE(expected1));
+	git_status_list_free(statuslist);
+
+	{
+		git_index *index;
+		cl_git_pass(git_repository_index(&index, g_repo));
+		cl_git_pass(git_index_remove_bypath(index, nfd));
+		cl_git_pass(git_index_add_bypath(index, nfc));
+		cl_git_pass(git_index_write(index));
+		git_index_free(index);
+	}
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	check_status(statuslist, expected2, ARRAY_SIZE(expected2));
+	git_status_list_free(statuslist);
+
+	cl_repo_set_bool(g_repo, "core.precomposeunicode", false);
+
+	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
+	check_status(statuslist, expected3, ARRAY_SIZE(expected3));
+	git_status_list_free(statuslist);
+}
+
 #endif
-- 
cgit v1.2.3


From 6b833e3a4a29d76e25120cf374838404a6b68825 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 24 Apr 2014 15:40:50 -0700
Subject: Improve docs for status rename detection limits

and make tests empty on platforms without iconv support.
---
 include/git2/status.h  | 29 +++++++++++++++++++++++++++--
 tests/status/renames.c |  7 +++++--
 2 files changed, 32 insertions(+), 4 deletions(-)

diff --git a/include/git2/status.h b/include/git2/status.h
index 84918456a..6af45c7dd 100644
--- a/include/git2/status.h
+++ b/include/git2/status.h
@@ -236,6 +236,11 @@ GIT_EXTERN(int) git_status_foreach(
  * in what order.  See the `git_status_options` structure for details
  * about the additional controls that this makes available.
  *
+ * Note that if a `pathspec` is given in the `git_status_options` to filter
+ * the status, then the results from rename detection (if you enable it) may
+ * not be accurate.  To do rename detection properly, this must be called
+ * with no `pathspec` so that all files can be considered.
+ *
  * @param repo Repository object
  * @param opts Status options structure
  * @param callback The function to call on each file
@@ -251,8 +256,20 @@ GIT_EXTERN(int) git_status_foreach_ext(
 /**
  * Get file status for a single file.
  *
- * This is not quite the same as calling `git_status_foreach_ext()` with
- * the pathspec set to the specified path.
+ * This tries to get status for the filename that you give.  If no files
+ * match that name (in either the HEAD, index, or working directory), this
+ * returns GIT_ENOTFOUND.
+ *
+ * If the name matches multiple files (for example, if the `path` names a
+ * directory or if running on a case- insensitive filesystem and yet the
+ * HEAD has two entries that both match the path), then this returns
+ * GIT_EAMBIGUOUS because it cannot give correct results.
+ *
+ * This does not do any sort of rename detection.  Renames require a set of
+ * targets and because of the path filtering, there is not enough
+ * information to check renames correctly.  To check file status with rename
+ * detection, there is no choice but to do a full `git_status_list_new` and
+ * scan through looking for the path that you are interested in.
  *
  * @param status_flags Output combination of git_status_t values for file
  * @param repo A repository object
@@ -269,6 +286,11 @@ GIT_EXTERN(int) git_status_file(
 /**
  * Gather file status information and populate the `git_status_list`.
  *
+ * Note that if a `pathspec` is given in the `git_status_options` to filter
+ * the status, then the results from rename detection (if you enable it) may
+ * not be accurate.  To do rename detection properly, this must be called
+ * with no `pathspec` so that all files can be considered.
+ *
  * @param out Pointer to store the status results in
  * @param repo Repository object
  * @param opts Status options structure
@@ -282,6 +304,9 @@ GIT_EXTERN(int) git_status_list_new(
 /**
  * Gets the count of status entries in this list.
  *
+ * If there are no changes in status (at least according the options given
+ * when the status list was created), this can return 0.
+ *
  * @param statuslist Existing status list object
  * @return the number of status entries
  */
diff --git a/tests/status/renames.c b/tests/status/renames.c
index 39fb801e2..24b8aca2b 100644
--- a/tests/status/renames.c
+++ b/tests/status/renames.c
@@ -582,12 +582,13 @@ void test_status_renames__zero_byte_file_does_not_fail(void)
 }
 
 #ifdef GIT_USE_ICONV
-
 static char *nfc = "\xC3\x85\x73\x74\x72\xC3\xB6\x6D";
 static char *nfd = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D";
+#endif
 
 void test_status_renames__precomposed_unicode_rename(void)
 {
+#ifdef GIT_USE_ICONV
 	git_status_list *statuslist;
 	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
 	struct status_entry expected0[] = {
@@ -634,10 +635,12 @@ void test_status_renames__precomposed_unicode_rename(void)
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
 	check_status(statuslist, expected3, ARRAY_SIZE(expected3));
 	git_status_list_free(statuslist);
+#endif
 }
 
 void test_status_renames__precomposed_unicode_toggle_is_rename(void)
 {
+#ifdef GIT_USE_ICONV
 	git_status_list *statuslist;
 	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
 	struct status_entry expected0[] = {
@@ -703,6 +706,6 @@ void test_status_renames__precomposed_unicode_toggle_is_rename(void)
 	cl_git_pass(git_status_list_new(&statuslist, g_repo, &opts));
 	check_status(statuslist, expected3, ARRAY_SIZE(expected3));
 	git_status_list_free(statuslist);
+#endif
 }
 
-#endif
-- 
cgit v1.2.3


From 424222f4157b050fd6417b8805796f7183a38e03 Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Fri, 25 Apr 2014 15:49:26 +0200
Subject: Filter: Make sure to release local on error

---
 src/filter.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/filter.c b/src/filter.c
index ff81eb14e..b2f57964a 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -617,7 +617,7 @@ int git_filter_list_apply_to_data(
 			si = di; /* swap buffers */
 		} else {
 			tgt->size = 0;
-			return error;
+			goto cleanup;
 		}
 	}
 
@@ -625,9 +625,10 @@ int git_filter_list_apply_to_data(
 	if (si != 1)
 		git_buf_swap(dbuffer[0], dbuffer[1]);
 
+cleanup:
 	git_buf_free(&local); /* don't leak if we allocated locally */
 
-	return 0;
+	return error;
 }
 
 int git_filter_list_apply_to_file(
-- 
cgit v1.2.3


From 7b8d564d5da4745e9227676a8768b3b48ca3dff8 Mon Sep 17 00:00:00 2001
From: Jiri Pospisil <mekishizufu@gmail.com>
Date: Fri, 25 Apr 2014 15:49:58 +0200
Subject: Reset tests: Use sandboxed index

---
 tests/reset/default.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/tests/reset/default.c b/tests/reset/default.c
index ecb3e7f9f..c76f14813 100644
--- a/tests/reset/default.c
+++ b/tests/reset/default.c
@@ -185,23 +185,20 @@ void test_reset_default__resetting_unknown_filepaths_does_not_fail(void)
 
 void test_reset_default__staged_rename_reset_delete(void)
 {
-	git_index *idx;
 	git_index_entry entry;
 	const git_index_entry *existing;
 	char *paths[] = { "new.txt" };
 
 	initialize("testrepo2");
 
-	cl_git_pass(git_repository_index(&idx, _repo));
-
-	existing = git_index_get_bypath(idx, "new.txt", 0);
+	existing = git_index_get_bypath(_index, "new.txt", 0);
 	cl_assert(existing);
 	memcpy(&entry, existing, sizeof(entry));
 
-	cl_git_pass(git_index_remove_bypath(idx, "new.txt"));
+	cl_git_pass(git_index_remove_bypath(_index, "new.txt"));
 
 	entry.path = "renamed.txt";
-	cl_git_pass(git_index_add(idx, &entry));
+	cl_git_pass(git_index_add(_index, &entry));
 
 	_pathspecs.strings = paths;
 	_pathspecs.count = 1;
-- 
cgit v1.2.3


From 4f9d54146d569fffb679386fd3057e571afacd1f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 26 Apr 2014 14:29:18 +0200
Subject: refdb: fix typo and wording

---
 src/refdb_fs.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index 2550b7e26..f9bd4eab5 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -930,7 +930,7 @@ static int should_write_reflog(int *write, git_repository *repo, const char *nam
 	git_config *config;
 	int error, logall, is_bare;
 
-	/* Defaults to the oppsite of being bare */
+	/* Defaults to the opposite of the repo being bare */
 	is_bare = git_repository_is_bare(repo);
 	logall = !is_bare;
 
-- 
cgit v1.2.3


From 1f0d4f3d8dd5c87d3f42a913a1af9d6f1f2da437 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 26 Apr 2014 13:51:14 +0200
Subject: netops: unit-test the cert host-name pattern matching

This kind of stuff should have unit tests, even if it's just to show
what we expect to match successfully.
---
 src/netops.c              |  8 ++++----
 src/netops.h              | 13 +++++++++++++
 tests/network/matchhost.c | 13 +++++++++++++
 3 files changed, 30 insertions(+), 4 deletions(-)
 create mode 100644 tests/network/matchhost.c

diff --git a/src/netops.c b/src/netops.c
index ad27d84cf..23f482b12 100644
--- a/src/netops.c
+++ b/src/netops.c
@@ -207,7 +207,7 @@ static int gitno_ssl_teardown(gitno_ssl *ssl)
 }
 
 /* Match host names according to RFC 2818 rules */
-static int match_host(const char *pattern, const char *host)
+int gitno__match_host(const char *pattern, const char *host)
 {
 	for (;;) {
 		char c = tolower(*pattern++);
@@ -230,9 +230,9 @@ static int match_host(const char *pattern, const char *host)
 			while(*host) {
 				char h = tolower(*host);
 				if (c == h)
-					return match_host(pattern, host++);
+					return gitno__match_host(pattern, host++);
 				if (h == '.')
-					return match_host(pattern, host);
+					return gitno__match_host(pattern, host);
 				host++;
 			}
 			return -1;
@@ -250,7 +250,7 @@ static int check_host_name(const char *name, const char *host)
 	if (!strcasecmp(name, host))
 		return 0;
 
-	if (match_host(name, host) < 0)
+	if (gitno__match_host(name, host) < 0)
 		return -1;
 
 	return 0;
diff --git a/src/netops.h b/src/netops.h
index 666d66b12..8e3a2524f 100644
--- a/src/netops.h
+++ b/src/netops.h
@@ -54,6 +54,19 @@ enum {
 	GITNO_CONNECT_SSL_NO_CHECK_CERT = 2,
 };
 
+/**
+ * Check if the name in a cert matches the wanted hostname
+ *
+ * Check if a pattern from a certificate matches the hostname we
+ * wanted to connect to according to RFC2818 rules (which specifies
+ * HTTP over TLS). Mainly, an asterisk matches anything, but is
+ * limited to a single url component.
+ *
+ * Note that this does not set an error message. It expects the user
+ * to provide the message for the user.
+ */
+int gitno__match_host(const char *pattern, const char *host);
+
 void gitno_buffer_setup(gitno_socket *t, gitno_buffer *buf, char *data, size_t len);
 void gitno_buffer_setup_callback(gitno_socket *t, gitno_buffer *buf, char *data, size_t len, int (*recv)(gitno_buffer *buf), void *cb_data);
 int gitno_recv(gitno_buffer *buf);
diff --git a/tests/network/matchhost.c b/tests/network/matchhost.c
new file mode 100644
index 000000000..3100dc21d
--- /dev/null
+++ b/tests/network/matchhost.c
@@ -0,0 +1,13 @@
+#include "clar_libgit2.h"
+#include "netops.h"
+
+void test_network_matchhost__match(void)
+{
+	cl_git_pass(gitno__match_host("*.example.org", "www.example.org"));
+	cl_git_pass(gitno__match_host("*.foo.example.org", "www.foo.example.org"));
+	cl_git_fail(gitno__match_host("*.foo.example.org", "foo.example.org"));
+	cl_git_fail(gitno__match_host("*.foo.example.org", "www.example.org"));
+	cl_git_fail(gitno__match_host("*.example.org", "example.org"));
+	cl_git_fail(gitno__match_host("*.example.org", "www.foo.example.org"));
+	cl_git_fail(gitno__match_host("*.example.org", "blah.www.www.example.org"));
+}
-- 
cgit v1.2.3


From 51d3f6f5f2f9dc6c9f9dd64d3ccbd0afdcf6fb6e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 26 Apr 2014 14:16:42 +0200
Subject: netops: provide more specific error for cert failure

Specify what we do not like about the certificate. In this case, we do
not like the name.
---
 src/netops.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/netops.c b/src/netops.c
index 23f482b12..1e1832112 100644
--- a/src/netops.c
+++ b/src/netops.c
@@ -321,7 +321,7 @@ static int verify_server_cert(gitno_ssl *ssl, const char *host)
 	GENERAL_NAMES_free(alts);
 
 	if (matched == 0)
-		goto cert_fail;
+		goto cert_fail_name;
 
 	if (matched == 1)
 		return 0;
@@ -358,11 +358,11 @@ static int verify_server_cert(gitno_ssl *ssl, const char *host)
 		int size = ASN1_STRING_to_UTF8(&peer_cn, str);
 		GITERR_CHECK_ALLOC(peer_cn);
 		if (memchr(peer_cn, '\0', size))
-			goto cert_fail;
+			goto cert_fail_name;
 	}
 
 	if (check_host_name((char *)peer_cn, host) < 0)
-		goto cert_fail;
+		goto cert_fail_name;
 
 	OPENSSL_free(peer_cn);
 
@@ -372,9 +372,9 @@ on_error:
 	OPENSSL_free(peer_cn);
 	return ssl_set_error(ssl, 0);
 
-cert_fail:
+cert_fail_name:
 	OPENSSL_free(peer_cn);
-	giterr_set(GITERR_SSL, "Certificate host name check failed");
+	giterr_set(GITERR_SSL, "hostname does not match certificate");
 	return -1;
 }
 
-- 
cgit v1.2.3


From 783555d8e11516fdc01b66da0f873f5854b9bff6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 26 Apr 2014 14:36:32 +0200
Subject: netops: catch the server not sending a certificate

It's possible for an encrypted connection not have a certificate. In
this case, SSL_get_verify_result() will return OK because no error
happened (as it never even tried to validate anything).

SSL_get_peer_certificate() will return NULL in this case so we need to
catch that. On the upside, the current code would segfault in this
situation instead of letting it through as a valid cert.
---
 src/netops.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/netops.c b/src/netops.c
index 1e1832112..24092c17f 100644
--- a/src/netops.c
+++ b/src/netops.c
@@ -287,6 +287,10 @@ static int verify_server_cert(gitno_ssl *ssl, const char *host)
 
 
 	cert = SSL_get_peer_certificate(ssl->ssl);
+	if (!cert) {
+		giterr_set(GITERR_SSL, "the server did not provide a certificate");
+		return -1;
+	}
 
 	/* Check the alternative names */
 	alts = X509_get_ext_d2i(cert, NID_subject_alt_name, NULL, NULL);
-- 
cgit v1.2.3


From c7f86efb13815554d5b5e7c58bf19769e99c1357 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 26 Apr 2014 18:04:43 +0200
Subject: zstream: grow based on used memory rather than allocated

When deflating data, we might need to grow the buffer. Currently we
add a guess on top of the currently-allocated buffer size.

When we re-use the buffer, it already has some memory allocated; adding
to that means that we always grow the buffer regardless of how much we
need to use.

Instead, increase on top of the currently-used size. This still leaves
us with the allocated size of the largest object we compress, but it's a
minor pain compared to unbounded growth.

This fixes #2285.
---
 src/zstream.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/zstream.c b/src/zstream.c
index 85fa2e0e6..e75fb265e 100644
--- a/src/zstream.c
+++ b/src/zstream.c
@@ -134,7 +134,7 @@ int git_zstream_deflatebuf(git_buf *out, const void *in, size_t in_len)
 	while (!git_zstream_done(&zs)) {
 		size_t step = git_zstream_suggest_output_len(&zs), written;
 
-		if ((error = git_buf_grow(out, out->asize + step)) < 0)
+		if ((error = git_buf_grow(out, out->size + step)) < 0)
 			goto done;
 
 		written = out->asize - out->size;
-- 
cgit v1.2.3


From 38d338b2b85f280fe54057375fc3ccd6d2877e26 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 26 Apr 2014 18:15:39 +0200
Subject: pack-objects: always write out the status in write_one()

Make sure we set the output parameter to a value.
---
 src/pack-objects.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/pack-objects.c b/src/pack-objects.c
index 7e5f667f4..ace8afd17 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -406,6 +406,7 @@ static int write_one(
 			po->delta = NULL;
 	}
 
+	*status = WRITE_ONE_WRITTEN;
 	po->written = 1;
 	po->recursing = 0;
 
-- 
cgit v1.2.3


From 7f0de93a0ddb7aeac24cf1427f50ec86e7a58c08 Mon Sep 17 00:00:00 2001
From: Marcin Sawicki <odcinek@gmail.com>
Date: Mon, 28 Apr 2014 15:24:36 +0100
Subject: Make the build CMake 2.6 compatible

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 704770b29..8a3890152 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -15,7 +15,7 @@ PROJECT(libgit2 C)
 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 
 # Add find modules to the path
-SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/cmake/Modules/")
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
 
 INCLUDE(CheckLibraryExists)
 INCLUDE(AddCFlagIfSupported)
-- 
cgit v1.2.3


From 36a6151833de6b911e4169b468967aabfedd59e2 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Tue, 29 Apr 2014 13:28:16 +0200
Subject: MidnightBSD may also not have strnlen

---
 src/strnlen.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/strnlen.h b/src/strnlen.h
index 007da2e55..fdd7fe39c 100644
--- a/src/strnlen.h
+++ b/src/strnlen.h
@@ -7,7 +7,7 @@
 #ifndef INCLUDE_strlen_h__
 #define INCLUDE_strlen_h__
 
-#if defined(__MINGW32__) || defined(__sun) || defined(__APPLE__)
+#if defined(__MINGW32__) || defined(__sun) || defined(__APPLE__) || defined(__MidnightBSD__)
 #   define NO_STRNLEN
 #endif
 
-- 
cgit v1.2.3


From 217c029b54e8f1574ae6bc71c4b25533ecff3b6a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 9 Apr 2014 14:08:22 +0200
Subject: commit: safer commit creation with reference update

The current version of the commit creation and amend function are unsafe
to use when passing the update_ref parameter, as they do not check that
the reference at the moment of update points to what the user expects.

Make sure that we're moving history forward when we ask the library to
update the reference for us by checking that the first parent of the new
commit is the current value of the reference. We also make sure that the
ref we're updating hasn't moved between the read and the write.

Similarly, when amending a commit, make sure that the current tip of the
branch is the commit we're amending.
---
 include/git2/commit.h                  |  5 +-
 src/commit.c                           | 99 ++++++++++++++++++++++++++--------
 tests/commit/commit.c                  |  4 ++
 tests/object/commit/commitstagedfile.c |  9 ++++
 4 files changed, 94 insertions(+), 23 deletions(-)

diff --git a/include/git2/commit.h b/include/git2/commit.h
index 834330b5d..fb53a701b 100644
--- a/include/git2/commit.h
+++ b/include/git2/commit.h
@@ -254,7 +254,8 @@ GIT_EXTERN(int) git_commit_nth_gen_ancestor(
  *	is not direct, it will be resolved to a direct reference.
  *	Use "HEAD" to update the HEAD of the current branch and
  *	make it point to this commit. If the reference doesn't
- *	exist yet, it will be created.
+ *	exist yet, it will be created. If it does exist, the first
+ *	parent must be the tip of this branch.
  *
  * @param author Signature with author and author time of commit
  *
@@ -329,7 +330,7 @@ GIT_EXTERN(int) git_commit_create_v(
  *
  * The `update_ref` value works as in the regular `git_commit_create()`,
  * updating the ref to point to the newly rewritten commit.  If you want
- * to amend a commit that is not currently the HEAD of the branch and then
+ * to amend a commit that is not currently the tip of the branch and then
  * rewrite the following commits to reach a ref, pass this as NULL and
  * update the rest of the commit chain and ref separately.
  *
diff --git a/src/commit.c b/src/commit.c
index 255debe82..227d5c4a5 100644
--- a/src/commit.c
+++ b/src/commit.c
@@ -34,6 +34,35 @@ void git_commit__free(void *_commit)
 	git__free(commit);
 }
 
+static int update_ref_for_commit(git_repository *repo, git_reference *ref, const char *update_ref, const git_oid *id, const git_signature *committer)
+{
+	git_reference *ref2 = NULL;
+	int error;
+	git_commit *c;
+	const char *shortmsg;
+	git_buf reflog_msg = GIT_BUF_INIT;
+
+	if ((error = git_commit_lookup(&c, repo, id)) < 0) {
+		return error;
+	}
+
+	shortmsg = git_commit_summary(c);
+	git_buf_printf(&reflog_msg, "commit%s: %s",
+		       git_commit_parentcount(c) == 0 ? " (initial)" : "",
+		       shortmsg);
+	git_commit_free(c);
+
+	if (ref) {
+		error = git_reference_set_target(&ref2, ref, id, committer, git_buf_cstr(&reflog_msg));
+		git_reference_free(ref2);
+	} else {
+		error = git_reference__update_terminal(repo, update_ref, id, committer, git_buf_cstr(&reflog_msg));
+	}
+
+	git_buf_free(&reflog_msg);
+	return error;
+}
+
 int git_commit_create_from_callback(
 	git_oid *id,
 	git_repository *repo,
@@ -46,6 +75,9 @@ int git_commit_create_from_callback(
 	git_commit_parent_callback parent_cb,
 	void *parent_payload)
 {
+	git_reference *ref = NULL;
+	int error = 0, matched_parent = 0;
+	const git_oid *current_id = NULL;
 	git_buf commit = GIT_BUF_INIT;
 	size_t i = 0;
 	git_odb *odb;
@@ -53,10 +85,31 @@ int git_commit_create_from_callback(
 
 	assert(id && repo && tree && parent_cb);
 
+	if (update_ref) {
+		error = git_reference_lookup_resolved(&ref, repo, update_ref, 10);
+		if (error < 0 && error != GIT_ENOTFOUND)
+			return error;
+	}
+	giterr_clear();
+
+	if (ref)
+		current_id = git_reference_target(ref);
+
 	git_oid__writebuf(&commit, "tree ", tree);
 
-	while ((parent = parent_cb(i++, parent_payload)) != NULL)
+	while ((parent = parent_cb(i, parent_payload)) != NULL) {
 		git_oid__writebuf(&commit, "parent ", parent);
+		if (i == 0 && current_id && git_oid_equal(current_id, parent))
+			matched_parent = 1;
+		i++;
+	}
+
+	if (ref && !matched_parent) {
+		git_reference_free(ref);
+		git_buf_free(&commit);
+		giterr_set(GITERR_OBJECT, "failed to create commit: current tip is not the first parent");
+		return GIT_EMODIFIED;
+	}
 
 	git_signature__writebuf(&commit, "author ", author);
 	git_signature__writebuf(&commit, "committer ", committer);
@@ -78,24 +131,8 @@ int git_commit_create_from_callback(
 	git_buf_free(&commit);
 
 	if (update_ref != NULL) {
-		int error;
-		git_commit *c;
-		const char *shortmsg;
-		git_buf reflog_msg = GIT_BUF_INIT;
-
-		if (git_commit_lookup(&c, repo, id) < 0)
-			goto on_error;
-
-		shortmsg = git_commit_summary(c);
-		git_buf_printf(&reflog_msg, "commit%s: %s",
-				git_commit_parentcount(c) == 0 ? " (initial)" : "",
-				shortmsg);
-		git_commit_free(c);
-
-		error = git_reference__update_terminal(repo, update_ref, id,
-				committer, git_buf_cstr(&reflog_msg));
-
-		git_buf_free(&reflog_msg);
+		error = update_ref_for_commit(repo, ref, update_ref, id, committer);
+		git_reference_free(ref);
 		return error;
 	}
 
@@ -242,6 +279,8 @@ int git_commit_amend(
 {
 	git_repository *repo;
 	git_oid tree_id;
+	git_reference *ref;
+	int error;
 
 	assert(id && commit_to_amend);
 
@@ -266,9 +305,27 @@ int git_commit_amend(
 		git_oid_cpy(&tree_id, git_tree_id(tree));
 	}
 
-	return git_commit_create_from_callback(
-		id, repo, update_ref, author, committer, message_encoding, message,
+	if (update_ref) {
+		if ((error = git_reference_lookup_resolved(&ref, repo, update_ref, 5)) < 0)
+			return error;
+
+		if (git_oid_cmp(git_commit_id(commit_to_amend), git_reference_target(ref))) {
+			git_reference_free(ref);
+			giterr_set(GITERR_REFERENCE, "commit to amend is not the tip of the given branch");
+			return -1;
+		}
+	}
+
+	error = git_commit_create_from_callback(
+		id, repo, NULL, author, committer, message_encoding, message,
 		&tree_id, commit_parent_for_amend, (void *)commit_to_amend);
+
+	if (!error && update_ref) {
+		error = update_ref_for_commit(repo, ref, NULL, id, committer);
+		git_reference_free(ref);
+	}
+
+	return error;
 }
 
 int git_commit__parse(void *_commit, git_odb_object *odb_obj)
diff --git a/tests/commit/commit.c b/tests/commit/commit.c
index 38397d2df..fa181b703 100644
--- a/tests/commit/commit.c
+++ b/tests/commit/commit.c
@@ -38,6 +38,10 @@ void test_commit_commit__create_unexisting_update_ref(void)
 	cl_git_pass(git_commit_create(&oid, _repo, "refs/heads/foo/bar", s, s,
 				      NULL, "some msg", tree, 1, (const git_commit **) &commit));
 
+	/* fail because the parent isn't the tip of the branch anymore */
+	cl_git_fail(git_commit_create(&oid, _repo, "refs/heads/foo/bar", s, s,
+				      NULL, "some msg", tree, 1, (const git_commit **) &commit));
+
 	cl_git_pass(git_reference_lookup(&ref, _repo, "refs/heads/foo/bar"));
 	cl_assert(!git_oid_cmp(&oid, git_reference_target(ref)));
 
diff --git a/tests/object/commit/commitstagedfile.c b/tests/object/commit/commitstagedfile.c
index 3e7b3c02c..9758ea9a2 100644
--- a/tests/object/commit/commitstagedfile.c
+++ b/tests/object/commit/commitstagedfile.c
@@ -175,6 +175,10 @@ void test_object_commit_commitstagedfile__amend_commit(void)
 	cl_git_pass(git_commit_amend(
 		&new_oid, old_commit, "HEAD", NULL, NULL, NULL, "Initial commit", NULL));
 
+	/* fail because the commit isn't the tip of the branch anymore */
+	cl_git_fail(git_commit_amend(
+		&new_oid, old_commit, "HEAD", NULL, NULL, NULL, "Initial commit", NULL));
+
 	cl_git_pass(git_commit_lookup(&new_commit, repo, &new_oid));
 
 	cl_assert_equal_i(0, git_commit_parentcount(new_commit));
@@ -182,6 +186,7 @@ void test_object_commit_commitstagedfile__amend_commit(void)
 	assert_commit_is_head(new_commit);
 
 	git_commit_free(old_commit);
+
 	old_commit = new_commit;
 
 	/* let's amend the tree of that last commit */
@@ -192,6 +197,10 @@ void test_object_commit_commitstagedfile__amend_commit(void)
 	cl_git_pass(git_tree_lookup(&tree, repo, &tree_oid));
 	cl_assert_equal_i(2, git_tree_entrycount(tree));
 
+	/* fail to amend on a ref which does not exist */
+	cl_git_fail_with(GIT_ENOTFOUND, git_commit_amend(
+		&new_oid, old_commit, "refs/heads/nope", NULL, NULL, NULL, "Initial commit", tree));
+
 	cl_git_pass(git_commit_amend(
 		&new_oid, old_commit, "HEAD", NULL, NULL, NULL, "Initial commit", tree));
 	git_tree_free(tree);
-- 
cgit v1.2.3


From 48ebea662a33a3b918143c014dde88e58e6d0a75 Mon Sep 17 00:00:00 2001
From: nulltoken <emeric.fermas@gmail.com>
Date: Mon, 7 Jan 2013 00:20:13 +0100
Subject: tests: Introduce count_config_entries_match() helper

---
 tests/config/config_helpers.c | 28 ++++++++++++++++++++++++++++
 tests/config/config_helpers.h |  4 ++++
 2 files changed, 32 insertions(+)

diff --git a/tests/config/config_helpers.c b/tests/config/config_helpers.c
index 53bd945a0..35da720e0 100644
--- a/tests/config/config_helpers.c
+++ b/tests/config/config_helpers.c
@@ -35,3 +35,31 @@ void assert_config_entry_value(
 
 	cl_assert_equal_s(expected_value, out);
 }
+
+static int count_config_entries_cb(
+	const git_config_entry *entry,
+	void *payload)
+{
+	int *how_many = (int *)payload;
+
+	GIT_UNUSED(entry);
+
+	(*how_many)++;
+
+	return 0;
+}
+
+int count_config_entries_match(git_repository *repo, const char *pattern)
+{
+	git_config *config;
+	int how_many = 0;
+
+	cl_git_pass(git_repository_config(&config, repo));
+
+	cl_assert_equal_i(0, git_config_foreach_match(
+		config,	pattern, count_config_entries_cb, &how_many));
+
+	git_config_free(config);
+
+	return how_many;
+}
diff --git a/tests/config/config_helpers.h b/tests/config/config_helpers.h
index b887b3d38..440645730 100644
--- a/tests/config/config_helpers.h
+++ b/tests/config/config_helpers.h
@@ -7,3 +7,7 @@ extern void assert_config_entry_value(
 	git_repository *repo,
 	const char *name,
 	const char *expected_value);
+
+extern int count_config_entries_match(
+	git_repository *repo,
+	const char *pattern);
-- 
cgit v1.2.3


From 04739e9f4a10327e3041cd4b2f7ca631a14dab9b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 30 Apr 2014 10:15:44 +0200
Subject: Unquiet CMake output

The point of this phase is to know what we have and not. Show the user a
clear indication of what we have.
---
 CMakeLists.txt | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8a3890152..e7701429c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -139,7 +139,7 @@ ELSE ()
 		FIND_PACKAGE(OpenSSL)
 	ENDIF ()
 
-	FIND_PACKAGE(HTTP_Parser QUIET)
+	FIND_PACKAGE(HTTP_Parser)
 	IF (HTTP_PARSER_FOUND AND HTTP_PARSER_VERSION_MAJOR EQUAL 2)
 		INCLUDE_DIRECTORIES(${HTTP_PARSER_INCLUDE_DIRS})
 		LINK_LIBRARIES(${HTTP_PARSER_LIBRARIES})
@@ -174,9 +174,7 @@ IF(WIN32 OR AMIGA OR ANDROID)
 ENDIF()
 
 # Optional external dependency: zlib
-# It's optional, but FIND_PACKAGE gives a warning that looks more like an
-# error.
-FIND_PACKAGE(ZLIB QUIET)
+FIND_PACKAGE(ZLIB)
 IF (ZLIB_FOUND)
 	INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIRS})
 	LINK_LIBRARIES(${ZLIB_LIBRARIES})
@@ -185,8 +183,6 @@ IF (ZLIB_FOUND)
 	ELSE()
 		SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} zlib")
 	ENDIF()
-	# Fake the message CMake would have shown
-	MESSAGE(STATUS "Found zlib: ${ZLIB_LIBRARY}")
 ELSE()
 	MESSAGE(STATUS "zlib was not found; using bundled 3rd-party sources." )
 	INCLUDE_DIRECTORIES(deps/zlib)
@@ -196,7 +192,7 @@ ENDIF()
 
 # Optional external dependency: libssh2
 IF (USE_SSH AND NOT MINGW)
-	FIND_PACKAGE(LIBSSH2 QUIET)
+	FIND_PACKAGE(LIBSSH2)
 ENDIF()
 IF (LIBSSH2_FOUND)
 	ADD_DEFINITIONS(-DGIT_SSH)
@@ -207,7 +203,7 @@ ENDIF()
 
 # Optional external dependency: iconv
 IF (USE_ICONV)
-	FIND_PACKAGE(ICONV QUIET)
+	FIND_PACKAGE(ICONV)
 ENDIF()
 IF (ICONV_FOUND)
 	ADD_DEFINITIONS(-DGIT_USE_ICONV)
-- 
cgit v1.2.3


From 096ac799a37e235d894641f2974a6d6105e41d4c Mon Sep 17 00:00:00 2001
From: Ting-Wei Lan <lantw44@gmail.com>
Date: Thu, 13 Feb 2014 22:38:23 +0800
Subject: Workaround missing .pc files on FreeBSD

This fixes #2118
---
 CMakeLists.txt | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e7701429c..ac75ebbcb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -157,7 +157,11 @@ IF (WIN32 AND NOT MINGW AND NOT SHA1_TYPE STREQUAL "builtin")
 	FILE(GLOB SRC_SHA1 src/hash/hash_win32.c)
 ELSEIF (OPENSSL_FOUND AND NOT SHA1_TYPE STREQUAL "builtin")
 	ADD_DEFINITIONS(-DOPENSSL_SHA1)
-	SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} openssl")
+	IF (CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
+		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -lssl")
+	ELSE()
+		SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} openssl")
+	ENDIF ()
 ELSE()
 	FILE(GLOB SRC_SHA1 src/hash/hash_generic.c)
 ENDIF()
@@ -178,7 +182,7 @@ FIND_PACKAGE(ZLIB)
 IF (ZLIB_FOUND)
 	INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIRS})
 	LINK_LIBRARIES(${ZLIB_LIBRARIES})
-	IF(APPLE)
+	IF(APPLE OR CMAKE_SYSTEM_NAME MATCHES "FreeBSD")
 		SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} -lz")
 	ELSE()
 		SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} zlib")
-- 
cgit v1.2.3


From f5fc63bc0cdc19250b384ea62e2e1796128831ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 30 Apr 2014 10:55:58 +0200
Subject: Don't exclude libssh2 from MinGW

It reportedly works. It does not however work when cross-compiling on
Travis, so let's disable it there.

This fixes #2311.
---
 .travis.yml    | 2 +-
 CMakeLists.txt | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index f25ff7681..fcae726dd 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -19,7 +19,7 @@ matrix:
  fast_finish: true
  include:
    - compiler: i586-mingw32msvc-gcc
-     env: OPTIONS="-DBUILD_CLAR=OFF -DWIN32=ON -DMINGW=ON"
+     env: OPTIONS="-DBUILD_CLAR=OFF -DWIN32=ON -DMINGW=ON -DUSE_SSH=OFF"
    - compiler: gcc
      env: COVERITY=1
  allow_failures:
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ac75ebbcb..b5bd669f0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -195,7 +195,7 @@ ELSE()
 ENDIF()
 
 # Optional external dependency: libssh2
-IF (USE_SSH AND NOT MINGW)
+IF (USE_SSH)
 	FIND_PACKAGE(LIBSSH2)
 ENDIF()
 IF (LIBSSH2_FOUND)
-- 
cgit v1.2.3


From 891b0277aff31d717444c39259da2414c1f1b554 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 30 Apr 2014 11:20:51 +0200
Subject: refs: document _next_name()

If it's not documented, it doesn't show up in the docs (and we really
should document, anyway).
---
 include/git2/refs.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/include/git2/refs.h b/include/git2/refs.h
index 6a1db65a8..ae2d379d9 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -525,6 +525,17 @@ GIT_EXTERN(int) git_reference_iterator_glob_new(
  */
 GIT_EXTERN(int) git_reference_next(git_reference **out, git_reference_iterator *iter);
 
+/**
+ * Get the next reference's name
+ *
+ * This function is provided for convenience in case only the names
+ * are interesting as it avoids the allocation of the `git_reference`
+ * object which `git_reference_next()` needs.
+ *
+ * @param out pointer in which to store the string
+ * @param iter the iterator
+ * @return 0, GIT_ITEROVER if there are no more; or an error code
+ */
 GIT_EXTERN(int) git_reference_next_name(const char **out, git_reference_iterator *iter);
 
 /**
-- 
cgit v1.2.3


From 40e48ea40f5dfe0fbf786efc89d4cf297f4525e1 Mon Sep 17 00:00:00 2001
From: nulltoken <emeric.fermas@gmail.com>
Date: Fri, 15 Nov 2013 15:36:37 +0000
Subject: remote: Introduce git_remote_delete()

---
 include/git2/remote.h         |  13 +++++
 src/remote.c                  | 117 ++++++++++++++++++++++++++++++++++++++++--
 tests/network/remote/delete.c |  57 ++++++++++++++++++++
 3 files changed, 184 insertions(+), 3 deletions(-)
 create mode 100644 tests/network/remote/delete.c

diff --git a/include/git2/remote.h b/include/git2/remote.h
index 11e1e26d0..62608358d 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -611,6 +611,19 @@ GIT_EXTERN(void) git_remote_set_update_fetchhead(git_remote *remote, int value);
  */
 GIT_EXTERN(int) git_remote_is_valid_name(const char *remote_name);
 
+/**
+* Delete an existing persisted remote.
+*
+* All remote-tracking branches and configuration settings
+* for the remote will be removed.
+*
+* once deleted, the passed remote object will be freed and invalidated.
+*
+* @param remote A valid remote
+* @return 0 on success, or an error code.
+*/
+GIT_EXTERN(int) git_remote_delete(git_remote *remote);
+
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/src/remote.c b/src/remote.c
index ea638e373..8bd52e7f2 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1303,13 +1303,14 @@ static int rename_remote_config_section(
 	if (git_buf_printf(&old_section_name, "remote.%s", old_name) < 0)
 		goto cleanup;
 
-	if (git_buf_printf(&new_section_name, "remote.%s", new_name) < 0)
-		goto cleanup;
+	if (new_name &&
+		(git_buf_printf(&new_section_name, "remote.%s", new_name) < 0))
+			goto cleanup;
 
 	error = git_config_rename_section(
 		repo,
 		git_buf_cstr(&old_section_name),
-		git_buf_cstr(&new_section_name));
+		new_name ? git_buf_cstr(&new_section_name) : NULL);
 
 cleanup:
 	git_buf_free(&old_section_name);
@@ -1747,3 +1748,113 @@ int git_remote_init_callbacks(git_remote_callbacks* opts, int version)
 		return 0;
 	}
 }
+
+struct branch_removal_data {
+	git_vector branches;
+	const char *name;
+};
+
+static int retrieve_branches_cb(
+	const git_config_entry *entry,
+	void *payload)
+{
+	int error;
+	struct branch_removal_data *data = (struct branch_removal_data *)payload;
+
+	if (strcmp(data->name, entry->value))
+		return 0;
+
+	error = git_vector_insert(
+		&data->branches,
+		git__strndup(
+		entry->name + strlen("branch."),
+		strlen(entry->name) - strlen("branch.") - strlen(".remote")));
+
+	return error;
+}
+
+static int delete_branch_remote_config_entry(
+	git_config *config,
+	const char *branch_name)
+{
+	int error;
+
+	git_buf config_entry = GIT_BUF_INIT;
+
+	if (git_buf_printf(&config_entry, "branch.%s.%s", branch_name, "remote") < 0)
+		return -1;
+
+	if ((error = git_config_delete_entry(config, git_buf_cstr(&config_entry))) < 0)
+		goto cleanup;
+
+	git_buf_clear(&config_entry);
+
+	if (git_buf_printf(&config_entry, "branch.%s.%s", branch_name, "merge") < 0)
+		return -1;
+
+	error = git_config_delete_entry(config, git_buf_cstr(&config_entry));
+
+cleanup:
+	git_buf_free(&config_entry);
+
+	return error;
+}
+
+static int remove_branch_config_related_entries(
+	git_repository *repo,
+	const char *remote_name)
+{
+	int error;
+	git_config *config;
+	size_t i;
+	char *branch_name;
+	struct branch_removal_data data;
+
+	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
+		return error;
+
+	if ((error = git_vector_init(&data.branches, 4, git__strcmp_cb)) < 0)
+		return error;
+
+	data.name = remote_name;
+
+	error = git_config_foreach_match(
+		config, "branch\\..+\\.remote", retrieve_branches_cb, &data);
+
+	git_vector_foreach(&data.branches, i, branch_name) {
+		if (!error)
+			error = delete_branch_remote_config_entry(config, branch_name);
+
+		git__free(branch_name);
+	}
+
+	git_vector_free(&data.branches);
+	return error;
+}
+
+int git_remote_delete(git_remote *remote)
+{
+	int error;
+	git_repository *repo;
+
+	assert(remote);
+
+	if (!remote->name) {
+		giterr_set(GITERR_INVALID, "Can't delete an anonymous remote.");
+		return -1;
+	}
+
+	repo = git_remote_owner(remote);
+
+	if ((error = rename_remote_config_section(
+		repo, git_remote_name(remote), NULL)) < 0)
+		return error;
+
+	if ((error = remove_branch_config_related_entries(repo,
+		git_remote_name(remote))) < 0)
+		return error;
+
+	git_remote_free(remote);
+
+	return 0;
+}
diff --git a/tests/network/remote/delete.c b/tests/network/remote/delete.c
new file mode 100644
index 000000000..5bf944cda
--- /dev/null
+++ b/tests/network/remote/delete.c
@@ -0,0 +1,57 @@
+#include "clar_libgit2.h"
+#include "config/config_helpers.h"
+
+#include "repository.h"
+
+static git_remote *_remote;
+static git_repository *_repo;
+
+void test_network_remote_delete__initialize(void)
+{
+	_repo = cl_git_sandbox_init("testrepo.git");
+
+	cl_git_pass(git_remote_load(&_remote, _repo, "test"));
+}
+
+void test_network_remote_delete__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+}
+
+void test_network_remote_delete__cannot_delete_an_anonymous_remote(void)
+{
+	git_remote *remote;
+
+	cl_git_pass(git_remote_create_anonymous(&remote, _repo, "git://github.com/libgit2/libgit2", NULL));
+
+	cl_git_fail(git_remote_delete(remote));
+
+	git_remote_free(remote);
+}
+
+void test_network_remote_delete__deleting_a_remote_removes_the_remote_tracking_references(void)
+{
+	cl_assert(false);
+}
+
+void test_network_remote_delete__deleting_a_remote_removes_the_remote_configuration_settings(void)
+{
+	cl_assert(count_config_entries_match(_repo, "remote\\.test\\.+") > 0);
+
+	cl_git_pass(git_remote_delete(_remote));
+
+	cl_assert_equal_i(0, count_config_entries_match(_repo, "remote\\.test\\.+"));
+}
+
+void test_network_remote_delete__deleting_a_remote_removes_the_branch_remote_configuration_settings(void)
+{
+	assert_config_entry_existence(_repo, "branch.mergeless.remote", true);
+	assert_config_entry_existence(_repo, "branch.master.remote", true);
+
+	cl_git_pass(git_remote_delete(_remote));
+
+	assert_config_entry_existence(_repo, "branch.mergeless.remote", false);
+	assert_config_entry_existence(_repo, "branch.mergeless.merge", false);
+	assert_config_entry_existence(_repo, "branch.master.remote", false);
+	assert_config_entry_existence(_repo, "branch.master.merge", false);
+}
-- 
cgit v1.2.3


From 039e354b7d991f8de7003c7a98ad85bec601cb05 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 30 Apr 2014 11:57:54 +0200
Subject: ciscript: don't use an empty string as a number

An empty string is not a valid number, and some shells complain.

Check instead if $COVERITY is non-empty, which is a common convention
and what we're doing anyway.
---
 script/cibuild.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/script/cibuild.sh b/script/cibuild.sh
index 1f15e851e..699404bd2 100755
--- a/script/cibuild.sh
+++ b/script/cibuild.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 
-if [ "$COVERITY" -eq 1 ];
+if [ -n "$COVERITY" ];
 then
 	./script/coverity.sh;
 	exit $?;
-- 
cgit v1.2.3


From 90a4340aaa52132894d4032c4231f23cc07fbd0a Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Wed, 30 Apr 2014 11:47:58 +0200
Subject: cygwin also doesn't have qsort_r

---
 src/util.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/util.c b/src/util.c
index 39858254f..f9d37e4f4 100644
--- a/src/util.c
+++ b/src/util.c
@@ -612,7 +612,7 @@ void git__qsort_r(
 #if defined(__MINGW32__) || defined(AMIGA) || \
 	defined(__OpenBSD__) || defined(__NetBSD__) || \
 	defined(__gnu_hurd__) || defined(__ANDROID_API__) || \
-	defined(__sun) || \
+	defined(__sun) || defined(__CYGWIN__) || \
 	(__GLIBC__ == 2 && __GLIBC_MINOR__ < 8)
 	git__insertsort_r(els, nel, elsize, NULL, cmp, payload);
 #elif defined(GIT_WIN32)
-- 
cgit v1.2.3


From 5cdac19caa6c0bf81c5a71d3801be73281387cd9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 30 Apr 2014 08:29:14 +0200
Subject: remote: move branch upstream deletion to use an iterator

This should make it more readable and allocate a bunch fewer strings.
---
 src/remote.c | 95 ++++++++++++++++++++++++------------------------------------
 1 file changed, 38 insertions(+), 57 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index 8bd52e7f2..ca1099a7f 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1749,55 +1749,19 @@ int git_remote_init_callbacks(git_remote_callbacks* opts, int version)
 	}
 }
 
-struct branch_removal_data {
-	git_vector branches;
-	const char *name;
-};
-
-static int retrieve_branches_cb(
-	const git_config_entry *entry,
-	void *payload)
+/* asserts a branch.<foo>.remote format */
+static const char *name_offset(size_t *len_out, const char *name)
 {
-	int error;
-	struct branch_removal_data *data = (struct branch_removal_data *)payload;
-
-	if (strcmp(data->name, entry->value))
-		return 0;
-
-	error = git_vector_insert(
-		&data->branches,
-		git__strndup(
-		entry->name + strlen("branch."),
-		strlen(entry->name) - strlen("branch.") - strlen(".remote")));
-
-	return error;
-}
-
-static int delete_branch_remote_config_entry(
-	git_config *config,
-	const char *branch_name)
-{
-	int error;
-
-	git_buf config_entry = GIT_BUF_INIT;
-
-	if (git_buf_printf(&config_entry, "branch.%s.%s", branch_name, "remote") < 0)
-		return -1;
-
-	if ((error = git_config_delete_entry(config, git_buf_cstr(&config_entry))) < 0)
-		goto cleanup;
+	size_t prefix_len;
+	const char *dot;
 
-	git_buf_clear(&config_entry);
+	prefix_len = strlen("remote.");
+	dot = strchr(name + prefix_len, '.');
 
-	if (git_buf_printf(&config_entry, "branch.%s.%s", branch_name, "merge") < 0)
-		return -1;
-
-	error = git_config_delete_entry(config, git_buf_cstr(&config_entry));
+	assert(dot);
 
-cleanup:
-	git_buf_free(&config_entry);
-
-	return error;
+	*len_out = dot - name - prefix_len;
+	return name + prefix_len;
 }
 
 static int remove_branch_config_related_entries(
@@ -1806,29 +1770,46 @@ static int remove_branch_config_related_entries(
 {
 	int error;
 	git_config *config;
-	size_t i;
-	char *branch_name;
-	struct branch_removal_data data;
+	git_config_entry *entry;
+	git_config_iterator *iter;
+	git_buf buf = GIT_BUF_INIT;
 
 	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
 		return error;
 
-	if ((error = git_vector_init(&data.branches, 4, git__strcmp_cb)) < 0)
+	if ((error = git_config_iterator_glob_new(&iter, config, "branch\\..+\\.remote")) < 0)
 		return error;
 
-	data.name = remote_name;
+	/* find any branches with us as upstream and remove that config */
+	while ((error = git_config_next(&entry, iter)) == 0) {
+		const char *branch;
+		size_t branch_len;
 
-	error = git_config_foreach_match(
-		config, "branch\\..+\\.remote", retrieve_branches_cb, &data);
+		if (strcmp(remote_name, entry->value))
+			continue;
 
-	git_vector_foreach(&data.branches, i, branch_name) {
-		if (!error)
-			error = delete_branch_remote_config_entry(config, branch_name);
+		branch = name_offset(&branch_len, entry->name);
 
-		git__free(branch_name);
+		git_buf_clear(&buf);
+		if (git_buf_printf(&buf, "branch.%.*s.merge", (int)branch_len, branch) < 0)
+			break;
+
+		if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0)
+			break;
+
+		git_buf_clear(&buf);
+		if (git_buf_printf(&buf, "branch.%.*s.remote", (int)branch_len, branch) < 0)
+			break;
+
+		if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0)
+			break;
 	}
 
-	git_vector_free(&data.branches);
+	if (error == GIT_ITEROVER)
+		error = 0;
+
+	git_buf_free(&buf);
+	git_config_iterator_free(iter);
 	return error;
 }
 
-- 
cgit v1.2.3


From 98b8fcff4f76e9707342a3b7d132955ba18b09c4 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Tue, 29 Apr 2014 20:45:02 +0200
Subject: Build regex.c for Solaris. Added required defines for Solaris

---
 CMakeLists.txt | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 704770b29..c506c4702 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -168,7 +168,7 @@ IF (ENABLE_TRACE STREQUAL "ON")
 ENDIF()
 
 # Include POSIX regex when it is required
-IF(WIN32 OR AMIGA OR ANDROID)
+IF(WIN32 OR AMIGA OR ANDROID OR CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)")
 	INCLUDE_DIRECTORIES(deps/regex)
 	SET(SRC_REGEX deps/regex/regex.c)
 ENDIF()
@@ -290,6 +290,10 @@ IF (MSVC)
 ELSE ()
 	SET(CMAKE_C_FLAGS "-D_GNU_SOURCE -Wall -Wextra ${CMAKE_C_FLAGS}")
 
+	IF (CMAKE_SYSTEM_NAME MATCHES "(Solaris|SunOS)")
+		SET(CMAKE_C_FLAGS "-std=c99 -D_POSIX_C_SOURCE=200112L -D__EXTENSIONS__ -D_POSIX_PTHREAD_SEMANTICS ${CMAKE_C_FLAGS}")
+	ENDIF()
+
 	IF (WIN32 AND NOT CYGWIN)
 		SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG")
 	ENDIF ()
-- 
cgit v1.2.3


From 6b05240ceaf4df7bbb4806f6827f0314db6a5a91 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sun, 27 Apr 2014 19:44:20 +0200
Subject: strcasecmp is in <strings.h>

---
 src/common.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/common.h b/src/common.h
index 9c8bdc18a..dd97a3099 100644
--- a/src/common.h
+++ b/src/common.h
@@ -44,6 +44,7 @@
 #else
 
 # include <unistd.h>
+# include <strings.h>
 # ifdef GIT_THREADS
 #	include <pthread.h>
 #	include <sched.h>
-- 
cgit v1.2.3


From 183aa4f8317f5a64f1bc931551a342e6a93ce1c3 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Wed, 30 Apr 2014 17:46:53 +0200
Subject: Check for NULL before passing it to vsnprintf

---
 src/config.c | 4 ++--
 src/remote.c | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/config.c b/src/config.c
index b3168f735..16854c0c8 100644
--- a/src/config.c
+++ b/src/config.c
@@ -1144,7 +1144,7 @@ int git_config_parse_int64(int64_t *out, const char *value)
 	}
 
 fail_parse:
-	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as an integer", value);
+	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as an integer", value ? value : "(null)");
 	return -1;
 }
 
@@ -1164,7 +1164,7 @@ int git_config_parse_int32(int32_t *out, const char *value)
 	return 0;
 
 fail_parse:
-	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a 32-bit integer", value);
+	giterr_set(GITERR_CONFIG, "Failed to parse '%s' as a 32-bit integer", value ? value : "(null)");
 	return -1;
 }
 
diff --git a/src/remote.c b/src/remote.c
index ea638e373..be7198a98 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -73,7 +73,7 @@ static int ensure_remote_name_is_valid(const char *name)
 	if (!git_remote_is_valid_name(name)) {
 		giterr_set(
 			GITERR_CONFIG,
-			"'%s' is not a valid remote name.", name);
+			"'%s' is not a valid remote name.", name ? name : "(null)");
 		error = GIT_EINVALIDSPEC;
 	}
 
-- 
cgit v1.2.3


From 1017f81f0049f493508c1409418af725e8d6998f Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sun, 27 Apr 2014 13:44:06 +0200
Subject: Undef lseek first

---
 src/win32/mingw-compat.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/win32/mingw-compat.h b/src/win32/mingw-compat.h
index 8f51d6f5a..059e39cbc 100644
--- a/src/win32/mingw-compat.h
+++ b/src/win32/mingw-compat.h
@@ -10,6 +10,7 @@
 #if defined(__MINGW32__)
 
 /* use a 64-bit file offset type */
+# undef lseek
 # define lseek _lseeki64
 # undef stat
 # define stat _stati64
-- 
cgit v1.2.3


From 6e94a1efbca605957d6fc56ae068f30ef57c3c01 Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sun, 27 Apr 2014 14:25:49 +0200
Subject: _InterlockedExchange expects a volatile LONG

---
 src/global.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/global.c b/src/global.c
index 15baf1eb8..2ed5b4c6d 100644
--- a/src/global.c
+++ b/src/global.c
@@ -74,7 +74,7 @@ static void git__shutdown(void)
 #if defined(GIT_THREADS) && defined(GIT_WIN32)
 
 static DWORD _tls_index;
-static DWORD _mutex = 0;
+static volatile LONG _mutex = 0;
 
 static int synchronized_threads_init()
 {
-- 
cgit v1.2.3


From f5dd2a289106c74647d35560eee55a48ff0f123f Mon Sep 17 00:00:00 2001
From: Jacques Germishuys <jacquesg@striata.com>
Date: Sun, 27 Apr 2014 15:00:00 +0200
Subject: git_pool_mallocsz takes an unsigned long

---
 src/attrcache.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/attrcache.c b/src/attrcache.c
index f1bc70467..ec22eab25 100644
--- a/src/attrcache.c
+++ b/src/attrcache.c
@@ -53,7 +53,7 @@ int git_attr_cache__alloc_file_entry(
 			cachesize++;
 	}
 
-	ce = git_pool_mallocz(pool, cachesize);
+	ce = git_pool_mallocz(pool, (uint32_t)cachesize);
 	GITERR_CHECK_ALLOC(ce);
 
 	if (baselen) {
-- 
cgit v1.2.3


From d0420fc681d32ba825efeeb08436c787ff7798ad Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Thu, 1 May 2014 22:39:35 +0800
Subject: Make examples/status.c compile on Windows

---
 examples/status.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/examples/status.c b/examples/status.c
index 5f619a055..9c99744cb 100644
--- a/examples/status.c
+++ b/examples/status.c
@@ -13,7 +13,11 @@
  */
 
 #include "common.h"
+#ifdef _WIN32
+#define sleep(a) Sleep(a * 1000)
+#else
 #include <unistd.h>
+#endif
 
 /**
  * This example demonstrates the use of the libgit2 status APIs,
-- 
cgit v1.2.3


From d19b2f9f9f2480130bd901246aa3e3843810e5fd Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 1 May 2014 12:46:46 -0700
Subject: Make ** pattern eat trailing slash

This allows "foo/**/*.html" to match "foo/file.html"
---
 src/fnmatch.c       |  2 ++
 tests/attr/ignore.c | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/src/fnmatch.c b/src/fnmatch.c
index 3846bab3c..d8a83a8ed 100644
--- a/src/fnmatch.c
+++ b/src/fnmatch.c
@@ -62,6 +62,8 @@ p_fnmatchx(const char *pattern, const char *string, int flags, size_t recurs)
 							flags &= ~FNM_PATHNAME;
 							while (c == '*')
 								c = *++pattern;
+							if (c == '/')
+								c = *++pattern;
 						}
 
 						if (*string == '.' && (flags & FNM_PERIOD) &&
diff --git a/tests/attr/ignore.c b/tests/attr/ignore.c
index 68875194d..5eadc7b3e 100644
--- a/tests/attr/ignore.c
+++ b/tests/attr/ignore.c
@@ -81,6 +81,24 @@ void test_attr_ignore__full_paths(void)
 	assert_is_ignored(false, "Folder/Middle/More/More/Contained/Not/Happy/Child");
 }
 
+void test_attr_ignore__more_starstar_cases(void)
+{
+	cl_must_pass(p_unlink("attr/.gitignore"));
+	cl_git_mkfile(
+		"attr/dir/.gitignore",
+		"sub/**/*.html\n");
+
+	assert_is_ignored(false, "aaa.html");
+	assert_is_ignored(false, "dir");
+	assert_is_ignored(false, "dir/sub");
+	assert_is_ignored(true,  "dir/sub/sub2/aaa.html");
+	assert_is_ignored(true,  "dir/sub/aaa.html");
+	assert_is_ignored(false, "dir/aaa.html");
+	assert_is_ignored(false, "sub");
+	assert_is_ignored(false, "sub/aaa.html");
+	assert_is_ignored(false, "sub/sub2/aaa.html");
+}
+
 void test_attr_ignore__leading_stars(void)
 {
 	cl_git_rewritefile(
-- 
cgit v1.2.3


From 6a1ca96e4193f79c16c6a71dd8b5d576acf22e91 Mon Sep 17 00:00:00 2001
From: Vicent Marti <tanoku@gmail.com>
Date: Fri, 2 May 2014 17:14:04 +0200
Subject: Temporary fix for Travis CI builds

See https://github.com/libgit2/libgit2/pull/2321#issuecomment-42039673
We may rollback once we found something more reliable
---
 src/posix.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/posix.c b/src/posix.c
index 7b2962feb..7484ac0d8 100644
--- a/src/posix.c
+++ b/src/posix.c
@@ -99,7 +99,7 @@ const char *p_gai_strerror(int ret)
 
 #endif /* NO_ADDRINFO */
 
-int p_open(const char *path, int flags, ...)
+int p_open(const char *path, volatile int flags, ...)
 {
 	mode_t mode = 0;
 
-- 
cgit v1.2.3


From 240f4af321612a0fe4cf01aed75a8cb44173feb8 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 28 Apr 2014 14:04:29 -0700
Subject: Add build option for diff internal statistics

---
 CMakeLists.txt       |  5 ++++
 src/checkout.c       |  3 +-
 src/diff.c           | 79 ++++++++++++++++++++++++++++++----------------------
 src/diff.h           |  7 ++++-
 src/diff_tform.c     |  8 +++---
 src/iterator.c       | 10 +++++--
 src/iterator.h       |  4 +++
 src/status.c         |  8 +++---
 src/util.h           |  8 ++++++
 tests/diff/workdir.c | 12 ++++++++
 10 files changed, 96 insertions(+), 48 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 884c9bcf1..83e03d6cd 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,6 +37,7 @@ OPTION( ANDROID				"Build for android NDK"	 				OFF )
 OPTION( USE_ICONV			"Link with and use iconv library" 		OFF )
 OPTION( USE_SSH				"Link with libssh to enable SSH support" ON )
 OPTION( VALGRIND			"Configure build for valgrind"			OFF )
+OPTION( PERF_STATS			"Internally track performance data"		OFF )
 
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	SET( USE_ICONV ON )
@@ -352,6 +353,10 @@ IF (THREADSAFE)
 	ADD_DEFINITIONS(-DGIT_THREADS)
 ENDIF()
 
+IF (PERF_STATS)
+	ADD_DEFINITIONS(-DGIT_PERF)
+ENDIF()
+
 ADD_DEFINITIONS(-D_FILE_OFFSET_BITS=64)
 
 # Collect sourcefiles
diff --git a/src/checkout.c b/src/checkout.c
index bc976b854..93d6bc9c5 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -185,8 +185,7 @@ static bool checkout_is_workdir_modified(
 		return true;
 
 	if (git_diff__oid_for_file(
-			data->repo, wditem->path, wditem->mode,
-			wditem->file_size, &oid) < 0)
+			&oid, data->diff, wditem->path, wditem->mode, wditem->file_size) < 0)
 		return false;
 
 	return (git_oid__cmp(&baseitem->id, &oid) != 0);
diff --git a/src/diff.c b/src/diff.c
index 4b6fbe25a..aa880650a 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -510,26 +510,31 @@ void git_diff_addref(git_diff *diff)
 }
 
 int git_diff__oid_for_file(
-	git_repository *repo,
+	git_oid *out,
+	git_diff *diff,
 	const char *path,
 	uint16_t  mode,
-	git_off_t size,
-	git_oid *oid)
+	git_off_t size)
 {
-	int result = 0;
+	int error = 0;
 	git_buf full_path = GIT_BUF_INIT;
+	git_filter_list *fl = NULL;
+
+	memset(out, 0, sizeof(*out));
 
 	if (git_buf_joinpath(
-		&full_path, git_repository_workdir(repo), path) < 0)
+		&full_path, git_repository_workdir(diff->repo), path) < 0)
 		return -1;
 
 	if (!mode) {
 		struct stat st;
 
-		if (p_stat(path, &st) < 0) {
-			giterr_set(GITERR_OS, "Could not stat '%s'", path);
-			result = -1;
-			goto cleanup;
+		GIT_PERF_INC(diff->stat_calls);
+
+		if (p_stat(full_path.ptr, &st) < 0) {
+			error = git_path_set_error(errno, path, "stat");
+			git_buf_free(&full_path);
+			return error;
 		}
 
 		mode = st.st_mode;
@@ -540,46 +545,43 @@ int git_diff__oid_for_file(
 	if (S_ISGITLINK(mode)) {
 		git_submodule *sm;
 
-		memset(oid, 0, sizeof(*oid));
+		GIT_PERF_INC(diff->submodule_lookups);
 
-		if (!git_submodule_lookup(&sm, repo, path)) {
+		if (!git_submodule_lookup(&sm, diff->repo, path)) {
 			const git_oid *sm_oid = git_submodule_wd_id(sm);
 			if (sm_oid)
-				git_oid_cpy(oid, sm_oid);
+				git_oid_cpy(out, sm_oid);
 			git_submodule_free(sm);
 		} else {
 			/* if submodule lookup failed probably just in an intermediate
 			 * state where some init hasn't happened, so ignore the error
 			 */
 			giterr_clear();
-			memset(oid, 0, sizeof(*oid));
 		}
 	} else if (S_ISLNK(mode)) {
-		result = git_odb__hashlink(oid, full_path.ptr);
+		GIT_PERF_INC(diff->oid_calculations);
+		error = git_odb__hashlink(out, full_path.ptr);
 	} else if (!git__is_sizet(size)) {
 		giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'", path);
-		result = -1;
-	} else {
-		git_filter_list *fl = NULL;
-
-		result = git_filter_list_load(&fl, repo, NULL, path, GIT_FILTER_TO_ODB);
-		if (!result) {
-			int fd = git_futils_open_ro(full_path.ptr);
-			if (fd < 0)
-				result = fd;
-			else {
-				result = git_odb__hashfd_filtered(
-					oid, fd, (size_t)size, GIT_OBJ_BLOB, fl);
-				p_close(fd);
-			}
-
-			git_filter_list_free(fl);
+		error = -1;
+	} else if (!(error = git_filter_list_load(
+			&fl, diff->repo, NULL, path, GIT_FILTER_TO_ODB)))
+	{
+		int fd = git_futils_open_ro(full_path.ptr);
+		if (fd < 0)
+			error = fd;
+		else {
+			GIT_PERF_INC(diff->oid_calculations);
+			error = git_odb__hashfd_filtered(
+				out, fd, (size_t)size, GIT_OBJ_BLOB, fl);
+			p_close(fd);
 		}
+
+		git_filter_list_free(fl);
 	}
 
-cleanup:
 	git_buf_free(&full_path);
-	return result;
+	return error;
 }
 
 static bool diff_time_eq(
@@ -617,6 +619,8 @@ static int maybe_modified_submodule(
 		ign == GIT_SUBMODULE_IGNORE_ALL)
 		return 0;
 
+	GIT_PERF_INC(diff->submodule_lookups);
+
 	if ((error = git_submodule_lookup(
 			&sub, diff->repo, info->nitem->path)) < 0) {
 
@@ -748,8 +752,8 @@ static int maybe_modified(
 	 */
 	if (status == GIT_DELTA_MODIFIED && git_oid_iszero(&nitem->id)) {
 		if (git_oid_iszero(&noid)) {
-			if ((error = git_diff__oid_for_file(diff->repo,
-					nitem->path, nitem->mode, nitem->file_size, &noid)) < 0)
+			if ((error = git_diff__oid_for_file(&noid,
+					diff, nitem->path, nitem->mode, nitem->file_size)) < 0)
 				return error;
 		}
 
@@ -914,6 +918,8 @@ static int handle_unmatched_new_item(
 		delta_type = GIT_DELTA_ADDED;
 
 	else if (nitem->mode == GIT_FILEMODE_COMMIT) {
+		GIT_PERF_INC(diff->submodule_lookups);
+
 		/* ignore things that are not actual submodules */
 		if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {
 			giterr_clear();
@@ -1066,6 +1072,11 @@ int git_diff__from_iterators(
 			error = 0;
 	}
 
+	GIT_PERF_ADD(diff->stat_calls, old_iter->stat_calls);
+	GIT_PERF_ADD(diff->stat_calls, new_iter->stat_calls);
+	GIT_PERF_ADD(diff->submodule_lookups, old_iter->submodule_lookups);
+	GIT_PERF_ADD(diff->submodule_lookups, new_iter->submodule_lookups);
+
 cleanup:
 	if (!error)
 		*diff_ptr = diff;
diff --git a/src/diff.h b/src/diff.h
index aae8fbff1..491fc4667 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -62,6 +62,11 @@ struct git_diff {
 	git_iterator_type_t old_src;
 	git_iterator_type_t new_src;
 	uint32_t diffcaps;
+#ifdef GIT_PERF
+	size_t stat_calls;
+	size_t oid_calculations;
+	size_t submodule_lookups;
+#endif
 
 	int (*strcomp)(const char *, const char *);
 	int (*strncomp)(const char *, const char *, size_t);
@@ -90,7 +95,7 @@ extern int git_diff_delta__format_file_header(
 	int oid_strlen);
 
 extern int git_diff__oid_for_file(
-	git_repository *, const char *, uint16_t, git_off_t, git_oid *);
+	git_oid *oit, git_diff *, const char *, uint16_t, git_off_t);
 
 extern int git_diff__from_iterators(
 	git_diff **diff_ptr,
diff --git a/src/diff_tform.c b/src/diff_tform.c
index 97fbc2883..a2dab0ae2 100644
--- a/src/diff_tform.c
+++ b/src/diff_tform.c
@@ -574,14 +574,14 @@ static int similarity_measure(
 	if (exact_match) {
 		if (git_oid_iszero(&a_file->id) &&
 			diff->old_src == GIT_ITERATOR_TYPE_WORKDIR &&
-			!git_diff__oid_for_file(diff->repo, a_file->path,
-				a_file->mode, a_file->size, &a_file->id))
+			!git_diff__oid_for_file(&a_file->id,
+				diff, a_file->path, a_file->mode, a_file->size))
 			a_file->flags |= GIT_DIFF_FLAG_VALID_ID;
 
 		if (git_oid_iszero(&b_file->id) &&
 			diff->new_src == GIT_ITERATOR_TYPE_WORKDIR &&
-			!git_diff__oid_for_file(diff->repo, b_file->path,
-				b_file->mode, b_file->size, &b_file->id))
+			!git_diff__oid_for_file(&b_file->id,
+				diff, b_file->path, b_file->mode, b_file->size))
 			b_file->flags |= GIT_DIFF_FLAG_VALID_ID;
 	}
 
diff --git a/src/iterator.c b/src/iterator.c
index ef27fa71f..5e668b50c 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -1017,6 +1017,8 @@ static int fs_iterator__expand_dir(fs_iterator *fi)
 		return GIT_ENOTFOUND;
 	}
 
+	GIT_PERF_ADD(fi->base.stat_calls, ff->entries.length);
+
 	fs_iterator__seek_frame_start(fi, ff);
 
 	ff->next  = fi->stack;
@@ -1304,9 +1306,11 @@ static int workdir_iterator__enter_dir(fs_iterator *fi)
 
 	/* convert submodules to GITLINK and remove trailing slashes */
 	git_vector_foreach(&ff->entries, pos, entry) {
-		if (S_ISDIR(entry->st.st_mode) &&
-			git_submodule__is_submodule(fi->base.repo, entry->path))
-		{
+		if (!S_ISDIR(entry->st.st_mode))
+			continue;
+
+		GIT_PERF_INC(fi->base.submodule_lookups);
+		if (git_submodule__is_submodule(fi->base.repo, entry->path)) {
 			entry->st.st_mode = GIT_FILEMODE_COMMIT;
 			entry->path_len--;
 			entry->path[entry->path_len] = '\0';
diff --git a/src/iterator.h b/src/iterator.h
index ba9c1e486..2968b8c0c 100644
--- a/src/iterator.h
+++ b/src/iterator.h
@@ -53,6 +53,10 @@ struct git_iterator {
 	char *end;
 	int (*prefixcomp)(const char *str, const char *prefix);
 	unsigned int flags;
+#ifdef GIT_PERF
+	size_t stat_calls;
+	size_t submodule_lookups;
+#endif
 };
 
 extern int git_iterator_for_nothing(
diff --git a/src/status.c b/src/status.c
index c4b990a84..e1f8e06ae 100644
--- a/src/status.c
+++ b/src/status.c
@@ -81,15 +81,15 @@ static unsigned int workdir_delta2status(
 			if (git_oid_iszero(&idx2wd->old_file.id) &&
 				diff->old_src == GIT_ITERATOR_TYPE_WORKDIR &&
 				!git_diff__oid_for_file(
-					diff->repo, idx2wd->old_file.path, idx2wd->old_file.mode,
-					idx2wd->old_file.size, &idx2wd->old_file.id))
+					&idx2wd->old_file.id, diff, idx2wd->old_file.path,
+					idx2wd->old_file.mode, idx2wd->old_file.size))
 			idx2wd->old_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
 			if (git_oid_iszero(&idx2wd->new_file.id) &&
 				diff->new_src == GIT_ITERATOR_TYPE_WORKDIR &&
 				!git_diff__oid_for_file(
-					diff->repo, idx2wd->new_file.path, idx2wd->new_file.mode,
-					idx2wd->new_file.size, &idx2wd->new_file.id))
+					&idx2wd->new_file.id, diff, idx2wd->new_file.path,
+					idx2wd->new_file.mode, idx2wd->new_file.size))
 				idx2wd->new_file.flags |= GIT_DIFF_FLAG_VALID_ID;
 
 			if (!git_oid_equal(&idx2wd->old_file.id, &idx2wd->new_file.id))
diff --git a/src/util.h b/src/util.h
index 6fb2dc0f4..be7a16ef8 100644
--- a/src/util.h
+++ b/src/util.h
@@ -436,4 +436,12 @@ GIT_INLINE(double) git__timer(void)
 
 #endif
 
+#ifdef GIT_PERF
+#	define GIT_PERF_INC(counter) (counter)++
+#	define GIT_PERF_ADD(counter,val) (counter) += (val)
+#else
+#	define GIT_PERF_INC(counter) 0
+#	define GIT_PERF_ADD(counter,val) 0
+#endif
+
 #endif /* INCLUDE_util_h__ */
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 6128e820e..03a3ff418 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -2,6 +2,11 @@
 #include "diff_helpers.h"
 #include "repository.h"
 
+#ifdef GIT_PERF
+/* access to diff usage statistics */
+#	include "diff.h"
+#endif
+
 static git_repository *g_repo = NULL;
 
 void test_diff_workdir__initialize(void)
@@ -58,6 +63,13 @@ void test_diff_workdir__to_index(void)
 		cl_assert_equal_i(5, exp.line_ctxt);
 		cl_assert_equal_i(4, exp.line_adds);
 		cl_assert_equal_i(5, exp.line_dels);
+
+#ifdef GIT_PERF
+		cl_assert_equal_sz(
+			13 /* in root */ + 3 /* in subdir */, diff->stat_calls);
+		cl_assert_equal_sz(9, diff->oid_calculations);
+		cl_assert_equal_sz(2, diff->submodule_lookups);
+#endif
 	}
 
 	git_diff_free(diff);
-- 
cgit v1.2.3


From 8ef4e11a76599111b98682d235e7a4df921b2597 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 28 Apr 2014 14:16:26 -0700
Subject: Skip diff oid calc when size definitely changed

When we think the stat cache in the index seems valid and the size
or mode of a file has definitely changed, then don't bother trying
to recalculate the OID of the workdir bits to confirm that it is
modified - just accept that it is modified.

This can result in files that show as modified with no actual diff,
but the behavior actually appears to match Git on the command line.

This also includes a minor optimization to not perform a submodule
lookup on the ".git" directory itself.
---
 src/diff.c              | 15 +++++++++++----
 src/iterator.c          |  2 +-
 tests/diff/workdir.c    |  4 ++--
 tests/status/worktree.c |  6 +++++-
 4 files changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/diff.c b/src/diff.c
index aa880650a..4c028ca4e 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -664,6 +664,7 @@ static int maybe_modified(
 	unsigned int omode = oitem->mode;
 	unsigned int nmode = nitem->mode;
 	bool new_is_workdir = (info->new_iter->type == GIT_ITERATOR_TYPE_WORKDIR);
+	bool modified_uncertain = false;
 	const char *matched_pathspec;
 	int error = 0;
 
@@ -731,15 +732,21 @@ static int maybe_modified(
 		/* if the stat data looks different, then mark modified - this just
 		 * means that the OID will be recalculated below to confirm change
 		 */
-		else if (omode != nmode ||
-			oitem->file_size != nitem->file_size ||
-			!diff_time_eq(&oitem->mtime, &nitem->mtime, use_nanos) ||
+		else if (omode != nmode || oitem->file_size != nitem->file_size) {
+			status = GIT_DELTA_MODIFIED;
+			modified_uncertain =
+				(oitem->file_size <= 0 && nitem->file_size > 0);
+		}
+		else if (!diff_time_eq(&oitem->mtime, &nitem->mtime, use_nanos) ||
 			(use_ctime &&
 			 !diff_time_eq(&oitem->ctime, &nitem->ctime, use_nanos)) ||
 			oitem->ino != nitem->ino ||
 			oitem->uid != nitem->uid ||
 			oitem->gid != nitem->gid)
+		{
 			status = GIT_DELTA_MODIFIED;
+			modified_uncertain = true;
+		}
 	}
 
 	/* if mode is GITLINK and submodules are ignored, then skip */
@@ -750,7 +757,7 @@ static int maybe_modified(
 	/* if we got here and decided that the files are modified, but we
 	 * haven't calculated the OID of the new item, then calculate it now
 	 */
-	if (status == GIT_DELTA_MODIFIED && git_oid_iszero(&nitem->id)) {
+	if (modified_uncertain && git_oid_iszero(&nitem->id)) {
 		if (git_oid_iszero(&noid)) {
 			if ((error = git_diff__oid_for_file(&noid,
 					diff, nitem->path, nitem->mode, nitem->file_size)) < 0)
diff --git a/src/iterator.c b/src/iterator.c
index 5e668b50c..03058b956 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -1306,7 +1306,7 @@ static int workdir_iterator__enter_dir(fs_iterator *fi)
 
 	/* convert submodules to GITLINK and remove trailing slashes */
 	git_vector_foreach(&ff->entries, pos, entry) {
-		if (!S_ISDIR(entry->st.st_mode))
+		if (!S_ISDIR(entry->st.st_mode) || !strcmp(GIT_DIR, entry->path))
 			continue;
 
 		GIT_PERF_INC(fi->base.submodule_lookups);
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 03a3ff418..84c8866e0 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -67,8 +67,8 @@ void test_diff_workdir__to_index(void)
 #ifdef GIT_PERF
 		cl_assert_equal_sz(
 			13 /* in root */ + 3 /* in subdir */, diff->stat_calls);
-		cl_assert_equal_sz(9, diff->oid_calculations);
-		cl_assert_equal_sz(2, diff->submodule_lookups);
+		cl_assert_equal_sz(5, diff->oid_calculations);
+		cl_assert_equal_sz(1, diff->submodule_lookups);
 #endif
 	}
 
diff --git a/tests/status/worktree.c b/tests/status/worktree.c
index def3d60f0..f51c61864 100644
--- a/tests/status/worktree.c
+++ b/tests/status/worktree.c
@@ -578,7 +578,11 @@ void test_status_worktree__line_endings_dont_count_as_changes_with_autocrlf(void
 
 	cl_git_pass(git_status_file(&status, repo, "current_file"));
 
-	cl_assert_equal_i(GIT_STATUS_CURRENT, status);
+	/* stat data on file should no longer match stat cache, even though
+	 * file diff will be empty because of line-ending conversion - matches
+	 * the Git command-line behavior here.
+	 */
+	cl_assert_equal_i(GIT_STATUS_WT_MODIFIED, status);
 }
 
 void test_status_worktree__line_endings_dont_count_as_changes_with_autocrlf_issue_1397(void)
-- 
cgit v1.2.3


From 0fc8e1f6bd9a5148d3a262142e9a70126f5c3a42 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 28 Apr 2014 14:34:55 -0700
Subject: Lay groundwork for updating stat cache in diff

This reorganized the diff OID calculation to make it easier to
correctly update the stat cache during a diff once the flags to
do so are enabled.

This includes marking the path of a git_index_entry as const so
we can make a "fake" git_index_entry with a "const char *" path
and not get warnings.  I was a little surprised at how unobtrusive
this change was, but I think it's probably a good thing.
---
 include/git2/index.h |  2 +-
 src/checkout.c       |  3 +--
 src/diff.c           | 44 ++++++++++++++++++++++++++++++--------------
 src/diff.h           |  4 +++-
 src/index.c          |  6 ++----
 5 files changed, 37 insertions(+), 22 deletions(-)

diff --git a/include/git2/index.h b/include/git2/index.h
index 05e58a632..cdb87282c 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -61,7 +61,7 @@ typedef struct git_index_entry {
 	unsigned short flags;
 	unsigned short flags_extended;
 
-	char *path;
+	const char *path;
 } git_index_entry;
 
 /**
diff --git a/src/checkout.c b/src/checkout.c
index 93d6bc9c5..d94cb0c7d 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -184,8 +184,7 @@ static bool checkout_is_workdir_modified(
 	if (baseitem->size && wditem->file_size != baseitem->size)
 		return true;
 
-	if (git_diff__oid_for_file(
-			&oid, data->diff, wditem->path, wditem->mode, wditem->file_size) < 0)
+	if (git_diff__oid_for_entry(&oid, data->diff, wditem) < 0)
 		return false;
 
 	return (git_oid__cmp(&baseitem->id, &oid) != 0);
diff --git a/src/diff.c b/src/diff.c
index 4c028ca4e..eae4543fc 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -515,39 +515,53 @@ int git_diff__oid_for_file(
 	const char *path,
 	uint16_t  mode,
 	git_off_t size)
+{
+	git_index_entry entry;
+
+	memset(&entry, 0, sizeof(entry));
+	entry.mode = mode;
+	entry.file_size = size;
+	entry.path = (char *)path;
+
+	return git_diff__oid_for_entry(out, diff, &entry);
+}
+
+int git_diff__oid_for_entry(
+	git_oid *out, git_diff *diff, const git_index_entry *src)
 {
 	int error = 0;
 	git_buf full_path = GIT_BUF_INIT;
+	git_index_entry entry = *src;
 	git_filter_list *fl = NULL;
 
 	memset(out, 0, sizeof(*out));
 
 	if (git_buf_joinpath(
-		&full_path, git_repository_workdir(diff->repo), path) < 0)
+		&full_path, git_repository_workdir(diff->repo), entry.path) < 0)
 		return -1;
 
-	if (!mode) {
+	if (!entry.mode) {
 		struct stat st;
 
 		GIT_PERF_INC(diff->stat_calls);
 
 		if (p_stat(full_path.ptr, &st) < 0) {
-			error = git_path_set_error(errno, path, "stat");
+			error = git_path_set_error(errno, entry.path, "stat");
 			git_buf_free(&full_path);
 			return error;
 		}
 
-		mode = st.st_mode;
-		size = st.st_size;
+		git_index_entry__init_from_stat(
+			&entry, &st, (diff->diffcaps & GIT_DIFFCAPS_TRUST_MODE_BITS) != 0);
 	}
 
 	/* calculate OID for file if possible */
-	if (S_ISGITLINK(mode)) {
+	if (S_ISGITLINK(entry.mode)) {
 		git_submodule *sm;
 
 		GIT_PERF_INC(diff->submodule_lookups);
 
-		if (!git_submodule_lookup(&sm, diff->repo, path)) {
+		if (!git_submodule_lookup(&sm, diff->repo, entry.path)) {
 			const git_oid *sm_oid = git_submodule_wd_id(sm);
 			if (sm_oid)
 				git_oid_cpy(out, sm_oid);
@@ -558,14 +572,15 @@ int git_diff__oid_for_file(
 			 */
 			giterr_clear();
 		}
-	} else if (S_ISLNK(mode)) {
+	} else if (S_ISLNK(entry.mode)) {
 		GIT_PERF_INC(diff->oid_calculations);
 		error = git_odb__hashlink(out, full_path.ptr);
-	} else if (!git__is_sizet(size)) {
-		giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'", path);
+	} else if (!git__is_sizet(entry.file_size)) {
+		giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'",
+			entry.path);
 		error = -1;
 	} else if (!(error = git_filter_list_load(
-			&fl, diff->repo, NULL, path, GIT_FILTER_TO_ODB)))
+			&fl, diff->repo, NULL, entry.path, GIT_FILTER_TO_ODB)))
 	{
 		int fd = git_futils_open_ro(full_path.ptr);
 		if (fd < 0)
@@ -573,13 +588,15 @@ int git_diff__oid_for_file(
 		else {
 			GIT_PERF_INC(diff->oid_calculations);
 			error = git_odb__hashfd_filtered(
-				out, fd, (size_t)size, GIT_OBJ_BLOB, fl);
+				out, fd, (size_t)entry.file_size, GIT_OBJ_BLOB, fl);
 			p_close(fd);
 		}
 
 		git_filter_list_free(fl);
 	}
 
+	/* TODO: update index for entry if requested */
+
 	git_buf_free(&full_path);
 	return error;
 }
@@ -759,8 +776,7 @@ static int maybe_modified(
 	 */
 	if (modified_uncertain && git_oid_iszero(&nitem->id)) {
 		if (git_oid_iszero(&noid)) {
-			if ((error = git_diff__oid_for_file(&noid,
-					diff, nitem->path, nitem->mode, nitem->file_size)) < 0)
+			if ((error = git_diff__oid_for_entry(&noid, diff, nitem)) < 0)
 				return error;
 		}
 
diff --git a/src/diff.h b/src/diff.h
index 491fc4667..8fa3c9b7b 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -95,7 +95,9 @@ extern int git_diff_delta__format_file_header(
 	int oid_strlen);
 
 extern int git_diff__oid_for_file(
-	git_oid *oit, git_diff *, const char *, uint16_t, git_off_t);
+	git_oid *out, git_diff *, const char *, uint16_t, git_off_t);
+extern int git_diff__oid_for_entry(
+	git_oid *out, git_diff *, const git_index_entry *entry);
 
 extern int git_diff__from_iterators(
 	git_diff **diff_ptr,
diff --git a/src/index.c b/src/index.c
index c044af402..8a7f29279 100644
--- a/src/index.c
+++ b/src/index.c
@@ -842,7 +842,7 @@ static int index_entry_reuc_init(git_index_reuc_entry **reuc_out,
 
 static void index_entry_cpy(git_index_entry *tgt, const git_index_entry *src)
 {
-	char *tgt_path = tgt->path;
+	const char *tgt_path = tgt->path;
 	memcpy(tgt, src, sizeof(*tgt));
 	tgt->path = tgt_path; /* reset to existing path data */
 }
@@ -2282,9 +2282,7 @@ static int read_tree_cb(
 		entry->mode == old_entry->mode &&
 		git_oid_equal(&entry->id, &old_entry->id))
 	{
-		char *oldpath = entry->path;
-		memcpy(entry, old_entry, sizeof(*entry));
-		entry->path = oldpath;
+		index_entry_cpy(entry, old_entry);
 		entry->flags_extended = 0;
 	}
 
-- 
cgit v1.2.3


From 94fb4aadc80c927a59696dc01db03f3a0629dae7 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 28 Apr 2014 14:48:41 -0700
Subject: Add diff option to update index stat cache

When diff is scanning the working directory, if it finds a file
where it is not sure if the index entry matches the working dir,
it will recalculate the OID (which is pretty expensive).  This
adds a new flag to diff so that if the OID calculation finds that
the file actually has not changed (i.e. just the modified time was
altered or such), then it will refresh the stat cache in the index
so that future calls to diff will not have to check the oid again.
---
 include/git2/diff.h  |  7 +++++
 src/checkout.c       |  2 +-
 src/diff.c           | 36 +++++++++++++++++++---
 src/diff.h           |  2 +-
 tests/diff/workdir.c | 87 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 128 insertions(+), 6 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 273f471b6..afdb2c981 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -145,6 +145,13 @@ typedef enum {
 	 */
 	GIT_DIFF_ENABLE_FAST_UNTRACKED_DIRS = (1u << 14),
 
+	/** When diff finds a file in the working directory with stat
+	 * information different from the index, but the OID ends up being the
+	 * same, write the correct stat information into the index.  Note:
+	 * without this flag, diff will always leave the index untouched.
+	 */
+	GIT_DIFF_UPDATE_INDEX = (1u << 15),
+
 	/*
 	 * Options controlling how output will be generated
 	 */
diff --git a/src/checkout.c b/src/checkout.c
index d94cb0c7d..727911694 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -184,7 +184,7 @@ static bool checkout_is_workdir_modified(
 	if (baseitem->size && wditem->file_size != baseitem->size)
 		return true;
 
-	if (git_diff__oid_for_entry(&oid, data->diff, wditem) < 0)
+	if (git_diff__oid_for_entry(&oid, data->diff, wditem, NULL) < 0)
 		return false;
 
 	return (git_oid__cmp(&baseitem->id, &oid) != 0);
diff --git a/src/diff.c b/src/diff.c
index eae4543fc..caed8bf40 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -442,6 +442,14 @@ static int diff_list_apply_options(
 		diff->new_src = tmp_src;
 	}
 
+	/* Unset UPDATE_INDEX unless diffing workdir and index */
+	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_UPDATE_INDEX) &&
+		(!(diff->old_src == GIT_ITERATOR_TYPE_WORKDIR ||
+		   diff->new_src == GIT_ITERATOR_TYPE_WORKDIR) ||
+		 !(diff->old_src == GIT_ITERATOR_TYPE_INDEX ||
+		   diff->new_src == GIT_ITERATOR_TYPE_INDEX)))
+		diff->opts.flags &= ~GIT_DIFF_UPDATE_INDEX;
+
 	/* if ignore_submodules not explicitly set, check diff config */
 	if (diff->opts.ignore_submodules <= 0) {
 		const git_config_entry *entry;
@@ -523,11 +531,14 @@ int git_diff__oid_for_file(
 	entry.file_size = size;
 	entry.path = (char *)path;
 
-	return git_diff__oid_for_entry(out, diff, &entry);
+	return git_diff__oid_for_entry(out, diff, &entry, NULL);
 }
 
 int git_diff__oid_for_entry(
-	git_oid *out, git_diff *diff, const git_index_entry *src)
+	git_oid *out,
+	git_diff *diff,
+	const git_index_entry *src,
+	const git_oid *update_match)
 {
 	int error = 0;
 	git_buf full_path = GIT_BUF_INIT;
@@ -595,7 +606,16 @@ int git_diff__oid_for_entry(
 		git_filter_list_free(fl);
 	}
 
-	/* TODO: update index for entry if requested */
+	/* update index for entry if requested */
+	if (!error && update_match && git_oid_equal(out, update_match)) {
+		git_index *idx;
+
+		if (!(error = git_repository_index(&idx, diff->repo))) {
+			memcpy(&entry.id, out, sizeof(entry.id));
+			error = git_index_add(idx, &entry);
+			git_index_free(idx);
+		}
+ 	}
 
 	git_buf_free(&full_path);
 	return error;
@@ -776,7 +796,12 @@ static int maybe_modified(
 	 */
 	if (modified_uncertain && git_oid_iszero(&nitem->id)) {
 		if (git_oid_iszero(&noid)) {
-			if ((error = git_diff__oid_for_entry(&noid, diff, nitem)) < 0)
+			const git_oid *update_check =
+				DIFF_FLAG_IS_SET(diff, GIT_DIFF_UPDATE_INDEX) ?
+				&oitem->id : NULL;
+
+			if ((error = git_diff__oid_for_entry(
+					&noid, diff, nitem, update_check)) < 0)
 				return error;
 		}
 
@@ -1208,6 +1233,9 @@ int git_diff_index_to_workdir(
 			&b, repo, GIT_ITERATOR_DONT_AUTOEXPAND, pfx, pfx)
 	);
 
+	if (!error && DIFF_FLAG_IS_SET(*diff, GIT_DIFF_UPDATE_INDEX))
+		error = git_index_write(index);
+
 	return error;
 }
 
diff --git a/src/diff.h b/src/diff.h
index 8fa3c9b7b..b2b7dba70 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -97,7 +97,7 @@ extern int git_diff_delta__format_file_header(
 extern int git_diff__oid_for_file(
 	git_oid *out, git_diff *, const char *, uint16_t, git_off_t);
 extern int git_diff__oid_for_entry(
-	git_oid *out, git_diff *, const git_index_entry *entry);
+	git_oid *out, git_diff *, const git_index_entry *, const git_oid *update);
 
 extern int git_diff__from_iterators(
 	git_diff **diff_ptr,
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 84c8866e0..9e4608e9d 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -1502,3 +1502,90 @@ void test_diff_workdir__with_stale_index(void)
 
 	git_index_free(idx);
 }
+
+static int touch_file(void *payload, git_buf *path)
+{
+	int fd;
+	char b;
+
+	GIT_UNUSED(payload);
+	if (git_path_isdir(path->ptr))
+		return 0;
+
+	cl_assert((fd = p_open(path->ptr, O_RDWR)) >= 0);
+	cl_assert_equal_i(1, p_read(fd, &b, 1));
+	cl_must_pass(p_lseek(fd, 0, SEEK_SET));
+	cl_must_pass(p_write(fd, &b, 1));
+	cl_must_pass(p_close(fd));
+
+	return 0;
+}
+
+static void basic_diff_status(git_diff **out, const git_diff_options *opts)
+{
+	diff_expects exp;
+
+	cl_git_pass(git_diff_index_to_workdir(out, g_repo, NULL, opts));
+
+	memset(&exp, 0, sizeof(exp));
+
+	cl_git_pass(git_diff_foreach(
+		*out, diff_file_cb, diff_hunk_cb, diff_line_cb, &exp));
+
+	cl_assert_equal_i(13, exp.files);
+	cl_assert_equal_i(0, exp.file_status[GIT_DELTA_ADDED]);
+	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_DELETED]);
+	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_MODIFIED]);
+	cl_assert_equal_i(1, exp.file_status[GIT_DELTA_IGNORED]);
+	cl_assert_equal_i(4, exp.file_status[GIT_DELTA_UNTRACKED]);
+}
+
+void test_diff_workdir__can_update_index(void)
+{
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	git_diff *diff = NULL;
+
+	g_repo = cl_git_sandbox_init("status");
+
+	/* touch all the files so stat times are different */
+	{
+		git_buf path = GIT_BUF_INIT;
+		cl_git_pass(git_buf_sets(&path, "status"));
+		cl_git_pass(git_path_direach(&path, 0, touch_file, NULL));
+		git_buf_free(&path);
+	}
+
+	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
+
+	basic_diff_status(&diff, &opts);
+#ifdef GIT_PERF
+	cl_assert_equal_sz(diff->stat_calls, 13 + 3);
+	cl_assert_equal_sz(diff->oid_calculations, 5);
+	cl_assert_equal_sz(diff->submodule_lookups, 1);
+#endif
+
+	git_diff_free(diff);
+
+	/* now allow diff to update stat cache */
+	opts.flags |= GIT_DIFF_UPDATE_INDEX;
+
+	basic_diff_status(&diff, &opts);
+#ifdef GIT_PERF
+	cl_assert_equal_sz(diff->stat_calls, 13 + 3);
+	cl_assert_equal_sz(diff->oid_calculations, 5);
+	cl_assert_equal_sz(diff->submodule_lookups, 1);
+#endif
+
+	git_diff_free(diff);
+
+	/* now if we do it again, we should see fewer OID calculations */
+
+	basic_diff_status(&diff, &opts);
+#ifdef GIT_PERF
+	cl_assert_equal_sz(diff->stat_calls, 13 + 3);
+	cl_assert_equal_sz(diff->oid_calculations, 0); /* Yay */
+	cl_assert_equal_sz(diff->submodule_lookups, 1);
+#endif
+
+	git_diff_free(diff);
+}
-- 
cgit v1.2.3


From cd424ad5518c7cfbba10a764d7bc097377ec3995 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 28 Apr 2014 16:39:53 -0700
Subject: Add GIT_STATUS_OPT_UPDATE_INDEX and use trace API

This adds an option to refresh the stat cache while generating
status.  It also rips out the GIT_PERF stuff I had an makes use
of the trace API to keep statistics about what happens during diff.
---
 CMakeLists.txt          |  5 ---
 include/git2/status.h   |  6 ++++
 src/diff.c              | 20 ++++-------
 src/diff.h              |  5 ---
 src/iterator.c          |  5 +--
 src/iterator.h          |  4 ---
 src/status.c            | 29 ++++++++++++++--
 src/util.h              |  8 -----
 tests/diff/workdir.c    | 66 +++++++++++++++++++++++------------
 tests/status/worktree.c | 91 +++++++++++++++++++++++++++++++++++++++++++++----
 10 files changed, 171 insertions(+), 68 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 83e03d6cd..884c9bcf1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -37,7 +37,6 @@ OPTION( ANDROID				"Build for android NDK"	 				OFF )
 OPTION( USE_ICONV			"Link with and use iconv library" 		OFF )
 OPTION( USE_SSH				"Link with libssh to enable SSH support" ON )
 OPTION( VALGRIND			"Configure build for valgrind"			OFF )
-OPTION( PERF_STATS			"Internally track performance data"		OFF )
 
 IF(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 	SET( USE_ICONV ON )
@@ -353,10 +352,6 @@ IF (THREADSAFE)
 	ADD_DEFINITIONS(-DGIT_THREADS)
 ENDIF()
 
-IF (PERF_STATS)
-	ADD_DEFINITIONS(-DGIT_PERF)
-ENDIF()
-
 ADD_DEFINITIONS(-D_FILE_OFFSET_BITS=64)
 
 # Collect sourcefiles
diff --git a/include/git2/status.h b/include/git2/status.h
index 6af45c7dd..ee2f33287 100644
--- a/include/git2/status.h
+++ b/include/git2/status.h
@@ -121,6 +121,11 @@ typedef enum {
  * - GIT_STATUS_OPT_NO_REFRESH bypasses the default status behavior of
  *   doing a "soft" index reload (i.e. reloading the index data if the
  *   file on disk has been modified outside libgit2).
+ * - GIT_STATUS_OPT_UPDATE_INDEX tells libgit2 to refresh the stat cache
+ *   in the index for files that are unchanged but have out of date stat
+ *   information in the index.  It will result in less work being done on
+ *   subsequent calls to get status.  This is mutually exclusive with the
+ *   NO_REFRESH option.
  *
  * Calling `git_status_foreach()` is like calling the extended version
  * with: GIT_STATUS_OPT_INCLUDE_IGNORED, GIT_STATUS_OPT_INCLUDE_UNTRACKED,
@@ -141,6 +146,7 @@ typedef enum {
 	GIT_STATUS_OPT_SORT_CASE_INSENSITIVELY  = (1u << 10),
 	GIT_STATUS_OPT_RENAMES_FROM_REWRITES    = (1u << 11),
 	GIT_STATUS_OPT_NO_REFRESH               = (1u << 12),
+	GIT_STATUS_OPT_UPDATE_INDEX             = (1u << 13),
 } git_status_opt_t;
 
 #define GIT_STATUS_OPT_DEFAULTS \
diff --git a/src/diff.c b/src/diff.c
index caed8bf40..8b7433c62 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -14,6 +14,7 @@
 #include "index.h"
 #include "odb.h"
 #include "submodule.h"
+#include "trace.h"
 
 #define DIFF_FLAG_IS_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) != 0)
 #define DIFF_FLAG_ISNT_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) == 0)
@@ -554,8 +555,7 @@ int git_diff__oid_for_entry(
 	if (!entry.mode) {
 		struct stat st;
 
-		GIT_PERF_INC(diff->stat_calls);
-
+		git_trace(GIT_TRACE_TRACE, "stat=1");
 		if (p_stat(full_path.ptr, &st) < 0) {
 			error = git_path_set_error(errno, entry.path, "stat");
 			git_buf_free(&full_path);
@@ -570,8 +570,7 @@ int git_diff__oid_for_entry(
 	if (S_ISGITLINK(entry.mode)) {
 		git_submodule *sm;
 
-		GIT_PERF_INC(diff->submodule_lookups);
-
+		git_trace(GIT_TRACE_TRACE, "submodule_lookup=1");
 		if (!git_submodule_lookup(&sm, diff->repo, entry.path)) {
 			const git_oid *sm_oid = git_submodule_wd_id(sm);
 			if (sm_oid)
@@ -584,7 +583,7 @@ int git_diff__oid_for_entry(
 			giterr_clear();
 		}
 	} else if (S_ISLNK(entry.mode)) {
-		GIT_PERF_INC(diff->oid_calculations);
+		git_trace(GIT_TRACE_TRACE, "oid_calculation=1");
 		error = git_odb__hashlink(out, full_path.ptr);
 	} else if (!git__is_sizet(entry.file_size)) {
 		giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'",
@@ -597,7 +596,7 @@ int git_diff__oid_for_entry(
 		if (fd < 0)
 			error = fd;
 		else {
-			GIT_PERF_INC(diff->oid_calculations);
+			git_trace(GIT_TRACE_TRACE, "oid_calculation=1");
 			error = git_odb__hashfd_filtered(
 				out, fd, (size_t)entry.file_size, GIT_OBJ_BLOB, fl);
 			p_close(fd);
@@ -656,7 +655,7 @@ static int maybe_modified_submodule(
 		ign == GIT_SUBMODULE_IGNORE_ALL)
 		return 0;
 
-	GIT_PERF_INC(diff->submodule_lookups);
+	git_trace(GIT_TRACE_TRACE, "submodule_lookup=1");
 
 	if ((error = git_submodule_lookup(
 			&sub, diff->repo, info->nitem->path)) < 0) {
@@ -966,7 +965,7 @@ static int handle_unmatched_new_item(
 		delta_type = GIT_DELTA_ADDED;
 
 	else if (nitem->mode == GIT_FILEMODE_COMMIT) {
-		GIT_PERF_INC(diff->submodule_lookups);
+		git_trace(GIT_TRACE_TRACE, "submodule_lookup=1");
 
 		/* ignore things that are not actual submodules */
 		if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {
@@ -1120,11 +1119,6 @@ int git_diff__from_iterators(
 			error = 0;
 	}
 
-	GIT_PERF_ADD(diff->stat_calls, old_iter->stat_calls);
-	GIT_PERF_ADD(diff->stat_calls, new_iter->stat_calls);
-	GIT_PERF_ADD(diff->submodule_lookups, old_iter->submodule_lookups);
-	GIT_PERF_ADD(diff->submodule_lookups, new_iter->submodule_lookups);
-
 cleanup:
 	if (!error)
 		*diff_ptr = diff;
diff --git a/src/diff.h b/src/diff.h
index b2b7dba70..2e7ce0b7d 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -62,11 +62,6 @@ struct git_diff {
 	git_iterator_type_t old_src;
 	git_iterator_type_t new_src;
 	uint32_t diffcaps;
-#ifdef GIT_PERF
-	size_t stat_calls;
-	size_t oid_calculations;
-	size_t submodule_lookups;
-#endif
 
 	int (*strcomp)(const char *, const char *);
 	int (*strncomp)(const char *, const char *, size_t);
diff --git a/src/iterator.c b/src/iterator.c
index 03058b956..bebdeba84 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -11,6 +11,7 @@
 #include "ignore.h"
 #include "buffer.h"
 #include "submodule.h"
+#include "trace.h"
 #include <ctype.h>
 
 #define ITERATOR_SET_CB(P,NAME_LC) do { \
@@ -1017,7 +1018,7 @@ static int fs_iterator__expand_dir(fs_iterator *fi)
 		return GIT_ENOTFOUND;
 	}
 
-	GIT_PERF_ADD(fi->base.stat_calls, ff->entries.length);
+	git_trace(GIT_TRACE_TRACE, "stat=%ld", (long)ff->entries.length);
 
 	fs_iterator__seek_frame_start(fi, ff);
 
@@ -1309,7 +1310,7 @@ static int workdir_iterator__enter_dir(fs_iterator *fi)
 		if (!S_ISDIR(entry->st.st_mode) || !strcmp(GIT_DIR, entry->path))
 			continue;
 
-		GIT_PERF_INC(fi->base.submodule_lookups);
+		git_trace(GIT_TRACE_TRACE, "submodule_lookup=1");
 		if (git_submodule__is_submodule(fi->base.repo, entry->path)) {
 			entry->st.st_mode = GIT_FILEMODE_COMMIT;
 			entry->path_len--;
diff --git a/src/iterator.h b/src/iterator.h
index 2968b8c0c..ba9c1e486 100644
--- a/src/iterator.h
+++ b/src/iterator.h
@@ -53,10 +53,6 @@ struct git_iterator {
 	char *end;
 	int (*prefixcomp)(const char *str, const char *prefix);
 	unsigned int flags;
-#ifdef GIT_PERF
-	size_t stat_calls;
-	size_t submodule_lookups;
-#endif
 };
 
 extern int git_iterator_for_nothing(
diff --git a/src/status.c b/src/status.c
index e1f8e06ae..e418cf7b6 100644
--- a/src/status.c
+++ b/src/status.c
@@ -225,6 +225,28 @@ static git_status_list *git_status_list_alloc(git_index *index)
 	return status;
 }
 
+static int status_validate_options(const git_status_options *opts)
+{
+	if (!opts)
+		return 0;
+
+	GITERR_CHECK_VERSION(opts, GIT_STATUS_OPTIONS_VERSION, "git_status_options");
+
+	if (opts->show > GIT_STATUS_SHOW_WORKDIR_ONLY) {
+		giterr_set(GITERR_INVALID, "Unknown status 'show' option");
+		return -1;
+	}
+
+	if ((opts->flags & GIT_STATUS_OPT_NO_REFRESH) != 0 &&
+		(opts->flags & GIT_STATUS_OPT_UPDATE_INDEX) != 0) {
+		giterr_set(GITERR_INVALID, "Updating index from status "
+			"is not allowed when index refresh is disabled");
+		return -1;
+	}
+
+	return 0;
+}
+
 int git_status_list_new(
 	git_status_list **out,
 	git_repository *repo,
@@ -240,11 +262,10 @@ int git_status_list_new(
 	int error = 0;
 	unsigned int flags = opts ? opts->flags : GIT_STATUS_OPT_DEFAULTS;
 
-	assert(show <= GIT_STATUS_SHOW_WORKDIR_ONLY);
-
 	*out = NULL;
 
-	GITERR_CHECK_VERSION(opts, GIT_STATUS_OPTIONS_VERSION, "git_status_options");
+	if (status_validate_options(opts) < 0)
+		return -1;
 
 	if ((error = git_repository__ensure_not_bare(repo, "status")) < 0 ||
 		(error = git_repository_index(&index, repo)) < 0)
@@ -287,6 +308,8 @@ int git_status_list_new(
 		diffopt.flags = diffopt.flags | GIT_DIFF_RECURSE_IGNORED_DIRS;
 	if ((flags & GIT_STATUS_OPT_EXCLUDE_SUBMODULES) != 0)
 		diffopt.flags = diffopt.flags | GIT_DIFF_IGNORE_SUBMODULES;
+	if ((flags & GIT_STATUS_OPT_UPDATE_INDEX) != 0)
+		diffopt.flags = diffopt.flags | GIT_DIFF_UPDATE_INDEX;
 
 	if ((flags & GIT_STATUS_OPT_RENAMES_FROM_REWRITES) != 0)
 		findopt.flags = findopt.flags |
diff --git a/src/util.h b/src/util.h
index be7a16ef8..6fb2dc0f4 100644
--- a/src/util.h
+++ b/src/util.h
@@ -436,12 +436,4 @@ GIT_INLINE(double) git__timer(void)
 
 #endif
 
-#ifdef GIT_PERF
-#	define GIT_PERF_INC(counter) (counter)++
-#	define GIT_PERF_ADD(counter,val) (counter) += (val)
-#else
-#	define GIT_PERF_INC(counter) 0
-#	define GIT_PERF_ADD(counter,val) 0
-#endif
-
 #endif /* INCLUDE_util_h__ */
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 9e4608e9d..a225ebc89 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -1,21 +1,43 @@
 #include "clar_libgit2.h"
 #include "diff_helpers.h"
 #include "repository.h"
-
-#ifdef GIT_PERF
-/* access to diff usage statistics */
-#	include "diff.h"
-#endif
+#include <git2/trace.h>
 
 static git_repository *g_repo = NULL;
 
+static struct {
+	size_t stat_calls;
+	size_t oid_calcs;
+	size_t submodule_lookups;
+} g_diff_perf;
+
+static void add_stats(git_trace_level_t level, const char *msg)
+{
+	const char *assign = strchr(msg, '=');
+
+	GIT_UNUSED(level);
+
+	if (!assign)
+		return;
+
+	if (!strncmp("stat", msg, (assign - msg)))
+		g_diff_perf.stat_calls += atoi(assign + 1);
+	else if (!strncmp("submodule_lookup", msg, (assign - msg)))
+		g_diff_perf.submodule_lookups += atoi(assign + 1);
+	else if (!strncmp("oid_calculation", msg, (assign - msg)))
+		g_diff_perf.oid_calcs += atoi(assign + 1);
+}
+
 void test_diff_workdir__initialize(void)
 {
+	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
+	cl_git_pass(git_trace_set(GIT_TRACE_TRACE, add_stats));
 }
 
 void test_diff_workdir__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
+	cl_git_pass(git_trace_set(0, NULL));
 }
 
 void test_diff_workdir__to_index(void)
@@ -64,11 +86,11 @@ void test_diff_workdir__to_index(void)
 		cl_assert_equal_i(4, exp.line_adds);
 		cl_assert_equal_i(5, exp.line_dels);
 
-#ifdef GIT_PERF
+#ifdef GIT_TRACE
 		cl_assert_equal_sz(
-			13 /* in root */ + 3 /* in subdir */, diff->stat_calls);
-		cl_assert_equal_sz(5, diff->oid_calculations);
-		cl_assert_equal_sz(1, diff->submodule_lookups);
+			13 /* in root */ + 3 /* in subdir */, g_diff_perf.stat_calls);
+		cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
+		cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
 #endif
 	}
 
@@ -1525,6 +1547,8 @@ static void basic_diff_status(git_diff **out, const git_diff_options *opts)
 {
 	diff_expects exp;
 
+	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
+
 	cl_git_pass(git_diff_index_to_workdir(out, g_repo, NULL, opts));
 
 	memset(&exp, 0, sizeof(exp));
@@ -1558,10 +1582,10 @@ void test_diff_workdir__can_update_index(void)
 	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_PERF
-	cl_assert_equal_sz(diff->stat_calls, 13 + 3);
-	cl_assert_equal_sz(diff->oid_calculations, 5);
-	cl_assert_equal_sz(diff->submodule_lookups, 1);
+#ifdef GIT_TRACE
+	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
+	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
+	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
 #endif
 
 	git_diff_free(diff);
@@ -1570,10 +1594,10 @@ void test_diff_workdir__can_update_index(void)
 	opts.flags |= GIT_DIFF_UPDATE_INDEX;
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_PERF
-	cl_assert_equal_sz(diff->stat_calls, 13 + 3);
-	cl_assert_equal_sz(diff->oid_calculations, 5);
-	cl_assert_equal_sz(diff->submodule_lookups, 1);
+#ifdef GIT_TRACE
+	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
+	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
+	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
 #endif
 
 	git_diff_free(diff);
@@ -1581,10 +1605,10 @@ void test_diff_workdir__can_update_index(void)
 	/* now if we do it again, we should see fewer OID calculations */
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_PERF
-	cl_assert_equal_sz(diff->stat_calls, 13 + 3);
-	cl_assert_equal_sz(diff->oid_calculations, 0); /* Yay */
-	cl_assert_equal_sz(diff->submodule_lookups, 1);
+#ifdef GIT_TRACE
+	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
+	cl_assert_equal_sz(0, g_diff_perf.oid_calcs); /* Yay */
+	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
 #endif
 
 	git_diff_free(diff);
diff --git a/tests/status/worktree.c b/tests/status/worktree.c
index f51c61864..0b94fb1a0 100644
--- a/tests/status/worktree.c
+++ b/tests/status/worktree.c
@@ -5,6 +5,36 @@
 #include "posix.h"
 #include "util.h"
 #include "path.h"
+#include <git2/trace.h>
+
+static struct {
+	size_t stat_calls;
+	size_t oid_calcs;
+	size_t submodule_lookups;
+} g_diff_perf;
+
+static void add_stats(git_trace_level_t level, const char *msg)
+{
+	const char *assign = strchr(msg, '=');
+
+	GIT_UNUSED(level);
+
+	if (!assign)
+		return;
+
+	if (!strncmp("stat", msg, (assign - msg)))
+		g_diff_perf.stat_calls += atoi(assign + 1);
+	else if (!strncmp("submodule_lookup", msg, (assign - msg)))
+		g_diff_perf.submodule_lookups += atoi(assign + 1);
+	else if (!strncmp("oid_calculation", msg, (assign - msg)))
+		g_diff_perf.oid_calcs += atoi(assign + 1);
+}
+
+void test_status_worktree__initialize(void)
+{
+	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
+	cl_git_pass(git_trace_set(GIT_TRACE_TRACE, add_stats));
+}
 
 /**
  * Cleanup
@@ -15,6 +45,7 @@
 void test_status_worktree__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
+	cl_git_pass(git_trace_set(0, NULL));
 }
 
 /**
@@ -40,11 +71,15 @@ void test_status_worktree__whole_repository(void)
 	cl_assert_equal_i(0, counts.wrong_sorted_path);
 }
 
-void assert_show(const int entry_counts, const char *entry_paths[],
-				 const unsigned int entry_statuses[], git_status_show_t show)
+void assert_show(
+	const int entry_counts,
+	const char *entry_paths[],
+	const unsigned int entry_statuses[],
+	git_repository *repo,
+	git_status_show_t show,
+	unsigned int extra_flags)
 {
 	status_entry_counts counts;
-	git_repository *repo = cl_git_sandbox_init("status");
 	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
 
 	memset(&counts, 0x0, sizeof(status_entry_counts));
@@ -52,7 +87,7 @@ void assert_show(const int entry_counts, const char *entry_paths[],
 	counts.expected_paths = entry_paths;
 	counts.expected_statuses = entry_statuses;
 
-	opts.flags = GIT_STATUS_OPT_DEFAULTS;
+	opts.flags = GIT_STATUS_OPT_DEFAULTS | extra_flags;
 	opts.show = show;
 
 	cl_git_pass(
@@ -67,19 +102,19 @@ void assert_show(const int entry_counts, const char *entry_paths[],
 void test_status_worktree__show_index_and_workdir(void)
 {
 	assert_show(entry_count0, entry_paths0, entry_statuses0,
-		GIT_STATUS_SHOW_INDEX_AND_WORKDIR);
+		cl_git_sandbox_init("status"), GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
 }
 
 void test_status_worktree__show_index_only(void)
 {
 	assert_show(entry_count5, entry_paths5, entry_statuses5,
-		GIT_STATUS_SHOW_INDEX_ONLY);
+		cl_git_sandbox_init("status"), GIT_STATUS_SHOW_INDEX_ONLY, 0);
 }
 
 void test_status_worktree__show_workdir_only(void)
 {
 	assert_show(entry_count6, entry_paths6, entry_statuses6,
-		GIT_STATUS_SHOW_WORKDIR_ONLY);
+		cl_git_sandbox_init("status"), GIT_STATUS_SHOW_WORKDIR_ONLY, 0);
 }
 
 /* this test is equivalent to t18-status.c:statuscb1 */
@@ -877,3 +912,45 @@ void test_status_worktree__long_filenames(void)
 	cl_assert_equal_i(0, counts.wrong_sorted_path);
 }
 
+/* The update stat cache tests mostly just mirror other tests and try
+ * to make sure that updating the stat cache doesn't change the results
+ * while reducing the amount of work that needs to be done
+ */
+
+void test_status_worktree__update_stat_cache_0(void)
+{
+	git_repository *repo = cl_git_sandbox_init("status");
+
+	assert_show(entry_count0, entry_paths0, entry_statuses0,
+		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
+
+#ifdef GIT_TRACE
+	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
+	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
+	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+
+	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
+#endif
+
+	assert_show(entry_count0, entry_paths0, entry_statuses0,
+		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, GIT_STATUS_OPT_UPDATE_INDEX);
+
+#ifdef GIT_TRACE
+	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
+	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
+	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+
+	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
+#endif
+
+	assert_show(entry_count0, entry_paths0, entry_statuses0,
+		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
+
+#ifdef GIT_TRACE
+	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
+	cl_assert_equal_sz(0, g_diff_perf.oid_calcs);
+	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+
+	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
+#endif
+}
-- 
cgit v1.2.3


From 225aab5d6a611076b22f00ae5a28184d92b5259c Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 28 Apr 2014 16:47:39 -0700
Subject: Don't use trace if GIT_TRACE not defined

---
 tests/diff/workdir.c    | 8 ++++++++
 tests/status/worktree.c | 6 ++++++
 2 files changed, 14 insertions(+)

diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index a225ebc89..0fd41d3e0 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -5,6 +5,7 @@
 
 static git_repository *g_repo = NULL;
 
+#ifdef GIT_TRACE
 static struct {
 	size_t stat_calls;
 	size_t oid_calcs;
@@ -27,17 +28,22 @@ static void add_stats(git_trace_level_t level, const char *msg)
 	else if (!strncmp("oid_calculation", msg, (assign - msg)))
 		g_diff_perf.oid_calcs += atoi(assign + 1);
 }
+#endif
 
 void test_diff_workdir__initialize(void)
 {
+#ifdef GIT_TRACE
 	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
 	cl_git_pass(git_trace_set(GIT_TRACE_TRACE, add_stats));
+#endif
 }
 
 void test_diff_workdir__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
+#ifdef GIT_TRACE
 	cl_git_pass(git_trace_set(0, NULL));
+#endif
 }
 
 void test_diff_workdir__to_index(void)
@@ -1547,7 +1553,9 @@ static void basic_diff_status(git_diff **out, const git_diff_options *opts)
 {
 	diff_expects exp;
 
+#ifdef GIT_TRACE
 	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
+#endif
 
 	cl_git_pass(git_diff_index_to_workdir(out, g_repo, NULL, opts));
 
diff --git a/tests/status/worktree.c b/tests/status/worktree.c
index 0b94fb1a0..c1d6be982 100644
--- a/tests/status/worktree.c
+++ b/tests/status/worktree.c
@@ -7,6 +7,7 @@
 #include "path.h"
 #include <git2/trace.h>
 
+#ifdef GIT_TRACE
 static struct {
 	size_t stat_calls;
 	size_t oid_calcs;
@@ -29,11 +30,14 @@ static void add_stats(git_trace_level_t level, const char *msg)
 	else if (!strncmp("oid_calculation", msg, (assign - msg)))
 		g_diff_perf.oid_calcs += atoi(assign + 1);
 }
+#endif
 
 void test_status_worktree__initialize(void)
 {
+#ifdef GIT_TRACE
 	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
 	cl_git_pass(git_trace_set(GIT_TRACE_TRACE, add_stats));
+#endif
 }
 
 /**
@@ -45,7 +49,9 @@ void test_status_worktree__initialize(void)
 void test_status_worktree__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
+#ifdef GIT_TRACE
 	cl_git_pass(git_trace_set(0, NULL));
+#endif
 }
 
 /**
-- 
cgit v1.2.3


From b23b112dfe8eceb39eaaea2d5e60d971c4371aa0 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 29 Apr 2014 11:29:49 -0700
Subject: Add payloads, bitmaps to trace API

This is a proposed adjustment to the trace APIs.  This makes the
trace levels into a bitmask so that they can be selectively enabled
and adds a callback-level payload, plus a message-level payload.

This makes it easier for me to a GIT_TRACE_PERF callbacks that
are simply bypassed if the PERF level is not set.
---
 include/git2/trace.h      | 43 ++++++++++++++++++++++++++++++-------------
 src/diff.c                | 12 ++++++------
 src/iterator.c            |  4 ++--
 src/trace.c               | 15 +++++++++------
 src/trace.h               | 19 +++++++++++--------
 tests/diff/diff_helpers.c | 19 +++++++++++++++++++
 tests/diff/diff_helpers.h | 14 ++++++++++++++
 tests/diff/workdir.c      | 29 ++++-------------------------
 tests/status/worktree.c   | 32 +++++---------------------------
 tests/trace/trace.c       | 39 ++++++++++++++++++++++-----------------
 10 files changed, 122 insertions(+), 104 deletions(-)

diff --git a/include/git2/trace.h b/include/git2/trace.h
index f9b4d6ff6..867b34612 100644
--- a/include/git2/trace.h
+++ b/include/git2/trace.h
@@ -20,47 +20,64 @@
 GIT_BEGIN_DECL
 
 /**
- * Available tracing levels.  When tracing is set to a particular level,
- * callers will be provided tracing at the given level and all lower levels.
+ * Available tracing messages.  Each tracing level can be enabled
+ * independently or pass GIT_TRACE_ALL to enable all levels.
  */
 typedef enum {
 	/** No tracing will be performed. */
-	GIT_TRACE_NONE = 0,
+	GIT_TRACE_NONE = 0x0000u,
+
+	/** All tracing messages will be sent. */
+	GIT_TRACE_ALL = 0xFFFFu,
 
 	/** Severe errors that may impact the program's execution */
-	GIT_TRACE_FATAL = 1,
+	GIT_TRACE_FATAL = 0x0001u,
 
 	/** Errors that do not impact the program's execution */
-	GIT_TRACE_ERROR = 2,
+	GIT_TRACE_ERROR = 0x0002u,
+	GIT_TRACE_ERROR_AND_BELOW = 0x0003u,
 
 	/** Warnings that suggest abnormal data */
-	GIT_TRACE_WARN = 3,
+	GIT_TRACE_WARN = 0x0004u,
+	GIT_TRACE_WARN_AND_BELOW = 0x0007u,
 
 	/** Informational messages about program execution */
-	GIT_TRACE_INFO = 4,
+	GIT_TRACE_INFO = 0x0008u,
+	GIT_TRACE_INFO_AND_BELOW = 0x000Fu,
 
 	/** Detailed data that allows for debugging */
-	GIT_TRACE_DEBUG = 5,
+	GIT_TRACE_DEBUG = 0x0010u,
 
 	/** Exceptionally detailed debugging data */
-	GIT_TRACE_TRACE = 6
+	GIT_TRACE_TRACE = 0x0020u,
+
+	/** Performance tracking related traces */
+	GIT_TRACE_PERF = 0x0040u,
 } git_trace_level_t;
 
 /**
  * An instance for a tracing function
  */
-typedef void (*git_trace_callback)(git_trace_level_t level, const char *msg);
+typedef void (*git_trace_callback)(
+	git_trace_level_t level, /* just one bit will be sent */
+	void *cb_payload,
+	void *msg_payload,
+	const char *msg);
 
 /**
  * Sets the system tracing configuration to the specified level with the
  * specified callback.  When system events occur at a level equal to, or
  * lower than, the given level they will be reported to the given callback.
  *
- * @param level Level to set tracing to
- * @param cb Function to call with trace data
+ * @param level Bitmask of all enabled trace levels
+ * @param cb Function to call with trace messages
+ * @param cb_payload Payload to pass when callback is invoked
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_trace_set(git_trace_level_t level, git_trace_callback cb);
+GIT_EXTERN(int) git_trace_set(
+	git_trace_level_t level,
+	git_trace_callback cb,
+	void *cb_payload);
 
 /** @} */
 GIT_END_DECL
diff --git a/src/diff.c b/src/diff.c
index 8b7433c62..5a6b127a1 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -555,7 +555,7 @@ int git_diff__oid_for_entry(
 	if (!entry.mode) {
 		struct stat st;
 
-		git_trace(GIT_TRACE_TRACE, "stat=1");
+		git_trace(GIT_TRACE_PERF, NULL, "stat");
 		if (p_stat(full_path.ptr, &st) < 0) {
 			error = git_path_set_error(errno, entry.path, "stat");
 			git_buf_free(&full_path);
@@ -570,7 +570,7 @@ int git_diff__oid_for_entry(
 	if (S_ISGITLINK(entry.mode)) {
 		git_submodule *sm;
 
-		git_trace(GIT_TRACE_TRACE, "submodule_lookup=1");
+		git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
 		if (!git_submodule_lookup(&sm, diff->repo, entry.path)) {
 			const git_oid *sm_oid = git_submodule_wd_id(sm);
 			if (sm_oid)
@@ -583,7 +583,7 @@ int git_diff__oid_for_entry(
 			giterr_clear();
 		}
 	} else if (S_ISLNK(entry.mode)) {
-		git_trace(GIT_TRACE_TRACE, "oid_calculation=1");
+		git_trace(GIT_TRACE_PERF, NULL, "oid_calculation");
 		error = git_odb__hashlink(out, full_path.ptr);
 	} else if (!git__is_sizet(entry.file_size)) {
 		giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'",
@@ -596,7 +596,7 @@ int git_diff__oid_for_entry(
 		if (fd < 0)
 			error = fd;
 		else {
-			git_trace(GIT_TRACE_TRACE, "oid_calculation=1");
+			git_trace(GIT_TRACE_PERF, NULL, "oid_calculation");
 			error = git_odb__hashfd_filtered(
 				out, fd, (size_t)entry.file_size, GIT_OBJ_BLOB, fl);
 			p_close(fd);
@@ -655,7 +655,7 @@ static int maybe_modified_submodule(
 		ign == GIT_SUBMODULE_IGNORE_ALL)
 		return 0;
 
-	git_trace(GIT_TRACE_TRACE, "submodule_lookup=1");
+	git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
 
 	if ((error = git_submodule_lookup(
 			&sub, diff->repo, info->nitem->path)) < 0) {
@@ -965,7 +965,7 @@ static int handle_unmatched_new_item(
 		delta_type = GIT_DELTA_ADDED;
 
 	else if (nitem->mode == GIT_FILEMODE_COMMIT) {
-		git_trace(GIT_TRACE_TRACE, "submodule_lookup=1");
+		git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
 
 		/* ignore things that are not actual submodules */
 		if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {
diff --git a/src/iterator.c b/src/iterator.c
index bebdeba84..0d7e5918d 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -1018,7 +1018,7 @@ static int fs_iterator__expand_dir(fs_iterator *fi)
 		return GIT_ENOTFOUND;
 	}
 
-	git_trace(GIT_TRACE_TRACE, "stat=%ld", (long)ff->entries.length);
+	git_trace(GIT_TRACE_PERF, &ff->entries.length, "stat");
 
 	fs_iterator__seek_frame_start(fi, ff);
 
@@ -1310,7 +1310,7 @@ static int workdir_iterator__enter_dir(fs_iterator *fi)
 		if (!S_ISDIR(entry->st.st_mode) || !strcmp(GIT_DIR, entry->path))
 			continue;
 
-		git_trace(GIT_TRACE_TRACE, "submodule_lookup=1");
+		git_trace(GIT_TRACE_PERF, entry->path, "submodule_lookup");
 		if (git_submodule__is_submodule(fi->base.repo, entry->path)) {
 			entry->st.st_mode = GIT_FILEMODE_COMMIT;
 			entry->path_len--;
diff --git a/src/trace.c b/src/trace.c
index ee5039f56..6ee2cf2ce 100644
--- a/src/trace.c
+++ b/src/trace.c
@@ -17,22 +17,25 @@ struct git_trace_data git_trace__data = {0};
 
 #endif
 
-int git_trace_set(git_trace_level_t level, git_trace_callback callback)
+int git_trace_set(
+	git_trace_level_t level, git_trace_callback cb, void *cb_payload)
 {
 #ifdef GIT_TRACE
-	assert(level == 0 || callback != NULL);
+	assert(level == 0 || cb != NULL);
 
 	git_trace__data.level = level;
-	git_trace__data.callback = callback;
+	git_trace__data.callback = cb;
+	git_trace__data.callback_payload = cb_payload;
 	GIT_MEMORY_BARRIER;
 
 	return 0;
 #else
 	GIT_UNUSED(level);
-	GIT_UNUSED(callback);
+	GIT_UNUSED(cb);
+	GIT_UNUSED(cb_payload);
 
-	giterr_set(GITERR_INVALID,
-		"This version of libgit2 was not built with tracing.");
+	giterr_set(
+		GITERR_INVALID, "This version of libgit2 was not built with tracing.");
 	return -1;
 #endif
 }
diff --git a/src/trace.h b/src/trace.h
index 4d4e3bf53..b35e3808f 100644
--- a/src/trace.h
+++ b/src/trace.h
@@ -15,13 +15,16 @@
 struct git_trace_data {
 	git_trace_level_t level;
 	git_trace_callback callback;
+	void *callback_payload;
 };
 
 extern struct git_trace_data git_trace__data;
 
 GIT_INLINE(void) git_trace__write_fmt(
 	git_trace_level_t level,
-	const char *fmt, ...)
+	void *message_payload,
+	const char *fmt,
+	...)
 {
 	git_trace_callback callback = git_trace__data.callback;
 	git_buf message = GIT_BUF_INIT;
@@ -31,18 +34,18 @@ GIT_INLINE(void) git_trace__write_fmt(
 	git_buf_vprintf(&message, fmt, ap);
 	va_end(ap);
 
-	callback(level, git_buf_cstr(&message));
+	callback(
+		level, git_trace__data.callback_payload, message_payload,
+		git_buf_cstr(&message));
 
 	git_buf_free(&message);
 }
 
 #define git_trace_level()		(git_trace__data.level)
-#define git_trace(l, ...)		{ \
-									if (git_trace__data.level >= l && \
-										git_trace__data.callback != NULL) { \
-										git_trace__write_fmt(l, __VA_ARGS__); \
-									} \
-								}
+#define git_trace(l, p, ...)	do { \
+	if ((git_trace__data.level & (l)) != 0 && git_trace__data.callback) { \
+		git_trace__write_fmt((l), (p), __VA_ARGS__); \
+	} } while (0)
 
 #else
 
diff --git a/tests/diff/diff_helpers.c b/tests/diff/diff_helpers.c
index 279cb20c5..5de9834ba 100644
--- a/tests/diff/diff_helpers.c
+++ b/tests/diff/diff_helpers.c
@@ -229,3 +229,22 @@ void diff_print_raw(FILE *fp, git_diff *diff)
 		git_diff_print(diff, GIT_DIFF_FORMAT_RAW,
 			git_diff_print_callback__to_file_handle, fp ? fp : stderr));
 }
+
+void diff_perf_track_stats(
+	git_trace_level_t level,
+	void *cb_payload,
+	void *msg_payload,
+	const char *msg)
+{
+	diff_perf *data = cb_payload;
+
+	if (!(level & GIT_TRACE_PERF))
+		return;
+
+	if (!strcmp("stat", msg))
+		data->stat_calls += msg_payload ? *((size_t *)msg_payload) : 1;
+	else if (!strcmp("submodule_lookup", msg))
+		data->submodule_lookups++;
+	else if (!strcmp("oid_calculation", msg))
+		data->oid_calcs++;
+}
diff --git a/tests/diff/diff_helpers.h b/tests/diff/diff_helpers.h
index bf21f4b1f..3ed538702 100644
--- a/tests/diff/diff_helpers.h
+++ b/tests/diff/diff_helpers.h
@@ -62,3 +62,17 @@ extern int diff_foreach_via_iterator(
 
 extern void diff_print(FILE *fp, git_diff *diff);
 extern void diff_print_raw(FILE *fp, git_diff *diff);
+
+#include "git2/trace.h"
+
+typedef struct {
+	size_t stat_calls;
+	size_t oid_calcs;
+	size_t submodule_lookups;
+} diff_perf;
+
+extern void diff_perf_track_stats(
+	git_trace_level_t level,
+	void *cb_payload,
+	void *msg_payload,
+	const char *msg);
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 0fd41d3e0..952c9022b 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -1,40 +1,19 @@
 #include "clar_libgit2.h"
 #include "diff_helpers.h"
 #include "repository.h"
-#include <git2/trace.h>
 
 static git_repository *g_repo = NULL;
 
 #ifdef GIT_TRACE
-static struct {
-	size_t stat_calls;
-	size_t oid_calcs;
-	size_t submodule_lookups;
-} g_diff_perf;
-
-static void add_stats(git_trace_level_t level, const char *msg)
-{
-	const char *assign = strchr(msg, '=');
-
-	GIT_UNUSED(level);
-
-	if (!assign)
-		return;
-
-	if (!strncmp("stat", msg, (assign - msg)))
-		g_diff_perf.stat_calls += atoi(assign + 1);
-	else if (!strncmp("submodule_lookup", msg, (assign - msg)))
-		g_diff_perf.submodule_lookups += atoi(assign + 1);
-	else if (!strncmp("oid_calculation", msg, (assign - msg)))
-		g_diff_perf.oid_calcs += atoi(assign + 1);
-}
+static diff_perf g_diff_perf;
 #endif
 
 void test_diff_workdir__initialize(void)
 {
 #ifdef GIT_TRACE
 	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-	cl_git_pass(git_trace_set(GIT_TRACE_TRACE, add_stats));
+	cl_git_pass(git_trace_set(
+		GIT_TRACE_PERF, diff_perf_track_stats, &g_diff_perf));
 #endif
 }
 
@@ -42,7 +21,7 @@ void test_diff_workdir__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
 #ifdef GIT_TRACE
-	cl_git_pass(git_trace_set(0, NULL));
+	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
 #endif
 }
 
diff --git a/tests/status/worktree.c b/tests/status/worktree.c
index c1d6be982..06864ad59 100644
--- a/tests/status/worktree.c
+++ b/tests/status/worktree.c
@@ -5,38 +5,18 @@
 #include "posix.h"
 #include "util.h"
 #include "path.h"
-#include <git2/trace.h>
+#include "../diff/diff_helpers.h"
 
 #ifdef GIT_TRACE
-static struct {
-	size_t stat_calls;
-	size_t oid_calcs;
-	size_t submodule_lookups;
-} g_diff_perf;
-
-static void add_stats(git_trace_level_t level, const char *msg)
-{
-	const char *assign = strchr(msg, '=');
-
-	GIT_UNUSED(level);
-
-	if (!assign)
-		return;
-
-	if (!strncmp("stat", msg, (assign - msg)))
-		g_diff_perf.stat_calls += atoi(assign + 1);
-	else if (!strncmp("submodule_lookup", msg, (assign - msg)))
-		g_diff_perf.submodule_lookups += atoi(assign + 1);
-	else if (!strncmp("oid_calculation", msg, (assign - msg)))
-		g_diff_perf.oid_calcs += atoi(assign + 1);
-}
+static diff_perf g_diff_perf;
 #endif
 
 void test_status_worktree__initialize(void)
 {
 #ifdef GIT_TRACE
 	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-	cl_git_pass(git_trace_set(GIT_TRACE_TRACE, add_stats));
+	cl_git_pass(git_trace_set(
+		GIT_TRACE_PERF, diff_perf_track_stats, &g_diff_perf));
 #endif
 }
 
@@ -50,7 +30,7 @@ void test_status_worktree__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
 #ifdef GIT_TRACE
-	cl_git_pass(git_trace_set(0, NULL));
+	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
 #endif
 }
 
@@ -956,7 +936,5 @@ void test_status_worktree__update_stat_cache_0(void)
 	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
 	cl_assert_equal_sz(0, g_diff_perf.oid_calcs);
 	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
 #endif
 }
diff --git a/tests/trace/trace.c b/tests/trace/trace.c
index 87b325378..328539379 100644
--- a/tests/trace/trace.c
+++ b/tests/trace/trace.c
@@ -3,44 +3,49 @@
 
 static int written = 0;
 
-static void trace_callback(git_trace_level_t level, const char *message)
+static void trace_callback(
+	git_trace_level_t level,
+	void *cb_payload,
+	void *msg_payload,
+	const char *msg)
 {
-	GIT_UNUSED(level);
+	GIT_UNUSED(level); GIT_UNUSED(msg_payload);
 
-	cl_assert(strcmp(message, "Hello world!") == 0);
+	cl_assert(strcmp(msg, "Hello world!") == 0);
 
-	written = 1;
+	if (cb_payload)
+		*((int *)cb_payload) = 1;
 }
 
 void test_trace_trace__initialize(void)
 {
-	git_trace_set(GIT_TRACE_INFO, trace_callback);
+	git_trace_set(GIT_TRACE_INFO_AND_BELOW, trace_callback, &written);
 	written = 0;
 }
 
 void test_trace_trace__cleanup(void)
 {
-	git_trace_set(GIT_TRACE_NONE, NULL);
+	git_trace_set(GIT_TRACE_NONE, NULL, NULL);
 }
 
 void test_trace_trace__sets(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO);
+	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
 #endif
 }
 
 void test_trace_trace__can_reset(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO);
-	cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback));
+	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
+	cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback, &written));
 
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
+	git_trace(GIT_TRACE_INFO, NULL, "Hello %s!", "world");
 	cl_assert(written == 0);
 
-	git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
+	git_trace(GIT_TRACE_ERROR, NULL, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }
@@ -48,13 +53,13 @@ void test_trace_trace__can_reset(void)
 void test_trace_trace__can_unset(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO);
-	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL));
+	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
+	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
 
 	cl_assert(git_trace_level() == GIT_TRACE_NONE);
 
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_FATAL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_FATAL, NULL, "Hello %s!", "world");
 	cl_assert(written == 0);
 #endif
 }
@@ -63,7 +68,7 @@ void test_trace_trace__skips_higher_level(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_DEBUG, "Hello %s!", "world");
+	git_trace(GIT_TRACE_DEBUG, NULL, "Hello %s!", "world");
 	cl_assert(written == 0);
 #endif
 }
@@ -72,7 +77,7 @@ void test_trace_trace__writes(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
+	git_trace(GIT_TRACE_INFO, NULL, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }
@@ -81,7 +86,7 @@ void test_trace_trace__writes_lower_level(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
+	git_trace(GIT_TRACE_ERROR, NULL, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }
-- 
cgit v1.2.3


From 7a2e56a3f6115c3a145e4f73d0aa8bea6dded899 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 29 Apr 2014 14:30:15 -0700
Subject: Get rid of redundant git_diff_options_init fn

Since git_diff_init_options was introduced, remove this old fn.
---
 include/git2/diff.h | 17 -----------------
 src/diff.c          | 14 --------------
 tests/diff/blob.c   |  2 +-
 tests/diff/tree.c   |  2 +-
 4 files changed, 2 insertions(+), 33 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index afdb2c981..18880889c 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -811,23 +811,6 @@ GIT_EXTERN(int) git_diff_find_similar(
 	git_diff *diff,
 	const git_diff_find_options *options);
 
-/**
- * Initialize diff options structure
- *
- * In most cases, you can probably just use `GIT_DIFF_OPTIONS_INIT` to
- * initialize the diff options structure, but in some cases that is not
- * going to work.  You can call this function instead.  Note that you
- * must pass both a pointer to the structure to be initialized and the
- * `GIT_DIFF_OPTIONS_VERSION` value from the header you compiled with.
- *
- * @param options Pointer to git_diff_options memory to be initialized
- * @param version Should be `GIT_DIFF_OPTIONS_VERSION`
- * @return 0 on success, negative on failure (such as unsupported version)
- */
-GIT_EXTERN(int) git_diff_options_init(
-	git_diff_options *options,
-	unsigned int version);
-
 /**@}*/
 
 
diff --git a/src/diff.c b/src/diff.c
index 5a6b127a1..b34d15312 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -1282,20 +1282,6 @@ int git_diff_tree_to_workdir_with_index(
 	return error;
 }
 
-int git_diff_options_init(git_diff_options *options, unsigned int version)
-{
-	git_diff_options template = GIT_DIFF_OPTIONS_INIT;
-
-	if (version != template.version) {
-		giterr_set(GITERR_INVALID,
-			"Invalid version %d for git_diff_options", (int)version);
-		return -1;
-	}
-
-	memcpy(options, &template, sizeof(*options));
-	return 0;
-}
-
 size_t git_diff_num_deltas(const git_diff *diff)
 {
 	assert(diff);
diff --git a/tests/diff/blob.c b/tests/diff/blob.c
index d1fff9c5b..527007965 100644
--- a/tests/diff/blob.c
+++ b/tests/diff/blob.c
@@ -26,7 +26,7 @@ void test_diff_blob__initialize(void)
 
 	g_repo = cl_git_sandbox_init("attr");
 
-	cl_git_pass(git_diff_options_init(&opts, GIT_DIFF_OPTIONS_VERSION));
+	cl_git_pass(git_diff_init_options(&opts, GIT_DIFF_OPTIONS_VERSION));
 	opts.context_lines = 1;
 
 	memset(&expected, 0, sizeof(expected));
diff --git a/tests/diff/tree.c b/tests/diff/tree.c
index 582174b8b..6ab49fdb0 100644
--- a/tests/diff/tree.c
+++ b/tests/diff/tree.c
@@ -9,7 +9,7 @@ static diff_expects expect;
 
 void test_diff_tree__initialize(void)
 {
-	cl_git_pass(git_diff_options_init(&opts, GIT_DIFF_OPTIONS_VERSION));
+	cl_git_pass(git_diff_init_options(&opts, GIT_DIFF_OPTIONS_VERSION));
 
 	memset(&expect, 0, sizeof(expect));
 
-- 
cgit v1.2.3


From 9c8ed4999740e921ecc2966bbcd0dbcfc725f59a Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 29 Apr 2014 15:05:58 -0700
Subject: Remove trace / add git_diff_perfdata struct + api

---
 include/git2/diff.h       | 30 +++++++++----------
 include/git2/status.h     |  9 +++---
 include/git2/sys/diff.h   | 28 +++++++++++++++++
 include/git2/trace.h      | 43 ++++++++-------------------
 src/diff.c                | 76 +++++++++++++++++++++++++----------------------
 src/diff.h                |  2 ++
 src/iterator.c            |  5 +---
 src/iterator.h            |  1 +
 src/status.c              | 36 ++++++++++++++++++----
 src/trace.c               | 15 ++++------
 src/trace.h               | 19 +++++-------
 tests/diff/diff_helpers.c | 19 ------------
 tests/diff/diff_helpers.h | 14 ---------
 tests/diff/workdir.c      | 60 +++++++++++++------------------------
 tests/status/worktree.c   | 75 ++++++++++++++++++++++------------------------
 tests/trace/trace.c       | 39 +++++++++++-------------
 16 files changed, 220 insertions(+), 251 deletions(-)

diff --git a/include/git2/diff.h b/include/git2/diff.h
index 18880889c..b849e3bb5 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -391,14 +391,13 @@ typedef struct {
 * Initializes a `git_diff_options` with default values. Equivalent to
 * creating an instance with GIT_DIFF_OPTIONS_INIT.
 *
-* @param opts the `git_diff_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_OPTIONS_VERSION` here.
+* @param opts The `git_diff_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_OPTIONS_VERSION`
 * @return Zero on success; -1 on failure.
 */
 GIT_EXTERN(int) git_diff_init_options(
-	git_diff_options* opts,
-	int version);
+	git_diff_options *opts,
+	unsigned int version);
 
 /**
  * When iterating over a diff, callback that will be made per file.
@@ -632,14 +631,13 @@ typedef struct {
 * Initializes a `git_diff_find_options` with default values. Equivalent to
 * creating an instance with GIT_DIFF_FIND_OPTIONS_INIT.
 *
-* @param opts the `git_diff_find_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_FIND_OPTIONS_VERSION` here.
+* @param opts The `git_diff_find_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_FIND_OPTIONS_VERSION`
 * @return Zero on success; -1 on failure.
 */
 GIT_EXTERN(int) git_diff_find_init_options(
-	git_diff_find_options* opts,
-	int version);
+	git_diff_find_options *opts,
+	unsigned int version);
 
 /** @name Diff Generator Functions
  *
@@ -1223,17 +1221,17 @@ GIT_EXTERN(int) git_diff_commit_as_email(
 	const git_diff_options *diff_opts);
 
 /**
-* Initializes a `git_diff_format_email_options` with default values. Equivalent to
-* creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
+* Initializes a `git_diff_format_email_options` with default values.
 *
-* @param opts the `git_diff_format_email_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION` here.
+* Equivalent to creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
+*
+* @param opts Uhe `git_diff_format_email_options` instance to initialize.
+* @param version Version of struct; pass `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION`
 * @return Zero on success; -1 on failure.
 */
 GIT_EXTERN(int) git_diff_format_email_init_options(
 	git_diff_format_email_options *opts,
-	int version);
+	unsigned int version);
 
 GIT_END_DECL
 
diff --git a/include/git2/status.h b/include/git2/status.h
index ee2f33287..effe5e1ea 100644
--- a/include/git2/status.h
+++ b/include/git2/status.h
@@ -184,14 +184,13 @@ typedef struct {
  * Initializes a `git_status_options` with default values. Equivalent to
  * creating an instance with GIT_STATUS_OPTIONS_INIT.
  *
- * @param opts the `git_status_options` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_STATUS_OPTIONS_VERSION` here.
+ * @param opts The `git_status_options` instance to initialize.
+ * @param version Version of struct; pass `GIT_STATUS_OPTIONS_VERSION`
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_status_init_options(
-	git_status_options* opts,
-	int version);
+	git_status_options *opts,
+	unsigned int version);
 
 /**
  * A status entry, providing the differences between the file as it exists
diff --git a/include/git2/sys/diff.h b/include/git2/sys/diff.h
index bc6cdf393..48d72f4f9 100644
--- a/include/git2/sys/diff.h
+++ b/include/git2/sys/diff.h
@@ -10,6 +10,8 @@
 #include "git2/common.h"
 #include "git2/types.h"
 #include "git2/oid.h"
+#include "git2/diff.h"
+#include "git2/status.h"
 
 /**
  * @file git2/sys/diff.h
@@ -58,6 +60,32 @@ GIT_EXTERN(int) git_diff_print_callback__to_file_handle(
 	const git_diff_line *line,
 	void *payload); /*< payload must be a `FILE *` */
 
+
+typedef struct {
+	unsigned int version;
+	size_t stat_calls;
+	size_t oid_calculations;
+} git_diff_perfdata;
+
+#define GIT_DIFF_PERFDATA_VERSION 1
+#define GIT_DIFF_PERFDATA_INIT {GIT_DIFF_PERFDATA_VERSION,0,0}
+
+/**
+ * Get performance data for a diff object.
+ *
+ * @param out Structure to be filled with diff performance data
+ * @param diff Diff to read performance data from
+ * @return 0 for success, <0 for error
+ */
+GIT_EXTERN(int) git_diff_get_perfdata(
+	git_diff_perfdata *out, const git_diff *diff);
+
+/**
+ * Get performance data for diffs from a git_status_list
+ */
+GIT_EXTERN(int) git_status_list_get_perfdata(
+	git_diff_perfdata *out, const git_status_list *status);
+
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/include/git2/trace.h b/include/git2/trace.h
index 867b34612..f9b4d6ff6 100644
--- a/include/git2/trace.h
+++ b/include/git2/trace.h
@@ -20,64 +20,47 @@
 GIT_BEGIN_DECL
 
 /**
- * Available tracing messages.  Each tracing level can be enabled
- * independently or pass GIT_TRACE_ALL to enable all levels.
+ * Available tracing levels.  When tracing is set to a particular level,
+ * callers will be provided tracing at the given level and all lower levels.
  */
 typedef enum {
 	/** No tracing will be performed. */
-	GIT_TRACE_NONE = 0x0000u,
-
-	/** All tracing messages will be sent. */
-	GIT_TRACE_ALL = 0xFFFFu,
+	GIT_TRACE_NONE = 0,
 
 	/** Severe errors that may impact the program's execution */
-	GIT_TRACE_FATAL = 0x0001u,
+	GIT_TRACE_FATAL = 1,
 
 	/** Errors that do not impact the program's execution */
-	GIT_TRACE_ERROR = 0x0002u,
-	GIT_TRACE_ERROR_AND_BELOW = 0x0003u,
+	GIT_TRACE_ERROR = 2,
 
 	/** Warnings that suggest abnormal data */
-	GIT_TRACE_WARN = 0x0004u,
-	GIT_TRACE_WARN_AND_BELOW = 0x0007u,
+	GIT_TRACE_WARN = 3,
 
 	/** Informational messages about program execution */
-	GIT_TRACE_INFO = 0x0008u,
-	GIT_TRACE_INFO_AND_BELOW = 0x000Fu,
+	GIT_TRACE_INFO = 4,
 
 	/** Detailed data that allows for debugging */
-	GIT_TRACE_DEBUG = 0x0010u,
+	GIT_TRACE_DEBUG = 5,
 
 	/** Exceptionally detailed debugging data */
-	GIT_TRACE_TRACE = 0x0020u,
-
-	/** Performance tracking related traces */
-	GIT_TRACE_PERF = 0x0040u,
+	GIT_TRACE_TRACE = 6
 } git_trace_level_t;
 
 /**
  * An instance for a tracing function
  */
-typedef void (*git_trace_callback)(
-	git_trace_level_t level, /* just one bit will be sent */
-	void *cb_payload,
-	void *msg_payload,
-	const char *msg);
+typedef void (*git_trace_callback)(git_trace_level_t level, const char *msg);
 
 /**
  * Sets the system tracing configuration to the specified level with the
  * specified callback.  When system events occur at a level equal to, or
  * lower than, the given level they will be reported to the given callback.
  *
- * @param level Bitmask of all enabled trace levels
- * @param cb Function to call with trace messages
- * @param cb_payload Payload to pass when callback is invoked
+ * @param level Level to set tracing to
+ * @param cb Function to call with trace data
  * @return 0 or an error code
  */
-GIT_EXTERN(int) git_trace_set(
-	git_trace_level_t level,
-	git_trace_callback cb,
-	void *cb_payload);
+GIT_EXTERN(int) git_trace_set(git_trace_level_t level, git_trace_callback cb);
 
 /** @} */
 GIT_END_DECL
diff --git a/src/diff.c b/src/diff.c
index b34d15312..26e671dce 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -14,7 +14,6 @@
 #include "index.h"
 #include "odb.h"
 #include "submodule.h"
-#include "trace.h"
 
 #define DIFF_FLAG_IS_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) != 0)
 #define DIFF_FLAG_ISNT_SET(DIFF,FLAG) (((DIFF)->opts.flags & (FLAG)) == 0)
@@ -555,7 +554,8 @@ int git_diff__oid_for_entry(
 	if (!entry.mode) {
 		struct stat st;
 
-		git_trace(GIT_TRACE_PERF, NULL, "stat");
+		diff->perf.stat_calls++;
+
 		if (p_stat(full_path.ptr, &st) < 0) {
 			error = git_path_set_error(errno, entry.path, "stat");
 			git_buf_free(&full_path);
@@ -570,7 +570,6 @@ int git_diff__oid_for_entry(
 	if (S_ISGITLINK(entry.mode)) {
 		git_submodule *sm;
 
-		git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
 		if (!git_submodule_lookup(&sm, diff->repo, entry.path)) {
 			const git_oid *sm_oid = git_submodule_wd_id(sm);
 			if (sm_oid)
@@ -583,8 +582,8 @@ int git_diff__oid_for_entry(
 			giterr_clear();
 		}
 	} else if (S_ISLNK(entry.mode)) {
-		git_trace(GIT_TRACE_PERF, NULL, "oid_calculation");
 		error = git_odb__hashlink(out, full_path.ptr);
+		diff->perf.oid_calculations++;
 	} else if (!git__is_sizet(entry.file_size)) {
 		giterr_set(GITERR_OS, "File size overflow (for 32-bits) on '%s'",
 			entry.path);
@@ -596,10 +595,10 @@ int git_diff__oid_for_entry(
 		if (fd < 0)
 			error = fd;
 		else {
-			git_trace(GIT_TRACE_PERF, NULL, "oid_calculation");
 			error = git_odb__hashfd_filtered(
 				out, fd, (size_t)entry.file_size, GIT_OBJ_BLOB, fl);
 			p_close(fd);
+			diff->perf.oid_calculations++;
 		}
 
 		git_filter_list_free(fl);
@@ -655,8 +654,6 @@ static int maybe_modified_submodule(
 		ign == GIT_SUBMODULE_IGNORE_ALL)
 		return 0;
 
-	git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
-
 	if ((error = git_submodule_lookup(
 			&sub, diff->repo, info->nitem->path)) < 0) {
 
@@ -965,8 +962,6 @@ static int handle_unmatched_new_item(
 		delta_type = GIT_DELTA_ADDED;
 
 	else if (nitem->mode == GIT_FILEMODE_COMMIT) {
-		git_trace(GIT_TRACE_PERF, NULL, "submodule_lookup");
-
 		/* ignore things that are not actual submodules */
 		if (git_submodule_lookup(NULL, info->repo, nitem->path) != 0) {
 			giterr_clear();
@@ -1119,6 +1114,8 @@ int git_diff__from_iterators(
 			error = 0;
 	}
 
+	diff->perf.stat_calls += old_iter->stat_calls + new_iter->stat_calls;
+
 cleanup:
 	if (!error)
 		*diff_ptr = diff;
@@ -1313,6 +1310,22 @@ int git_diff_is_sorted_icase(const git_diff *diff)
 	return (diff->opts.flags & GIT_DIFF_IGNORE_CASE) != 0;
 }
 
+static int diff_options_bad_version(int version, const char *thing)
+{
+	giterr_set(GITERR_INVALID, "Invalid version %d for %s", version, thing);
+	return -1;
+}
+
+int git_diff_get_perfdata(git_diff_perfdata *out, const git_diff *diff)
+{
+	if (!out || out->version != GIT_DIFF_PERFDATA_VERSION)
+		return diff_options_bad_version(
+			out ? out->version : 0, "git_diff_perfdata");
+	out->stat_calls = diff->perf.stat_calls;
+	out->oid_calculations = diff->perf.oid_calculations;
+	return 0;
+}
+
 int git_diff__paired_foreach(
 	git_diff *head2idx,
 	git_diff *idx2wd,
@@ -1615,38 +1628,29 @@ int git_diff_commit_as_email(
 	return error;
 }
 
-int git_diff_init_options(git_diff_options* opts, int version)
+int git_diff_init_options(git_diff_options* opts, unsigned int version)
 {
-	if (version != GIT_DIFF_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_options", version);
-		return -1;
-	} else {
-		git_diff_options o = GIT_DIFF_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	git_diff_options o = GIT_DIFF_OPTIONS_INIT;
+	if (version != o.version)
+		return diff_options_bad_version(version, "git_diff_options");
+	memcpy(opts, &o, sizeof(o));
+	return 0;
 }
 
-int git_diff_find_init_options(git_diff_find_options* opts, int version)
+int git_diff_find_init_options(git_diff_find_options* opts, unsigned int version)
 {
-	if (version != GIT_DIFF_FIND_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_find_options", version);
-		return -1;
-	} else {
-		git_diff_find_options o = GIT_DIFF_FIND_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	git_diff_find_options o = GIT_DIFF_FIND_OPTIONS_INIT;
+	if (version != o.version)
+		return diff_options_bad_version(version, "git_diff_find_options");
+	memcpy(opts, &o, sizeof(o));
+	return 0;
 }
 
-int git_diff_format_email_init_options(git_diff_format_email_options* opts, int version)
+int git_diff_format_email_init_options(git_diff_format_email_options* opts, unsigned int version)
 {
-	if (version != GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_format_email_options", version);
-		return -1;
-	} else {
-		git_diff_format_email_options o = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	git_diff_format_email_options o = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
+	if (version != o.version)
+		return diff_options_bad_version(version, "git_diff_format_email_options");
+	memcpy(opts, &o, sizeof(o));
+	return 0;
 }
diff --git a/src/diff.h b/src/diff.h
index 2e7ce0b7d..3305238d0 100644
--- a/src/diff.h
+++ b/src/diff.h
@@ -8,6 +8,7 @@
 #define INCLUDE_diff_h__
 
 #include "git2/diff.h"
+#include "git2/sys/diff.h"
 #include "git2/oid.h"
 
 #include <stdio.h>
@@ -62,6 +63,7 @@ struct git_diff {
 	git_iterator_type_t old_src;
 	git_iterator_type_t new_src;
 	uint32_t diffcaps;
+	git_diff_perfdata perf;
 
 	int (*strcomp)(const char *, const char *);
 	int (*strncomp)(const char *, const char *, size_t);
diff --git a/src/iterator.c b/src/iterator.c
index 0d7e5918d..4f8087c8d 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -11,7 +11,6 @@
 #include "ignore.h"
 #include "buffer.h"
 #include "submodule.h"
-#include "trace.h"
 #include <ctype.h>
 
 #define ITERATOR_SET_CB(P,NAME_LC) do { \
@@ -1017,8 +1016,7 @@ static int fs_iterator__expand_dir(fs_iterator *fi)
 		fs_iterator__free_frame(ff);
 		return GIT_ENOTFOUND;
 	}
-
-	git_trace(GIT_TRACE_PERF, &ff->entries.length, "stat");
+	fi->base.stat_calls += ff->entries.length;
 
 	fs_iterator__seek_frame_start(fi, ff);
 
@@ -1310,7 +1308,6 @@ static int workdir_iterator__enter_dir(fs_iterator *fi)
 		if (!S_ISDIR(entry->st.st_mode) || !strcmp(GIT_DIR, entry->path))
 			continue;
 
-		git_trace(GIT_TRACE_PERF, entry->path, "submodule_lookup");
 		if (git_submodule__is_submodule(fi->base.repo, entry->path)) {
 			entry->st.st_mode = GIT_FILEMODE_COMMIT;
 			entry->path_len--;
diff --git a/src/iterator.h b/src/iterator.h
index ba9c1e486..f67830212 100644
--- a/src/iterator.h
+++ b/src/iterator.h
@@ -52,6 +52,7 @@ struct git_iterator {
 	char *start;
 	char *end;
 	int (*prefixcomp)(const char *str, const char *prefix);
+	size_t stat_calls;
 	unsigned int flags;
 };
 
diff --git a/src/status.c b/src/status.c
index e418cf7b6..aab838bcf 100644
--- a/src/status.c
+++ b/src/status.c
@@ -518,14 +518,38 @@ int git_status_should_ignore(
 	return git_ignore_path_is_ignored(ignored, repo, path);
 }
 
-int git_status_init_options(git_status_options* opts, int version)
+int git_status_init_options(git_status_options* opts, unsigned int version)
 {
-	if (version != GIT_STATUS_OPTIONS_VERSION) {
+	git_status_options o = GIT_STATUS_OPTIONS_INIT;
+	if (version != o.version) {
 		giterr_set(GITERR_INVALID, "Invalid version %d for git_status_options", version);
 		return -1;
-	} else {
-		git_status_options o = GIT_STATUS_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
 	}
+	memcpy(opts, &o, sizeof(o));
+	return 0;
+}
+
+int git_status_list_get_perfdata(
+	git_diff_perfdata *out, const git_status_list *status)
+{
+	if (!out || out->version != GIT_DIFF_PERFDATA_VERSION) {
+		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_perfdata",
+				   out ? out->version : 0);
+		return -1;
+	}
+
+	out->stat_calls = 0;
+	out->oid_calculations = 0;
+
+	if (status->head2idx) {
+		out->stat_calls += status->head2idx->perf.stat_calls;
+		out->oid_calculations += status->head2idx->perf.oid_calculations;
+	}
+	if (status->idx2wd) {
+		out->stat_calls += status->idx2wd->perf.stat_calls;
+		out->oid_calculations += status->idx2wd->perf.oid_calculations;
+	}
+
+	return 0;
 }
+
diff --git a/src/trace.c b/src/trace.c
index 6ee2cf2ce..ee5039f56 100644
--- a/src/trace.c
+++ b/src/trace.c
@@ -17,25 +17,22 @@ struct git_trace_data git_trace__data = {0};
 
 #endif
 
-int git_trace_set(
-	git_trace_level_t level, git_trace_callback cb, void *cb_payload)
+int git_trace_set(git_trace_level_t level, git_trace_callback callback)
 {
 #ifdef GIT_TRACE
-	assert(level == 0 || cb != NULL);
+	assert(level == 0 || callback != NULL);
 
 	git_trace__data.level = level;
-	git_trace__data.callback = cb;
-	git_trace__data.callback_payload = cb_payload;
+	git_trace__data.callback = callback;
 	GIT_MEMORY_BARRIER;
 
 	return 0;
 #else
 	GIT_UNUSED(level);
-	GIT_UNUSED(cb);
-	GIT_UNUSED(cb_payload);
+	GIT_UNUSED(callback);
 
-	giterr_set(
-		GITERR_INVALID, "This version of libgit2 was not built with tracing.");
+	giterr_set(GITERR_INVALID,
+		"This version of libgit2 was not built with tracing.");
 	return -1;
 #endif
 }
diff --git a/src/trace.h b/src/trace.h
index b35e3808f..4d4e3bf53 100644
--- a/src/trace.h
+++ b/src/trace.h
@@ -15,16 +15,13 @@
 struct git_trace_data {
 	git_trace_level_t level;
 	git_trace_callback callback;
-	void *callback_payload;
 };
 
 extern struct git_trace_data git_trace__data;
 
 GIT_INLINE(void) git_trace__write_fmt(
 	git_trace_level_t level,
-	void *message_payload,
-	const char *fmt,
-	...)
+	const char *fmt, ...)
 {
 	git_trace_callback callback = git_trace__data.callback;
 	git_buf message = GIT_BUF_INIT;
@@ -34,18 +31,18 @@ GIT_INLINE(void) git_trace__write_fmt(
 	git_buf_vprintf(&message, fmt, ap);
 	va_end(ap);
 
-	callback(
-		level, git_trace__data.callback_payload, message_payload,
-		git_buf_cstr(&message));
+	callback(level, git_buf_cstr(&message));
 
 	git_buf_free(&message);
 }
 
 #define git_trace_level()		(git_trace__data.level)
-#define git_trace(l, p, ...)	do { \
-	if ((git_trace__data.level & (l)) != 0 && git_trace__data.callback) { \
-		git_trace__write_fmt((l), (p), __VA_ARGS__); \
-	} } while (0)
+#define git_trace(l, ...)		{ \
+									if (git_trace__data.level >= l && \
+										git_trace__data.callback != NULL) { \
+										git_trace__write_fmt(l, __VA_ARGS__); \
+									} \
+								}
 
 #else
 
diff --git a/tests/diff/diff_helpers.c b/tests/diff/diff_helpers.c
index 5de9834ba..279cb20c5 100644
--- a/tests/diff/diff_helpers.c
+++ b/tests/diff/diff_helpers.c
@@ -229,22 +229,3 @@ void diff_print_raw(FILE *fp, git_diff *diff)
 		git_diff_print(diff, GIT_DIFF_FORMAT_RAW,
 			git_diff_print_callback__to_file_handle, fp ? fp : stderr));
 }
-
-void diff_perf_track_stats(
-	git_trace_level_t level,
-	void *cb_payload,
-	void *msg_payload,
-	const char *msg)
-{
-	diff_perf *data = cb_payload;
-
-	if (!(level & GIT_TRACE_PERF))
-		return;
-
-	if (!strcmp("stat", msg))
-		data->stat_calls += msg_payload ? *((size_t *)msg_payload) : 1;
-	else if (!strcmp("submodule_lookup", msg))
-		data->submodule_lookups++;
-	else if (!strcmp("oid_calculation", msg))
-		data->oid_calcs++;
-}
diff --git a/tests/diff/diff_helpers.h b/tests/diff/diff_helpers.h
index 3ed538702..bf21f4b1f 100644
--- a/tests/diff/diff_helpers.h
+++ b/tests/diff/diff_helpers.h
@@ -62,17 +62,3 @@ extern int diff_foreach_via_iterator(
 
 extern void diff_print(FILE *fp, git_diff *diff);
 extern void diff_print_raw(FILE *fp, git_diff *diff);
-
-#include "git2/trace.h"
-
-typedef struct {
-	size_t stat_calls;
-	size_t oid_calcs;
-	size_t submodule_lookups;
-} diff_perf;
-
-extern void diff_perf_track_stats(
-	git_trace_level_t level,
-	void *cb_payload,
-	void *msg_payload,
-	const char *msg);
diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index 952c9022b..a6d48abc6 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -1,28 +1,13 @@
 #include "clar_libgit2.h"
 #include "diff_helpers.h"
 #include "repository.h"
+#include "git2/sys/diff.h"
 
 static git_repository *g_repo = NULL;
 
-#ifdef GIT_TRACE
-static diff_perf g_diff_perf;
-#endif
-
-void test_diff_workdir__initialize(void)
-{
-#ifdef GIT_TRACE
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-	cl_git_pass(git_trace_set(
-		GIT_TRACE_PERF, diff_perf_track_stats, &g_diff_perf));
-#endif
-}
-
 void test_diff_workdir__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
-#ifdef GIT_TRACE
-	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
-#endif
 }
 
 void test_diff_workdir__to_index(void)
@@ -70,13 +55,14 @@ void test_diff_workdir__to_index(void)
 		cl_assert_equal_i(5, exp.line_ctxt);
 		cl_assert_equal_i(4, exp.line_adds);
 		cl_assert_equal_i(5, exp.line_dels);
+	}
 
-#ifdef GIT_TRACE
+	{
+		git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
+		cl_git_pass(git_diff_get_perfdata(&perf, diff));
 		cl_assert_equal_sz(
-			13 /* in root */ + 3 /* in subdir */, g_diff_perf.stat_calls);
-		cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-		cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+			13 /* in root */ + 3 /* in subdir */, perf.stat_calls);
+		cl_assert_equal_sz(5, perf.oid_calculations);
 	}
 
 	git_diff_free(diff);
@@ -1532,10 +1518,6 @@ static void basic_diff_status(git_diff **out, const git_diff_options *opts)
 {
 	diff_expects exp;
 
-#ifdef GIT_TRACE
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
-
 	cl_git_pass(git_diff_index_to_workdir(out, g_repo, NULL, opts));
 
 	memset(&exp, 0, sizeof(exp));
@@ -1555,6 +1537,7 @@ void test_diff_workdir__can_update_index(void)
 {
 	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
 	git_diff *diff = NULL;
+	git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
 
 	g_repo = cl_git_sandbox_init("status");
 
@@ -1569,11 +1552,10 @@ void test_diff_workdir__can_update_index(void)
 	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+	cl_git_pass(git_diff_get_perfdata(&perf, diff));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(5, perf.oid_calculations);
 
 	git_diff_free(diff);
 
@@ -1581,22 +1563,20 @@ void test_diff_workdir__can_update_index(void)
 	opts.flags |= GIT_DIFF_UPDATE_INDEX;
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+	cl_git_pass(git_diff_get_perfdata(&perf, diff));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(5, perf.oid_calculations);
 
 	git_diff_free(diff);
 
 	/* now if we do it again, we should see fewer OID calculations */
 
 	basic_diff_status(&diff, &opts);
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(0, g_diff_perf.oid_calcs); /* Yay */
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+
+	cl_git_pass(git_diff_get_perfdata(&perf, diff));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(0, perf.oid_calculations);
 
 	git_diff_free(diff);
 }
diff --git a/tests/status/worktree.c b/tests/status/worktree.c
index 06864ad59..ca9068aba 100644
--- a/tests/status/worktree.c
+++ b/tests/status/worktree.c
@@ -6,19 +6,7 @@
 #include "util.h"
 #include "path.h"
 #include "../diff/diff_helpers.h"
-
-#ifdef GIT_TRACE
-static diff_perf g_diff_perf;
-#endif
-
-void test_status_worktree__initialize(void)
-{
-#ifdef GIT_TRACE
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-	cl_git_pass(git_trace_set(
-		GIT_TRACE_PERF, diff_perf_track_stats, &g_diff_perf));
-#endif
-}
+#include "git2/sys/diff.h"
 
 /**
  * Cleanup
@@ -29,9 +17,6 @@ void test_status_worktree__initialize(void)
 void test_status_worktree__cleanup(void)
 {
 	cl_git_sandbox_cleanup();
-#ifdef GIT_TRACE
-	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
-#endif
 }
 
 /**
@@ -903,38 +888,50 @@ void test_status_worktree__long_filenames(void)
  * while reducing the amount of work that needs to be done
  */
 
+static void check_status0(git_status_list *status)
+{
+	size_t i, max_i = git_status_list_entrycount(status);
+	cl_assert_equal_sz(entry_count0, max_i);
+	for (i = 0; i < max_i; ++i) {
+		const git_status_entry *entry = git_status_byindex(status, i);
+		cl_assert_equal_i(entry_statuses0[i], entry->status);
+	}
+}
+
 void test_status_worktree__update_stat_cache_0(void)
 {
 	git_repository *repo = cl_git_sandbox_init("status");
+	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+	git_status_list *status;
+	git_diff_perfdata perf = GIT_DIFF_PERFDATA_INIT;
 
-	assert_show(entry_count0, entry_paths0, entry_statuses0,
-		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
+	opts.flags = GIT_STATUS_OPT_DEFAULTS;
 
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+	cl_git_pass(git_status_list_new(&status, repo, &opts));
+	check_status0(status);
+	cl_git_pass(git_status_list_get_perfdata(&perf, status));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(5, perf.oid_calculations);
 
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
+	git_status_list_free(status);
 
-	assert_show(entry_count0, entry_paths0, entry_statuses0,
-		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, GIT_STATUS_OPT_UPDATE_INDEX);
+	opts.flags |= GIT_STATUS_OPT_UPDATE_INDEX;
+
+	cl_git_pass(git_status_list_new(&status, repo, &opts));
+	check_status0(status);
+	cl_git_pass(git_status_list_get_perfdata(&perf, status));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(5, perf.oid_calculations);
 
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(5, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
+	git_status_list_free(status);
 
-	memset(&g_diff_perf, 0, sizeof(g_diff_perf));
-#endif
+	opts.flags &= ~GIT_STATUS_OPT_UPDATE_INDEX;
 
-	assert_show(entry_count0, entry_paths0, entry_statuses0,
-		repo, GIT_STATUS_SHOW_INDEX_AND_WORKDIR, 0);
+	cl_git_pass(git_status_list_new(&status, repo, &opts));
+	check_status0(status);
+	cl_git_pass(git_status_list_get_perfdata(&perf, status));
+	cl_assert_equal_sz(13 + 3, perf.stat_calls);
+	cl_assert_equal_sz(0, perf.oid_calculations);
 
-#ifdef GIT_TRACE
-	cl_assert_equal_sz(13 + 3, g_diff_perf.stat_calls);
-	cl_assert_equal_sz(0, g_diff_perf.oid_calcs);
-	cl_assert_equal_sz(1, g_diff_perf.submodule_lookups);
-#endif
+	git_status_list_free(status);
 }
diff --git a/tests/trace/trace.c b/tests/trace/trace.c
index 328539379..87b325378 100644
--- a/tests/trace/trace.c
+++ b/tests/trace/trace.c
@@ -3,49 +3,44 @@
 
 static int written = 0;
 
-static void trace_callback(
-	git_trace_level_t level,
-	void *cb_payload,
-	void *msg_payload,
-	const char *msg)
+static void trace_callback(git_trace_level_t level, const char *message)
 {
-	GIT_UNUSED(level); GIT_UNUSED(msg_payload);
+	GIT_UNUSED(level);
 
-	cl_assert(strcmp(msg, "Hello world!") == 0);
+	cl_assert(strcmp(message, "Hello world!") == 0);
 
-	if (cb_payload)
-		*((int *)cb_payload) = 1;
+	written = 1;
 }
 
 void test_trace_trace__initialize(void)
 {
-	git_trace_set(GIT_TRACE_INFO_AND_BELOW, trace_callback, &written);
+	git_trace_set(GIT_TRACE_INFO, trace_callback);
 	written = 0;
 }
 
 void test_trace_trace__cleanup(void)
 {
-	git_trace_set(GIT_TRACE_NONE, NULL, NULL);
+	git_trace_set(GIT_TRACE_NONE, NULL);
 }
 
 void test_trace_trace__sets(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
+	cl_assert(git_trace_level() == GIT_TRACE_INFO);
 #endif
 }
 
 void test_trace_trace__can_reset(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
-	cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback, &written));
+	cl_assert(git_trace_level() == GIT_TRACE_INFO);
+	cl_git_pass(git_trace_set(GIT_TRACE_ERROR, trace_callback));
 
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_INFO, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
 	cl_assert(written == 0);
 
-	git_trace(GIT_TRACE_ERROR, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }
@@ -53,13 +48,13 @@ void test_trace_trace__can_reset(void)
 void test_trace_trace__can_unset(void)
 {
 #ifdef GIT_TRACE
-	cl_assert(git_trace_level() == GIT_TRACE_INFO_AND_BELOW);
-	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL, NULL));
+	cl_assert(git_trace_level() == GIT_TRACE_INFO);
+	cl_git_pass(git_trace_set(GIT_TRACE_NONE, NULL));
 
 	cl_assert(git_trace_level() == GIT_TRACE_NONE);
 
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_FATAL, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_FATAL, "Hello %s!", "world");
 	cl_assert(written == 0);
 #endif
 }
@@ -68,7 +63,7 @@ void test_trace_trace__skips_higher_level(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_DEBUG, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_DEBUG, "Hello %s!", "world");
 	cl_assert(written == 0);
 #endif
 }
@@ -77,7 +72,7 @@ void test_trace_trace__writes(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_INFO, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_INFO, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }
@@ -86,7 +81,7 @@ void test_trace_trace__writes_lower_level(void)
 {
 #ifdef GIT_TRACE
 	cl_assert(written == 0);
-	git_trace(GIT_TRACE_ERROR, NULL, "Hello %s!", "world");
+	git_trace(GIT_TRACE_ERROR, "Hello %s!", "world");
 	cl_assert(written == 1);
 #endif
 }
-- 
cgit v1.2.3


From 702efc891f2a620f10998062ba0c00b34100f632 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 30 Apr 2014 10:57:42 -0700
Subject: Make init_options fns use unsigned ints and macro

Use an unsigned int for the version and add a helper macro so the
code is simplified (and so the error message is a common string).
---
 include/git2/blame.h      | 19 +++++++++----------
 include/git2/clone.h      | 19 +++++++++----------
 include/git2/diff.h       | 44 ++++++++++++++++++++++----------------------
 include/git2/merge.h      |  6 +++---
 include/git2/push.h       |  4 ++--
 include/git2/repository.h |  9 ++++-----
 src/blame.c               | 13 ++++---------
 src/clone.c               | 13 ++++---------
 src/common.h              |  5 +++++
 src/diff.c                | 27 ++++++++++++---------------
 src/merge.c               | 40 +++++++++++++---------------------------
 src/push.c                | 13 ++++---------
 src/repository.c          | 15 ++++++---------
 src/status.c              | 10 +++-------
 14 files changed, 100 insertions(+), 137 deletions(-)

diff --git a/include/git2/blame.h b/include/git2/blame.h
index b7fa9aeda..7f0de1731 100644
--- a/include/git2/blame.h
+++ b/include/git2/blame.h
@@ -83,17 +83,16 @@ typedef struct git_blame_options {
 #define GIT_BLAME_OPTIONS_INIT {GIT_BLAME_OPTIONS_VERSION}
 
 /**
-* Initializes a `git_blame_options` with default values. Equivalent to
-* creating an instance with GIT_BLAME_OPTIONS_INIT.
-*
-* @param opts the `git_blame_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_BLAME_OPTIONS_VERSION` here.
-* @return Zero on success; -1 on failure.
-*/
+ * Initializes a `git_blame_options` with default values. Equivalent to
+ * creating an instance with GIT_BLAME_OPTIONS_INIT.
+ *
+ * @param opts The `git_blame_options` struct to initialize
+ * @param version Version of struct; pass `GIT_BLAME_OPTIONS_VERSION`
+ * @return Zero on success; -1 on failure.
+ */
 GIT_EXTERN(int) git_blame_init_options(
-	git_blame_options* opts,
-	int version);
+	git_blame_options *opts,
+	unsigned int version);
 
 /**
  * Structure that represents a blame hunk.
diff --git a/include/git2/clone.h b/include/git2/clone.h
index 20be1a105..985c04bf6 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -66,17 +66,16 @@ typedef struct git_clone_options {
 #define GIT_CLONE_OPTIONS_INIT {GIT_CLONE_OPTIONS_VERSION, {GIT_CHECKOUT_OPTIONS_VERSION, GIT_CHECKOUT_SAFE_CREATE}, GIT_REMOTE_CALLBACKS_INIT}
 
 /**
-* Initializes a `git_clone_options` with default values. Equivalent to
-* creating an instance with GIT_CLONE_OPTIONS_INIT.
-*
-* @param opts the `git_clone_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_CLONE_OPTIONS_VERSION` here.
-* @return Zero on success; -1 on failure.
-*/
+ * Initializes a `git_clone_options` with default values. Equivalent to
+ * creating an instance with GIT_CLONE_OPTIONS_INIT.
+ *
+ * @param opts The `git_clone_options` struct to initialize
+ * @param version Version of struct; pass `GIT_CLONE_OPTIONS_VERSION`
+ * @return Zero on success; -1 on failure.
+ */
 GIT_EXTERN(int) git_clone_init_options(
-	git_clone_options* opts,
-	int version);
+	git_clone_options *opts,
+	unsigned int version);
 
 /**
  * Clone a remote repository.
diff --git a/include/git2/diff.h b/include/git2/diff.h
index b849e3bb5..b40cc6135 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -388,13 +388,13 @@ typedef struct {
 	{GIT_DIFF_OPTIONS_VERSION, 0, GIT_SUBMODULE_IGNORE_DEFAULT, {NULL,0}, NULL, NULL, 3}
 
 /**
-* Initializes a `git_diff_options` with default values. Equivalent to
-* creating an instance with GIT_DIFF_OPTIONS_INIT.
-*
-* @param opts The `git_diff_options` instance to initialize.
-* @param version Version of struct; pass `GIT_DIFF_OPTIONS_VERSION`
-* @return Zero on success; -1 on failure.
-*/
+ * Initializes a `git_diff_options` with default values. Equivalent to
+ * creating an instance with GIT_DIFF_OPTIONS_INIT.
+ *
+ * @param opts The `git_diff_options` struct to initialize
+ * @param version Version of struct; pass `GIT_DIFF_OPTIONS_VERSION`
+ * @return Zero on success; -1 on failure.
+ */
 GIT_EXTERN(int) git_diff_init_options(
 	git_diff_options *opts,
 	unsigned int version);
@@ -628,13 +628,13 @@ typedef struct {
 #define GIT_DIFF_FIND_OPTIONS_INIT {GIT_DIFF_FIND_OPTIONS_VERSION}
 
 /**
-* Initializes a `git_diff_find_options` with default values. Equivalent to
-* creating an instance with GIT_DIFF_FIND_OPTIONS_INIT.
-*
-* @param opts The `git_diff_find_options` instance to initialize.
-* @param version Version of struct; pass `GIT_DIFF_FIND_OPTIONS_VERSION`
-* @return Zero on success; -1 on failure.
-*/
+ * Initializes a `git_diff_find_options` with default values. Equivalent to
+ * creating an instance with GIT_DIFF_FIND_OPTIONS_INIT.
+ *
+ * @param opts The `git_diff_find_options` struct to initialize
+ * @param version Version of struct; pass `GIT_DIFF_FIND_OPTIONS_VERSION`
+ * @return Zero on success; -1 on failure.
+ */
 GIT_EXTERN(int) git_diff_find_init_options(
 	git_diff_find_options *opts,
 	unsigned int version);
@@ -1221,14 +1221,14 @@ GIT_EXTERN(int) git_diff_commit_as_email(
 	const git_diff_options *diff_opts);
 
 /**
-* Initializes a `git_diff_format_email_options` with default values.
-*
-* Equivalent to creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
-*
-* @param opts Uhe `git_diff_format_email_options` instance to initialize.
-* @param version Version of struct; pass `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION`
-* @return Zero on success; -1 on failure.
-*/
+ * Initializes a `git_diff_format_email_options` with default values.
+ *
+ * Equivalent to creating an instance with GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT.
+ *
+ * @param opts The `git_diff_format_email_options` struct to initialize
+ * @param version Version of struct; pass `GIT_DIFF_FORMAT_EMAIL_OPTIONS_VERSION`
+ * @return Zero on success; -1 on failure.
+ */
 GIT_EXTERN(int) git_diff_format_email_init_options(
 	git_diff_format_email_options *opts,
 	unsigned int version);
diff --git a/include/git2/merge.h b/include/git2/merge.h
index 6d97e81e6..ef2dc3804 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -57,7 +57,7 @@ typedef struct {
  */
 GIT_EXTERN(int) git_merge_file_init_input(
 	git_merge_file_input *opts,
-	int version);
+	unsigned int version);
 
 /**
  * Flags for `git_merge_tree` options.  A combination of these flags can be
@@ -164,7 +164,7 @@ typedef struct {
  */
 GIT_EXTERN(int) git_merge_file_init_options(
 	git_merge_file_options *opts,
-	int version);
+	unsigned int version);
 
 typedef struct {
 	/**
@@ -232,7 +232,7 @@ typedef struct {
  */
 GIT_EXTERN(int) git_merge_init_options(
 	git_merge_options *opts,
-	int version);
+	unsigned int version);
 
 /**
  * The results of `git_merge_analysis` indicate the merge opportunities.
diff --git a/include/git2/push.h b/include/git2/push.h
index 7a8bec12c..cbf115661 100644
--- a/include/git2/push.h
+++ b/include/git2/push.h
@@ -49,8 +49,8 @@ typedef struct {
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_push_init_options(
-	git_push_options* opts,
-	int version);
+	git_push_options *opts,
+	unsigned int version);
 
 /** Push network progress notification function */
 typedef int (*git_push_transfer_progress)(
diff --git a/include/git2/repository.h b/include/git2/repository.h
index 4433e71a2..e3f687a29 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -271,14 +271,13 @@ typedef struct {
  * Initializes a `git_repository_init_options` with default values. Equivalent
  * to creating an instance with GIT_REPOSITORY_INIT_OPTIONS_INIT.
  *
- * @param opts the `git_repository_init_options` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_REPOSITORY_INIT_OPTIONS_VERSION` here.
+ * @param opts the `git_repository_init_options` struct to initialize
+ * @param version Version of struct; pass `GIT_REPOSITORY_INIT_OPTIONS_VERSION`
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_repository_init_init_options(
-	git_repository_init_options* opts,
-	int version);
+	git_repository_init_options *opts,
+	unsigned int version);
 
 /**
  * Create a new Git repository in the given folder with extended controls.
diff --git a/src/blame.c b/src/blame.c
index e45c0ee1c..eb977c287 100644
--- a/src/blame.c
+++ b/src/blame.c
@@ -480,14 +480,9 @@ int git_blame_buffer(
 	return 0;
 }
 
-int git_blame_init_options(git_blame_options* opts, int version)
+int git_blame_init_options(git_blame_options *opts, unsigned int version)
 {
-	if (version != GIT_BLAME_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_blame_options", version);
-		return -1;
-	} else {
-		git_blame_options o = GIT_BLAME_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_blame_options, GIT_BLAME_OPTIONS_INIT);
+	return 0;
 }
diff --git a/src/clone.c b/src/clone.c
index 62f103561..c6be00f0e 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -445,14 +445,9 @@ int git_clone(
 	return error;
 }
 
-int git_clone_init_options(git_clone_options* opts, int version)
+int git_clone_init_options(git_clone_options *opts, unsigned int version)
 {
-	if (version != GIT_CLONE_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_clone_options", version);
-		return -1;
-	} else {
-		git_clone_options o = GIT_CLONE_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_clone_options, GIT_CLONE_OPTIONS_INIT);
+	return 0;
 }
diff --git a/src/common.h b/src/common.h
index dd97a3099..807e5fa39 100644
--- a/src/common.h
+++ b/src/common.h
@@ -170,6 +170,11 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v
 }
 #define GIT_INIT_STRUCTURE(S,V) git__init_structure(S, sizeof(*S), V)
 
+#define GIT_INIT_STRUCTURE_FROM_TEMPLATE(PTR,VERSION,TYPE,TPL) do { \
+	TYPE _tmpl = TPL; \
+	GITERR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);	\
+	memcpy((PTR), &_tmpl, sizeof(_tmpl)); } while (0)
+
 /* NOTE: other giterr functions are in the public errors.h header file */
 
 #include "util.h"
diff --git a/src/diff.c b/src/diff.c
index 26e671dce..56f333f76 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -1628,29 +1628,26 @@ int git_diff_commit_as_email(
 	return error;
 }
 
-int git_diff_init_options(git_diff_options* opts, unsigned int version)
+int git_diff_init_options(git_diff_options *opts, unsigned int version)
 {
-	git_diff_options o = GIT_DIFF_OPTIONS_INIT;
-	if (version != o.version)
-		return diff_options_bad_version(version, "git_diff_options");
-	memcpy(opts, &o, sizeof(o));
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_diff_options, GIT_DIFF_OPTIONS_INIT);
 	return 0;
 }
 
-int git_diff_find_init_options(git_diff_find_options* opts, unsigned int version)
+int git_diff_find_init_options(
+	git_diff_find_options *opts, unsigned int version)
 {
-	git_diff_find_options o = GIT_DIFF_FIND_OPTIONS_INIT;
-	if (version != o.version)
-		return diff_options_bad_version(version, "git_diff_find_options");
-	memcpy(opts, &o, sizeof(o));
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_diff_find_options, GIT_DIFF_FIND_OPTIONS_INIT);
 	return 0;
 }
 
-int git_diff_format_email_init_options(git_diff_format_email_options* opts, unsigned int version)
+int git_diff_format_email_init_options(
+	git_diff_format_email_options *opts, unsigned int version)
 {
-	git_diff_format_email_options o = GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT;
-	if (version != o.version)
-		return diff_options_bad_version(version, "git_diff_format_email_options");
-	memcpy(opts, &o, sizeof(o));
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_diff_format_email_options,
+		GIT_DIFF_FORMAT_EMAIL_OPTIONS_INIT);
 	return 0;
 }
diff --git a/src/merge.c b/src/merge.c
index 69c42bc0c..6a8e5874f 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2803,38 +2803,24 @@ void git_merge_head_free(git_merge_head *head)
 	git__free(head);
 }
 
-int git_merge_init_options(git_merge_options *opts, int version)
+int git_merge_init_options(git_merge_options *opts, unsigned int version)
 {
-	if (version != GIT_MERGE_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_options", version);
-		return -1;
-	} else {
-		git_merge_options default_opts = GIT_MERGE_OPTIONS_INIT;
-		memcpy(opts, &default_opts, sizeof(git_merge_options));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_merge_options, GIT_MERGE_OPTIONS_INIT);
+	return 0;
 }
 
-int git_merge_file_init_input(git_merge_file_input *input, int version)
+int git_merge_file_init_input(git_merge_file_input *input, unsigned int version)
 {
-	if (version != GIT_MERGE_FILE_INPUT_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_file_input", version);
-		return -1;
-	} else {
-		git_merge_file_input i = GIT_MERGE_FILE_INPUT_INIT;
-		memcpy(input, &i, sizeof(i));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		input, version, git_merge_file_input, GIT_MERGE_FILE_INPUT_INIT);
+	return 0;
 }
 
-int git_merge_file_init_options(git_merge_file_options *opts, int version)
+int git_merge_file_init_options(
+	git_merge_file_options *opts, unsigned int version)
 {
-	if (version != GIT_MERGE_FILE_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_merge_file_options", version);
-		return -1;
-	} else {
-		git_merge_file_options o = GIT_MERGE_FILE_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_merge_file_options, GIT_MERGE_FILE_OPTIONS_INIT);
+	return 0;
 }
diff --git a/src/push.c b/src/push.c
index 9943f215c..be5ec1c0e 100644
--- a/src/push.c
+++ b/src/push.c
@@ -716,14 +716,9 @@ void git_push_free(git_push *push)
 	git__free(push);
 }
 
-int git_push_init_options(git_push_options* opts, int version)
+int git_push_init_options(git_push_options *opts, unsigned int version)
 {
-	if (version != GIT_PUSH_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_push_options", version);
-		return -1;
-	} else {
-		git_push_options o = GIT_PUSH_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_push_options, GIT_PUSH_OPTIONS_INIT);
+	return 0;
 }
diff --git a/src/repository.c b/src/repository.c
index 8daa04d5d..ac7af7692 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -2026,14 +2026,11 @@ int git_repository_is_shallow(git_repository *repo)
 	return st.st_size == 0 ? 0 : 1;
 }
 
-int git_repository_init_init_options(git_repository_init_options* opts, int version)
+int git_repository_init_init_options(
+	git_repository_init_options *opts, unsigned int version)
 {
-	if (version != GIT_REPOSITORY_INIT_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_repository_init_options", version);
-		return -1;
-	} else {
-		git_repository_init_options o = GIT_REPOSITORY_INIT_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_repository_init_options,
+		GIT_REPOSITORY_INIT_OPTIONS_INIT);
+	return 0;
 }
diff --git a/src/status.c b/src/status.c
index aab838bcf..bcc2692d2 100644
--- a/src/status.c
+++ b/src/status.c
@@ -518,14 +518,10 @@ int git_status_should_ignore(
 	return git_ignore_path_is_ignored(ignored, repo, path);
 }
 
-int git_status_init_options(git_status_options* opts, unsigned int version)
+int git_status_init_options(git_status_options *opts, unsigned int version)
 {
-	git_status_options o = GIT_STATUS_OPTIONS_INIT;
-	if (version != o.version) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_status_options", version);
-		return -1;
-	}
-	memcpy(opts, &o, sizeof(o));
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_status_options, GIT_STATUS_OPTIONS_INIT);
 	return 0;
 }
 
-- 
cgit v1.2.3


From bc91347b5894c98964a12c6637d5ca91d9723b42 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Wed, 30 Apr 2014 11:16:31 -0700
Subject: Fix remaining init_options inconsistencies

There were a couple of "init_opts()" functions a few more cases
of structure initialization that I somehow missed.
---
 include/git2/checkout.h          | 11 +++++------
 include/git2/cherrypick.h        | 11 +++++------
 include/git2/remote.h            |  9 ++++-----
 include/git2/revert.h            | 11 +++++------
 include/git2/sys/config.h        |  9 ++++-----
 include/git2/sys/odb_backend.h   |  9 ++++-----
 include/git2/sys/refdb_backend.h |  9 ++++-----
 include/git2/transport.h         |  9 ++++-----
 src/checkout.c                   | 13 ++++---------
 src/cherrypick.c                 | 14 +++++---------
 src/config.c                     | 13 ++++---------
 src/diff.c                       | 11 ++---------
 src/odb.c                        | 13 ++++---------
 src/refdb.c                      | 13 ++++---------
 src/remote.c                     | 13 ++++---------
 src/revert.c                     | 13 ++++---------
 src/status.c                     |  7 ++-----
 src/transport.c                  | 13 ++++---------
 tests/structinit/structinit.c    |  4 ++--
 19 files changed, 74 insertions(+), 131 deletions(-)

diff --git a/include/git2/checkout.h b/include/git2/checkout.h
index 69addb7d9..494f67456 100644
--- a/include/git2/checkout.h
+++ b/include/git2/checkout.h
@@ -270,14 +270,13 @@ typedef struct git_checkout_options {
 * Initializes a `git_checkout_options` with default values. Equivalent to
 * creating an instance with GIT_CHECKOUT_OPTIONS_INIT.
 *
-* @param opts the `git_checkout_options` instance to initialize.
-* @param version the version of the struct; you should pass
-* `GIT_CHECKOUT_OPTIONS_VERSION` here.
+* @param opts the `git_checkout_options` struct to initialize.
+* @param version Version of struct; pass `GIT_CHECKOUT_OPTIONS_VERSION`
 * @return Zero on success; -1 on failure.
 */
-GIT_EXTERN(int) git_checkout_init_opts(
-	git_checkout_options* opts,
-	int version);
+GIT_EXTERN(int) git_checkout_init_options(
+	git_checkout_options *opts,
+	unsigned int version);
 
 /**
  * Updates files in the index and the working tree to match the content of
diff --git a/include/git2/cherrypick.h b/include/git2/cherrypick.h
index 7c48e6659..e998d325f 100644
--- a/include/git2/cherrypick.h
+++ b/include/git2/cherrypick.h
@@ -37,14 +37,13 @@ typedef struct {
  * Initializes a `git_cherry_pick_options` with default values. Equivalent to
  * creating an instance with GIT_CHERRY_PICK_OPTIONS_INIT.
  *
- * @param opts the `git_cherry_pick_options` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_CHERRY_PICK_OPTIONS_VERSION` here.
+ * @param opts the `git_cherry_pick_options` struct to initialize
+ * @param version Version of struct; pass `GIT_CHERRY_PICK_OPTIONS_VERSION`
  * @return Zero on success; -1 on failure.
  */
-GIT_EXTERN(int) git_cherry_pick_init_opts(
-	git_cherry_pick_options* opts,
-	int version);
+GIT_EXTERN(int) git_cherry_pick_init_options(
+	git_cherry_pick_options *opts,
+	unsigned int version);
 
 /**
  * Cherry-picks the given commit against the given "our" commit, producing an
diff --git a/include/git2/remote.h b/include/git2/remote.h
index 11e1e26d0..3633501e2 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -501,14 +501,13 @@ struct git_remote_callbacks {
  * Initializes a `git_remote_callbacks` with default values. Equivalent to
  * creating an instance with GIT_REMOTE_CALLBACKS_INIT.
  *
- * @param opts the `git_remote_callbacks` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_REMOTE_CALLBACKS_VERSION` here.
+ * @param opts the `git_remote_callbacks` struct to initialize
+ * @param version Version of struct; pass `GIT_REMOTE_CALLBACKS_VERSION`
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_remote_init_callbacks(
-	git_remote_callbacks* opts,
-	int version);
+	git_remote_callbacks *opts,
+	unsigned int version);
 
 /**
  * Set the callbacks for a remote
diff --git a/include/git2/revert.h b/include/git2/revert.h
index 3a6beb6b8..da37fbe7b 100644
--- a/include/git2/revert.h
+++ b/include/git2/revert.h
@@ -37,14 +37,13 @@ typedef struct {
  * Initializes a `git_revert_options` with default values. Equivalent to
  * creating an instance with GIT_REVERT_OPTIONS_INIT.
  *
- * @param opts the `git_revert_options` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_REVERT_OPTIONS_VERSION` here.
+ * @param opts the `git_revert_options` struct to initialize
+ * @param version Version of struct; pass `GIT_REVERT_OPTIONS_VERSION`
  * @return Zero on success; -1 on failure.
  */
-GIT_EXTERN(int) git_revert_init_opts(
-	git_revert_options* opts,
-	int version);
+GIT_EXTERN(int) git_revert_init_options(
+	git_revert_options *opts,
+	unsigned int version);
 
 /**
  * Reverts the given commit against the given "our" commit, producing an
diff --git a/include/git2/sys/config.h b/include/git2/sys/config.h
index 3df2ba327..46bb65293 100644
--- a/include/git2/sys/config.h
+++ b/include/git2/sys/config.h
@@ -73,14 +73,13 @@ struct git_config_backend {
  * Initializes a `git_config_backend` with default values. Equivalent to
  * creating an instance with GIT_CONFIG_BACKEND_INIT.
  *
- * @param opts the `git_config_backend` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_CONFIG_BACKEND_VERSION` here.
+ * @param opts the `git_config_backend` struct to initialize.
+ * @param version Version of struct; pass `GIT_CONFIG_BACKEND_VERSION`
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_config_init_backend(
-	git_config_backend* backend,
-	int version);
+	git_config_backend *backend,
+	unsigned int version);
 
 /**
  * Add a generic config file instance to an existing config
diff --git a/include/git2/sys/odb_backend.h b/include/git2/sys/odb_backend.h
index 77fe0dd31..1fc3c3159 100644
--- a/include/git2/sys/odb_backend.h
+++ b/include/git2/sys/odb_backend.h
@@ -93,14 +93,13 @@ struct git_odb_backend {
  * Initializes a `git_odb_backend` with default values. Equivalent to
  * creating an instance with GIT_ODB_BACKEND_INIT.
  *
- * @param opts the `git_odb_backend` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_ODB_BACKEND_VERSION` here.
+ * @param opts the `git_odb_backend` struct to initialize.
+ * @param version Version the struct; pass `GIT_ODB_BACKEND_VERSION`
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_odb_init_backend(
-	git_odb_backend* backend,
-	int version);
+	git_odb_backend *backend,
+	unsigned int version);
 
 GIT_EXTERN(void *) git_odb_backend_malloc(git_odb_backend *backend, size_t len);
 
diff --git a/include/git2/sys/refdb_backend.h b/include/git2/sys/refdb_backend.h
index dce142c77..3b216a287 100644
--- a/include/git2/sys/refdb_backend.h
+++ b/include/git2/sys/refdb_backend.h
@@ -162,14 +162,13 @@ struct git_refdb_backend {
  * Initializes a `git_refdb_backend` with default values. Equivalent to
  * creating an instance with GIT_REFDB_BACKEND_INIT.
  *
- * @param opts the `git_refdb_backend` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_REFDB_BACKEND_VERSION` here.
+ * @param opts the `git_refdb_backend` struct to initialize
+ * @param version Version of struct; pass `GIT_REFDB_BACKEND_VERSION`
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_refdb_init_backend(
-	git_refdb_backend* backend,
-	int version);
+	git_refdb_backend *backend,
+	unsigned int version);
 
 /**
  * Constructors for default filesystem-based refdb backend
diff --git a/include/git2/transport.h b/include/git2/transport.h
index a33146ca8..af7812b5d 100644
--- a/include/git2/transport.h
+++ b/include/git2/transport.h
@@ -314,14 +314,13 @@ struct git_transport {
  * Initializes a `git_transport` with default values. Equivalent to
  * creating an instance with GIT_TRANSPORT_INIT.
  *
- * @param opts the `git_transport` instance to initialize.
- * @param version the version of the struct; you should pass
- *        `GIT_TRANSPORT_VERSION` here.
+ * @param opts the `git_transport` struct to initialize
+ * @param version Version of struct; pass `GIT_TRANSPORT_VERSION`
  * @return Zero on success; -1 on failure.
  */
 GIT_EXTERN(int) git_transport_init(
-	git_transport* opts,
-	int version);
+	git_transport *opts,
+	unsigned int version);
 
 /**
  * Function to use to create a transport from a URL. The transport database
diff --git a/src/checkout.c b/src/checkout.c
index 727911694..b869efe2b 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -2240,14 +2240,9 @@ int git_checkout_head(
 	return git_checkout_tree(repo, NULL, opts);
 }
 
-int git_checkout_init_opts(git_checkout_options* opts, int version)
+int git_checkout_init_options(git_checkout_options *opts, unsigned int version)
 {
-	if (version != GIT_CHECKOUT_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_checkout_options", version);
-		return -1;
-	} else {
-		git_checkout_options o = GIT_CHECKOUT_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_checkout_options, GIT_CHECKOUT_OPTIONS_INIT);
+	return 0;
 }
diff --git a/src/cherrypick.c b/src/cherrypick.c
index 6a5ca834c..e02348a03 100644
--- a/src/cherrypick.c
+++ b/src/cherrypick.c
@@ -217,14 +217,10 @@ done:
 	return error;
 }
 
-int git_cherry_pick_init_opts(git_cherry_pick_options* opts, int version)
+int git_cherry_pick_init_options(
+	git_cherry_pick_options *opts, unsigned int version)
 {
-	if (version != GIT_CHERRY_PICK_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_cherry_pick_options", version);
-		return -1;
-	} else {
-		git_cherry_pick_options o = GIT_CHERRY_PICK_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_cherry_pick_options, GIT_CHERRY_PICK_OPTIONS_INIT);
+	return 0;
 }
diff --git a/src/config.c b/src/config.c
index 16854c0c8..ee92398fc 100644
--- a/src/config.c
+++ b/src/config.c
@@ -1276,14 +1276,9 @@ cleanup:
 	return error;
 }
 
-int git_config_init_backend(git_config_backend* backend, int version)
+int git_config_init_backend(git_config_backend *backend, unsigned int version)
 {
-	if (version != GIT_CONFIG_BACKEND_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_config_backend", version);
-		return -1;
-	} else {
-		git_config_backend b = GIT_CONFIG_BACKEND_INIT;
-		memcpy(backend, &b, sizeof(b));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		backend, version, git_config_backend, GIT_CONFIG_BACKEND_INIT);
+	return 0;
 }
diff --git a/src/diff.c b/src/diff.c
index 56f333f76..781f23ec6 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -1310,17 +1310,10 @@ int git_diff_is_sorted_icase(const git_diff *diff)
 	return (diff->opts.flags & GIT_DIFF_IGNORE_CASE) != 0;
 }
 
-static int diff_options_bad_version(int version, const char *thing)
-{
-	giterr_set(GITERR_INVALID, "Invalid version %d for %s", version, thing);
-	return -1;
-}
-
 int git_diff_get_perfdata(git_diff_perfdata *out, const git_diff *diff)
 {
-	if (!out || out->version != GIT_DIFF_PERFDATA_VERSION)
-		return diff_options_bad_version(
-			out ? out->version : 0, "git_diff_perfdata");
+	assert(out);
+	GITERR_CHECK_VERSION(out, GIT_DIFF_PERFDATA_VERSION, "git_diff_perfdata");
 	out->stat_calls = diff->perf.stat_calls;
 	out->oid_calculations = diff->perf.oid_calculations;
 	return 0;
diff --git a/src/odb.c b/src/odb.c
index 00740d2e2..20a3f6c6e 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -1123,14 +1123,9 @@ int git_odb__error_ambiguous(const char *message)
 	return GIT_EAMBIGUOUS;
 }
 
-int git_odb_init_backend(git_odb_backend* backend, int version)
+int git_odb_init_backend(git_odb_backend *backend, unsigned int version)
 {
-	if (version != GIT_ODB_BACKEND_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_odb_backend", version);
-		return -1;
-	} else {
-		git_odb_backend b = GIT_ODB_BACKEND_INIT;
-		memcpy(backend, &b, sizeof(b));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		backend, version, git_odb_backend, GIT_ODB_BACKEND_INIT);
+	return 0;
 }
diff --git a/src/refdb.c b/src/refdb.c
index 3e7a592f8..69bf74734 100644
--- a/src/refdb.c
+++ b/src/refdb.c
@@ -236,14 +236,9 @@ int git_refdb_ensure_log(git_refdb *db, const char *refname)
 	return db->backend->ensure_log(db->backend, refname);
 }
 
-int git_refdb_init_backend(git_refdb_backend* backend, int version)
+int git_refdb_init_backend(git_refdb_backend *backend, unsigned int version)
 {
-	if (version != GIT_REFDB_BACKEND_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_refdb_backend", version);
-		return -1;
-	} else {
-		git_refdb_backend b = GIT_REFDB_BACKEND_INIT;
-		memcpy(backend, &b, sizeof(b));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		backend, version, git_refdb_backend, GIT_REFDB_BACKEND_INIT);
+	return 0;
 }
diff --git a/src/remote.c b/src/remote.c
index be7198a98..8f302a51e 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1736,14 +1736,9 @@ const git_refspec *git_remote_get_refspec(const git_remote *remote, size_t n)
 	return git_vector_get(&remote->refspecs, n);
 }
 
-int git_remote_init_callbacks(git_remote_callbacks* opts, int version)
+int git_remote_init_callbacks(git_remote_callbacks *opts, unsigned int version)
 {
-	if (version != GIT_REMOTE_CALLBACKS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_remote_callbacks", version);
-		return -1;
-	} else {
-		git_remote_callbacks o = GIT_REMOTE_CALLBACKS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_remote_callbacks, GIT_REMOTE_CALLBACKS_INIT);
+	return 0;
 }
diff --git a/src/revert.c b/src/revert.c
index 29e124f6c..9c587724b 100644
--- a/src/revert.c
+++ b/src/revert.c
@@ -220,14 +220,9 @@ done:
 	return error;
 }
 
-int git_revert_init_opts(git_revert_options* opts, int version)
+int git_revert_init_options(git_revert_options *opts, unsigned int version)
 {
-	if (version != GIT_REVERT_OPTIONS_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_revert_options", version);
-		return -1;
-	} else {
-		git_revert_options o = GIT_REVERT_OPTIONS_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_revert_options, GIT_REVERT_OPTIONS_INIT);
+	return 0;
 }
diff --git a/src/status.c b/src/status.c
index bcc2692d2..8d7612f72 100644
--- a/src/status.c
+++ b/src/status.c
@@ -528,11 +528,8 @@ int git_status_init_options(git_status_options *opts, unsigned int version)
 int git_status_list_get_perfdata(
 	git_diff_perfdata *out, const git_status_list *status)
 {
-	if (!out || out->version != GIT_DIFF_PERFDATA_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_diff_perfdata",
-				   out ? out->version : 0);
-		return -1;
-	}
+	assert(out);
+	GITERR_CHECK_VERSION(out, GIT_DIFF_PERFDATA_VERSION, "git_diff_perfdata");
 
 	out->stat_calls = 0;
 	out->oid_calculations = 0;
diff --git a/src/transport.c b/src/transport.c
index dc074a503..2194b1864 100644
--- a/src/transport.c
+++ b/src/transport.c
@@ -218,14 +218,9 @@ int git_remote_supported_url(const char* url)
 	return fn != &git_transport_dummy;
 }
 
-int git_transport_init(git_transport* opts, int version)
+int git_transport_init(git_transport *opts, unsigned int version)
 {
-	if (version != GIT_TRANSPORT_VERSION) {
-		giterr_set(GITERR_INVALID, "Invalid version %d for git_transport", version);
-		return -1;
-	} else {
-		git_transport o = GIT_TRANSPORT_INIT;
-		memcpy(opts, &o, sizeof(o));
-		return 0;
-	}
+	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
+		opts, version, git_transport, GIT_TRANSPORT_INIT);
+	return 0;
 }
diff --git a/tests/structinit/structinit.c b/tests/structinit/structinit.c
index 2942099dd..38bedada7 100644
--- a/tests/structinit/structinit.c
+++ b/tests/structinit/structinit.c
@@ -48,7 +48,7 @@ void test_structinit_structinit__compare(void)
 	/* checkout */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
 		git_checkout_options, GIT_CHECKOUT_OPTIONS_VERSION, \
-		GIT_CHECKOUT_OPTIONS_INIT, git_checkout_init_opts);
+		GIT_CHECKOUT_OPTIONS_INIT, git_checkout_init_options);
 
 	/* clone */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
@@ -98,7 +98,7 @@ void test_structinit_structinit__compare(void)
 	/* revert */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
 		git_revert_options, GIT_REVERT_OPTIONS_VERSION, \
-		GIT_REVERT_OPTIONS_INIT, git_revert_init_opts);
+		GIT_REVERT_OPTIONS_INIT, git_revert_init_options);
 
 	/* status */
 	CHECK_MACRO_FUNC_INIT_EQUAL( \
-- 
cgit v1.2.3


From 0f603132bc2397bf8308e72651c56cb7dbd3ad70 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 1 May 2014 14:47:33 -0700
Subject: Improve handling of fake home directory

There are a few tests that set up a fake home directory and a
fake GLOBAL search path so that we can test things in global
ignore or attribute or config files.  This cleans up that code to
work more robustly even if there is a test failure.  This also
fixes some valgrind warnings where scanning search paths for
separators could end up doing a little bit of sketchy data access
when coming to the end of search list.
---
 src/config.c          | 18 ++++++++----------
 src/sysdir.c          | 16 +++++++++++-----
 tests/attr/ignore.c   |  5 ++---
 tests/clar_libgit2.c  | 31 +++++++++++++++++++++----------
 tests/clar_libgit2.h  |  9 +++++++--
 tests/config/global.c | 35 +++++++++++++++++++++++++++--------
 tests/status/ignore.c |  5 +----
 7 files changed, 77 insertions(+), 42 deletions(-)

diff --git a/src/config.c b/src/config.c
index ee92398fc..f9d697197 100644
--- a/src/config.c
+++ b/src/config.c
@@ -984,24 +984,22 @@ int git_config__global_location(git_buf *buf)
 {
 	const git_buf *paths;
 	const char *sep, *start;
-	size_t len;
 
 	if (git_sysdir_get(&paths, GIT_SYSDIR_GLOBAL) < 0)
 		return -1;
 
 	/* no paths, so give up */
-	if (git_buf_len(paths) == 0)
+	if (!paths || !git_buf_len(paths))
 		return -1;
 
-	start = git_buf_cstr(paths);
-	sep = strchr(start, GIT_PATH_LIST_SEPARATOR);
-
-	if (sep)
-		len = sep - start;
-	else
-		len = paths->size;
+	/* find unescaped separator or end of string */
+	for (sep = start = git_buf_cstr(paths); *sep; ++sep) {
+		if (*sep == GIT_PATH_LIST_SEPARATOR &&
+			(sep <= start || sep[-1] != '\\'))
+			break;
+	}
 
-	if (git_buf_set(buf, start, len) < 0)
+	if (git_buf_set(buf, start, (size_t)(sep - start)) < 0)
 		return -1;
 
 	return git_buf_joinpath(buf, buf->ptr, GIT_CONFIG_FILENAME_GLOBAL);
diff --git a/src/sysdir.c b/src/sysdir.c
index aebf23135..e0c24f3b3 100644
--- a/src/sysdir.c
+++ b/src/sysdir.c
@@ -194,14 +194,19 @@ static int git_sysdir_find_in_dirlist(
 	const git_buf *syspath;
 
 	GITERR_CHECK_ERROR(git_sysdir_get(&syspath, which));
+	if (!syspath || !git_buf_len(syspath))
+		goto done;
 
 	for (scan = git_buf_cstr(syspath); scan; scan = next) {
-		for (next = strchr(scan, GIT_PATH_LIST_SEPARATOR);
-			 next && next > scan && next[-1] == '\\';
-			 next = strchr(next + 1, GIT_PATH_LIST_SEPARATOR))
-			/* find unescaped separator or end of string */;
+		/* find unescaped separator or end of string */
+		for (next = scan; *next; ++next) {
+			if (*next == GIT_PATH_LIST_SEPARATOR &&
+				(next <= scan || next[-1] != '\\'))
+				break;
+		}
 
-		len = next ? (size_t)(next++ - scan) : strlen(scan);
+		len = (size_t)(next - scan);
+		next = (*next ? next + 1 : NULL);
 		if (!len)
 			continue;
 
@@ -213,6 +218,7 @@ static int git_sysdir_find_in_dirlist(
 			return 0;
 	}
 
+done:
 	git_buf_free(path);
 	giterr_set(GITERR_OS, "The %s file '%s' doesn't exist", label, name);
 	return GIT_ENOTFOUND;
diff --git a/tests/attr/ignore.c b/tests/attr/ignore.c
index 5eadc7b3e..b187db01c 100644
--- a/tests/attr/ignore.c
+++ b/tests/attr/ignore.c
@@ -148,12 +148,11 @@ void test_attr_ignore__skip_gitignore_directory(void)
 
 void test_attr_ignore__expand_tilde_to_homedir(void)
 {
-	git_buf cleanup = GIT_BUF_INIT;
 	git_config *cfg;
 
 	assert_is_ignored(false, "example.global_with_tilde");
 
-	cl_fake_home(&cleanup);
+	cl_fake_home();
 
 	/* construct fake home with fake global excludes */
 	cl_git_mkfile("home/globalexclude", "# found me\n*.global_with_tilde\n");
@@ -168,7 +167,7 @@ void test_attr_ignore__expand_tilde_to_homedir(void)
 
 	cl_git_pass(git_futils_rmdir_r("home", NULL, GIT_RMDIR_REMOVE_FILES));
 
-	cl_fake_home_cleanup(&cleanup);
+	cl_fake_home_cleanup(NULL);
 
 	git_attr_cache_flush(g_repo); /* must reset to pick up change */
 
diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c
index 6f6143dad..9ec9a6419 100644
--- a/tests/clar_libgit2.c
+++ b/tests/clar_libgit2.c
@@ -484,23 +484,34 @@ void clar__assert_equal_file(
 		(size_t)expected_bytes, (size_t)total_bytes);
 }
 
-void cl_fake_home(git_buf *restore)
+static char *_cl_restore_home = NULL;
+
+void cl_fake_home_cleanup(void *payload)
+{
+	char *restore = _cl_restore_home;
+	_cl_restore_home = NULL;
+
+	GIT_UNUSED(payload);
+
+	cl_git_pass(git_libgit2_opts(
+		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore));
+	git__free(restore);
+}
+
+void cl_fake_home(void)
 {
 	git_buf path = GIT_BUF_INIT;
 
 	cl_git_pass(git_libgit2_opts(
-		GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore));
+		GIT_OPT_GET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, &path));
+
+	_cl_restore_home = git_buf_detach(&path);
+	cl_set_cleanup(cl_fake_home_cleanup, NULL);
 
-	cl_must_pass(p_mkdir("home", 0777));
+	if (!git_path_exists("home"))
+		cl_must_pass(p_mkdir("home", 0777));
 	cl_git_pass(git_path_prettify(&path, "home", NULL));
 	cl_git_pass(git_libgit2_opts(
 		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr));
 	git_buf_free(&path);
 }
-
-void cl_fake_home_cleanup(git_buf *restore)
-{
-	cl_git_pass(git_libgit2_opts(
-		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore->ptr));
-	git_buf_free(restore);
-}
diff --git a/tests/clar_libgit2.h b/tests/clar_libgit2.h
index 082fa9f4a..f84d9e353 100644
--- a/tests/clar_libgit2.h
+++ b/tests/clar_libgit2.h
@@ -131,7 +131,12 @@ int cl_repo_get_bool(git_repository *repo, const char *cfg);
 
 void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value);
 
-void cl_fake_home(git_buf *restore);
-void cl_fake_home_cleanup(git_buf *restore);
+/* set up a fake "home" directory and set libgit2 GLOBAL search path.
+ *
+ * automatically configures cleanup function to restore the regular search
+ * path, although you can call it explicitly if you wish (with NULL).
+ */
+void cl_fake_home(void);
+void cl_fake_home_cleanup(void *);
 
 #endif
diff --git a/tests/config/global.c b/tests/config/global.c
index d5f95f504..006b34628 100644
--- a/tests/config/global.c
+++ b/tests/config/global.c
@@ -2,22 +2,36 @@
 #include "buffer.h"
 #include "fileops.h"
 
+static git_config_level_t setting[3] = {
+	GIT_CONFIG_LEVEL_GLOBAL,
+	GIT_CONFIG_LEVEL_XDG,
+	GIT_CONFIG_LEVEL_SYSTEM
+};
+static char *restore[3];
+
 void test_config_global__initialize(void)
 {
+	int i;
 	git_buf path = GIT_BUF_INIT;
 
-	cl_assert_equal_i(0, p_mkdir("home", 0777));
+	/* snapshot old settings to restore later */
+	for (i = 0; i < 3; ++i) {
+		cl_git_pass(
+			git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, setting[i], &path));
+		restore[i] = git_buf_detach(&path);
+	}
+
+	cl_git_pass(git_futils_mkdir_r("home", NULL, 0777));
 	cl_git_pass(git_path_prettify(&path, "home", NULL));
 	cl_git_pass(git_libgit2_opts(
 		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr));
 
-	cl_assert_equal_i(0, p_mkdir("xdg", 0777));
-	cl_assert_equal_i(0, p_mkdir("xdg/git", 0777));
+	cl_git_pass(git_futils_mkdir_r("xdg/git", NULL, 0777));
 	cl_git_pass(git_path_prettify(&path, "xdg/git", NULL));
 	cl_git_pass(git_libgit2_opts(
 		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, path.ptr));
 
-	cl_assert_equal_i(0, p_mkdir("etc", 0777));
+	cl_git_pass(git_futils_mkdir_r("etc", NULL, 0777));
 	cl_git_pass(git_path_prettify(&path, "etc", NULL));
 	cl_git_pass(git_libgit2_opts(
 		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, path.ptr));
@@ -27,13 +41,18 @@ void test_config_global__initialize(void)
 
 void test_config_global__cleanup(void)
 {
+	int i;
+
+	for (i = 0; i < 3; ++i) {
+		cl_git_pass(
+			git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, setting[i], restore[i]));
+		git__free(restore[i]);
+		restore[i] = NULL;
+	}
+
 	cl_git_pass(git_futils_rmdir_r("home", NULL, GIT_RMDIR_REMOVE_FILES));
 	cl_git_pass(git_futils_rmdir_r("xdg", NULL, GIT_RMDIR_REMOVE_FILES));
 	cl_git_pass(git_futils_rmdir_r("etc", NULL, GIT_RMDIR_REMOVE_FILES));
-
-	git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, NULL);
-	git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, NULL);
-	git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, NULL);
 }
 
 void test_config_global__open_global(void)
diff --git a/tests/status/ignore.c b/tests/status/ignore.c
index d88b2eb6b..caa1f1927 100644
--- a/tests/status/ignore.c
+++ b/tests/status/ignore.c
@@ -364,7 +364,6 @@ void test_status_ignore__leading_slash_ignores(void)
 {
 	git_status_options opts = GIT_STATUS_OPTIONS_INIT;
 	status_entry_counts counts;
-	git_buf home = GIT_BUF_INIT;
 	static const char *paths_2[] = {
 		"dir/.gitignore",
 		"dir/a/ignore_me",
@@ -385,7 +384,7 @@ void test_status_ignore__leading_slash_ignores(void)
 
 	make_test_data(test_repo_1, test_files_1);
 
-	cl_fake_home(&home);
+	cl_fake_home();
 	cl_git_mkfile("home/.gitignore", "/ignore_me\n");
 	{
 		git_config *cfg;
@@ -412,8 +411,6 @@ void test_status_ignore__leading_slash_ignores(void)
 	cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
 	cl_assert_equal_i(0, counts.wrong_status_flags_count);
 	cl_assert_equal_i(0, counts.wrong_sorted_path);
-
-	cl_fake_home_cleanup(&home);
 }
 
 void test_status_ignore__contained_dir_with_matching_name(void)
-- 
cgit v1.2.3


From 99dfa470398b9c4e06e5a5ee61868d3b9e21b26e Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 1 May 2014 15:12:12 -0700
Subject: Some further sandboxing cleanups to tests

Trying to find other issues where tests may not clean up quite
properly when they are through...
---
 tests/attr/repo.c            |  5 -----
 tests/clar_libgit2.c         |  8 +++++---
 tests/refs/branches/create.c |  9 +++------
 tests/refs/branches/delete.c |  7 ++-----
 tests/refs/branches/ishead.c | 24 +++---------------------
 5 files changed, 13 insertions(+), 40 deletions(-)

diff --git a/tests/attr/repo.c b/tests/attr/repo.c
index 9aab7ed96..5e812a72b 100644
--- a/tests/attr/repo.c
+++ b/tests/attr/repo.c
@@ -9,11 +9,6 @@ static git_repository *g_repo = NULL;
 
 void test_attr_repo__initialize(void)
 {
-	/* Before each test, instantiate the attr repo from the fixtures and
-	 * rename the .gitted to .git so it is a repo with a working dir.
-	 * Also rename gitattributes to .gitattributes, because it contains
-	 * macro definitions which are only allowed in the root.
-	 */
 	g_repo = cl_git_sandbox_init("attr");
 }
 
diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c
index 9ec9a6419..f457adb33 100644
--- a/tests/clar_libgit2.c
+++ b/tests/clar_libgit2.c
@@ -493,9 +493,11 @@ void cl_fake_home_cleanup(void *payload)
 
 	GIT_UNUSED(payload);
 
-	cl_git_pass(git_libgit2_opts(
-		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore));
-	git__free(restore);
+	if (restore) {
+		cl_git_pass(git_libgit2_opts(
+			GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, restore));
+		git__free(restore);
+	}
 }
 
 void cl_fake_home(void)
diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index b91eed6e8..38af2f681 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -7,10 +7,9 @@ static git_reference *branch;
 
 void test_refs_branches_create__initialize(void)
 {
-	cl_fixture_sandbox("testrepo.git");
-	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
-
+	repo = cl_git_sandbox_init("testrepo.git");
 	branch = NULL;
+	target = NULL;
 }
 
 void test_refs_branches_create__cleanup(void)
@@ -21,10 +20,8 @@ void test_refs_branches_create__cleanup(void)
 	git_commit_free(target);
 	target = NULL;
 
-	git_repository_free(repo);
+	cl_git_sandbox_cleanup();
 	repo = NULL;
-
-	cl_fixture_cleanup("testrepo.git");
 }
 
 static void retrieve_target_from_oid(git_commit **out, git_repository *repo, const char *sha)
diff --git a/tests/refs/branches/delete.c b/tests/refs/branches/delete.c
index ed5f1627b..e3199e230 100644
--- a/tests/refs/branches/delete.c
+++ b/tests/refs/branches/delete.c
@@ -10,8 +10,7 @@ void test_refs_branches_delete__initialize(void)
 {
 	git_oid id;
 
-	cl_fixture_sandbox("testrepo.git");
-	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
+	repo = cl_git_sandbox_init("testrepo.git");
 
 	cl_git_pass(git_oid_fromstr(&id, "be3563ae3f795b2b4353bcce3a527ad0a4f7f644"));
 	cl_git_pass(git_reference_create(&fake_remote, repo, "refs/remotes/nulltoken/master", &id, 0, NULL, NULL));
@@ -22,10 +21,8 @@ void test_refs_branches_delete__cleanup(void)
 	git_reference_free(fake_remote);
 	fake_remote = NULL;
 
-	git_repository_free(repo);
+	cl_git_sandbox_cleanup();
 	repo = NULL;
-
-	cl_fixture_cleanup("testrepo.git");
 }
 
 void test_refs_branches_delete__can_not_delete_a_branch_pointed_at_by_HEAD(void)
diff --git a/tests/refs/branches/ishead.c b/tests/refs/branches/ishead.c
index 12a8c4449..d16a79652 100644
--- a/tests/refs/branches/ishead.c
+++ b/tests/refs/branches/ishead.c
@@ -7,7 +7,8 @@ static git_reference *branch;
 
 void test_refs_branches_ishead__initialize(void)
 {
-	cl_git_pass(git_repository_open(&repo, cl_fixture("testrepo.git")));
+	repo = cl_git_sandbox_init("testrepo.git");
+	branch = NULL;
 }
 
 void test_refs_branches_ishead__cleanup(void)
@@ -15,7 +16,7 @@ void test_refs_branches_ishead__cleanup(void)
 	git_reference_free(branch);
 	branch = NULL;
 
-	git_repository_free(repo);
+	cl_git_sandbox_cleanup();
 	repo = NULL;
 }
 
@@ -28,34 +29,20 @@ void test_refs_branches_ishead__can_tell_if_a_branch_is_pointed_at_by_HEAD(void)
 
 void test_refs_branches_ishead__can_properly_handle_unborn_HEAD(void)
 {
-	git_repository_free(repo);
-
-	repo = cl_git_sandbox_init("testrepo.git");
-
 	make_head_unborn(repo, NON_EXISTING_HEAD);
 
 	cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master"));
 
 	cl_assert_equal_i(false, git_branch_is_head(branch));
-
-	cl_git_sandbox_cleanup();
-	repo = NULL;
 }
 
 void test_refs_branches_ishead__can_properly_handle_missing_HEAD(void)
 {
-	git_repository_free(repo);
-
-	repo = cl_git_sandbox_init("testrepo.git");
-
 	delete_head(repo);
 
 	cl_git_pass(git_reference_lookup(&branch, repo, "refs/heads/master"));
 
 	cl_assert_equal_i(false, git_branch_is_head(branch));
-
-	cl_git_sandbox_cleanup();
-	repo = NULL;
 }
 
 void test_refs_branches_ishead__can_tell_if_a_branch_is_not_pointed_at_by_HEAD(void)
@@ -95,9 +82,6 @@ void test_refs_branches_ishead__only_direct_references_are_considered(void)
 {
 	git_reference *linked, *super, *head;
 
-	git_repository_free(repo);
-	repo = cl_git_sandbox_init("testrepo.git");
-
 	cl_git_pass(git_reference_symbolic_create(&linked, repo, "refs/heads/linked", "refs/heads/master", 0, NULL, NULL));
 	cl_git_pass(git_reference_symbolic_create(&super, repo, "refs/heads/super", "refs/heads/linked", 0, NULL, NULL));
 	cl_git_pass(git_reference_symbolic_create(&head, repo, GIT_HEAD_FILE, "refs/heads/super", 1, NULL, NULL));
@@ -111,6 +95,4 @@ void test_refs_branches_ishead__only_direct_references_are_considered(void)
 	git_reference_free(linked);
 	git_reference_free(super);
 	git_reference_free(head);
-	cl_git_sandbox_cleanup();
-	repo = NULL;
 }
-- 
cgit v1.2.3


From d2c16e9ac4921e94eb5db972e6b8452d71a623fc Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 2 May 2014 15:15:43 -0700
Subject: Doc fixes

---
 include/git2/merge.h  | 4 ++--
 include/git2/object.h | 5 +++++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index ef2dc3804..abbc3a5bb 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -61,7 +61,7 @@ GIT_EXTERN(int) git_merge_file_init_input(
 
 /**
  * Flags for `git_merge_tree` options.  A combination of these flags can be
- * passed in via the `flags` value in the `git_merge_tree_opts`.
+ * passed in via the `flags` value in the `git_merge_options`.
  */
 typedef enum {
 	/**
@@ -73,7 +73,7 @@ typedef enum {
 } git_merge_tree_flag_t;
 
 /**
- * Merge file favor options for `git_merge_trees_opts` instruct the file-level
+ * Merge file favor options for `git_merge_options` instruct the file-level
  * merging functionality how to deal with conflicting regions of the files.
  */
 typedef enum {
diff --git a/include/git2/object.h b/include/git2/object.h
index 7417ea913..9b13d824e 100644
--- a/include/git2/object.h
+++ b/include/git2/object.h
@@ -107,6 +107,11 @@ GIT_EXTERN(const git_oid *) git_object_id(const git_object *obj);
 /**
  * Get a short abbreviated OID string for the object
  *
+ * This starts at the "core.abbrev" length (default 7 characters) and
+ * iteratively extends to a longer string if that length is ambiguous.
+ * The result will be unambiguous (at least until new objects are added to
+ * the repository).
+ *
  * @param out Buffer to write string into
  * @param obj The object to get an ID for
  * @return 0 on success, <0 for error
-- 
cgit v1.2.3


From ee311907ee0299ff2c1d7fc37699dc3e4da20c52 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 5 May 2014 16:04:14 +0200
Subject: odb: ignore files in the objects dir

We assume that everything under GIT_DIR/objects/ is a directory. This is
not necessarily the case if some process left a stray file in there.

Check beforehand if we do have a directory and ignore the entry
otherwise.
---
 src/odb_loose.c     |  4 ++++
 tests/odb/foreach.c | 24 ++++++++++++++++++++++++
 2 files changed, 28 insertions(+)

diff --git a/src/odb_loose.c b/src/odb_loose.c
index 7b46a6652..b2e8bed4d 100644
--- a/src/odb_loose.c
+++ b/src/odb_loose.c
@@ -755,6 +755,10 @@ static int foreach_cb(void *_state, git_buf *path)
 {
 	struct foreach_state *state = (struct foreach_state *) _state;
 
+	/* non-dir is some stray file, ignore it */
+	if (!git_path_isdir(git_buf_cstr(path)))
+		return 0;
+
 	return git_path_direach(path, 0, foreach_object_dir_cb, state);
 }
 
diff --git a/tests/odb/foreach.c b/tests/odb/foreach.c
index 256ae9cd7..ab3808b00 100644
--- a/tests/odb/foreach.c
+++ b/tests/odb/foreach.c
@@ -2,6 +2,7 @@
 #include "odb.h"
 #include "git2/odb_backend.h"
 #include "pack.h"
+#include "buffer.h"
 
 static git_odb *_odb;
 static git_repository *_repo;
@@ -80,3 +81,26 @@ void test_odb_foreach__interrupt_foreach(void)
 	cl_assert_equal_i(-321, git_odb_foreach(_odb, foreach_stop_cb, &nobj));
 	cl_assert(nobj == 1000);
 }
+
+void test_odb_foreach__files_in_objects_dir(void)
+{
+	git_repository *repo;
+	git_odb *odb;
+	git_buf buf = GIT_BUF_INIT;
+	size_t nobj = 0;
+
+	cl_fixture_sandbox("testrepo.git");
+	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
+
+	cl_git_pass(git_buf_printf(&buf, "%s/objects/somefile", git_repository_path(repo)));
+
+	cl_git_mkfile(buf.ptr, "");
+
+	cl_git_pass(git_repository_odb(&odb, repo));
+	cl_git_pass(git_odb_foreach(odb, foreach_cb, &nobj));
+	cl_assert_equal_i(47 + 1640, nobj); /* count + in-pack */
+
+	git_odb_free(odb);
+	git_repository_free(repo);
+	cl_fixture_cleanup("testrepo.git");
+}
-- 
cgit v1.2.3


From 001befcdd5a208a046e0196e3fec7b16041cfe14 Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Tue, 6 May 2014 12:16:24 -0700
Subject: Fix the issues in git__on_shutdown

---
 src/global.c | 12 +++++++-----
 src/sysdir.c |  2 ++
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/global.c b/src/global.c
index 15baf1eb8..a64dce9ef 100644
--- a/src/global.c
+++ b/src/global.c
@@ -23,7 +23,7 @@ static git_atomic git__n_inits;
 void git__on_shutdown(git_global_shutdown_fn callback)
 {
 	int count = git_atomic_inc(&git__n_shutdown_callbacks);
-	assert(count <= MAX_SHUTDOWN_CB);
+	assert(count <= MAX_SHUTDOWN_CB && count > 0);
 	git__shutdown_callbacks[count - 1] = callback;
 }
 
@@ -31,10 +31,12 @@ static void git__shutdown(void)
 {
 	int pos;
 
-	while ((pos = git_atomic_dec(&git__n_shutdown_callbacks)) >= 0) {
-		if (git__shutdown_callbacks[pos])
-			git__shutdown_callbacks[pos]();
-	}
+	for (pos = git_atomic_get(&git__n_shutdown_callbacks); pos > 0; pos = git_atomic_dec(&git__n_shutdown_callbacks))
+		if (git__shutdown_callbacks[pos - 1]) {
+			git__shutdown_callbacks[pos - 1]();
+			git__shutdown_callbacks[pos - 1] = NULL;
+		}
+
 }
 
 /**
diff --git a/src/sysdir.c b/src/sysdir.c
index e0c24f3b3..cd94a8b57 100644
--- a/src/sysdir.c
+++ b/src/sysdir.c
@@ -90,6 +90,8 @@ void git_sysdir_global_shutdown(void)
 	int i;
 	for (i = 0; i < GIT_SYSDIR__MAX; ++i)
 		git_buf_free(&git_sysdir__dirs[i]);
+
+	git_sysdir__dirs_shutdown_set = 0;
 }
 
 static int git_sysdir_check_selector(git_sysdir_t which)
-- 
cgit v1.2.3


From 6e9afb97d14545f9cea292f581de89d610ae8c07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 6 May 2014 21:14:58 +0200
Subject: object: fix a brace

The brace in the check for peel's return was surrounding the wrong
thing, which made 'error' be set to 1 when there was an error instead of
the error code.
---
 src/object.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/object.c b/src/object.c
index 3847a0739..93068b85f 100644
--- a/src/object.c
+++ b/src/object.c
@@ -375,7 +375,7 @@ int git_object_lookup_bypath(
 
 	assert(out && treeish && path);
 
-	if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJ_TREE) < 0) ||
+	if ((error = git_object_peel((git_object**)&tree, treeish, GIT_OBJ_TREE)) < 0 ||
 		 (error = git_tree_entry_bypath(&entry, tree, path)) < 0)
 	{
 		goto cleanup;
-- 
cgit v1.2.3


From f554611a274aafd702bd899f4663c16eb76ae8f0 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 6 May 2014 12:41:26 -0700
Subject: Improve checks for ignore containment

The diff code was using an "ignored_prefix" directory to track if
a parent directory was ignored that contained untracked files
alongside tracked files. Unfortunately, when negative ignore rules
were used for directories inside ignored parents, the wrong rules
were applied to untracked files inside the negatively ignored
child directories.

This commit moves the logic for ignore containment into the workdir
iterator (which is a better place for it), so the ignored-ness of
a directory is contained in the frame stack during traversal.  This
allows a child directory to override with a negative ignore and yet
still restore the ignored state of the parent when we traverse out
of the child.

Along with this, there are some problems with "directory only"
ignore rules on container directories.  Given "a/*" and "!a/b/c/"
(where the second rule is a directory rule but the first rule is
just a generic prefix rule), then the directory only constraint
was having "a/b/c/d/file" match the first rule and not the second.
This was fixed by having ignore directory-only rules test a rule
against the prefix of a file with LEADINGDIR enabled.

Lastly, spot checks for ignores using `git_ignore_path_is_ignored`
were tested from the top directory down to the bottom to deal with
the containment problem, but this is wrong. We have to test bottom
to top so that negative subdirectory rules will be checked before
parent ignore rules.

This does change the behavior of some existing tests, but it seems
only to bring us more in line with core Git, so I think those
changes are acceptable.
---
 src/attr_file.c       |  25 +++++++++---
 src/attr_file.h       |   6 +--
 src/diff.c            |  40 +++----------------
 src/ignore.c          |  69 +++++++++++++-------------------
 src/ignore.h          |   9 ++++-
 src/iterator.c        |  66 ++++++++++++++++++++++---------
 src/iterator.h        |   2 +
 tests/diff/iterator.c |   2 +-
 tests/status/ignore.c | 107 ++++++++++++++++++++++++++++++++++++++++++++++++++
 9 files changed, 220 insertions(+), 106 deletions(-)

diff --git a/src/attr_file.c b/src/attr_file.c
index 156a23d91..3e95a2134 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -281,7 +281,7 @@ uint32_t git_attr_file__name_hash(const char *name)
 
 int git_attr_file__lookup_one(
 	git_attr_file *file,
-	const git_attr_path *path,
+	git_attr_path *path,
 	const char *attr,
 	const char **value)
 {
@@ -342,14 +342,11 @@ int git_attr_file__load_standalone(git_attr_file **out, const char *path)
 
 bool git_attr_fnmatch__match(
 	git_attr_fnmatch *match,
-	const git_attr_path *path)
+	git_attr_path *path)
 {
 	const char *filename;
 	int flags = 0;
 
-	if ((match->flags & GIT_ATTR_FNMATCH_DIRECTORY) && !path->is_dir)
-		return false;
-
 	if (match->flags & GIT_ATTR_FNMATCH_ICASE)
 		flags |= FNM_CASEFOLD;
 	if (match->flags & GIT_ATTR_FNMATCH_LEADINGDIR)
@@ -365,12 +362,28 @@ bool git_attr_fnmatch__match(
 			flags |= FNM_LEADING_DIR;
 	}
 
+	if ((match->flags & GIT_ATTR_FNMATCH_DIRECTORY) && !path->is_dir) {
+		int matchval;
+
+		/* for attribute checks or root ignore checks, fail match */
+		if (!(match->flags & GIT_ATTR_FNMATCH_IGNORE) ||
+			path->basename == path->path)
+			return false;
+
+		/* for ignore checks, use container of current item for check */
+		path->basename[-1] = '\0';
+		flags |= FNM_LEADING_DIR;
+		matchval = p_fnmatch(match->pattern, path->path, flags);
+		path->basename[-1] = '/';
+		return (matchval != FNM_NOMATCH);
+	}
+
 	return (p_fnmatch(match->pattern, filename, flags) != FNM_NOMATCH);
 }
 
 bool git_attr_rule__match(
 	git_attr_rule *rule,
-	const git_attr_path *path)
+	git_attr_path *path)
 {
 	bool matched = git_attr_fnmatch__match(&rule->match, path);
 
diff --git a/src/attr_file.h b/src/attr_file.h
index e50aec07c..87cde7e35 100644
--- a/src/attr_file.h
+++ b/src/attr_file.h
@@ -138,7 +138,7 @@ int git_attr_file__clear_rules(
 
 int git_attr_file__lookup_one(
 	git_attr_file *file,
-	const git_attr_path *path,
+	git_attr_path *path,
 	const char *attr,
 	const char **value);
 
@@ -162,13 +162,13 @@ extern int git_attr_fnmatch__parse(
 
 extern bool git_attr_fnmatch__match(
 	git_attr_fnmatch *rule,
-	const git_attr_path *path);
+	git_attr_path *path);
 
 extern void git_attr_rule__free(git_attr_rule *rule);
 
 extern bool git_attr_rule__match(
 	git_attr_rule *rule,
-	const git_attr_path *path);
+	git_attr_path *path);
 
 extern git_attr_assignment *git_attr_rule__lookup_assignment(
 	git_attr_rule *rule, const char *name);
diff --git a/src/diff.c b/src/diff.c
index 781f23ec6..0864dfc40 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -632,7 +632,6 @@ typedef struct {
 	git_iterator *new_iter;
 	const git_index_entry *oitem;
 	const git_index_entry *nitem;
-	git_buf ignore_prefix;
 } diff_in_progress;
 
 #define MODE_BITS_MASK 0000777
@@ -843,24 +842,13 @@ static int handle_unmatched_new_item(
 	/* check if this is a prefix of the other side */
 	contains_oitem = entry_is_prefixed(diff, info->oitem, nitem);
 
-	/* check if this is contained in an ignored parent directory */
-	if (git_buf_len(&info->ignore_prefix)) {
-		if (diff->pfxcomp(nitem->path, git_buf_cstr(&info->ignore_prefix)) == 0)
-			delta_type = GIT_DELTA_IGNORED;
-		else
-			git_buf_clear(&info->ignore_prefix);
-	}
+	/* update delta_type if this item is ignored */
+	if (git_iterator_current_is_ignored(info->new_iter))
+		delta_type = GIT_DELTA_IGNORED;
 
 	if (nitem->mode == GIT_FILEMODE_TREE) {
 		bool recurse_into_dir = contains_oitem;
 
-		/* if not already inside an ignored dir, check if this is ignored */
-		if (delta_type != GIT_DELTA_IGNORED &&
-			git_iterator_current_is_ignored(info->new_iter)) {
-			delta_type = GIT_DELTA_IGNORED;
-			git_buf_sets(&info->ignore_prefix, nitem->path);
-		}
-
 		/* check if user requests recursion into this type of dir */
 		recurse_into_dir = contains_oitem ||
 			(delta_type == GIT_DELTA_UNTRACKED &&
@@ -937,27 +925,12 @@ static int handle_unmatched_new_item(
 		}
 	}
 
-	/* In core git, the next two checks are effectively reversed --
-	 * i.e. when an file contained in an ignored directory is explicitly
-	 * ignored, it shows up as an ignored file in the diff list, even though
-	 * other untracked files in the same directory are skipped completely.
-	 *
-	 * To me, this seems odd.  If the directory is ignored and the file is
-	 * untracked, we should skip it consistently, regardless of whether it
-	 * happens to match a pattern in the ignore file.
-	 *
-	 * To match the core git behavior, reverse the following two if checks
-	 * so that individual file ignores are checked before container
-	 * directory exclusions are used to skip the file.
-	 */
 	else if (delta_type == GIT_DELTA_IGNORED &&
-		DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_RECURSE_IGNORED_DIRS))
+		DIFF_FLAG_ISNT_SET(diff, GIT_DIFF_RECURSE_IGNORED_DIRS) &&
+		git_iterator_current_tree_is_ignored(info->new_iter))
 		/* item contained in ignored directory, so skip over it */
 		return git_iterator_advance(&info->nitem, info->new_iter);
 
-	else if (git_iterator_current_is_ignored(info->new_iter))
-		delta_type = GIT_DELTA_IGNORED;
-
 	else if (info->new_iter->type != GIT_ITERATOR_TYPE_WORKDIR)
 		delta_type = GIT_DELTA_ADDED;
 
@@ -1067,7 +1040,6 @@ int git_diff__from_iterators(
 	info.repo = repo;
 	info.old_iter = old_iter;
 	info.new_iter = new_iter;
-	git_buf_init(&info.ignore_prefix, 0);
 
 	/* make iterators have matching icase behavior */
 	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_IGNORE_CASE)) {
@@ -1122,8 +1094,6 @@ cleanup:
 	else
 		git_diff_free(diff);
 
-	git_buf_free(&info.ignore_prefix);
-
 	return error;
 }
 
diff --git a/src/ignore.c b/src/ignore.c
index f373c9482..78f01ac44 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -248,14 +248,15 @@ void git_ignore__free(git_ignores *ignores)
 }
 
 static bool ignore_lookup_in_rules(
-	git_attr_file *file, git_attr_path *path, int *ignored)
+	int *ignored, git_attr_file *file, git_attr_path *path)
 {
 	size_t j;
 	git_attr_fnmatch *match;
 
 	git_vector_rforeach(&file->rules, j, match) {
 		if (git_attr_fnmatch__match(match, path)) {
-			*ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0);
+			*ignored = ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) == 0) ?
+				GIT_IGNORE_TRUE : GIT_IGNORE_FALSE;
 			return true;
 		}
 	}
@@ -264,34 +265,34 @@ static bool ignore_lookup_in_rules(
 }
 
 int git_ignore__lookup(
-	git_ignores *ignores, const char *pathname, int *ignored)
+	int *out, git_ignores *ignores, const char *pathname)
 {
 	unsigned int i;
 	git_attr_file *file;
 	git_attr_path path;
 
+	*out = GIT_IGNORE_NOTFOUND;
+
 	if (git_attr_path__init(
 		&path, pathname, git_repository_workdir(ignores->repo)) < 0)
 		return -1;
 
 	/* first process builtins - success means path was found */
-	if (ignore_lookup_in_rules(ignores->ign_internal, &path, ignored))
+	if (ignore_lookup_in_rules(out, ignores->ign_internal, &path))
 		goto cleanup;
 
 	/* next process files in the path */
 	git_vector_foreach(&ignores->ign_path, i, file) {
-		if (ignore_lookup_in_rules(file, &path, ignored))
+		if (ignore_lookup_in_rules(out, file, &path))
 			goto cleanup;
 	}
 
 	/* last process global ignores */
 	git_vector_foreach(&ignores->ign_global, i, file) {
-		if (ignore_lookup_in_rules(file, &path, ignored))
+		if (ignore_lookup_in_rules(out, file, &path))
 			goto cleanup;
 	}
 
-	*ignored = 0;
-
 cleanup:
 	git_attr_path__free(&path);
 	return 0;
@@ -335,8 +336,6 @@ int git_ignore_path_is_ignored(
 	int error;
 	const char *workdir;
 	git_attr_path path;
-	char *tail, *end;
-	bool full_is_dir;
 	git_ignores ignores;
 	unsigned int i;
 	git_attr_file *file;
@@ -345,55 +344,42 @@ int git_ignore_path_is_ignored(
 
 	workdir = repo ? git_repository_workdir(repo) : NULL;
 
-	if ((error = git_attr_path__init(&path, pathname, workdir)) < 0)
-		return error;
+	memset(&path, 0, sizeof(path));
+	memset(&ignores, 0, sizeof(ignores));
 
-	tail = path.path;
-	end  = &path.full.ptr[path.full.size];
-	full_is_dir = path.is_dir;
+	if ((error = git_attr_path__init(&path, pathname, workdir)) < 0 ||
+		(error = git_ignore__for_path(repo, path.path, &ignores)) < 0)
+		goto cleanup;
 
 	while (1) {
-		/* advance to next component of path */
-		path.basename = tail;
-
-		while (tail < end && *tail != '/') tail++;
-		*tail = '\0';
-
-		path.full.size = (tail - path.full.ptr);
-		path.is_dir = (tail == end) ? full_is_dir : true;
-
-		/* initialize ignores the first time through */
-		if (path.basename == path.path &&
-			(error = git_ignore__for_path(repo, path.path, &ignores)) < 0)
-			break;
-
 		/* first process builtins - success means path was found */
-		if (ignore_lookup_in_rules(ignores.ign_internal, &path, ignored))
+		if (ignore_lookup_in_rules(ignored, ignores.ign_internal, &path))
 			goto cleanup;
 
 		/* next process files in the path */
 		git_vector_foreach(&ignores.ign_path, i, file) {
-			if (ignore_lookup_in_rules(file, &path, ignored))
+			if (ignore_lookup_in_rules(ignored, file, &path))
 				goto cleanup;
 		}
 
 		/* last process global ignores */
 		git_vector_foreach(&ignores.ign_global, i, file) {
-			if (ignore_lookup_in_rules(file, &path, ignored))
+			if (ignore_lookup_in_rules(ignored, file, &path))
 				goto cleanup;
 		}
 
-		/* if we found no rules before reaching the end, we're done */
-		if (tail == end)
+		/* move up one directory */
+		if (path.basename == path.path)
 			break;
-
-		/* now add this directory to list of ignores */
-		if ((error = git_ignore__push_dir(&ignores, path.path)) < 0)
+		path.basename[-1] = '\0';
+		while (path.basename > path.path && *path.basename != '/')
+			path.basename--;
+		if (path.basename > path.path)
+			path.basename++;
+		path.is_dir = 1;
+
+		if ((error = git_ignore__pop_dir(&ignores)) < 0)
 			break;
-
-		/* reinstate divider in path */
-		*tail = '/';
-		while (*tail == '/') tail++;
 	}
 
 	*ignored = 0;
@@ -404,7 +390,6 @@ cleanup:
 	return error;
 }
 
-
 int git_ignore__check_pathspec_for_exact_ignores(
 	git_repository *repo,
 	git_vector *vspec,
diff --git a/src/ignore.h b/src/ignore.h
index ff9369000..77668c661 100644
--- a/src/ignore.h
+++ b/src/ignore.h
@@ -42,7 +42,14 @@ extern int git_ignore__pop_dir(git_ignores *ign);
 
 extern void git_ignore__free(git_ignores *ign);
 
-extern int git_ignore__lookup(git_ignores *ign, const char *path, int *ignored);
+enum {
+	GIT_IGNORE_UNCHECKED = -2,
+	GIT_IGNORE_NOTFOUND = -1,
+	GIT_IGNORE_FALSE = 0,
+	GIT_IGNORE_TRUE = 1,
+};
+
+extern int git_ignore__lookup(int *out, git_ignores *ign, const char *path);
 
 /* command line Git sometimes generates an error message if given a
  * pathspec that contains an exact match to an ignored file (provided
diff --git a/src/iterator.c b/src/iterator.c
index 4f8087c8d..c664f17cd 100644
--- a/src/iterator.c
+++ b/src/iterator.c
@@ -897,6 +897,7 @@ struct fs_iterator_frame {
 	fs_iterator_frame *next;
 	git_vector entries;
 	size_t index;
+	int is_ignored;
 };
 
 typedef struct fs_iterator fs_iterator;
@@ -1290,16 +1291,28 @@ GIT_INLINE(bool) workdir_path_is_dotgit(const git_buf *path)
 
 static int workdir_iterator__enter_dir(fs_iterator *fi)
 {
+	workdir_iterator *wi = (workdir_iterator *)fi;
 	fs_iterator_frame *ff = fi->stack;
 	size_t pos;
 	git_path_with_stat *entry;
 	bool found_submodules = false;
 
-	/* only push new ignores if this is not top level directory */
+	/* check if this directory is ignored */
+	if (git_ignore__lookup(
+			&ff->is_ignored, &wi->ignores, fi->path.ptr + fi->root_len) < 0) {
+		giterr_clear();
+		ff->is_ignored = GIT_IGNORE_NOTFOUND;
+	}
+
+	/* if this is not the top level directory... */
 	if (ff->next != NULL) {
-		workdir_iterator *wi = (workdir_iterator *)fi;
 		ssize_t slash_pos = git_buf_rfind_next(&fi->path, '/');
 
+		/* inherit ignored from parent if no rule specified */
+		if (ff->is_ignored <= GIT_IGNORE_NOTFOUND)
+			ff->is_ignored = ff->next->is_ignored;
+
+		/* push new ignores for files in this directory */
 		(void)git_ignore__push_dir(&wi->ignores, &fi->path.ptr[slash_pos + 1]);
 	}
 
@@ -1342,7 +1355,7 @@ static int workdir_iterator__update_entry(fs_iterator *fi)
 		return GIT_ENOTFOUND;
 
 	/* reset is_ignored since we haven't checked yet */
-	wi->is_ignored = -1;
+	wi->is_ignored = GIT_IGNORE_UNCHECKED;
 
 	return 0;
 }
@@ -1487,6 +1500,19 @@ int git_iterator_current_parent_tree(
 	return 0;
 }
 
+static void workdir_iterator_update_is_ignored(workdir_iterator *wi)
+{
+	if (git_ignore__lookup(
+			&wi->is_ignored, &wi->ignores, wi->fi.entry.path) < 0) {
+		giterr_clear();
+		wi->is_ignored = GIT_IGNORE_NOTFOUND;
+	}
+
+	/* use ignore from containing frame stack */
+	if (wi->is_ignored <= GIT_IGNORE_NOTFOUND)
+		wi->is_ignored = wi->fi.stack->is_ignored;
+}
+
 bool git_iterator_current_is_ignored(git_iterator *iter)
 {
 	workdir_iterator *wi = (workdir_iterator *)iter;
@@ -1494,14 +1520,22 @@ bool git_iterator_current_is_ignored(git_iterator *iter)
 	if (iter->type != GIT_ITERATOR_TYPE_WORKDIR)
 		return false;
 
-	if (wi->is_ignored != -1)
-		return (bool)(wi->is_ignored != 0);
+	if (wi->is_ignored != GIT_IGNORE_UNCHECKED)
+		return (bool)(wi->is_ignored == GIT_IGNORE_TRUE);
 
-	if (git_ignore__lookup(
-			&wi->ignores, wi->fi.entry.path, &wi->is_ignored) < 0)
-		wi->is_ignored = true;
+	workdir_iterator_update_is_ignored(wi);
+
+	return (bool)(wi->is_ignored == GIT_IGNORE_TRUE);
+}
+
+bool git_iterator_current_tree_is_ignored(git_iterator *iter)
+{
+	workdir_iterator *wi = (workdir_iterator *)iter;
+
+	if (iter->type != GIT_ITERATOR_TYPE_WORKDIR)
+		return false;
 
-	return (bool)wi->is_ignored;
+	return (bool)(wi->fi.stack->is_ignored == GIT_IGNORE_TRUE);
 }
 
 int git_iterator_cmp(git_iterator *iter, const char *path_prefix)
@@ -1549,10 +1583,8 @@ int git_iterator_advance_over_with_status(
 		return error;
 
 	if (!S_ISDIR(entry->mode)) {
-		if (git_ignore__lookup(
-				&wi->ignores, wi->fi.entry.path, &wi->is_ignored) < 0)
-			wi->is_ignored = true;
-		if (wi->is_ignored)
+		workdir_iterator_update_is_ignored(wi);
+		if (wi->is_ignored == GIT_IGNORE_TRUE)
 			*status = GIT_ITERATOR_STATUS_IGNORED;
 		return git_iterator_advance(entryptr, iter);
 	}
@@ -1564,14 +1596,12 @@ int git_iterator_advance_over_with_status(
 
 	/* scan inside directory looking for a non-ignored item */
 	while (entry && !iter->prefixcomp(entry->path, base)) {
-		if (git_ignore__lookup(
-				&wi->ignores, wi->fi.entry.path, &wi->is_ignored) < 0)
-			wi->is_ignored = true;
+		workdir_iterator_update_is_ignored(wi);
 
 		/* if we found an explicitly ignored item, then update from
 		 * EMPTY to IGNORED
 		 */
-		if (wi->is_ignored)
+		if (wi->is_ignored == GIT_IGNORE_TRUE)
 			*status = GIT_ITERATOR_STATUS_IGNORED;
 		else if (S_ISDIR(entry->mode)) {
 			error = git_iterator_advance_into(&entry, iter);
@@ -1580,7 +1610,7 @@ int git_iterator_advance_over_with_status(
 				continue;
 			else if (error == GIT_ENOTFOUND) {
 				error = 0;
-				wi->is_ignored = true; /* mark empty directories as ignored */
+				wi->is_ignored = GIT_IGNORE_TRUE; /* mark empty dirs ignored */
 			} else
 				break; /* real error, stop here */
 		} else {
diff --git a/src/iterator.h b/src/iterator.h
index f67830212..d88ad5191 100644
--- a/src/iterator.h
+++ b/src/iterator.h
@@ -245,6 +245,8 @@ extern int git_iterator_current_parent_tree(
 
 extern bool git_iterator_current_is_ignored(git_iterator *iter);
 
+extern bool git_iterator_current_tree_is_ignored(git_iterator *iter);
+
 extern int git_iterator_cmp(
 	git_iterator *iter, const char *path_prefix);
 
diff --git a/tests/diff/iterator.c b/tests/diff/iterator.c
index cdc64eb1d..a2df1c7a7 100644
--- a/tests/diff/iterator.c
+++ b/tests/diff/iterator.c
@@ -647,7 +647,7 @@ static void workdir_iterator_test(
 
 void test_diff_iterator__workdir_0(void)
 {
-	workdir_iterator_test("attr", NULL, NULL, 27, 1, NULL, "ign");
+	workdir_iterator_test("attr", NULL, NULL, 23, 5, NULL, "ign");
 }
 
 static const char *status_paths[] = {
diff --git a/tests/status/ignore.c b/tests/status/ignore.c
index caa1f1927..a4e766fdf 100644
--- a/tests/status/ignore.c
+++ b/tests/status/ignore.c
@@ -681,3 +681,110 @@ void test_status_ignore__issue_1766_negated_ignores(void)
 	}
 }
 
+static void add_one_to_index(const char *file)
+{
+	git_index *index;
+	cl_git_pass(git_repository_index(&index, g_repo));
+	cl_git_pass(git_index_add_bypath(index, file));
+	git_index_free(index);
+}
+
+/* Some further broken scenarios that have been reported */
+void test_status_ignore__more_breakage(void)
+{
+	static const char *test_files[] = {
+		"empty_standard_repo/d1/pfx-d2/d3/d4/d5/tracked",
+		"empty_standard_repo/d1/pfx-d2/d3/d4/d5/untracked",
+		"empty_standard_repo/d1/pfx-d2/d3/d4/untracked",
+		NULL
+	};
+
+	make_test_data("empty_standard_repo", test_files);
+	cl_git_mkfile(
+		"empty_standard_repo/.gitignore",
+		"/d1/pfx-*\n"
+		"!/d1/pfx-d2/\n"
+		"/d1/pfx-d2/*\n"
+		"!/d1/pfx-d2/d3/\n"
+		"/d1/pfx-d2/d3/*\n"
+		"!/d1/pfx-d2/d3/d4/\n");
+	add_one_to_index("d1/pfx-d2/d3/d4/d5/tracked");
+
+	{
+		git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+		status_entry_counts counts;
+		static const char *files[] = {
+			".gitignore",
+			"d1/pfx-d2/d3/d4/d5/tracked",
+			"d1/pfx-d2/d3/d4/d5/untracked",
+			"d1/pfx-d2/d3/d4/untracked",
+		};
+		static const unsigned int statuses[] = {
+			GIT_STATUS_WT_NEW,
+			GIT_STATUS_INDEX_NEW,
+			GIT_STATUS_WT_NEW,
+			GIT_STATUS_WT_NEW,
+		};
+
+		memset(&counts, 0x0, sizeof(status_entry_counts));
+		counts.expected_entry_count = 4;
+		counts.expected_paths = files;
+		counts.expected_statuses = statuses;
+		opts.flags = GIT_STATUS_OPT_DEFAULTS |
+			GIT_STATUS_OPT_INCLUDE_IGNORED |
+			GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
+		cl_git_pass(git_status_foreach_ext(
+			g_repo, &opts, cb_status__normal, &counts));
+
+		cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
+		cl_assert_equal_i(0, counts.wrong_status_flags_count);
+		cl_assert_equal_i(0, counts.wrong_sorted_path);
+	}
+
+	refute_is_ignored("d1/pfx-d2/d3/d4/d5/tracked");
+	refute_is_ignored("d1/pfx-d2/d3/d4/d5/untracked");
+	refute_is_ignored("d1/pfx-d2/d3/d4/untracked");
+}
+
+void test_status_ignore__negative_ignores_inside_ignores(void)
+{
+	static const char *test_files[] = {
+		"empty_standard_repo/top/mid/btm/tracked",
+		"empty_standard_repo/top/mid/btm/untracked",
+		NULL
+	};
+
+	make_test_data("empty_standard_repo", test_files);
+	cl_git_mkfile(
+		"empty_standard_repo/.gitignore",
+		"top\n!top/mid/btm\n");
+	add_one_to_index("top/mid/btm/tracked");
+
+	{
+		git_status_options opts = GIT_STATUS_OPTIONS_INIT;
+		status_entry_counts counts;
+		static const char *files[] = {
+			".gitignore", "top/mid/btm/tracked", "top/mid/btm/untracked",
+		};
+		static const unsigned int statuses[] = {
+			GIT_STATUS_WT_NEW, GIT_STATUS_INDEX_NEW, GIT_STATUS_WT_NEW,
+		};
+
+		memset(&counts, 0x0, sizeof(status_entry_counts));
+		counts.expected_entry_count = 3;
+		counts.expected_paths = files;
+		counts.expected_statuses = statuses;
+		opts.flags = GIT_STATUS_OPT_DEFAULTS |
+			GIT_STATUS_OPT_INCLUDE_IGNORED |
+			GIT_STATUS_OPT_RECURSE_IGNORED_DIRS;
+		cl_git_pass(git_status_foreach_ext(
+			g_repo, &opts, cb_status__normal, &counts));
+
+		cl_assert_equal_i(counts.expected_entry_count, counts.entry_count);
+		cl_assert_equal_i(0, counts.wrong_status_flags_count);
+		cl_assert_equal_i(0, counts.wrong_sorted_path);
+	}
+
+	refute_is_ignored("top/mid/btm/tracked");
+	refute_is_ignored("top/mid/btm/untracked");
+}
-- 
cgit v1.2.3


From 0bf5430dc77c69d2b2d27a771b584b17cedb97ec Mon Sep 17 00:00:00 2001
From: Anurag Gupta <anugupta@microsoft.com>
Date: Tue, 6 May 2014 13:33:47 -0700
Subject: Fix the issues in git_shutdown

1) Call to git_shutdown results in setting git__n_shutdown_callbacks
to -1. Next call to git__on_shutdown results in ABW (Array Bound Write)
for array git__shutdown_callbacks. In the current Implementation,
git_atomic_dec is called git__n_shutdown_callbacks + 1 times. I have
modified it to a for loop so that it is more readable. It would not
set git__n_shutdown_callbacks to a negative number and reset the
elements of git__shutdown_callbacks to NULL.

2) In function git_sysdir_get, shutdown function is registered only if
git_sysdir__dirs_shutdown_set is set to 0. However, after this variable
is set to 1, it is never reset to 0. If git_sysdir_global_init is
called again from synchronized_threads_init it does not register
shutdown function for this subsystem.
---
 src/global.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/global.c b/src/global.c
index a64dce9ef..4dfdcf438 100644
--- a/src/global.c
+++ b/src/global.c
@@ -31,11 +31,11 @@ static void git__shutdown(void)
 {
 	int pos;
 
-	for (pos = git_atomic_get(&git__n_shutdown_callbacks); pos > 0; pos = git_atomic_dec(&git__n_shutdown_callbacks))
-		if (git__shutdown_callbacks[pos - 1]) {
-			git__shutdown_callbacks[pos - 1]();
-			git__shutdown_callbacks[pos - 1] = NULL;
-		}
+	for (pos = git_atomic_get(&git__n_shutdown_callbacks); pos > 0; pos = git_atomic_dec(&git__n_shutdown_callbacks)) {
+		git_global_shutdown_fn cb = git__swap(git__shutdown_callbacks[pos - 1], NULL);
+		if (cb != NULL)
+			cb();
+	}
 
 }
 
-- 
cgit v1.2.3


From 5269008cf632efcd6a16f6160ec44244ce442400 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 6 May 2014 16:01:49 -0700
Subject: Add filter options and ALLOW_UNSAFE

Diff and status do not want core.safecrlf to actually raise an
error regardless of the setting, so this extends the filter API
with an additional options flags parameter and adds a flag so that
filters can be applied with GIT_FILTER_OPT_ALLOW_UNSAFE, indicating
that unsafe filter application should be downgraded from a failure
to a warning.
---
 include/git2/filter.h      |  8 ++++++-
 include/git2/repository.h  |  5 +++++
 include/git2/sys/filter.h  | 12 ++++++++--
 src/blob.c                 |  6 +++--
 src/checkout.c             |  3 ++-
 src/crlf.c                 | 23 +++++++++++++++----
 src/diff.c                 |  3 ++-
 src/diff_file.c            |  3 ++-
 src/filter.c               | 17 ++++++++++++--
 src/repository.c           |  3 ++-
 tests/filter/crlf.c        | 55 ++++++++++++++++++++++++++++++++++++++++++----
 tests/filter/custom.c      | 15 +++++++------
 tests/filter/ident.c       |  6 +++--
 tests/object/blob/filter.c |  2 +-
 14 files changed, 132 insertions(+), 29 deletions(-)

diff --git a/include/git2/filter.h b/include/git2/filter.h
index f96b6766b..7fd9b7e59 100644
--- a/include/git2/filter.h
+++ b/include/git2/filter.h
@@ -35,6 +35,11 @@ typedef enum {
 	GIT_FILTER_CLEAN = GIT_FILTER_TO_ODB,
 } git_filter_mode_t;
 
+typedef enum {
+	GIT_FILTER_OPT_DEFAULT = 0u,
+	GIT_FILTER_OPT_ALLOW_UNSAFE = (1u << 0),
+} git_filter_opt_t;
+
 /**
  * A filter that can transform file data
  *
@@ -83,7 +88,8 @@ GIT_EXTERN(int) git_filter_list_load(
 	git_repository *repo,
 	git_blob *blob, /* can be NULL */
 	const char *path,
-	git_filter_mode_t mode);
+	git_filter_mode_t mode,
+	git_filter_opt_t options);
 
 /**
  * Apply filter list to a data buffer.
diff --git a/include/git2/repository.h b/include/git2/repository.h
index e3f687a29..04df25fd3 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -546,6 +546,10 @@ GIT_EXTERN(int) git_repository_mergehead_foreach(
  * hash a file in the repository and you want to apply filtering rules (e.g.
  * crlf filters) before generating the SHA, then use this function.
  *
+ * Note: if the repository has `core.safecrlf` set to fail and the
+ * filtering triggers that failure, then this function will return an
+ * error and not calculate the hash of the file.
+ *
  * @param out Output value of calculated SHA
  * @param repo Repository pointer
  * @param path Path to file on disk whose contents should be hashed. If the
@@ -555,6 +559,7 @@ GIT_EXTERN(int) git_repository_mergehead_foreach(
  *             NULL, then the `path` parameter will be used instead. If
  *             this is passed as the empty string, then no filters will be
  *             applied when calculating the hash.
+ * @return 0 on success, or an error code
  */
 GIT_EXTERN(int) git_repository_hashfile(
 	git_oid *out,
diff --git a/include/git2/sys/filter.h b/include/git2/sys/filter.h
index 8fe21c9c0..1b21a9d30 100644
--- a/include/git2/sys/filter.h
+++ b/include/git2/sys/filter.h
@@ -55,7 +55,10 @@ GIT_EXTERN(git_filter *) git_filter_lookup(const char *name);
  * your own chains of filters.
  */
 GIT_EXTERN(int) git_filter_list_new(
-	git_filter_list **out, git_repository *repo, git_filter_mode_t mode);
+	git_filter_list **out,
+	git_repository *repo,
+	git_filter_mode_t mode,
+	git_filter_opt_t options);
 
 /**
  * Add a filter to a filter list with the given payload.
@@ -115,10 +118,15 @@ GIT_EXTERN(uint16_t) git_filter_source_filemode(const git_filter_source *src);
 GIT_EXTERN(const git_oid *) git_filter_source_id(const git_filter_source *src);
 
 /**
- * Get the git_filter_mode_t to be applied
+ * Get the git_filter_mode_t to be used
  */
 GIT_EXTERN(git_filter_mode_t) git_filter_source_mode(const git_filter_source *src);
 
+/**
+ * Get the git_filter_opt_t options to be applied
+ */
+GIT_EXTERN(git_filter_opt_t) git_filter_source_options(const git_filter_source *src);
+
 /*
  * struct git_filter
  *
diff --git a/src/blob.c b/src/blob.c
index 0aa2516db..ab7dec67f 100644
--- a/src/blob.c
+++ b/src/blob.c
@@ -198,7 +198,8 @@ int git_blob__create_from_paths(
 		if (try_load_filters)
 			/* Load the filters for writing this file to the ODB */
 			error = git_filter_list_load(
-				&fl, repo, NULL, hint_path, GIT_FILTER_TO_ODB);
+				&fl, repo, NULL, hint_path,
+				GIT_FILTER_TO_ODB, GIT_FILTER_OPT_DEFAULT);
 
 		if (error < 0)
 			/* well, that didn't work */;
@@ -356,7 +357,8 @@ int git_blob_filtered_content(
 		return 0;
 
 	if (!(error = git_filter_list_load(
-			&fl, git_blob_owner(blob), blob, path, GIT_FILTER_TO_WORKTREE))) {
+			&fl, git_blob_owner(blob), blob, path,
+			GIT_FILTER_TO_WORKTREE, GIT_FILTER_OPT_DEFAULT))) {
 
 		error = git_filter_list_apply_to_blob(out, fl, blob);
 
diff --git a/src/checkout.c b/src/checkout.c
index b869efe2b..20763fd35 100644
--- a/src/checkout.c
+++ b/src/checkout.c
@@ -1212,7 +1212,8 @@ static int blob_content_to_file(
 
 	if (!opts->disable_filters)
 		error = git_filter_list_load(
-			&fl, git_blob_owner(blob), blob, hint_path, GIT_FILTER_TO_WORKTREE);
+			&fl, git_blob_owner(blob), blob, hint_path,
+			GIT_FILTER_TO_WORKTREE, GIT_FILTER_OPT_DEFAULT);
 
 	if (!error)
 		error = git_filter_list_apply_to_blob(&out, fl, blob);
diff --git a/src/crlf.c b/src/crlf.c
index 8be1b9a05..dad3ecebc 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -139,10 +139,19 @@ static int crlf_apply_to_odb(
 			return GIT_PASSTHROUGH;
 
 		/* If safecrlf is enabled, sanity-check the result. */
-		if (ca->safe_crlf && (stats.cr != stats.crlf || stats.lf != stats.crlf)) {
-			giterr_set(GITERR_FILTER, "LF would be replaced by CRLF in '%s'",
-				git_filter_source_path(src));
-			return -1;
+		if (stats.cr != stats.crlf || stats.lf != stats.crlf) {
+			switch (ca->safe_crlf) {
+			case GIT_SAFE_CRLF_FAIL:
+				giterr_set(
+					GITERR_FILTER, "LF would be replaced by CRLF in '%s'",
+					git_filter_source_path(src));
+				return -1;
+			case GIT_SAFE_CRLF_WARN:
+				/* TODO: issue warning when warning API is available */;
+				break;
+			default:
+				break;
+			}
 		}
 
 		/*
@@ -267,6 +276,7 @@ static int crlf_check(
 	if (ca.crlf_action == GIT_CRLF_GUESS ||
 		(ca.crlf_action == GIT_CRLF_AUTO &&
 		git_filter_source_mode(src) == GIT_FILTER_SMUDGE)) {
+
 		error = git_repository__cvar(
 			&ca.auto_crlf, git_filter_source_repo(src), GIT_CVAR_AUTO_CRLF);
 		if (error < 0)
@@ -285,6 +295,11 @@ static int crlf_check(
 			&ca.safe_crlf, git_filter_source_repo(src), GIT_CVAR_SAFE_CRLF);
 		if (error < 0)
 			return error;
+
+		/* downgrade FAIL to WARN if ALLOW_UNSAFE option is used */
+		if ((git_filter_source_options(src) & GIT_FILTER_OPT_ALLOW_UNSAFE) &&
+			ca.safe_crlf == GIT_SAFE_CRLF_FAIL)
+			ca.safe_crlf = GIT_SAFE_CRLF_WARN;
 	}
 
 	*payload = git__malloc(sizeof(ca));
diff --git a/src/diff.c b/src/diff.c
index 781f23ec6..bc23e6b0d 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -589,7 +589,8 @@ int git_diff__oid_for_entry(
 			entry.path);
 		error = -1;
 	} else if (!(error = git_filter_list_load(
-			&fl, diff->repo, NULL, entry.path, GIT_FILTER_TO_ODB)))
+		&fl, diff->repo, NULL, entry.path,
+		GIT_FILTER_TO_ODB, GIT_FILTER_OPT_ALLOW_UNSAFE)))
 	{
 		int fd = git_futils_open_ro(full_path.ptr);
 		if (fd < 0)
diff --git a/src/diff_file.c b/src/diff_file.c
index b9f92df3f..f2a1d5099 100644
--- a/src/diff_file.c
+++ b/src/diff_file.c
@@ -300,7 +300,8 @@ static int diff_file_content_load_workdir_file(
 		goto cleanup;
 
 	if ((error = git_filter_list_load(
-			&fl, fc->repo, NULL, fc->file->path, GIT_FILTER_TO_ODB)) < 0)
+			&fl, fc->repo, NULL, fc->file->path,
+			GIT_FILTER_TO_ODB, GIT_FILTER_OPT_ALLOW_UNSAFE)) < 0)
 		goto cleanup;
 
 	/* if there are no filters, try to mmap the file */
diff --git a/src/filter.c b/src/filter.c
index b2f57964a..b0e2b8bea 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -23,6 +23,7 @@ struct git_filter_source {
 	git_oid         oid;  /* zero if unknown (which is likely) */
 	uint16_t        filemode; /* zero if unknown */
 	git_filter_mode_t mode;
+	git_filter_opt_t  options;
 };
 
 typedef struct {
@@ -358,6 +359,11 @@ git_filter_mode_t git_filter_source_mode(const git_filter_source *src)
 	return src->mode;
 }
 
+git_filter_opt_t git_filter_source_options(const git_filter_source *src)
+{
+	return src->options;
+}
+
 static int filter_list_new(
 	git_filter_list **out, const git_filter_source *src)
 {
@@ -372,6 +378,7 @@ static int filter_list_new(
 	fl->source.repo = src->repo;
 	fl->source.path = fl->path;
 	fl->source.mode = src->mode;
+	fl->source.options = src->options;
 
 	*out = fl;
 	return 0;
@@ -419,12 +426,16 @@ static int filter_list_check_attributes(
 }
 
 int git_filter_list_new(
-	git_filter_list **out, git_repository *repo, git_filter_mode_t mode)
+	git_filter_list **out,
+	git_repository *repo,
+	git_filter_mode_t mode,
+	git_filter_opt_t options)
 {
 	git_filter_source src = { 0 };
 	src.repo = repo;
 	src.path = NULL;
 	src.mode = mode;
+	src.options = options;
 	return filter_list_new(out, &src);
 }
 
@@ -433,7 +444,8 @@ int git_filter_list_load(
 	git_repository *repo,
 	git_blob *blob, /* can be NULL */
 	const char *path,
-	git_filter_mode_t mode)
+	git_filter_mode_t mode,
+	git_filter_opt_t options)
 {
 	int error = 0;
 	git_filter_list *fl = NULL;
@@ -448,6 +460,7 @@ int git_filter_list_load(
 	src.repo = repo;
 	src.path = path;
 	src.mode = mode;
+	src.options = options;
 	if (blob)
 		git_oid_cpy(&src.oid, git_blob_id(blob));
 
diff --git a/src/repository.c b/src/repository.c
index ac7af7692..df5f322ce 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1789,7 +1789,8 @@ int git_repository_hashfile(
 	/* passing empty string for "as_path" indicated --no-filters */
 	if (strlen(as_path) > 0) {
 		error = git_filter_list_load(
-			&fl, repo, NULL, as_path, GIT_FILTER_TO_ODB);
+			&fl, repo, NULL, as_path,
+			GIT_FILTER_TO_ODB, GIT_FILTER_OPT_DEFAULT);
 		if (error < 0)
 			return error;
 	} else {
diff --git a/tests/filter/crlf.c b/tests/filter/crlf.c
index 75320efee..66c267e31 100644
--- a/tests/filter/crlf.c
+++ b/tests/filter/crlf.c
@@ -25,7 +25,8 @@ void test_filter_crlf__to_worktree(void)
 	git_filter *crlf;
 	git_buf in = { 0 }, out = { 0 };
 
-	cl_git_pass(git_filter_list_new(&fl, g_repo, GIT_FILTER_TO_WORKTREE));
+	cl_git_pass(git_filter_list_new(
+		&fl, g_repo, GIT_FILTER_TO_WORKTREE, 0));
 
 	crlf = git_filter_lookup(GIT_FILTER_CRLF);
 	cl_assert(crlf != NULL);
@@ -53,7 +54,8 @@ void test_filter_crlf__to_odb(void)
 	git_filter *crlf;
 	git_buf in = { 0 }, out = { 0 };
 
-	cl_git_pass(git_filter_list_new(&fl, g_repo, GIT_FILTER_TO_ODB));
+	cl_git_pass(git_filter_list_new(
+		&fl, g_repo, GIT_FILTER_TO_ODB, 0));
 
 	crlf = git_filter_lookup(GIT_FILTER_CRLF);
 	cl_assert(crlf != NULL);
@@ -79,7 +81,8 @@ void test_filter_crlf__with_safecrlf(void)
 
 	cl_repo_set_bool(g_repo, "core.safecrlf", true);
 
-	cl_git_pass(git_filter_list_new(&fl, g_repo, GIT_FILTER_TO_ODB));
+	cl_git_pass(git_filter_list_new(
+		&fl, g_repo, GIT_FILTER_TO_ODB, 0));
 
 	crlf = git_filter_lookup(GIT_FILTER_CRLF);
 	cl_assert(crlf != NULL);
@@ -111,13 +114,57 @@ void test_filter_crlf__with_safecrlf(void)
 	git_buf_free(&out);
 }
 
+void test_filter_crlf__with_safecrlf_and_unsafe_allowed(void)
+{
+	git_filter_list *fl;
+	git_filter *crlf;
+	git_buf in = {0}, out = GIT_BUF_INIT;
+
+	cl_repo_set_bool(g_repo, "core.safecrlf", true);
+
+	cl_git_pass(git_filter_list_new(
+		&fl, g_repo, GIT_FILTER_TO_ODB, GIT_FILTER_OPT_ALLOW_UNSAFE));
+
+	crlf = git_filter_lookup(GIT_FILTER_CRLF);
+	cl_assert(crlf != NULL);
+
+	cl_git_pass(git_filter_list_push(fl, crlf, NULL));
+
+	/* Normalized \r\n succeeds with safecrlf */
+	in.ptr = "Normal\r\nCRLF\r\nline-endings.\r\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr);
+
+	/* Mix of line endings fails with safecrlf, but allowed to pass */
+	in.ptr = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	/* TODO: check for warning */
+	cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr);
+
+	/* Normalized \n fails with safecrlf, but allowed to pass */
+	in.ptr = "Normal\nLF\nonly\nline-endings.\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	/* TODO: check for warning */
+	cl_assert_equal_s("Normal\nLF\nonly\nline-endings.\n", out.ptr);
+
+	git_filter_list_free(fl);
+	git_buf_free(&out);
+}
+
 void test_filter_crlf__no_safecrlf(void)
 {
 	git_filter_list *fl;
 	git_filter *crlf;
 	git_buf in = {0}, out = GIT_BUF_INIT;
 
-	cl_git_pass(git_filter_list_new(&fl, g_repo, GIT_FILTER_TO_ODB));
+	cl_git_pass(git_filter_list_new(
+		&fl, g_repo, GIT_FILTER_TO_ODB, 0));
 
 	crlf = git_filter_lookup(GIT_FILTER_CRLF);
 	cl_assert(crlf != NULL);
diff --git a/tests/filter/custom.c b/tests/filter/custom.c
index 70524010e..0fd7c3744 100644
--- a/tests/filter/custom.c
+++ b/tests/filter/custom.c
@@ -194,7 +194,7 @@ void test_filter_custom__to_odb(void)
 	git_buf in = GIT_BUF_INIT_CONST(workdir_data, strlen(workdir_data));
 
 	cl_git_pass(git_filter_list_load(
-		&fl, g_repo, NULL, "herofile", GIT_FILTER_TO_ODB));
+		&fl, g_repo, NULL, "herofile", GIT_FILTER_TO_ODB, 0));
 
 	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
 
@@ -215,7 +215,7 @@ void test_filter_custom__to_workdir(void)
 		bitflipped_and_reversed_data, BITFLIPPED_AND_REVERSED_DATA_LEN);
 
 	cl_git_pass(git_filter_list_load(
-		&fl, g_repo, NULL, "herofile", GIT_FILTER_TO_WORKTREE));
+		&fl, g_repo, NULL, "herofile", GIT_FILTER_TO_WORKTREE, 0));
 
 	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
 
@@ -233,13 +233,13 @@ void test_filter_custom__can_register_a_custom_filter_in_the_repository(void)
 	git_filter_list *fl;
 
 	cl_git_pass(git_filter_list_load(
-		&fl, g_repo, NULL, "herofile", GIT_FILTER_TO_WORKTREE));
+		&fl, g_repo, NULL, "herofile", GIT_FILTER_TO_WORKTREE, 0));
 	/* expect: bitflip, reverse, crlf */
 	cl_assert_equal_sz(3, git_filter_list_length(fl));
 	git_filter_list_free(fl);
 
 	cl_git_pass(git_filter_list_load(
-		&fl, g_repo, NULL, "herocorp", GIT_FILTER_TO_WORKTREE));
+		&fl, g_repo, NULL, "herocorp", GIT_FILTER_TO_WORKTREE, 0));
 	/* expect: bitflip, reverse - possibly crlf depending on global config */
 	{
 		size_t flen = git_filter_list_length(fl);
@@ -248,19 +248,20 @@ void test_filter_custom__can_register_a_custom_filter_in_the_repository(void)
 	git_filter_list_free(fl);
 
 	cl_git_pass(git_filter_list_load(
-		&fl, g_repo, NULL, "hero.bin", GIT_FILTER_TO_WORKTREE));
+		&fl, g_repo, NULL, "hero.bin", GIT_FILTER_TO_WORKTREE, 0));
 	/* expect: bitflip, reverse */
 	cl_assert_equal_sz(2, git_filter_list_length(fl));
 	git_filter_list_free(fl);
 
 	cl_git_pass(git_filter_list_load(
-		&fl, g_repo, NULL, "heroflip", GIT_FILTER_TO_WORKTREE));
+		&fl, g_repo, NULL, "heroflip", GIT_FILTER_TO_WORKTREE, 0));
 	/* expect: bitflip (because of -reverse) */
 	cl_assert_equal_sz(1, git_filter_list_length(fl));
 	git_filter_list_free(fl);
 
 	cl_git_pass(git_filter_list_load(
-		&fl, g_repo, NULL, "doesntapplytome.bin", GIT_FILTER_TO_WORKTREE));
+		&fl, g_repo, NULL, "doesntapplytome.bin",
+		GIT_FILTER_TO_WORKTREE, 0));
 	/* expect: none */
 	cl_assert_equal_sz(0, git_filter_list_length(fl));
 	git_filter_list_free(fl);
diff --git a/tests/filter/ident.c b/tests/filter/ident.c
index 2c8e6abea..2c9a3eb68 100644
--- a/tests/filter/ident.c
+++ b/tests/filter/ident.c
@@ -39,7 +39,8 @@ void test_filter_ident__to_worktree(void)
 	git_filter_list *fl;
 	git_filter *ident;
 
-	cl_git_pass(git_filter_list_new(&fl, g_repo, GIT_FILTER_TO_WORKTREE));
+	cl_git_pass(git_filter_list_new(
+		&fl, g_repo, GIT_FILTER_TO_WORKTREE, 0));
 
 	ident = git_filter_lookup(GIT_FILTER_IDENT);
 	cl_assert(ident != NULL);
@@ -78,7 +79,8 @@ void test_filter_ident__to_odb(void)
 	git_filter_list *fl;
 	git_filter *ident;
 
-	cl_git_pass(git_filter_list_new(&fl, g_repo, GIT_FILTER_TO_ODB));
+	cl_git_pass(git_filter_list_new(
+		&fl, g_repo, GIT_FILTER_TO_ODB, 0));
 
 	ident = git_filter_lookup(GIT_FILTER_IDENT);
 	cl_assert(ident != NULL);
diff --git a/tests/object/blob/filter.c b/tests/object/blob/filter.c
index 0b2d6bf9e..9798055cd 100644
--- a/tests/object/blob/filter.c
+++ b/tests/object/blob/filter.c
@@ -121,7 +121,7 @@ void test_object_blob_filter__to_odb(void)
 	cl_git_append2file("empty_standard_repo/.gitattributes", "*.txt text\n");
 
 	cl_git_pass(git_filter_list_load(
-		&fl, g_repo, NULL, "filename.txt", GIT_FILTER_TO_ODB));
+		&fl, g_repo, NULL, "filename.txt", GIT_FILTER_TO_ODB, 0));
 	cl_assert(fl != NULL);
 
 	for (i = 0; i < CRLF_NUM_TEST_OBJECTS; i++) {
-- 
cgit v1.2.3


From ac99d86ba5e2a9d2332b7f82737e1231c621dc43 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 7 May 2014 11:34:32 +0200
Subject: repository: introduce a convenience config snapshot method

Accessing the repository's config and immediately taking a snapshot of
it is a common operation, so let's provide a convenience function for
it.
---
 include/git2/repository.h | 14 +++++++++++++-
 src/branch.c              |  7 ++-----
 src/diff_driver.c         |  5 +----
 src/pack-objects.c        |  7 ++-----
 src/remote.c              |  7 ++-----
 src/repository.c          | 17 ++++++++++++-----
 src/signature.c           |  7 ++-----
 7 files changed, 34 insertions(+), 30 deletions(-)

diff --git a/include/git2/repository.h b/include/git2/repository.h
index 4433e71a2..37140d48a 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -409,12 +409,24 @@ GIT_EXTERN(int) git_repository_is_bare(git_repository *repo);
  * The configuration file must be freed once it's no longer
  * being used by the user.
  *
- * @param out Pointer to store the loaded config file
+ * @param out Pointer to store the loaded configuration
  * @param repo A repository object
  * @return 0, or an error code
  */
 GIT_EXTERN(int) git_repository_config(git_config **out, git_repository *repo);
 
+/**
+ * Get a snapshot of the repository's configuration
+ *
+ * Convenience function to take a snapshot from the repository's
+ * configuration.
+ *
+ * @param out Pointer to store the loaded configuration
+ * @param repo the repository
+ * @return 0, or an error code
+ */
+GIT_EXTERN(int) git_repository_config_snapshot(git_config **out, git_repository *repo);
+
 /**
  * Get the Object Database for this repository.
  *
diff --git a/src/branch.c b/src/branch.c
index d8c82b73e..52760853b 100644
--- a/src/branch.c
+++ b/src/branch.c
@@ -332,7 +332,7 @@ int git_branch_upstream_name(
 	int error = -1;
 	git_remote *remote = NULL;
 	const git_refspec *refspec;
-	git_config *config, *repo_config;
+	git_config *config;
 
 	assert(out && refname);
 
@@ -341,10 +341,7 @@ int git_branch_upstream_name(
 	if (!git_reference__is_branch(refname))
 		return not_a_local_branch(refname);
 
-	if ((error = git_repository_config__weakptr(&repo_config, repo)) < 0)
-		return error;
-
-	if ((error = git_config_snapshot(&config, repo_config)) < 0)
+	if ((error = git_repository_config_snapshot(&config, repo)) < 0)
 		return error;
 
 	if ((error = retrieve_upstream_configuration(
diff --git a/src/diff_driver.c b/src/diff_driver.c
index 6e87fd6f8..28c0a6b17 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -234,14 +234,11 @@ static int git_diff_driver_load(
 	}
 
 	/* if you can't read config for repo, just use default driver */
-	if (git_repository_config__weakptr(&repo_cfg, repo) < 0) {
+	if (git_repository_config_snapshot(&cfg, repo) < 0) {
 		giterr_clear();
 		goto done;
 	}
 
-	if ((error = git_config_snapshot(&cfg, repo_cfg)) < 0)
-		return error;
-
 	drv = git__calloc(1, sizeof(git_diff_driver) + namelen + 1);
 	GITERR_CHECK_ALLOC(drv);
 	drv->type = DIFF_DRIVER_AUTO;
diff --git a/src/pack-objects.c b/src/pack-objects.c
index e7c7f391f..882ddf544 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -86,14 +86,11 @@ static unsigned name_hash(const char *name)
 
 static int packbuilder_config(git_packbuilder *pb)
 {
-	git_config *config, *repo_config;
+	git_config *config;
 	int ret;
 	int64_t val;
 
-	if ((ret = git_repository_config__weakptr(&repo_config, pb->repo)) < 0)
-		return ret;
-
-	if ((ret = git_config_snapshot(&config, repo_config)) < 0)
+	if ((ret = git_repository_config_snapshot(&config, pb->repo)) < 0)
 		return ret;
 
 #define config_get(KEY,DST,DFLT) do { \
diff --git a/src/remote.c b/src/remote.c
index 3a754d4bd..0a6b72fb9 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -347,7 +347,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	git_buf buf = GIT_BUF_INIT;
 	const char *val;
 	int error = 0;
-	git_config *config, *repo_config;
+	git_config *config;
 	struct refspec_cb_data data = { NULL };
 	bool optional_setting_found = false, found;
 
@@ -356,10 +356,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 	if ((error = ensure_remote_name_is_valid(name)) < 0)
 		return error;
 
-	if (git_repository_config__weakptr(&repo_config, repo) < 0)
-		return -1;
-
-	if ((error = git_config_snapshot(&config, repo_config)) < 0)
+	if ((error = git_repository_config_snapshot(&config, repo)) < 0)
 		return error;
 
 	remote = git__malloc(sizeof(git_remote));
diff --git a/src/repository.c b/src/repository.c
index c1d98300c..dfddc5966 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -439,7 +439,7 @@ int git_repository_open_ext(
 	int error;
 	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT;
 	git_repository *repo;
-	git_config *repo_config, *config;
+	git_config *config;
 
 	if (repo_ptr)
 		*repo_ptr = NULL;
@@ -454,10 +454,7 @@ int git_repository_open_ext(
 	repo->path_repository = git_buf_detach(&path);
 	GITERR_CHECK_ALLOC(repo->path_repository);
 
-	if ((error = git_repository_config__weakptr(&repo_config, repo)) < 0)
-		return error;
-
-	if ((error = git_config_snapshot(&config, repo_config)) < 0)
+	if ((error = git_repository_config_snapshot(&config, repo)) < 0)
 		return error;
 
 	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
@@ -624,6 +621,16 @@ int git_repository_config(git_config **out, git_repository *repo)
 	return 0;
 }
 
+int git_repository_config_snapshot(git_config **out, git_repository *repo)
+{
+	git_config *weak;
+
+	if (git_repository_config__weakptr(&weak, repo) < 0)
+		return -1;
+
+	return git_config_snapshot(out, weak);
+}
+
 void git_repository_set_config(git_repository *repo, git_config *config)
 {
 	assert(repo && config);
diff --git a/src/signature.c b/src/signature.c
index b0ee0da74..2545b7519 100644
--- a/src/signature.c
+++ b/src/signature.c
@@ -141,13 +141,10 @@ int git_signature_now(git_signature **sig_out, const char *name, const char *ema
 int git_signature_default(git_signature **out, git_repository *repo)
 {
 	int error;
-	git_config *cfg, *repo_cfg;
+	git_config *cfg;
 	const char *user_name, *user_email;
 
-	if ((error = git_repository_config__weakptr(&repo_cfg, repo)) < 0)
-		return error;
-
-	if ((error = git_config_snapshot(&cfg, repo_cfg)) < 0)
+	if ((error = git_repository_config_snapshot(&cfg, repo)) < 0)
 		return error;
 
 	if (!(error = git_config_get_string(&user_name, cfg, "user.name")) &&
-- 
cgit v1.2.3


From 1e4976cb015bd10a2a8c377e02801306473afc26 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 8 May 2014 10:17:14 -0700
Subject: Be more careful with user-supplied buffers

This adds in missing calls to `git_buf_sanitize` and fixes a
number of places where `git_buf` APIs could inadvertently write
NUL terminator bytes into invalid buffers.  This also changes the
behavior of `git_buf_sanitize` to NUL terminate a buffer if it can
and of `git_buf_shorten` to do nothing if it can.

Adds tests of filtering code with zeroed (i.e. unsanitized) buffer
which was previously triggering a segfault.
---
 src/buffer.c               | 37 ++++++++++++++++++++++---------------
 src/config.c               |  3 +++
 src/diff_print.c           |  6 +++---
 src/filter.c               |  5 ++++-
 src/pack-objects.c         |  1 +
 src/submodule.c            |  4 +++-
 tests/object/blob/filter.c | 13 ++++++++++---
 7 files changed, 46 insertions(+), 23 deletions(-)

diff --git a/src/buffer.c b/src/buffer.c
index 5169c3e09..b8f8660ed 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -104,17 +104,20 @@ void git_buf_free(git_buf *buf)
 void git_buf_sanitize(git_buf *buf)
 {
 	if (buf->ptr == NULL) {
-		assert (buf->size == 0 && buf->asize == 0);
+		assert(buf->size == 0 && buf->asize == 0);
 		buf->ptr = git_buf__initbuf;
-	}
+	} else if (buf->asize > buf->size)
+		buf->ptr[buf->size] = '\0';
 }
 
 void git_buf_clear(git_buf *buf)
 {
 	buf->size = 0;
 
-	if (!buf->ptr)
+	if (!buf->ptr) {
 		buf->ptr = git_buf__initbuf;
+		buf->asize = 0;
+	}
 
 	if (buf->asize > 0)
 		buf->ptr[0] = '\0';
@@ -129,8 +132,11 @@ int git_buf_set(git_buf *buf, const void *data, size_t len)
 			ENSURE_SIZE(buf, len + 1);
 			memmove(buf->ptr, data, len);
 		}
+
 		buf->size = len;
-		buf->ptr[buf->size] = '\0';
+		if (buf->asize > buf->size)
+			buf->ptr[buf->size] = '\0';
+
 	}
 	return 0;
 }
@@ -326,19 +332,20 @@ void git_buf_consume(git_buf *buf, const char *end)
 
 void git_buf_truncate(git_buf *buf, size_t len)
 {
-	if (len < buf->size) {
-		buf->size = len;
+	if (len >= buf->size)
+		return;
+
+	buf->size = len;
+	if (buf->size < buf->asize)
 		buf->ptr[buf->size] = '\0';
-	}
 }
 
 void git_buf_shorten(git_buf *buf, size_t amount)
 {
-	if (amount > buf->size)
-		amount = buf->size;
-
-	buf->size = buf->size - amount;
-	buf->ptr[buf->size] = '\0';
+	if (buf->size > amount)
+		git_buf_truncate(buf, buf->size - amount);
+	else
+		git_buf_clear(buf);
 }
 
 void git_buf_rtruncate_at_char(git_buf *buf, char separator)
@@ -574,7 +581,8 @@ void git_buf_rtrim(git_buf *buf)
 		buf->size--;
 	}
 
-	buf->ptr[buf->size] = '\0';
+	if (buf->asize > buf->size)
+		buf->ptr[buf->size] = '\0';
 }
 
 int git_buf_cmp(const git_buf *a, const git_buf *b)
@@ -598,8 +606,7 @@ int git_buf_splice(
 	/* Ported from git.git
 	 * https://github.com/git/git/blob/16eed7c/strbuf.c#L159-176
 	 */
-	if (git_buf_grow(buf, git_buf_len(buf) + nb_to_insert - nb_to_remove) < 0)
-		return -1;
+	ENSURE_SIZE(buf, buf->size + nb_to_insert - nb_to_insert + 1);
 
 	memmove(buf->ptr + where + nb_to_insert,
 			buf->ptr + where + nb_to_remove,
diff --git a/src/config.c b/src/config.c
index f9d697197..4dddab6df 100644
--- a/src/config.c
+++ b/src/config.c
@@ -967,16 +967,19 @@ void git_config_iterator_free(git_config_iterator *iter)
 
 int git_config_find_global(git_buf *path)
 {
+	git_buf_sanitize(path);
 	return git_sysdir_find_global_file(path, GIT_CONFIG_FILENAME_GLOBAL);
 }
 
 int git_config_find_xdg(git_buf *path)
 {
+	git_buf_sanitize(path);
 	return git_sysdir_find_xdg_file(path, GIT_CONFIG_FILENAME_XDG);
 }
 
 int git_config_find_system(git_buf *path)
 {
+	git_buf_sanitize(path);
 	return git_sysdir_find_system_file(path, GIT_CONFIG_FILENAME_SYSTEM);
 }
 
diff --git a/src/diff_print.c b/src/diff_print.c
index 07c1f8577..08e1e7f90 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -597,9 +597,9 @@ int git_diff_print_callback__to_file_handle(
 }
 
 /* print a git_patch to a git_buf */
-int git_patch_to_buf(
-	git_buf *out,
-	git_patch *patch)
+int git_patch_to_buf(git_buf *out, git_patch *patch)
 {
+	assert(out && patch);
+	git_buf_sanitize(out);
 	return git_patch_print(patch, git_diff_print_callback__to_buf, out);
 }
diff --git a/src/filter.c b/src/filter.c
index b2f57964a..3c36aaf36 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -578,6 +578,9 @@ int git_filter_list_apply_to_data(
 	git_buf *dbuffer[2], local = GIT_BUF_INIT;
 	unsigned int si = 0;
 
+	git_buf_sanitize(tgt);
+	git_buf_sanitize(src);
+
 	if (!fl)
 		return filter_list_out_buffer_from_raw(tgt, src->ptr, src->size);
 
@@ -613,7 +616,7 @@ int git_filter_list_apply_to_data(
 			/* PASSTHROUGH means filter decided not to process the buffer */
 			error = 0;
 		} else if (!error) {
-			git_buf_shorten(dbuffer[di], 0); /* force NUL termination */
+			git_buf_sanitize(dbuffer[di]); /* force NUL termination */
 			si = di; /* swap buffers */
 		} else {
 			tgt->size = 0;
diff --git a/src/pack-objects.c b/src/pack-objects.c
index ace8afd17..b50338578 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -1276,6 +1276,7 @@ int git_packbuilder_foreach(git_packbuilder *pb, int (*cb)(void *buf, size_t siz
 int git_packbuilder_write_buf(git_buf *buf, git_packbuilder *pb)
 {
 	PREPARE_PACK;
+	git_buf_sanitize(buf);
 	return write_pack(pb, &write_pack_buf, buf);
 }
 
diff --git a/src/submodule.c b/src/submodule.c
index 5ddbfe828..b1291df8e 100644
--- a/src/submodule.c
+++ b/src/submodule.c
@@ -641,7 +641,9 @@ int git_submodule_resolve_url(git_buf *out, git_repository *repo, const char *ur
 {
 	int error = 0;
 
-	assert(url);
+	assert(out && repo && url);
+
+	git_buf_sanitize(out);
 
 	if (git_path_is_relative(url)) {
 		if (!(error = get_url_base(out, repo)))
diff --git a/tests/object/blob/filter.c b/tests/object/blob/filter.c
index 0b2d6bf9e..3cc8fdc3d 100644
--- a/tests/object/blob/filter.c
+++ b/tests/object/blob/filter.c
@@ -112,7 +112,7 @@ void test_object_blob_filter__to_odb(void)
 	git_config *cfg;
 	int i;
 	git_blob *blob;
-	git_buf out = GIT_BUF_INIT;
+	git_buf out = GIT_BUF_INIT, zeroed;
 
 	cl_git_pass(git_repository_config(&cfg, g_repo));
 	cl_assert(cfg);
@@ -127,13 +127,20 @@ void test_object_blob_filter__to_odb(void)
 	for (i = 0; i < CRLF_NUM_TEST_OBJECTS; i++) {
 		cl_git_pass(git_blob_lookup(&blob, g_repo, &g_crlf_oids[i]));
 
+		/* try once with allocated blob */
 		cl_git_pass(git_filter_list_apply_to_blob(&out, fl, blob));
-
 		cl_assert_equal_sz(g_crlf_filtered[i].size, out.size);
-
 		cl_assert_equal_i(
 			0, memcmp(out.ptr, g_crlf_filtered[i].ptr, out.size));
 
+		/* try again with zeroed blob */
+		memset(&zeroed, 0, sizeof(zeroed));
+		cl_git_pass(git_filter_list_apply_to_blob(&zeroed, fl, blob));
+		cl_assert_equal_sz(g_crlf_filtered[i].size, zeroed.size);
+		cl_assert_equal_i(
+			0, memcmp(zeroed.ptr, g_crlf_filtered[i].ptr, zeroed.size));
+		git_buf_free(&zeroed);
+
 		git_blob_free(blob);
 	}
 
-- 
cgit v1.2.3


From 45c53eb6cb9ba8ae8bce7d5a70b30b458b7db7e2 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 8 May 2014 10:46:04 -0700
Subject: Use unsigned type for APIs with opt flag mask

---
 include/git2/filter.h     | 3 ++-
 include/git2/sys/filter.h | 6 +++---
 src/filter.c              | 8 ++++----
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/include/git2/filter.h b/include/git2/filter.h
index 7fd9b7e59..e57a67e73 100644
--- a/include/git2/filter.h
+++ b/include/git2/filter.h
@@ -80,6 +80,7 @@ typedef struct git_filter_list git_filter_list;
  * @param blob The blob to which the filter will be applied (if known)
  * @param path Relative path of the file to be filtered
  * @param mode Filtering direction (WT->ODB or ODB->WT)
+ * @param options Combination of `git_filter_opt_t` flags
  * @return 0 on success (which could still return NULL if no filters are
  *         needed for the requested file), <0 on error
  */
@@ -89,7 +90,7 @@ GIT_EXTERN(int) git_filter_list_load(
 	git_blob *blob, /* can be NULL */
 	const char *path,
 	git_filter_mode_t mode,
-	git_filter_opt_t options);
+	uint32_t options);
 
 /**
  * Apply filter list to a data buffer.
diff --git a/include/git2/sys/filter.h b/include/git2/sys/filter.h
index 1b21a9d30..60248271a 100644
--- a/include/git2/sys/filter.h
+++ b/include/git2/sys/filter.h
@@ -58,7 +58,7 @@ GIT_EXTERN(int) git_filter_list_new(
 	git_filter_list **out,
 	git_repository *repo,
 	git_filter_mode_t mode,
-	git_filter_opt_t options);
+	uint32_t options);
 
 /**
  * Add a filter to a filter list with the given payload.
@@ -123,9 +123,9 @@ GIT_EXTERN(const git_oid *) git_filter_source_id(const git_filter_source *src);
 GIT_EXTERN(git_filter_mode_t) git_filter_source_mode(const git_filter_source *src);
 
 /**
- * Get the git_filter_opt_t options to be applied
+ * Get the combination git_filter_opt_t options to be applied
  */
-GIT_EXTERN(git_filter_opt_t) git_filter_source_options(const git_filter_source *src);
+GIT_EXTERN(uint32_t) git_filter_source_options(const git_filter_source *src);
 
 /*
  * struct git_filter
diff --git a/src/filter.c b/src/filter.c
index b0e2b8bea..76d7b7b56 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -23,7 +23,7 @@ struct git_filter_source {
 	git_oid         oid;  /* zero if unknown (which is likely) */
 	uint16_t        filemode; /* zero if unknown */
 	git_filter_mode_t mode;
-	git_filter_opt_t  options;
+	uint32_t        options;
 };
 
 typedef struct {
@@ -359,7 +359,7 @@ git_filter_mode_t git_filter_source_mode(const git_filter_source *src)
 	return src->mode;
 }
 
-git_filter_opt_t git_filter_source_options(const git_filter_source *src)
+uint32_t git_filter_source_options(const git_filter_source *src)
 {
 	return src->options;
 }
@@ -429,7 +429,7 @@ int git_filter_list_new(
 	git_filter_list **out,
 	git_repository *repo,
 	git_filter_mode_t mode,
-	git_filter_opt_t options)
+	uint32_t options)
 {
 	git_filter_source src = { 0 };
 	src.repo = repo;
@@ -445,7 +445,7 @@ int git_filter_list_load(
 	git_blob *blob, /* can be NULL */
 	const char *path,
 	git_filter_mode_t mode,
-	git_filter_opt_t options)
+	uint32_t options)
 {
 	int error = 0;
 	git_filter_list *fl = NULL;
-- 
cgit v1.2.3


From 6bcb0987558390bb8bf0a654f90f47a5ec7c31ee Mon Sep 17 00:00:00 2001
From: Jeff King <peff@peff.net>
Date: Thu, 8 May 2014 00:35:56 -0400
Subject: cmake: s/ICONV/Iconv/ in FIND_PACKAGE

The cmake module we provide is in the file FindIconv.cmake,
so we must match the case correctly. It happens to work in
practice because we only turn on ICONV on Darwin, and people
generally have case-insensitive filesystems there.

Note that we only need to update the package name here. The
package itself still sets the all-uppercase ICONV_FOUND
flag, so we continue to use uppercase in the rest of cmake.
---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 884c9bcf1..6f731d491 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -207,7 +207,7 @@ ENDIF()
 
 # Optional external dependency: iconv
 IF (USE_ICONV)
-	FIND_PACKAGE(ICONV)
+	FIND_PACKAGE(Iconv)
 ENDIF()
 IF (ICONV_FOUND)
 	ADD_DEFINITIONS(-DGIT_USE_ICONV)
-- 
cgit v1.2.3


From 56ec2256f24eb43b09351194d02cd8458ff39708 Mon Sep 17 00:00:00 2001
From: Jeff King <peff@peff.net>
Date: Thu, 8 May 2014 01:06:38 -0400
Subject: examples: add a basic for-each-ref example

This is quite close to running "git for-each-ref" except:

  1. It does not take any formatting or selection options at
     all.

  2. The output is not sorted.

I wrote it to look at debugging some issues with ref
iteration, but there's no reason it can't live on as an
example command.
---
 examples/.gitignore     |  1 +
 examples/Makefile       |  1 +
 examples/for-each-ref.c | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 48 insertions(+)
 create mode 100644 examples/for-each-ref.c

diff --git a/examples/.gitignore b/examples/.gitignore
index b652e28b5..083c8835e 100644
--- a/examples/.gitignore
+++ b/examples/.gitignore
@@ -9,4 +9,5 @@ log
 rev-parse
 status
 tag
+for-each-ref
 *.dSYM
diff --git a/examples/Makefile b/examples/Makefile
index e866b7fee..11b019984 100644
--- a/examples/Makefile
+++ b/examples/Makefile
@@ -4,6 +4,7 @@ CC = gcc
 CFLAGS = -g -I../include -I../src -Wall -Wextra -Wmissing-prototypes -Wno-missing-field-initializers
 LFLAGS = -L../build -lgit2 -lz
 APPS = general showindex diff rev-list cat-file status log rev-parse init blame tag
+APPS += for-each-ref
 
 all: $(APPS)
 
diff --git a/examples/for-each-ref.c b/examples/for-each-ref.c
new file mode 100644
index 000000000..d6846bb0d
--- /dev/null
+++ b/examples/for-each-ref.c
@@ -0,0 +1,46 @@
+#include <git2.h>
+#include <stdio.h>
+#include "common.h"
+
+static int show_ref(git_reference *ref, void *data)
+{
+        git_repository *repo = data;
+        git_reference *resolved = NULL;
+        char hex[GIT_OID_HEXSZ+1];
+        const git_oid *oid;
+        git_object *obj;
+
+        if (git_reference_type(ref) == GIT_REF_SYMBOLIC)
+                check_lg2(git_reference_resolve(&resolved, ref),
+                          "Unable to resolve symbolic reference",
+                          git_reference_name(ref));
+
+        oid = git_reference_target(resolved ? resolved : ref);
+        git_oid_fmt(hex, oid);
+        hex[GIT_OID_HEXSZ] = 0;
+        check_lg2(git_object_lookup(&obj, repo, oid, GIT_OBJ_ANY),
+                  "Unable to lookup object", hex);
+
+        printf("%s %-6s\t%s\n",
+               hex,
+               git_object_type2string(git_object_type(obj)),
+               git_reference_name(ref));
+
+        if (resolved)
+                git_reference_free(resolved);
+        return 0;
+}
+
+int main(int argc, char **argv)
+{
+        git_repository *repo;
+
+        if (argc != 1 || argv[1] /* silence -Wunused-parameter */)
+                fatal("Sorry, no for-each-ref options supported yet", NULL);
+
+        check_lg2(git_repository_open(&repo, "."),
+                  "Could not open repository", NULL);
+        check_lg2(git_reference_foreach(repo, show_ref, repo),
+                  "Could not iterate over references", NULL);
+        return 0;
+}
-- 
cgit v1.2.3


From 2dde1e0c1c398708d6a84763015e690f23cc7511 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 8 May 2014 22:31:59 +0200
Subject: indexer: avoid memory moves

Our vector does a move of the rest of the array when we remove an
item. Doing this repeatedly can be expensive, and we do this a lot in
the indexer. Instead, set the value to NULL and skip those entries.

perf reported around 30% of `index-pack` time was going into
memmove. With this change, that goes away and we spent most of the time
hashing and inflating data.
---
 src/indexer.c | 23 +++++++++++++++--------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/src/indexer.c b/src/indexer.c
index adf5ceaa7..3c8415c7c 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -717,6 +717,9 @@ static int fix_thin_pack(git_indexer *idx, git_transfer_progress *stats)
 
 	/* Loop until we find the first REF delta */
 	git_vector_foreach(&idx->deltas, i, delta) {
+		if (!delta)
+			continue;
+
 		curpos = delta->delta_off;
 		error = git_packfile_unpack_header(&size, &type, &idx->pack->mwf, &w, &curpos);
 		git_mwindow_close(&w);
@@ -756,13 +759,18 @@ static int resolve_deltas(git_indexer *idx, git_transfer_progress *stats)
 {
 	unsigned int i;
 	struct delta_info *delta;
-	int progressed = 0, progress_cb_result;
+	int progressed = 0, non_null = 0, progress_cb_result;
 
 	while (idx->deltas.length > 0) {
 		progressed = 0;
+		non_null = 0;
 		git_vector_foreach(&idx->deltas, i, delta) {
 			git_rawobj obj;
 
+			if (!delta)
+				continue;
+
+			non_null = 1;
 			idx->off = delta->delta_off;
 			if (git_packfile_unpack(&obj, idx->pack, &idx->off) < 0)
 				continue;
@@ -777,16 +785,15 @@ static int resolve_deltas(git_indexer *idx, git_transfer_progress *stats)
 			if ((progress_cb_result = do_progress_callback(idx, stats)) < 0)
 				return progress_cb_result;
 
-			/*
-			 * Remove this delta from the list and
-			 * decrease i so we don't skip over the next
-			 * delta.
-			 */
-			git_vector_remove(&idx->deltas, i);
+			/* remove from the list */
+			git_vector_set(NULL, &idx->deltas, i, NULL);
 			git__free(delta);
-			i--;
 		}
 
+		/* if none were actually set, we're done */
+		if (!non_null)
+			break;
+
 		if (!progressed && (fix_thin_pack(idx, stats) < 0)) {
 			giterr_set(GITERR_INDEXER, "missing delta bases");
 			return -1;
-- 
cgit v1.2.3


From 43a0413524fcb3b7e3405382c050a0b3c45cf257 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 8 May 2014 13:52:46 -0700
Subject: Pass unconverted data when iconv doesn't like it

When using Iconv to convert unicode data and iconv doesn't like
the source data (because it thinks that it's not actual UTF-8),
instead of stopping the operation, just use the unconverted data.
This will generally do the right thing on the filesystem, since
that is the source of the non-UTF-8 path data anyhow.

This adds some tests for creating and looking up branches with
messy Unicode names.  Also, this takes the helper function that
was previously internal to `git_repository_init` and makes it
into `git_path_does_fs_decompose_unicode` which is a useful in
tests to understand what the expected results should be.
---
 src/path.c                   | 63 +++++++++++++++++++++++++++++++++++++++++++-
 src/path.h                   |  2 ++
 src/repository.c             | 57 ++-------------------------------------
 tests/refs/branches/create.c | 56 +++++++++++++++++++++++++++++++++++++++
 4 files changed, 122 insertions(+), 56 deletions(-)

diff --git a/src/path.c b/src/path.c
index 2690cd8e8..e0b00a086 100644
--- a/src/path.c
+++ b/src/path.c
@@ -799,8 +799,11 @@ int git_path_iconv(git_path_iconv_t *ic, char **in, size_t *inlen)
 		if (rv != (size_t)-1)
 			break;
 
+		/* if we cannot convert the data (probably because iconv thinks
+		 * it is not valid UTF-8 source data), then use original data
+		 */
 		if (errno != E2BIG)
-			goto fail;
+			return 0;
 
 		/* make space for 2x the remaining data to be converted
 		 * (with per retry overhead to avoid infinite loops)
@@ -823,6 +826,64 @@ fail:
 	return -1;
 }
 
+static const char *nfc_file = "\xC3\x85\x73\x74\x72\xC3\xB6\x6D.XXXXXX";
+static const char *nfd_file = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D.XXXXXX";
+
+/* Check if the platform is decomposing unicode data for us.  We will
+ * emulate core Git and prefer to use precomposed unicode data internally
+ * on these platforms, composing the decomposed unicode on the fly.
+ *
+ * This mainly happens on the Mac where HDFS stores filenames as
+ * decomposed unicode.  Even on VFAT and SAMBA file systems, the Mac will
+ * return decomposed unicode from readdir() even when the actual
+ * filesystem is storing precomposed unicode.
+ */
+bool git_path_does_fs_decompose_unicode(const char *root)
+{
+	git_buf path = GIT_BUF_INIT;
+	int fd;
+	bool found_decomposed = false;
+	char tmp[6];
+
+	/* Create a file using a precomposed path and then try to find it
+	 * using the decomposed name.  If the lookup fails, then we will mark
+	 * that we should precompose unicode for this repository.
+	 */
+	if (git_buf_joinpath(&path, root, nfc_file) < 0 ||
+		(fd = p_mkstemp(path.ptr)) < 0)
+		goto done;
+	p_close(fd);
+
+	/* record trailing digits generated by mkstemp */
+	memcpy(tmp, path.ptr + path.size - sizeof(tmp), sizeof(tmp));
+
+	/* try to look up as NFD path */
+	if (git_buf_joinpath(&path, root, nfd_file) < 0)
+		goto done;
+	memcpy(path.ptr + path.size - sizeof(tmp), tmp, sizeof(tmp));
+
+	found_decomposed = git_path_exists(path.ptr);
+
+	/* remove temporary file (using original precomposed path) */
+	if (git_buf_joinpath(&path, root, nfc_file) < 0)
+		goto done;
+	memcpy(path.ptr + path.size - sizeof(tmp), tmp, sizeof(tmp));
+
+	(void)p_unlink(path.ptr);
+
+done:
+	git_buf_free(&path);
+	return found_decomposed;
+}
+
+#else
+
+bool git_path_does_fs_decompose_unicode(const char *root)
+{
+	GIT_UNUSED(root);
+	return false;
+}
+
 #endif
 
 #if defined(__sun) || defined(__GNU__)
diff --git a/src/path.h b/src/path.h
index 2367d707b..3213c5104 100644
--- a/src/path.h
+++ b/src/path.h
@@ -436,4 +436,6 @@ extern int git_path_iconv(git_path_iconv_t *ic, char **in, size_t *inlen);
 
 #endif /* GIT_USE_ICONV */
 
+extern bool git_path_does_fs_decompose_unicode(const char *root);
+
 #endif
diff --git a/src/repository.c b/src/repository.c
index ac7af7692..466f2d341 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -880,60 +880,6 @@ static bool are_symlinks_supported(const char *wd_path)
 	return symlinks_supported;
 }
 
-#ifdef GIT_USE_ICONV
-
-static const char *nfc_file = "\xC3\x85\x73\x74\x72\xC3\xB6\x6D.XXXXXX";
-static const char *nfd_file = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D.XXXXXX";
-
-/* Check if the platform is decomposing unicode data for us.  We will
- * emulate core Git and prefer to use precomposed unicode data internally
- * on these platforms, composing the decomposed unicode on the fly.
- *
- * This mainly happens on the Mac where HDFS stores filenames as
- * decomposed unicode.  Even on VFAT and SAMBA file systems, the Mac will
- * return decomposed unicode from readdir() even when the actual
- * filesystem is storing precomposed unicode.
- */
-static bool does_fs_decompose_unicode_paths(const char *wd_path)
-{
-	git_buf path = GIT_BUF_INIT;
-	int fd;
-	bool found_decomposed = false;
-	char tmp[6];
-
-	/* Create a file using a precomposed path and then try to find it
-	 * using the decomposed name.  If the lookup fails, then we will mark
-	 * that we should precompose unicode for this repository.
-	 */
-	if (git_buf_joinpath(&path, wd_path, nfc_file) < 0 ||
-		(fd = p_mkstemp(path.ptr)) < 0)
-		goto done;
-	p_close(fd);
-
-	/* record trailing digits generated by mkstemp */
-	memcpy(tmp, path.ptr + path.size - sizeof(tmp), sizeof(tmp));
-
-	/* try to look up as NFD path */
-	if (git_buf_joinpath(&path, wd_path, nfd_file) < 0)
-		goto done;
-	memcpy(path.ptr + path.size - sizeof(tmp), tmp, sizeof(tmp));
-
-	found_decomposed = git_path_exists(path.ptr);
-
-	/* remove temporary file (using original precomposed path) */
-	if (git_buf_joinpath(&path, wd_path, nfc_file) < 0)
-		goto done;
-	memcpy(path.ptr + path.size - sizeof(tmp), tmp, sizeof(tmp));
-
-	(void)p_unlink(path.ptr);
-
-done:
-	git_buf_free(&path);
-	return found_decomposed;
-}
-
-#endif
-
 static int create_empty_file(const char *path, mode_t mode)
 {
 	int fd;
@@ -1024,8 +970,9 @@ static int repo_init_fs_configs(
 #ifdef GIT_USE_ICONV
 	if ((error = git_config_set_bool(
 			cfg, "core.precomposeunicode",
-			does_fs_decompose_unicode_paths(work_dir))) < 0)
+			git_path_does_fs_decompose_unicode(work_dir))) < 0)
 		return error;
+	/* on non-iconv platforms, don't even set core.precomposeunicode */
 #endif
 
 	return 0;
diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 38af2f681..518d4e93e 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -1,5 +1,6 @@
 #include "clar_libgit2.h"
 #include "refs.h"
+#include "path.h"
 
 static git_repository *repo;
 static git_commit *target;
@@ -137,3 +138,58 @@ void test_refs_branches_create__default_reflog_message(void)
 	git_reflog_free(log);
 	git_signature_free(sig);
 }
+
+static void assert_branch_matches_name(
+	const char *expected, const char *lookup_as)
+{
+	git_reference *ref;
+	git_buf b = GIT_BUF_INIT;
+
+	cl_git_pass(git_branch_lookup(&ref, repo, lookup_as, GIT_BRANCH_LOCAL));
+
+	cl_git_pass(git_buf_sets(&b, "refs/heads/"));
+	cl_git_pass(git_buf_puts(&b, expected));
+	cl_assert_equal_s(b.ptr, git_reference_name(ref));
+
+	cl_git_pass(
+		git_oid_cmp(git_reference_target(ref), git_commit_id(target)));
+
+	git_reference_free(ref);
+	git_buf_free(&b);
+}
+
+void test_refs_branches_create__can_create_branch_with_unicode(void)
+{
+	const char *nfc = "\xC3\x85\x73\x74\x72\xC3\xB6\x6D";
+	const char *nfd = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D";
+	const char *emoji = "\xF0\x9F\x8D\xB7";
+	const char *names[] = { nfc, nfd, emoji };
+	const char *alt[] = { nfd, nfc, NULL };
+	const char *expected[] = { nfc, nfd, emoji };
+	unsigned int i;
+
+	retrieve_known_commit(&target, repo);
+
+	if (cl_repo_get_bool(repo, "core.precomposeunicode"))
+		expected[1] = nfc;
+#ifdef __APPLE__
+	/* test decomp. because not all Mac filesystems decompose unicode */
+	else if (git_path_does_fs_decompose_unicode(git_repository_path(repo)))
+		expected[0] = nfd;
+#endif
+
+	for (i = 0; i < ARRAY_SIZE(names); ++i) {
+		cl_git_pass(git_branch_create(
+			&branch, repo, names[i], target, 0, NULL, NULL));
+		cl_git_pass(git_oid_cmp(
+			git_reference_target(branch), git_commit_id(target)));
+
+		assert_branch_matches_name(expected[i], names[i]);
+		if (alt[i])
+			assert_branch_matches_name(expected[i], alt[i]);
+
+		cl_git_pass(git_branch_delete(branch));
+		git_reference_free(branch);
+		branch = NULL;
+	}
+}
-- 
cgit v1.2.3


From be20ac5a1d170aa1143bb2d1367bc224a88f54d1 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 8 May 2014 14:33:37 -0700
Subject: Allow cl_repo_get_bool to work with missing key

One of the test helpers provides a quick way for looking up a
boolean key.  But if the key way missing completely, the check
would actually raise an error.  Given the way we use this helper,
if the key is missing, this should just return false, I think.
---
 tests/clar_libgit2.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c
index f457adb33..b2730f4d1 100644
--- a/tests/clar_libgit2.c
+++ b/tests/clar_libgit2.c
@@ -408,7 +408,8 @@ int cl_repo_get_bool(git_repository *repo, const char *cfg)
 	int val = 0;
 	git_config *config;
 	cl_git_pass(git_repository_config(&config, repo));
-	cl_git_pass(git_config_get_bool(&val, config, cfg));;
+	if (git_config_get_bool(&val, config, cfg) < 0)
+		giterr_clear();
 	git_config_free(config);
 	return val;
 }
-- 
cgit v1.2.3


From 8a2ef218b99c41923dc32e25dc0915f68e2e4bca Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 8 May 2014 14:48:27 -0700
Subject: Don't always test composed-insensitive lookups

Only on a filesystem that is composed/decomposed insensitive,
should be testing that a branch can be looked up by the opposite
form and still work correctly.
---
 tests/refs/branches/create.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 518d4e93e..864640ab3 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -167,16 +167,16 @@ void test_refs_branches_create__can_create_branch_with_unicode(void)
 	const char *alt[] = { nfd, nfc, NULL };
 	const char *expected[] = { nfc, nfd, emoji };
 	unsigned int i;
+	bool fs_decompose_unicode =
+		git_path_does_fs_decompose_unicode(git_repository_path(repo));
 
 	retrieve_known_commit(&target, repo);
 
 	if (cl_repo_get_bool(repo, "core.precomposeunicode"))
 		expected[1] = nfc;
-#ifdef __APPLE__
 	/* test decomp. because not all Mac filesystems decompose unicode */
-	else if (git_path_does_fs_decompose_unicode(git_repository_path(repo)))
+	else if (fs_decompose_unicode)
 		expected[0] = nfd;
-#endif
 
 	for (i = 0; i < ARRAY_SIZE(names); ++i) {
 		cl_git_pass(git_branch_create(
@@ -185,7 +185,7 @@ void test_refs_branches_create__can_create_branch_with_unicode(void)
 			git_reference_target(branch), git_commit_id(target)));
 
 		assert_branch_matches_name(expected[i], names[i]);
-		if (alt[i])
+		if (fs_decompose_unicode && alt[i])
 			assert_branch_matches_name(expected[i], alt[i]);
 
 		cl_git_pass(git_branch_delete(branch));
-- 
cgit v1.2.3


From bb45e39063669514b84ac5b47c3520cfe99396c3 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 8 May 2014 15:01:07 -0700
Subject: Disable threads::refdb::edit_while_iterate test

It seems that with the various recent changes to reference updating
and reflog writing, that the thread safety of refdb updates has
been reduced (either that or it was never thread safe and the
window for error has increased).  Either way, this test is now
sometimes segfaulting which is no good, so let's disable the test
for now.  We don't really make any public promises about thread
safety for this type of operation, so I think this is acceptable,
at least in the short term.
---
 tests/threads/refdb.c | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/tests/threads/refdb.c b/tests/threads/refdb.c
index 3b35b45e3..c1cd29677 100644
--- a/tests/threads/refdb.c
+++ b/tests/threads/refdb.c
@@ -190,17 +190,22 @@ void test_threads_refdb__edit_while_iterate(void)
 		}
 
 		id[t] = t;
-#ifdef GIT_THREADS
-		cl_git_pass(git_thread_create(&th[t], NULL, fn, &id[t]));
-#else
+
+		/* It appears with all reflog writing changes, etc., that this
+		 * test has started to fail quite frequently, so let's disable it
+		 * for now by just running on a single thread...
+		 */
+/* #ifdef GIT_THREADS */
+/*		cl_git_pass(git_thread_create(&th[t], NULL, fn, &id[t])); */
+/* #else */
 		fn(&id[t]);
-#endif
+/* #endif */
 	}
 
 #ifdef GIT_THREADS
-	for (t = 0; t < THREADS; ++t) {
-		cl_git_pass(git_thread_join(th[t], NULL));
-	}
+/*	for (t = 0; t < THREADS; ++t) { */
+/*		cl_git_pass(git_thread_join(th[t], NULL)); */
+/*	} */
 
 	memset(th, 0, sizeof(th));
 
-- 
cgit v1.2.3


From 86d5810b82965224b1270c3627da029588935abb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 6 May 2014 16:20:14 +0200
Subject: pack: remove misleading comment

---
 src/pack.c | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index de038a45c..9c6a4e78b 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -546,13 +546,6 @@ static int packfile_unpack_delta(
 
 	if (!cached) { /* have to inflate it */
 		error = git_packfile_unpack(&base, p, &base_offset);
-
-		/*
-		 * TODO: git.git tries to load the base from other packfiles
-		 * or loose objects.
-		 *
-		 * We'll need to do this in order to support thin packs.
-		 */
 		if (error < 0)
 			return error;
 	}
-- 
cgit v1.2.3


From ae0817393c0aaff5c4b085c46ed11acc0ab64198 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 6 May 2014 21:21:04 +0200
Subject: pack: do not repeat the same error message four times

Repeating this error message makes it harder to find out where we
actually are finding the error, and they don't really describe what
we're trying to do.
---
 src/pack.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index 9c6a4e78b..b9374d04f 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -653,7 +653,7 @@ int git_packfile_stream_open(git_packfile_stream *obj, struct git_pack_file *p,
 	st = inflateInit(&obj->zstream);
 	if (st != Z_OK) {
 		git__free(obj);
-		giterr_set(GITERR_ZLIB, "Failed to inflate packfile");
+		giterr_set(GITERR_ZLIB, "failed to init packfile stream");
 		return -1;
 	}
 
@@ -684,7 +684,7 @@ ssize_t git_packfile_stream_read(git_packfile_stream *obj, void *buffer, size_t
 	written = len - obj->zstream.avail_out;
 
 	if (st != Z_OK && st != Z_STREAM_END) {
-		giterr_set(GITERR_ZLIB, "Failed to inflate packfile");
+		giterr_set(GITERR_ZLIB, "error reading from the zlib stream");
 		return -1;
 	}
 
@@ -729,7 +729,7 @@ int packfile_unpack_compressed(
 	st = inflateInit(&stream);
 	if (st != Z_OK) {
 		git__free(buffer);
-		giterr_set(GITERR_ZLIB, "Failed to inflate packfile");
+		giterr_set(GITERR_ZLIB, "failed to init zlib stream on unpack");
 
 		return -1;
 	}
@@ -756,7 +756,7 @@ int packfile_unpack_compressed(
 
 	if ((st != Z_STREAM_END) || stream.total_out != size) {
 		git__free(buffer);
-		giterr_set(GITERR_ZLIB, "Failed to inflate packfile");
+		giterr_set(GITERR_ZLIB, "error inflating zlib stream");
 		return -1;
 	}
 
-- 
cgit v1.2.3


From 2acdf4b854bf55ba2630c7342d09b136d919d6ad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 6 May 2014 19:20:33 +0200
Subject: pack: unpack using a loop

We currently make use of recursive function calls to unpack an object,
resolving the deltas as we come back down the chain. This means that we
have unbounded stack growth as we look up objects in a pack.

This is now done in two steps: first we figure out what the dependency
chain is by looking up the delta bases until we reach a non-delta
object, pushing the information we need onto a stack and then we pop
from that stack and apply the deltas until there are no more left.

This version of the code does not make use of the delta base cache so it
is slower than what's in the mainline. A later commit will reintroduce
it.
---
 src/pack.c | 144 ++++++++++++++++++++++++++++++++++++++++++++++++++-----------
 src/pack.h |   9 ++++
 2 files changed, 128 insertions(+), 25 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index b9374d04f..523905f8f 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -40,6 +40,13 @@ static int pack_entry_find_offset(
 		const git_oid *short_oid,
 		size_t len);
 
+/**
+ * Generate the chain of dependencies which we need to get to the
+ * object at `off`. As we use a stack, the latest is the base object,
+ * the rest are deltas.
+ */
+static int pack_dependency_chain(git_dependency_chain *chain, struct git_pack_file *p, git_off_t off);
+
 static int packfile_error(const char *message)
 {
 	giterr_set(GITERR_ODB, "Invalid pack file - %s", message);
@@ -583,47 +590,63 @@ int git_packfile_unpack(
 	git_mwindow *w_curs = NULL;
 	git_off_t curpos = *obj_offset;
 	int error;
+	git_dependency_chain chain;
+	struct pack_chain_elem *elem;
 
-	size_t size = 0;
-	git_otype type;
+	git_otype base_type;
 
 	/*
 	 * TODO: optionally check the CRC on the packfile
 	 */
 
+	error = pack_dependency_chain(&chain, p, *obj_offset);
+	if (error < 0)
+		return error;
+
 	obj->data = NULL;
 	obj->len = 0;
 	obj->type = GIT_OBJ_BAD;
 
-	error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos);
+	/* the first one is the base, so we expand that one */
+	elem = git_array_pop(chain);
+	curpos = elem->offset;
+	error = packfile_unpack_compressed(obj, p, &w_curs, &curpos, elem->size, elem->type);
 	git_mwindow_close(&w_curs);
 
 	if (error < 0)
-		return error;
+		goto cleanup;
+
+	base_type = elem->type;
+	/* we now apply each consecutive delta until we run out */
+	while (git_array_size(chain) > 0) {
+		git_rawobj base, delta;
+
+		elem = git_array_pop(chain);
+		curpos = elem->offset;
+		error = packfile_unpack_compressed(&delta, p, &w_curs, &curpos, elem->size, elem->type);
+		git_mwindow_close(&w_curs);
+
+		if (error < 0)
+			break;
+
+		/* the current object becomes the new base, on which we apply the delta */
+		base = *obj;
+		obj->data = NULL;
+		obj->len = 0;
+		obj->type = GIT_OBJ_BAD;
+
+		error = git__delta_apply(obj, base.data, base.len, delta.data, delta.len);
+		git__free(delta.data);
+		git__free(base.data);
+
+		if (error < 0)
+			break;
 
-	switch (type) {
-	case GIT_OBJ_OFS_DELTA:
-	case GIT_OBJ_REF_DELTA:
-		error = packfile_unpack_delta(
-				obj, p, &w_curs, &curpos,
-				size, type, *obj_offset);
-		break;
-
-	case GIT_OBJ_COMMIT:
-	case GIT_OBJ_TREE:
-	case GIT_OBJ_BLOB:
-	case GIT_OBJ_TAG:
-		error = packfile_unpack_compressed(
-				obj, p, &w_curs, &curpos,
-				size, type);
-		break;
-
-	default:
-		error = packfile_error("invalid packfile type in header");;
-		break;
+		obj->type = base_type;
 	}
 
-	*obj_offset = curpos;
+cleanup:
+	git_array_clear(chain);
 	return error;
 }
 
@@ -1215,3 +1238,74 @@ int git_pack_entry_find(
 	git_oid_cpy(&e->sha1, &found_oid);
 	return 0;
 }
+
+static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pack_file *p, git_off_t obj_offset)
+{
+	git_dependency_chain chain = GIT_ARRAY_INIT;
+	git_mwindow *w_curs = NULL;
+	git_off_t curpos = obj_offset, base_offset;
+	int error = 0, found_base = 0;
+	size_t size;
+	git_otype type;
+
+	while (!found_base && error == 0) {
+		struct pack_chain_elem *elem;
+
+		curpos = obj_offset;
+		elem = git_array_alloc(chain);
+		if (!elem)
+			return -1;
+
+		error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos);
+		git_mwindow_close(&w_curs);
+
+		if (error < 0)
+			return error;
+
+		elem->offset = curpos;
+		elem->size = size;
+		elem->type = type;
+
+		switch (type) {
+		case GIT_OBJ_OFS_DELTA:
+		case GIT_OBJ_REF_DELTA:
+			base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
+			git_mwindow_close(&w_curs);
+
+			if (base_offset == 0)
+				return packfile_error("delta offset is zero");
+			if (base_offset < 0) /* must actually be an error code */
+				return (int)base_offset;
+
+			/* we need to pass the pos *after* the delta-base bit */
+			elem->offset = curpos;
+
+			/* go through the loop again, but with the new object */
+			obj_offset = base_offset;
+			break;
+
+		/* one of these means we've found the final object in the chain */
+		case GIT_OBJ_COMMIT:
+		case GIT_OBJ_TREE:
+		case GIT_OBJ_BLOB:
+		case GIT_OBJ_TAG:
+			found_base = 1;
+			break;
+
+		default:
+			error = packfile_error("invalid packfile type in header");
+			break;
+		}
+	}
+
+	if (!found_base) {
+		git_array_clear(chain);
+		return packfile_error("after dependency chain loop; cannot happen");
+	}
+
+	if (error < 0)
+		git_array_clear(chain);
+
+	*chain_out = chain;
+	return error;
+}
diff --git a/src/pack.h b/src/pack.h
index 58f81e2f0..a2ea3849f 100644
--- a/src/pack.h
+++ b/src/pack.h
@@ -17,6 +17,7 @@
 #include "mwindow.h"
 #include "odb.h"
 #include "oidmap.h"
+#include "array.h"
 
 #define GIT_PACK_FILE_MODE 0444
 
@@ -60,6 +61,14 @@ typedef struct git_pack_cache_entry {
 	git_rawobj raw;
 } git_pack_cache_entry;
 
+struct pack_chain_elem {
+	git_off_t offset;
+	size_t size;
+	git_otype type;
+};
+
+typedef git_array_t(struct pack_chain_elem) git_dependency_chain;
+
 #include "offmap.h"
 
 GIT__USE_OFFMAP;
-- 
cgit v1.2.3


From a332e91c92524cc21818eadfbe723361d31dc187 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 6 May 2014 23:37:28 +0200
Subject: pack: use a cache for delta bases when unpacking

Bring back the use of the delta base cache for unpacking objects. When
generating the delta chain, we stop when we find a delta base in the
pack's cache and use that as the starting point.
---
 src/pack.c | 145 ++++++++++++++++++++++++++++++-------------------------------
 src/pack.h |   5 +++
 2 files changed, 77 insertions(+), 73 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index 523905f8f..c1d7592fd 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -42,8 +42,9 @@ static int pack_entry_find_offset(
 
 /**
  * Generate the chain of dependencies which we need to get to the
- * object at `off`. As we use a stack, the latest is the base object,
- * the rest are deltas.
+ * object at `off`. `chain` is used a stack, popping gives the right
+ * order to apply deltas on. If an object is found in the pack's base
+ * cache, we stop calculating there.
  */
 static int pack_dependency_chain(git_dependency_chain *chain, struct git_pack_file *p, git_off_t off);
 
@@ -521,67 +522,6 @@ int git_packfile_resolve_header(
 	return error;
 }
 
-static int packfile_unpack_delta(
-		git_rawobj *obj,
-		struct git_pack_file *p,
-		git_mwindow **w_curs,
-		git_off_t *curpos,
-		size_t delta_size,
-		git_otype delta_type,
-		git_off_t obj_offset)
-{
-	git_off_t base_offset, base_key;
-	git_rawobj base, delta;
-	git_pack_cache_entry *cached = NULL;
-	int error, found_base = 0;
-
-	base_offset = get_delta_base(p, w_curs, curpos, delta_type, obj_offset);
-	git_mwindow_close(w_curs);
-	if (base_offset == 0)
-		return packfile_error("delta offset is zero");
-	if (base_offset < 0) /* must actually be an error code */
-		return (int)base_offset;
-
-	if (!p->bases.entries && (cache_init(&p->bases) < 0))
-		return -1;
-
-	base_key = base_offset; /* git_packfile_unpack modifies base_offset */
-	if ((cached = cache_get(&p->bases, base_offset)) != NULL) {
-		memcpy(&base, &cached->raw, sizeof(git_rawobj));
-		found_base = 1;
-	}
-
-	if (!cached) { /* have to inflate it */
-		error = git_packfile_unpack(&base, p, &base_offset);
-		if (error < 0)
-			return error;
-	}
-
-	error = packfile_unpack_compressed(&delta, p, w_curs, curpos, delta_size, delta_type);
-	git_mwindow_close(w_curs);
-
-	if (error < 0) {
-		if (!found_base)
-			git__free(base.data);
-		return error;
-	}
-
-	obj->type = base.type;
-	error = git__delta_apply(obj, base.data, base.len, delta.data, delta.len);
-	if (error < 0)
-		goto on_error;
-
-	if (found_base)
-		git_atomic_dec(&cached->refcount);
-	else if (cache_add(&p->bases, &base, base_key) < 0)
-		git__free(base.data);
-
-on_error:
-	git__free(delta.data);
-
-	return error; /* error set by git__delta_apply */
-}
-
 int git_packfile_unpack(
 	git_rawobj *obj,
 	struct git_pack_file *p,
@@ -589,10 +529,10 @@ int git_packfile_unpack(
 {
 	git_mwindow *w_curs = NULL;
 	git_off_t curpos = *obj_offset;
-	int error;
-	git_dependency_chain chain;
+	int error, free_base = 0;
+	git_dependency_chain chain = GIT_ARRAY_INIT;
 	struct pack_chain_elem *elem;
-
+	git_pack_cache_entry *cached = NULL;
 	git_otype base_type;
 
 	/*
@@ -609,16 +549,38 @@ int git_packfile_unpack(
 
 	/* the first one is the base, so we expand that one */
 	elem = git_array_pop(chain);
-	curpos = elem->offset;
-	error = packfile_unpack_compressed(obj, p, &w_curs, &curpos, elem->size, elem->type);
-	git_mwindow_close(&w_curs);
+	if (elem->cached) {
+		cached = elem->cached_entry;
+		memcpy(obj, &cached->raw, sizeof(git_rawobj));
+		base_type = obj->type;
+	} else {
+		curpos = elem->offset;
+		error = packfile_unpack_compressed(obj, p, &w_curs, &curpos, elem->size, elem->type);
+		git_mwindow_close(&w_curs);
+		base_type = elem->type;
+		free_base = 1;
+	}
 
 	if (error < 0)
 		goto cleanup;
 
-	base_type = elem->type;
+	/*
+	 * Finding the object we want as the base element is
+	 * problematic, as we need to make sure we don't accidentally
+	 * give the caller the cached object, which it would then feel
+	 * free to free, so we need to copy the data.
+	 */
+	if (cached && git_array_size(chain) == 0) {
+		void *data = obj->data;
+		obj->data = git__malloc(obj->len + 1);
+		GITERR_CHECK_ALLOC(obj->data);
+		memcpy(obj->data, data, obj->len + 1);
+		git_atomic_dec(&cached->refcount);
+		goto cleanup;
+	}
+
 	/* we now apply each consecutive delta until we run out */
-	while (git_array_size(chain) > 0) {
+	while (git_array_size(chain) > 0 && !error) {
 		git_rawobj base, delta;
 
 		elem = git_array_pop(chain);
@@ -636,16 +598,39 @@ int git_packfile_unpack(
 		obj->type = GIT_OBJ_BAD;
 
 		error = git__delta_apply(obj, base.data, base.len, delta.data, delta.len);
+		obj->type = base_type;
+		/*
+		 * We usually don't want to free the base at this
+		 * point, as we put it into the cache in the previous
+		 * iteration. free_base lets us know that we got the
+		 * base object directly from the packfile, so we can free it.
+		 */
 		git__free(delta.data);
-		git__free(base.data);
+		if (free_base) {
+			free_base = 0;
+			git__free(base.data);
+		}
+
+		if (cached) {
+			git_atomic_dec(&cached->refcount);
+			cached = NULL;
+		}
 
 		if (error < 0)
 			break;
 
-		obj->type = base_type;
+		/* only try to cache if we're not handing this buffer off to the caller */
+		if (git_array_size(chain) > 0 &&
+		    (error = cache_add(&p->bases, obj, elem->base_key)) < 0)
+			goto cleanup;
 	}
 
 cleanup:
+	if (error < 0)
+		git__free(obj->data);
+
+	*obj_offset = elem->offset;
+
 	git_array_clear(chain);
 	return error;
 }
@@ -1248,8 +1233,12 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 	size_t size;
 	git_otype type;
 
+	if (!p->bases.entries && (cache_init(&p->bases) < 0))
+		return -1;
+
 	while (!found_base && error == 0) {
 		struct pack_chain_elem *elem;
+		git_pack_cache_entry *cached = NULL;
 
 		curpos = obj_offset;
 		elem = git_array_alloc(chain);
@@ -1262,13 +1251,23 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 		if (error < 0)
 			return error;
 
+		elem->cached = 0;
 		elem->offset = curpos;
 		elem->size = size;
 		elem->type = type;
+		elem->base_key = obj_offset;
 
 		switch (type) {
 		case GIT_OBJ_OFS_DELTA:
 		case GIT_OBJ_REF_DELTA:
+			/* if we have a base cached, we can stop here instead */
+			if ((cached = cache_get(&p->bases, obj_offset)) != NULL) {
+				elem->cached_entry = cached;
+				elem->cached = 1;
+				found_base = 1;
+				break;
+			}
+
 			base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
 			git_mwindow_close(&w_curs);
 
diff --git a/src/pack.h b/src/pack.h
index a2ea3849f..e86889d1b 100644
--- a/src/pack.h
+++ b/src/pack.h
@@ -62,9 +62,14 @@ typedef struct git_pack_cache_entry {
 } git_pack_cache_entry;
 
 struct pack_chain_elem {
+	int cached;
+	git_off_t base_key;
+	/* if we don't have it cached we have this */
 	git_off_t offset;
 	size_t size;
 	git_otype type;
+	/* if cached, we have this instead */
+	git_pack_cache_entry *cached_entry;
 };
 
 typedef git_array_t(struct pack_chain_elem) git_dependency_chain;
-- 
cgit v1.2.3


From e6d10c58b547181fe19f6bacff6bd0dee9f67b9b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 8 May 2014 16:24:54 +0200
Subject: pack: make sure not to leak the dep chain

---
 src/pack.c | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index c1d7592fd..a8577d389 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -1242,14 +1242,16 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 
 		curpos = obj_offset;
 		elem = git_array_alloc(chain);
-		if (!elem)
-			return -1;
+		if (!elem) {
+			error = -1;
+			goto on_error;
+		}
 
 		error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos);
 		git_mwindow_close(&w_curs);
 
 		if (error < 0)
-			return error;
+			goto on_error;
 
 		elem->cached = 0;
 		elem->offset = curpos;
@@ -1273,8 +1275,10 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 
 			if (base_offset == 0)
 				return packfile_error("delta offset is zero");
-			if (base_offset < 0) /* must actually be an error code */
-				return (int)base_offset;
+			if (base_offset < 0) { /* must actually be an error code */
+				error = (int)base_offset;
+				goto on_error;
+			}
 
 			/* we need to pass the pos *after* the delta-base bit */
 			elem->offset = curpos;
@@ -1302,9 +1306,10 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 		return packfile_error("after dependency chain loop; cannot happen");
 	}
 
-	if (error < 0)
-		git_array_clear(chain);
-
 	*chain_out = chain;
 	return error;
+
+on_error:
+	git_array_clear(chain);
+	return error;
 }
-- 
cgit v1.2.3


From b2559f477a3f8e2bc76140ca2c76d8cc30b5f5da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 8 May 2014 17:14:59 +0200
Subject: pack: preallocate a 64-element chain

Dependency chains are often large and require a few
reallocations. Allocate a 64-element chain before doing anything else to
avoid allocations during the loop.

This value comes from the stack-allocated one git uses. We still
allocate this on the heap, but it does help performance a little bit.
---
 src/pack.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/pack.c b/src/pack.c
index a8577d389..664e8efb0 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -1236,6 +1236,7 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 	if (!p->bases.entries && (cache_init(&p->bases) < 0))
 		return -1;
 
+	git_array_init_to_size(chain, 64);
 	while (!found_base && error == 0) {
 		struct pack_chain_elem *elem;
 		git_pack_cache_entry *cached = NULL;
-- 
cgit v1.2.3


From 9dbd150f5f499bbf768d65c4ebb596651e77a1b8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 9 May 2014 09:36:09 +0200
Subject: pack: simplify delta chain code

The switch makes the loop somewhat unwieldy. Let's assume it's fine and
perform the check when we're accessing the data.

This makes our code look a lot more like git's.
---
 src/pack.c | 100 +++++++++++++++++++++++++++++++------------------------------
 1 file changed, 51 insertions(+), 49 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index 664e8efb0..e1fd276b7 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -549,21 +549,38 @@ int git_packfile_unpack(
 
 	/* the first one is the base, so we expand that one */
 	elem = git_array_pop(chain);
+	base_type = elem->type;
 	if (elem->cached) {
 		cached = elem->cached_entry;
 		memcpy(obj, &cached->raw, sizeof(git_rawobj));
-		base_type = obj->type;
-	} else {
-		curpos = elem->offset;
-		error = packfile_unpack_compressed(obj, p, &w_curs, &curpos, elem->size, elem->type);
-		git_mwindow_close(&w_curs);
-		base_type = elem->type;
-		free_base = 1;
 	}
 
 	if (error < 0)
 		goto cleanup;
 
+	switch (base_type) {
+	case GIT_OBJ_COMMIT:
+	case GIT_OBJ_TREE:
+	case GIT_OBJ_BLOB:
+	case GIT_OBJ_TAG:
+		if (!elem->cached) {
+			curpos = elem->offset;
+			error = packfile_unpack_compressed(obj, p, &w_curs, &curpos, elem->size, elem->type);
+			git_mwindow_close(&w_curs);
+			free_base = 1;
+		}
+		if (error < 0)
+			goto cleanup;
+		break;
+	case GIT_OBJ_OFS_DELTA:
+	case GIT_OBJ_REF_DELTA:
+		error = packfile_error("dependency chain ends in a delta");
+		goto cleanup;
+	default:
+		error = packfile_error("invalid packfile type in header");
+		goto cleanup;
+	}
+
 	/*
 	 * Finding the object we want as the base element is
 	 * problematic, as we need to make sure we don't accidentally
@@ -1229,7 +1246,7 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 	git_dependency_chain chain = GIT_ARRAY_INIT;
 	git_mwindow *w_curs = NULL;
 	git_off_t curpos = obj_offset, base_offset;
-	int error = 0, found_base = 0;
+	int error = 0;
 	size_t size;
 	git_otype type;
 
@@ -1237,7 +1254,7 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 		return -1;
 
 	git_array_init_to_size(chain, 64);
-	while (!found_base && error == 0) {
+	while (true) {
 		struct pack_chain_elem *elem;
 		git_pack_cache_entry *cached = NULL;
 
@@ -1248,6 +1265,16 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 			goto on_error;
 		}
 
+		elem->base_key = obj_offset;
+
+		/* if we have a base cached, we can stop here instead */
+		if ((cached = cache_get(&p->bases, obj_offset)) != NULL) {
+			elem->cached_entry = cached;
+			elem->cached = 1;
+			elem->type = cached->raw.type;
+			break;
+		}
+
 		error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos);
 		git_mwindow_close(&w_curs);
 
@@ -1260,51 +1287,26 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pac
 		elem->type = type;
 		elem->base_key = obj_offset;
 
-		switch (type) {
-		case GIT_OBJ_OFS_DELTA:
-		case GIT_OBJ_REF_DELTA:
-			/* if we have a base cached, we can stop here instead */
-			if ((cached = cache_get(&p->bases, obj_offset)) != NULL) {
-				elem->cached_entry = cached;
-				elem->cached = 1;
-				found_base = 1;
-				break;
-			}
-
-			base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
-			git_mwindow_close(&w_curs);
-
-			if (base_offset == 0)
-				return packfile_error("delta offset is zero");
-			if (base_offset < 0) { /* must actually be an error code */
-				error = (int)base_offset;
-				goto on_error;
-			}
-
-			/* we need to pass the pos *after* the delta-base bit */
-			elem->offset = curpos;
-
-			/* go through the loop again, but with the new object */
-			obj_offset = base_offset;
+		if (type != GIT_OBJ_OFS_DELTA && type != GIT_OBJ_REF_DELTA)
 			break;
 
-		/* one of these means we've found the final object in the chain */
-		case GIT_OBJ_COMMIT:
-		case GIT_OBJ_TREE:
-		case GIT_OBJ_BLOB:
-		case GIT_OBJ_TAG:
-			found_base = 1;
-			break;
+		base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
+		git_mwindow_close(&w_curs);
 
-		default:
-			error = packfile_error("invalid packfile type in header");
-			break;
+		if (base_offset == 0) {
+			error = packfile_error("delta offset is zero");
+			goto on_error;
 		}
-	}
+		if (base_offset < 0) { /* must actually be an error code */
+			error = (int)base_offset;
+			goto on_error;
+		}
+
+		/* we need to pass the pos *after* the delta-base bit */
+		elem->offset = curpos;
 
-	if (!found_base) {
-		git_array_clear(chain);
-		return packfile_error("after dependency chain loop; cannot happen");
+		/* go through the loop again, but with the new object */
+		obj_offset = base_offset;
 	}
 
 	*chain_out = chain;
-- 
cgit v1.2.3


From b1914c36511af468366482c4dc8974bd1c2995fc Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 12 May 2014 10:24:46 -0700
Subject: Minor fixes for warnings and error propagation

---
 include/git2/repository.h |  6 +++++-
 src/config_file.c         | 13 +++++--------
 src/diff_driver.c         |  2 +-
 src/repository.c          |  5 +++--
 4 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/include/git2/repository.h b/include/git2/repository.h
index 0f7119b76..037cb3f96 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -418,7 +418,11 @@ GIT_EXTERN(int) git_repository_config(git_config **out, git_repository *repo);
  * Get a snapshot of the repository's configuration
  *
  * Convenience function to take a snapshot from the repository's
- * configuration.
+ * configuration.  The contents of this snapshot will not change,
+ * even if the underlying config files are modified.
+ *
+ * The configuration file must be freed once it's no longer
+ * being used by the user.
  *
  * @param out Pointer to store the loaded configuration
  * @param repo the repository
diff --git a/src/config_file.c b/src/config_file.c
index c09a032be..b00d0827d 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -247,18 +247,15 @@ static int refcounted_strmap_alloc(refcounted_strmap **out)
 	int error;
 
 	map = git__calloc(1, sizeof(refcounted_strmap));
-	if (!map) {
-		giterr_set_oom();
-		return -1;
-	}
+	GITERR_CHECK_ALLOC(map);
 
 	git_atomic_set(&map->refcount, 1);
-	if ((error = git_strmap_alloc(&map->values)) < 0) {
+
+	if ((error = git_strmap_alloc(&map->values)) < 0)
 		git__free(map);
-		return error;
-	}
+	else
+		*out = map;
 
-	*out = map;
 	return error;
 }
 
diff --git a/src/diff_driver.c b/src/diff_driver.c
index 28c0a6b17..fc1354f36 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -219,7 +219,7 @@ static int git_diff_driver_load(
 	git_diff_driver *drv = NULL;
 	size_t namelen = strlen(driver_name);
 	khiter_t pos;
-	git_config *cfg, *repo_cfg;
+	git_config *cfg;
 	git_buf name = GIT_BUF_INIT;
 	const git_config_entry *ce;
 	bool found_driver = false;
diff --git a/src/repository.c b/src/repository.c
index 87f6f7ab7..43a476016 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -627,10 +627,11 @@ int git_repository_config(git_config **out, git_repository *repo)
 
 int git_repository_config_snapshot(git_config **out, git_repository *repo)
 {
+	int error;
 	git_config *weak;
 
-	if (git_repository_config__weakptr(&weak, repo) < 0)
-		return -1;
+	if ((error = git_repository_config__weakptr(&weak, repo)) < 0)
+		return error;
 
 	return git_config_snapshot(out, weak);
 }
-- 
cgit v1.2.3


From ce3b71d91b9cac3b462dec9ac2c7e397b55c00a6 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 12 May 2014 10:28:45 -0700
Subject: Don't scale diff stat when not needed

---
 src/diff_stats.c   | 2 ++
 tests/diff/stats.c | 4 ++++
 2 files changed, 6 insertions(+)

diff --git a/src/diff_stats.c b/src/diff_stats.c
index 6ad670c42..42ccbfb87 100644
--- a/src/diff_stats.c
+++ b/src/diff_stats.c
@@ -284,6 +284,8 @@ int git_diff_stats_to_buf(
 			if (width < STATS_FULL_MIN_SCALE)
 				width = STATS_FULL_MIN_SCALE;
 		}
+		if (width > stats->max_filestat)
+			width = 0;
 
 		for (i = 0; i < stats->files_changed; ++i) {
 			if ((delta = git_diff_get_delta(stats->diff, i)) == NULL)
diff --git a/tests/diff/stats.c b/tests/diff/stats.c
index 055019f69..f731997da 100644
--- a/tests/diff/stats.c
+++ b/tests/diff/stats.c
@@ -54,6 +54,10 @@ void test_diff_stats__stat(void)
 	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 0));
 	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
 	git_buf_free(&buf);
+
+	cl_git_pass(git_diff_stats_to_buf(&buf, _stats, GIT_DIFF_STATS_FULL, 80));
+	cl_assert(strcmp(git_buf_cstr(&buf), stat) == 0);
+	git_buf_free(&buf);
 }
 
 void test_diff_stats__multiple_hunks(void)
-- 
cgit v1.2.3


From a3ffbf230e454309c96961a182520a53f555d356 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 11 May 2014 03:50:34 +0200
Subject: pack: expose a cached delta base directly

Instead of going through a special entry in the chain, let's pass it as
an output parameter.
---
 src/pack.c | 185 ++++++++++++++++++++++++++++++-------------------------------
 src/pack.h |   4 --
 2 files changed, 92 insertions(+), 97 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index e1fd276b7..b5e8febd4 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -40,14 +40,6 @@ static int pack_entry_find_offset(
 		const git_oid *short_oid,
 		size_t len);
 
-/**
- * Generate the chain of dependencies which we need to get to the
- * object at `off`. `chain` is used a stack, popping gives the right
- * order to apply deltas on. If an object is found in the pack's base
- * cache, we stop calculating there.
- */
-static int pack_dependency_chain(git_dependency_chain *chain, struct git_pack_file *p, git_off_t off);
-
 static int packfile_error(const char *message)
 {
 	giterr_set(GITERR_ODB, "Invalid pack file - %s", message);
@@ -522,6 +514,87 @@ int git_packfile_resolve_header(
 	return error;
 }
 
+/**
+ * Generate the chain of dependencies which we need to get to the
+ * object at `off`. `chain` is used a stack, popping gives the right
+ * order to apply deltas on. If an object is found in the pack's base
+ * cache, we stop calculating there.
+ */
+static int pack_dependency_chain(git_dependency_chain *chain_out, git_pack_cache_entry **cached_out,
+				 git_off_t *cached_off, struct git_pack_file *p, git_off_t obj_offset)
+{
+	git_dependency_chain chain = GIT_ARRAY_INIT;
+	git_mwindow *w_curs = NULL;
+	git_off_t curpos = obj_offset, base_offset;
+	int error = 0;
+	size_t size;
+	git_otype type;
+
+	if (!p->bases.entries && (cache_init(&p->bases) < 0))
+		return -1;
+
+	git_array_init_to_size(chain, 64);
+	while (true) {
+		struct pack_chain_elem *elem;
+		git_pack_cache_entry *cached = NULL;
+
+		/* if we have a base cached, we can stop here instead */
+		if ((cached = cache_get(&p->bases, obj_offset)) != NULL) {
+			*cached_out = cached;
+			*cached_off = obj_offset;
+			break;
+		}
+
+		curpos = obj_offset;
+		elem = git_array_alloc(chain);
+		if (!elem) {
+			error = -1;
+			goto on_error;
+		}
+
+		elem->base_key = obj_offset;
+
+		error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos);
+		git_mwindow_close(&w_curs);
+
+		if (error < 0)
+			goto on_error;
+
+		elem->offset = curpos;
+		elem->size = size;
+		elem->type = type;
+		elem->base_key = obj_offset;
+
+		if (type != GIT_OBJ_OFS_DELTA && type != GIT_OBJ_REF_DELTA)
+			break;
+
+		base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
+		git_mwindow_close(&w_curs);
+
+		if (base_offset == 0) {
+			error = packfile_error("delta offset is zero");
+			goto on_error;
+		}
+		if (base_offset < 0) { /* must actually be an error code */
+			error = (int)base_offset;
+			goto on_error;
+		}
+
+		/* we need to pass the pos *after* the delta-base bit */
+		elem->offset = curpos;
+
+		/* go through the loop again, but with the new object */
+		obj_offset = base_offset;
+	}
+
+	*chain_out = chain;
+	return error;
+
+on_error:
+	git_array_clear(chain);
+	return error;
+}
+
 int git_packfile_unpack(
 	git_rawobj *obj,
 	struct git_pack_file *p,
@@ -531,7 +604,7 @@ int git_packfile_unpack(
 	git_off_t curpos = *obj_offset;
 	int error, free_base = 0;
 	git_dependency_chain chain = GIT_ARRAY_INIT;
-	struct pack_chain_elem *elem;
+	struct pack_chain_elem *elem = NULL;
 	git_pack_cache_entry *cached = NULL;
 	git_otype base_type;
 
@@ -539,7 +612,7 @@ int git_packfile_unpack(
 	 * TODO: optionally check the CRC on the packfile
 	 */
 
-	error = pack_dependency_chain(&chain, p, *obj_offset);
+	error = pack_dependency_chain(&chain, &cached, obj_offset, p, *obj_offset);
 	if (error < 0)
 		return error;
 
@@ -547,12 +620,12 @@ int git_packfile_unpack(
 	obj->len = 0;
 	obj->type = GIT_OBJ_BAD;
 
-	/* the first one is the base, so we expand that one */
-	elem = git_array_pop(chain);
-	base_type = elem->type;
-	if (elem->cached) {
-		cached = elem->cached_entry;
+	if (cached) {
 		memcpy(obj, &cached->raw, sizeof(git_rawobj));
+		base_type = obj->type;
+	} else {
+		elem = git_array_pop(chain);
+		base_type = elem->type;
 	}
 
 	if (error < 0)
@@ -563,10 +636,11 @@ int git_packfile_unpack(
 	case GIT_OBJ_TREE:
 	case GIT_OBJ_BLOB:
 	case GIT_OBJ_TAG:
-		if (!elem->cached) {
+		if (!cached) {
 			curpos = elem->offset;
 			error = packfile_unpack_compressed(obj, p, &w_curs, &curpos, elem->size, elem->type);
 			git_mwindow_close(&w_curs);
+			base_type = elem->type;
 			free_base = 1;
 		}
 		if (error < 0)
@@ -646,7 +720,8 @@ cleanup:
 	if (error < 0)
 		git__free(obj->data);
 
-	*obj_offset = elem->offset;
+	if (elem)
+		*obj_offset = elem->offset;
 
 	git_array_clear(chain);
 	return error;
@@ -1240,79 +1315,3 @@ int git_pack_entry_find(
 	git_oid_cpy(&e->sha1, &found_oid);
 	return 0;
 }
-
-static int pack_dependency_chain(git_dependency_chain *chain_out, struct git_pack_file *p, git_off_t obj_offset)
-{
-	git_dependency_chain chain = GIT_ARRAY_INIT;
-	git_mwindow *w_curs = NULL;
-	git_off_t curpos = obj_offset, base_offset;
-	int error = 0;
-	size_t size;
-	git_otype type;
-
-	if (!p->bases.entries && (cache_init(&p->bases) < 0))
-		return -1;
-
-	git_array_init_to_size(chain, 64);
-	while (true) {
-		struct pack_chain_elem *elem;
-		git_pack_cache_entry *cached = NULL;
-
-		curpos = obj_offset;
-		elem = git_array_alloc(chain);
-		if (!elem) {
-			error = -1;
-			goto on_error;
-		}
-
-		elem->base_key = obj_offset;
-
-		/* if we have a base cached, we can stop here instead */
-		if ((cached = cache_get(&p->bases, obj_offset)) != NULL) {
-			elem->cached_entry = cached;
-			elem->cached = 1;
-			elem->type = cached->raw.type;
-			break;
-		}
-
-		error = git_packfile_unpack_header(&size, &type, &p->mwf, &w_curs, &curpos);
-		git_mwindow_close(&w_curs);
-
-		if (error < 0)
-			goto on_error;
-
-		elem->cached = 0;
-		elem->offset = curpos;
-		elem->size = size;
-		elem->type = type;
-		elem->base_key = obj_offset;
-
-		if (type != GIT_OBJ_OFS_DELTA && type != GIT_OBJ_REF_DELTA)
-			break;
-
-		base_offset = get_delta_base(p, &w_curs, &curpos, type, obj_offset);
-		git_mwindow_close(&w_curs);
-
-		if (base_offset == 0) {
-			error = packfile_error("delta offset is zero");
-			goto on_error;
-		}
-		if (base_offset < 0) { /* must actually be an error code */
-			error = (int)base_offset;
-			goto on_error;
-		}
-
-		/* we need to pass the pos *after* the delta-base bit */
-		elem->offset = curpos;
-
-		/* go through the loop again, but with the new object */
-		obj_offset = base_offset;
-	}
-
-	*chain_out = chain;
-	return error;
-
-on_error:
-	git_array_clear(chain);
-	return error;
-}
diff --git a/src/pack.h b/src/pack.h
index e86889d1b..610e70c18 100644
--- a/src/pack.h
+++ b/src/pack.h
@@ -62,14 +62,10 @@ typedef struct git_pack_cache_entry {
 } git_pack_cache_entry;
 
 struct pack_chain_elem {
-	int cached;
 	git_off_t base_key;
-	/* if we don't have it cached we have this */
 	git_off_t offset;
 	size_t size;
 	git_otype type;
-	/* if cached, we have this instead */
-	git_pack_cache_entry *cached_entry;
 };
 
 typedef git_array_t(struct pack_chain_elem) git_dependency_chain;
-- 
cgit v1.2.3


From 15bcced22379857978d80539da5fdd8f4667ff95 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 11 May 2014 05:31:22 +0200
Subject: pack: use stack allocation for smaller delta chains

This avoid allocating the array on the heap for relatively small
chains. The expected performance increase is sadly not really
noticeable.
---
 src/pack.c | 61 +++++++++++++++++++++++++++++++++++++++++++++----------------
 1 file changed, 45 insertions(+), 16 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index b5e8febd4..235e8d3ee 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -514,26 +514,30 @@ int git_packfile_resolve_header(
 	return error;
 }
 
+#define SMALL_STACK_SIZE 64
+
 /**
  * Generate the chain of dependencies which we need to get to the
  * object at `off`. `chain` is used a stack, popping gives the right
  * order to apply deltas on. If an object is found in the pack's base
  * cache, we stop calculating there.
  */
-static int pack_dependency_chain(git_dependency_chain *chain_out, git_pack_cache_entry **cached_out,
-				 git_off_t *cached_off, struct git_pack_file *p, git_off_t obj_offset)
+static int pack_dependency_chain(git_dependency_chain *chain_out,
+				 git_pack_cache_entry **cached_out, git_off_t *cached_off,
+				 struct pack_chain_elem *small_stack, size_t *stack_sz,
+				 struct git_pack_file *p, git_off_t obj_offset)
 {
 	git_dependency_chain chain = GIT_ARRAY_INIT;
 	git_mwindow *w_curs = NULL;
 	git_off_t curpos = obj_offset, base_offset;
-	int error = 0;
-	size_t size;
+	int error = 0, use_heap = 0;
+	size_t size, elem_pos;
 	git_otype type;
 
 	if (!p->bases.entries && (cache_init(&p->bases) < 0))
 		return -1;
 
-	git_array_init_to_size(chain, 64);
+	elem_pos = 0;
 	while (true) {
 		struct pack_chain_elem *elem;
 		git_pack_cache_entry *cached = NULL;
@@ -545,11 +549,24 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, git_pack_cache
 			break;
 		}
 
+		/* if we run out of space on the small stack, use the array */
+		if (elem_pos == SMALL_STACK_SIZE) {
+			git_array_init_to_size(chain, elem_pos);
+			GITERR_CHECK_ARRAY(chain);
+			memcpy(chain.ptr, small_stack, elem_pos * sizeof(struct pack_chain_elem));
+			chain.size = elem_pos;
+			use_heap = 1;
+		}
+
 		curpos = obj_offset;
-		elem = git_array_alloc(chain);
-		if (!elem) {
-			error = -1;
-			goto on_error;
+		if (!use_heap) {
+			elem = &small_stack[elem_pos];
+		} else {
+			elem = git_array_alloc(chain);
+			if (!elem) {
+				error = -1;
+				goto on_error;
+			}
 		}
 
 		elem->base_key = obj_offset;
@@ -585,8 +602,11 @@ static int pack_dependency_chain(git_dependency_chain *chain_out, git_pack_cache
 
 		/* go through the loop again, but with the new object */
 		obj_offset = base_offset;
+		elem_pos++;
 	}
 
+	
+	*stack_sz = elem_pos + 1;
 	*chain_out = chain;
 	return error;
 
@@ -604,15 +624,17 @@ int git_packfile_unpack(
 	git_off_t curpos = *obj_offset;
 	int error, free_base = 0;
 	git_dependency_chain chain = GIT_ARRAY_INIT;
-	struct pack_chain_elem *elem = NULL;
+	struct pack_chain_elem *elem = NULL, *stack;
 	git_pack_cache_entry *cached = NULL;
+	struct pack_chain_elem small_stack[SMALL_STACK_SIZE];
+	size_t stack_size, elem_pos;
 	git_otype base_type;
 
 	/*
 	 * TODO: optionally check the CRC on the packfile
 	 */
 
-	error = pack_dependency_chain(&chain, &cached, obj_offset, p, *obj_offset);
+	error = pack_dependency_chain(&chain, &cached, obj_offset, small_stack, &stack_size, p, *obj_offset);
 	if (error < 0)
 		return error;
 
@@ -620,11 +642,16 @@ int git_packfile_unpack(
 	obj->len = 0;
 	obj->type = GIT_OBJ_BAD;
 
+	/* let's point to the right stack */
+	stack = chain.ptr ? chain.ptr : small_stack;
+
+	elem_pos = stack_size;
 	if (cached) {
 		memcpy(obj, &cached->raw, sizeof(git_rawobj));
 		base_type = obj->type;
+		elem_pos--;	/* stack_size includes the base, which isn't actually there */
 	} else {
-		elem = git_array_pop(chain);
+		elem = &stack[--elem_pos];
 		base_type = elem->type;
 	}
 
@@ -661,7 +688,7 @@ int git_packfile_unpack(
 	 * give the caller the cached object, which it would then feel
 	 * free to free, so we need to copy the data.
 	 */
-	if (cached && git_array_size(chain) == 0) {
+	if (cached && stack_size == 1) {
 		void *data = obj->data;
 		obj->data = git__malloc(obj->len + 1);
 		GITERR_CHECK_ALLOC(obj->data);
@@ -671,10 +698,10 @@ int git_packfile_unpack(
 	}
 
 	/* we now apply each consecutive delta until we run out */
-	while (git_array_size(chain) > 0 && !error) {
+	while (elem_pos > 0 && !error) {
 		git_rawobj base, delta;
 
-		elem = git_array_pop(chain);
+		elem = &stack[elem_pos - 1];
 		curpos = elem->offset;
 		error = packfile_unpack_compressed(&delta, p, &w_curs, &curpos, elem->size, elem->type);
 		git_mwindow_close(&w_curs);
@@ -711,9 +738,11 @@ int git_packfile_unpack(
 			break;
 
 		/* only try to cache if we're not handing this buffer off to the caller */
-		if (git_array_size(chain) > 0 &&
+		if (elem_pos != 1 &&
 		    (error = cache_add(&p->bases, obj, elem->base_key)) < 0)
 			goto cleanup;
+
+		elem_pos--;
 	}
 
 cleanup:
-- 
cgit v1.2.3


From c968ce2c2c49ca7a559ecb8f7014f777c3a8a5f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 12 May 2014 02:01:05 +0200
Subject: pack: don't forget to cache the base object

The base object is a good cache candidate, so we shouldn't forget to add
it to the cache.
---
 src/pack.c | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index 235e8d3ee..d93ee25f9 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -668,7 +668,6 @@ int git_packfile_unpack(
 			error = packfile_unpack_compressed(obj, p, &w_curs, &curpos, elem->size, elem->type);
 			git_mwindow_close(&w_curs);
 			base_type = elem->type;
-			free_base = 1;
 		}
 		if (error < 0)
 			goto cleanup;
@@ -683,7 +682,7 @@ int git_packfile_unpack(
 	}
 
 	/*
-	 * Finding the object we want as the base element is
+	 * Finding the object we want a cached base element is
 	 * problematic, as we need to make sure we don't accidentally
 	 * give the caller the cached object, which it would then feel
 	 * free to free, so we need to copy the data.
@@ -701,6 +700,13 @@ int git_packfile_unpack(
 	while (elem_pos > 0 && !error) {
 		git_rawobj base, delta;
 
+		/*
+		 * We can now try to add the base to the cache, as
+		 * long as it's not already the cached one.
+		 */
+		if (!cached)
+			free_base = !!cache_add(&p->bases, obj, elem->base_key);
+
 		elem = &stack[elem_pos - 1];
 		curpos = elem->offset;
 		error = packfile_unpack_compressed(&delta, p, &w_curs, &curpos, elem->size, elem->type);
@@ -737,11 +743,6 @@ int git_packfile_unpack(
 		if (error < 0)
 			break;
 
-		/* only try to cache if we're not handing this buffer off to the caller */
-		if (elem_pos != 1 &&
-		    (error = cache_add(&p->bases, obj, elem->base_key)) < 0)
-			goto cleanup;
-
 		elem_pos--;
 	}
 
-- 
cgit v1.2.3


From 7c57cd97d814a39829a6b6e03473e693ea4df602 Mon Sep 17 00:00:00 2001
From: Albert Meltzer <kitbellew@users.noreply.github.com>
Date: Mon, 12 May 2014 20:25:44 -0700
Subject: Win32 fix for #2300.

The code doesn't use SSL and a test requires it.
---
 src/netops.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/netops.c b/src/netops.c
index 24092c17f..a0193a022 100644
--- a/src/netops.c
+++ b/src/netops.c
@@ -206,6 +206,8 @@ static int gitno_ssl_teardown(gitno_ssl *ssl)
 	return ret;
 }
 
+#endif
+
 /* Match host names according to RFC 2818 rules */
 int gitno__match_host(const char *pattern, const char *host)
 {
@@ -256,6 +258,8 @@ static int check_host_name(const char *name, const char *host)
 	return 0;
 }
 
+#ifdef GIT_SSL
+
 static int verify_server_cert(gitno_ssl *ssl, const char *host)
 {
 	X509 *cert;
-- 
cgit v1.2.3


From b3f27c43685c3fb492b03ccca7c57a0b5db217ab Mon Sep 17 00:00:00 2001
From: Linquize <linquize@yahoo.com.hk>
Date: Tue, 13 May 2014 21:08:50 +0800
Subject: Initialize local variable

---
 src/indexer.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/indexer.c b/src/indexer.c
index 3c8415c7c..68496ceea 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -703,7 +703,7 @@ static int fix_thin_pack(git_indexer *idx, git_transfer_progress *stats)
 	size_t size;
 	git_otype type;
 	git_mwindow *w = NULL;
-	git_off_t curpos;
+	git_off_t curpos = 0;
 	unsigned char *base_info;
 	unsigned int left = 0;
 	git_oid base;
-- 
cgit v1.2.3


From 562516ecebeefa89595b23c5aa559551a8bb7c56 Mon Sep 17 00:00:00 2001
From: Stefan Widgren <stefan.widgren@gmail.com>
Date: Tue, 13 May 2014 22:43:59 +0200
Subject: Add R bindings to the README

---
 README.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/README.md b/README.md
index 8dd073430..b60e8a234 100644
--- a/README.md
+++ b/README.md
@@ -189,6 +189,8 @@ Here are the bindings to libgit2 that are currently available:
     * GitPowerShell <https://github.com/ethomson/gitpowershell>
 * Python
     * pygit2 <https://github.com/libgit2/pygit2>
+* R
+    * git2r <https://github.com/ropensci/git2r>
 * Ruby
     * Rugged <https://github.com/libgit2/rugged>
 * Vala
-- 
cgit v1.2.3


From a37aa82ea6f952745c883065a86162343e438981 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 13 May 2014 15:54:23 -0700
Subject: Some coverity inspired cleanups

---
 src/config.c      | 12 ++++++------
 src/config_file.c |  8 +++++---
 src/diff_driver.c | 10 +++++-----
 src/tag.c         | 14 ++++++++------
 4 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/src/config.c b/src/config.c
index 757ff0387..4bd27a875 100644
--- a/src/config.c
+++ b/src/config.c
@@ -153,19 +153,19 @@ int git_config_snapshot(git_config **out, git_config *in)
 		git_config_backend *b;
 
 		if ((error = internal->file->snapshot(&b, internal->file)) < 0)
-			goto on_error;
+			break;
 
 		if ((error = git_config_add_backend(config, b, internal->level, 0)) < 0) {
 			b->free(b);
-			goto on_error;
+			break;
 		}
 	}
 
-	*out = config;
-	return error;
+	if (error < 0)
+		git_config_free(config);
+	else
+		*out = config;
 
-on_error:
-	git_config_free(config);
 	return error;
 }
 
diff --git a/src/config_file.c b/src/config_file.c
index b00d0827d..fdc9bc8a2 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -313,6 +313,7 @@ static int config__refresh(git_config_backend *cfg)
 		goto out;
 
 	reader = git_array_get(b->readers, git_array_size(b->readers) - 1);
+	GITERR_CHECK_ALLOC(reader);
 
 	if ((error = config_parse(values->values, b, reader, b->level, 0)) < 0)
 		goto out;
@@ -327,7 +328,8 @@ static int config__refresh(git_config_backend *cfg)
 
 out:
 	refcounted_strmap_free(values);
-	git_buf_free(&reader->buffer);
+	if (reader)
+		git_buf_free(&reader->buffer);
 	return error;
 }
 
@@ -344,8 +346,8 @@ static int config_refresh(git_config_backend *cfg)
 			&reader->buffer, reader->file_path,
 			&reader->file_mtime, &reader->file_size, &updated);
 
-		if (error < 0)
-			return (error == GIT_ENOTFOUND) ? 0 : error;
+		if (error < 0 && error != GIT_ENOTFOUND)
+			return error;
 
 		if (updated)
 			any_updated = 1;
diff --git a/src/diff_driver.c b/src/diff_driver.c
index fc1354f36..dc8e79e25 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -233,17 +233,17 @@ static int git_diff_driver_load(
 		return 0;
 	}
 
+	drv = git__calloc(1, sizeof(git_diff_driver) + namelen + 1);
+	GITERR_CHECK_ALLOC(drv);
+	drv->type = DIFF_DRIVER_AUTO;
+	memcpy(drv->name, driver_name, namelen);
+
 	/* if you can't read config for repo, just use default driver */
 	if (git_repository_config_snapshot(&cfg, repo) < 0) {
 		giterr_clear();
 		goto done;
 	}
 
-	drv = git__calloc(1, sizeof(git_diff_driver) + namelen + 1);
-	GITERR_CHECK_ALLOC(drv);
-	drv->type = DIFF_DRIVER_AUTO;
-	memcpy(drv->name, driver_name, namelen);
-
 	if ((error = git_buf_printf(&name, "diff.%s.binary", driver_name)) < 0)
 		goto done;
 
diff --git a/src/tag.c b/src/tag.c
index 1a4ee1e1c..d7b531d34 100644
--- a/src/tag.c
+++ b/src/tag.c
@@ -363,20 +363,22 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 	}
 
 	/* write the buffer */
-	if (git_odb_open_wstream(&stream, odb, strlen(buffer), GIT_OBJ_TAG) < 0)
-		return -1;
+	if ((error = git_odb_open_wstream(
+			&stream, odb, strlen(buffer), GIT_OBJ_TAG)) < 0)
+		return error;
 
-	git_odb_stream_write(stream, buffer, strlen(buffer));
+	if (!(error = git_odb_stream_write(stream, buffer, strlen(buffer))))
+		error = git_odb_stream_finalize_write(oid, stream);
 
-	error = git_odb_stream_finalize_write(oid, stream);
 	git_odb_stream_free(stream);
 
 	if (error < 0) {
 		git_buf_free(&ref_name);
-		return -1;
+		return error;
 	}
 
-	error = git_reference_create(&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite, NULL, NULL);
+	error = git_reference_create(
+		&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite, NULL, NULL);
 
 	git_reference_free(new_ref);
 	git_buf_free(&ref_name);
-- 
cgit v1.2.3


From 2b52a0bfaedf7571e7ecd706947f5865d513760c Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Tue, 13 May 2014 16:32:27 -0700
Subject: Increase use of config snapshots

And decrease extra reload checks of config data.
---
 src/attrcache.c    | 11 +++++++----
 src/config.h       |  6 ++++++
 src/config_cache.c | 42 ++++++++++++++++++++++++------------------
 src/diff.c         | 19 ++++++++++---------
 src/refdb_fs.c     | 16 ++++++----------
 src/repository.c   | 24 ++++++++++++------------
 src/repository.h   |  4 ++++
 7 files changed, 69 insertions(+), 53 deletions(-)

diff --git a/src/attrcache.c b/src/attrcache.c
index f1bc70467..56c028e60 100644
--- a/src/attrcache.c
+++ b/src/attrcache.c
@@ -349,14 +349,11 @@ int git_attr_cache__do_init(git_repository *repo)
 {
 	int ret = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_config *cfg;
+	git_config *cfg = NULL;
 
 	if (cache)
 		return 0;
 
-	if ((ret = git_repository_config__weakptr(&cfg, repo)) < 0)
-		return ret;
-
 	cache = git__calloc(1, sizeof(git_attr_cache));
 	GITERR_CHECK_ALLOC(cache);
 
@@ -367,6 +364,9 @@ int git_attr_cache__do_init(git_repository *repo)
 		return -1;
 	}
 
+	if ((ret = git_repository_config_snapshot(&cfg, repo)) < 0)
+		goto cancel;
+
 	/* cache config settings for attributes and ignores */
 	ret = attr_cache__lookup_path(
 		&cache->cfg_attr_file, cfg, GIT_ATTR_CONFIG, GIT_ATTR_FILE_XDG);
@@ -390,11 +390,14 @@ int git_attr_cache__do_init(git_repository *repo)
 	if (cache)
 		goto cancel; /* raced with another thread, free this but no error */
 
+	git_config_free(cfg);
+
 	/* insert default macros */
 	return git_attr_add_macro(repo, "binary", "-diff -crlf -text");
 
 cancel:
 	attr_cache__free(cache);
+	git_config_free(cfg);
 	return ret;
 }
 
diff --git a/src/config.h b/src/config.h
index 00b6063e7..b0dcb49ac 100644
--- a/src/config.h
+++ b/src/config.h
@@ -76,4 +76,10 @@ extern int git_config__get_bool_force(
 extern int git_config__get_int_force(
 	const git_config *cfg, const char *key, int fallback_value);
 
+/* API for repository cvar-style lookups from config - not cached, but
+ * uses cvar value maps and fallbacks
+ */
+extern int git_config__cvar(
+	int *out, git_config *config, git_cvar_cached cvar);
+
 #endif
diff --git a/src/config_cache.c b/src/config_cache.c
index 4bcbf02bf..dca9976f8 100644
--- a/src/config_cache.c
+++ b/src/config_cache.c
@@ -7,11 +7,11 @@
 
 #include "common.h"
 #include "fileops.h"
+#include "repository.h"
 #include "config.h"
 #include "git2/config.h"
 #include "vector.h"
 #include "filter.h"
-#include "repository.h"
 
 struct map_data {
 	const char *cvar_name;
@@ -69,32 +69,38 @@ static struct map_data _cvar_maps[] = {
 	{"core.abbrev", _cvar_map_int, 1, GIT_ABBREV_DEFAULT },
 	{"core.precomposeunicode", NULL, 0, GIT_PRECOMPOSE_DEFAULT },
 	{"core.safecrlf", NULL, 0, GIT_SAFE_CRLF_DEFAULT},
+	{"core.logallrefupdates", NULL, 0, GIT_LOGALLREFUPDATES_DEFAULT },
 };
 
+int git_config__cvar(int *out, git_config *config, git_cvar_cached cvar)
+{
+	int error = 0;
+	struct map_data *data = &_cvar_maps[(int)cvar];
+	const git_config_entry *entry;
+
+	git_config__lookup_entry(&entry, config, data->cvar_name, false);
+
+	if (!entry)
+		*out = data->default_value;
+	else if (data->maps)
+		error = git_config_lookup_map_value(
+			out, data->maps, data->map_count, entry->value);
+	else
+		error = git_config_parse_bool(out, entry->value);
+
+	return error;
+}
+
 int git_repository__cvar(int *out, git_repository *repo, git_cvar_cached cvar)
 {
 	*out = repo->cvar_cache[(int)cvar];
 
 	if (*out == GIT_CVAR_NOT_CACHED) {
-		struct map_data *data = &_cvar_maps[(int)cvar];
-		git_config *config;
 		int error;
-		const git_config_entry *entry;
-
-		if ((error = git_repository_config__weakptr(&config, repo)) < 0)
-			return error;
-
-		git_config__lookup_entry(&entry, config, data->cvar_name, false);
-
-		if (!entry)
-			*out = data->default_value;
-		else if (data->maps)
-			error = git_config_lookup_map_value(
-				out, data->maps, data->map_count, entry->value);
-		else
-			error = git_config_parse_bool(out, entry->value);
+		git_config *config;
 
-		if (error < 0)
+		if ((error = git_repository_config__weakptr(&config, repo)) < 0 ||
+			(error = git_config__cvar(out, config, cvar)) < 0)
 			return error;
 
 		repo->cvar_cache[(int)cvar] = *out;
diff --git a/src/diff.c b/src/diff.c
index b3e36101c..325c599e0 100644
--- a/src/diff.c
+++ b/src/diff.c
@@ -381,7 +381,7 @@ static int diff_list_apply_options(
 	git_diff *diff,
 	const git_diff_options *opts)
 {
-	git_config *cfg;
+	git_config *cfg = NULL;
 	git_repository *repo = diff->repo;
 	git_pool *pool = &diff->pool;
 	int val;
@@ -406,20 +406,20 @@ static int diff_list_apply_options(
 		diff->opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
 
 	/* load config values that affect diff behavior */
-	if ((val = git_repository_config__weakptr(&cfg, repo)) < 0)
+	if ((val = git_repository_config_snapshot(&cfg, repo)) < 0)
 		return val;
 
-	if (!git_repository__cvar(&val, repo, GIT_CVAR_SYMLINKS) && val)
+	if (!git_config__cvar(&val, cfg, GIT_CVAR_SYMLINKS) && val)
 		diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_HAS_SYMLINKS;
 
-	if (!git_repository__cvar(&val, repo, GIT_CVAR_IGNORESTAT) && val)
+	if (!git_config__cvar(&val, cfg, GIT_CVAR_IGNORESTAT) && val)
 		diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_IGNORE_STAT;
 
 	if ((diff->opts.flags & GIT_DIFF_IGNORE_FILEMODE) == 0 &&
-		!git_repository__cvar(&val, repo, GIT_CVAR_FILEMODE) && val)
+		!git_config__cvar(&val, cfg, GIT_CVAR_FILEMODE) && val)
 		diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_MODE_BITS;
 
-	if (!git_repository__cvar(&val, repo, GIT_CVAR_TRUSTCTIME) && val)
+	if (!git_config__cvar(&val, cfg, GIT_CVAR_TRUSTCTIME) && val)
 		diff->diffcaps = diff->diffcaps | GIT_DIFFCAPS_TRUST_CTIME;
 
 	/* Don't set GIT_DIFFCAPS_USE_DEV - compile time option in core git */
@@ -481,8 +481,6 @@ static int diff_list_apply_options(
 	/* strdup prefix from pool so we're not dependent on external data */
 	diff->opts.old_prefix = diff_strdup_prefix(pool, diff->opts.old_prefix);
 	diff->opts.new_prefix = diff_strdup_prefix(pool, diff->opts.new_prefix);
-	if (!diff->opts.old_prefix || !diff->opts.new_prefix)
-		return -1;
 
 	if (DIFF_FLAG_IS_SET(diff, GIT_DIFF_REVERSE)) {
 		const char *tmp_prefix = diff->opts.old_prefix;
@@ -490,7 +488,10 @@ static int diff_list_apply_options(
 		diff->opts.new_prefix  = tmp_prefix;
 	}
 
-	return 0;
+	git_config_free(cfg);
+
+	/* check strdup results for error */
+	return (!diff->opts.old_prefix || !diff->opts.new_prefix) ? -1 : 0;
 }
 
 static void diff_list_free(git_diff *diff)
diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index f9bd4eab5..dd8bf7916 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -927,19 +927,15 @@ static int has_reflog(git_repository *repo, const char *name);
 /* We only write if it's under heads/, remotes/ or notes/ or if it already has a log */
 static int should_write_reflog(int *write, git_repository *repo, const char *name)
 {
-	git_config *config;
-	int error, logall, is_bare;
+	int error, logall;
 
-	/* Defaults to the opposite of the repo being bare */
-	is_bare = git_repository_is_bare(repo);
-	logall = !is_bare;
-
-	if ((error = git_repository_config__weakptr(&config, repo)) < 0)
+	error = git_repository__cvar(&logall, repo, GIT_CVAR_LOGALLREFUPDATES);
+	if (error < 0)
 		return error;
 
-	error = git_config_get_bool(&logall, config, "core.logallrefupdates");
-	if (error < 0 && error != GIT_ENOTFOUND)
-		return error;
+	/* Defaults to the opposite of the repo being bare */
+	if (logall == GIT_LOGALLREFUPDATES_UNSET)
+		logall = !git_repository_is_bare(repo);
 
 	if (!logall) {
 		*write = 0;
diff --git a/src/repository.c b/src/repository.c
index 7d055e28e..b0db5484a 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -443,7 +443,6 @@ int git_repository_open_ext(
 	int error;
 	git_buf path = GIT_BUF_INIT, parent = GIT_BUF_INIT;
 	git_repository *repo;
-	git_config *config;
 
 	if (repo_ptr)
 		*repo_ptr = NULL;
@@ -458,23 +457,24 @@ int git_repository_open_ext(
 	repo->path_repository = git_buf_detach(&path);
 	GITERR_CHECK_ALLOC(repo->path_repository);
 
-	if ((error = git_repository_config_snapshot(&config, repo)) < 0)
-		return error;
-
 	if ((flags & GIT_REPOSITORY_OPEN_BARE) != 0)
 		repo->is_bare = 1;
-	else if ((error = load_config_data(repo, config)) < 0 ||
-		 (error = load_workdir(repo, config, &parent)) < 0)
-	{
+	else {
+		git_config *config = NULL;
+
+		if ((error = git_repository_config_snapshot(&config, repo)) < 0 ||
+			(error = load_config_data(repo, config)) < 0 ||
+			(error = load_workdir(repo, config, &parent)) < 0)
+			git_repository_free(repo);
+
 		git_config_free(config);
-		git_repository_free(repo);
-		return error;
 	}
 
-	git_config_free(config);
+	if (!error)
+		*repo_ptr = repo;
 	git_buf_free(&parent);
-	*repo_ptr = repo;
-	return 0;
+
+	return error;
 }
 
 int git_repository_open(git_repository **repo_out, const char *path)
diff --git a/src/repository.h b/src/repository.h
index 27eec9dd8..aba16a016 100644
--- a/src/repository.h
+++ b/src/repository.h
@@ -39,6 +39,7 @@ typedef enum {
 	GIT_CVAR_ABBREV,        /* core.abbrev */
 	GIT_CVAR_PRECOMPOSE,    /* core.precomposeunicode */
 	GIT_CVAR_SAFE_CRLF,		/* core.safecrlf */
+	GIT_CVAR_LOGALLREFUPDATES, /* core.logallrefupdates */
 	GIT_CVAR_CACHE_MAX
 } git_cvar_cached;
 
@@ -92,6 +93,9 @@ typedef enum {
 	GIT_PRECOMPOSE_DEFAULT = GIT_CVAR_FALSE,
 	/* core.safecrlf */
 	GIT_SAFE_CRLF_DEFAULT = GIT_CVAR_FALSE,
+	/* core.logallrefupdates */
+	GIT_LOGALLREFUPDATES_UNSET = 2,
+	GIT_LOGALLREFUPDATES_DEFAULT = GIT_LOGALLREFUPDATES_UNSET,
 } git_cvar_value;
 
 /* internal repository init flags */
-- 
cgit v1.2.3


From 4af0ef9690e9fdfc81afbeed7039d02a5f191001 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Thu, 15 May 2014 11:09:49 -0400
Subject: Fix mutex init/free in config_file.c

---
 src/config_file.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/config_file.c b/src/config_file.c
index fdc9bc8a2..56271144b 100644
--- a/src/config_file.c
+++ b/src/config_file.c
@@ -270,7 +270,6 @@ static int config_open(git_config_backend *cfg, git_config_level_t level)
 	if ((res = refcounted_strmap_alloc(&b->header.values)) < 0)
 		return res;
 
-	git_mutex_init(&b->header.values_mutex);
 	git_array_init(b->readers);
 	reader = git_array_alloc(b->readers);
 	if (!reader) {
@@ -375,6 +374,7 @@ static void backend_free(git_config_backend *_backend)
 
 	git__free(backend->file_path);
 	refcounted_strmap_free(backend->header.values);
+	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
 }
 
@@ -686,6 +686,7 @@ int git_config_file__ondisk(git_config_backend **out, const char *path)
 	GITERR_CHECK_ALLOC(backend);
 
 	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+	git_mutex_init(&backend->header.values_mutex);
 
 	backend->file_path = git__strdup(path);
 	GITERR_CHECK_ALLOC(backend->file_path);
@@ -758,6 +759,7 @@ static void backend_readonly_free(git_config_backend *_backend)
 		return;
 
 	refcounted_strmap_free(backend->header.values);
+	git_mutex_free(&backend->header.values_mutex);
 	git__free(backend);
 }
 
@@ -784,6 +786,7 @@ int git_config_file__snapshot(git_config_backend **out, diskfile_backend *in)
 	GITERR_CHECK_ALLOC(backend);
 
 	backend->header.parent.version = GIT_CONFIG_BACKEND_VERSION;
+	git_mutex_init(&backend->header.values_mutex);
 
 	backend->snapshot_from = in;
 
-- 
cgit v1.2.3


From 8487e23797cef0284b592b5ef93eaacbac7196dc Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Thu, 15 May 2014 10:56:28 -0700
Subject: Better search path sandboxing

There are a number of tests that modify the global or system
search paths during the tests.  This adds a helper function to
make it easier to restore those paths and makes sure that they
are getting restored in a manner that preserves test isolation.
---
 tests/clar_libgit2.c   | 13 +++++++++++++
 tests/clar_libgit2.h   |  2 ++
 tests/config/global.c  | 28 +---------------------------
 tests/config/include.c |  2 ++
 tests/core/env.c       | 26 ++++++++++++--------------
 tests/main.c           |  6 +-----
 tests/repo/config.c    | 38 ++++++++++++++++++++------------------
 tests/repo/open.c      |  5 +++--
 8 files changed, 54 insertions(+), 66 deletions(-)

diff --git a/tests/clar_libgit2.c b/tests/clar_libgit2.c
index b2730f4d1..0a4c3e8e5 100644
--- a/tests/clar_libgit2.c
+++ b/tests/clar_libgit2.c
@@ -518,3 +518,16 @@ void cl_fake_home(void)
 		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr));
 	git_buf_free(&path);
 }
+
+void cl_sandbox_set_search_path_defaults(void)
+{
+	const char *sandbox_path = clar_sandbox_path();
+
+	git_libgit2_opts(
+		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, sandbox_path);
+	git_libgit2_opts(
+		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, sandbox_path);
+	git_libgit2_opts(
+		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_SYSTEM, sandbox_path);
+}
+
diff --git a/tests/clar_libgit2.h b/tests/clar_libgit2.h
index f84d9e353..da37bd655 100644
--- a/tests/clar_libgit2.h
+++ b/tests/clar_libgit2.h
@@ -139,4 +139,6 @@ void cl_repo_set_string(git_repository *repo, const char *cfg, const char *value
 void cl_fake_home(void);
 void cl_fake_home_cleanup(void *);
 
+void cl_sandbox_set_search_path_defaults(void);
+
 #endif
diff --git a/tests/config/global.c b/tests/config/global.c
index 006b34628..fc471f90d 100644
--- a/tests/config/global.c
+++ b/tests/config/global.c
@@ -2,25 +2,10 @@
 #include "buffer.h"
 #include "fileops.h"
 
-static git_config_level_t setting[3] = {
-	GIT_CONFIG_LEVEL_GLOBAL,
-	GIT_CONFIG_LEVEL_XDG,
-	GIT_CONFIG_LEVEL_SYSTEM
-};
-static char *restore[3];
-
 void test_config_global__initialize(void)
 {
-	int i;
 	git_buf path = GIT_BUF_INIT;
 
-	/* snapshot old settings to restore later */
-	for (i = 0; i < 3; ++i) {
-		cl_git_pass(
-			git_libgit2_opts(GIT_OPT_GET_SEARCH_PATH, setting[i], &path));
-		restore[i] = git_buf_detach(&path);
-	}
-
 	cl_git_pass(git_futils_mkdir_r("home", NULL, 0777));
 	cl_git_pass(git_path_prettify(&path, "home", NULL));
 	cl_git_pass(git_libgit2_opts(
@@ -41,18 +26,7 @@ void test_config_global__initialize(void)
 
 void test_config_global__cleanup(void)
 {
-	int i;
-
-	for (i = 0; i < 3; ++i) {
-		cl_git_pass(
-			git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, setting[i], restore[i]));
-		git__free(restore[i]);
-		restore[i] = NULL;
-	}
-
-	cl_git_pass(git_futils_rmdir_r("home", NULL, GIT_RMDIR_REMOVE_FILES));
-	cl_git_pass(git_futils_rmdir_r("xdg", NULL, GIT_RMDIR_REMOVE_FILES));
-	cl_git_pass(git_futils_rmdir_r("etc", NULL, GIT_RMDIR_REMOVE_FILES));
+	cl_sandbox_set_search_path_defaults();
 }
 
 void test_config_global__open_global(void)
diff --git a/tests/config/include.c b/tests/config/include.c
index 535573808..58bc690ff 100644
--- a/tests/config/include.c
+++ b/tests/config/include.c
@@ -47,6 +47,8 @@ void test_config_include__homedir(void)
 	cl_assert_equal_s(str, "huzzah");
 
 	git_config_free(cfg);
+
+	cl_sandbox_set_search_path_defaults();
 }
 
 void test_config_include__refresh(void)
diff --git a/tests/core/env.c b/tests/core/env.c
index df1d92a02..293b786db 100644
--- a/tests/core/env.c
+++ b/tests/core/env.c
@@ -40,12 +40,12 @@ void test_core_env__initialize(void)
 	}
 }
 
-static void reset_global_search_path(void)
+static void set_global_search_path_from_env(void)
 {
 	cl_git_pass(git_sysdir_set(GIT_SYSDIR_GLOBAL, NULL));
 }
 
-static void reset_system_search_path(void)
+static void set_system_search_path_from_env(void)
 {
 	cl_git_pass(git_sysdir_set(GIT_SYSDIR_SYSTEM, NULL));
 }
@@ -69,9 +69,7 @@ void test_core_env__cleanup(void)
 			(void)p_rmdir(*val);
 	}
 
-	/* reset search paths to default */
-	reset_global_search_path();
-	reset_system_search_path();
+	cl_sandbox_set_search_path_defaults();
 }
 
 static void setenv_and_check(const char *name, const char *value)
@@ -124,12 +122,12 @@ void test_core_env__0(void)
 			GIT_ENOTFOUND, git_sysdir_find_global_file(&found, testfile));
 
 		setenv_and_check("HOME", path.ptr);
-		reset_global_search_path();
+		set_global_search_path_from_env();
 
 		cl_git_pass(git_sysdir_find_global_file(&found, testfile));
 
 		cl_setenv("HOME", env_save[0]);
-		reset_global_search_path();
+		set_global_search_path_from_env();
 
 		cl_assert_equal_i(
 			GIT_ENOTFOUND, git_sysdir_find_global_file(&found, testfile));
@@ -138,7 +136,7 @@ void test_core_env__0(void)
 		setenv_and_check("HOMEDRIVE", NULL);
 		setenv_and_check("HOMEPATH", NULL);
 		setenv_and_check("USERPROFILE", path.ptr);
-		reset_global_search_path();
+		set_global_search_path_from_env();
 
 		cl_git_pass(git_sysdir_find_global_file(&found, testfile));
 
@@ -148,7 +146,7 @@ void test_core_env__0(void)
 
 			if (root >= 0) {
 				setenv_and_check("USERPROFILE", NULL);
-				reset_global_search_path();
+				set_global_search_path_from_env();
 
 				cl_assert_equal_i(
 					GIT_ENOTFOUND, git_sysdir_find_global_file(&found, testfile));
@@ -158,7 +156,7 @@ void test_core_env__0(void)
 				setenv_and_check("HOMEDRIVE", path.ptr);
 				path.ptr[root] = old;
 				setenv_and_check("HOMEPATH", &path.ptr[root]);
-				reset_global_search_path();
+				set_global_search_path_from_env();
 
 				cl_git_pass(git_sysdir_find_global_file(&found, testfile));
 			}
@@ -185,7 +183,7 @@ void test_core_env__1(void)
 	cl_git_pass(cl_setenv("HOMEPATH", "doesnotexist"));
 	cl_git_pass(cl_setenv("USERPROFILE", "doesnotexist"));
 #endif
-	reset_global_search_path();
+	set_global_search_path_from_env();
 
 	cl_assert_equal_i(
 		GIT_ENOTFOUND, git_sysdir_find_global_file(&path, "nonexistentfile"));
@@ -195,8 +193,8 @@ void test_core_env__1(void)
 	cl_git_pass(cl_setenv("HOMEPATH", NULL));
 	cl_git_pass(cl_setenv("USERPROFILE", NULL));
 #endif
-	reset_global_search_path();
-	reset_system_search_path();
+	set_global_search_path_from_env();
+	set_system_search_path_from_env();
 
 	cl_assert_equal_i(
 		GIT_ENOTFOUND, git_sysdir_find_global_file(&path, "nonexistentfile"));
@@ -206,7 +204,7 @@ void test_core_env__1(void)
 
 #ifdef GIT_WIN32
 	cl_git_pass(cl_setenv("PROGRAMFILES", NULL));
-	reset_system_search_path();
+	set_system_search_path_from_env();
 
 	cl_assert_equal_i(
 		GIT_ENOTFOUND, git_sysdir_find_system_file(&path, "nonexistentfile"));
diff --git a/tests/main.c b/tests/main.c
index ffbbcbf48..3de4f9801 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -6,16 +6,12 @@ int __cdecl main(int argc, char *argv[])
 int main(int argc, char *argv[])
 #endif
 {
-	const char *sandbox_path;
 	int res;
 
 	clar_test_init(argc, argv);
 
 	git_threads_init();
-
-	sandbox_path = clar_sandbox_path();
-	git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, sandbox_path);
-	git_libgit2_opts(GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_XDG, sandbox_path);
+	cl_sandbox_set_search_path_defaults();
 
 	/* Run the test suite */
 	res = clar_test_run();
diff --git a/tests/repo/config.c b/tests/repo/config.c
index 2e7be37aa..93dedd576 100644
--- a/tests/repo/config.c
+++ b/tests/repo/config.c
@@ -8,7 +8,8 @@ static git_buf path = GIT_BUF_INIT;
 void test_repo_config__initialize(void)
 {
 	cl_fixture_sandbox("empty_standard_repo");
-	cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git"));
+	cl_git_pass(cl_rename(
+		"empty_standard_repo/.gitted", "empty_standard_repo/.git"));
 
 	git_buf_clear(&path);
 
@@ -18,15 +19,19 @@ void test_repo_config__initialize(void)
 
 void test_repo_config__cleanup(void)
 {
-	cl_git_pass(git_path_prettify(&path, "alternate", NULL));
-	cl_git_pass(git_futils_rmdir_r(path.ptr, NULL, GIT_RMDIR_REMOVE_FILES));
+	cl_sandbox_set_search_path_defaults();
+
 	git_buf_free(&path);
+
+	cl_git_pass(
+		git_futils_rmdir_r("alternate", NULL, GIT_RMDIR_REMOVE_FILES));
 	cl_assert(!git_path_isdir("alternate"));
 
 	cl_fixture_cleanup("empty_standard_repo");
+
 }
 
-void test_repo_config__open_missing_global(void)
+void test_repo_config__can_open_global_when_there_is_no_file(void)
 {
 	git_repository *repo;
 	git_config *config, *global;
@@ -40,23 +45,23 @@ void test_repo_config__open_missing_global(void)
 
 	cl_git_pass(git_repository_open(&repo, "empty_standard_repo"));
 	cl_git_pass(git_repository_config(&config, repo));
-	cl_git_pass(git_config_open_level(&global, config, GIT_CONFIG_LEVEL_GLOBAL));
+	cl_git_pass(git_config_open_level(
+		&global, config, GIT_CONFIG_LEVEL_GLOBAL));
 
 	cl_git_pass(git_config_set_string(global, "test.set", "42"));
 
 	git_config_free(global);
 	git_config_free(config);
 	git_repository_free(repo);
-
-	git_sysdir_global_shutdown();
 }
 
-void test_repo_config__open_missing_global_with_separators(void)
+void test_repo_config__can_open_missing_global_with_separators(void)
 {
 	git_repository *repo;
 	git_config *config, *global;
 
-	cl_git_pass(git_buf_printf(&path, "%c%s", GIT_PATH_LIST_SEPARATOR, "dummy"));
+	cl_git_pass(git_buf_printf(
+		&path, "%c%s", GIT_PATH_LIST_SEPARATOR, "dummy"));
 
 	cl_git_pass(git_libgit2_opts(
 		GIT_OPT_SET_SEARCH_PATH, GIT_CONFIG_LEVEL_GLOBAL, path.ptr));
@@ -69,20 +74,19 @@ void test_repo_config__open_missing_global_with_separators(void)
 
 	cl_git_pass(git_repository_open(&repo, "empty_standard_repo"));
 	cl_git_pass(git_repository_config(&config, repo));
-	cl_git_pass(git_config_open_level(&global, config, GIT_CONFIG_LEVEL_GLOBAL));
+	cl_git_pass(git_config_open_level(
+		&global, config, GIT_CONFIG_LEVEL_GLOBAL));
 
 	cl_git_pass(git_config_set_string(global, "test.set", "42"));
 
 	git_config_free(global);
 	git_config_free(config);
 	git_repository_free(repo);
-
-	git_sysdir_global_shutdown();
 }
 
 #include "repository.h"
 
-void test_repo_config__read_no_configs(void)
+void test_repo_config__read_with_no_configs_at_all(void)
 {
 	git_repository *repo;
 	int val;
@@ -106,9 +110,9 @@ void test_repo_config__read_no_configs(void)
 	cl_assert_equal_i(GIT_ABBREV_DEFAULT, val);
 	git_repository_free(repo);
 
-	git_sysdir_global_shutdown();
+	/* with no local config, just system */
 
-	/* with just system */
+	cl_sandbox_set_search_path_defaults();
 
 	cl_must_pass(p_mkdir("alternate/1", 0777));
 	cl_git_pass(git_buf_joinpath(&path, path.ptr, "1"));
@@ -123,7 +127,7 @@ void test_repo_config__read_no_configs(void)
 	cl_assert_equal_i(10, val);
 	git_repository_free(repo);
 
-	/* with xdg + system */
+	/* with just xdg + system */
 
 	cl_must_pass(p_mkdir("alternate/2", 0777));
 	path.ptr[path.size - 1] = '2';
@@ -204,6 +208,4 @@ void test_repo_config__read_no_configs(void)
 
 	cl_assert(!git_path_exists("empty_standard_repo/.git/config"));
 	cl_assert(!git_path_exists("alternate/3/.gitconfig"));
-
-	git_sysdir_global_shutdown();
 }
diff --git a/tests/repo/open.c b/tests/repo/open.c
index 190adff1c..637c785d5 100644
--- a/tests/repo/open.c
+++ b/tests/repo/open.c
@@ -298,7 +298,8 @@ void test_repo_open__no_config(void)
 	git_config *config;
 
 	cl_fixture_sandbox("empty_standard_repo");
-	cl_git_pass(cl_rename("empty_standard_repo/.gitted", "empty_standard_repo/.git"));
+	cl_git_pass(cl_rename(
+		"empty_standard_repo/.gitted", "empty_standard_repo/.git"));
 
 	/* remove local config */
 	cl_git_pass(git_futils_rmdir_r(
@@ -325,7 +326,7 @@ void test_repo_open__no_config(void)
 	git_repository_free(repo);
 	cl_fixture_cleanup("empty_standard_repo");
 
-	git_sysdir_global_shutdown();
+	cl_sandbox_set_search_path_defaults();
 }
 
 void test_repo_open__force_bare(void)
-- 
cgit v1.2.3


From 649214be4bd9d8239787e3af7e6d877955d09e11 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 15 May 2014 19:59:05 +0200
Subject: pack: init the cache on packfile alloc

When running multithreaded, it is not enough to check for the offmap
allocation. Move the call to cache_init() to packfile allocation so we
can be sure it is always allocated free of races.

This fixes #2355.
---
 src/pack.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/src/pack.c b/src/pack.c
index d93ee25f9..ace7abb58 100644
--- a/src/pack.c
+++ b/src/pack.c
@@ -83,16 +83,12 @@ static void cache_free(git_pack_cache *cache)
 		}
 
 		git_offmap_free(cache->entries);
-		git_mutex_free(&cache->lock);
+		cache->entries = NULL;
 	}
-
-	memset(cache, 0, sizeof(*cache));
 }
 
 static int cache_init(git_pack_cache *cache)
 {
-	memset(cache, 0, sizeof(*cache));
-
 	cache->entries = git_offmap_alloc();
 	GITERR_CHECK_ALLOC(cache->entries);
 
@@ -534,9 +530,6 @@ static int pack_dependency_chain(git_dependency_chain *chain_out,
 	size_t size, elem_pos;
 	git_otype type;
 
-	if (!p->bases.entries && (cache_init(&p->bases) < 0))
-		return -1;
-
 	elem_pos = 0;
 	while (true) {
 		struct pack_chain_elem *elem;
@@ -985,6 +978,7 @@ void git_packfile_free(struct git_pack_file *p)
 	git__free(p->bad_object_sha1);
 
 	git_mutex_free(&p->lock);
+	git_mutex_free(&p->bases.lock);
 	git__free(p);
 }
 
@@ -1120,6 +1114,11 @@ int git_packfile_alloc(struct git_pack_file **pack_out, const char *path)
 		return -1;
 	}
 
+	if (cache_init(&p->bases) < 0) {
+		git__free(p);
+		return -1;
+	}
+
 	*pack_out = p;
 
 	return 0;
-- 
cgit v1.2.3


From ec8a949a58864272860a4838c6b3d862beda7076 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 30 Apr 2014 09:20:03 +0200
Subject: remote: remove remote-tracking branches on delete

When we delete a remote, we also need to go through its fetch refspecs
and remove the references they create locally.
---
 src/remote.c                  | 58 ++++++++++++++++++++++++++++++++++++++++---
 tests/network/remote/delete.c | 12 ++++++---
 2 files changed, 62 insertions(+), 8 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index ca1099a7f..f55375398 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1813,6 +1813,53 @@ static int remove_branch_config_related_entries(
 	return error;
 }
 
+static int remove_refs(git_repository *repo, const char *glob)
+{
+	git_reference_iterator *iter;
+	const char *name;
+	int error;
+
+	if ((error = git_reference_iterator_glob_new(&iter, repo, glob)) < 0)
+		return error;
+
+	while ((error = git_reference_next_name(&name, iter)) == 0) {
+		if ((error = git_reference_remove(repo, name)) < 0)
+			break;
+	}
+	git_reference_iterator_free(iter);
+
+	if (error == GIT_ITEROVER)
+		error = 0;
+
+	return error;
+}
+
+static int remove_remote_tracking(git_repository *repo, const char *remote_name)
+{
+	git_remote *remote;
+	int error;
+	size_t i, count;
+
+	/* we want to use what's on the config, regardless of changes to the instance in memory */
+	if ((error = git_remote_load(&remote, repo, remote_name)) < 0)
+		return error;
+
+	count = git_remote_refspec_count(remote);
+	for (i = 0; i < count; i++) {
+		const git_refspec *refspec = git_remote_get_refspec(remote, i);
+
+		/* shouldn't ever actually happen */
+		if (refspec == NULL)
+			continue;
+
+		if ((error = remove_refs(repo, git_refspec_dst(refspec))) < 0)
+			break;
+	}
+
+	git_remote_free(remote);
+	return error;
+}
+
 int git_remote_delete(git_remote *remote)
 {
 	int error;
@@ -1827,14 +1874,17 @@ int git_remote_delete(git_remote *remote)
 
 	repo = git_remote_owner(remote);
 
-	if ((error = rename_remote_config_section(
-		repo, git_remote_name(remote), NULL)) < 0)
-		return error;
-
 	if ((error = remove_branch_config_related_entries(repo,
 		git_remote_name(remote))) < 0)
 		return error;
 
+	if ((error = remove_remote_tracking(repo, git_remote_name(remote))) < 0)
+		return error;
+
+	if ((error = rename_remote_config_section(
+		repo, git_remote_name(remote), NULL)) < 0)
+		return error;
+
 	git_remote_free(remote);
 
 	return 0;
diff --git a/tests/network/remote/delete.c b/tests/network/remote/delete.c
index 5bf944cda..db55b0768 100644
--- a/tests/network/remote/delete.c
+++ b/tests/network/remote/delete.c
@@ -27,14 +27,18 @@ void test_network_remote_delete__cannot_delete_an_anonymous_remote(void)
 	cl_git_fail(git_remote_delete(remote));
 
 	git_remote_free(remote);
+	git_remote_free(_remote);
 }
 
-void test_network_remote_delete__deleting_a_remote_removes_the_remote_tracking_references(void)
+void test_network_remote_delete__remove_remote_tracking_branches(void)
 {
-	cl_assert(false);
+	git_reference *ref;
+
+	cl_git_pass(git_remote_delete(_remote));
+	cl_git_fail_with(GIT_ENOTFOUND, git_reference_lookup(&ref, _repo, "refs/remotes/test/master"));
 }
 
-void test_network_remote_delete__deleting_a_remote_removes_the_remote_configuration_settings(void)
+void test_network_remote_delete__remove_remote_configuration_settings(void)
 {
 	cl_assert(count_config_entries_match(_repo, "remote\\.test\\.+") > 0);
 
@@ -43,7 +47,7 @@ void test_network_remote_delete__deleting_a_remote_removes_the_remote_configurat
 	cl_assert_equal_i(0, count_config_entries_match(_repo, "remote\\.test\\.+"));
 }
 
-void test_network_remote_delete__deleting_a_remote_removes_the_branch_remote_configuration_settings(void)
+void test_network_remote_delete__remove_branch_upstream_configuration_settings(void)
 {
 	assert_config_entry_existence(_repo, "branch.mergeless.remote", true);
 	assert_config_entry_existence(_repo, "branch.master.remote", true);
-- 
cgit v1.2.3


From bafaf790cd26e6dd827599f2d07d76e82f346e1a Mon Sep 17 00:00:00 2001
From: Edward Lee <e45lee@uwaterloo.ca>
Date: Fri, 16 May 2014 08:09:20 -0400
Subject: Fixed permissions on template directories.

---
 src/repository.c | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/repository.c b/src/repository.c
index b0db5484a..695351977 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1190,6 +1190,7 @@ static int repo_init_structure(
 	bool external_tpl =
 		((opts->flags & GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE) != 0);
 	mode_t dmode = pick_dir_mode(opts);
+	bool chmod = opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK;
 
 	/* Hide the ".git" directory */
 #ifdef GIT_WIN32
@@ -1230,10 +1231,17 @@ static int repo_init_structure(
 			default_template = true;
 		}
 
-		if (tdir)
-			error = git_futils_cp_r(tdir, repo_dir,
-				GIT_CPDIR_COPY_SYMLINKS | GIT_CPDIR_CHMOD_DIRS |
-				GIT_CPDIR_SIMPLE_TO_MODE, dmode);
+		if (tdir) {
+			if (chmod) {
+				error = git_futils_cp_r(tdir, repo_dir,
+					GIT_CPDIR_COPY_SYMLINKS | GIT_CPDIR_CHMOD_DIRS |
+					GIT_CPDIR_SIMPLE_TO_MODE, dmode);
+			} else {
+				error = git_futils_cp_r(tdir, repo_dir,
+					GIT_CPDIR_COPY_SYMLINKS |
+					GIT_CPDIR_SIMPLE_TO_MODE, dmode);
+			}
+		}
 
 		git_buf_free(&template_buf);
 		git_config_free(cfg);
@@ -1254,9 +1262,15 @@ static int repo_init_structure(
 	 * - only create files if no external template was specified
 	 */
 	for (tpl = repo_template; !error && tpl->path; ++tpl) {
-		if (!tpl->content)
-			error = git_futils_mkdir(
-				tpl->path, repo_dir, dmode, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD);
+		if (!tpl->content) {
+			if (chmod) {
+				error = git_futils_mkdir(
+					tpl->path, repo_dir, dmode, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD);
+			} else {
+				error = git_futils_mkdir(
+					tpl->path, repo_dir, dmode, GIT_MKDIR_PATH);
+			}
+		}
 		else if (!external_tpl) {
 			const char *content = tpl->content;
 
-- 
cgit v1.2.3


From f0b820dd67ee6ac53bf6bebd84dfa5c709c4b499 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Fri, 16 May 2014 12:38:56 -0400
Subject: Win32: Supply _O_NOINHERIT when calling _wopen

---
 src/win32/posix_w32.c | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c
index 0d070f6b5..73bf92572 100644
--- a/src/win32/posix_w32.c
+++ b/src/win32/posix_w32.c
@@ -19,6 +19,15 @@
 # define FILE_NAME_NORMALIZED 0
 #endif
 
+/* Options which we always provide to _wopen.
+ *
+ * _O_BINARY - Raw access; no translation of CR or LF characters
+ * _O_NOINHERIT - Do not mark the created handle as inheritable by child processes.
+ *    The Windows default is 'not inheritable', but the CRT's default (following
+ *    POSIX convention) is 'inheritable'. We have no desire for our handles to be
+ *    inheritable on Windows, so specify the flag to get default behavior back. */
+#define STANDARD_OPEN_FLAGS (_O_BINARY | _O_NOINHERIT)
+
 /* GetFinalPathNameByHandleW signature */
 typedef DWORD(WINAPI *PFGetFinalPathNameByHandleW)(HANDLE, LPWSTR, DWORD, DWORD);
 
@@ -317,7 +326,7 @@ int p_open(const char *path, int flags, ...)
 		va_end(arg_list);
 	}
 
-	return _wopen(buf, flags | _O_BINARY, mode);
+	return _wopen(buf, flags | STANDARD_OPEN_FLAGS, mode);
 }
 
 int p_creat(const char *path, mode_t mode)
@@ -327,7 +336,7 @@ int p_creat(const char *path, mode_t mode)
 	if (utf8_to_16_with_errno(buf, path) < 0)
 		return -1;
 
-	return _wopen(buf, _O_WRONLY | _O_CREAT | _O_TRUNC | _O_BINARY, mode);
+	return _wopen(buf, _O_WRONLY | _O_CREAT | _O_TRUNC | STANDARD_OPEN_FLAGS, mode);
 }
 
 int p_getcwd(char *buffer_out, size_t size)
-- 
cgit v1.2.3


From d0f00de4d8e2173a3132f0024e74f5049638ce2f Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 16 May 2014 11:08:19 -0700
Subject: Increase binary detection len to 8k

---
 src/blob.c        | 3 ++-
 src/diff_driver.c | 6 +++++-
 src/filter.h      | 4 ++++
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/blob.c b/src/blob.c
index ab7dec67f..30d5b705b 100644
--- a/src/blob.c
+++ b/src/blob.c
@@ -334,7 +334,8 @@ int git_blob_is_binary(const git_blob *blob)
 	assert(blob);
 
 	content.ptr   = blob->odb_object->buffer;
-	content.size  = min(blob->odb_object->cached.size, 4000);
+	content.size  =
+		min(blob->odb_object->cached.size, GIT_FILTER_BYTES_TO_CHECK_NUL);
 	content.asize = 0;
 
 	return git_buf_text_is_binary(&content);
diff --git a/src/diff_driver.c b/src/diff_driver.c
index dc8e79e25..c3c5f365b 100644
--- a/src/diff_driver.c
+++ b/src/diff_driver.c
@@ -397,7 +397,11 @@ void git_diff_driver_update_options(
 int git_diff_driver_content_is_binary(
 	git_diff_driver *driver, const char *content, size_t content_len)
 {
-	const git_buf search = { (char *)content, 0, min(content_len, 4000) };
+	git_buf search;
+
+	search.ptr   = (char *)content;
+	search.size  = min(content_len, GIT_FILTER_BYTES_TO_CHECK_NUL);
+	search.asize = 0;
 
 	GIT_UNUSED(driver);
 
diff --git a/src/filter.h b/src/filter.h
index d0ace0f9a..5a366108b 100644
--- a/src/filter.h
+++ b/src/filter.h
@@ -10,6 +10,10 @@
 #include "common.h"
 #include "git2/filter.h"
 
+/* Amount of file to examine for NUL byte when checking binary-ness */
+#define GIT_FILTER_BYTES_TO_CHECK_NUL 8000
+
+/* Possible CRLF values */
 typedef enum {
 	GIT_CRLF_GUESS = -1,
 	GIT_CRLF_BINARY = 0,
-- 
cgit v1.2.3


From 8af4966db15ed35832235627e2d01068d4734dea Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 16 May 2014 16:30:58 -0700
Subject: Git binary check compat tests

A variety of data patterns for diffs verified to match the
behavior of binary detection with Git on the command line.
---
 tests/diff/workdir.c | 114 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)

diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index a6d48abc6..f82bb00e8 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -1580,3 +1580,117 @@ void test_diff_workdir__can_update_index(void)
 
 	git_diff_free(diff);
 }
+
+#define STR7    "0123456"
+#define STR8    "01234567"
+#define STR40   STR8   STR8   STR8   STR8   STR8
+#define STR200  STR40  STR40  STR40  STR40  STR40
+#define STR999Z STR200 STR200 STR200 STR200 STR40 STR40 STR40 STR40 \
+	            STR8 STR8 STR8 STR8 STR7 "\0"
+#define STR1000 STR200 STR200 STR200 STR200 STR200
+#define STR3999Z STR1000 STR1000 STR1000 STR999Z
+#define STR4000 STR1000 STR1000 STR1000 STR1000
+
+static void assert_delta_binary(git_diff *diff, size_t idx, int is_binary)
+{
+	git_patch *patch;
+	const git_diff_delta *delta;
+
+	cl_git_pass(git_patch_from_diff(&patch, diff, idx));
+	delta = git_patch_get_delta(patch);
+	cl_assert_equal_b((delta->flags & GIT_DIFF_FLAG_BINARY), is_binary);
+	git_patch_free(patch);
+}
+
+void test_diff_workdir__binary_detection(void)
+{
+	git_index *idx;
+	git_diff *diff = NULL;
+	git_buf b = GIT_BUF_INIT;
+	int i;
+	git_buf data[10] = {
+		{ "1234567890", 0, 0 },         /* 0 - all ascii text control */
+		{ "Åü†HøπΩ", 0, 0 },            /* 1 - UTF-8 multibyte text */
+		{ "\xEF\xBB\xBFÜ⤒ƒ8£€", 0, 0 }, /* 2 - UTF-8 with BOM */
+		{ STR999Z, 0, 1000 },           /* 3 - ASCII with NUL at 1000 */
+		{ STR3999Z, 0, 4000 },          /* 4 - ASCII with NUL at 4000 */
+		{ STR4000 STR3999Z "x", 0, 8001 }, /* 5 - ASCII with NUL at 8000 */
+		{ STR4000 STR4000 "\0", 0, 8001 }, /* 6 - ASCII with NUL at 8001 */
+		{ "\x00\xDC\x00\x6E\x21\x39\xFE\x0E\x00\x63\x00\xF8"
+		  "\x00\x64\x00\x65\x20\x48", 0, 18 }, /* 7 - UTF-16 text */
+		{ "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d"
+		  "\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d",
+		  0, 26 }, /* 8 - All non-printable characters (no NUL) */
+		{ "Hello \x01\x02\x03\x04\x05\x06 World!\x01\x02\x03\x04"
+		  "\x05\x06\x07", 0, 26 }, /* 9 - 50-50 non-printable (no NUL) */
+	};
+
+	g_repo = cl_git_sandbox_init("empty_standard_repo");
+	cl_git_pass(git_repository_index(&idx, g_repo));
+
+	/* We start with ASCII in index and test data in workdir,
+	 * then we will try with test data in index and ASCII in workdir.
+	 */
+
+	cl_git_pass(git_buf_sets(&b, "empty_standard_repo/0"));
+	for (i = 0; i < 10; ++i) {
+		b.ptr[b.size - 1] = '0' + i;
+		cl_git_mkfile(b.ptr, "baseline");
+		cl_git_pass(git_index_add_bypath(idx, &b.ptr[b.size - 1]));
+
+		if (data[i].size == 0)
+			data[i].size = strlen(data[i].ptr);
+		cl_git_write2file(
+			b.ptr, data[i].ptr, data[i].size, O_WRONLY|O_TRUNC, 0664);
+	}
+	git_index_write(idx);
+
+	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
+
+	cl_assert_equal_i(10, git_diff_num_deltas(diff));
+
+	/* using diff binary detection (i.e. looking for NUL byte) */
+	assert_delta_binary(diff, 0, false);
+	assert_delta_binary(diff, 1, false);
+	assert_delta_binary(diff, 2, false);
+	assert_delta_binary(diff, 3, true);
+	assert_delta_binary(diff, 4, true);
+	assert_delta_binary(diff, 5, true);
+	assert_delta_binary(diff, 6, false);
+	assert_delta_binary(diff, 7, true);
+	assert_delta_binary(diff, 8, false);
+	assert_delta_binary(diff, 9, false);
+	/* The above have been checked to match command-line Git */
+
+	git_diff_free(diff);
+
+	cl_git_pass(git_buf_sets(&b, "empty_standard_repo/0"));
+	for (i = 0; i < 10; ++i) {
+		b.ptr[b.size - 1] = '0' + i;
+		cl_git_pass(git_index_add_bypath(idx, &b.ptr[b.size - 1]));
+
+		cl_git_write2file(b.ptr, "baseline\n", 9, O_WRONLY|O_TRUNC, 0664);
+	}
+	git_index_write(idx);
+
+	cl_git_pass(git_diff_index_to_workdir(&diff, g_repo, NULL, NULL));
+
+	cl_assert_equal_i(10, git_diff_num_deltas(diff));
+
+	/* using diff binary detection (i.e. looking for NUL byte) */
+	assert_delta_binary(diff, 0, false);
+	assert_delta_binary(diff, 1, false);
+	assert_delta_binary(diff, 2, false);
+	assert_delta_binary(diff, 3, true);
+	assert_delta_binary(diff, 4, true);
+	assert_delta_binary(diff, 5, true);
+	assert_delta_binary(diff, 6, false);
+	assert_delta_binary(diff, 7, true);
+	assert_delta_binary(diff, 8, false);
+	assert_delta_binary(diff, 9, false);
+
+	git_diff_free(diff);
+
+	git_index_free(idx);
+	git_buf_free(&b);
+}
-- 
cgit v1.2.3


From f7310540ae888454f9ab69200cfcd8df07faf957 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 13 May 2014 02:41:48 +0200
Subject: indexer: use mmap for writing

Some OSs cannot keep their ideas about file content straight when mixing
standard IO with file mapping. As we use mmap for reading from the
packfile, let's make writing to the pack file use mmap.
---
 src/indexer.c   | 154 ++++++++++++++++++++++++++++++--------------------------
 src/map.h       |   1 +
 src/posix.c     |   7 +++
 src/posix.h     |   1 +
 src/unix/map.c  |   6 +++
 src/win32/map.c |   5 ++
 6 files changed, 102 insertions(+), 72 deletions(-)

diff --git a/src/indexer.c b/src/indexer.c
index 68496ceea..11268e018 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -34,7 +34,6 @@ struct git_indexer {
 		have_delta :1;
 	struct git_pack_header hdr;
 	struct git_pack_file *pack;
-	git_filebuf pack_file;
 	unsigned int mode;
 	git_off_t off;
 	git_off_t entry_start;
@@ -67,33 +66,18 @@ const git_oid *git_indexer_hash(const git_indexer *idx)
 	return &idx->hash;
 }
 
-static int open_pack(struct git_pack_file **out, const char *filename)
-{
-	struct git_pack_file *pack;
-
-	if (git_packfile_alloc(&pack, filename) < 0)
-		return -1;
-
-	if ((pack->mwf.fd = p_open(pack->pack_name, O_RDONLY)) < 0) {
-		giterr_set(GITERR_OS, "Failed to open packfile.");
-		git_packfile_free(pack);
-		return -1;
-	}
-
-	*out = pack;
-	return 0;
-}
-
 static int parse_header(struct git_pack_header *hdr, struct git_pack_file *pack)
 {
 	int error;
+	git_map map;
 
-	/* Verify we recognize this pack file format. */
-	if ((error = p_read(pack->mwf.fd, hdr, sizeof(*hdr))) < 0) {
-		giterr_set(GITERR_OS, "Failed to read in pack header");
+	if ((error = p_mmap(&map, sizeof(*hdr), GIT_PROT_READ, GIT_MAP_SHARED, pack->mwf.fd, 0)) < 0)
 		return error;
-	}
 
+	memcpy(hdr, map.data, sizeof(*hdr));
+	p_munmap(&map);
+
+	/* Verify we recognize this pack file format. */
 	if (hdr->hdr_signature != ntohl(PACK_SIGNATURE)) {
 		giterr_set(GITERR_INDEXER, "Wrong pack signature");
 		return -1;
@@ -124,9 +108,9 @@ int git_indexer_new(
 		void *progress_payload)
 {
 	git_indexer *idx;
-	git_buf path = GIT_BUF_INIT;
+	git_buf path = GIT_BUF_INIT, tmp_path = GIT_BUF_INIT;
 	static const char suff[] = "/pack";
-	int error;
+	int error, fd;
 
 	idx = git__calloc(1, sizeof(git_indexer));
 	GITERR_CHECK_ALLOC(idx);
@@ -140,19 +124,30 @@ int git_indexer_new(
 	if (error < 0)
 		goto cleanup;
 
-	error = git_filebuf_open(&idx->pack_file, path.ptr,
-		GIT_FILEBUF_TEMPORARY | GIT_FILEBUF_DO_NOT_BUFFER,
-		idx->mode);
+	fd = git_futils_mktmp(&tmp_path, git_buf_cstr(&path), idx->mode);
 	git_buf_free(&path);
+	if (fd < 0)
+		goto cleanup;
+
+	error = git_packfile_alloc(&idx->pack, git_buf_cstr(&tmp_path));
+	git_buf_free(&tmp_path);
+
 	if (error < 0)
 		goto cleanup;
 
+	idx->pack->mwf.fd = fd;
+	if ((error = git_mwindow_file_register(&idx->pack->mwf)) < 0)
+		goto cleanup;
+
 	*out = idx;
 	return 0;
 
 cleanup:
+	if (fd != -1)
+		p_close(fd);
+
 	git_buf_free(&path);
-	git_filebuf_cleanup(&idx->pack_file);
+	git_buf_free(&tmp_path);
 	git__free(idx);
 	return -1;
 }
@@ -429,6 +424,40 @@ static void hash_partially(git_indexer *idx, const uint8_t *data, size_t size)
 	idx->inbuf_len += size - to_expell;
 }
 
+static int write_at(git_indexer *idx, const void *data, git_off_t offset, size_t size)
+{
+	git_file fd = idx->pack->mwf.fd;
+	long page_size = git__page_size();
+	git_off_t page_start, page_offset;
+	git_map map;
+	int error;
+
+	/* the offset needs to be at the beginning of the a page boundary */
+	page_start = (offset / page_size) * page_size;
+	page_offset = offset - page_start;
+
+	if ((error = p_mmap(&map, page_offset + size, GIT_PROT_WRITE, GIT_MAP_SHARED, fd, page_start)) < 0)
+		return error;
+
+	memcpy(map.data + page_offset, data, size);
+	p_munmap(&map);
+
+	return 0;
+}
+
+static int append_to_pack(git_indexer *idx, const void *data, size_t size)
+{
+	git_off_t current_size = idx->pack->mwf.size;
+
+	/* add the extra space we need at the end */
+	if (p_ftruncate(idx->pack->mwf.fd, current_size + size) < 0) {
+		giterr_system_set(errno);
+		return -1;
+	}
+
+	return write_at(idx, data, idx->pack->mwf.size, size);
+}
+
 int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_transfer_progress *stats)
 {
 	int error = -1;
@@ -440,22 +469,13 @@ int git_indexer_append(git_indexer *idx, const void *data, size_t size, git_tran
 
 	processed = stats->indexed_objects;
 
-	if ((error = git_filebuf_write(&idx->pack_file, data, size)) < 0)
+	if ((error = append_to_pack(idx, data, size)) < 0)
 		return error;
 
 	hash_partially(idx, data, (int)size);
 
 	/* Make sure we set the new size of the pack */
-	if (idx->opened_pack) {
-		idx->pack->mwf.size += size;
-	} else {
-		if ((error = open_pack(&idx->pack, idx->pack_file.path_lock)) < 0)
-			return error;
-		idx->opened_pack = 1;
-		mwf = &idx->pack->mwf;
-		if ((error = git_mwindow_file_register(&idx->pack->mwf)) < 0)
-			return error;
-	}
+	idx->pack->mwf.size += size;
 
 	if (!idx->parsed_header) {
 		unsigned int total_objects;
@@ -616,17 +636,10 @@ static int index_path(git_buf *path, git_indexer *idx, const char *suffix)
  * Rewind the packfile by the trailer, as we might need to fix the
  * packfile by injecting objects at the tail and must overwrite it.
  */
-static git_off_t seek_back_trailer(git_indexer *idx)
+static void seek_back_trailer(git_indexer *idx)
 {
-	git_off_t off;
-
-	if ((off = p_lseek(idx->pack_file.fd, -GIT_OID_RAWSZ, SEEK_CUR)) < 0)
-		return -1;
-
 	idx->pack->mwf.size -= GIT_OID_RAWSZ;
 	git_mwindow_free_all(&idx->pack->mwf);
-
-	return off;
 }
 
 static int inject_object(git_indexer *idx, git_oid *id)
@@ -642,7 +655,8 @@ static int inject_object(git_indexer *idx, git_oid *id)
 	size_t len, hdr_len;
 	int error;
 
-	entry_start = seek_back_trailer(idx);
+	seek_back_trailer(idx);
+	entry_start = idx->pack->mwf.size;
 
 	if (git_odb_read(&obj, idx->odb, id) < 0)
 		return -1;
@@ -657,7 +671,9 @@ static int inject_object(git_indexer *idx, git_oid *id)
 
 	/* Write out the object header */
 	hdr_len = git_packfile__object_header(hdr, len, git_odb_object_type(obj));
-	git_filebuf_write(&idx->pack_file, hdr, hdr_len);
+	if ((error = append_to_pack(idx, hdr, hdr_len)) < 0)
+		goto cleanup;
+
 	idx->pack->mwf.size += hdr_len;
 	entry->crc = crc32(entry->crc, hdr, (uInt)hdr_len);
 
@@ -665,13 +681,16 @@ static int inject_object(git_indexer *idx, git_oid *id)
 		goto cleanup;
 
 	/* And then the compressed object */
-	git_filebuf_write(&idx->pack_file, buf.ptr, buf.size);
+	if ((error = append_to_pack(idx, buf.ptr, buf.size)) < 0)
+		goto cleanup;
+
 	idx->pack->mwf.size += buf.size;
 	entry->crc = htonl(crc32(entry->crc, (unsigned char *)buf.ptr, (uInt)buf.size));
 	git_buf_free(&buf);
 
 	/* Write a fake trailer so the pack functions play ball */
-	if ((error = git_filebuf_write(&idx->pack_file, &foo, GIT_OID_RAWSZ)) < 0)
+
+	if ((error = append_to_pack(idx, &foo, GIT_OID_RAWSZ)) < 0)
 		goto cleanup;
 
 	idx->pack->mwf.size += GIT_OID_RAWSZ;
@@ -817,19 +836,12 @@ static int update_header_and_rehash(git_indexer *idx, git_transfer_progress *sta
 	ctx = &idx->trailer;
 
 	git_hash_ctx_init(ctx);
-	git_mwindow_free_all(mwf);
+
 
 	/* Update the header to include the numer of local objects we injected */
 	idx->hdr.hdr_entries = htonl(stats->total_objects + stats->local_objects);
-	if (p_lseek(idx->pack_file.fd, 0, SEEK_SET) < 0) {
-		giterr_set(GITERR_OS, "failed to seek to the beginning of the pack");
+	if (write_at(idx, &idx->hdr, 0, sizeof(struct git_pack_header)) < 0)
 		return -1;
-	}
-
-	if (p_write(idx->pack_file.fd, &idx->hdr, sizeof(struct git_pack_header)) < 0) {
-		giterr_set(GITERR_OS, "failed to update the pack header");
-		return -1;
-	}
 
 	/*
 	 * We now use the same technique as before to determine the
@@ -837,6 +849,7 @@ static int update_header_and_rehash(git_indexer *idx, git_transfer_progress *sta
 	 * hash_partially() keep the existing trailer out of the
 	 * calculation.
 	 */
+	git_mwindow_free_all(mwf);
 	idx->inbuf_len = 0;
 	while (hashed < mwf->size) {
 		ptr = git_mwindow_open(mwf, &w, hashed, chunk, &left);
@@ -906,13 +919,7 @@ int git_indexer_commit(git_indexer *idx, git_transfer_progress *stats)
 			return -1;
 
 		git_hash_final(&trailer_hash, &idx->trailer);
-		if (p_lseek(idx->pack_file.fd, -GIT_OID_RAWSZ, SEEK_END) < 0)
-			return -1;
-
-		if (p_write(idx->pack_file.fd, &trailer_hash, GIT_OID_RAWSZ) < 0) {
-			giterr_set(GITERR_OS, "failed to update pack trailer");
-			return -1;
-		}
+		write_at(idx, &trailer_hash, idx->pack->mwf.size - GIT_OID_RAWSZ, GIT_OID_RAWSZ);
 	}
 
 	git_vector_sort(&idx->objects);
@@ -995,14 +1002,18 @@ int git_indexer_commit(git_indexer *idx, git_transfer_progress *stats)
 
 	git_mwindow_free_all(&idx->pack->mwf);
 	/* We need to close the descriptor here so Windows doesn't choke on commit_at */
-	p_close(idx->pack->mwf.fd);
+	if (p_close(idx->pack->mwf.fd) < 0) {
+		giterr_set(GITERR_OS, "failed to close packfile");
+		goto on_error;
+	}
+
 	idx->pack->mwf.fd = -1;
 
 	if (index_path(&filename, idx, ".pack") < 0)
 		goto on_error;
+
 	/* And don't forget to rename the packfile to its new place. */
-	if (git_filebuf_commit_at(&idx->pack_file, filename.ptr) < 0)
-		return -1;
+	p_rename(idx->pack->pack_name, git_buf_cstr(&filename));
 
 	git_buf_free(&filename);
 	return 0;
@@ -1022,7 +1033,7 @@ void git_indexer_free(git_indexer *idx)
 
 	git_vector_free_deep(&idx->objects);
 
-	if (idx->pack) {
+	if (idx->pack && idx->pack->idx_cache) {
 		struct git_pack_entry *pentry;
 		kh_foreach_value(
 			idx->pack->idx_cache, pentry, { git__free(pentry); });
@@ -1032,6 +1043,5 @@ void git_indexer_free(git_indexer *idx)
 
 	git_vector_free_deep(&idx->deltas);
 	git_packfile_free(idx->pack);
-	git_filebuf_cleanup(&idx->pack_file);
 	git__free(idx);
 }
diff --git a/src/map.h b/src/map.h
index da3d1e19a..722eb7a30 100644
--- a/src/map.h
+++ b/src/map.h
@@ -42,5 +42,6 @@ typedef struct { /* memory mapped buffer	*/
 
 extern int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset);
 extern int p_munmap(git_map *map);
+extern long git__page_size(void);
 
 #endif /* INCLUDE_map_h__ */
diff --git a/src/posix.c b/src/posix.c
index 7484ac0d8..7aeb0e6c1 100644
--- a/src/posix.c
+++ b/src/posix.c
@@ -207,6 +207,13 @@ int p_write(git_file fd, const void *buf, size_t cnt)
 
 #include "map.h"
 
+long git__page_size(void)
+{
+	/* dummy; here we don't need any alignment anyway */
+	return 4096;
+}
+
+
 int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
 {
 	GIT_MMAP_VALIDATE(out, len, prot, flags);
diff --git a/src/posix.h b/src/posix.h
index f85b1aebd..745e4af75 100644
--- a/src/posix.h
+++ b/src/posix.h
@@ -60,6 +60,7 @@ extern int p_write(git_file fd, const void *buf, size_t cnt);
 #define p_lseek(f,n,w) lseek(f, n, w)
 #define p_close(fd) close(fd)
 #define p_umask(m) umask(m)
+#define p_ftruncate(fd, sz) ftruncate(fd, sz)
 
 extern int p_open(const char *path, int flags, ...);
 extern int p_creat(const char *path, mode_t mode);
diff --git a/src/unix/map.c b/src/unix/map.c
index e62ab3e76..3d0cbbaf8 100644
--- a/src/unix/map.c
+++ b/src/unix/map.c
@@ -10,8 +10,14 @@
 
 #include "map.h"
 #include <sys/mman.h>
+#include <unistd.h>
 #include <errno.h>
 
+long git__page_size(void)
+{
+	return sysconf(_SC_PAGE_SIZE);
+}
+
 int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
 {
 	int mprot = 0;
diff --git a/src/win32/map.c b/src/win32/map.c
index 902ea3994..ef83f882e 100644
--- a/src/win32/map.c
+++ b/src/win32/map.c
@@ -23,6 +23,11 @@ static DWORD get_page_size(void)
 	return page_size;
 }
 
+long git__page_size(void)
+{
+	return (long)get_page_size();
+}
+
 int p_mmap(git_map *out, size_t len, int prot, int flags, int fd, git_off_t offset)
 {
 	HANDLE fh = (HANDLE)_get_osfhandle(fd);
-- 
cgit v1.2.3


From 0731a5b4db086eefac1a842e37526ef7bdbaa7de Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 14 May 2014 19:12:48 +0200
Subject: indexer: mmap fixes for Windows

Windows has its own ftruncate() called _chsize_s().

p_mkstemp() is changed to use p_open() so we can make sure we open for
writing; the addition of exclusive create is a good thing to do
regardless, as we want a temporary path for ourselves.

Lastly, MSVC doesn't quite know how to add two numbers if one of them is a
void pointer, so let's alias it to unsigned char.C
---
 src/indexer.c         | 4 +++-
 src/posix.h           | 2 +-
 src/win32/posix.h     | 6 ++++++
 src/win32/posix_w32.c | 2 +-
 4 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/indexer.c b/src/indexer.c
index 11268e018..ebfdffb47 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -429,6 +429,7 @@ static int write_at(git_indexer *idx, const void *data, git_off_t offset, size_t
 	git_file fd = idx->pack->mwf.fd;
 	long page_size = git__page_size();
 	git_off_t page_start, page_offset;
+	unsigned char *map_data;
 	git_map map;
 	int error;
 
@@ -439,7 +440,8 @@ static int write_at(git_indexer *idx, const void *data, git_off_t offset, size_t
 	if ((error = p_mmap(&map, page_offset + size, GIT_PROT_WRITE, GIT_MAP_SHARED, fd, page_start)) < 0)
 		return error;
 
-	memcpy(map.data + page_offset, data, size);
+	map_data = (unsigned char *)map.data;
+	memcpy(map_data + page_offset, data, size);
 	p_munmap(&map);
 
 	return 0;
diff --git a/src/posix.h b/src/posix.h
index 745e4af75..965cd98d5 100644
--- a/src/posix.h
+++ b/src/posix.h
@@ -60,7 +60,6 @@ extern int p_write(git_file fd, const void *buf, size_t cnt);
 #define p_lseek(f,n,w) lseek(f, n, w)
 #define p_close(fd) close(fd)
 #define p_umask(m) umask(m)
-#define p_ftruncate(fd, sz) ftruncate(fd, sz)
 
 extern int p_open(const char *path, int flags, ...);
 extern int p_creat(const char *path, mode_t mode);
@@ -74,6 +73,7 @@ extern int p_rename(const char *from, const char *to);
 #define p_rmdir(p) rmdir(p)
 #define p_chmod(p,m) chmod(p, m)
 #define p_access(p,m) access(p,m)
+#define p_ftruncate(fd, sz) ftruncate(fd, sz)
 #define p_recv(s,b,l,f) recv(s,b,l,f)
 #define p_send(s,b,l,f) send(s,b,l,f)
 typedef int GIT_SOCKET;
diff --git a/src/win32/posix.h b/src/win32/posix.h
index 7f9d57cc3..2cbea1807 100644
--- a/src/win32/posix.h
+++ b/src/win32/posix.h
@@ -19,6 +19,12 @@
 # define EAFNOSUPPORT (INT_MAX-1)
 #endif
 
+#ifdef _MSC_VER
+# define p_ftruncate(fd, sz) _chsize_s(fd, sz)
+#else  /* MinGW */
+# define p_ftruncate(fd, sz) _chsize(fd, sz)
+#endif
+
 GIT_INLINE(int) p_link(const char *old, const char *new)
 {
 	GIT_UNUSED(old);
diff --git a/src/win32/posix_w32.c b/src/win32/posix_w32.c
index 73bf92572..34938431a 100644
--- a/src/win32/posix_w32.c
+++ b/src/win32/posix_w32.c
@@ -578,7 +578,7 @@ int p_mkstemp(char *tmp_path)
 		return -1;
 #endif
 
-	return p_creat(tmp_path, 0744); //-V536
+	return p_open(tmp_path, O_RDWR | O_CREAT | O_EXCL, 0744); //-V536
 }
 
 int p_access(const char* path, mode_t mode)
-- 
cgit v1.2.3


From c6320bec93ec885208e602f7ebef3e7d79ca7901 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Sat, 17 May 2014 12:19:32 -0400
Subject: print_binary_hunk: Treat types with respect

---
 src/diff_print.c | 31 ++++++++++++++++++++++++-------
 1 file changed, 24 insertions(+), 7 deletions(-)

diff --git a/src/diff_print.c b/src/diff_print.c
index 08e1e7f90..de1477a85 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -286,7 +286,9 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 {
 	git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT, *out = NULL;
 	const void *old_data, *new_data;
-	size_t old_data_len, new_data_len, delta_data_len, inflated_len, remain;
+	git_off_t off_t_old_data_len, off_t_new_data_len;
+	unsigned long old_data_len, new_data_len, delta_data_len, inflated_len;
+	size_t remain;
 	const char *out_type = "literal";
 	char *ptr;
 	int error;
@@ -294,8 +296,17 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 	old_data = old ? git_blob_rawcontent(old) : NULL;
 	new_data = new ? git_blob_rawcontent(new) : NULL;
 
-	old_data_len = old ? (size_t)git_blob_rawsize(old) : 0;
-	new_data_len = new ? (size_t)git_blob_rawsize(new) : 0;
+	off_t_old_data_len = old ? git_blob_rawsize(old) : 0;
+	off_t_new_data_len = new ? git_blob_rawsize(new) : 0;
+
+	/* The git_delta function accepts unsigned long only */
+	if (off_t_old_data_len > ULONG_MAX || off_t_new_data_len > ULONG_MAX) {
+		error = -1;
+		goto done;
+	}
+
+	old_data_len = (unsigned long)off_t_old_data_len;
+	new_data_len = (unsigned long)off_t_new_data_len;
 
 	out = &deflate;
 	inflated_len = new_data_len;
@@ -304,11 +315,17 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 		&deflate, new_data, new_data_len)) < 0)
 		goto done;
 
+	/* The git_delta function accepts unsigned long only */
+	if (deflate.size > ULONG_MAX) {
+		error = -1;
+		goto done;
+	}
+
 	if (old && new) {
 		void *delta_data;
 
 		delta_data = git_delta(old_data, old_data_len, new_data,
-			new_data_len, &delta_data_len, deflate.size);
+			new_data_len, &delta_data_len, (unsigned long)deflate.size);
 
 		if (delta_data) {
 			error = git_zstream_deflatebuf(&delta, delta_data, delta_data_len);
@@ -325,16 +342,16 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 		}
 	}
 
-	git_buf_printf(pi->buf, "%s %" PRIuZ "\n", out_type, inflated_len);
+	git_buf_printf(pi->buf, "%s %u\n", out_type, inflated_len);
 	pi->line.num_lines++;
 
 	for (ptr = out->ptr, remain = out->size; remain > 0; ) {
 		size_t chunk_len = (52 < remain) ? 52 : remain;
 
 		if (chunk_len <= 26)
-			git_buf_putc(pi->buf, chunk_len + 'A' - 1);
+			git_buf_putc(pi->buf, (char)chunk_len + 'A' - 1);
 		else
-			git_buf_putc(pi->buf, chunk_len - 26 + 'a' - 1);
+			git_buf_putc(pi->buf, (char)chunk_len - 26 + 'a' - 1);
 
 		git_buf_put_base85(pi->buf, ptr, chunk_len);
 		git_buf_putc(pi->buf, '\n');
-- 
cgit v1.2.3


From 4c9ffdff76d6d0c4dd65793148d38b35b7703d0d Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Sat, 17 May 2014 12:45:34 -0400
Subject: Fix printf format string from previous commit

---
 src/diff_print.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/diff_print.c b/src/diff_print.c
index de1477a85..26753515b 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -342,7 +342,7 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 		}
 	}
 
-	git_buf_printf(pi->buf, "%s %u\n", out_type, inflated_len);
+	git_buf_printf(pi->buf, "%s %lu\n", out_type, inflated_len);
 	pi->line.num_lines++;
 
 	for (ptr = out->ptr, remain = out->size; remain > 0; ) {
-- 
cgit v1.2.3


From d7a294633dc6420d2411500bd40c7dfd2aa76d37 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Sat, 17 May 2014 16:58:09 -0400
Subject: Fix a bug in the pack::packbuilder suite

---
 tests/pack/packbuilder.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/pack/packbuilder.c b/tests/pack/packbuilder.c
index 53db81828..1059424ed 100644
--- a/tests/pack/packbuilder.c
+++ b/tests/pack/packbuilder.c
@@ -17,6 +17,7 @@ static git_transfer_progress _stats;
 void test_pack_packbuilder__initialize(void)
 {
 	_repo = cl_git_sandbox_init("testrepo.git");
+	cl_git_pass(p_chdir("testrepo.git"));
 	cl_git_pass(git_revwalk_new(&_revwalker, _repo));
 	cl_git_pass(git_packbuilder_new(&_packbuilder, _repo));
 	cl_git_pass(git_vector_init(&_commits, 0, NULL));
@@ -46,6 +47,7 @@ void test_pack_packbuilder__cleanup(void)
 	git_indexer_free(_indexer);
 	_indexer = NULL;
 
+	p_chdir("..");
 	cl_git_sandbox_cleanup();
 	_repo = NULL;
 }
-- 
cgit v1.2.3


From 49e369b29d5bde227b162dd4681ecccff2f443df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 18 May 2014 10:06:49 +0200
Subject: message: don't assume the comment char

The comment char is configurable and we need to provide a way for the
user to specify which comment char they chose for their message.
---
 include/git2/message.h                 |  8 +++++---
 src/message.c                          |  4 ++--
 tests/object/commit/commitstagedfile.c |  2 +-
 tests/object/message.c                 | 14 +++++++-------
 4 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/include/git2/message.h b/include/git2/message.h
index bcdb72f6a..d78b1dce5 100644
--- a/include/git2/message.h
+++ b/include/git2/message.h
@@ -29,12 +29,14 @@ GIT_BEGIN_DECL
  *
  * @param message The message to be prettified.
  *
- * @param strip_comments Non-zero to remove lines starting with "#", 0 to
- *     leave them in.
+ * @param strip_comments Non-zero to remove comment lines, 0 to leave them in.
+ *
+ * @param comment_char Comment character. Lines starting with this character
+ * are considered to be comments and removed if `strip_comments` is non-zero.
  *
  * @return 0 or an error code.
  */
-GIT_EXTERN(int) git_message_prettify(git_buf *out, const char *message, int strip_comments);
+GIT_EXTERN(int) git_message_prettify(git_buf *out, const char *message, int strip_comments, char comment_char);
 
 /** @} */
 GIT_END_DECL
diff --git a/src/message.c b/src/message.c
index 07b2569ad..6c5a2379f 100644
--- a/src/message.c
+++ b/src/message.c
@@ -21,7 +21,7 @@ static size_t line_length_without_trailing_spaces(const char *line, size_t len)
 
 /* Greatly inspired from git.git "stripspace" */
 /* see https://github.com/git/git/blob/497215d8811ac7b8955693ceaad0899ecd894ed2/builtin/stripspace.c#L4-67 */
-int git_message_prettify(git_buf *message_out, const char *message, int strip_comments)
+int git_message_prettify(git_buf *message_out, const char *message, int strip_comments, char comment_char)
 {
 	const size_t message_len = strlen(message);
 
@@ -40,7 +40,7 @@ int git_message_prettify(git_buf *message_out, const char *message, int strip_co
 			line_length = message_len - i;
 		}
 
-		if (strip_comments && line_length && message[i] == '#')
+		if (strip_comments && line_length && message[i] == comment_char)
 			continue;
 
 		rtrimmed_line_length = line_length_without_trailing_spaces(message + i, line_length);
diff --git a/tests/object/commit/commitstagedfile.c b/tests/object/commit/commitstagedfile.c
index 9758ea9a2..5b48519b8 100644
--- a/tests/object/commit/commitstagedfile.c
+++ b/tests/object/commit/commitstagedfile.c
@@ -112,7 +112,7 @@ void test_object_commit_commitstagedfile__generate_predictable_object_ids(void)
 	cl_git_pass(git_tree_lookup(&tree, repo, &tree_oid));
 
 	memset(&buffer, 0, sizeof(git_buf));
-	cl_git_pass(git_message_prettify(&buffer, "Initial commit", 0));
+	cl_git_pass(git_message_prettify(&buffer, "Initial commit", 0, '#'));
 
 	cl_git_pass(git_commit_create_v(
 		&commit_oid,
diff --git a/tests/object/message.c b/tests/object/message.c
index ab5565341..40d8e7297 100644
--- a/tests/object/message.c
+++ b/tests/object/message.c
@@ -6,7 +6,7 @@ static void assert_message_prettifying(char *expected_output, char *input, int s
 {
 	git_buf prettified_message = GIT_BUF_INIT;
 
-	git_message_prettify(&prettified_message, input, strip_comments);
+	git_message_prettify(&prettified_message, input, strip_comments, '#');
 	cl_assert_equal_s(expected_output, git_buf_cstr(&prettified_message));
 
 	git_buf_free(&prettified_message);
@@ -175,25 +175,25 @@ void test_object_message__message_prettify(void)
 	git_buf buffer;
 
 	memset(&buffer, 0, sizeof(buffer));
-	cl_git_pass(git_message_prettify(&buffer, "", 0));
+	cl_git_pass(git_message_prettify(&buffer, "", 0, '#'));
 	cl_assert_equal_s(buffer.ptr, "");
 	git_buf_free(&buffer);
-	cl_git_pass(git_message_prettify(&buffer, "", 1));
+	cl_git_pass(git_message_prettify(&buffer, "", 1, '#'));
 	cl_assert_equal_s(buffer.ptr, "");
 	git_buf_free(&buffer);
 
-	cl_git_pass(git_message_prettify(&buffer, "Short", 0));
+	cl_git_pass(git_message_prettify(&buffer, "Short", 0, '#'));
 	cl_assert_equal_s("Short\n", buffer.ptr);
 	git_buf_free(&buffer);
-	cl_git_pass(git_message_prettify(&buffer, "Short", 1));
+	cl_git_pass(git_message_prettify(&buffer, "Short", 1, '#'));
 	cl_assert_equal_s("Short\n", buffer.ptr);
 	git_buf_free(&buffer);
 
-	cl_git_pass(git_message_prettify(&buffer, "This is longer\nAnd multiline\n# with some comments still in\n", 0));
+	cl_git_pass(git_message_prettify(&buffer, "This is longer\nAnd multiline\n# with some comments still in\n", 0, '#'));
 	cl_assert_equal_s(buffer.ptr, "This is longer\nAnd multiline\n# with some comments still in\n");
 	git_buf_free(&buffer);
 
-	cl_git_pass(git_message_prettify(&buffer, "This is longer\nAnd multiline\n# with some comments still in\n", 1));
+	cl_git_pass(git_message_prettify(&buffer, "This is longer\nAnd multiline\n# with some comments still in\n", 1, '#'));
 	cl_assert_equal_s(buffer.ptr, "This is longer\nAnd multiline\n");
 	git_buf_free(&buffer);
 }
-- 
cgit v1.2.3


From 9c4feef9f8e4c3b57d164f62b1e5666e87c1d8f2 Mon Sep 17 00:00:00 2001
From: Albert Meltzer <kitbellew@users.noreply.github.com>
Date: Sat, 17 May 2014 12:44:21 -0700
Subject: Fix warning on uninitialized variable.

---
 src/indexer.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/indexer.c b/src/indexer.c
index ebfdffb47..25c3d0537 100644
--- a/src/indexer.c
+++ b/src/indexer.c
@@ -110,7 +110,7 @@ int git_indexer_new(
 	git_indexer *idx;
 	git_buf path = GIT_BUF_INIT, tmp_path = GIT_BUF_INIT;
 	static const char suff[] = "/pack";
-	int error, fd;
+	int error, fd = -1;
 
 	idx = git__calloc(1, sizeof(git_indexer));
 	GITERR_CHECK_ALLOC(idx);
-- 
cgit v1.2.3


From b2067248632e8bf88f8be40a18079fab95b68f29 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 15 May 2014 09:03:30 +0200
Subject: clone: add failing test for a mirror-clone with clone_into

Show a failure to perform a mirror-clone from a repository, both local
and remote.
---
 tests/network/fetchlocal.c | 26 ++++++++++++++++++++++++++
 tests/online/clone.c       | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 59 insertions(+)

diff --git a/tests/network/fetchlocal.c b/tests/network/fetchlocal.c
index 4c39394bb..0d23bef48 100644
--- a/tests/network/fetchlocal.c
+++ b/tests/network/fetchlocal.c
@@ -86,3 +86,29 @@ void test_network_fetchlocal__partial(void)
 	git_strarray_free(&refnames);
 	git_remote_free(origin);
 }
+
+void test_network_fetchlocal__clone_into_mirror(void)
+{
+	git_buf path = GIT_BUF_INIT;
+	git_repository *repo;
+	git_remote *remote;
+	git_reference *head;
+
+	cl_git_pass(git_repository_init(&repo, "./foo.git", true));
+	cl_git_pass(git_remote_create(&remote, repo, "origin", cl_git_fixture_url("testrepo.git")));
+
+	git_remote_clear_refspecs(remote);
+	cl_git_pass(git_remote_add_fetch(remote, "+refs/*:refs/*"));
+
+	cl_git_pass(git_clone_into(repo, remote, NULL, NULL, NULL));
+
+	cl_git_pass(git_reference_lookup(&head, repo, "HEAD"));
+	cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head));
+	cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head));
+
+	git_remote_free(remote);
+	git_reference_free(head);
+	git_repository_free(repo);
+	git_buf_free(&path);
+	cl_fixture_cleanup("./foo.git");
+}
diff --git a/tests/online/clone.c b/tests/online/clone.c
index 6e0e63950..e269771c0 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -164,6 +164,39 @@ void test_online_clone__clone_into(void)
 	git_buf_free(&path);
 }
 
+void test_online_clone__clone_mirror(void)
+{
+	git_buf path = GIT_BUF_INIT;
+	git_remote *remote;
+	git_reference *head;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+
+	bool fetch_progress_cb_was_called = false;
+
+	cl_git_pass(git_repository_init(&g_repo, "./foo.git", true));
+	cl_git_pass(git_remote_create(&remote, g_repo, "origin", LIVE_REPO_URL));
+
+	callbacks.transfer_progress = &fetch_progress;
+	callbacks.payload = &fetch_progress_cb_was_called;
+	git_remote_set_callbacks(remote, &callbacks);
+
+	git_remote_clear_refspecs(remote);
+	cl_git_pass(git_remote_add_fetch(remote, "+refs/*:refs/*"));
+
+	cl_git_pass(git_clone_into(g_repo, remote, NULL, NULL, NULL));
+
+	cl_git_pass(git_reference_lookup(&head, g_repo, "HEAD"));
+	cl_assert_equal_i(GIT_REF_SYMBOLIC, git_reference_type(head));
+	cl_assert_equal_s("refs/heads/master", git_reference_symbolic_target(head));
+
+	cl_assert_equal_i(true, fetch_progress_cb_was_called);
+
+	git_remote_free(remote);
+	git_reference_free(head);
+	git_buf_free(&path);
+	cl_fixture_cleanup("./foo.git");
+}
+
 static int update_tips(const char *refname, const git_oid *a, const git_oid *b, void *payload)
 {
 	int *callcount = (int*)payload;
-- 
cgit v1.2.3


From 3c607685da2cf9a22559f53fd7670e1c4cad45e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 19 May 2014 13:36:00 +0200
Subject: clone: duplicate the remote

Instead of changing the user-provided remote, duplicate it so we can add
the extra refspec without having to worry about unsetting it before
returning.
---
 src/clone.c | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/src/clone.c b/src/clone.c
index c6be00f0e..c627edbc0 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -336,25 +336,30 @@ static bool should_checkout(
 	return !git_repository_head_unborn(repo);
 }
 
-int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
+int git_clone_into(git_repository *repo, git_remote *_remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
 {
 	int error = 0, old_fetchhead;
-	git_strarray refspecs;
 	git_buf reflog_message = GIT_BUF_INIT;
+	git_remote *remote;
+	const git_remote_callbacks *callbacks;
 
-	assert(repo && remote);
+	assert(repo && _remote);
 
 	if (!git_repository_is_empty(repo)) {
 		giterr_set(GITERR_INVALID, "the repository is not empty");
 		return -1;
 	}
 
-
-	if ((error = git_remote_get_fetch_refspecs(&refspecs, remote)) < 0)
+	if ((error = git_remote_dup(&remote, _remote)) < 0)
 		return error;
 
+	callbacks = git_remote_get_callbacks(_remote);
+	if (!giterr__check_version(callbacks, 1, "git_remote_callbacks") &&
+	    (error = git_remote_set_callbacks(remote, git_remote_get_callbacks(_remote))) < 0)
+		goto cleanup;
+
 	if ((error = git_remote_add_fetch(remote, "refs/tags/*:refs/tags/*")) < 0)
-		return error;
+		goto cleanup;
 
 	old_fetchhead = git_remote_update_fetchhead(remote);
 	git_remote_set_update_fetchhead(remote, 0);
@@ -375,15 +380,7 @@ int git_clone_into(git_repository *repo, git_remote *remote, const git_checkout_
 
 cleanup:
 	git_remote_set_update_fetchhead(remote, old_fetchhead);
-
-	/* Go back to the original refspecs */
-	{
-		int error_alt = git_remote_set_fetch_refspecs(remote, &refspecs);
-		if (!error)
-			error = error_alt;
-	}
-
-	git_strarray_free(&refspecs);
+	git_remote_free(remote);
 	git_buf_free(&reflog_message);
 
 	return error;
-- 
cgit v1.2.3


From 32332fccc9f1e316bcecf3ab5133331315e31871 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 19 May 2014 14:15:40 +0200
Subject: clone: don't error out if the branch already exists

We set up the current branch after we fetch from the remote. This means
that the user's refspec may have already created this reference. It is
therefore not an error if we cannot create the branch because it already
exists.

This allows for the user to replicate git-clone's --mirror option.
---
 src/clone.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/clone.c b/src/clone.c
index c627edbc0..24f1cae59 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -171,6 +171,10 @@ static int update_head_to_new_branch(
 
 	git_reference_free(tracking_branch);
 
+	/* if it already existed, then the user's refspec created it for us, ignore it' */
+	if (error == GIT_EEXISTS)
+		error = 0;
+
 	return error;
 }
 
-- 
cgit v1.2.3


From 213a269a50479e0a2d762ae4c9ad1a4e52e53331 Mon Sep 17 00:00:00 2001
From: Martin Woodward <martinwo@microsoft.com>
Date: Mon, 19 May 2014 14:39:45 +0100
Subject: Restore attributions for fnmatch

---
 src/fnmatch.c | 34 ++++++++++++++++++++++++++++++++++
 src/fnmatch.h | 27 ++++++++++++++++++++++++---
 2 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/src/fnmatch.c b/src/fnmatch.c
index d8a83a8ed..d7899e3e6 100644
--- a/src/fnmatch.c
+++ b/src/fnmatch.c
@@ -5,6 +5,40 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
+/*
+ * This file contains code originally derrived from OpenBSD fnmatch.c 
+ *
+ * Copyright (c) 1989, 1993, 1994
+ *      The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
 /*
  * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6.
  * Compares a filename or pathname to a pattern.
diff --git a/src/fnmatch.h b/src/fnmatch.h
index 920e7de4d..88af45939 100644
--- a/src/fnmatch.h
+++ b/src/fnmatch.h
@@ -1,8 +1,29 @@
 /*
- * Copyright (C) the libgit2 contributors. All rights reserved.
+ * Copyright (C) 2008 The Android Open Source Project
+ * All rights reserved.
  *
- * This file is part of libgit2, distributed under the GNU GPL v2 with
- * a Linking Exception. For full terms see the included COPYING file.
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
  */
 #ifndef INCLUDE_fnmatch__compat_h__
 #define INCLUDE_fnmatch__compat_h__
-- 
cgit v1.2.3


From 16798d08cf3a1757deb9f0363b35fbf775cfc3fb Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 19 May 2014 14:57:09 -0700
Subject: Make core.safecrlf work on LF-ending platforms

If you enabled core.safecrlf on an LF-ending platform, we would
error even for files with all LFs.  We should only be warning on
irreversible mappings, I think.
---
 src/crlf.c          |  4 +++-
 tests/filter/crlf.c |  6 +++---
 tests/index/crlf.c  | 18 ++++++++++++++++++
 3 files changed, 24 insertions(+), 4 deletions(-)

diff --git a/src/crlf.c b/src/crlf.c
index dad3ecebc..22cba84ab 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -139,7 +139,9 @@ static int crlf_apply_to_odb(
 			return GIT_PASSTHROUGH;
 
 		/* If safecrlf is enabled, sanity-check the result. */
-		if (stats.cr != stats.crlf || stats.lf != stats.crlf) {
+		if (stats.cr != stats.crlf ||
+			(stats.crlf > 0 && stats.lf != stats.crlf)) {
+
 			switch (ca->safe_crlf) {
 			case GIT_SAFE_CRLF_FAIL:
 				giterr_set(
diff --git a/tests/filter/crlf.c b/tests/filter/crlf.c
index 66c267e31..334b1e349 100644
--- a/tests/filter/crlf.c
+++ b/tests/filter/crlf.c
@@ -103,12 +103,12 @@ void test_filter_crlf__with_safecrlf(void)
 	cl_git_fail(git_filter_list_apply_to_data(&out, fl, &in));
 	cl_assert_equal_i(giterr_last()->klass, GITERR_FILTER);
 
-	/* Normalized \n fails with safecrlf */
+	/* Normalized \n is reversible, so does not fail with safecrlf */
 	in.ptr = "Normal\nLF\nonly\nline-endings.\n";
 	in.size = strlen(in.ptr);
 
-	cl_git_fail(git_filter_list_apply_to_data(&out, fl, &in));
-	cl_assert_equal_i(giterr_last()->klass, GITERR_FILTER);
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_s(in.ptr, out.ptr);
 
 	git_filter_list_free(fl);
 	git_buf_free(&out);
diff --git a/tests/index/crlf.c b/tests/index/crlf.c
index cf69c6226..7babd5939 100644
--- a/tests/index/crlf.c
+++ b/tests/index/crlf.c
@@ -134,3 +134,21 @@ void test_index_crlf__autocrlf_input_text_auto_attr(void)
 	cl_git_pass(git_oid_fromstr(&oid, FILE_OID_LF));
 	cl_assert(git_oid_cmp(&oid, &entry->id) == 0);
 }
+
+void test_index_crlf__safecrlf_true_no_attrs(void)
+{
+	cl_repo_set_bool(g_repo, "core.autocrlf", true);
+	cl_repo_set_bool(g_repo, "core.safecrlf", true);
+
+	cl_git_mkfile("crlf/newfile.txt", ALL_LF_TEXT_RAW);
+	cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
+
+	cl_git_mkfile("crlf/newfile.txt", ALL_CRLF_TEXT_RAW);
+	cl_git_pass(git_index_add_bypath(g_index, "newfile.txt"));
+
+	cl_git_mkfile("crlf/newfile.txt", MORE_CRLF_TEXT_RAW);
+	cl_git_fail(git_index_add_bypath(g_index, "newfile.txt"));
+
+	cl_git_mkfile("crlf/newfile.txt", MORE_LF_TEXT_RAW);
+	cl_git_fail(git_index_add_bypath(g_index, "newfile.txt"));
+}
-- 
cgit v1.2.3


From c094197bf92736bb1c40cf1ca87bda970ab7f999 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Mon, 19 May 2014 15:05:39 -0700
Subject: Just don't CRLF filter if there are no CRs

---
 src/crlf.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/crlf.c b/src/crlf.c
index 22cba84ab..821e04eb2 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -138,10 +138,12 @@ static int crlf_apply_to_odb(
 		if (git_buf_text_gather_stats(&stats, from, false))
 			return GIT_PASSTHROUGH;
 
-		/* If safecrlf is enabled, sanity-check the result. */
-		if (stats.cr != stats.crlf ||
-			(stats.crlf > 0 && stats.lf != stats.crlf)) {
+		/* If there are no CR characters to filter out, then just pass */
+		if (!stats.cr)
+			return GIT_PASSTHROUGH;
 
+		/* If safecrlf is enabled, sanity-check the result. */
+		if (stats.cr != stats.crlf || stats.lf != stats.crlf) {
 			switch (ca->safe_crlf) {
 			case GIT_SAFE_CRLF_FAIL:
 				giterr_set(
-- 
cgit v1.2.3


From ac11219b8014fec1c5a83f1b19cf78015adc856c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 19 May 2014 16:54:19 +0200
Subject: smart: send a flush when we disconnect

The git server wants to hear a flush from us when we disconnect,
particularly when we want to perform a fetch but are up to date.
---
 src/transports/smart.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/transports/smart.c b/src/transports/smart.c
index 69eaf9b78..7fb41f788 100644
--- a/src/transports/smart.c
+++ b/src/transports/smart.c
@@ -272,6 +272,18 @@ static int git_smart__close(git_transport *transport)
 	unsigned int i;
 	git_pkt *p;
 	int ret;
+	git_smart_subtransport_stream *stream;
+	const char flush[] = "0000";
+
+	/*
+	 * If we're still connected at this point and not using RPC,
+	 * we should say goodbye by sending a flush, or git-daemon
+	 * will complain that we disconnected unexpectedly.
+	 */
+	if (t->connected && !t->rpc &&
+	    !t->wrapped->action(&stream, t->wrapped, t->url, GIT_SERVICE_UPLOADPACK)) {
+		t->current_stream->write(t->current_stream, flush, 4);
+	}
 
 	ret = git_smart__reset_stream(t, true);
 
-- 
cgit v1.2.3


From 430866d28cca5e1c04ca5e65dc0f66ae00a2f288 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 20 May 2014 08:29:51 +0200
Subject: Fix a leak in the tests

---
 tests/odb/foreach.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/odb/foreach.c b/tests/odb/foreach.c
index ab3808b00..56daf7574 100644
--- a/tests/odb/foreach.c
+++ b/tests/odb/foreach.c
@@ -93,8 +93,8 @@ void test_odb_foreach__files_in_objects_dir(void)
 	cl_git_pass(git_repository_open(&repo, "testrepo.git"));
 
 	cl_git_pass(git_buf_printf(&buf, "%s/objects/somefile", git_repository_path(repo)));
-
 	cl_git_mkfile(buf.ptr, "");
+	git_buf_free(&buf);
 
 	cl_git_pass(git_repository_odb(&odb, repo));
 	cl_git_pass(git_odb_foreach(odb, foreach_cb, &nobj));
-- 
cgit v1.2.3


From 60cdf49583e235fd4441e7104a8b04d206824c7c Mon Sep 17 00:00:00 2001
From: Albert Meltzer <kitbellew@users.noreply.github.com>
Date: Mon, 19 May 2014 09:13:45 -0700
Subject: Minor fix for cmn/clone-into-mirror.

A recently added check might skip initialization of old_fetchhead and go
directly to cleanup. So, destruct in the opposite order of construction.
---
 src/clone.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/clone.c b/src/clone.c
index 24f1cae59..9ac9eb2a1 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -342,7 +342,7 @@ static bool should_checkout(
 
 int git_clone_into(git_repository *repo, git_remote *_remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
 {
-	int error = 0, old_fetchhead;
+	int error;
 	git_buf reflog_message = GIT_BUF_INIT;
 	git_remote *remote;
 	const git_remote_callbacks *callbacks;
@@ -359,13 +359,12 @@ int git_clone_into(git_repository *repo, git_remote *_remote, const git_checkout
 
 	callbacks = git_remote_get_callbacks(_remote);
 	if (!giterr__check_version(callbacks, 1, "git_remote_callbacks") &&
-	    (error = git_remote_set_callbacks(remote, git_remote_get_callbacks(_remote))) < 0)
+	    (error = git_remote_set_callbacks(remote, callbacks)) < 0)
 		goto cleanup;
 
 	if ((error = git_remote_add_fetch(remote, "refs/tags/*:refs/tags/*")) < 0)
 		goto cleanup;
 
-	old_fetchhead = git_remote_update_fetchhead(remote);
 	git_remote_set_update_fetchhead(remote, 0);
 	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
 
@@ -383,7 +382,6 @@ int git_clone_into(git_repository *repo, git_remote *_remote, const git_checkout
 		error = git_checkout_head(repo, co_opts);
 
 cleanup:
-	git_remote_set_update_fetchhead(remote, old_fetchhead);
 	git_remote_free(remote);
 	git_buf_free(&reflog_message);
 
-- 
cgit v1.2.3


From 8156835df17d89bd7ce1525792aa13146fab551e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 20 May 2014 09:29:39 +0200
Subject: smart: store reported symrefs

The protocol has a capability which allows the server to tell us which
refs are symrefs, so we can e.g. know which is the default branch.

This capability is different from the ones we already support, as it's
not setting a flag to true, but requires us to store a list of
refspec-formatted mappings.

This commit does not yet expose the information in the reference
listing.
---
 src/transports/smart.c          | 26 +++++++++++++++---
 src/transports/smart.h          |  5 ++--
 src/transports/smart_protocol.c | 58 +++++++++++++++++++++++++++++++++++++++--
 3 files changed, 82 insertions(+), 7 deletions(-)

diff --git a/src/transports/smart.c b/src/transports/smart.c
index 69eaf9b78..2f3e77726 100644
--- a/src/transports/smart.c
+++ b/src/transports/smart.c
@@ -7,6 +7,7 @@
 #include "git2.h"
 #include "smart.h"
 #include "refs.h"
+#include "refspec.h"
 
 static int git_smart__recv_cb(gitno_buffer *buf)
 {
@@ -63,7 +64,7 @@ static int git_smart__set_callbacks(
 	return 0;
 }
 
-int git_smart__update_heads(transport_smart *t)
+int git_smart__update_heads(transport_smart *t, git_vector *symrefs)
 {
 	size_t i;
 	git_pkt *pkt;
@@ -81,6 +82,19 @@ int git_smart__update_heads(transport_smart *t)
 	return 0;
 }
 
+static void free_symrefs(git_vector *symrefs)
+{
+	git_refspec *spec;
+	size_t i;
+
+	git_vector_foreach(symrefs, i, spec) {
+		git_refspec__free(spec);
+		git__free(spec);
+	}
+
+	git_vector_free(symrefs);
+}
+
 static int git_smart__connect(
 	git_transport *transport,
 	const char *url,
@@ -94,6 +108,7 @@ static int git_smart__connect(
 	int error;
 	git_pkt *pkt;
 	git_pkt_ref *first;
+	git_vector symrefs;
 	git_smart_service_t service;
 
 	if (git_smart__reset_stream(t, true) < 0)
@@ -147,8 +162,11 @@ static int git_smart__connect(
 
 	first = (git_pkt_ref *)git_vector_get(&t->refs, 0);
 
+	if ((error = git_vector_init(&symrefs, 1, NULL)) < 0)
+		return error;
+
 	/* Detect capabilities */
-	if (git_smart__detect_caps(first, &t->caps) < 0)
+	if (git_smart__detect_caps(first, &t->caps, &symrefs) < 0)
 		return -1;
 
 	/* If the only ref in the list is capabilities^{} with OID_ZERO, remove it */
@@ -159,7 +177,9 @@ static int git_smart__connect(
 	}
 
 	/* Keep a list of heads for _ls */
-	git_smart__update_heads(t);
+	git_smart__update_heads(t, &symrefs);
+
+	free_symrefs(&symrefs);
 
 	if (t->rpc && git_smart__reset_stream(t, false) < 0)
 		return -1;
diff --git a/src/transports/smart.h b/src/transports/smart.h
index a2b6b2a71..f1fc29520 100644
--- a/src/transports/smart.h
+++ b/src/transports/smart.h
@@ -23,6 +23,7 @@
 #define GIT_CAP_DELETE_REFS "delete-refs"
 #define GIT_CAP_REPORT_STATUS "report-status"
 #define GIT_CAP_THIN_PACK "thin-pack"
+#define GIT_CAP_SYMREF "symref"
 
 enum git_pkt_type {
 	GIT_PKT_CMD,
@@ -154,7 +155,7 @@ typedef struct {
 
 /* smart_protocol.c */
 int git_smart__store_refs(transport_smart *t, int flushes);
-int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps);
+int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vector *symrefs);
 int git_smart__push(git_transport *transport, git_push *push);
 
 int git_smart__negotiate_fetch(
@@ -174,7 +175,7 @@ int git_smart__download_pack(
 int git_smart__negotiation_step(git_transport *transport, void *data, size_t len);
 int git_smart__get_push_stream(transport_smart *t, git_smart_subtransport_stream **out);
 
-int git_smart__update_heads(transport_smart *t);
+int git_smart__update_heads(transport_smart *t, git_vector *symrefs);
 
 /* smart_pkt.c */
 int git_pkt_parse_line(git_pkt **head, const char *line, const char **out, size_t len);
diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index 5dd6bab24..bab0cf113 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -78,7 +78,52 @@ int git_smart__store_refs(transport_smart *t, int flushes)
 	return flush;
 }
 
-int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps)
+static int append_symref(const char **out, git_vector *symrefs, const char *ptr)
+{
+	int error;
+	const char *end;
+	git_buf buf = GIT_BUF_INIT;
+	git_refspec *mapping;
+
+	ptr += strlen(GIT_CAP_SYMREF);
+	if (*ptr != '=')
+		goto on_invalid;
+
+	ptr++;
+	if (!(end = strchr(ptr, ' ')) &&
+	    !(end = strchr(ptr, '\0')))
+		goto on_invalid;
+
+	if ((error = git_buf_put(&buf, ptr, end - ptr)) < 0)
+		return error;
+
+	/* symref mapping has refspec format */
+	mapping = git__malloc(sizeof(git_refspec));
+	GITERR_CHECK_ALLOC(mapping);
+
+	error = git_refspec__parse(mapping, git_buf_cstr(&buf), true);
+	git_buf_free(&buf);
+
+	/* if the error isn't OOM, then it's a parse error; let's use a nicer message */
+	if (error < 0) {
+		if (giterr_last()->klass != GITERR_NOMEMORY)
+			goto on_invalid;
+
+		return error;
+	}
+
+	if ((error = git_vector_insert(symrefs, mapping)) < 0)
+		return error;
+
+	*out = end;
+	return 0;
+
+on_invalid:
+	giterr_set(GITERR_NET, "remote sent invalid symref");
+	return -1;
+}
+
+int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps, git_vector *symrefs)
 {
 	const char *ptr;
 
@@ -141,6 +186,15 @@ int git_smart__detect_caps(git_pkt_ref *pkt, transport_smart_caps *caps)
 			continue;
 		}
 
+		if (!git__prefixcmp(ptr, GIT_CAP_SYMREF)) {
+			int error;
+
+			if ((error = append_symref(&ptr, symrefs, ptr)) < 0)
+				return error;
+
+			continue;
+		}
+
 		/* We don't know this capability, so skip it */
 		ptr = strchr(ptr, ' ');
 	}
@@ -969,7 +1023,7 @@ int git_smart__push(git_transport *transport, git_push *push)
 		if (error < 0)
 			goto done;
 
-		error = git_smart__update_heads(t);
+		error = git_smart__update_heads(t, NULL);
 	}
 
 done:
-- 
cgit v1.2.3


From 306475eb0173d7943a27afee6054af8d0f76bedd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 20 May 2014 09:55:26 +0200
Subject: remote: expose the remote's symref mappings

Add a symref_target field to git_remote_head to expose the symref
mappings to the user.
---
 include/git2/net.h         |  5 +++++
 src/transports/smart.c     | 19 +++++++++++++++++++
 src/transports/smart_pkt.c |  1 +
 tests/online/fetch.c       | 18 ++++++++++++++++++
 4 files changed, 43 insertions(+)

diff --git a/include/git2/net.h b/include/git2/net.h
index e70ba1f71..a727696a2 100644
--- a/include/git2/net.h
+++ b/include/git2/net.h
@@ -41,6 +41,11 @@ struct git_remote_head {
 	git_oid oid;
 	git_oid loid;
 	char *name;
+	/**
+	 * If the server send a symref mapping for this ref, this will
+	 * point to the target.
+	 */
+	char *symref_target;
 };
 
 /**
diff --git a/src/transports/smart.c b/src/transports/smart.c
index 2f3e77726..47ef5038c 100644
--- a/src/transports/smart.c
+++ b/src/transports/smart.c
@@ -75,6 +75,25 @@ int git_smart__update_heads(transport_smart *t, git_vector *symrefs)
 		if (pkt->type != GIT_PKT_REF)
 			continue;
 
+		if (symrefs) {
+			git_refspec *spec;
+			git_buf buf = GIT_BUF_INIT;
+			size_t j;
+			int error;
+
+			git_vector_foreach(symrefs, j, spec) {
+				git_buf_clear(&buf);
+				if (git_refspec_src_matches(spec, ref->head.name) &&
+				    !(error = git_refspec_transform(&buf, spec, ref->head.name)))
+					ref->head.symref_target = git_buf_detach(&buf);
+			}
+
+			git_buf_free(&buf);
+
+			if (error < 0)
+				return error;
+		}
+
 		if (git_vector_insert(&t->heads, &ref->head) < 0)
 			return -1;
 	}
diff --git a/src/transports/smart_pkt.c b/src/transports/smart_pkt.c
index e9376ae6f..b5f9d6dbe 100644
--- a/src/transports/smart_pkt.c
+++ b/src/transports/smart_pkt.c
@@ -433,6 +433,7 @@ void git_pkt_free(git_pkt *pkt)
 	if (pkt->type == GIT_PKT_REF) {
 		git_pkt_ref *p = (git_pkt_ref *) pkt;
 		git__free(p->head.name);
+		git__free(p->head.symref_target);
 	}
 
 	if (pkt->type == GIT_PKT_OK) {
diff --git a/tests/online/fetch.c b/tests/online/fetch.c
index c54ec5673..f03a6faa6 100644
--- a/tests/online/fetch.c
+++ b/tests/online/fetch.c
@@ -184,3 +184,21 @@ void test_online_fetch__ls_disconnected(void)
 
 	git_remote_free(remote);
 }
+
+void test_online_fetch__remote_symrefs(void)
+{
+	const git_remote_head **refs;
+	size_t refs_len;
+	git_remote *remote;
+
+	cl_git_pass(git_remote_create(&remote, _repo, "test",
+				"http://github.com/libgit2/TestGitRepository.git"));
+	cl_git_pass(git_remote_connect(remote, GIT_DIRECTION_FETCH));
+	git_remote_disconnect(remote);
+	cl_git_pass(git_remote_ls(&refs, &refs_len, remote));
+
+	cl_assert_equal_s("HEAD", refs[0]->name);
+	cl_assert_equal_s("refs/heads/master", refs[0]->symref_target);
+
+	git_remote_free(remote);
+}
-- 
cgit v1.2.3


From 04865aa05e9d16ad56920103678ee4c34578da78 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 21 May 2014 10:01:44 +0200
Subject: local transport: expose the symref data

When using the local transport, we always have the symbolic information
available, so fill it.
---
 src/transports/local.c | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/transports/local.c b/src/transports/local.c
index 2c17e6271..8d3619388 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -43,14 +43,19 @@ typedef struct {
 static int add_ref(transport_local *t, const char *name)
 {
 	const char peeled[] = "^{}";
-	git_oid head_oid;
+	git_reference *ref, *resolved;
 	git_remote_head *head;
+	git_oid obj_id;
 	git_object *obj = NULL, *target = NULL;
 	git_buf buf = GIT_BUF_INIT;
 	int error;
 
-	error = git_reference_name_to_id(&head_oid, t->repo, name);
+	if ((error = git_reference_lookup(&ref, t->repo, name)) < 0)
+		return error;
+
+	error = git_reference_resolve(&resolved, ref);
 	if (error < 0) {
+		git_reference_free(ref);
 		if (!strcmp(name, GIT_HEAD_FILE) && error == GIT_ENOTFOUND) {
 			/* This is actually okay.  Empty repos often have a HEAD that
 			 * points to a nonexistent "refs/heads/master". */
@@ -60,13 +65,22 @@ static int add_ref(transport_local *t, const char *name)
 		return error;
 	}
 
+	git_oid_cpy(&obj_id, git_reference_target(resolved));
+	git_reference_free(resolved);
+
 	head = git__calloc(1, sizeof(git_remote_head));
 	GITERR_CHECK_ALLOC(head);
 
 	head->name = git__strdup(name);
 	GITERR_CHECK_ALLOC(head->name);
 
-	git_oid_cpy(&head->oid, &head_oid);
+	git_oid_cpy(&head->oid, &obj_id);
+
+	if (git_reference_type(ref) == GIT_REF_SYMBOLIC) {
+		head->symref_target = git__strdup(git_reference_symbolic_target(ref));
+		GITERR_CHECK_ALLOC(head->symref_target);
+	}
+	git_reference_free(ref);
 
 	if ((error = git_vector_insert(&t->refs, head)) < 0) {
 		git__free(head->name);
@@ -176,7 +190,7 @@ static int path_from_url_or_path(git_buf *local_path_out, const char *url_or_pat
 
 /*
  * Try to open the url as a git directory. The direction doesn't
- * matter in this case because we're calulating the heads ourselves.
+ * matter in this case because we're calculating the heads ourselves.
  */
 static int local_connect(
 	git_transport *transport,
-- 
cgit v1.2.3


From d22db24fb75134f30c3a72af0bc47fc7f0a07f33 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 21 May 2014 09:32:35 +0200
Subject: remote: add api to guess the remote's default branch

If the remote supports the symref protocol extension, then we return
that, otherwise we guess with git's rules.
---
 include/git2/remote.h                | 18 +++++++++++++
 src/remote.c                         | 47 +++++++++++++++++++++++++++++++++
 tests/network/remote/defaultbranch.c | 50 ++++++++++++++++++++++++++++++++++++
 3 files changed, 115 insertions(+)
 create mode 100644 tests/network/remote/defaultbranch.c

diff --git a/include/git2/remote.h b/include/git2/remote.h
index 07cd2e7c6..28771ac42 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -623,6 +623,24 @@ GIT_EXTERN(int) git_remote_is_valid_name(const char *remote_name);
 */
 GIT_EXTERN(int) git_remote_delete(git_remote *remote);
 
+/**
+ * Retrieve the name of the remote's default branch
+ *
+ * The default branch of a repository is the branch which HEAD points
+ * to. If the remote does not support reporting this information
+ * directly, it performs the guess as git does; that is, if there are
+ * multiple branches which point to the same commit, the first one is
+ * chosen. If the master branch is a candidate, it wins.
+ *
+ * This function must only be called after connecting.
+ *
+ * @param out the buffern in which to store the reference name
+ * @param remote the remote
+ * @return 0, GIT_ENOTFOUND if the remote does not have any references
+ * or none of them point to HEAD's commit, or an error message.
+ */
+GIT_EXTERN(int) git_remote_default_branch(git_buf *out, git_remote *remote);
+
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/src/remote.c b/src/remote.c
index bdc4791a9..f2e2e2f7a 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1885,3 +1885,50 @@ int git_remote_delete(git_remote *remote)
 
 	return 0;
 }
+
+int git_remote_default_branch(git_buf *out, git_remote *remote)
+{
+	const git_remote_head **heads;
+	const git_remote_head *guess = NULL;
+	const git_oid *head_id;
+	size_t heads_len, i;
+	int error;
+
+	if ((error = git_remote_ls(&heads, &heads_len, remote)) < 0)
+		return error;
+
+	if (heads_len == 0)
+		return GIT_ENOTFOUND;
+
+	git_buf_sanitize(out);
+	/* the first one must be HEAD so if that has the symref info, we're done */
+	if (heads[0]->symref_target)
+		return git_buf_puts(out, heads[0]->symref_target);
+
+	/*
+	 * If there's no symref information, we have to look over them
+	 * and guess. We return the first match unless the master
+	 * branch is a candidate. Then we return the master branch.
+	 */
+	head_id = &heads[0]->oid;
+
+	for (i = 1; i < heads_len; i++) {
+		if (git_oid_cmp(head_id, &heads[i]->oid))
+			continue;
+
+		if (!guess) {
+			guess = heads[i];
+			continue;
+		}
+
+		if (!git__strcmp(GIT_REFS_HEADS_MASTER_FILE, heads[i]->name)) {
+			guess = heads[i];
+			break;
+		}
+	}
+
+	if (!guess)
+		return GIT_ENOTFOUND;
+
+	return git_buf_puts(out, guess->name);
+}
diff --git a/tests/network/remote/defaultbranch.c b/tests/network/remote/defaultbranch.c
new file mode 100644
index 000000000..fa3a329db
--- /dev/null
+++ b/tests/network/remote/defaultbranch.c
@@ -0,0 +1,50 @@
+#include "clar_libgit2.h"
+#include "buffer.h"
+#include "refspec.h"
+#include "remote.h"
+
+static git_remote *g_remote;
+static git_repository *g_repo_a, *g_repo_b;
+
+void test_network_remote_defaultbranch__initialize(void)
+{
+	g_repo_a = cl_git_sandbox_init("testrepo.git");
+	cl_git_pass(git_repository_init(&g_repo_b, "repo-b.git", true));
+	cl_git_pass(git_remote_create(&g_remote, g_repo_b, "origin", git_repository_path(g_repo_a)));
+}
+
+void test_network_remote_defaultbranch__cleanup(void)
+{
+	git_remote_free(g_remote);
+	git_repository_free(g_repo_b);
+
+	cl_git_sandbox_cleanup();
+	cl_fixture_cleanup("repo-b.git");
+}
+
+static void assert_default_branch(const char *should)
+{
+	git_buf name = GIT_BUF_INIT;
+
+	cl_git_pass(git_remote_connect(g_remote, GIT_DIRECTION_FETCH));
+	cl_git_pass(git_remote_default_branch(&name, g_remote));
+	cl_assert_equal_s(should, name.ptr);
+	git_buf_free(&name);
+}
+
+void test_network_remote_defaultbranch__master(void)
+{
+	assert_default_branch("refs/heads/master");
+}
+
+void test_network_remote_defaultbranch__master_does_not_win(void)
+{
+	cl_git_pass(git_repository_set_head(g_repo_a, "refs/heads/not-good", NULL, NULL));
+	assert_default_branch("refs/heads/not-good");
+}
+
+void test_network_remote_defaultbranch__master_on_detached(void)
+{
+	cl_git_pass(git_repository_detach_head(g_repo_a, NULL, NULL));
+	assert_default_branch("refs/heads/master");
+}
-- 
cgit v1.2.3


From cdb8a608249b3d0b9e8fe1b3ea1e9c1aa731ab8b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 21 May 2014 11:51:33 +0200
Subject: clone: make use of the remote's default branch guessing

Let's use the remote's default branch guessing instead of reinventing
one ourselves with callbacks.
---
 src/clone.c | 84 +++++++++++++------------------------------------------------
 1 file changed, 17 insertions(+), 67 deletions(-)

diff --git a/src/clone.c b/src/clone.c
index 9ac9eb2a1..b6a0f03d0 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -108,51 +108,10 @@ static int create_tracking_branch(
 struct head_info {
 	git_repository *repo;
 	git_oid remote_head_oid;
-	git_buf branchname;
 	const git_refspec *refspec;
 	bool found;
 };
 
-static int reference_matches_remote_head(
-	const char *reference_name,
-	void *payload)
-{
-	struct head_info *head_info = (struct head_info *)payload;
-	git_oid oid;
-	int error;
-
-	/* TODO: Should we guard against references
-	 * which name doesn't start with refs/heads/ ?
-	 */
-
-	error = git_reference_name_to_id(&oid, head_info->repo, reference_name);
-	if (error == GIT_ENOTFOUND) {
-		/* If the reference doesn't exists, it obviously cannot match the
-		 * expected oid. */
-		giterr_clear();
-		return 0;
-	}
-
-	if (!error && !git_oid__cmp(&head_info->remote_head_oid, &oid)) {
-		/* Determine the local reference name from the remote tracking one */
-		error = git_refspec_rtransform(
-			&head_info->branchname, head_info->refspec, reference_name);
-
-		if (!error &&
-			git_buf_len(&head_info->branchname) > 0 &&
-			!(error = git_buf_sets(
-				&head_info->branchname,
-				git_buf_cstr(&head_info->branchname) +
-				strlen(GIT_REFS_HEADS_DIR))))
-		{
-			head_info->found = true;
-			error = GIT_ITEROVER;
-		}
-	}
-
-	return error;
-}
-
 static int update_head_to_new_branch(
 	git_repository *repo,
 	const git_oid *target,
@@ -161,6 +120,10 @@ static int update_head_to_new_branch(
 	const char *reflog_message)
 {
 	git_reference *tracking_branch = NULL;
+
+	if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR))
+		name += strlen(GIT_REFS_HEADS_DIR);
+
 	int error = create_tracking_branch(&tracking_branch, repo, target, name,
 			signature, reflog_message);
 
@@ -190,6 +153,7 @@ static int update_head_to_remote(
 	const git_remote_head *remote_head, **refs;
 	struct head_info head_info;
 	git_buf remote_master_name = GIT_BUF_INIT;
+	git_buf branch = GIT_BUF_INIT;
 
 	if ((error = git_remote_ls(&refs, &refs_len, remote)) < 0)
 		return error;
@@ -199,15 +163,22 @@ static int update_head_to_remote(
 		return setup_tracking_config(
 			repo, "master", GIT_REMOTE_ORIGIN, GIT_REFS_HEADS_MASTER_FILE);
 
+	memset(&head_info, 0, sizeof(head_info));
+	error = git_remote_default_branch(&branch, remote);
+	if (error == GIT_ENOTFOUND) {
+		git_buf_puts(&branch, GIT_REFS_HEADS_MASTER_FILE);
+	} else {
+		head_info.found = 1;
+	}
+
 	/* Get the remote's HEAD. This is always the first ref in the list. */
 	remote_head = refs[0];
 	assert(remote_head);
 
-	memset(&head_info, 0, sizeof(head_info));
 	git_oid_cpy(&head_info.remote_head_oid, &remote_head->oid);
 	head_info.repo = repo;
 	head_info.refspec =
-		git_remote__matching_refspec(remote, GIT_REFS_HEADS_MASTER_FILE);
+		git_remote__matching_refspec(remote, git_buf_cstr(&branch));
 
 	if (head_info.refspec == NULL) {
 		memset(&dummy_spec, 0, sizeof(git_refspec));
@@ -218,35 +189,14 @@ static int update_head_to_remote(
 	if ((error = git_refspec_transform(
 		&remote_master_name,
 		head_info.refspec,
-		GIT_REFS_HEADS_MASTER_FILE)) < 0)
+		git_buf_cstr(&branch))) < 0)
 		return error;
 
-	/* Check to see if the remote HEAD points to the remote master */
-	error = reference_matches_remote_head(
-		git_buf_cstr(&remote_master_name), &head_info);
-	if (error < 0 && error != GIT_ITEROVER)
-		goto cleanup;
-
-	if (head_info.found) {
-		error = update_head_to_new_branch(
-			repo,
-			&head_info.remote_head_oid,
-			git_buf_cstr(&head_info.branchname),
-			signature, reflog_message);
-		goto cleanup;
-	}
-
-	/* Not master. Check all the other refs. */
-	error = git_reference_foreach_name(
-		repo, reference_matches_remote_head, &head_info);
-	if (error < 0 && error != GIT_ITEROVER)
-		goto cleanup;
-
 	if (head_info.found) {
 		error = update_head_to_new_branch(
 			repo,
 			&head_info.remote_head_oid,
-			git_buf_cstr(&head_info.branchname),
+			git_buf_cstr(&branch),
 			signature, reflog_message);
 	} else {
 		error = git_repository_set_head_detached(
@@ -255,7 +205,7 @@ static int update_head_to_remote(
 
 cleanup:
 	git_buf_free(&remote_master_name);
-	git_buf_free(&head_info.branchname);
+	git_buf_free(&branch);
 	return error;
 }
 
-- 
cgit v1.2.3


From 2a597116583696486141261a8b459319b513facf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 21 May 2014 11:54:10 +0200
Subject: clone: get rid of head_info

Since we no longer need to push data to callbacks, there's no need for
this truct.
---
 src/clone.c | 35 ++++++++++++-----------------------
 1 file changed, 12 insertions(+), 23 deletions(-)

diff --git a/src/clone.c b/src/clone.c
index b6a0f03d0..f19771c1e 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -105,13 +105,6 @@ static int create_tracking_branch(
 		git_reference_name(*branch));
 }
 
-struct head_info {
-	git_repository *repo;
-	git_oid remote_head_oid;
-	const git_refspec *refspec;
-	bool found;
-};
-
 static int update_head_to_new_branch(
 	git_repository *repo,
 	const git_oid *target,
@@ -147,11 +140,11 @@ static int update_head_to_remote(
 		const git_signature *signature,
 		const char *reflog_message)
 {
-	int error = 0;
+	int error = 0, found_branch = 0;
 	size_t refs_len;
-	git_refspec dummy_spec;
+	git_refspec dummy_spec, *refspec;
 	const git_remote_head *remote_head, **refs;
-	struct head_info head_info;
+	const git_oid *remote_head_id;
 	git_buf remote_master_name = GIT_BUF_INIT;
 	git_buf branch = GIT_BUF_INIT;
 
@@ -163,47 +156,43 @@ static int update_head_to_remote(
 		return setup_tracking_config(
 			repo, "master", GIT_REMOTE_ORIGIN, GIT_REFS_HEADS_MASTER_FILE);
 
-	memset(&head_info, 0, sizeof(head_info));
 	error = git_remote_default_branch(&branch, remote);
 	if (error == GIT_ENOTFOUND) {
 		git_buf_puts(&branch, GIT_REFS_HEADS_MASTER_FILE);
 	} else {
-		head_info.found = 1;
+		found_branch = 1;
 	}
 
 	/* Get the remote's HEAD. This is always the first ref in the list. */
 	remote_head = refs[0];
 	assert(remote_head);
 
-	git_oid_cpy(&head_info.remote_head_oid, &remote_head->oid);
-	head_info.repo = repo;
-	head_info.refspec =
-		git_remote__matching_refspec(remote, git_buf_cstr(&branch));
+	remote_head_id = &remote_head->oid;
+	refspec = git_remote__matching_refspec(remote, git_buf_cstr(&branch));
 
-	if (head_info.refspec == NULL) {
+	if (refspec == NULL) {
 		memset(&dummy_spec, 0, sizeof(git_refspec));
-		head_info.refspec = &dummy_spec;
+		refspec = &dummy_spec;
 	}
 
 	/* Determine the remote tracking reference name from the local master */
 	if ((error = git_refspec_transform(
 		&remote_master_name,
-		head_info.refspec,
+		refspec,
 		git_buf_cstr(&branch))) < 0)
 		return error;
 
-	if (head_info.found) {
+	if (found_branch) {
 		error = update_head_to_new_branch(
 			repo,
-			&head_info.remote_head_oid,
+			remote_head_id,
 			git_buf_cstr(&branch),
 			signature, reflog_message);
 	} else {
 		error = git_repository_set_head_detached(
-			repo, &head_info.remote_head_oid, signature, reflog_message);
+			repo, remote_head_id, signature, reflog_message);
 	}
 
-cleanup:
 	git_buf_free(&remote_master_name);
 	git_buf_free(&branch);
 	return error;
-- 
cgit v1.2.3


From 7230330740eff79dc910d2a20418545bdcf2f65c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 21 May 2014 12:45:22 +0200
Subject: travis: build on osx too

---
 .travis.yml                  | 16 ++++++++++++----
 script/install-deps-linux.sh |  6 ++++++
 script/install-deps-osx.sh   |  5 +++++
 3 files changed, 23 insertions(+), 4 deletions(-)
 create mode 100755 script/install-deps-linux.sh
 create mode 100755 script/install-deps-osx.sh

diff --git a/.travis.yml b/.travis.yml
index fcae726dd..bab02bb44 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,6 +3,10 @@
 
 language: c
 
+os:
+  - linux
+  - osx
+
 compiler:
   - gcc
   - clang
@@ -17,17 +21,21 @@ env:
 
 matrix:
  fast_finish: true
+ exclude:
+   - os: osx
+     compiler: gcc
  include:
    - compiler: i586-mingw32msvc-gcc
      env: OPTIONS="-DBUILD_CLAR=OFF -DWIN32=ON -DMINGW=ON -DUSE_SSH=OFF"
+     os: linux
    - compiler: gcc
      env: COVERITY=1
+     os: linux
  allow_failures:
    - env: COVERITY=1
 
 install:
- - sudo apt-get -qq update
- - sudo apt-get -qq install cmake libssh2-1-dev openssh-client openssh-server
+  - ./script/install-deps-${TRAVIS_OS_NAME}.sh
 
 # Run the Build script and tests
 script:
@@ -35,8 +43,8 @@ script:
 
 # Run Tests
 after_success:
- - sudo apt-get -qq install valgrind
- - valgrind --leak-check=full --show-reachable=yes --suppressions=./libgit2_clar.supp _build/libgit2_clar -ionline
+ - if [ "$TRAVIS_OS_NAME" = "linux" ]; then sudo apt-get -qq install valgrind; fi
+ - if [ "$TRAVIS_OS_NAME" = "linux" ]; then valgrind --leak-check=full --show-reachable=yes --suppressions=./libgit2_clar.supp _build/libgit2_clar -ionline; fi
 
 # Only watch the development branch
 branches:
diff --git a/script/install-deps-linux.sh b/script/install-deps-linux.sh
new file mode 100755
index 000000000..347922b89
--- /dev/null
+++ b/script/install-deps-linux.sh
@@ -0,0 +1,6 @@
+#!/bin/sh
+
+set -x
+
+sudo apt-get -qq update &&
+sudo apt-get -qq install cmake libssh2-1-dev openssh-client openssh-server
diff --git a/script/install-deps-osx.sh b/script/install-deps-osx.sh
new file mode 100755
index 000000000..c2e0162d8
--- /dev/null
+++ b/script/install-deps-osx.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+set -x
+
+brew install libssh2 cmake
-- 
cgit v1.2.3


From ead9c591ef6cbad37198421637ae31eec5ab4472 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 21 May 2014 17:25:00 -0700
Subject: Include windows.h on win32 for Sleep

---
 examples/status.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/examples/status.c b/examples/status.c
index 9c99744cb..a59f34454 100644
--- a/examples/status.c
+++ b/examples/status.c
@@ -14,9 +14,10 @@
 
 #include "common.h"
 #ifdef _WIN32
-#define sleep(a) Sleep(a * 1000)
+# include <Windows.h>
+# define sleep(a) Sleep(a * 1000)
 #else
-#include <unistd.h>
+# include <unistd.h>
 #endif
 
 /**
-- 
cgit v1.2.3


From 4c4408c351650dac84c81a67a321a4d92cc85ffa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 22 May 2014 12:28:39 +0200
Subject: Plug leaks and fix a C99-ism

We have too many places where we repeat free code, so when adding the
new free to the generic code, it didn't take for the local transport.

While there, fix a C99-ism that sneaked through.
---
 src/clone.c                     |  3 ++-
 src/transports/local.c          | 19 +++++++++++--------
 src/transports/smart_protocol.c |  7 +++----
 3 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/src/clone.c b/src/clone.c
index f19771c1e..8381ec63c 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -113,11 +113,12 @@ static int update_head_to_new_branch(
 	const char *reflog_message)
 {
 	git_reference *tracking_branch = NULL;
+	int error;
 
 	if (!git__prefixcmp(name, GIT_REFS_HEADS_DIR))
 		name += strlen(GIT_REFS_HEADS_DIR);
 
-	int error = create_tracking_branch(&tracking_branch, repo, target, name,
+	error = create_tracking_branch(&tracking_branch, repo, target, name,
 			signature, reflog_message);
 
 	if (!error)
diff --git a/src/transports/local.c b/src/transports/local.c
index 8d3619388..038337d72 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -40,6 +40,13 @@ typedef struct {
 		have_refs : 1;
 } transport_local;
 
+static void free_head(git_remote_head *head)
+{
+	git__free(head->name);
+	git__free(head->symref_target);
+	git__free(head);
+}
+
 static int add_ref(transport_local *t, const char *name)
 {
 	const char peeled[] = "^{}";
@@ -83,8 +90,7 @@ static int add_ref(transport_local *t, const char *name)
 	git_reference_free(ref);
 
 	if ((error = git_vector_insert(&t->refs, head)) < 0) {
-		git__free(head->name);
-		git__free(head);
+		free_head(head);
 		return error;
 	}
 
@@ -117,8 +123,7 @@ static int add_ref(transport_local *t, const char *name)
 		git_oid_cpy(&head->oid, git_object_id(target));
 
 		if ((error = git_vector_insert(&t->refs, head)) < 0) {
-			git__free(head->name);
-			git__free(head);
+			free_head(head);
 		}
 	}
 
@@ -640,10 +645,8 @@ static void local_free(git_transport *transport)
 	size_t i;
 	git_remote_head *head;
 
-	git_vector_foreach(&t->refs, i, head) {
-		git__free(head->name);
-		git__free(head);
-	}
+	git_vector_foreach(&t->refs, i, head)
+		free_head(head);
 
 	git_vector_free(&t->refs);
 
diff --git a/src/transports/smart_protocol.c b/src/transports/smart_protocol.c
index bab0cf113..a52aacc60 100644
--- a/src/transports/smart_protocol.c
+++ b/src/transports/smart_protocol.c
@@ -26,17 +26,16 @@ int git_smart__store_refs(transport_smart *t, int flushes)
 	int error, flush = 0, recvd;
 	const char *line_end = NULL;
 	git_pkt *pkt = NULL;
-	git_pkt_ref *ref;
 	size_t i;
 
 	/* Clear existing refs in case git_remote_connect() is called again
 	 * after git_remote_disconnect().
 	 */
-	git_vector_foreach(refs, i, ref) {
-		git__free(ref->head.name);
-		git__free(ref);
+	git_vector_foreach(refs, i, pkt) {
+		git_pkt_free(pkt);
 	}
 	git_vector_clear(refs);
+	pkt = NULL;
 
 	do {
 		if (buf->offset > 0)
-- 
cgit v1.2.3


From 9331f98acaffd377a8076ab111bed84ff89e8e72 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 22 May 2014 12:52:31 +0200
Subject: smart: initialize the error variable

---
 src/transports/smart.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/transports/smart.c b/src/transports/smart.c
index c9845bff9..a5c3e82dc 100644
--- a/src/transports/smart.c
+++ b/src/transports/smart.c
@@ -79,7 +79,7 @@ int git_smart__update_heads(transport_smart *t, git_vector *symrefs)
 			git_refspec *spec;
 			git_buf buf = GIT_BUF_INIT;
 			size_t j;
-			int error;
+			int error = 0;
 
 			git_vector_foreach(symrefs, j, spec) {
 				git_buf_clear(&buf);
-- 
cgit v1.2.3


From 052a2ffde4d8cf0d2b07c70956631d97875ad5ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 22 May 2014 16:01:02 +0200
Subject: index: check for valid filemodes on add

---
 src/index.c             | 14 ++++++++++++++
 tests/index/filemodes.c | 15 +++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/src/index.c b/src/index.c
index 8a7f29279..b63a0bec6 100644
--- a/src/index.c
+++ b/src/index.c
@@ -1104,6 +1104,15 @@ int git_index_remove_bypath(git_index *index, const char *path)
 	return 0;
 }
 
+static bool valid_filemode(const int filemode)
+{
+	return (filemode == GIT_FILEMODE_BLOB ||
+		filemode == GIT_FILEMODE_BLOB_EXECUTABLE ||
+		filemode == GIT_FILEMODE_LINK ||
+		filemode == GIT_FILEMODE_COMMIT);
+}
+
+
 int git_index_add(git_index *index, const git_index_entry *source_entry)
 {
 	git_index_entry *entry = NULL;
@@ -1111,6 +1120,11 @@ int git_index_add(git_index *index, const git_index_entry *source_entry)
 
 	assert(index && source_entry && source_entry->path);
 
+	if (!valid_filemode(source_entry->mode)) {
+		giterr_set(GITERR_INDEX, "invalid filemode");
+		return -1;
+	}
+
 	if ((ret = index_entry_dup(&entry, source_entry)) < 0 ||
 		(ret = index_insert(index, &entry, 1)) < 0)
 		return ret;
diff --git a/tests/index/filemodes.c b/tests/index/filemodes.c
index 013932696..e00b9c975 100644
--- a/tests/index/filemodes.c
+++ b/tests/index/filemodes.c
@@ -152,3 +152,18 @@ void test_index_filemodes__trusted(void)
 
 	git_index_free(index);
 }
+
+void test_index_filemodes__invalid(void)
+{
+	git_index *index;
+	git_index_entry entry;
+
+	cl_git_pass(git_repository_index(&index, g_repo));
+
+	entry.path = "foo";
+	entry.mode = GIT_OBJ_BLOB;
+	cl_git_fail(git_index_add(index, &entry));
+
+	entry.mode = GIT_FILEMODE_BLOB;
+	cl_git_pass(git_index_add(index, &entry));
+}
-- 
cgit v1.2.3


From 97fc71ab3b935df5f32faae13035e40eeb03c07f Mon Sep 17 00:00:00 2001
From: Eoin Coffey <ecoffey@gmail.com>
Date: Thu, 22 May 2014 16:01:45 -0600
Subject: Add support for --author flag in example log implementation

---
 examples/log.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/examples/log.c b/examples/log.c
index 471c5ff96..655b95d10 100644
--- a/examples/log.c
+++ b/examples/log.c
@@ -54,7 +54,7 @@ struct log_options {
 	int min_parents, max_parents;
 	git_time_t before;
 	git_time_t after;
-	char *author;
+	const char *author;
 	char *committer;
 };
 
@@ -75,6 +75,7 @@ int main(int argc, char *argv[])
 	git_oid oid;
 	git_commit *commit = NULL;
 	git_pathspec *ps = NULL;
+	const git_signature *sig;
 
 	git_threads_init();
 
@@ -128,6 +129,12 @@ int main(int argc, char *argv[])
 				continue;
 		}
 
+		if (opt.author != NULL) {
+			if ((sig = git_commit_author(commit)) == NULL ||
+				strstr(sig->name, opt.author) == NULL)
+				continue;
+		}
+
 		if (count++ < opt.skip)
 			continue;
 		if (opt.limit != -1 && printed++ >= opt.limit) {
@@ -401,6 +408,8 @@ static int parse_options(
 			set_sorting(s, GIT_SORT_TOPOLOGICAL);
 		else if (!strcmp(a, "--reverse"))
 			set_sorting(s, GIT_SORT_REVERSE);
+		else if (match_str_arg(&opt->author, &args, "--author"))
+			/** Found valid --author */;
 		else if (match_str_arg(&s->repodir, &args, "--git-dir"))
 			/** Found git-dir. */;
 		else if (match_int_arg(&opt->skip, &args, "--skip", 0))
-- 
cgit v1.2.3


From 530594c0aa04df31e3cef331f6dad8083f66f15d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 23 May 2014 05:53:41 +0200
Subject: odb: clear backend errors on successful read

We go through the different backends in order, so it's not an error if
at least one of the backends has the data we want.
---
 src/odb.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/odb.c b/src/odb.c
index 20a3f6c6e..a4fc02686 100644
--- a/src/odb.c
+++ b/src/odb.c
@@ -783,6 +783,7 @@ int git_odb_read(git_odb_object **out, git_odb *db, const git_oid *id)
 		return error;
 	}
 
+	giterr_clear();
 	if ((object = odb_object__alloc(id, &raw)) == NULL)
 		return -1;
 
-- 
cgit v1.2.3


From 31b0cb518f11d4ec8a95df54d077d51b05fa899c Mon Sep 17 00:00:00 2001
From: Michael Anderson <drmikeando@gmail.com>
Date: Thu, 22 May 2014 17:16:21 +0800
Subject: Fixed miscellaneous documentation errors.

---
 include/git2/cherrypick.h |  2 +-
 include/git2/errors.h     | 32 ++++++++++++++++----------------
 include/git2/merge.h      | 10 +++++-----
 include/git2/reflog.h     |  2 +-
 include/git2/refs.h       |  4 +---
 include/git2/repository.h |  2 +-
 include/git2/revert.h     |  7 +++----
 include/git2/signature.h  |  2 +-
 include/git2/submodule.h  |  2 +-
 include/git2/tree.h       |  2 +-
 10 files changed, 31 insertions(+), 34 deletions(-)

diff --git a/include/git2/cherrypick.h b/include/git2/cherrypick.h
index e998d325f..9eccb0af9 100644
--- a/include/git2/cherrypick.h
+++ b/include/git2/cherrypick.h
@@ -56,7 +56,7 @@ GIT_EXTERN(int) git_cherry_pick_init_options(
  * @param cherry_pick_commit the commit to cherry-pick
  * @param our_commit the commit to revert against (eg, HEAD)
  * @param mainline the parent of the revert commit, if it is a merge
- * @param merge_tree_opts the merge tree options (or null for defaults)
+ * @param merge_options the merge options (or null for defaults)
  * @return zero on success, -1 on failure.
  */
 GIT_EXTERN(int) git_cherry_pick_commit(
diff --git a/include/git2/errors.h b/include/git2/errors.h
index e22f0d86d..c914653fc 100644
--- a/include/git2/errors.h
+++ b/include/git2/errors.h
@@ -19,13 +19,13 @@ GIT_BEGIN_DECL
 
 /** Generic return codes */
 typedef enum {
-	GIT_OK         =  0,		/*< No error */
+	GIT_OK         =  0,		/**< No error */
 
-	GIT_ERROR      = -1,		/*< Generic error */
-	GIT_ENOTFOUND  = -3,		/*< Requested object could not be found */
-	GIT_EEXISTS    = -4,		/*< Object exists preventing operation */
-	GIT_EAMBIGUOUS = -5,		/*< More than one object matches */
-	GIT_EBUFS      = -6,		/*< Output buffer too short to hold data */
+	GIT_ERROR      = -1,		/**< Generic error */
+	GIT_ENOTFOUND  = -3,		/**< Requested object could not be found */
+	GIT_EEXISTS    = -4,		/**< Object exists preventing operation */
+	GIT_EAMBIGUOUS = -5,		/**< More than one object matches */
+	GIT_EBUFS      = -6,		/**< Output buffer too short to hold data */
 
 	/* GIT_EUSER is a special error that is never generated by libgit2
 	 * code.  You can return it from a callback (e.g to stop an iteration)
@@ -33,17 +33,17 @@ typedef enum {
 	 */
 	GIT_EUSER      = -7,
 
-	GIT_EBAREREPO       =  -8,	/*< Operation not allowed on bare repository */
-	GIT_EUNBORNBRANCH   =  -9,	/*< HEAD refers to branch with no commits */
-	GIT_EUNMERGED       = -10,	/*< Merge in progress prevented operation */
-	GIT_ENONFASTFORWARD = -11,	/*< Reference was not fast-forwardable */
-	GIT_EINVALIDSPEC    = -12,	/*< Name/ref spec was not in a valid format */
-	GIT_EMERGECONFLICT  = -13,	/*< Merge conflicts prevented operation */
-	GIT_ELOCKED         = -14,	/*< Lock file prevented operation */
-	GIT_EMODIFIED       = -15,	/*< Reference value does not match expected */
+	GIT_EBAREREPO       =  -8,	/**< Operation not allowed on bare repository */
+	GIT_EUNBORNBRANCH   =  -9,	/**< HEAD refers to branch with no commits */
+	GIT_EUNMERGED       = -10,	/**< Merge in progress prevented operation */
+	GIT_ENONFASTFORWARD = -11,	/**< Reference was not fast-forwardable */
+	GIT_EINVALIDSPEC    = -12,	/**< Name/ref spec was not in a valid format */
+	GIT_EMERGECONFLICT  = -13,	/**< Merge conflicts prevented operation */
+	GIT_ELOCKED         = -14,	/**< Lock file prevented operation */
+	GIT_EMODIFIED       = -15,	/**< Reference value does not match expected */
 
-	GIT_PASSTHROUGH     = -30,	/*< Internal only */
-	GIT_ITEROVER        = -31,	/*< Signals end of iteration with iterator */
+	GIT_PASSTHROUGH     = -30,	/**< Internal only */
+	GIT_ITEROVER        = -31,	/**< Signals end of iteration with iterator */
 } git_error_code;
 
 /**
diff --git a/include/git2/merge.h b/include/git2/merge.h
index abbc3a5bb..7915050b0 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -378,8 +378,8 @@ GIT_EXTERN(int) git_merge_head_from_id(
 /**
  * Gets the commit ID that the given `git_merge_head` refers to.
  *
- * @param id pointer to commit id to be filled in
  * @param head the given merge head
+ * @return commit id
  */
 GIT_EXTERN(const git_oid *) git_merge_head_id(
 	const git_merge_head *head);
@@ -424,8 +424,8 @@ GIT_EXTERN(int) git_merge_file(
  * @param out The git_merge_file_result to be filled in
  * @param repo The repository
  * @param ancestor The index entry for the ancestor file (stage level 1)
- * @param our_path The index entry for our file (stage level 2)
- * @param their_path The index entry for their file (stage level 3)
+ * @param ours The index entry for our file (stage level 2)
+ * @param theirs The index entry for their file (stage level 3)
  * @param opts The merge file options or NULL
  * @return 0 on success or error code
  */
@@ -497,8 +497,8 @@ GIT_EXTERN(int) git_merge_commits(
  * completes, resolve any conflicts and prepare a commit.
  *
  * @param repo the repository to merge
- * @param merge_heads the heads to merge into
- * @param merge_heads_len the number of heads to merge
+ * @param their_heads the heads to merge into
+ * @param their_heads_len the number of heads to merge
  * @param merge_opts merge options
  * @param checkout_opts checkout options
  * @return 0 on success or error code
diff --git a/include/git2/reflog.h b/include/git2/reflog.h
index df06e1b8e..ac42a231c 100644
--- a/include/git2/reflog.h
+++ b/include/git2/reflog.h
@@ -69,7 +69,7 @@ GIT_EXTERN(int) git_reflog_append(git_reflog *reflog, const git_oid *id, const g
  *
  * @param repo the repository
  * @param old_name the old name of the reference
- * @param new_name the new name of the reference
+ * @param name the new name of the reference
  * @return 0 on success, GIT_EINVALIDSPEC or an error code
  */
 GIT_EXTERN(int) git_reflog_rename(git_repository *repo, const char *old_name, const char *name);
diff --git a/include/git2/refs.h b/include/git2/refs.h
index ae2d379d9..e5bb15c7c 100644
--- a/include/git2/refs.h
+++ b/include/git2/refs.h
@@ -178,7 +178,6 @@ GIT_EXTERN(int) git_reference_symbolic_create(git_reference **out, git_repositor
  * @param name The name of the reference
  * @param id The object id pointed to by the reference.
  * @param force Overwrite existing references
- * @param force Overwrite existing references
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
  * @return 0 on success, GIT_EEXISTS, GIT_EINVALIDSPEC or an error code
@@ -221,7 +220,6 @@ GIT_EXTERN(int) git_reference_create(git_reference **out, git_repository *repo,
  * @param name The name of the reference
  * @param id The object id pointed to by the reference.
  * @param force Overwrite existing references
- * @param force Overwrite existing references
  * @param current_id The expected value of the reference at the time of update
  * @param signature The identity that will used to populate the reflog entry
  * @param log_message The one line long message to be appended to the reflog
@@ -415,7 +413,7 @@ GIT_EXTERN(int) git_reference_delete(git_reference *ref);
  * This method removes the named reference from the repository without
  * looking at its old value.
  *
- * @param ref The reference to remove
+ * @param name The reference to remove
  * @return 0 or an error code
  */
 GIT_EXTERN(int) git_reference_remove(git_repository *repo, const char *name);
diff --git a/include/git2/repository.h b/include/git2/repository.h
index 037cb3f96..6a8ff4545 100644
--- a/include/git2/repository.h
+++ b/include/git2/repository.h
@@ -649,7 +649,7 @@ GIT_EXTERN(int) git_repository_set_head_detached(
  *
  * @param repo Repository pointer
  * @param signature The identity that will used to populate the reflog entry
- * @param log_message The one line long message to be appended to the reflog
+ * @param reflog_message The one line long message to be appended to the reflog
  * @return 0 on success, GIT_EUNBORNBRANCH when HEAD points to a non existing
  * branch or an error code
  */
diff --git a/include/git2/revert.h b/include/git2/revert.h
index da37fbe7b..fc1767c93 100644
--- a/include/git2/revert.h
+++ b/include/git2/revert.h
@@ -56,7 +56,7 @@ GIT_EXTERN(int) git_revert_init_options(
  * @param revert_commit the commit to revert
  * @param our_commit the commit to revert against (eg, HEAD)
  * @param mainline the parent of the revert commit, if it is a merge
- * @param merge_tree_opts the merge tree options (or null for defaults)
+ * @param merge_options the merge options (or null for defaults)
  * @return zero on success, -1 on failure.
  */
 int git_revert_commit(
@@ -71,9 +71,8 @@ int git_revert_commit(
  * Reverts the given commit, producing changes in the working directory.
  *
  * @param repo the repository to revert
- * @param commits the commits to revert
- * @param commits_len the number of commits to revert
- * @param flags merge flags
+ * @param commit the commit to revert
+ * @param given_opts merge flags
  * @return zero on success, -1 on failure.
  */
 GIT_EXTERN(int) git_revert(
diff --git a/include/git2/signature.h b/include/git2/signature.h
index a1dd1ec7a..feb1b4073 100644
--- a/include/git2/signature.h
+++ b/include/git2/signature.h
@@ -69,7 +69,7 @@ GIT_EXTERN(int) git_signature_default(git_signature **out, git_repository *repo)
  * Call `git_signature_free()` to free the data.
  *
  * @param dest pointer where to store the copy
- * @param entry signature to duplicate
+ * @param sig signature to duplicate
  * @return 0 or an error code
  */
 GIT_EXTERN(int) git_signature_dup(git_signature **dest, const git_signature *sig);
diff --git a/include/git2/submodule.h b/include/git2/submodule.h
index 28e235725..864d1c58c 100644
--- a/include/git2/submodule.h
+++ b/include/git2/submodule.h
@@ -283,7 +283,7 @@ GIT_EXTERN(const char *) git_submodule_url(git_submodule *submodule);
  * Resolve a submodule url relative to the given repository.
  *
  * @param out buffer to store the absolute submodule url in
- * @param repository Pointer to repository object
+ * @param repo Pointer to repository object
  * @param url Relative url
  * @return 0 or an error code
  */
diff --git a/include/git2/tree.h b/include/git2/tree.h
index 6669652ae..56922d40b 100644
--- a/include/git2/tree.h
+++ b/include/git2/tree.h
@@ -151,7 +151,7 @@ GIT_EXTERN(int) git_tree_entry_bypath(
  * and must be freed explicitly with `git_tree_entry_free()`.
  *
  * @param dest pointer where to store the copy
- * @param entry tree entry to duplicate
+ * @param source tree entry to duplicate
  * @return 0 or an error code
  */
 GIT_EXTERN(int) git_tree_entry_dup(git_tree_entry **dest, const git_tree_entry *source);
-- 
cgit v1.2.3


From 161e6dc1cacb724543c81ee0a62ed28742a81190 Mon Sep 17 00:00:00 2001
From: Eoin Coffey <ecoffey@gmail.com>
Date: Fri, 23 May 2014 12:27:16 -0600
Subject: Add --committer option, and break out helper function

---
 examples/log.c | 28 +++++++++++++++++++++-------
 1 file changed, 21 insertions(+), 7 deletions(-)

diff --git a/examples/log.c b/examples/log.c
index 655b95d10..5a43f632a 100644
--- a/examples/log.c
+++ b/examples/log.c
@@ -44,6 +44,7 @@ struct log_state {
 
 /** utility functions that are called to configure the walker */
 static void set_sorting(struct log_state *s, unsigned int sort_mode);
+static int signature_does_not_match(const git_signature *sig, const char *filter);
 static void push_rev(struct log_state *s, git_object *obj, int hide);
 static int add_revision(struct log_state *s, const char *revstr);
 
@@ -55,7 +56,7 @@ struct log_options {
 	git_time_t before;
 	git_time_t after;
 	const char *author;
-	char *committer;
+	const char *committer;
 };
 
 /** utility functions that parse options and help with log output */
@@ -75,7 +76,6 @@ int main(int argc, char *argv[])
 	git_oid oid;
 	git_commit *commit = NULL;
 	git_pathspec *ps = NULL;
-	const git_signature *sig;
 
 	git_threads_init();
 
@@ -129,11 +129,11 @@ int main(int argc, char *argv[])
 				continue;
 		}
 
-		if (opt.author != NULL) {
-			if ((sig = git_commit_author(commit)) == NULL ||
-				strstr(sig->name, opt.author) == NULL)
-				continue;
-		}
+		if (signature_does_not_match(git_commit_author(commit), opt.author))
+			continue;
+
+		if (signature_does_not_match(git_commit_committer(commit), opt.committer))
+			continue;
 
 		if (count++ < opt.skip)
 			continue;
@@ -179,6 +179,18 @@ int main(int argc, char *argv[])
 	return 0;
 }
 
+/** Determine if the given git_signature does not contain the filter text. */
+static int signature_does_not_match(const git_signature *sig, const char *filter) {
+	if (filter == NULL)
+		return 0;
+
+	if (sig == NULL ||
+		(strstr(sig->name, filter) == NULL &&
+		strstr(sig->email, filter) == NULL))
+		return 1;
+	return 0;
+}
+
 /** Push object (for hide or show) onto revwalker. */
 static void push_rev(struct log_state *s, git_object *obj, int hide)
 {
@@ -410,6 +422,8 @@ static int parse_options(
 			set_sorting(s, GIT_SORT_REVERSE);
 		else if (match_str_arg(&opt->author, &args, "--author"))
 			/** Found valid --author */;
+		else if (match_str_arg(&opt->committer, &args, "--committer"))
+			/** Found valid --committer */;
 		else if (match_str_arg(&s->repodir, &args, "--git-dir"))
 			/** Found git-dir. */;
 		else if (match_int_arg(&opt->skip, &args, "--skip", 0))
-- 
cgit v1.2.3


From 26cce32133363133b479cfd811523270db851466 Mon Sep 17 00:00:00 2001
From: Eoin Coffey <ecoffey@gmail.com>
Date: Fri, 23 May 2014 12:59:19 -0600
Subject: Add support for --grep

---
 examples/log.c | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/examples/log.c b/examples/log.c
index 5a43f632a..965f854d7 100644
--- a/examples/log.c
+++ b/examples/log.c
@@ -44,7 +44,6 @@ struct log_state {
 
 /** utility functions that are called to configure the walker */
 static void set_sorting(struct log_state *s, unsigned int sort_mode);
-static int signature_does_not_match(const git_signature *sig, const char *filter);
 static void push_rev(struct log_state *s, git_object *obj, int hide);
 static int add_revision(struct log_state *s, const char *revstr);
 
@@ -57,6 +56,7 @@ struct log_options {
 	git_time_t after;
 	const char *author;
 	const char *committer;
+	const char *grep;
 };
 
 /** utility functions that parse options and help with log output */
@@ -66,6 +66,9 @@ static void print_time(const git_time *intime, const char *prefix);
 static void print_commit(git_commit *commit);
 static int match_with_parent(git_commit *commit, int i, git_diff_options *);
 
+/** utility functions for filtering */
+static int signature_does_not_match(const git_signature *sig, const char *filter);
+static int log_message_does_not_match(const git_commit *commit, const char *filter);
 
 int main(int argc, char *argv[])
 {
@@ -135,6 +138,9 @@ int main(int argc, char *argv[])
 		if (signature_does_not_match(git_commit_committer(commit), opt.committer))
 			continue;
 
+		if (log_message_does_not_match(commit, opt.grep))
+			continue;
+
 		if (count++ < opt.skip)
 			continue;
 		if (opt.limit != -1 && printed++ >= opt.limit) {
@@ -188,6 +194,20 @@ static int signature_does_not_match(const git_signature *sig, const char *filter
 		(strstr(sig->name, filter) == NULL &&
 		strstr(sig->email, filter) == NULL))
 		return 1;
+
+	return 0;
+}
+
+static int log_message_does_not_match(const git_commit *commit, const char *filter) {
+	const char *message = NULL;
+
+	if (filter == NULL)
+		return 0;
+
+	if ((message = git_commit_message(commit)) == NULL ||
+		strstr(message, filter) == NULL)
+		return 1;
+
 	return 0;
 }
 
@@ -424,6 +444,8 @@ static int parse_options(
 			/** Found valid --author */;
 		else if (match_str_arg(&opt->committer, &args, "--committer"))
 			/** Found valid --committer */;
+		else if (match_str_arg(&opt->grep, &args, "--grep"))
+			/** Found valid --grep */;
 		else if (match_str_arg(&s->repodir, &args, "--git-dir"))
 			/** Found git-dir. */;
 		else if (match_int_arg(&opt->skip, &args, "--skip", 0))
-- 
cgit v1.2.3


From 87493bca9c5c14f99adea5ceadf6caa8005a6ada Mon Sep 17 00:00:00 2001
From: Eoin Coffey <ecoffey@gmail.com>
Date: Fri, 23 May 2014 13:00:30 -0600
Subject: Remove simple --author, --committer, and --grep from PROJECTS

---
 PROJECTS.md | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/PROJECTS.md b/PROJECTS.md
index 9472fb43c..d17214471 100644
--- a/PROJECTS.md
+++ b/PROJECTS.md
@@ -39,12 +39,6 @@ These are good small projects to get started with libgit2.
       the data is available, you would just need to add the code into the
       `print_commit()` routine (along with a way of passing the option
       into that function).
-    * For `examples/log.c`, implement any one of `--author=<...>`,
-      `--committer=<...>`, or `--grep=<...>` but just use simple string
-      match with `strstr()` instead of full regular expression
-      matching. (I.e. I'm suggesting implementing this as if
-      `--fixed-strings` was always turned on, because it will be a simpler
-      project.)
     * As an extension to the matching idea for `examples/log.c`, add the
       `-i` option to use `strcasestr()` for matches.
     * For `examples/log.c`, implement the `--first-parent` option now that
-- 
cgit v1.2.3


From 517341c5d8b316f5590d55a4913a65c78ab05973 Mon Sep 17 00:00:00 2001
From: Edward Lee <e45lee@uwaterloo.ca>
Date: Fri, 23 May 2014 22:41:35 -0400
Subject: Address style concerns in setting mkdir/copy flags.

---
 src/repository.c | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/repository.c b/src/repository.c
index 695351977..e8d50aed3 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -1232,15 +1232,10 @@ static int repo_init_structure(
 		}
 
 		if (tdir) {
-			if (chmod) {
-				error = git_futils_cp_r(tdir, repo_dir,
-					GIT_CPDIR_COPY_SYMLINKS | GIT_CPDIR_CHMOD_DIRS |
-					GIT_CPDIR_SIMPLE_TO_MODE, dmode);
-			} else {
-				error = git_futils_cp_r(tdir, repo_dir,
-					GIT_CPDIR_COPY_SYMLINKS |
-					GIT_CPDIR_SIMPLE_TO_MODE, dmode);
-			}
+			uint32_t cpflags = GIT_CPDIR_COPY_SYMLINKS | GIT_CPDIR_SIMPLE_TO_MODE;
+			if (opts->mode != GIT_REPOSITORY_INIT_SHARED_UMASK)
+					cpflags |= GIT_CPDIR_CHMOD_DIRS;
+			error = git_futils_cp_r(tdir, repo_dir, cpflags, dmode);
 		}
 
 		git_buf_free(&template_buf);
@@ -1263,13 +1258,12 @@ static int repo_init_structure(
 	 */
 	for (tpl = repo_template; !error && tpl->path; ++tpl) {
 		if (!tpl->content) {
-			if (chmod) {
-				error = git_futils_mkdir(
-					tpl->path, repo_dir, dmode, GIT_MKDIR_PATH | GIT_MKDIR_CHMOD);
-			} else {
-				error = git_futils_mkdir(
-					tpl->path, repo_dir, dmode, GIT_MKDIR_PATH);
-			}
+			uint32_t mkdir_flags = GIT_MKDIR_PATH;
+			if (chmod)
+				mkdir_flags |= GIT_MKDIR_CHMOD;
+
+			error = git_futils_mkdir(
+				tpl->path, repo_dir, dmode, mkdir_flags);
 		}
 		else if (!external_tpl) {
 			const char *content = tpl->content;
-- 
cgit v1.2.3


From 3ac1ff42d7cfa8ac981a37712863419c071f2640 Mon Sep 17 00:00:00 2001
From: "Cha, Hojeong" <ikadro@gmail.com>
Date: Tue, 27 May 2014 23:32:38 +0900
Subject: Fix compile error on Visual Studio

---
 tests/diff/workdir.c  | 4 ++--
 tests/repo/pathspec.c | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/diff/workdir.c b/tests/diff/workdir.c
index f82bb00e8..963be9481 100644
--- a/tests/diff/workdir.c
+++ b/tests/diff/workdir.c
@@ -1610,8 +1610,8 @@ void test_diff_workdir__binary_detection(void)
 	int i;
 	git_buf data[10] = {
 		{ "1234567890", 0, 0 },         /* 0 - all ascii text control */
-		{ "Åü†HøπΩ", 0, 0 },            /* 1 - UTF-8 multibyte text */
-		{ "\xEF\xBB\xBFÜ⤒ƒ8£€", 0, 0 }, /* 2 - UTF-8 with BOM */
+		{ "\xC3\x85\xC3\xBC\xE2\x80\xA0\x48\xC3\xB8\xCF\x80\xCE\xA9", 0, 0 },            /* 1 - UTF-8 multibyte text */
+		{ "\xEF\xBB\xBF\xC3\x9C\xE2\xA4\x92\xC6\x92\x38\xC2\xA3\xE2\x82\xAC", 0, 0 }, /* 2 - UTF-8 with BOM */
 		{ STR999Z, 0, 1000 },           /* 3 - ASCII with NUL at 1000 */
 		{ STR3999Z, 0, 4000 },          /* 4 - ASCII with NUL at 4000 */
 		{ STR4000 STR3999Z "x", 0, 8001 }, /* 5 - ASCII with NUL at 8000 */
diff --git a/tests/repo/pathspec.c b/tests/repo/pathspec.c
index 334066b67..5b86662bc 100644
--- a/tests/repo/pathspec.c
+++ b/tests/repo/pathspec.c
@@ -167,7 +167,7 @@ void test_repo_pathspec__workdir4(void)
 
 	cl_git_pass(git_pathspec_match_workdir(&m, g_repo, 0, ps));
 	cl_assert_equal_sz(13, git_pathspec_match_list_entrycount(m));
-	cl_assert_equal_s("è¿™", git_pathspec_match_list_entry(m, 12));
+	cl_assert_equal_s("\xE8\xBF\x99", git_pathspec_match_list_entry(m, 12));
 	git_pathspec_match_list_free(m);
 
 	git_pathspec_free(ps);
-- 
cgit v1.2.3


From d362093f9e858cf48d3c09bbcacf01f057b58db1 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Thu, 8 May 2014 15:41:36 -0700
Subject: Introduce GIT_MERGE_CONFIG_* for merge.ff settings

git_merge_analysis will now return GIT_MERGE_CONFIG_NO_FASTFORWARD
when merge.ff=false and GIT_MERGE_CONFIG_FASTFORWARD_ONLY when
merge.ff=true
---
 include/git2/merge.h           | 12 ++++++++++
 src/merge.c                    | 52 ++++++++++++++++++++++++++++++++++--------
 tests/merge/workdir/analysis.c | 26 +++++++++++++++++++++
 3 files changed, 81 insertions(+), 9 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index 7915050b0..dc63ed588 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -266,6 +266,18 @@ typedef enum {
 	 * to simply set HEAD to the target commit(s).
 	 */
 	GIT_MERGE_ANALYSIS_UNBORN = (1 << 3),
+
+	/**
+	 * There is a `merge.ff=false` configuration setting, suggesting that
+	 * the user does not want to allow a fast-forward merge.
+	 */
+	GIT_MERGE_CONFIG_NO_FASTFORWARD = (1 << 4),
+
+	/**
+	 * There is a `merge.ff=only` configuration setting, suggesting that
+	 * the user only wants fast-forward merges.
+	 */
+	GIT_MERGE_CONFIG_FASTFORWARD_ONLY = (1 << 5),
 } git_merge_analysis_t;
 
 /**
diff --git a/src/merge.c b/src/merge.c
index 6a8e5874f..85b74483b 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2564,6 +2564,37 @@ done:
 	return error;
 }
 
+int analysis_config(git_merge_analysis_t *out, git_repository *repo)
+{
+	git_config *config;
+	const char *value;
+	int bool_value, error = 0;
+
+	if ((error = git_repository_config(&config, repo)) < 0)
+		goto done;
+
+	if ((error = git_config_get_string(&value, config, "merge.ff")) < 0) {
+		if (error == GIT_ENOTFOUND) {
+			giterr_clear();
+			error = 0;
+		}
+
+		goto done;
+	}
+
+	if (git_config_parse_bool(&bool_value, value) == 0) {
+		if (!bool_value)
+			*out |= GIT_MERGE_CONFIG_NO_FASTFORWARD;
+	} else {
+		if (strcasecmp(value, "only") == 0)
+			*out |= GIT_MERGE_CONFIG_FASTFORWARD_ONLY;
+	}
+
+done:
+	git_config_free(config);
+	return error;
+}
+
 int git_merge_analysis(
 	git_merge_analysis_t *out,
 	git_repository *repo,
@@ -2575,16 +2606,19 @@ int git_merge_analysis(
 
 	assert(out && repo && their_heads);
 
+	if (their_heads_len != 1) {
+		giterr_set(GITERR_MERGE, "Can only merge a single branch");
+		error = -1;
+		goto done;
+	}
+
 	*out = GIT_MERGE_ANALYSIS_NONE;
 
-	if (git_repository_head_unborn(repo)) {
-		*out = GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_UNBORN;
+	if ((error = analysis_config(out, repo)) < 0)
 		goto done;
-	}
 
-	if (their_heads_len != 1) {
-		giterr_set(GITERR_MERGE, "Can only merge a single branch");
-		error = -1;
+	if (git_repository_head_unborn(repo)) {
+		*out |= GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_UNBORN;
 		goto done;
 	}
 
@@ -2593,15 +2627,15 @@ int git_merge_analysis(
 
 	/* We're up-to-date if we're trying to merge our own common ancestor. */
 	if (ancestor_head && git_oid_equal(&ancestor_head->oid, &their_heads[0]->oid))
-		*out = GIT_MERGE_ANALYSIS_UP_TO_DATE;
+		*out |= GIT_MERGE_ANALYSIS_UP_TO_DATE;
 
 	/* We're fastforwardable if we're our own common ancestor. */
 	else if (ancestor_head && git_oid_equal(&ancestor_head->oid, &our_head->oid))
-		*out = GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_NORMAL;
+		*out |= GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_NORMAL;
 
 	/* Otherwise, just a normal merge is possible. */
 	else
-		*out = GIT_MERGE_ANALYSIS_NORMAL;
+		*out |= GIT_MERGE_ANALYSIS_NORMAL;
 
 done:
 	git_merge_head_free(ancestor_head);
diff --git a/tests/merge/workdir/analysis.c b/tests/merge/workdir/analysis.c
index 0e937857f..daa4e9dd8 100644
--- a/tests/merge/workdir/analysis.c
+++ b/tests/merge/workdir/analysis.c
@@ -105,3 +105,29 @@ void test_merge_workdir_analysis__unborn(void)
 	git_buf_free(&master);
 }
 
+void test_merge_workdir_analysis__fastforward_with_config_noff(void)
+{
+	git_config *config;
+	git_merge_analysis_t analysis;
+
+	git_repository_config(&config, repo);
+	git_config_set_string(config, "merge.ff", "false");
+
+	analysis = analysis_from_branch(FASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (analysis & GIT_MERGE_ANALYSIS_NORMAL));
+	cl_assert_equal_i(GIT_MERGE_CONFIG_NO_FASTFORWARD, (analysis & GIT_MERGE_CONFIG_NO_FASTFORWARD));
+}
+
+void test_merge_workdir_analysis__no_fastforward_with_config_ffonly(void)
+{
+	git_config *config;
+	git_merge_analysis_t analysis;
+
+	git_repository_config(&config, repo);
+	git_config_set_string(config, "merge.ff", "only");
+
+	analysis = analysis_from_branch(NOFASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (analysis & GIT_MERGE_ANALYSIS_NORMAL));
+	cl_assert_equal_i(GIT_MERGE_CONFIG_FASTFORWARD_ONLY, (analysis & GIT_MERGE_CONFIG_FASTFORWARD_ONLY));
+}
-- 
cgit v1.2.3


From a3622ba6cc0970abe485baa98ab53e32df28cfdc Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 16 May 2014 13:54:40 -0500
Subject: Move GIT_MERGE_CONFIG_* to its own enum

---
 include/git2/merge.h           | 14 +++++++--
 src/merge.c                    | 21 +++++++------
 tests/merge/workdir/analysis.c | 69 +++++++++++++++++++++++-------------------
 3 files changed, 61 insertions(+), 43 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index dc63ed588..d0092e45e 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -266,19 +266,26 @@ typedef enum {
 	 * to simply set HEAD to the target commit(s).
 	 */
 	GIT_MERGE_ANALYSIS_UNBORN = (1 << 3),
+} git_merge_analysis_t;
+
+typedef enum {
+	/*
+	 * No configuration was found that suggests a behavior for merge.
+	 */
+	GIT_MERGE_CONFIG_NONE = 0,
 
 	/**
 	 * There is a `merge.ff=false` configuration setting, suggesting that
 	 * the user does not want to allow a fast-forward merge.
 	 */
-	GIT_MERGE_CONFIG_NO_FASTFORWARD = (1 << 4),
+	GIT_MERGE_CONFIG_NO_FASTFORWARD = (1 << 0),
 
 	/**
 	 * There is a `merge.ff=only` configuration setting, suggesting that
 	 * the user only wants fast-forward merges.
 	 */
-	GIT_MERGE_CONFIG_FASTFORWARD_ONLY = (1 << 5),
-} git_merge_analysis_t;
+	GIT_MERGE_CONFIG_FASTFORWARD_ONLY = (1 << 1),
+} git_merge_config_t;
 
 /**
  * Analyzes the given branch(es) and determines the opportunities for
@@ -292,6 +299,7 @@ typedef enum {
  */
 GIT_EXTERN(int) git_merge_analysis(
 	git_merge_analysis_t *analysis_out,
+	git_merge_config_t *config_out,
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len);
diff --git a/src/merge.c b/src/merge.c
index 85b74483b..02851e526 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2564,12 +2564,14 @@ done:
 	return error;
 }
 
-int analysis_config(git_merge_analysis_t *out, git_repository *repo)
+int merge_config(git_merge_config_t *out, git_repository *repo)
 {
 	git_config *config;
 	const char *value;
 	int bool_value, error = 0;
 
+	*out = GIT_MERGE_CONFIG_NONE;
+
 	if ((error = git_repository_config(&config, repo)) < 0)
 		goto done;
 
@@ -2596,7 +2598,8 @@ done:
 }
 
 int git_merge_analysis(
-	git_merge_analysis_t *out,
+	git_merge_analysis_t *analysis_out,
+	git_merge_config_t *config_out,
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len)
@@ -2604,7 +2607,7 @@ int git_merge_analysis(
 	git_merge_head *ancestor_head = NULL, *our_head = NULL;
 	int error = 0;
 
-	assert(out && repo && their_heads);
+	assert(analysis_out && config_out && repo && their_heads);
 
 	if (their_heads_len != 1) {
 		giterr_set(GITERR_MERGE, "Can only merge a single branch");
@@ -2612,13 +2615,13 @@ int git_merge_analysis(
 		goto done;
 	}
 
-	*out = GIT_MERGE_ANALYSIS_NONE;
+	*analysis_out = GIT_MERGE_ANALYSIS_NONE;
 
-	if ((error = analysis_config(out, repo)) < 0)
+	if ((error = merge_config(config_out, repo)) < 0)
 		goto done;
 
 	if (git_repository_head_unborn(repo)) {
-		*out |= GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_UNBORN;
+		*analysis_out |= GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_UNBORN;
 		goto done;
 	}
 
@@ -2627,15 +2630,15 @@ int git_merge_analysis(
 
 	/* We're up-to-date if we're trying to merge our own common ancestor. */
 	if (ancestor_head && git_oid_equal(&ancestor_head->oid, &their_heads[0]->oid))
-		*out |= GIT_MERGE_ANALYSIS_UP_TO_DATE;
+		*analysis_out |= GIT_MERGE_ANALYSIS_UP_TO_DATE;
 
 	/* We're fastforwardable if we're our own common ancestor. */
 	else if (ancestor_head && git_oid_equal(&ancestor_head->oid, &our_head->oid))
-		*out |= GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_NORMAL;
+		*analysis_out |= GIT_MERGE_ANALYSIS_FASTFORWARD | GIT_MERGE_ANALYSIS_NORMAL;
 
 	/* Otherwise, just a normal merge is possible. */
 	else
-		*out |= GIT_MERGE_ANALYSIS_NORMAL;
+		*analysis_out |= GIT_MERGE_ANALYSIS_NORMAL;
 
 done:
 	git_merge_head_free(ancestor_head);
diff --git a/tests/merge/workdir/analysis.c b/tests/merge/workdir/analysis.c
index daa4e9dd8..d4cf587c4 100644
--- a/tests/merge/workdir/analysis.c
+++ b/tests/merge/workdir/analysis.c
@@ -36,71 +36,76 @@ void test_merge_workdir_analysis__cleanup(void)
 	cl_git_sandbox_cleanup();
 }
 
-static git_merge_analysis_t analysis_from_branch(const char *branchname)
+static void analysis_from_branch(
+	git_merge_analysis_t *merge_analysis,
+	git_merge_config_t *merge_config,
+	const char *branchname)
 {
 	git_buf refname = GIT_BUF_INIT;
 	git_reference *their_ref;
 	git_merge_head *their_head;
-	git_merge_analysis_t analysis;
 
 	git_buf_printf(&refname, "%s%s", GIT_REFS_HEADS_DIR, branchname);
 
 	cl_git_pass(git_reference_lookup(&their_ref, repo, git_buf_cstr(&refname)));
 	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
 
-	cl_git_pass(git_merge_analysis(&analysis, repo, (const git_merge_head **)&their_head, 1));
+	cl_git_pass(git_merge_analysis(merge_analysis, merge_config, repo, (const git_merge_head **)&their_head, 1));
 
 	git_buf_free(&refname);
 	git_merge_head_free(their_head);
 	git_reference_free(their_ref);
-
-	return analysis;
 }
 
 void test_merge_workdir_analysis__fastforward(void)
 {
-	git_merge_analysis_t analysis;
+	git_merge_analysis_t merge_analysis;
+	git_merge_config_t merge_config;
 
-	analysis = analysis_from_branch(FASTFORWARD_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (analysis & GIT_MERGE_ANALYSIS_NORMAL));
+	analysis_from_branch(&merge_analysis, &merge_config, FASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (merge_analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (merge_analysis & GIT_MERGE_ANALYSIS_NORMAL));
 }
 
 void test_merge_workdir_analysis__no_fastforward(void)
 {
-	git_merge_analysis_t analysis;
+	git_merge_analysis_t merge_analysis;
+	git_merge_config_t merge_config;
 
-	analysis = analysis_from_branch(NOFASTFORWARD_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, analysis);
+	analysis_from_branch(&merge_analysis, &merge_config, NOFASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, merge_analysis);
 }
 
 void test_merge_workdir_analysis__uptodate(void)
 {
-	git_merge_analysis_t analysis;
+	git_merge_analysis_t merge_analysis;
+	git_merge_config_t merge_config;
 
-	analysis = analysis_from_branch(UPTODATE_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, analysis);
+	analysis_from_branch(&merge_analysis, &merge_config, UPTODATE_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, merge_analysis);
 }
 
 void test_merge_workdir_analysis__uptodate_merging_prev_commit(void)
 {
-	git_merge_analysis_t analysis;
+	git_merge_analysis_t merge_analysis;
+	git_merge_config_t merge_config;
 
-	analysis = analysis_from_branch(PREVIOUS_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, analysis);
+	analysis_from_branch(&merge_analysis, &merge_config, PREVIOUS_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, merge_analysis);
 }
 
 void test_merge_workdir_analysis__unborn(void)
 {
-	git_merge_analysis_t analysis;
+	git_merge_analysis_t merge_analysis;
+	git_merge_config_t merge_config;
 	git_buf master = GIT_BUF_INIT;
 
 	git_buf_joinpath(&master, git_repository_path(repo), "refs/heads/master");
 	p_unlink(git_buf_cstr(&master));
 
-	analysis = analysis_from_branch(NOFASTFORWARD_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UNBORN, (analysis & GIT_MERGE_ANALYSIS_UNBORN));
+	analysis_from_branch(&merge_analysis, &merge_config, NOFASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (merge_analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UNBORN, (merge_analysis & GIT_MERGE_ANALYSIS_UNBORN));
 
 	git_buf_free(&master);
 }
@@ -108,26 +113,28 @@ void test_merge_workdir_analysis__unborn(void)
 void test_merge_workdir_analysis__fastforward_with_config_noff(void)
 {
 	git_config *config;
-	git_merge_analysis_t analysis;
+	git_merge_analysis_t merge_analysis;
+	git_merge_config_t merge_config;
 
 	git_repository_config(&config, repo);
 	git_config_set_string(config, "merge.ff", "false");
 
-	analysis = analysis_from_branch(FASTFORWARD_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (analysis & GIT_MERGE_ANALYSIS_NORMAL));
-	cl_assert_equal_i(GIT_MERGE_CONFIG_NO_FASTFORWARD, (analysis & GIT_MERGE_CONFIG_NO_FASTFORWARD));
+	analysis_from_branch(&merge_analysis, &merge_config, FASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (merge_analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (merge_analysis & GIT_MERGE_ANALYSIS_NORMAL));
+	cl_assert_equal_i(GIT_MERGE_CONFIG_NO_FASTFORWARD, (merge_config & GIT_MERGE_CONFIG_NO_FASTFORWARD));
 }
 
 void test_merge_workdir_analysis__no_fastforward_with_config_ffonly(void)
 {
 	git_config *config;
-	git_merge_analysis_t analysis;
+	git_merge_analysis_t merge_analysis;
+	git_merge_config_t merge_config;
 
 	git_repository_config(&config, repo);
 	git_config_set_string(config, "merge.ff", "only");
 
-	analysis = analysis_from_branch(NOFASTFORWARD_BRANCH);
-	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (analysis & GIT_MERGE_ANALYSIS_NORMAL));
-	cl_assert_equal_i(GIT_MERGE_CONFIG_FASTFORWARD_ONLY, (analysis & GIT_MERGE_CONFIG_FASTFORWARD_ONLY));
+	analysis_from_branch(&merge_analysis, &merge_config, NOFASTFORWARD_BRANCH);
+	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (merge_analysis & GIT_MERGE_ANALYSIS_NORMAL));
+	cl_assert_equal_i(GIT_MERGE_CONFIG_FASTFORWARD_ONLY, (merge_config & GIT_MERGE_CONFIG_FASTFORWARD_ONLY));
 }
-- 
cgit v1.2.3


From 22ab8881787f00eec479e1f148a3846a67c9bcfe Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 20 May 2014 22:07:15 -0700
Subject: Use a config snapshot

---
 src/merge.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/merge.c b/src/merge.c
index 02851e526..54c7660db 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2572,7 +2572,7 @@ int merge_config(git_merge_config_t *out, git_repository *repo)
 
 	*out = GIT_MERGE_CONFIG_NONE;
 
-	if ((error = git_repository_config(&config, repo)) < 0)
+	if ((error = git_repository_config_snapshot(&config, repo)) < 0)
 		goto done;
 
 	if ((error = git_config_get_string(&value, config, "merge.ff")) < 0) {
-- 
cgit v1.2.3


From de3f851ec49deba7b152c01c53aa329439d1f3f5 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Wed, 21 May 2014 09:44:05 -0700
Subject: Staticify `merge_config`

---
 src/merge.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/merge.c b/src/merge.c
index 54c7660db..e2f1e388d 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2564,7 +2564,7 @@ done:
 	return error;
 }
 
-int merge_config(git_merge_config_t *out, git_repository *repo)
+static int merge_config(git_merge_config_t *out, git_repository *repo)
 {
 	git_config *config;
 	const char *value;
-- 
cgit v1.2.3


From eff531e1034401b144b02ff2913a361669d04129 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Tue, 27 May 2014 20:58:20 -0500
Subject: Modify GIT_MERGE_CONFIG -> GIT_MERGE_PREFERENCE

---
 include/git2/merge.h           | 13 +++++++------
 src/merge.c                    | 14 +++++++-------
 tests/merge/workdir/analysis.c | 36 ++++++++++++++++++------------------
 3 files changed, 32 insertions(+), 31 deletions(-)

diff --git a/include/git2/merge.h b/include/git2/merge.h
index d0092e45e..9eb14ccb1 100644
--- a/include/git2/merge.h
+++ b/include/git2/merge.h
@@ -270,22 +270,23 @@ typedef enum {
 
 typedef enum {
 	/*
-	 * No configuration was found that suggests a behavior for merge.
+	 * No configuration was found that suggests a preferred behavior for
+	 * merge.
 	 */
-	GIT_MERGE_CONFIG_NONE = 0,
+	GIT_MERGE_PREFERENCE_NONE = 0,
 
 	/**
 	 * There is a `merge.ff=false` configuration setting, suggesting that
 	 * the user does not want to allow a fast-forward merge.
 	 */
-	GIT_MERGE_CONFIG_NO_FASTFORWARD = (1 << 0),
+	GIT_MERGE_PREFERENCE_NO_FASTFORWARD = (1 << 0),
 
 	/**
 	 * There is a `merge.ff=only` configuration setting, suggesting that
 	 * the user only wants fast-forward merges.
 	 */
-	GIT_MERGE_CONFIG_FASTFORWARD_ONLY = (1 << 1),
-} git_merge_config_t;
+	GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY = (1 << 1),
+} git_merge_preference_t;
 
 /**
  * Analyzes the given branch(es) and determines the opportunities for
@@ -299,7 +300,7 @@ typedef enum {
  */
 GIT_EXTERN(int) git_merge_analysis(
 	git_merge_analysis_t *analysis_out,
-	git_merge_config_t *config_out,
+	git_merge_preference_t *preference_out,
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len);
diff --git a/src/merge.c b/src/merge.c
index e2f1e388d..a279d31d4 100644
--- a/src/merge.c
+++ b/src/merge.c
@@ -2564,13 +2564,13 @@ done:
 	return error;
 }
 
-static int merge_config(git_merge_config_t *out, git_repository *repo)
+static int merge_preference(git_merge_preference_t *out, git_repository *repo)
 {
 	git_config *config;
 	const char *value;
 	int bool_value, error = 0;
 
-	*out = GIT_MERGE_CONFIG_NONE;
+	*out = GIT_MERGE_PREFERENCE_NONE;
 
 	if ((error = git_repository_config_snapshot(&config, repo)) < 0)
 		goto done;
@@ -2586,10 +2586,10 @@ static int merge_config(git_merge_config_t *out, git_repository *repo)
 
 	if (git_config_parse_bool(&bool_value, value) == 0) {
 		if (!bool_value)
-			*out |= GIT_MERGE_CONFIG_NO_FASTFORWARD;
+			*out |= GIT_MERGE_PREFERENCE_NO_FASTFORWARD;
 	} else {
 		if (strcasecmp(value, "only") == 0)
-			*out |= GIT_MERGE_CONFIG_FASTFORWARD_ONLY;
+			*out |= GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY;
 	}
 
 done:
@@ -2599,7 +2599,7 @@ done:
 
 int git_merge_analysis(
 	git_merge_analysis_t *analysis_out,
-	git_merge_config_t *config_out,
+	git_merge_preference_t *preference_out,
 	git_repository *repo,
 	const git_merge_head **their_heads,
 	size_t their_heads_len)
@@ -2607,7 +2607,7 @@ int git_merge_analysis(
 	git_merge_head *ancestor_head = NULL, *our_head = NULL;
 	int error = 0;
 
-	assert(analysis_out && config_out && repo && their_heads);
+	assert(analysis_out && preference_out && repo && their_heads);
 
 	if (their_heads_len != 1) {
 		giterr_set(GITERR_MERGE, "Can only merge a single branch");
@@ -2617,7 +2617,7 @@ int git_merge_analysis(
 
 	*analysis_out = GIT_MERGE_ANALYSIS_NONE;
 
-	if ((error = merge_config(config_out, repo)) < 0)
+	if ((error = merge_preference(preference_out, repo)) < 0)
 		goto done;
 
 	if (git_repository_head_unborn(repo)) {
diff --git a/tests/merge/workdir/analysis.c b/tests/merge/workdir/analysis.c
index d4cf587c4..85918abe4 100644
--- a/tests/merge/workdir/analysis.c
+++ b/tests/merge/workdir/analysis.c
@@ -38,7 +38,7 @@ void test_merge_workdir_analysis__cleanup(void)
 
 static void analysis_from_branch(
 	git_merge_analysis_t *merge_analysis,
-	git_merge_config_t *merge_config,
+	git_merge_preference_t *merge_pref,
 	const char *branchname)
 {
 	git_buf refname = GIT_BUF_INIT;
@@ -50,7 +50,7 @@ static void analysis_from_branch(
 	cl_git_pass(git_reference_lookup(&their_ref, repo, git_buf_cstr(&refname)));
 	cl_git_pass(git_merge_head_from_ref(&their_head, repo, their_ref));
 
-	cl_git_pass(git_merge_analysis(merge_analysis, merge_config, repo, (const git_merge_head **)&their_head, 1));
+	cl_git_pass(git_merge_analysis(merge_analysis, merge_pref, repo, (const git_merge_head **)&their_head, 1));
 
 	git_buf_free(&refname);
 	git_merge_head_free(their_head);
@@ -60,9 +60,9 @@ static void analysis_from_branch(
 void test_merge_workdir_analysis__fastforward(void)
 {
 	git_merge_analysis_t merge_analysis;
-	git_merge_config_t merge_config;
+	git_merge_preference_t merge_pref;
 
-	analysis_from_branch(&merge_analysis, &merge_config, FASTFORWARD_BRANCH);
+	analysis_from_branch(&merge_analysis, &merge_pref, FASTFORWARD_BRANCH);
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (merge_analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (merge_analysis & GIT_MERGE_ANALYSIS_NORMAL));
 }
@@ -70,40 +70,40 @@ void test_merge_workdir_analysis__fastforward(void)
 void test_merge_workdir_analysis__no_fastforward(void)
 {
 	git_merge_analysis_t merge_analysis;
-	git_merge_config_t merge_config;
+	git_merge_preference_t merge_pref;
 
-	analysis_from_branch(&merge_analysis, &merge_config, NOFASTFORWARD_BRANCH);
+	analysis_from_branch(&merge_analysis, &merge_pref, NOFASTFORWARD_BRANCH);
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, merge_analysis);
 }
 
 void test_merge_workdir_analysis__uptodate(void)
 {
 	git_merge_analysis_t merge_analysis;
-	git_merge_config_t merge_config;
+	git_merge_preference_t merge_pref;
 
-	analysis_from_branch(&merge_analysis, &merge_config, UPTODATE_BRANCH);
+	analysis_from_branch(&merge_analysis, &merge_pref, UPTODATE_BRANCH);
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, merge_analysis);
 }
 
 void test_merge_workdir_analysis__uptodate_merging_prev_commit(void)
 {
 	git_merge_analysis_t merge_analysis;
-	git_merge_config_t merge_config;
+	git_merge_preference_t merge_pref;
 
-	analysis_from_branch(&merge_analysis, &merge_config, PREVIOUS_BRANCH);
+	analysis_from_branch(&merge_analysis, &merge_pref, PREVIOUS_BRANCH);
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UP_TO_DATE, merge_analysis);
 }
 
 void test_merge_workdir_analysis__unborn(void)
 {
 	git_merge_analysis_t merge_analysis;
-	git_merge_config_t merge_config;
+	git_merge_preference_t merge_pref;
 	git_buf master = GIT_BUF_INIT;
 
 	git_buf_joinpath(&master, git_repository_path(repo), "refs/heads/master");
 	p_unlink(git_buf_cstr(&master));
 
-	analysis_from_branch(&merge_analysis, &merge_config, NOFASTFORWARD_BRANCH);
+	analysis_from_branch(&merge_analysis, &merge_pref, NOFASTFORWARD_BRANCH);
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (merge_analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_UNBORN, (merge_analysis & GIT_MERGE_ANALYSIS_UNBORN));
 
@@ -114,27 +114,27 @@ void test_merge_workdir_analysis__fastforward_with_config_noff(void)
 {
 	git_config *config;
 	git_merge_analysis_t merge_analysis;
-	git_merge_config_t merge_config;
+	git_merge_preference_t merge_pref;
 
 	git_repository_config(&config, repo);
 	git_config_set_string(config, "merge.ff", "false");
 
-	analysis_from_branch(&merge_analysis, &merge_config, FASTFORWARD_BRANCH);
+	analysis_from_branch(&merge_analysis, &merge_pref, FASTFORWARD_BRANCH);
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_FASTFORWARD, (merge_analysis & GIT_MERGE_ANALYSIS_FASTFORWARD));
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (merge_analysis & GIT_MERGE_ANALYSIS_NORMAL));
-	cl_assert_equal_i(GIT_MERGE_CONFIG_NO_FASTFORWARD, (merge_config & GIT_MERGE_CONFIG_NO_FASTFORWARD));
+	cl_assert_equal_i(GIT_MERGE_PREFERENCE_NO_FASTFORWARD, (merge_pref & GIT_MERGE_PREFERENCE_NO_FASTFORWARD));
 }
 
 void test_merge_workdir_analysis__no_fastforward_with_config_ffonly(void)
 {
 	git_config *config;
 	git_merge_analysis_t merge_analysis;
-	git_merge_config_t merge_config;
+	git_merge_preference_t merge_pref;
 
 	git_repository_config(&config, repo);
 	git_config_set_string(config, "merge.ff", "only");
 
-	analysis_from_branch(&merge_analysis, &merge_config, NOFASTFORWARD_BRANCH);
+	analysis_from_branch(&merge_analysis, &merge_pref, NOFASTFORWARD_BRANCH);
 	cl_assert_equal_i(GIT_MERGE_ANALYSIS_NORMAL, (merge_analysis & GIT_MERGE_ANALYSIS_NORMAL));
-	cl_assert_equal_i(GIT_MERGE_CONFIG_FASTFORWARD_ONLY, (merge_config & GIT_MERGE_CONFIG_FASTFORWARD_ONLY));
+	cl_assert_equal_i(GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY, (merge_pref & GIT_MERGE_PREFERENCE_FASTFORWARD_ONLY));
 }
-- 
cgit v1.2.3


From 4386d80be108102548d4ff52c875aedfa94e7412 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sat, 21 Dec 2013 17:18:21 +0000
Subject: clone: perform a "local clone" when given a local path

When git is given such a path, it will perform a "local clone",
bypassing the git-aware protocol and simply copying over all objects
that exist in the source.

Copy this behaviour when given a local path.
---
 include/git2/clone.h |  25 +++++++++++
 src/clone.c          | 114 ++++++++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 128 insertions(+), 11 deletions(-)

diff --git a/include/git2/clone.h b/include/git2/clone.h
index 985c04bf6..ceb1a53bb 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -123,6 +123,31 @@ GIT_EXTERN(int) git_clone_into(
 	const char *branch,
 	const git_signature *signature);
 
+/**
+ * Perform a local clone into a repository
+ *
+ * A "local clone" bypasses any git-aware protocols and simply copies
+ * over the object database from the source repository. It is often
+ * faster than a git-aware clone, but no verification of the data is
+ * performed, and can copy over too much data.
+ *
+ * @param repo the repository to use
+ * @param remote the remote repository to clone from
+ * @param co_opts options to use during checkout
+ * @param branch the branch to checkout after the clone, pass NULL for the
+ *        remote's default branch
+ * @param signature the identity used when updating the reflog
+ * @return 0 on success, any non-zero return value from a callback
+ *         function, or a negative value to indicate an error (use
+ *         `giterr_last` for a detailed error message)
+ */
+GIT_EXTERN(int) git_clone_local_into(
+	git_repository *repo,
+	git_remote *remote,
+	const git_checkout_options *co_opts,
+	const char *branch,
+	const git_signature *signature);
+
 /** @} */
 GIT_END_DECL
 #endif
diff --git a/src/clone.c b/src/clone.c
index 8381ec63c..b66ba6b4c 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -22,6 +22,7 @@
 #include "refs.h"
 #include "path.h"
 #include "repository.h"
+#include "odb.h"
 
 static int create_branch(
 	git_reference **branch,
@@ -280,6 +281,23 @@ static bool should_checkout(
 	return !git_repository_head_unborn(repo);
 }
 
+static int checkout_branch(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature, const char *reflog_message)
+{
+	int error;
+
+	if (branch)
+		error = update_head_to_branch(repo, git_remote_name(remote), branch,
+				signature, reflog_message);
+	/* Point HEAD to the same ref as the remote's head */
+	else
+		error = update_head_to_remote(repo, remote, signature, reflog_message);
+
+	if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts))
+		error = git_checkout_head(repo, co_opts);
+
+	return error;
+}
+
 int git_clone_into(git_repository *repo, git_remote *_remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
 {
 	int error;
@@ -311,15 +329,7 @@ int git_clone_into(git_repository *repo, git_remote *_remote, const git_checkout
 	if ((error = git_remote_fetch(remote, signature, git_buf_cstr(&reflog_message))) != 0)
 		goto cleanup;
 
-	if (branch)
-		error = update_head_to_branch(repo, git_remote_name(remote), branch,
-				signature, git_buf_cstr(&reflog_message));
-	/* Point HEAD to the same ref as the remote's head */
-	else
-		error = update_head_to_remote(repo, remote, signature, git_buf_cstr(&reflog_message));
-
-	if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts))
-		error = git_checkout_head(repo, co_opts);
+	error = checkout_branch(repo, remote, co_opts, branch, signature, git_buf_cstr(&reflog_message));
 
 cleanup:
 	git_remote_free(remote);
@@ -362,8 +372,15 @@ int git_clone(
 		return error;
 
 	if (!(error = create_and_configure_origin(&origin, repo, url, &options))) {
-		error = git_clone_into(
-			repo, origin, &options.checkout_opts, options.checkout_branch, options.signature);
+		if (git__prefixcmp(url, "file://")) {
+			error = git_clone_local_into(
+				repo, origin, &options.checkout_opts,
+				options.checkout_branch, options.signature);
+		} else {
+			error = git_clone_into(
+				repo, origin, &options.checkout_opts,
+				options.checkout_branch, options.signature);
+		}
 
 		git_remote_free(origin);
 	}
@@ -390,3 +407,78 @@ int git_clone_init_options(git_clone_options *opts, unsigned int version)
 		opts, version, git_clone_options, GIT_CLONE_OPTIONS_INIT);
 	return 0;
 }
+
+static const char *repository_base(git_repository *repo)
+{
+	if (git_repository_is_bare(repo))
+		return git_repository_path(repo);
+
+	return git_repository_workdir(repo);
+}
+
+int git_clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
+{
+	int error, root;
+	git_repository *src;
+	git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT;
+	git_buf reflog_message = GIT_BUF_INIT;
+	const char *url;
+
+	assert(repo && remote && co_opts);
+
+	if (!git_repository_is_empty(repo)) {
+		giterr_set(GITERR_INVALID, "the repository is not empty");
+		return -1;
+	}
+
+	/*
+	 * Let's figure out what path we should use for the source
+	 * repo, if it's not rooted, the path should be relative to
+	 * the repository's worktree/gitdir.
+	 */
+	url = git_remote_url(remote);
+	if (!git__prefixcmp(url, "file://"))
+		root = strlen("file://");
+	else
+		root = git_path_root(url);
+
+	if (root >= 0)
+		git_buf_puts(&src_path, url + root);
+	else
+		git_buf_joinpath(&src_path, repository_base(repo), url);
+
+	if (git_buf_oom(&src_path))
+		return -1;
+
+	/* Copy .git/objects/ from the source to the target */
+	if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) {
+		git_buf_free(&src_path);
+		return error;
+	}
+
+	git_buf_joinpath(&src_odb, git_repository_path(src), GIT_OBJECTS_DIR);
+	git_buf_joinpath(&dst_odb, git_repository_path(repo), GIT_OBJECTS_DIR);
+	if (git_buf_oom(&src_odb) || git_buf_oom(&dst_odb)) {
+		error = -1;
+		goto cleanup;
+	}
+
+	if ((error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
+				     0, GIT_OBJECT_DIR_MODE)) < 0)
+		goto cleanup;
+
+	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
+
+	if ((error = git_remote_fetch(remote, signature, git_buf_cstr(&reflog_message))) != 0)
+		goto cleanup;
+
+	error = checkout_branch(repo, remote, co_opts, branch, signature, git_buf_cstr(&reflog_message));
+
+cleanup:
+	git_buf_free(&reflog_message);
+	git_buf_free(&src_path);
+	git_buf_free(&src_odb);
+	git_buf_free(&dst_odb);
+	git_repository_free(src);
+	return error;
+}
-- 
cgit v1.2.3


From a0b5f7854c2302105e1029933df5d94a765cb89f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 22 Dec 2013 15:39:54 +0000
Subject: clone: store the realpath when given a relative one

A call like git_clone("./foo", "./foo1") writes origin's url as './foo',
which makes it unusable, as they're relative to different things.

Go with git's behaviour and store the realpath as the url.
---
 src/clone.c | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/src/clone.c b/src/clone.c
index b66ba6b4c..b6f8c7e85 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -242,6 +242,15 @@ static int create_and_configure_origin(
 	int error;
 	git_remote *origin = NULL;
 	const char *name;
+	char buf[GIT_PATH_MAX];
+
+	/* If the path exists and is a dir, the url should be the absolute path */
+	if (git_path_root(url) < 0 && git_path_exists(url) && git_path_isdir(url)) {
+		if (p_realpath(url, buf) == NULL)
+			return -1;
+
+		url = buf;
+	}
 
 	name = options->remote_name ? options->remote_name : "origin";
 	if ((error = git_remote_create(&origin, repo, name, url)) < 0)
@@ -372,7 +381,7 @@ int git_clone(
 		return error;
 
 	if (!(error = create_and_configure_origin(&origin, repo, url, &options))) {
-		if (git__prefixcmp(url, "file://")) {
+		if (git_path_exists(url) && git_path_isdir(url)) {
 			error = git_clone_local_into(
 				repo, origin, &options.checkout_opts,
 				options.checkout_branch, options.signature);
-- 
cgit v1.2.3


From 121b26738e6a5e6eadeb2a2bc666956ae21cb92b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 23 Dec 2013 11:12:31 +0000
Subject: clone: add flags to override whether to perform a local clone

---
 include/git2/clone.h |  7 +++++++
 src/clone.c          | 25 ++++++++++++++++++++++++-
 src/clone.h          | 12 ++++++++++++
 tests/clone/local.c  | 29 +++++++++++++++++++++++++++++
 4 files changed, 72 insertions(+), 1 deletion(-)
 create mode 100644 src/clone.h
 create mode 100644 tests/clone/local.c

diff --git a/include/git2/clone.h b/include/git2/clone.h
index ceb1a53bb..71e8e72f2 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -23,6 +23,12 @@
  */
 GIT_BEGIN_DECL
 
+typedef enum {
+	GIT_CLONE_LOCAL_AUTO,
+	GIT_CLONE_LOCAL,
+	GIT_CLONE_NO_LOCAL,
+} git_clone_local_t;
+
 /**
  * Clone options structure
  *
@@ -57,6 +63,7 @@ typedef struct git_clone_options {
 
 	int bare;
 	int ignore_cert_errors;
+	git_clone_local_t local;
 	const char *remote_name;
 	const char* checkout_branch;
 	git_signature *signature;
diff --git a/src/clone.c b/src/clone.c
index b6f8c7e85..58430f63a 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -347,6 +347,29 @@ cleanup:
 	return error;
 }
 
+int git_clone__should_clone_local(const char *url, git_clone_local_t local)
+{
+	const char *path;
+	int is_url;
+
+	if (local == GIT_CLONE_NO_LOCAL)
+		return false;
+
+	is_url = !git__prefixcmp(url, "file://");
+
+	if (is_url && local != GIT_CLONE_LOCAL)
+		return false;
+
+	path = url;
+	if (is_url)
+		path = url + strlen("file://");
+
+	if ((git_path_exists(path) && git_path_isdir(path)) && local != GIT_CLONE_NO_LOCAL)
+		return true;
+
+	return false;
+}
+
 int git_clone(
 	git_repository **out,
 	const char *url,
@@ -381,7 +404,7 @@ int git_clone(
 		return error;
 
 	if (!(error = create_and_configure_origin(&origin, repo, url, &options))) {
-		if (git_path_exists(url) && git_path_isdir(url)) {
+		if (git_clone__should_clone_local(url, options.local)) {
 			error = git_clone_local_into(
 				repo, origin, &options.checkout_opts,
 				options.checkout_branch, options.signature);
diff --git a/src/clone.h b/src/clone.h
new file mode 100644
index 000000000..14ca5d44c
--- /dev/null
+++ b/src/clone.h
@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_clone_h__
+#define INCLUDE_clone_h__
+
+extern int git_clone__should_clone_local(const char *url, git_clone_local_t local);
+
+#endif
diff --git a/tests/clone/local.c b/tests/clone/local.c
new file mode 100644
index 000000000..478bbb673
--- /dev/null
+++ b/tests/clone/local.c
@@ -0,0 +1,29 @@
+#include "clar_libgit2.h"
+
+#include "git2/clone.h"
+#include "clone.h"
+#include "buffer.h"
+
+void assert_clone(const char *path, git_clone_local_t opt, int val)
+{
+	cl_assert_equal_i(val, git_clone__should_clone_local(path, opt));
+}
+
+void test_clone_local__should_clone_local(void)
+{
+	git_buf buf = GIT_BUF_INIT;
+	const char *path;
+
+	/* we use a fixture path because it needs to exist for us to want to clone */
+	
+	cl_git_pass(git_buf_printf(&buf, "file://%s", cl_fixture("testrepo.git")));
+	cl_assert_equal_i(false, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_AUTO));
+	cl_assert_equal_i(true,  git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL));
+	cl_assert_equal_i(false, git_clone__should_clone_local(buf.ptr, GIT_CLONE_NO_LOCAL));
+	git_buf_free(&buf);
+
+	path = cl_fixture("testrepo.git");
+	cl_assert_equal_i(true,  git_clone__should_clone_local(path, GIT_CLONE_LOCAL_AUTO));
+	cl_assert_equal_i(true,  git_clone__should_clone_local(path, GIT_CLONE_LOCAL));
+	cl_assert_equal_i(false, git_clone__should_clone_local(path, GIT_CLONE_NO_LOCAL));
+}
-- 
cgit v1.2.3


From c1dbfcbb4a5ca92ae90f1bdb7004edb2eb86284c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 28 May 2014 10:07:23 +0200
Subject: clone: add flag not to link

---
 include/git2/clone.h | 1 +
 src/clone.c          | 2 +-
 tests/clone/local.c  | 2 ++
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/include/git2/clone.h b/include/git2/clone.h
index 71e8e72f2..31bb52ccd 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -27,6 +27,7 @@ typedef enum {
 	GIT_CLONE_LOCAL_AUTO,
 	GIT_CLONE_LOCAL,
 	GIT_CLONE_NO_LOCAL,
+	GIT_CLONE_LOCAL_NO_LINKS,
 } git_clone_local_t;
 
 /**
diff --git a/src/clone.c b/src/clone.c
index 58430f63a..c02ca04b4 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -357,7 +357,7 @@ int git_clone__should_clone_local(const char *url, git_clone_local_t local)
 
 	is_url = !git__prefixcmp(url, "file://");
 
-	if (is_url && local != GIT_CLONE_LOCAL)
+	if (is_url && local != GIT_CLONE_LOCAL && local != GIT_CLONE_LOCAL_NO_LINKS )
 		return false;
 
 	path = url;
diff --git a/tests/clone/local.c b/tests/clone/local.c
index 478bbb673..7b273b23a 100644
--- a/tests/clone/local.c
+++ b/tests/clone/local.c
@@ -19,11 +19,13 @@ void test_clone_local__should_clone_local(void)
 	cl_git_pass(git_buf_printf(&buf, "file://%s", cl_fixture("testrepo.git")));
 	cl_assert_equal_i(false, git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_AUTO));
 	cl_assert_equal_i(true,  git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL));
+	cl_assert_equal_i(true,  git_clone__should_clone_local(buf.ptr, GIT_CLONE_LOCAL_NO_LINKS));
 	cl_assert_equal_i(false, git_clone__should_clone_local(buf.ptr, GIT_CLONE_NO_LOCAL));
 	git_buf_free(&buf);
 
 	path = cl_fixture("testrepo.git");
 	cl_assert_equal_i(true,  git_clone__should_clone_local(path, GIT_CLONE_LOCAL_AUTO));
 	cl_assert_equal_i(true,  git_clone__should_clone_local(path, GIT_CLONE_LOCAL));
+	cl_assert_equal_i(true,  git_clone__should_clone_local(path, GIT_CLONE_LOCAL_NO_LINKS));
 	cl_assert_equal_i(false, git_clone__should_clone_local(path, GIT_CLONE_NO_LOCAL));
 }
-- 
cgit v1.2.3


From 94f742bac60656f4f915711b953814477633b984 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 28 May 2014 10:18:05 +0200
Subject: fileops: allow linking files when copying directory structures

When passed the LINK_FILES flag, the recursive copy will hardlink files
instead of copying them.
---
 src/fileops.c     |  6 ++++--
 src/fileops.h     |  2 ++
 tests/core/copy.c | 26 ++++++++++++++++++++++++++
 3 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/src/fileops.c b/src/fileops.c
index 13b8f6a39..bebbae4f9 100644
--- a/src/fileops.c
+++ b/src/fileops.c
@@ -740,9 +740,11 @@ static int _cp_r_callback(void *ref, git_buf *from)
 		return error;
 
 	/* make symlink or regular file */
-	if (S_ISLNK(from_st.st_mode))
+	if (info->flags & GIT_CPDIR_LINK_FILES) {
+		error = p_link(from->ptr, info->to.ptr);
+	} else if (S_ISLNK(from_st.st_mode)) {
 		error = cp_link(from->ptr, info->to.ptr, (size_t)from_st.st_size);
-	else {
+	} else {
 		mode_t usemode = from_st.st_mode;
 
 		if ((info->flags & GIT_CPDIR_SIMPLE_TO_MODE) != 0)
diff --git a/src/fileops.h b/src/fileops.h
index 62227abae..4f5700a99 100644
--- a/src/fileops.h
+++ b/src/fileops.h
@@ -173,6 +173,7 @@ extern int git_futils_cp(
  * - GIT_CPDIR_SIMPLE_TO_MODE: default tries to replicate the mode of the
  *   source file to the target; with this flag, always use 0666 (or 0777 if
  *   source has exec bits set) for target.
+ * - GIT_CPDIR_LINK_FILES will try to use hardlinks for the files
  */
 typedef enum {
 	GIT_CPDIR_CREATE_EMPTY_DIRS = (1u << 0),
@@ -181,6 +182,7 @@ typedef enum {
 	GIT_CPDIR_OVERWRITE         = (1u << 3),
 	GIT_CPDIR_CHMOD_DIRS        = (1u << 4),
 	GIT_CPDIR_SIMPLE_TO_MODE    = (1u << 5),
+	GIT_CPDIR_LINK_FILES        = (1u << 6),
 } git_futils_cpdir_flags;
 
 /**
diff --git a/tests/core/copy.c b/tests/core/copy.c
index c0c59c056..04b2dfab5 100644
--- a/tests/core/copy.c
+++ b/tests/core/copy.c
@@ -45,6 +45,16 @@ void test_core_copy__file_in_dir(void)
 	cl_assert(!git_path_isdir("an_dir"));
 }
 
+void assert_hard_link(const char *path)
+{
+	/* we assert this by checking that there's more than one link to the file */
+	struct stat st;
+
+	cl_assert(git_path_isfile(path));
+	cl_git_pass(p_stat(path, &st));
+	cl_assert(st.st_nlink > 1);
+}
+
 void test_core_copy__tree(void)
 {
 	struct stat st;
@@ -122,5 +132,21 @@ void test_core_copy__tree(void)
 	cl_git_pass(git_futils_rmdir_r("t2", NULL, GIT_RMDIR_REMOVE_FILES));
 	cl_assert(!git_path_isdir("t2"));
 
+#ifndef GIT_WIN32
+	cl_git_pass(git_futils_cp_r("src", "t3", GIT_CPDIR_CREATE_EMPTY_DIRS | GIT_CPDIR_LINK_FILES, 0));
+	cl_assert(git_path_isdir("t3"));
+
+	cl_assert(git_path_isdir("t3"));
+	cl_assert(git_path_isdir("t3/b"));
+	cl_assert(git_path_isdir("t3/c"));
+	cl_assert(git_path_isdir("t3/c/d"));
+	cl_assert(git_path_isdir("t3/c/e"));
+
+	assert_hard_link("t3/f1");
+	assert_hard_link("t3/b/f2");
+	assert_hard_link("t3/c/f3");
+	assert_hard_link("t3/c/d/f4");
+#endif
+
 	cl_git_pass(git_futils_rmdir_r("src", NULL, GIT_RMDIR_REMOVE_FILES));
 }
-- 
cgit v1.2.3


From 2614819cf3e2163fb831c12c6d793254c78adb3d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 28 May 2014 11:28:57 +0200
Subject: clone: allow for linking in local clone

If requested, git_clone_local_into() will try to link the object files
instead of copying them.

This only works on non-Windows (since it doesn't have this) when both
are on the same filesystem (which are unix semantics).
---
 include/git2/clone.h |  4 ++++
 src/clone.c          | 36 +++++++++++++++++++++++++++-----
 tests/clone/local.c  | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 94 insertions(+), 5 deletions(-)

diff --git a/include/git2/clone.h b/include/git2/clone.h
index 31bb52ccd..b2c944a78 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -144,6 +144,9 @@ GIT_EXTERN(int) git_clone_into(
  * @param co_opts options to use during checkout
  * @param branch the branch to checkout after the clone, pass NULL for the
  *        remote's default branch
+ * @param link wether to use hardlinks instead of copying
+ * objects. This is only possible if both repositories are on the same
+ * filesystem.
  * @param signature the identity used when updating the reflog
  * @return 0 on success, any non-zero return value from a callback
  *         function, or a negative value to indicate an error (use
@@ -154,6 +157,7 @@ GIT_EXTERN(int) git_clone_local_into(
 	git_remote *remote,
 	const git_checkout_options *co_opts,
 	const char *branch,
+	int link,
 	const git_signature *signature);
 
 /** @} */
diff --git a/src/clone.c b/src/clone.c
index c02ca04b4..5aaa94ff6 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -405,9 +405,10 @@ int git_clone(
 
 	if (!(error = create_and_configure_origin(&origin, repo, url, &options))) {
 		if (git_clone__should_clone_local(url, options.local)) {
+			int link = options.local != GIT_CLONE_LOCAL_NO_LINKS;
 			error = git_clone_local_into(
 				repo, origin, &options.checkout_opts,
-				options.checkout_branch, options.signature);
+				options.checkout_branch, link, options.signature);
 		} else {
 			error = git_clone_into(
 				repo, origin, &options.checkout_opts,
@@ -448,15 +449,36 @@ static const char *repository_base(git_repository *repo)
 	return git_repository_workdir(repo);
 }
 
-int git_clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
+static bool can_link(const char *src, const char *dst, int link)
+{
+#ifdef GIT_WIN32
+	return false;
+#else
+
+	struct stat st_src, st_dst;
+
+	if (!link)
+		return false;
+
+	if (p_stat(src, &st_src) < 0)
+		return false;
+
+	if (p_stat(dst, &st_dst) < 0)
+		return false;
+
+	return st_src.st_dev == st_dst.st_dev;
+#endif
+}
+
+int git_clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link, const git_signature *signature)
 {
-	int error, root;
+	int error, root, flags;
 	git_repository *src;
 	git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT;
 	git_buf reflog_message = GIT_BUF_INIT;
 	const char *url;
 
-	assert(repo && remote && co_opts);
+	assert(repo && remote);
 
 	if (!git_repository_is_empty(repo)) {
 		giterr_set(GITERR_INVALID, "the repository is not empty");
@@ -495,8 +517,12 @@ int git_clone_local_into(git_repository *repo, git_remote *remote, const git_che
 		goto cleanup;
 	}
 
+	flags = 0;
+	if (can_link(git_repository_path(src), git_repository_path(repo), link))
+		flags |= GIT_CPDIR_LINK_FILES;
+
 	if ((error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
-				     0, GIT_OBJECT_DIR_MODE)) < 0)
+				     flags, GIT_OBJECT_DIR_MODE)) < 0)
 		goto cleanup;
 
 	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
diff --git a/tests/clone/local.c b/tests/clone/local.c
index 7b273b23a..289c50aaf 100644
--- a/tests/clone/local.c
+++ b/tests/clone/local.c
@@ -3,6 +3,8 @@
 #include "git2/clone.h"
 #include "clone.h"
 #include "buffer.h"
+#include "path.h"
+#include "posix.h"
 
 void assert_clone(const char *path, git_clone_local_t opt, int val)
 {
@@ -29,3 +31,60 @@ void test_clone_local__should_clone_local(void)
 	cl_assert_equal_i(true,  git_clone__should_clone_local(path, GIT_CLONE_LOCAL_NO_LINKS));
 	cl_assert_equal_i(false, git_clone__should_clone_local(path, GIT_CLONE_NO_LOCAL));
 }
+
+void test_clone_local__hardlinks(void)
+{
+	git_repository *repo;
+	git_remote *remote;
+	git_signature *sig;
+	git_buf buf = GIT_BUF_INIT;
+	struct stat st;
+
+	cl_git_pass(git_repository_init(&repo, "./clone.git", true));
+	cl_git_pass(git_remote_create(&remote, repo, "origin", cl_fixture("testrepo.git")));
+	cl_git_pass(git_signature_now(&sig, "foo", "bar"));
+	cl_git_pass(git_clone_local_into(repo, remote, NULL, NULL, true, sig));
+
+	git_remote_free(remote);
+	git_repository_free(repo);
+
+	/*
+	 * We can't rely on the link option taking effect in the first
+	 * clone, since the temp dir and fixtures dir may reside on
+	 * different filesystems. We perform the second clone
+	 * side-by-side to make sure this is the case.
+	 */
+
+	cl_git_pass(git_repository_init(&repo, "./clone2.git", true));
+	cl_git_pass(git_buf_puts(&buf, cl_git_path_url("clone.git")));
+	cl_git_pass(git_remote_create(&remote, repo, "origin", buf.ptr));
+	cl_git_pass(git_clone_local_into(repo, remote, NULL, NULL, true, sig));
+
+#ifndef GIT_WIN32
+	git_buf_clear(&buf);
+	cl_git_pass(git_buf_join_n(&buf, '/', 4, git_repository_path(repo), "objects", "08", "b041783f40edfe12bb406c9c9a8a040177c125"));
+
+	cl_git_pass(p_stat(buf.ptr, &st));
+	cl_assert(st.st_nlink > 1);
+#endif
+
+	git_remote_free(remote);
+	git_repository_free(repo);
+	git_buf_clear(&buf);
+
+	cl_git_pass(git_repository_init(&repo, "./clone3.git", true));
+	cl_git_pass(git_buf_puts(&buf, cl_git_path_url("clone.git")));
+	cl_git_pass(git_remote_create(&remote, repo, "origin", buf.ptr));
+	cl_git_pass(git_clone_local_into(repo, remote, NULL, NULL, false, sig));
+
+	git_buf_clear(&buf);
+	cl_git_pass(git_buf_join_n(&buf, '/', 4, git_repository_path(repo), "objects", "08", "b041783f40edfe12bb406c9c9a8a040177c125"));
+
+	cl_git_pass(p_stat(buf.ptr, &st));
+	cl_assert_equal_i(1, st.st_nlink);
+
+	git_buf_free(&buf);
+	git_signature_free(sig);
+	git_remote_free(remote);
+	git_repository_free(repo);
+}
-- 
cgit v1.2.3


From 33bf1b1ab0e14453e67e94dc6aa679dcdcce56e8 Mon Sep 17 00:00:00 2001
From: Eoin Coffey <ecoffey@gmail.com>
Date: Wed, 28 May 2014 09:40:08 -0600
Subject: examples/log.c: invert filtering impl and conditional

---
 examples/log.c | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/examples/log.c b/examples/log.c
index 965f854d7..d5f75a297 100644
--- a/examples/log.c
+++ b/examples/log.c
@@ -67,8 +67,8 @@ static void print_commit(git_commit *commit);
 static int match_with_parent(git_commit *commit, int i, git_diff_options *);
 
 /** utility functions for filtering */
-static int signature_does_not_match(const git_signature *sig, const char *filter);
-static int log_message_does_not_match(const git_commit *commit, const char *filter);
+static int signature_matches(const git_signature *sig, const char *filter);
+static int log_message_matches(const git_commit *commit, const char *filter);
 
 int main(int argc, char *argv[])
 {
@@ -132,13 +132,13 @@ int main(int argc, char *argv[])
 				continue;
 		}
 
-		if (signature_does_not_match(git_commit_author(commit), opt.author))
+		if (!signature_matches(git_commit_author(commit), opt.author))
 			continue;
 
-		if (signature_does_not_match(git_commit_committer(commit), opt.committer))
+		if (!signature_matches(git_commit_committer(commit), opt.committer))
 			continue;
 
-		if (log_message_does_not_match(commit, opt.grep))
+		if (!log_message_matches(commit, opt.grep))
 			continue;
 
 		if (count++ < opt.skip)
@@ -186,26 +186,26 @@ int main(int argc, char *argv[])
 }
 
 /** Determine if the given git_signature does not contain the filter text. */
-static int signature_does_not_match(const git_signature *sig, const char *filter) {
+static int signature_matches(const git_signature *sig, const char *filter) {
 	if (filter == NULL)
-		return 0;
+		return 1;
 
-	if (sig == NULL ||
-		(strstr(sig->name, filter) == NULL &&
-		strstr(sig->email, filter) == NULL))
+	if (sig != NULL &&
+		(strstr(sig->name, filter) != NULL ||
+		strstr(sig->email, filter) != NULL))
 		return 1;
 
 	return 0;
 }
 
-static int log_message_does_not_match(const git_commit *commit, const char *filter) {
+static int log_message_matches(const git_commit *commit, const char *filter) {
 	const char *message = NULL;
 
 	if (filter == NULL)
-		return 0;
+		return 1;
 
-	if ((message = git_commit_message(commit)) == NULL ||
-		strstr(message, filter) == NULL)
+	if ((message = git_commit_message(commit)) != NULL &&
+		strstr(message, filter) != NULL)
 		return 1;
 
 	return 0;
-- 
cgit v1.2.3


From fda73bc5fd9f118c661e963f5c50f5c87df2364c Mon Sep 17 00:00:00 2001
From: Ungureanu Marius <teromario@yahoo.com>
Date: Wed, 28 May 2014 22:57:21 +0300
Subject: [Blob] Update documentation for is_binary.

filter.h tells me that we check the first 8000 bytes.
---
 include/git2/blob.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/git2/blob.h b/include/git2/blob.h
index 1b6583309..c24ff7e7f 100644
--- a/include/git2/blob.h
+++ b/include/git2/blob.h
@@ -210,7 +210,7 @@ GIT_EXTERN(int) git_blob_create_frombuffer(
  *
  * The heuristic used to guess if a file is binary is taken from core git:
  * Searching for NUL bytes and looking for a reasonable ratio of printable
- * to non-printable characters among the first 4000 bytes.
+ * to non-printable characters among the first 8000 bytes.
  *
  * @param blob The blob which content should be analyzed
  * @return 1 if the content of the blob is detected
-- 
cgit v1.2.3


From bc9f67fa8524a8bcf343af6a721f57b52334810b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 29 May 2014 10:03:04 +0200
Subject: clone: more explicit local tests

Assert the exact amount of links we expect. While there, check that a
plain git_clone() automatically chooses to link.
---
 tests/clone/local.c | 43 +++++++++++++++++++++++++++++--------------
 1 file changed, 29 insertions(+), 14 deletions(-)

diff --git a/tests/clone/local.c b/tests/clone/local.c
index 289c50aaf..a4406c1cc 100644
--- a/tests/clone/local.c
+++ b/tests/clone/local.c
@@ -5,11 +5,7 @@
 #include "buffer.h"
 #include "path.h"
 #include "posix.h"
-
-void assert_clone(const char *path, git_clone_local_t opt, int val)
-{
-	cl_assert_equal_i(val, git_clone__should_clone_local(path, opt));
-}
+#include "fileops.h"
 
 void test_clone_local__should_clone_local(void)
 {
@@ -40,20 +36,21 @@ void test_clone_local__hardlinks(void)
 	git_buf buf = GIT_BUF_INIT;
 	struct stat st;
 
+
+	/*
+	 * In this first clone, we just copy over, since the temp dir
+	 * will often be in a different filesystem, so we cannot
+	 * link. It also allows us to control the number of links
+	 */
 	cl_git_pass(git_repository_init(&repo, "./clone.git", true));
 	cl_git_pass(git_remote_create(&remote, repo, "origin", cl_fixture("testrepo.git")));
 	cl_git_pass(git_signature_now(&sig, "foo", "bar"));
-	cl_git_pass(git_clone_local_into(repo, remote, NULL, NULL, true, sig));
+	cl_git_pass(git_clone_local_into(repo, remote, NULL, NULL, false, sig));
 
 	git_remote_free(remote);
 	git_repository_free(repo);
 
-	/*
-	 * We can't rely on the link option taking effect in the first
-	 * clone, since the temp dir and fixtures dir may reside on
-	 * different filesystems. We perform the second clone
-	 * side-by-side to make sure this is the case.
-	 */
+	/* This second clone is in the same filesystem, so we can hardlink */
 
 	cl_git_pass(git_repository_init(&repo, "./clone2.git", true));
 	cl_git_pass(git_buf_puts(&buf, cl_git_path_url("clone.git")));
@@ -65,7 +62,7 @@ void test_clone_local__hardlinks(void)
 	cl_git_pass(git_buf_join_n(&buf, '/', 4, git_repository_path(repo), "objects", "08", "b041783f40edfe12bb406c9c9a8a040177c125"));
 
 	cl_git_pass(p_stat(buf.ptr, &st));
-	cl_assert(st.st_nlink > 1);
+	cl_assert_equal_i(2, st.st_nlink);
 #endif
 
 	git_remote_free(remote);
@@ -83,8 +80,26 @@ void test_clone_local__hardlinks(void)
 	cl_git_pass(p_stat(buf.ptr, &st));
 	cl_assert_equal_i(1, st.st_nlink);
 
+	git_remote_free(remote);
+	git_repository_free(repo);
+
+	/* this one should automatically use links */
+	cl_git_pass(git_clone(&repo, "./clone.git", "./clone4.git", NULL));
+
+#ifndef GIT_WIN32
+	git_buf_clear(&buf);
+	cl_git_pass(git_buf_join_n(&buf, '/', 4, git_repository_path(repo), "objects", "08", "b041783f40edfe12bb406c9c9a8a040177c125"));
+
+	cl_git_pass(p_stat(buf.ptr, &st));
+	cl_assert_equal_i(3, st.st_nlink);
+#endif
+
 	git_buf_free(&buf);
 	git_signature_free(sig);
-	git_remote_free(remote);
 	git_repository_free(repo);
+
+	cl_git_pass(git_futils_rmdir_r("./clone.git", NULL, GIT_RMDIR_REMOVE_FILES));
+	cl_git_pass(git_futils_rmdir_r("./clone2.git", NULL, GIT_RMDIR_REMOVE_FILES));
+	cl_git_pass(git_futils_rmdir_r("./clone3.git", NULL, GIT_RMDIR_REMOVE_FILES));
+	cl_git_pass(git_futils_rmdir_r("./clone4.git", NULL, GIT_RMDIR_REMOVE_FILES));
 }
-- 
cgit v1.2.3


From 5f0527aeac65b10b0df9034f5763865d253daf75 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 30 May 2014 13:06:34 +0200
Subject: config: initialize the error

The error would be uninitialized if we take a snapshot of a config with
no backends.
---
 src/config.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/config.c b/src/config.c
index 4bd27a875..8a0fb653c 100644
--- a/src/config.c
+++ b/src/config.c
@@ -139,7 +139,7 @@ int git_config_open_ondisk(git_config **out, const char *path)
 
 int git_config_snapshot(git_config **out, git_config *in)
 {
-	int error;
+	int error = 0;
 	size_t i;
 	file_internal *internal;
 	git_config *config;
-- 
cgit v1.2.3


From 68f9d6b2833774c279964790eda97363225e09a7 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Thu, 15 May 2014 22:44:50 +0200
Subject: Refs: Fix some issue when core.precomposeunicode = true.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This fixes two issues I found when core.precomposeunicode is enabled:

* When creating a reference with a NFD string, the returned
  git_reference would return this NFD string as the reference’s
  name. But when looking up the reference later, the name would
  then be returned as NFC string.
* Renaming a reference would not honor the core.precomposeunicode and
  apply no normalization to the new reference name.
---
 src/refs.c | 33 +++++++++------------------------
 src/refs.h |  1 -
 2 files changed, 9 insertions(+), 25 deletions(-)

diff --git a/src/refs.c b/src/refs.c
index 9428f617d..adbabb452 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -365,7 +365,7 @@ static int reference__create(
 	if (ref_out)
 		*ref_out = NULL;
 
-	error = git_reference__normalize_name_lax(normalized, sizeof(normalized), name);
+	error = reference_normalize_for_repo(normalized, sizeof(normalized), repo, name);
 	if (error < 0)
 		return error;
 
@@ -388,15 +388,15 @@ static int reference__create(
 			return -1;
 		}
 
-		ref = git_reference__alloc(name, oid, NULL);
+		ref = git_reference__alloc(normalized, oid, NULL);
 	} else {
 		char normalized_target[GIT_REFNAME_MAX];
 
-		if ((error = git_reference__normalize_name_lax(
-			normalized_target, sizeof(normalized_target), symbolic)) < 0)
+		if ((error = reference_normalize_for_repo(
+			normalized_target, sizeof(normalized_target), repo, symbolic)) < 0)
 			return error;
 
-		ref = git_reference__alloc_symbolic(name, normalized_target);
+		ref = git_reference__alloc_symbolic(normalized, normalized_target);
 	}
 
 	GITERR_CHECK_ALLOC(ref);
@@ -569,18 +569,14 @@ int git_reference_symbolic_set_target(
 static int reference__rename(git_reference **out, git_reference *ref, const char *new_name, int force,
 				 const git_signature *signature, const char *message)
 {
-	unsigned int normalization_flags;
 	char normalized[GIT_REFNAME_MAX];
 	bool should_head_be_updated = false;
 	int error = 0;
 
 	assert(ref && new_name && signature);
 
-	normalization_flags = ref->type == GIT_REF_SYMBOLIC ?
-		GIT_REF_FORMAT_ALLOW_ONELEVEL : GIT_REF_FORMAT_NORMAL;
-
-	if ((error = git_reference_normalize_name(
-			normalized, sizeof(normalized), new_name, normalization_flags)) < 0)
+	if ((error = reference_normalize_for_repo(
+			normalized, sizeof(normalized), git_reference_owner(ref), new_name)) < 0)
 		return error;
 
 
@@ -590,12 +586,12 @@ static int reference__rename(git_reference **out, git_reference *ref, const char
 
 	should_head_be_updated = (error > 0);
 
-	if ((error = git_refdb_rename(out, ref->db, ref->name, new_name, force, signature, message)) < 0)
+	if ((error = git_refdb_rename(out, ref->db, ref->name, normalized, force, signature, message)) < 0)
 		return error;
 
 	/* Update HEAD it was pointing to the reference being renamed */
 	if (should_head_be_updated &&
-		(error = git_repository_set_head(ref->db->repo, new_name, signature, message)) < 0) {
+		(error = git_repository_set_head(ref->db->repo, normalized, signature, message)) < 0) {
 		giterr_set(GITERR_REFERENCE, "Failed to update HEAD after renaming reference");
 		return error;
 	}
@@ -1018,17 +1014,6 @@ cleanup:
 	return error;
 }
 
-int git_reference__normalize_name_lax(
-	char *buffer_out,
-	size_t out_size,
-	const char *name)
-{
-	return git_reference_normalize_name(
-		buffer_out,
-		out_size,
-		name,
-		GIT_REF_FORMAT_ALLOW_ONELEVEL);
-}
 #define GIT_REF_TYPEMASK (GIT_REF_OID | GIT_REF_SYMBOLIC)
 
 int git_reference_cmp(
diff --git a/src/refs.h b/src/refs.h
index d57d67026..7337e2a48 100644
--- a/src/refs.h
+++ b/src/refs.h
@@ -66,7 +66,6 @@ struct git_reference {
 
 git_reference *git_reference__set_name(git_reference *ref, const char *name);
 
-int git_reference__normalize_name_lax(char *buffer_out, size_t out_size, const char *name);
 int git_reference__normalize_name(git_buf *buf, const char *name, unsigned int flags);
 int git_reference__update_terminal(git_repository *repo, const char *ref_name, const git_oid *oid, const git_signature *signature, const char *log_message);
 int git_reference__is_valid_name(const char *refname, unsigned int flags);
-- 
cgit v1.2.3


From 824f755f101525d60adb7a73b407880c4aaec950 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Tue, 20 May 2014 17:31:53 +0200
Subject: Refs: Introduce `git_refname_t`.

---
 src/refs.c | 23 ++++++++++-------------
 src/refs.h |  2 ++
 2 files changed, 12 insertions(+), 13 deletions(-)

diff --git a/src/refs.c b/src/refs.c
index adbabb452..1603876da 100644
--- a/src/refs.c
+++ b/src/refs.c
@@ -159,8 +159,7 @@ int git_reference_name_to_id(
 }
 
 static int reference_normalize_for_repo(
-	char *out,
-	size_t out_size,
+	git_refname_t out,
 	git_repository *repo,
 	const char *name)
 {
@@ -171,7 +170,7 @@ static int reference_normalize_for_repo(
 		precompose)
 		flags |= GIT_REF_FORMAT__PRECOMPOSE_UNICODE;
 
-	return git_reference_normalize_name(out, out_size, name, flags);
+	return git_reference_normalize_name(out, GIT_REFNAME_MAX, name, flags);
 }
 
 int git_reference_lookup_resolved(
@@ -180,7 +179,7 @@ int git_reference_lookup_resolved(
 	const char *name,
 	int max_nesting)
 {
-	char scan_name[GIT_REFNAME_MAX];
+	git_refname_t scan_name;
 	git_ref_t scan_type;
 	int error = 0, nesting;
 	git_reference *ref = NULL;
@@ -197,8 +196,7 @@ int git_reference_lookup_resolved(
 
 	scan_type = GIT_REF_SYMBOLIC;
 
-	if ((error = reference_normalize_for_repo(
-			scan_name, sizeof(scan_name), repo, name)) < 0)
+	if ((error = reference_normalize_for_repo(scan_name, repo, name)) < 0)
 		return error;
 
 	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
@@ -354,7 +352,7 @@ static int reference__create(
 	const git_oid *old_id,
 	const char *old_target)
 {
-	char normalized[GIT_REFNAME_MAX];
+	git_refname_t normalized;
 	git_refdb *refdb;
 	git_reference *ref = NULL;
 	int error = 0;
@@ -365,7 +363,7 @@ static int reference__create(
 	if (ref_out)
 		*ref_out = NULL;
 
-	error = reference_normalize_for_repo(normalized, sizeof(normalized), repo, name);
+	error = reference_normalize_for_repo(normalized, repo, name);
 	if (error < 0)
 		return error;
 
@@ -390,10 +388,9 @@ static int reference__create(
 
 		ref = git_reference__alloc(normalized, oid, NULL);
 	} else {
-		char normalized_target[GIT_REFNAME_MAX];
+		git_refname_t normalized_target;
 
-		if ((error = reference_normalize_for_repo(
-			normalized_target, sizeof(normalized_target), repo, symbolic)) < 0)
+		if ((error = reference_normalize_for_repo(normalized_target, repo, symbolic)) < 0)
 			return error;
 
 		ref = git_reference__alloc_symbolic(normalized, normalized_target);
@@ -569,14 +566,14 @@ int git_reference_symbolic_set_target(
 static int reference__rename(git_reference **out, git_reference *ref, const char *new_name, int force,
 				 const git_signature *signature, const char *message)
 {
-	char normalized[GIT_REFNAME_MAX];
+	git_refname_t normalized;
 	bool should_head_be_updated = false;
 	int error = 0;
 
 	assert(ref && new_name && signature);
 
 	if ((error = reference_normalize_for_repo(
-			normalized, sizeof(normalized), git_reference_owner(ref), new_name)) < 0)
+			normalized, git_reference_owner(ref), new_name)) < 0)
 		return error;
 
 
diff --git a/src/refs.h b/src/refs.h
index 7337e2a48..f75a4bf7e 100644
--- a/src/refs.h
+++ b/src/refs.h
@@ -51,6 +51,8 @@
 
 #define GIT_REFNAME_MAX 1024
 
+typedef char git_refname_t[GIT_REFNAME_MAX];
+
 struct git_reference {
 	git_refdb *db;
 	git_ref_t type;
-- 
cgit v1.2.3


From 1a90b1e3f106139f75183ef21dd5b461d9d83f1d Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Fri, 30 May 2014 14:53:28 +0200
Subject: Refs: Add a unicode test for git_branch_move.

This tests that decomposed branch names are correctly precomposed when
passed to `git_branch_move` and `core.precomposeunicode` is enabled.
---
 tests/refs/branches/move.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/tests/refs/branches/move.c b/tests/refs/branches/move.c
index 6c6dbbe21..f136b00d6 100644
--- a/tests/refs/branches/move.c
+++ b/tests/refs/branches/move.c
@@ -241,3 +241,20 @@ void test_refs_branches_move__default_reflog_message(void)
 	git_reflog_free(log);
 	git_signature_free(sig);
 }
+
+void test_refs_branches_move__can_move_with_unicode(void)
+{
+	git_reference *original_ref, *new_ref;
+	const char *new_branch_name = "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D";
+
+	cl_git_pass(git_reference_lookup(&original_ref, repo, "refs/heads/br2"));
+	cl_git_pass(git_branch_move(&new_ref, original_ref, new_branch_name, 0, NULL, NULL));
+
+	if (cl_repo_get_bool(repo, "core.precomposeunicode"))
+		cl_assert_equal_s(GIT_REFS_HEADS_DIR "\xC3\x85\x73\x74\x72\xC3\xB6\x6D", git_reference_name(new_ref));
+	else
+		cl_assert_equal_s(GIT_REFS_HEADS_DIR "\x41\xCC\x8A\x73\x74\x72\x6F\xCC\x88\x6D", git_reference_name(new_ref));
+
+	git_reference_free(original_ref);
+	git_reference_free(new_ref);
+}
-- 
cgit v1.2.3


From 9d6c3d2853901f2fba049ba80cadb71caa8535c1 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Fri, 30 May 2014 15:15:54 +0200
Subject: Refs: Extend unicode test for branch creation.

This adds another assertion to ensure that the reference name inside
the git_reference struct returned by `git_branch_create` is returned as
precomposed if `core.precomposeunicode` is enabled.
---
 tests/refs/branches/create.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/refs/branches/create.c b/tests/refs/branches/create.c
index 864640ab3..3a4f33b6e 100644
--- a/tests/refs/branches/create.c
+++ b/tests/refs/branches/create.c
@@ -179,11 +179,14 @@ void test_refs_branches_create__can_create_branch_with_unicode(void)
 		expected[0] = nfd;
 
 	for (i = 0; i < ARRAY_SIZE(names); ++i) {
+		const char *name;
 		cl_git_pass(git_branch_create(
 			&branch, repo, names[i], target, 0, NULL, NULL));
 		cl_git_pass(git_oid_cmp(
 			git_reference_target(branch), git_commit_id(target)));
 
+		cl_git_pass(git_branch_name(&name, branch));
+		cl_assert_equal_s(expected[i], name);
 		assert_branch_matches_name(expected[i], names[i]);
 		if (fs_decompose_unicode && alt[i])
 			assert_branch_matches_name(expected[i], alt[i]);
-- 
cgit v1.2.3


From 49837fd49fb9de999be5add82a12bf6332d4703f Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@microsoft.com>
Date: Fri, 30 May 2014 11:30:53 -0500
Subject: Ignore core.safecrlf=warn until we have a warn infrastructure

---
 src/config_cache.c  |  8 +++++++-
 tests/filter/crlf.c | 41 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 48 insertions(+), 1 deletion(-)

diff --git a/src/config_cache.c b/src/config_cache.c
index dca9976f8..45c39ce17 100644
--- a/src/config_cache.c
+++ b/src/config_cache.c
@@ -51,6 +51,12 @@ static git_cvar_map _cvar_map_autocrlf[] = {
 	{GIT_CVAR_STRING, "input", GIT_AUTO_CRLF_INPUT}
 };
 
+static git_cvar_map _cvar_map_safecrlf[] = {
+	{GIT_CVAR_FALSE, NULL, GIT_SAFE_CRLF_FALSE},
+	{GIT_CVAR_TRUE, NULL, GIT_SAFE_CRLF_FAIL},
+	{GIT_CVAR_STRING, "warn", GIT_SAFE_CRLF_WARN}
+};
+
 /*
  * Generic map for integer values
  */
@@ -68,7 +74,7 @@ static struct map_data _cvar_maps[] = {
 	{"core.trustctime", NULL, 0, GIT_TRUSTCTIME_DEFAULT },
 	{"core.abbrev", _cvar_map_int, 1, GIT_ABBREV_DEFAULT },
 	{"core.precomposeunicode", NULL, 0, GIT_PRECOMPOSE_DEFAULT },
-	{"core.safecrlf", NULL, 0, GIT_SAFE_CRLF_DEFAULT},
+	{"core.safecrlf", _cvar_map_safecrlf, ARRAY_SIZE(_cvar_map_safecrlf), GIT_SAFE_CRLF_DEFAULT},
 	{"core.logallrefupdates", NULL, 0, GIT_LOGALLREFUPDATES_DEFAULT },
 };
 
diff --git a/tests/filter/crlf.c b/tests/filter/crlf.c
index 334b1e349..a31dac965 100644
--- a/tests/filter/crlf.c
+++ b/tests/filter/crlf.c
@@ -196,3 +196,44 @@ void test_filter_crlf__no_safecrlf(void)
 	git_buf_free(&out);
 }
 
+void test_filter_crlf__safecrlf_warn(void)
+{
+	git_filter_list *fl;
+	git_filter *crlf;
+	git_buf in = {0}, out = GIT_BUF_INIT;
+
+	cl_repo_set_string(g_repo, "core.safecrlf", "warn");
+
+	cl_git_pass(git_filter_list_new(
+		&fl, g_repo, GIT_FILTER_TO_ODB, 0));
+
+	crlf = git_filter_lookup(GIT_FILTER_CRLF);
+	cl_assert(crlf != NULL);
+
+	cl_git_pass(git_filter_list_push(fl, crlf, NULL));
+
+	/* Normalized \r\n succeeds with safecrlf=warn */
+	in.ptr = "Normal\r\nCRLF\r\nline-endings.\r\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_s("Normal\nCRLF\nline-endings.\n", out.ptr);
+
+	/* Mix of line endings succeeds with safecrlf=warn */
+	in.ptr = "Mixed\nup\r\nLF\nand\r\nCRLF\nline-endings.\r\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	/* TODO: check for warning */
+	cl_assert_equal_s("Mixed\nup\nLF\nand\nCRLF\nline-endings.\n", out.ptr);
+
+	/* Normalized \n is reversible, so does not fail with safecrlf=warn */
+	in.ptr = "Normal\nLF\nonly\nline-endings.\n";
+	in.size = strlen(in.ptr);
+
+	cl_git_pass(git_filter_list_apply_to_data(&out, fl, &in));
+	cl_assert_equal_s(in.ptr, out.ptr);
+
+	git_filter_list_free(fl);
+	git_buf_free(&out);
+}
-- 
cgit v1.2.3


From d723dbed0c46ddb2fb037c63cc13a6131c3824b8 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <schreiber.arthur@googlemail.com>
Date: Fri, 30 May 2014 19:26:49 +0200
Subject: Remote: Set an error when a remote cannot be found.

Inside `git_remote_load`, the calls to `get_optional_config` use
`giterr_clear` to unset any errors that are set due to missing config
keys. If neither a fetch nor a push url config was found for a remote,
we should set an error again.
---
 src/remote.c                   | 1 +
 tests/network/remote/remotes.c | 9 +++++++++
 2 files changed, 10 insertions(+)

diff --git a/src/remote.c b/src/remote.c
index f2e2e2f7a..abcf55e3d 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -403,6 +403,7 @@ int git_remote_load(git_remote **out, git_repository *repo, const char *name)
 
 	if (!optional_setting_found) {
 		error = GIT_ENOTFOUND;
+		giterr_set(GITERR_CONFIG, "Remote '%s' does not exist.", name);
 		goto cleanup;
 	}
 
diff --git a/tests/network/remote/remotes.c b/tests/network/remote/remotes.c
index 306ccaee5..333b52a5b 100644
--- a/tests/network/remote/remotes.c
+++ b/tests/network/remote/remotes.c
@@ -60,6 +60,15 @@ void test_network_remote_remotes__pushurl(void)
 	cl_assert(git_remote_pushurl(_remote) == NULL);
 }
 
+void test_network_remote_remotes__error_when_not_found(void)
+{
+	git_remote *r;
+	cl_git_fail_with(git_remote_load(&r, _repo, "does-not-exist"), GIT_ENOTFOUND);
+
+	cl_assert(giterr_last() != NULL);
+	cl_assert(giterr_last()->klass == GITERR_CONFIG);
+}
+
 void test_network_remote_remotes__error_when_no_push_available(void)
 {
 	git_remote *r;
-- 
cgit v1.2.3


From 947a58c17557d634f16f7efc547b5b236575a3b9 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Fri, 30 May 2014 13:19:49 -0700
Subject: Clean up the handling of large binary diffs

---
 src/diff_print.c | 86 +++++++++++++++++++++++++++++++-------------------------
 src/util.h       |  7 +++++
 2 files changed, 55 insertions(+), 38 deletions(-)

diff --git a/src/diff_print.c b/src/diff_print.c
index 26753515b..72fe69482 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -286,50 +286,46 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 {
 	git_buf deflate = GIT_BUF_INIT, delta = GIT_BUF_INIT, *out = NULL;
 	const void *old_data, *new_data;
-	git_off_t off_t_old_data_len, off_t_new_data_len;
-	unsigned long old_data_len, new_data_len, delta_data_len, inflated_len;
-	size_t remain;
+	git_off_t old_data_len, new_data_len;
+	unsigned long delta_data_len, inflated_len;
 	const char *out_type = "literal";
-	char *ptr;
+	char *scan, *end;
 	int error;
 
 	old_data = old ? git_blob_rawcontent(old) : NULL;
 	new_data = new ? git_blob_rawcontent(new) : NULL;
 
-	off_t_old_data_len = old ? git_blob_rawsize(old) : 0;
-	off_t_new_data_len = new ? git_blob_rawsize(new) : 0;
+	old_data_len = old ? git_blob_rawsize(old) : 0;
+	new_data_len = new ? git_blob_rawsize(new) : 0;
 
-	/* The git_delta function accepts unsigned long only */
-	if (off_t_old_data_len > ULONG_MAX || off_t_new_data_len > ULONG_MAX) {
-		error = -1;
+	if (!git__is_ulong(old_data_len) || !git__is_ulong(new_data_len)) {
+		error = GIT_EBUFS;
 		goto done;
 	}
 
-	old_data_len = (unsigned long)off_t_old_data_len;
-	new_data_len = (unsigned long)off_t_new_data_len;
-
 	out = &deflate;
-	inflated_len = new_data_len;
+	inflated_len = (unsigned long)new_data_len;
 
-	if ((error = git_zstream_deflatebuf(
-		&deflate, new_data, new_data_len)) < 0)
+	if ((error = git_zstream_deflatebuf(out, new_data, (size_t)new_data_len)) < 0)
 		goto done;
 
 	/* The git_delta function accepts unsigned long only */
-	if (deflate.size > ULONG_MAX) {
-		error = -1;
+	if (!git__is_ulong((git_off_t)deflate.size)) {
+		error = GIT_EBUFS;
 		goto done;
 	}
 
 	if (old && new) {
-		void *delta_data;
-
-		delta_data = git_delta(old_data, old_data_len, new_data,
-			new_data_len, &delta_data_len, (unsigned long)deflate.size);
+		void *delta_data = git_delta(
+			old_data, (unsigned long)old_data_len,
+			new_data, (unsigned long)new_data_len,
+			&delta_data_len, (unsigned long)deflate.size);
 
 		if (delta_data) {
-			error = git_zstream_deflatebuf(&delta, delta_data, delta_data_len);
-			free(delta_data);
+			error = git_zstream_deflatebuf(
+				&delta, delta_data, (size_t)delta_data_len);
+
+			git__free(delta_data);
 
 			if (error < 0)
 				goto done;
@@ -345,15 +341,17 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 	git_buf_printf(pi->buf, "%s %lu\n", out_type, inflated_len);
 	pi->line.num_lines++;
 
-	for (ptr = out->ptr, remain = out->size; remain > 0; ) {
-		size_t chunk_len = (52 < remain) ? 52 : remain;
+	for (scan = out->ptr, end = out->ptr + out->size; scan < end; ) {
+		size_t chunk_len = end - scan;
+		if (chunk_len > 52)
+			chunk_len = 52;
 
 		if (chunk_len <= 26)
 			git_buf_putc(pi->buf, (char)chunk_len + 'A' - 1);
 		else
 			git_buf_putc(pi->buf, (char)chunk_len - 26 + 'a' - 1);
 
-		git_buf_put_base85(pi->buf, ptr, chunk_len);
+		git_buf_put_base85(pi->buf, scan, chunk_len);
 		git_buf_putc(pi->buf, '\n');
 
 		if (git_buf_oom(pi->buf)) {
@@ -361,8 +359,7 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 			goto done;
 		}
 
-		ptr += chunk_len;
-		remain -= chunk_len;
+		scan += chunk_len;
 		pi->line.num_lines++;
 	}
 
@@ -381,26 +378,33 @@ static int diff_print_patch_file_binary(
 	git_blob *old = NULL, *new = NULL;
 	const git_oid *old_id, *new_id;
 	int error;
+	size_t pre_binary_size;
 
-	if ((pi->flags & GIT_DIFF_SHOW_BINARY) == 0) {
-		pi->line.num_lines = 1;
-		return diff_delta_format_with_paths(
-			pi->buf, delta, oldpfx, newpfx,
-				"Binary files %s%s and %s%s differ\n");
-	}
+	if ((pi->flags & GIT_DIFF_SHOW_BINARY) == 0)
+		goto noshow;
 
+	pre_binary_size = pi->buf->size;
 	git_buf_printf(pi->buf, "GIT binary patch\n");
 	pi->line.num_lines++;
 
 	old_id = (delta->status != GIT_DELTA_ADDED) ? &delta->old_file.id : NULL;
 	new_id = (delta->status != GIT_DELTA_DELETED) ? &delta->new_file.id : NULL;
 
-	if ((old_id && (error = git_blob_lookup(&old, pi->diff->repo, old_id)) < 0) ||
-		(new_id && (error = git_blob_lookup(&new, pi->diff->repo,new_id)) < 0) ||
-		(error = print_binary_hunk(pi, old, new)) < 0 ||
+	if (old_id && (error = git_blob_lookup(&old, pi->diff->repo, old_id)) < 0)
+		goto done;
+	if (new_id && (error = git_blob_lookup(&new, pi->diff->repo,new_id)) < 0)
+		goto done;
+
+	if ((error = print_binary_hunk(pi, old, new)) < 0 ||
 		(error = git_buf_putc(pi->buf, '\n')) < 0 ||
 		(error = print_binary_hunk(pi, new, old)) < 0)
-		goto done;
+	{
+		if (error == GIT_EBUFS) {
+			giterr_clear();
+			git_buf_truncate(pi->buf, pre_binary_size);
+			goto noshow;
+		}
+	}
 
 	pi->line.num_lines++;
 
@@ -409,6 +413,12 @@ done:
 	git_blob_free(new);
 
 	return error;
+
+noshow:
+	pi->line.num_lines = 1;
+	return diff_delta_format_with_paths(
+		pi->buf, delta, oldpfx, newpfx,
+		"Binary files %s%s and %s%s differ\n");
 }
 
 static int diff_print_patch_file(
diff --git a/src/util.h b/src/util.h
index 6fb2dc0f4..ca676c039 100644
--- a/src/util.h
+++ b/src/util.h
@@ -133,6 +133,13 @@ GIT_INLINE(int) git__is_uint32(size_t p)
 	return p == (size_t)r;
 }
 
+/** @return true if p fits into the range of an unsigned long */
+GIT_INLINE(int) git__is_ulong(git_off_t p)
+{
+	unsigned long r = (unsigned long)p;
+	return p == (git_off_t)r;
+}
+
 /* 32-bit cross-platform rotl */
 #ifdef _MSC_VER /* use built-in method in MSVC */
 #	define git__rotl(v, s) (uint32_t)_rotl(v, s)
-- 
cgit v1.2.3


From bc81220dfcf3419085c545b4a271aa04178c6960 Mon Sep 17 00:00:00 2001
From: Russell Belfer <rb@github.com>
Date: Sat, 31 May 2014 10:19:55 -0700
Subject: minor cleanups

---
 src/diff_print.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/diff_print.c b/src/diff_print.c
index 72fe69482..bb925ef98 100644
--- a/src/diff_print.c
+++ b/src/diff_print.c
@@ -298,15 +298,15 @@ static int print_binary_hunk(diff_print_info *pi, git_blob *old, git_blob *new)
 	old_data_len = old ? git_blob_rawsize(old) : 0;
 	new_data_len = new ? git_blob_rawsize(new) : 0;
 
-	if (!git__is_ulong(old_data_len) || !git__is_ulong(new_data_len)) {
-		error = GIT_EBUFS;
-		goto done;
-	}
+	/* The git_delta function accepts unsigned long only */
+	if (!git__is_ulong(old_data_len) || !git__is_ulong(new_data_len))
+		return GIT_EBUFS;
 
 	out = &deflate;
 	inflated_len = (unsigned long)new_data_len;
 
-	if ((error = git_zstream_deflatebuf(out, new_data, (size_t)new_data_len)) < 0)
+	if ((error = git_zstream_deflatebuf(
+			out, new_data, (size_t)new_data_len)) < 0)
 		goto done;
 
 	/* The git_delta function accepts unsigned long only */
-- 
cgit v1.2.3


From 8a9419aae185204c9f727285643ab99b1b968610 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 1 Jun 2014 02:16:07 +0200
Subject: remote: build up the list of refs to remove

When removing the remote-tracking branches, build up the list and remove
in two steps, working around an issue with the iterator. Removing while
we're iterating over the refs can cause us to miss references.
---
 src/remote.c | 42 ++++++++++++++++++++++++++++++++++--------
 1 file changed, 34 insertions(+), 8 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index f2e2e2f7a..b56bf3b24 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1809,24 +1809,50 @@ static int remove_branch_config_related_entries(
 	return error;
 }
 
-static int remove_refs(git_repository *repo, const char *glob)
+static int remove_refs(git_repository *repo, const git_refspec *spec)
 {
-	git_reference_iterator *iter;
+	git_reference_iterator *iter = NULL;
+	git_vector refs;
 	const char *name;
+	char *dup;
 	int error;
+	size_t i;
 
-	if ((error = git_reference_iterator_glob_new(&iter, repo, glob)) < 0)
+	if ((error = git_vector_init(&refs, 8, NULL)) < 0)
 		return error;
 
+	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
+		goto cleanup;
+
 	while ((error = git_reference_next_name(&name, iter)) == 0) {
-		if ((error = git_reference_remove(repo, name)) < 0)
-			break;
-	}
-	git_reference_iterator_free(iter);
+		if (!git_refspec_dst_matches(spec, name))
+			continue;
+
+		dup = git__strdup(name);
+		if (!dup) {
+			error = -1;
+			goto cleanup;
+		}
 
+		if ((error = git_vector_insert(&refs, dup)) < 0)
+			goto cleanup;
+	}
 	if (error == GIT_ITEROVER)
 		error = 0;
+	if (error < 0)
+		goto cleanup;
+
+	git_vector_foreach(&refs, i, name) {
+		if ((error = git_reference_remove(repo, name)) < 0)
+			break;
+	}
 
+cleanup:
+	git_reference_iterator_free(iter);
+	git_vector_foreach(&refs, i, dup) {
+		git__free(dup);
+	}
+	git_vector_free(&refs);
 	return error;
 }
 
@@ -1848,7 +1874,7 @@ static int remove_remote_tracking(git_repository *repo, const char *remote_name)
 		if (refspec == NULL)
 			continue;
 
-		if ((error = remove_refs(repo, git_refspec_dst(refspec))) < 0)
+		if ((error = remove_refs(repo, refspec)) < 0)
 			break;
 	}
 
-- 
cgit v1.2.3


From 4ee2543c5ac1e7ed2f849968a7396f04d83fee54 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 2 Jun 2014 16:46:47 +0200
Subject: refs: failing test for concurrent ref access

If we remove a reference while we're iterating through the packed refs,
the position in the iterator will be off.
---
 tests/refs/iterator.c | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/tests/refs/iterator.c b/tests/refs/iterator.c
index a29b0cf8b..c77451309 100644
--- a/tests/refs/iterator.c
+++ b/tests/refs/iterator.c
@@ -186,3 +186,36 @@ void test_refs_iterator__foreach_name_can_cancel(void)
 		-333);
 	cl_assert_equal_i(0, cancel_after);
 }
+
+void test_refs_iterator__concurrent_delete(void)
+{
+	git_reference_iterator *iter;
+	size_t full_count = 0, concurrent_count = 0;
+	const char *name;
+	int error;
+
+	git_repository_free(repo);
+	repo = cl_git_sandbox_init("testrepo");
+
+	cl_git_pass(git_reference_iterator_new(&iter, repo));
+	while ((error = git_reference_next_name(&name, iter)) == 0) {
+		full_count++;
+	}
+
+	git_reference_iterator_free(iter);
+	cl_assert_equal_i(GIT_ITEROVER, error);
+
+	cl_git_pass(git_reference_iterator_new(&iter, repo));
+	while ((error = git_reference_next_name(&name, iter)) == 0) {
+		cl_git_pass(git_reference_remove(repo, name));
+		concurrent_count++;
+	}
+
+	git_reference_iterator_free(iter);
+	cl_assert_equal_i(GIT_ITEROVER, error);
+
+	cl_assert_equal_i(full_count, concurrent_count);
+
+	cl_git_sandbox_cleanup();
+	repo = NULL;
+}
-- 
cgit v1.2.3


From 2d945f82f63a4df57b2bd9ba6551d99d4517f7f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 2 Jun 2014 17:44:51 +0200
Subject: refs: copy the packed refs on iteration

This lets us work without worrying about what's happening but work on a
snapshot.
---
 src/refdb_fs.c | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/src/refdb_fs.c b/src/refdb_fs.c
index dd8bf7916..0e36ca8ac 100644
--- a/src/refdb_fs.c
+++ b/src/refdb_fs.c
@@ -458,6 +458,7 @@ typedef struct {
 	git_pool pool;
 	git_vector loose;
 
+	git_sortedcache *cache;
 	size_t loose_pos;
 	size_t packed_pos;
 } refdb_fs_iter;
@@ -468,6 +469,7 @@ static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)
 
 	git_vector_free(&iter->loose);
 	git_pool_clear(&iter->pool);
+	git_sortedcache_free(iter->cache);
 	git__free(iter);
 }
 
@@ -539,10 +541,14 @@ static int refdb_fs_backend__iterator_next(
 		giterr_clear();
 	}
 
-	git_sortedcache_rlock(backend->refcache);
+	if (!iter->cache) {
+		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
+			return error;
+	}
 
-	while (iter->packed_pos < git_sortedcache_entrycount(backend->refcache)) {
-		ref = git_sortedcache_entry(backend->refcache, iter->packed_pos++);
+	error = GIT_ITEROVER;
+	while (iter->packed_pos < git_sortedcache_entrycount(iter->cache)) {
+		ref = git_sortedcache_entry(iter->cache, iter->packed_pos++);
 		if (!ref) /* stop now if another thread deleted refs and we past end */
 			break;
 
@@ -556,7 +562,6 @@ static int refdb_fs_backend__iterator_next(
 		break;
 	}
 
-	git_sortedcache_runlock(backend->refcache);
 	return error;
 }
 
@@ -579,10 +584,14 @@ static int refdb_fs_backend__iterator_next_name(
 		giterr_clear();
 	}
 
-	git_sortedcache_rlock(backend->refcache);
+	if (!iter->cache) {
+		if ((error = git_sortedcache_copy(&iter->cache, backend->refcache, 1, NULL, NULL)) < 0)
+			return error;
+	}
 
-	while (iter->packed_pos < git_sortedcache_entrycount(backend->refcache)) {
-		ref = git_sortedcache_entry(backend->refcache, iter->packed_pos++);
+	error = GIT_ITEROVER;
+	while (iter->packed_pos < git_sortedcache_entrycount(iter->cache)) {
+		ref = git_sortedcache_entry(iter->cache, iter->packed_pos++);
 		if (!ref) /* stop now if another thread deleted refs and we past end */
 			break;
 
@@ -596,7 +605,6 @@ static int refdb_fs_backend__iterator_next_name(
 		break;
 	}
 
-	git_sortedcache_runlock(backend->refcache);
 	return error;
 }
 
-- 
cgit v1.2.3


From 11e2665e5040066cc251a45d017f37d2b0bd0617 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 2 Jun 2014 18:53:32 +0200
Subject: Formatting fixes for the docs

These are some issues I found while playing around with the new parser
for docurium.
---
 include/git2/checkout.h | 24 ++++++++++----------
 include/git2/diff.h     | 58 ++++++++++++++++++++++++-------------------------
 include/git2/index.h    |  2 +-
 include/git2/reset.h    |  6 ++---
 include/git2/types.h    | 26 +++++++++++-----------
 5 files changed, 58 insertions(+), 58 deletions(-)

diff --git a/include/git2/checkout.h b/include/git2/checkout.h
index 494f67456..ad44173e6 100644
--- a/include/git2/checkout.h
+++ b/include/git2/checkout.h
@@ -43,17 +43,17 @@ GIT_BEGIN_DECL
  * In between those are `GIT_CHECKOUT_SAFE` and `GIT_CHECKOUT_SAFE_CREATE`
  * both of which only make modifications that will not lose changes.
  *
- *                      |  target == baseline   |  target != baseline  |
- * ---------------------|-----------------------|----------------------|
- *  workdir == baseline |       no action       |  create, update, or  |
- *                      |                       |     delete file      |
- * ---------------------|-----------------------|----------------------|
- *  workdir exists and  |       no action       |   conflict (notify   |
- *    is != baseline    | notify dirty MODIFIED | and cancel checkout) |
- * ---------------------|-----------------------|----------------------|
- *   workdir missing,   | create if SAFE_CREATE |     create file      |
- *   baseline present   | notify dirty DELETED  |                      |
- * ---------------------|-----------------------|----------------------|
+ *                         |  target == baseline   |  target != baseline  |
+ *    ---------------------|-----------------------|----------------------|
+ *     workdir == baseline |       no action       |  create, update, or  |
+ *                         |                       |     delete file      |
+ *    ---------------------|-----------------------|----------------------|
+ *     workdir exists and  |       no action       |   conflict (notify   |
+ *       is != baseline    | notify dirty MODIFIED | and cancel checkout) |
+ *    ---------------------|-----------------------|----------------------|
+ *      workdir missing,   | create if SAFE_CREATE |     create file      |
+ *      baseline present   | notify dirty DELETED  |                      |
+ *    ---------------------|-----------------------|----------------------|
  *
  * The only difference between SAFE and SAFE_CREATE is that SAFE_CREATE
  * will cause a file to be checked out if it is missing from the working
@@ -106,7 +106,7 @@ GIT_BEGIN_DECL
  *   target contains that file.
  */
 typedef enum {
-	GIT_CHECKOUT_NONE = 0, /** default is a dry run, no actual updates */
+	GIT_CHECKOUT_NONE = 0, /**< default is a dry run, no actual updates */
 
 	/** Allow safe updates that cannot overwrite uncommitted data */
 	GIT_CHECKOUT_SAFE = (1u << 0),
diff --git a/include/git2/diff.h b/include/git2/diff.h
index b40cc6135..675c209be 100644
--- a/include/git2/diff.h
+++ b/include/git2/diff.h
@@ -212,9 +212,9 @@ typedef struct git_diff git_diff;
  * considered reserved for internal or future use.
  */
 typedef enum {
-	GIT_DIFF_FLAG_BINARY     = (1u << 0), /** file(s) treated as binary data */
-	GIT_DIFF_FLAG_NOT_BINARY = (1u << 1), /** file(s) treated as text data */
-	GIT_DIFF_FLAG_VALID_ID  = (1u << 2), /** `id` value is known correct */
+	GIT_DIFF_FLAG_BINARY     = (1u << 0), /**< file(s) treated as binary data */
+	GIT_DIFF_FLAG_NOT_BINARY = (1u << 1), /**< file(s) treated as text data */
+	GIT_DIFF_FLAG_VALID_ID  = (1u << 2), /**< `id` value is known correct */
 } git_diff_flag_t;
 
 /**
@@ -228,15 +228,15 @@ typedef enum {
  * DELETED pairs).
  */
 typedef enum {
-	GIT_DELTA_UNMODIFIED = 0, /** no changes */
-	GIT_DELTA_ADDED = 1,	  /** entry does not exist in old version */
-	GIT_DELTA_DELETED = 2,	  /** entry does not exist in new version */
-	GIT_DELTA_MODIFIED = 3,   /** entry content changed between old and new */
-	GIT_DELTA_RENAMED = 4,    /** entry was renamed between old and new */
-	GIT_DELTA_COPIED = 5,     /** entry was copied from another old entry */
-	GIT_DELTA_IGNORED = 6,    /** entry is ignored item in workdir */
-	GIT_DELTA_UNTRACKED = 7,  /** entry is untracked item in workdir */
-	GIT_DELTA_TYPECHANGE = 8, /** type of entry changed between old and new */
+	GIT_DELTA_UNMODIFIED = 0, /**< no changes */
+	GIT_DELTA_ADDED = 1,	  /**< entry does not exist in old version */
+	GIT_DELTA_DELETED = 2,	  /**< entry does not exist in new version */
+	GIT_DELTA_MODIFIED = 3,   /**< entry content changed between old and new */
+	GIT_DELTA_RENAMED = 4,    /**< entry was renamed between old and new */
+	GIT_DELTA_COPIED = 5,     /**< entry was copied from another old entry */
+	GIT_DELTA_IGNORED = 6,    /**< entry is ignored item in workdir */
+	GIT_DELTA_UNTRACKED = 7,  /**< entry is untracked item in workdir */
+	GIT_DELTA_TYPECHANGE = 8, /**< type of entry changed between old and new */
 } git_delta_t;
 
 /**
@@ -416,12 +416,12 @@ typedef int (*git_diff_file_cb)(
  */
 typedef struct git_diff_hunk git_diff_hunk;
 struct git_diff_hunk {
-	int    old_start;     /** Starting line number in old_file */
-	int    old_lines;     /** Number of lines in old_file */
-	int    new_start;     /** Starting line number in new_file */
-	int    new_lines;     /** Number of lines in new_file */
-	size_t header_len;    /** Number of bytes in header text */
-	char   header[128];   /** Header text, NUL-byte terminated */
+	int    old_start;     /**< Starting line number in old_file */
+	int    old_lines;     /**< Number of lines in old_file */
+	int    new_start;     /**< Starting line number in new_file */
+	int    new_lines;     /**< Number of lines in new_file */
+	size_t header_len;    /**< Number of bytes in header text */
+	char   header[128];   /**< Header text, NUL-byte terminated */
 };
 
 /**
@@ -464,13 +464,13 @@ typedef enum {
  */
 typedef struct git_diff_line git_diff_line;
 struct git_diff_line {
-	char   origin;       /** A git_diff_line_t value */
-	int    old_lineno;   /** Line number in old file or -1 for added line */
-	int    new_lineno;   /** Line number in new file or -1 for deleted line */
-	int    num_lines;    /** Number of newline characters in content */
-	size_t content_len;  /** Number of bytes of data */
-	git_off_t content_offset; /** Offset in the original file to the content */
-	const char *content; /** Pointer to diff text, not NUL-byte terminated */
+	char   origin;       /**< A git_diff_line_t value */
+	int    old_lineno;   /**< Line number in old file or -1 for added line */
+	int    new_lineno;   /**< Line number in new file or -1 for deleted line */
+	int    num_lines;    /**< Number of newline characters in content */
+	size_t content_len;  /**< Number of bytes of data */
+	git_off_t content_offset; /**< Offset in the original file to the content */
+	const char *content; /**< Pointer to diff text, not NUL-byte terminated */
 };
 
 /**
@@ -482,10 +482,10 @@ struct git_diff_line {
  * of lines of file and hunk headers.
  */
 typedef int (*git_diff_line_cb)(
-	const git_diff_delta *delta, /** delta that contains this data */
-	const git_diff_hunk *hunk,   /** hunk containing this data */
-	const git_diff_line *line,   /** line data */
-	void *payload);              /** user reference data */
+	const git_diff_delta *delta, /**< delta that contains this data */
+	const git_diff_hunk *hunk,   /**< hunk containing this data */
+	const git_diff_line *line,   /**< line data */
+	void *payload);              /**< user reference data */
 
 /**
  * Flags to control the behavior of diff rename/copy detection.
diff --git a/include/git2/index.h b/include/git2/index.h
index cdb87282c..b08329e2f 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -415,7 +415,7 @@ GIT_EXTERN(int) git_index_add(git_index *index, const git_index_entry *source_en
  *	(entry->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT
  *
  * @param entry The entry
- * @returns the stage number
+ * @return the stage number
  */
 GIT_EXTERN(int) git_index_entry_stage(const git_index_entry *entry);
 
diff --git a/include/git2/reset.h b/include/git2/reset.h
index 1759cc036..b8c580339 100644
--- a/include/git2/reset.h
+++ b/include/git2/reset.h
@@ -19,9 +19,9 @@ GIT_BEGIN_DECL
  * Kinds of reset operation
  */
 typedef enum {
-	GIT_RESET_SOFT  = 1, /** Move the head to the given commit */
-	GIT_RESET_MIXED = 2, /** SOFT plus reset index to the commit */
-	GIT_RESET_HARD  = 3, /** MIXED plus changes in working tree discarded */
+	GIT_RESET_SOFT  = 1, /**< Move the head to the given commit */
+	GIT_RESET_MIXED = 2, /**< SOFT plus reset index to the commit */
+	GIT_RESET_HARD  = 3, /**< MIXED plus changes in working tree discarded */
 } git_reset_t;
 
 /**
diff --git a/include/git2/types.h b/include/git2/types.h
index 1b6f4cca1..6295ebbfa 100644
--- a/include/git2/types.h
+++ b/include/git2/types.h
@@ -154,15 +154,15 @@ typedef struct git_packbuilder git_packbuilder;
 
 /** Time in a signature */
 typedef struct git_time {
-	git_time_t time; /** time in seconds from epoch */
-	int offset; /** timezone offset, in minutes */
+	git_time_t time; /**< time in seconds from epoch */
+	int offset; /**< timezone offset, in minutes */
 } git_time;
 
 /** An action signature (e.g. for committers, taggers, etc) */
 typedef struct git_signature {
-	char *name; /** full name of the author */
-	char *email; /** email of the author */
-	git_time when; /** time when the action happened */
+	char *name; /**< full name of the author */
+	char *email; /**< email of the author */
+	git_time when; /**< time when the action happened */
 } git_signature;
 
 /** In-memory representation of a reference. */
@@ -183,9 +183,9 @@ typedef struct git_status_list git_status_list;
 
 /** Basic type of any Git reference. */
 typedef enum {
-	GIT_REF_INVALID = 0, /** Invalid reference */
-	GIT_REF_OID = 1, /** A reference which points at an object id */
-	GIT_REF_SYMBOLIC = 2, /** A reference which points at another reference */
+	GIT_REF_INVALID = 0, /**< Invalid reference */
+	GIT_REF_OID = 1, /**< A reference which points at an object id */
+	GIT_REF_SYMBOLIC = 2, /**< A reference which points at another reference */
 	GIT_REF_LISTALL = GIT_REF_OID|GIT_REF_SYMBOLIC,
 } git_ref_t;
 
@@ -314,12 +314,12 @@ typedef enum {
  *   when we don't want any particular ignore rule to be specified.
  */
 typedef enum {
-	GIT_SUBMODULE_IGNORE_RESET     = -1, /* reset to on-disk value */
+	GIT_SUBMODULE_IGNORE_RESET     = -1, /**< reset to on-disk value */
 
-	GIT_SUBMODULE_IGNORE_NONE      = 1,  /* any change or untracked == dirty */
-	GIT_SUBMODULE_IGNORE_UNTRACKED = 2,  /* dirty if tracked files change */
-	GIT_SUBMODULE_IGNORE_DIRTY     = 3,  /* only dirty if HEAD moved */
-	GIT_SUBMODULE_IGNORE_ALL       = 4,  /* never dirty */
+	GIT_SUBMODULE_IGNORE_NONE      = 1,  /**< any change or untracked == dirty */
+	GIT_SUBMODULE_IGNORE_UNTRACKED = 2,  /**< dirty if tracked files change */
+	GIT_SUBMODULE_IGNORE_DIRTY     = 3,  /**< only dirty if HEAD moved */
+	GIT_SUBMODULE_IGNORE_ALL       = 4,  /**< never dirty */
 
 	GIT_SUBMODULE_IGNORE_DEFAULT   = 0
 } git_submodule_ignore_t;
-- 
cgit v1.2.3


From dedfc7346b7873bfeb04ce06257bfa712d9632e8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 2 Jun 2014 19:21:24 +0200
Subject: index: split GIT_IDXENTRY into two flag enums

The documentation has shown this as a single enum for a long time. These
should in fact be two enums. One with the bits for the flags and another
with the bits for the extended flags.
---
 include/git2/index.h | 59 +++++++++++++++++++++++++++-------------------------
 1 file changed, 31 insertions(+), 28 deletions(-)

diff --git a/include/git2/index.h b/include/git2/index.h
index b08329e2f..0b4476b4e 100644
--- a/include/git2/index.h
+++ b/include/git2/index.h
@@ -73,10 +73,13 @@ typedef struct git_index_entry {
  */
 #define GIT_IDXENTRY_NAMEMASK  (0x0fff)
 #define GIT_IDXENTRY_STAGEMASK (0x3000)
-#define GIT_IDXENTRY_EXTENDED  (0x4000)
-#define GIT_IDXENTRY_VALID     (0x8000)
 #define GIT_IDXENTRY_STAGESHIFT 12
 
+typedef enum {
+	GIT_IDXENTRY_EXTENDED  = (0x4000),
+	GIT_IDXENTRY_VALID     = (0x8000),
+} git_indxentry_flag_t;
+
 #define GIT_IDXENTRY_STAGE(E) \
 	(((E)->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT)
 
@@ -92,36 +95,36 @@ typedef struct git_index_entry {
  * in-memory only and used by libgit2.  Only the flags in
  * `GIT_IDXENTRY_EXTENDED_FLAGS` will get saved on-disk.
  *
- * These bitmasks match the three fields in the `git_index_entry`
- * `flags_extended` value that belong on disk.  You can use them to
- * interpret the data in the `flags_extended`.
+ * Thee first three bitmasks match the three fields in the
+ * `git_index_entry` `flags_extended` value that belong on disk.  You
+ * can use them to interpret the data in the `flags_extended`.
+ *
+ * The rest of the bitmasks match the other fields in the `git_index_entry`
+ * `flags_extended` value that are only used in-memory by libgit2.
+ * You can use them to interpret the data in the `flags_extended`.
+ *
  */
-#define GIT_IDXENTRY_INTENT_TO_ADD     (1 << 13)
-#define GIT_IDXENTRY_SKIP_WORKTREE     (1 << 14)
-/* GIT_IDXENTRY_EXTENDED2 is reserved for future extension */
-#define GIT_IDXENTRY_EXTENDED2         (1 << 15)
+typedef enum {
 
-#define GIT_IDXENTRY_EXTENDED_FLAGS (GIT_IDXENTRY_INTENT_TO_ADD | GIT_IDXENTRY_SKIP_WORKTREE)
+	GIT_IDXENTRY_INTENT_TO_ADD  =  (1 << 13),
+	GIT_IDXENTRY_SKIP_WORKTREE  =  (1 << 14),
+	/** Reserved for future extension */
+	GIT_IDXENTRY_EXTENDED2      =  (1 << 15),
 
-/**
- * Bitmasks for in-memory only fields of `git_index_entry`'s `flags_extended`
- *
- * These bitmasks match the other fields in the `git_index_entry`
- * `flags_extended` value that are only used in-memory by libgit2.  You
- * can use them to interpret the data in the `flags_extended`.
- */
-#define GIT_IDXENTRY_UPDATE            (1 << 0)
-#define GIT_IDXENTRY_REMOVE            (1 << 1)
-#define GIT_IDXENTRY_UPTODATE          (1 << 2)
-#define GIT_IDXENTRY_ADDED             (1 << 3)
+	GIT_IDXENTRY_EXTENDED_FLAGS = (GIT_IDXENTRY_INTENT_TO_ADD | GIT_IDXENTRY_SKIP_WORKTREE),
+	GIT_IDXENTRY_UPDATE            =  (1 << 0),
+	GIT_IDXENTRY_REMOVE            =  (1 << 1),
+	GIT_IDXENTRY_UPTODATE          =  (1 << 2),
+	GIT_IDXENTRY_ADDED             =  (1 << 3),
 
-#define GIT_IDXENTRY_HASHED            (1 << 4)
-#define GIT_IDXENTRY_UNHASHED          (1 << 5)
-#define GIT_IDXENTRY_WT_REMOVE         (1 << 6) /* remove in work directory */
-#define GIT_IDXENTRY_CONFLICTED        (1 << 7)
+	GIT_IDXENTRY_HASHED            =  (1 << 4),
+	GIT_IDXENTRY_UNHASHED          =  (1 << 5),
+	GIT_IDXENTRY_WT_REMOVE         =  (1 << 6), /**< remove in work directory */
+	GIT_IDXENTRY_CONFLICTED        =  (1 << 7),
 
-#define GIT_IDXENTRY_UNPACKED          (1 << 8)
-#define GIT_IDXENTRY_NEW_SKIP_WORKTREE (1 << 9)
+	GIT_IDXENTRY_UNPACKED          =  (1 << 8),
+	GIT_IDXENTRY_NEW_SKIP_WORKTREE =  (1 << 9),
+} git_idxentry_extended_flag_t;
 
 /** Capabilities of system that affect index actions. */
 typedef enum {
@@ -412,7 +415,7 @@ GIT_EXTERN(int) git_index_add(git_index *index, const git_index_entry *source_en
  *
  * This entry is calculated from the entry's flag attribute like this:
  *
- *	(entry->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT
+ *    (entry->flags & GIT_IDXENTRY_STAGEMASK) >> GIT_IDXENTRY_STAGESHIFT
  *
  * @param entry The entry
  * @return the stage number
-- 
cgit v1.2.3


From 69a1a6918c0fc76468329bbb3258d83db8f4c487 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 3 Jun 2014 16:18:08 +0200
Subject: Plug a leak in the tests

---
 tests/index/filemodes.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/index/filemodes.c b/tests/index/filemodes.c
index e00b9c975..58d7935a0 100644
--- a/tests/index/filemodes.c
+++ b/tests/index/filemodes.c
@@ -166,4 +166,6 @@ void test_index_filemodes__invalid(void)
 
 	entry.mode = GIT_FILEMODE_BLOB;
 	cl_git_pass(git_index_add(index, &entry));
+
+	git_index_free(index);
 }
-- 
cgit v1.2.3


From 18d7896cb00b9a4abe55cb461e12db4813e6a59e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 3 Jun 2014 21:47:53 +0200
Subject: clone: re-use the local transport's path resolution

Whe already worked out the kinks with the function used in the local
transport. Expose it and make use of it in the local clone method
instead of trying to work it out again.
---
 src/clone.c            | 18 +++---------------
 src/path.c             | 18 ++++++++++++++++++
 src/path.h             |  3 +++
 src/transports/local.c | 22 ++--------------------
 4 files changed, 26 insertions(+), 35 deletions(-)

diff --git a/src/clone.c b/src/clone.c
index 5aaa94ff6..6c4fb6727 100644
--- a/src/clone.c
+++ b/src/clone.c
@@ -472,11 +472,10 @@ static bool can_link(const char *src, const char *dst, int link)
 
 int git_clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link, const git_signature *signature)
 {
-	int error, root, flags;
+	int error, flags;
 	git_repository *src;
 	git_buf src_odb = GIT_BUF_INIT, dst_odb = GIT_BUF_INIT, src_path = GIT_BUF_INIT;
 	git_buf reflog_message = GIT_BUF_INIT;
-	const char *url;
 
 	assert(repo && remote);
 
@@ -490,19 +489,8 @@ int git_clone_local_into(git_repository *repo, git_remote *remote, const git_che
 	 * repo, if it's not rooted, the path should be relative to
 	 * the repository's worktree/gitdir.
 	 */
-	url = git_remote_url(remote);
-	if (!git__prefixcmp(url, "file://"))
-		root = strlen("file://");
-	else
-		root = git_path_root(url);
-
-	if (root >= 0)
-		git_buf_puts(&src_path, url + root);
-	else
-		git_buf_joinpath(&src_path, repository_base(repo), url);
-
-	if (git_buf_oom(&src_path))
-		return -1;
+	if ((error = git_path_from_url_or_path(&src_path, git_remote_url(remote))) < 0)
+		return error;
 
 	/* Copy .git/objects/ from the source to the target */
 	if ((error = git_repository_open(&src, git_buf_cstr(&src_path))) < 0) {
diff --git a/src/path.c b/src/path.c
index e0b00a086..5beab97ed 100644
--- a/src/path.c
+++ b/src/path.c
@@ -1127,3 +1127,21 @@ int git_path_dirload_with_stat(
 
 	return error;
 }
+
+int git_path_from_url_or_path(git_buf *local_path_out, const char *url_or_path)
+{
+	int error;
+
+	/* If url_or_path begins with file:// treat it as a URL */
+	if (!git__prefixcmp(url_or_path, "file://")) {
+		if ((error = git_path_fromurl(local_path_out, url_or_path)) < 0) {
+			return error;
+		}
+	} else { /* We assume url_or_path is already a path */
+		if ((error = git_buf_sets(local_path_out, url_or_path)) < 0) {
+			return error;
+		}
+	}
+
+	return 0;
+}
diff --git a/src/path.h b/src/path.h
index 3213c5104..3e6efe3de 100644
--- a/src/path.h
+++ b/src/path.h
@@ -438,4 +438,7 @@ extern int git_path_iconv(git_path_iconv_t *ic, char **in, size_t *inlen);
 
 extern bool git_path_does_fs_decompose_unicode(const char *root);
 
+/* Used for paths to repositories on the filesystem */
+extern int git_path_from_url_or_path(git_buf *local_path_out, const char *url_or_path);
+
 #endif
diff --git a/src/transports/local.c b/src/transports/local.c
index 038337d72..f859f0b70 100644
--- a/src/transports/local.c
+++ b/src/transports/local.c
@@ -175,24 +175,6 @@ on_error:
 	return -1;
 }
 
-static int path_from_url_or_path(git_buf *local_path_out, const char *url_or_path)
-{
-	int error;
-
-	/* If url_or_path begins with file:// treat it as a URL */
-	if (!git__prefixcmp(url_or_path, "file://")) {
-		if ((error = git_path_fromurl(local_path_out, url_or_path)) < 0) {
-			return error;
-		}
-	} else { /* We assume url_or_path is already a path */
-		if ((error = git_buf_sets(local_path_out, url_or_path)) < 0) {
-			return error;
-		}
-	}
-
-	return 0;
-}
-
 /*
  * Try to open the url as a git directory. The direction doesn't
  * matter in this case because we're calculating the heads ourselves.
@@ -222,7 +204,7 @@ static int local_connect(
 	t->flags = flags;
 
 	/* 'url' may be a url or path; convert to a path */
-	if ((error = path_from_url_or_path(&buf, url)) < 0) {
+	if ((error = git_path_from_url_or_path(&buf, url)) < 0) {
 		git_buf_free(&buf);
 		return error;
 	}
@@ -386,7 +368,7 @@ static int local_push(
 	size_t j;
 
 	/* 'push->remote->url' may be a url or path; convert to a path */
-	if ((error = path_from_url_or_path(&buf, push->remote->url)) < 0) {
+	if ((error = git_path_from_url_or_path(&buf, push->remote->url)) < 0) {
 		git_buf_free(&buf);
 		return error;
 	}
-- 
cgit v1.2.3


From fe3b9d07317732830a3416187e2946979caafc92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 6 Jun 2014 00:54:11 +0200
Subject: remote: failing test for rename

When there is a reference in the target namespace, we should overwrite
it. Instead it gets a different name under the current code.
---
 tests/network/remote/rename.c | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/tests/network/remote/rename.c b/tests/network/remote/rename.c
index 4d8628425..b7ec44726 100644
--- a/tests/network/remote/rename.c
+++ b/tests/network/remote/rename.c
@@ -172,3 +172,33 @@ void test_network_remote_rename__cannot_rename_an_inmemory_remote(void)
 
 	git_remote_free(remote);
 }
+
+void test_network_remote_rename__overwrite_ref_in_target(void)
+{
+	git_oid id;
+	char idstr[GIT_OID_HEXSZ + 1] = {0};
+	git_remote *remote;
+	git_reference *ref;
+	git_branch_t btype;
+	git_branch_iterator *iter;
+
+	cl_git_pass(git_oid_fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"));
+	cl_git_pass(git_reference_create(&ref, _repo, "refs/remotes/renamed/master", &id, 1, NULL, NULL));
+	git_reference_free(ref);
+
+	cl_git_pass(git_remote_load(&remote, _repo, "test"));
+	cl_git_pass(git_remote_rename(remote, "renamed", dont_call_me_cb, NULL));
+	git_remote_free(remote);
+
+
+	/* make sure there's only one remote-tracking branch */
+	cl_git_pass(git_branch_iterator_new(&iter, _repo, GIT_BRANCH_REMOTE));
+	cl_git_pass(git_branch_next(&ref, &btype, iter));
+	cl_assert_equal_s("refs/remotes/renamed/master", git_reference_name(ref));
+	git_oid_fmt(idstr, git_reference_target(ref));
+	cl_assert_equal_s("be3563ae3f795b2b4353bcce3a527ad0a4f7f644", idstr);
+	git_reference_free(ref);
+
+	cl_git_fail_with(GIT_ITEROVER, git_branch_next(&ref, &btype, iter));
+	git_branch_iterator_free(iter);
+}
-- 
cgit v1.2.3


From a52ab4b82a06f3a4e6065ecfa1b27917b4ba216b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 6 Jun 2014 01:09:49 +0200
Subject: remote: tighten up reference renaming

Tighten up which references we consider for renaming so we don't try to
rename unrelated ones and end up with unexplained references.

If there is a reference on the target namespace, git overwrites it, so
let's do the same.
---
 src/remote.c | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index 0c82433d1..0d1a88ea7 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1380,7 +1380,7 @@ static int rename_one_remote_reference(
 		goto cleanup;
 
 	error = git_reference_rename(
-		NULL, reference, git_buf_cstr(&new_name), 0,
+		NULL, reference, git_buf_cstr(&new_name), 1,
 		NULL, git_buf_cstr(&log_message));
 	git_reference_free(reference);
 
@@ -1396,18 +1396,20 @@ static int rename_remote_references(
 	const char *new_name)
 {
 	int error;
+	git_buf buf = GIT_BUF_INIT;
 	git_reference *ref;
 	git_reference_iterator *iter;
 
-	if ((error = git_reference_iterator_new(&iter, repo)) < 0)
+	if ((error = git_buf_printf(&buf, GIT_REFS_REMOTES_DIR "%s/*", old_name)) < 0)
 		return error;
 
-	while ((error = git_reference_next(&ref, iter)) == 0) {
-		if (git__prefixcmp(ref->name, GIT_REFS_REMOTES_DIR)) {
-			git_reference_free(ref);
-			continue;
-		}
+	error = git_reference_iterator_glob_new(&iter, repo, git_buf_cstr(&buf));
+	git_buf_free(&buf);
 
+	if (error < 0)
+		return error;
+
+	while ((error = git_reference_next(&ref, iter)) == 0) {
 		if ((error = rename_one_remote_reference(ref, old_name, new_name)) < 0)
 			break;
 	}
-- 
cgit v1.2.3


From 05554d839d8068d7da37a53655bd065569306763 Mon Sep 17 00:00:00 2001
From: Arthur Schreiber <arthur.schreiber@hp.com>
Date: Fri, 6 Jun 2014 11:01:20 +0200
Subject: Update AUTHORS

Add me. :)
---
 AUTHORS | 1 +
 1 file changed, 1 insertion(+)

diff --git a/AUTHORS b/AUTHORS
index 6854ed016..2eaec0ff6 100644
--- a/AUTHORS
+++ b/AUTHORS
@@ -6,6 +6,7 @@ Alexei Sholik
 Andreas Ericsson
 Anton "antong" Gyllenberg
 Ankur Sethi
+Arthur Schreiber
 Ben Noordhuis
 Ben Straub
 Benjamin C Meyer
-- 
cgit v1.2.3


From 5a49ff9fa0b89c9fd479e04e0f694fa5f07fd6f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 6 Jun 2014 15:54:42 +0200
Subject: remote: remove rename code for anonymous remotes

We don't allow renames of anonymous remotes, so there's no need to
handle them.

A remote is always associated with a repository, so there's no need to
check for that.
---
 src/remote.c | 53 +++++++++++------------------------------------------
 1 file changed, 11 insertions(+), 42 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index 0d1a88ea7..dd88cf91a 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1442,10 +1442,8 @@ static int rename_fetch_refspecs(
 		if (spec->push)
 			continue;
 
-		/* Every refspec is a problem refspec for an anonymous remote, OR */
 		/* Does the dst part of the refspec follow the expected format? */
-		if (!remote->name ||
-			strcmp(git_buf_cstr(&base), spec->string)) {
+		if (strcmp(git_buf_cstr(&base), spec->string)) {
 
 			if ((error = callback(spec->string, payload)) != 0) {
 				giterr_set_after_callback(error);
@@ -1497,49 +1495,20 @@ int git_remote_rename(
 	if ((error = ensure_remote_name_is_valid(new_name)) < 0)
 		return error;
 
-	if (remote->repo) {
-		if ((error = ensure_remote_doesnot_exist(remote->repo, new_name)) < 0)
-			return error;
+	if ((error = ensure_remote_doesnot_exist(remote->repo, new_name)) < 0)
+		return error;
 
-		if (!remote->name) {
-			if ((error = rename_fetch_refspecs(
-				remote,
-				new_name,
-				callback,
-				payload)) < 0)
-					return error;
+	if ((error = rename_remote_config_section(remote->repo, remote->name, new_name)) < 0)
+		return error;
 
-			remote->name = git__strdup(new_name);
-			GITERR_CHECK_ALLOC(remote->name);
+	if ((error = update_branch_remote_config_entry(remote->repo, remote->name, new_name)) < 0)
+		return error;
 
-			return git_remote_save(remote);
-		}
+	if ((error = rename_remote_references(remote->repo, remote->name, new_name)) < 0)
+		return error;
 
-		if ((error = rename_remote_config_section(
-			remote->repo,
-			remote->name,
-			new_name)) < 0)
-				return error;
-
-		if ((error = update_branch_remote_config_entry(
-			remote->repo,
-			remote->name,
-			new_name)) < 0)
-				return error;
-
-		if ((error = rename_remote_references(
-			remote->repo,
-			remote->name,
-			new_name)) < 0)
-				return error;
-
-		if ((error = rename_fetch_refspecs(
-			remote,
-			new_name,
-			callback,
-			payload)) < 0)
-				return error;
-	}
+	if ((error = rename_fetch_refspecs(remote, new_name, callback, payload)) < 0)
+		return error;
 
 	git__free(remote->name);
 
-- 
cgit v1.2.3


From 61dcfe1400a5ff1cf4dc805795cb72657c524906 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 6 Jun 2014 15:57:37 +0200
Subject: remote: make sure the name stays valid on rename

We must make sure that the name pointer remains valid, so make sure to
allocate the new one before freeing the old one and swap them so the
user never sees an invalid pointer.
---
 src/remote.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index dd88cf91a..c7b97ca62 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1484,6 +1484,7 @@ int git_remote_rename(
 	void *payload)
 {
 	int error;
+	char *tmp, *dup;
 
 	assert(remote && new_name);
 
@@ -1510,10 +1511,12 @@ int git_remote_rename(
 	if ((error = rename_fetch_refspecs(remote, new_name, callback, payload)) < 0)
 		return error;
 
-	git__free(remote->name);
+	dup = git__strdup(new_name);
+	GITERR_CHECK_ALLOC(dup);
 
-	remote->name = git__strdup(new_name);
-	GITERR_CHECK_ALLOC(remote->name);
+	tmp = remote->name;
+	remote->name = dup;
+	git__free(tmp);
 
 	return 0;
 }
-- 
cgit v1.2.3


From 72bca13e5d0d421da7992f029e275d950c864105 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 6 Jun 2014 16:33:54 +0200
Subject: remote: return problem refspecs instead of using a callback

There is no reason why we need to use a callback here. A string array
fits better with the usage, as this is not an event and we don't need
anything from the user.
---
 include/git2/remote.h         |  8 ++--
 src/remote.c                  | 40 +++++++++++--------
 tests/network/remote/rename.c | 90 +++++++++++++++++++++++++------------------
 tests/submodule/add.c         |  5 ++-
 4 files changed, 87 insertions(+), 56 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index 28771ac42..8d3744265 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -572,6 +572,9 @@ GIT_EXTERN(void) git_remote_set_autotag(
  *
  * A temporary in-memory remote cannot be given a name with this method.
  *
+ * @param problems non-default refspecs cannot be renamed and will be
+ * stored here for further processing by the caller. Always free this
+ * strarray on succesful return.
  * @param remote the remote to rename
  * @param new_name the new name the remote should bear
  * @param callback Optional callback to notify the consumer of fetch refspecs
@@ -580,10 +583,9 @@ GIT_EXTERN(void) git_remote_set_autotag(
  * @return 0, GIT_EINVALIDSPEC, GIT_EEXISTS or an error code
  */
 GIT_EXTERN(int) git_remote_rename(
+	git_strarray *problems,
 	git_remote *remote,
-	const char *new_name,
-	git_remote_rename_problem_cb callback,
-	void *payload);
+	const char *new_name);
 
 /**
  * Retrieve the update FETCH_HEAD setting.
diff --git a/src/remote.c b/src/remote.c
index c7b97ca62..4e6f350d5 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1419,11 +1419,7 @@ static int rename_remote_references(
 	return (error == GIT_ITEROVER) ? 0 : error;
 }
 
-static int rename_fetch_refspecs(
-	git_remote *remote,
-	const char *new_name,
-	int (*callback)(const char *problematic_refspec, void *payload),
-	void *payload)
+static int rename_fetch_refspecs(git_vector *problems, git_remote *remote, const char *new_name)
 {
 	git_config *config;
 	git_buf base = GIT_BUF_INIT, var = GIT_BUF_INIT, val = GIT_BUF_INIT;
@@ -1434,6 +1430,9 @@ static int rename_fetch_refspecs(
 	if ((error = git_repository_config__weakptr(&config, remote->repo)) < 0)
 		return error;
 
+	if ((error = git_vector_init(problems, 1, NULL)) < 0)
+		return error;
+
 	if ((error = git_buf_printf(
 			&base, "+refs/heads/*:refs/remotes/%s/*", remote->name)) < 0)
 		return error;
@@ -1444,11 +1443,13 @@ static int rename_fetch_refspecs(
 
 		/* Does the dst part of the refspec follow the expected format? */
 		if (strcmp(git_buf_cstr(&base), spec->string)) {
+			char *dup;
 
-			if ((error = callback(spec->string, payload)) != 0) {
-				giterr_set_after_callback(error);
+			dup = git__strdup(spec->string);
+			GITERR_CHECK_ALLOC(dup);
+
+			if ((error = git_vector_insert(problems, dup)) < 0)
 				break;
-			}
 
 			continue;
 		}
@@ -1474,19 +1475,25 @@ static int rename_fetch_refspecs(
 	git_buf_free(&base);
 	git_buf_free(&var);
 	git_buf_free(&val);
+
+	if (error < 0) {
+		char *str;
+		git_vector_foreach(problems, i, str)
+			git__free(str);
+
+		git_vector_free(problems);
+	}
+
 	return error;
 }
 
-int git_remote_rename(
-	git_remote *remote,
-	const char *new_name,
-	git_remote_rename_problem_cb callback,
-	void *payload)
+int git_remote_rename(git_strarray *out, git_remote *remote, const char *new_name)
 {
 	int error;
+	git_vector problem_refspecs;
 	char *tmp, *dup;
 
-	assert(remote && new_name);
+	assert(out && remote && new_name);
 
 	if (!remote->name) {
 		giterr_set(GITERR_INVALID, "Can't rename an anonymous remote.");
@@ -1508,9 +1515,12 @@ int git_remote_rename(
 	if ((error = rename_remote_references(remote->repo, remote->name, new_name)) < 0)
 		return error;
 
-	if ((error = rename_fetch_refspecs(remote, new_name, callback, payload)) < 0)
+	if ((error = rename_fetch_refspecs(&problem_refspecs, remote, new_name)) < 0)
 		return error;
 
+	out->count = problem_refspecs.length;
+	out->strings = (char **) problem_refspecs.contents;
+
 	dup = git__strdup(new_name);
 	GITERR_CHECK_ALLOC(dup);
 
diff --git a/tests/network/remote/rename.c b/tests/network/remote/rename.c
index b7ec44726..48a33038a 100644
--- a/tests/network/remote/rename.c
+++ b/tests/network/remote/rename.c
@@ -33,10 +33,14 @@ static int dont_call_me_cb(const char *fetch_refspec, void *payload)
 
 void test_network_remote_rename__renaming_a_remote_moves_related_configuration_section(void)
 {
+	git_strarray problems = {0};
+
 	assert_config_entry_existence(_repo, "remote.test.fetch", true);
 	assert_config_entry_existence(_repo, "remote.just/renamed.fetch", false);
 
-	cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
+	cl_git_pass(git_remote_rename(&problems, _remote, "just/renamed"));
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 
 	assert_config_entry_existence(_repo, "remote.test.fetch", false);
 	assert_config_entry_existence(_repo, "remote.just/renamed.fetch", true);
@@ -44,16 +48,24 @@ void test_network_remote_rename__renaming_a_remote_moves_related_configuration_s
 
 void test_network_remote_rename__renaming_a_remote_updates_branch_related_configuration_entries(void)
 {
+	git_strarray problems = {0};
+
 	assert_config_entry_value(_repo, "branch.master.remote", "test");
 
-	cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
+	cl_git_pass(git_remote_rename(&problems, _remote, "just/renamed"));
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 
 	assert_config_entry_value(_repo, "branch.master.remote", "just/renamed");
 }
 
 void test_network_remote_rename__renaming_a_remote_updates_default_fetchrefspec(void)
 {
-	cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
+	git_strarray problems = {0};
+
+	cl_git_pass(git_remote_rename(&problems, _remote, "just/renamed"));
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 
 	assert_config_entry_value(_repo, "remote.just/renamed.fetch", "+refs/heads/*:refs/remotes/just/renamed/*");
 }
@@ -61,6 +73,7 @@ void test_network_remote_rename__renaming_a_remote_updates_default_fetchrefspec(
 void test_network_remote_rename__renaming_a_remote_without_a_fetchrefspec_doesnt_create_one(void)
 {
 	git_config *config;
+	git_strarray problems = {0};
 
 	git_remote_free(_remote);
 	cl_git_pass(git_repository_config__weakptr(&config, _repo));
@@ -70,70 +83,64 @@ void test_network_remote_rename__renaming_a_remote_without_a_fetchrefspec_doesnt
 
 	assert_config_entry_existence(_repo, "remote.test.fetch", false);
 
-	cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
+	cl_git_pass(git_remote_rename(&problems, _remote, "just/renamed"));
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 
 	assert_config_entry_existence(_repo, "remote.just/renamed.fetch", false);
 }
 
-static int ensure_refspecs(const char* refspec_name, void *payload)
-{
-	int i = 0;
-	bool found = false;
-	const char ** exp = (const char **)payload;
-
-	while (exp[i]) {
-		if (strcmp(exp[i++], refspec_name))
-			continue;
-
-		found = true;
-		break;
-	}
-
-	cl_assert(found);
-
-	return 0;
-}
-
 void test_network_remote_rename__renaming_a_remote_notifies_of_non_default_fetchrefspec(void)
 {
 	git_config *config;
 
-	char *expected_refspecs[] = {
-		"+refs/*:refs/*",
-		NULL
-	};
+	git_strarray problems = {0};
 
 	git_remote_free(_remote);
 	cl_git_pass(git_repository_config__weakptr(&config, _repo));
 	cl_git_pass(git_config_set_string(config, "remote.test.fetch", "+refs/*:refs/*"));
 	cl_git_pass(git_remote_load(&_remote, _repo, "test"));
 
-	cl_git_pass(git_remote_rename(_remote, "just/renamed", ensure_refspecs, &expected_refspecs));
+	cl_git_pass(git_remote_rename(&problems, _remote, "just/renamed"));
+	cl_assert_equal_i(1, problems.count);
+	cl_assert_equal_s("+refs/*:refs/*", problems.strings[0]);
+	git_strarray_free(&problems);
 
 	assert_config_entry_value(_repo, "remote.just/renamed.fetch", "+refs/*:refs/*");
+
+	git_strarray_free(&problems);
 }
 
 void test_network_remote_rename__new_name_can_contain_dots(void)
 {
-	cl_git_pass(git_remote_rename(_remote, "just.renamed", dont_call_me_cb, NULL));
+	git_strarray problems = {0};
+
+	cl_git_pass(git_remote_rename(&problems, _remote, "just.renamed"));
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 	cl_assert_equal_s("just.renamed", git_remote_name(_remote));
 }
 
 void test_network_remote_rename__new_name_must_conform_to_reference_naming_conventions(void)
 {
+	git_strarray problems = {0};
+
 	cl_assert_equal_i(
 		GIT_EINVALIDSPEC,
-		git_remote_rename(_remote, "new@{name", dont_call_me_cb, NULL));
+		git_remote_rename(&problems, _remote, "new@{name"));
 }
 
 void test_network_remote_rename__renamed_name_is_persisted(void)
 {
 	git_remote *renamed;
 	git_repository *another_repo;
+	git_strarray problems = {0};
 
 	cl_git_fail(git_remote_load(&renamed, _repo, "just/renamed"));
 
-	cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
+	cl_git_pass(git_remote_rename(&problems, _remote, "just/renamed"));
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 
 	cl_git_pass(git_repository_open(&another_repo, "testrepo.git"));
 	cl_git_pass(git_remote_load(&renamed, _repo, "just/renamed"));
@@ -144,19 +151,24 @@ void test_network_remote_rename__renamed_name_is_persisted(void)
 
 void test_network_remote_rename__cannot_overwrite_an_existing_remote(void)
 {
-	cl_assert_equal_i(GIT_EEXISTS, git_remote_rename(_remote, "test", dont_call_me_cb, NULL));
-	cl_assert_equal_i(GIT_EEXISTS, git_remote_rename(_remote, "test_with_pushurl", dont_call_me_cb, NULL));
+	git_strarray problems = {0};
+
+	cl_assert_equal_i(GIT_EEXISTS, git_remote_rename(&problems, _remote, "test"));
+	cl_assert_equal_i(GIT_EEXISTS, git_remote_rename(&problems, _remote, "test_with_pushurl"));
 }
 
 void test_network_remote_rename__renaming_a_remote_moves_the_underlying_reference(void)
 {
 	git_reference *underlying;
+	git_strarray problems = {0};
 
 	cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&underlying, _repo, "refs/remotes/just/renamed"));
 	cl_git_pass(git_reference_lookup(&underlying, _repo, "refs/remotes/test/master"));
 	git_reference_free(underlying);
 
-	cl_git_pass(git_remote_rename(_remote, "just/renamed", dont_call_me_cb, NULL));
+	cl_git_pass(git_remote_rename(&problems, _remote, "just/renamed"));
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 
 	cl_assert_equal_i(GIT_ENOTFOUND, git_reference_lookup(&underlying, _repo, "refs/remotes/test/master"));
 	cl_git_pass(git_reference_lookup(&underlying, _repo, "refs/remotes/just/renamed/master"));
@@ -166,10 +178,12 @@ void test_network_remote_rename__renaming_a_remote_moves_the_underlying_referenc
 void test_network_remote_rename__cannot_rename_an_inmemory_remote(void)
 {
 	git_remote *remote;
+	git_strarray problems = {0};
 
 	cl_git_pass(git_remote_create_anonymous(&remote, _repo, "file:///blah", NULL));
-	cl_git_fail(git_remote_rename(remote, "newname", NULL, NULL));
+	cl_git_fail(git_remote_rename(&problems, remote, "newname"));
 
+	git_strarray_free(&problems);
 	git_remote_free(remote);
 }
 
@@ -181,15 +195,17 @@ void test_network_remote_rename__overwrite_ref_in_target(void)
 	git_reference *ref;
 	git_branch_t btype;
 	git_branch_iterator *iter;
+	git_strarray problems = {0};
 
 	cl_git_pass(git_oid_fromstr(&id, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750"));
 	cl_git_pass(git_reference_create(&ref, _repo, "refs/remotes/renamed/master", &id, 1, NULL, NULL));
 	git_reference_free(ref);
 
 	cl_git_pass(git_remote_load(&remote, _repo, "test"));
-	cl_git_pass(git_remote_rename(remote, "renamed", dont_call_me_cb, NULL));
+	cl_git_pass(git_remote_rename(&problems, remote, "renamed"));
 	git_remote_free(remote);
-
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 
 	/* make sure there's only one remote-tracking branch */
 	cl_git_pass(git_branch_iterator_new(&iter, _repo, GIT_BRANCH_REMOTE));
diff --git a/tests/submodule/add.c b/tests/submodule/add.c
index af81713f1..9fdc7cc57 100644
--- a/tests/submodule/add.c
+++ b/tests/submodule/add.c
@@ -68,13 +68,16 @@ void test_submodule_add__url_relative(void)
 {
 	git_submodule *sm;
 	git_remote *remote;
+	git_strarray problems = {0};
 
 	/* default remote url is https://github.com/libgit2/false.git */
 	g_repo = cl_git_sandbox_init("testrepo2");
 
 	/* make sure we don't default to origin - rename origin -> test_remote */
 	cl_git_pass(git_remote_load(&remote, g_repo, "origin"));
-	cl_git_pass(git_remote_rename(remote, "test_remote", NULL, NULL));
+	cl_git_pass(git_remote_rename(&problems, remote, "test_remote"));
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
 	cl_git_fail(git_remote_load(&remote, g_repo, "origin"));
 	git_remote_free(remote);
 
-- 
cgit v1.2.3


From eb6aa791a7c1a311b556398acce69cde3d43e3cd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 6 Jun 2014 22:01:35 +0200
Subject: remote: failing test for renaming with a symref

---
 tests/network/remote/rename.c | 48 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/tests/network/remote/rename.c b/tests/network/remote/rename.c
index 48a33038a..1b819a445 100644
--- a/tests/network/remote/rename.c
+++ b/tests/network/remote/rename.c
@@ -218,3 +218,51 @@ void test_network_remote_rename__overwrite_ref_in_target(void)
 	cl_git_fail_with(GIT_ITEROVER, git_branch_next(&ref, &btype, iter));
 	git_branch_iterator_free(iter);
 }
+
+void test_network_remote_rename__symref_head(void)
+{
+	int error;
+	git_remote *remote;
+	git_reference *ref;
+	git_branch_t btype;
+	git_branch_iterator *iter;
+	git_strarray problems = {0};
+	char idstr[GIT_OID_HEXSZ + 1] = {0};
+	git_vector refs;
+
+	cl_git_pass(git_reference_symbolic_create(&ref, _repo, "refs/remotes/test/HEAD", "refs/remotes/test/master", 0, NULL, NULL));
+	git_reference_free(ref);
+
+	cl_git_pass(git_remote_load(&remote, _repo, "test"));
+	cl_git_pass(git_remote_rename(&problems, remote, "renamed"));
+	git_remote_free(remote);
+	cl_assert_equal_i(0, problems.count);
+	git_strarray_free(&problems);
+
+	cl_git_pass(git_vector_init(&refs, 2, (git_vector_cmp) git_reference_cmp));
+	cl_git_pass(git_branch_iterator_new(&iter, _repo, GIT_BRANCH_REMOTE));
+
+	while ((error = git_branch_next(&ref, &btype, iter)) == 0) {
+		cl_git_pass(git_vector_insert(&refs, ref));
+	}
+	cl_assert_equal_i(GIT_ITEROVER, error);
+	git_vector_sort(&refs);
+
+	cl_assert_equal_i(2, refs.length);
+
+	ref = git_vector_get(&refs, 0);
+	cl_assert_equal_s("refs/remotes/renamed/HEAD", git_reference_name(ref));
+	cl_assert_equal_s("refs/remotes/renamed/master", git_reference_symbolic_target(ref));
+	git_reference_free(ref);
+
+	ref = git_vector_get(&refs, 1);
+	cl_assert_equal_s("refs/remotes/renamed/master", git_reference_name(ref));
+	git_oid_fmt(idstr, git_reference_target(ref));
+	cl_assert_equal_s("be3563ae3f795b2b4353bcce3a527ad0a4f7f644", idstr);
+	git_reference_free(ref);
+
+	git_vector_free(&refs);
+
+	cl_git_fail_with(GIT_ITEROVER, git_branch_next(&ref, &btype, iter));
+	git_branch_iterator_free(iter);
+}
-- 
cgit v1.2.3


From d15445646440807a082feb54a1e92d54864137d1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 6 Jun 2014 22:38:26 +0200
Subject: remote: handle symrefs when renaming

A symref inside the namespace gets renamed, we should make it point to
the target's new name.

This is for the origin/HEAD -> origin/master type of situations.
---
 src/remote.c | 49 +++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 39 insertions(+), 10 deletions(-)

diff --git a/src/remote.c b/src/remote.c
index 4e6f350d5..827c54f9d 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1359,19 +1359,24 @@ static int update_branch_remote_config_entry(
 }
 
 static int rename_one_remote_reference(
-	git_reference *reference,
+	git_reference *reference_in,
 	const char *old_remote_name,
 	const char *new_remote_name)
 {
 	int error;
+	git_reference *ref = NULL, *dummy = NULL;
+	git_buf namespace = GIT_BUF_INIT, old_namespace = GIT_BUF_INIT;
 	git_buf new_name = GIT_BUF_INIT;
 	git_buf log_message = GIT_BUF_INIT;
+	size_t pfx_len;
+	const char *target;
 
-	if ((error = git_buf_printf(
-					&new_name,
-					GIT_REFS_REMOTES_DIR "%s%s",
-					new_remote_name,
-					reference->name + strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name))) < 0)
+	if ((error = git_buf_printf(&namespace, GIT_REFS_REMOTES_DIR "%s/", new_remote_name)) < 0)
+		return error;
+
+	pfx_len = strlen(GIT_REFS_REMOTES_DIR) + strlen(old_remote_name) + 1;
+	git_buf_puts(&new_name, namespace.ptr);
+	if ((error = git_buf_puts(&new_name, git_reference_name(reference_in) + pfx_len)) < 0)
 		goto cleanup;
 
 	if ((error = git_buf_printf(&log_message,
@@ -1379,12 +1384,36 @@ static int rename_one_remote_reference(
 					old_remote_name, new_remote_name)) < 0)
 		goto cleanup;
 
-	error = git_reference_rename(
-		NULL, reference, git_buf_cstr(&new_name), 1,
-		NULL, git_buf_cstr(&log_message));
-	git_reference_free(reference);
+	if ((error = git_reference_rename(&ref, reference_in, git_buf_cstr(&new_name), 1,
+					  NULL, git_buf_cstr(&log_message))) < 0)
+		goto cleanup;
+
+	if (git_reference_type(ref) != GIT_REF_SYMBOLIC)
+		goto cleanup;
+
+	/* Handle refs like origin/HEAD -> origin/master */
+	target = git_reference_symbolic_target(ref);
+	if ((error = git_buf_printf(&old_namespace, GIT_REFS_REMOTES_DIR "%s/", old_remote_name)) < 0)
+		goto cleanup;
+
+	if (git__prefixcmp(target, old_namespace.ptr))
+		goto cleanup;
+
+	git_buf_clear(&new_name);
+	git_buf_puts(&new_name, namespace.ptr);
+	if ((error = git_buf_puts(&new_name, target + pfx_len)) < 0)
+		goto cleanup;
+
+	error = git_reference_symbolic_set_target(&dummy, ref, git_buf_cstr(&new_name),
+						  NULL, git_buf_cstr(&log_message));
+
+	git_reference_free(dummy);
 
 cleanup:
+	git_reference_free(reference_in);
+	git_reference_free(ref);
+	git_buf_free(&namespace);
+	git_buf_free(&old_namespace);
 	git_buf_free(&new_name);
 	git_buf_free(&log_message);
 	return error;
-- 
cgit v1.2.3


From 231f350d91e71e3c171041a64f0d238888fad002 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 6 Jun 2014 22:55:34 +0200
Subject: remote: don't free the remote on delete

This was a bad idea. Don't free except in the free function.
---
 include/git2/remote.h         | 2 --
 src/remote.c                  | 2 --
 tests/network/remote/delete.c | 2 +-
 3 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index 8d3744265..cba57c4f6 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -618,8 +618,6 @@ GIT_EXTERN(int) git_remote_is_valid_name(const char *remote_name);
 * All remote-tracking branches and configuration settings
 * for the remote will be removed.
 *
-* once deleted, the passed remote object will be freed and invalidated.
-*
 * @param remote A valid remote
 * @return 0 on success, or an error code.
 */
diff --git a/src/remote.c b/src/remote.c
index 827c54f9d..47b61b1b1 100644
--- a/src/remote.c
+++ b/src/remote.c
@@ -1921,8 +1921,6 @@ int git_remote_delete(git_remote *remote)
 		repo, git_remote_name(remote), NULL)) < 0)
 		return error;
 
-	git_remote_free(remote);
-
 	return 0;
 }
 
diff --git a/tests/network/remote/delete.c b/tests/network/remote/delete.c
index db55b0768..664f47a43 100644
--- a/tests/network/remote/delete.c
+++ b/tests/network/remote/delete.c
@@ -15,6 +15,7 @@ void test_network_remote_delete__initialize(void)
 
 void test_network_remote_delete__cleanup(void)
 {
+	git_remote_free(_remote);
 	cl_git_sandbox_cleanup();
 }
 
@@ -27,7 +28,6 @@ void test_network_remote_delete__cannot_delete_an_anonymous_remote(void)
 	cl_git_fail(git_remote_delete(remote));
 
 	git_remote_free(remote);
-	git_remote_free(_remote);
 }
 
 void test_network_remote_delete__remove_remote_tracking_branches(void)
-- 
cgit v1.2.3


From 6d1b04383ed0744b0346dc9834e34ef7b634a2e0 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Sat, 7 Jun 2014 12:18:24 -0400
Subject: Win32: Fix failing clone_mirror test

---
 tests/online/clone.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/online/clone.c b/tests/online/clone.c
index e269771c0..8a2a64f95 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -194,6 +194,9 @@ void test_online_clone__clone_mirror(void)
 	git_remote_free(remote);
 	git_reference_free(head);
 	git_buf_free(&path);
+	git_repository_free(g_repo);
+	g_repo = NULL;
+
 	cl_fixture_cleanup("./foo.git");
 }
 
-- 
cgit v1.2.3


From daf2a648b1dcc02665dcf9c6f5317db61d84be89 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@hotmail.com>
Date: Sat, 7 Jun 2014 12:18:56 -0400
Subject: Win32: Fix diff::workdir::submodules test #2361

---
 tests/submodule/submodule_helpers.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/submodule/submodule_helpers.c b/tests/submodule/submodule_helpers.c
index 50aa97568..c6d04b40a 100644
--- a/tests/submodule/submodule_helpers.c
+++ b/tests/submodule/submodule_helpers.c
@@ -19,8 +19,8 @@ void rewrite_gitmodules(const char *workdir)
 	cl_git_pass(git_buf_joinpath(&in_f, workdir, "gitmodules"));
 	cl_git_pass(git_buf_joinpath(&out_f, workdir, ".gitmodules"));
 
-	cl_assert((in  = fopen(in_f.ptr, "r")) != NULL);
-	cl_assert((out = fopen(out_f.ptr, "w")) != NULL);
+	cl_assert((in  = fopen(in_f.ptr, "rb")) != NULL);
+	cl_assert((out = fopen(out_f.ptr, "wb")) != NULL);
 
 	while (fgets(line, sizeof(line), in) != NULL) {
 		char *scan = line;
-- 
cgit v1.2.3


From fb5917679dd1cc0ee50d1d88893c07cbcd82471f Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@microsoft.com>
Date: Sat, 7 Jun 2014 12:51:48 -0400
Subject: Win32: Fix object::cache::threadmania test on x64

---
 src/global.c                   |   4 +-
 src/pack-objects.c             |   2 +-
 src/thread-utils.h             |  19 ++++++--
 src/win32/pthread.c            | 108 +++++++++++++++++++++++------------------
 src/win32/pthread.h            |  21 +++++---
 tests/object/cache.c           |   4 +-
 tests/threads/refdb.c          |   4 +-
 tests/threads/thread_helpers.c |   2 +-
 8 files changed, 96 insertions(+), 68 deletions(-)

diff --git a/src/global.c b/src/global.c
index 7da31853e..1c4a7a1a9 100644
--- a/src/global.c
+++ b/src/global.c
@@ -78,7 +78,7 @@ static void git__shutdown(void)
 static DWORD _tls_index;
 static volatile LONG _mutex = 0;
 
-static int synchronized_threads_init()
+static int synchronized_threads_init(void)
 {
 	int error;
 
@@ -112,7 +112,7 @@ int git_threads_init(void)
 	return error;
 }
 
-static void synchronized_threads_shutdown()
+static void synchronized_threads_shutdown(void)
 {
 	/* Shut down any subsystems that have global state */
 	git__shutdown();
diff --git a/src/pack-objects.c b/src/pack-objects.c
index 3d3330ae8..0040a826b 100644
--- a/src/pack-objects.c
+++ b/src/pack-objects.c
@@ -1209,7 +1209,7 @@ static int ll_find_deltas(git_packbuilder *pb, git_pobject **list,
 		git_mutex_unlock(&target->mutex);
 
 		if (!sub_size) {
-			git_thread_join(target->thread, NULL);
+			git_thread_join(&target->thread, NULL);
 			git_cond_free(&target->cond);
 			git_mutex_free(&target->mutex);
 			active_threads--;
diff --git a/src/thread-utils.h b/src/thread-utils.h
index 50d8610a3..0cc7b04ad 100644
--- a/src/thread-utils.h
+++ b/src/thread-utils.h
@@ -40,12 +40,23 @@ typedef git_atomic git_atomic_ssize;
 
 #ifdef GIT_THREADS
 
+#if defined(GIT_WIN32)
+
+#define git_thread git_win32_thread
+#define git_thread_create(thread, attr, start_routine, arg) \
+	git_win32__thread_create(thread, attr, start_routine, arg)
+#define git_thread_join(thread_ptr, status) \
+	git_win32__thread_join(thread_ptr, status)
+
+#else
+
 #define git_thread pthread_t
 #define git_thread_create(thread, attr, start_routine, arg) \
 	pthread_create(thread, attr, start_routine, arg)
-#define git_thread_kill(thread) pthread_cancel(thread)
-#define git_thread_exit(status)	pthread_exit(status)
-#define git_thread_join(id, status) pthread_join(id, status)
+#define git_thread_join(thread_ptr, status) \
+	pthread_join(*(thread_ptr), status)
+
+#endif
 
 #if defined(GIT_WIN32)
 #define git_thread_yield() Sleep(0)
@@ -179,8 +190,6 @@ GIT_INLINE(int64_t) git_atomic64_add(git_atomic64 *a, int64_t addend)
 
 #define git_thread unsigned int
 #define git_thread_create(thread, attr, start_routine, arg) 0
-#define git_thread_kill(thread) (void)0
-#define git_thread_exit(status) (void)0
 #define git_thread_join(id, status) (void)0
 #define git_thread_yield() (void)0
 
diff --git a/src/win32/pthread.c b/src/win32/pthread.c
index db8927471..b14b35621 100644
--- a/src/win32/pthread.c
+++ b/src/win32/pthread.c
@@ -8,32 +8,63 @@
 #include "pthread.h"
 #include "../global.h"
 
-int pthread_create(
-	pthread_t *GIT_RESTRICT thread,
+#define CLEAN_THREAD_EXIT 0x6F012842
+
+/* The thread procedure stub used to invoke the caller's procedure
+ * and capture the return value for later collection. Windows will
+ * only hold a DWORD, but we need to be able to store an entire
+ * void pointer. This requires the indirection. */
+static DWORD WINAPI git_win32__threadproc(LPVOID lpParameter)
+{
+	git_win32_thread *thread = lpParameter;
+
+	thread->value = thread->proc(thread->value);
+
+	return CLEAN_THREAD_EXIT;
+}
+
+int git_win32__thread_create(
+	git_win32_thread *GIT_RESTRICT thread,
 	const pthread_attr_t *GIT_RESTRICT attr,
 	void *(*start_routine)(void*),
 	void *GIT_RESTRICT arg)
 {
 	GIT_UNUSED(attr);
-	*thread = CreateThread(
-		NULL, 0, (LPTHREAD_START_ROUTINE)start_routine, arg, 0, NULL);
-	return *thread ? 0 : -1;
+
+	thread->value = arg;
+	thread->proc = start_routine;
+	thread->thread = CreateThread(
+		NULL, 0, git_win32__threadproc, thread, 0, NULL);
+
+	return thread->thread ? 0 : -1;
 }
 
-int pthread_join(pthread_t thread, void **value_ptr)
+int git_win32__thread_join(
+	git_win32_thread *thread,
+	void **value_ptr)
 {
-	DWORD ret = WaitForSingleObject(thread, INFINITE);
+	DWORD exit;
+
+	if (WaitForSingleObject(thread->thread, INFINITE) != WAIT_OBJECT_0)
+		return -1;
+
+	if (!GetExitCodeThread(thread->thread, &exit)) {
+		CloseHandle(thread->thread);
+		return -1;
+	}
 
-	if (ret == WAIT_OBJECT_0) {
-		if (value_ptr != NULL) {
-			*value_ptr = NULL;
-			GetExitCodeThread(thread, (void *)value_ptr);
-		}
-		CloseHandle(thread);
-		return 0;
+	/* Check for the thread having exited uncleanly. If exit was unclean,
+	 * then we don't have a return value to give back to the caller. */
+	if (exit != CLEAN_THREAD_EXIT) {
+		assert(false);
+		thread->value = NULL;
 	}
 
-	return -1;
+	if (value_ptr)
+		*value_ptr = thread->value;
+
+	CloseHandle(thread->thread);
+	return 0;
 }
 
 int pthread_mutex_init(
@@ -144,9 +175,6 @@ int pthread_num_processors_np(void)
 	return n ? n : 1;
 }
 
-
-static HINSTANCE win32_kernel32_dll;
-
 typedef void (WINAPI *win32_srwlock_fn)(GIT_SRWLOCK *);
 
 static win32_srwlock_fn win32_srwlock_initialize;
@@ -159,7 +187,7 @@ int pthread_rwlock_init(
 	pthread_rwlock_t *GIT_RESTRICT lock,
 	const pthread_rwlockattr_t *GIT_RESTRICT attr)
 {
-	(void)attr;
+	GIT_UNUSED(attr);
 
 	if (win32_srwlock_initialize)
 		win32_srwlock_initialize(&lock->native.srwl);
@@ -217,38 +245,22 @@ int pthread_rwlock_destroy(pthread_rwlock_t *lock)
 	return 0;
 }
 
-
-static void win32_pthread_shutdown(void)
-{
-	if (win32_kernel32_dll) {
-		FreeLibrary(win32_kernel32_dll);
-		win32_kernel32_dll = NULL;
-	}
-}
-
 int win32_pthread_initialize(void)
 {
-	if (win32_kernel32_dll)
-		return 0;
-
-	win32_kernel32_dll = LoadLibrary("Kernel32.dll");
-	if (!win32_kernel32_dll) {
-		giterr_set(GITERR_OS, "Could not load Kernel32.dll!");
-		return -1;
+	HMODULE hModule = GetModuleHandleW(L"kernel32");
+
+	if (hModule) {
+		win32_srwlock_initialize = (win32_srwlock_fn)
+			GetProcAddress(hModule, "InitializeSRWLock");
+		win32_srwlock_acquire_shared = (win32_srwlock_fn)
+			GetProcAddress(hModule, "AcquireSRWLockShared");
+		win32_srwlock_release_shared = (win32_srwlock_fn)
+			GetProcAddress(hModule, "ReleaseSRWLockShared");
+		win32_srwlock_acquire_exclusive = (win32_srwlock_fn)
+			GetProcAddress(hModule, "AcquireSRWLockExclusive");
+		win32_srwlock_release_exclusive = (win32_srwlock_fn)
+			GetProcAddress(hModule, "ReleaseSRWLockExclusive");
 	}
 
-	win32_srwlock_initialize = (win32_srwlock_fn)
-		GetProcAddress(win32_kernel32_dll, "InitializeSRWLock");
-	win32_srwlock_acquire_shared = (win32_srwlock_fn)
-		GetProcAddress(win32_kernel32_dll, "AcquireSRWLockShared");
-	win32_srwlock_release_shared = (win32_srwlock_fn)
-		GetProcAddress(win32_kernel32_dll, "ReleaseSRWLockShared");
-	win32_srwlock_acquire_exclusive = (win32_srwlock_fn)
-		GetProcAddress(win32_kernel32_dll, "AcquireSRWLockExclusive");
-	win32_srwlock_release_exclusive = (win32_srwlock_fn)
-		GetProcAddress(win32_kernel32_dll, "ReleaseSRWLockExclusive");
-
-	git__on_shutdown(win32_pthread_shutdown);
-
 	return 0;
 }
diff --git a/src/win32/pthread.h b/src/win32/pthread.h
index af5b121f0..a15504ed5 100644
--- a/src/win32/pthread.h
+++ b/src/win32/pthread.h
@@ -16,13 +16,18 @@
 #	define GIT_RESTRICT __restrict__
 #endif
 
+typedef struct {
+	HANDLE thread;
+	void *(*proc)(void *);
+	void *value;
+} git_win32_thread;
+
 typedef int pthread_mutexattr_t;
 typedef int pthread_condattr_t;
 typedef int pthread_attr_t;
 typedef int pthread_rwlockattr_t;
 
 typedef CRITICAL_SECTION pthread_mutex_t;
-typedef HANDLE pthread_t;
 typedef HANDLE pthread_cond_t;
 
 typedef struct { void *Ptr; } GIT_SRWLOCK;
@@ -36,13 +41,15 @@ typedef struct {
 
 #define PTHREAD_MUTEX_INITIALIZER  {(void*)-1}
 
-int pthread_create(
-	pthread_t *GIT_RESTRICT thread,
-	const pthread_attr_t *GIT_RESTRICT attr,
-	void *(*start_routine)(void*),
-	void *GIT_RESTRICT arg);
+int git_win32__thread_create(
+	git_win32_thread *GIT_RESTRICT,
+	const pthread_attr_t *GIT_RESTRICT,
+	void *(*) (void *),
+	void *GIT_RESTRICT);
 
-int pthread_join(pthread_t, void **);
+int git_win32__thread_join(
+	git_win32_thread *,
+	void **);
 
 int pthread_mutex_init(
 	pthread_mutex_t *GIT_RESTRICT mutex,
diff --git a/tests/object/cache.c b/tests/object/cache.c
index b927b2514..bdf12da7a 100644
--- a/tests/object/cache.c
+++ b/tests/object/cache.c
@@ -229,7 +229,7 @@ void test_object_cache__threadmania(void)
 
 #ifdef GIT_THREADS
 		for (th = 0; th < THREADCOUNT; ++th) {
-			cl_git_pass(git_thread_join(t[th], &data));
+			cl_git_pass(git_thread_join(&t[th], &data));
 			cl_assert_equal_i(th, ((int *)data)[0]);
 			git__free(data);
 		}
@@ -276,7 +276,7 @@ void test_object_cache__fast_thread_rush(void)
 #ifdef GIT_THREADS
 		for (th = 0; th < THREADCOUNT*2; ++th) {
 			void *rval;
-			cl_git_pass(git_thread_join(t[th], &rval));
+			cl_git_pass(git_thread_join(&t[th], &rval));
 			cl_assert_equal_i(th, *((int *)rval));
 		}
 #endif
diff --git a/tests/threads/refdb.c b/tests/threads/refdb.c
index c1cd29677..94a21f259 100644
--- a/tests/threads/refdb.c
+++ b/tests/threads/refdb.c
@@ -84,7 +84,7 @@ void test_threads_refdb__iterator(void)
 
 #ifdef GIT_THREADS
 		for (t = 0; t < THREADS; ++t) {
-			cl_git_pass(git_thread_join(th[t], NULL));
+			cl_git_pass(git_thread_join(&th[t], NULL));
 		}
 #endif
 
@@ -215,7 +215,7 @@ void test_threads_refdb__edit_while_iterate(void)
 	}
 
 	for (t = 0; t < THREADS; ++t) {
-		cl_git_pass(git_thread_join(th[t], NULL));
+		cl_git_pass(git_thread_join(&th[t], NULL));
 	}
 #endif
 }
diff --git a/tests/threads/thread_helpers.c b/tests/threads/thread_helpers.c
index 25370dddb..760a7bd33 100644
--- a/tests/threads/thread_helpers.c
+++ b/tests/threads/thread_helpers.c
@@ -32,7 +32,7 @@ void run_in_parallel(
 
 #ifdef GIT_THREADS
 		for (t = 0; t < threads; ++t)
-			cl_git_pass(git_thread_join(th[t], NULL));
+			cl_git_pass(git_thread_join(&th[t], NULL));
 		memset(th, 0, threads * sizeof(git_thread));
 #endif
 
-- 
cgit v1.2.3


From 1b4e29b7f68ce80bb01fd878f6ddc6cf20819581 Mon Sep 17 00:00:00 2001
From: Philip Kelley <phkelley@microsoft.com>
Date: Sat, 7 Jun 2014 13:56:39 -0400
Subject: React to review feedback

---
 src/thread-utils.h  | 21 ++++++++-------------
 src/win32/pthread.c |  9 +++++----
 src/win32/pthread.h | 14 +++++++++++++-
 3 files changed, 26 insertions(+), 18 deletions(-)

diff --git a/src/thread-utils.h b/src/thread-utils.h
index 0cc7b04ad..daec14eeb 100644
--- a/src/thread-utils.h
+++ b/src/thread-utils.h
@@ -40,21 +40,16 @@ typedef git_atomic git_atomic_ssize;
 
 #ifdef GIT_THREADS
 
-#if defined(GIT_WIN32)
-
-#define git_thread git_win32_thread
-#define git_thread_create(thread, attr, start_routine, arg) \
-	git_win32__thread_create(thread, attr, start_routine, arg)
-#define git_thread_join(thread_ptr, status) \
-	git_win32__thread_join(thread_ptr, status)
+#if !defined(GIT_WIN32)
 
-#else
+typedef struct {
+	pthread_t thread;
+} git_thread;
 
-#define git_thread pthread_t
-#define git_thread_create(thread, attr, start_routine, arg) \
-	pthread_create(thread, attr, start_routine, arg)
-#define git_thread_join(thread_ptr, status) \
-	pthread_join(*(thread_ptr), status)
+#define git_thread_create(git_thread_ptr, attr, start_routine, arg) \
+	pthread_create(&(git_thread_ptr)->thread, attr, start_routine, arg)
+#define git_thread_join(git_thread_ptr, status) \
+	pthread_join((git_thread_ptr)->thread, status)
 
 #endif
 
diff --git a/src/win32/pthread.c b/src/win32/pthread.c
index b14b35621..ec45ecbe5 100644
--- a/src/win32/pthread.c
+++ b/src/win32/pthread.c
@@ -18,7 +18,7 @@ static DWORD WINAPI git_win32__threadproc(LPVOID lpParameter)
 {
 	git_win32_thread *thread = lpParameter;
 
-	thread->value = thread->proc(thread->value);
+	thread->result = thread->proc(thread->param);
 
 	return CLEAN_THREAD_EXIT;
 }
@@ -31,7 +31,8 @@ int git_win32__thread_create(
 {
 	GIT_UNUSED(attr);
 
-	thread->value = arg;
+	thread->result = NULL;
+	thread->param = arg;
 	thread->proc = start_routine;
 	thread->thread = CreateThread(
 		NULL, 0, git_win32__threadproc, thread, 0, NULL);
@@ -57,11 +58,11 @@ int git_win32__thread_join(
 	 * then we don't have a return value to give back to the caller. */
 	if (exit != CLEAN_THREAD_EXIT) {
 		assert(false);
-		thread->value = NULL;
+		thread->result = NULL;
 	}
 
 	if (value_ptr)
-		*value_ptr = thread->value;
+		*value_ptr = thread->result;
 
 	CloseHandle(thread->thread);
 	return 0;
diff --git a/src/win32/pthread.h b/src/win32/pthread.h
index a15504ed5..e4826ca7f 100644
--- a/src/win32/pthread.h
+++ b/src/win32/pthread.h
@@ -19,7 +19,8 @@
 typedef struct {
 	HANDLE thread;
 	void *(*proc)(void *);
-	void *value;
+	void *param;
+	void *result;
 } git_win32_thread;
 
 typedef int pthread_mutexattr_t;
@@ -51,6 +52,17 @@ int git_win32__thread_join(
 	git_win32_thread *,
 	void **);
 
+#ifdef GIT_THREADS
+
+typedef git_win32_thread git_thread;
+
+#define git_thread_create(git_thread_ptr, attr, start_routine, arg) \
+	git_win32__thread_create(git_thread_ptr, attr, start_routine, arg)
+#define git_thread_join(git_thread_ptr, status) \
+	git_win32__thread_join(git_thread_ptr, status)
+
+#endif
+
 int pthread_mutex_init(
 	pthread_mutex_t *GIT_RESTRICT mutex,
 	const pthread_mutexattr_t *GIT_RESTRICT mutexattr);
-- 
cgit v1.2.3


From 99807672055b6bb86e44311a199592ceb35c72bd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 8 Jun 2014 19:42:54 +0200
Subject: Change SOVERSION at API breaks

Since the SOVERSION doesn't need to follow the library's version and
simply needs to be monotonically increasing whenever we release
something that breaks the ABI, we can set some number and allow multiple
versions of the library to be installed side-by-side.

We start here with the minor version as that's what we release for now,
and it allows to backport this change to earlier versions.
---
 CMakeLists.txt         | 5 ++++-
 include/git2/version.h | 2 ++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6f731d491..6f1a97edb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -127,6 +127,9 @@ STRING(REGEX REPLACE "^.*LIBGIT2_VERSION \"[0-9]+\\.([0-9]+).*$" "\\1" LIBGIT2_V
 STRING(REGEX REPLACE "^.*LIBGIT2_VERSION \"[0-9]+\\.[0-9]+\\.([0-9]+).*$" "\\1" LIBGIT2_VERSION_REV "${GIT2_HEADER}")
 SET(LIBGIT2_VERSION_STRING "${LIBGIT2_VERSION_MAJOR}.${LIBGIT2_VERSION_MINOR}.${LIBGIT2_VERSION_REV}")
 
+FILE(STRINGS "include/git2/version.h" GIT2_HEADER_SOVERSION REGEX "^#define LIBGIT2_SOVERSION [0-9]+$")
+STRING(REGEX REPLACE "^.*LIBGIT2_SOVERSION ([0-9]+)$" "\\1" LIBGIT2_SOVERSION "${GIT2_HEADER_SOVERSION}")
+
 # Find required dependencies
 INCLUDE_DIRECTORIES(src include)
 
@@ -397,7 +400,7 @@ MSVC_SPLIT_SOURCES(git2)
 
 IF (SONAME)
 	SET_TARGET_PROPERTIES(git2 PROPERTIES VERSION ${LIBGIT2_VERSION_STRING})
-	SET_TARGET_PROPERTIES(git2 PROPERTIES SOVERSION ${LIBGIT2_VERSION_MAJOR})
+	SET_TARGET_PROPERTIES(git2 PROPERTIES SOVERSION ${LIBGIT2_SOVERSION})
 	IF (LIBGIT2_FILENAME)
 		ADD_DEFINITIONS(-DLIBGIT2_FILENAME=\"${LIBGIT2_FILENAME}\")
 		SET_TARGET_PROPERTIES(git2 PROPERTIES OUTPUT_NAME ${LIBGIT2_FILENAME})
diff --git a/include/git2/version.h b/include/git2/version.h
index c4c5e8eb1..9d8a74edd 100644
--- a/include/git2/version.h
+++ b/include/git2/version.h
@@ -12,4 +12,6 @@
 #define LIBGIT2_VER_MINOR 20
 #define LIBGIT2_VER_REVISION 0
 
+#define LIBGIT2_SOVERSION 20
+
 #endif
-- 
cgit v1.2.3


From 4fb32a44f928de534f79c9642e2cdb1ab9d9129b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Sun, 8 Jun 2014 20:01:02 +0200
Subject: Bump version to 0.21.0

Bump library version to 0.21.0 and SONAME to 21
---
 include/git2/version.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/include/git2/version.h b/include/git2/version.h
index 9d8a74edd..5bda42735 100644
--- a/include/git2/version.h
+++ b/include/git2/version.h
@@ -7,11 +7,11 @@
 #ifndef INCLUDE_git_version_h__
 #define INCLUDE_git_version_h__
 
-#define LIBGIT2_VERSION "0.20.0"
+#define LIBGIT2_VERSION "0.21.0"
 #define LIBGIT2_VER_MAJOR 0
-#define LIBGIT2_VER_MINOR 20
+#define LIBGIT2_VER_MINOR 21
 #define LIBGIT2_VER_REVISION 0
 
-#define LIBGIT2_SOVERSION 20
+#define LIBGIT2_SOVERSION 21
 
 #endif
-- 
cgit v1.2.3


From 281da0043ca6fe8c5ba6bc24c24c10d80db93956 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 9 Jun 2014 19:35:41 +0200
Subject: remote: fix rename docs

---
 include/git2/remote.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/include/git2/remote.h b/include/git2/remote.h
index cba57c4f6..c72c9c8cc 100644
--- a/include/git2/remote.h
+++ b/include/git2/remote.h
@@ -577,9 +577,6 @@ GIT_EXTERN(void) git_remote_set_autotag(
  * strarray on succesful return.
  * @param remote the remote to rename
  * @param new_name the new name the remote should bear
- * @param callback Optional callback to notify the consumer of fetch refspecs
- * that haven't been automatically updated and need potential manual tweaking.
- * @param payload Additional data to pass to the callback
  * @return 0, GIT_EINVALIDSPEC, GIT_EEXISTS or an error code
  */
 GIT_EXTERN(int) git_remote_rename(
-- 
cgit v1.2.3


From 2c11d2eeb550ed2f795c714829b3fd3788b2ab68 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Mon, 9 Jun 2014 23:23:53 +0200
Subject: treebuilder: insert sorted

By inserting in the right position, we can keep the vector sorted,
making entry insertion almost twice as fast.
---
 src/tree.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/tree.c b/src/tree.c
index 94f779eca..b64efe460 100644
--- a/src/tree.c
+++ b/src/tree.c
@@ -460,7 +460,7 @@ static int append_entry(
 	git_oid_cpy(&entry->oid, id);
 	entry->attr = (uint16_t)filemode;
 
-	if (git_vector_insert(&bld->entries, entry) < 0) {
+	if (git_vector_insert_sorted(&bld->entries, entry, NULL) < 0) {
 		git__free(entry);
 		return -1;
 	}
@@ -671,7 +671,7 @@ int git_treebuilder_insert(
 		entry = alloc_entry(filename);
 		GITERR_CHECK_ALLOC(entry);
 
-		if (git_vector_insert(&bld->entries, entry) < 0) {
+		if (git_vector_insert_sorted(&bld->entries, entry, NULL) < 0) {
 			git__free(entry);
 			return -1;
 		}
-- 
cgit v1.2.3


From 17fbf852a5c210cfa6a4e1e906dd9e35d2adc1c1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Tue, 10 Jun 2014 03:53:26 +0200
Subject: pathspec: use C guards in header

---
 include/git2/pathspec.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/include/git2/pathspec.h b/include/git2/pathspec.h
index 2fb0bb716..de6f027c5 100644
--- a/include/git2/pathspec.h
+++ b/include/git2/pathspec.h
@@ -12,6 +12,8 @@
 #include "strarray.h"
 #include "diff.h"
 
+GIT_BEGIN_DECL
+
 /**
  * Compiled pathspec
  */
@@ -257,4 +259,5 @@ GIT_EXTERN(size_t) git_pathspec_match_list_failed_entrycount(
 GIT_EXTERN(const char *) git_pathspec_match_list_failed_entry(
 	const git_pathspec_match_list *m, size_t pos);
 
+GIT_END_DECL
 #endif
-- 
cgit v1.2.3


From f9a97667945a87abfca50e153a7d2fdf5c4319a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 11 Jun 2014 00:06:44 +0200
Subject: revwalk: more sensible array handling

Instead of using a sentinel empty value to detect the last commit, let's
check for when we get a NULL from popping the stack, which lets us know
when we're done.

The current code causes us to read uninitialized data, although only on
RHEL/CentOS 6 in release mode. This is a readability win overall.
---
 src/revwalk.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/revwalk.c b/src/revwalk.c
index 7aedd1f44..530c9705e 100644
--- a/src/revwalk.c
+++ b/src/revwalk.c
@@ -48,7 +48,7 @@ static int mark_uninteresting(git_revwalk *walk, git_commit_list_node *commit)
 
 	assert(commit);
 
-	git_array_alloc(pending);
+	git_array_init_to_size(pending, 2);
 	GITERR_CHECK_ARRAY(pending);
 
 	do {
@@ -67,7 +67,7 @@ static int mark_uninteresting(git_revwalk *walk, git_commit_list_node *commit)
 		tmp = git_array_pop(pending);
 		commit = tmp ? *tmp : NULL;
 
-	} while (git_array_size(pending) > 0);
+	} while (commit != NULL);
 
 	git_array_clear(pending);
 
-- 
cgit v1.2.3


From 1d3364ac9d2bcd2d194f0afa0d301456d0d4e276 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 11 Jun 2014 20:52:15 +0200
Subject: netops: init OpenSSL once under lock

The OpenSSL init functions are not reentrant, which means that running
multiple fetches in parallel can cause us to crash.

Use a mutex to init OpenSSL, and since we're adding this extra checks,
init it only once.
---
 src/global.c |  3 +++
 src/global.h |  2 ++
 src/netops.c | 34 ++++++++++++++++++++++++++++++++--
 3 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/src/global.c b/src/global.c
index 7da31853e..fe410587e 100644
--- a/src/global.c
+++ b/src/global.c
@@ -16,6 +16,9 @@ git_mutex git__mwindow_mutex;
 
 #define MAX_SHUTDOWN_CB 8
 
+git_mutex git__ssl_mutex;
+git_atomic git__ssl_init;
+
 static git_global_shutdown_fn git__shutdown_callbacks[MAX_SHUTDOWN_CB];
 static git_atomic git__n_shutdown_callbacks;
 static git_atomic git__n_inits;
diff --git a/src/global.h b/src/global.h
index 778250376..245f811e4 100644
--- a/src/global.h
+++ b/src/global.h
@@ -18,6 +18,8 @@ typedef struct {
 git_global_st *git__global_state(void);
 
 extern git_mutex git__mwindow_mutex;
+extern git_mutex git__ssl_mutex;
+extern git_atomic git__ssl_init;
 
 #define GIT_GLOBAL (git__global_state())
 
diff --git a/src/netops.c b/src/netops.c
index a0193a022..7bce159ad 100644
--- a/src/netops.c
+++ b/src/netops.c
@@ -33,6 +33,7 @@
 #include "posix.h"
 #include "buffer.h"
 #include "http_parser.h"
+#include "global.h"
 
 #ifdef GIT_WIN32
 static void net_set_error(const char *str)
@@ -386,12 +387,41 @@ cert_fail_name:
 	return -1;
 }
 
-static int ssl_setup(gitno_socket *socket, const char *host, int flags)
+/**
+ * The OpenSSL init functions are not reentrant so we need to init
+ * them under lock.
+ */
+static int init_ssl(void)
 {
-	int ret;
+	if (git__ssl_init.val)
+		return 0;
+
+	if (git_mutex_lock(&git__ssl_mutex) < 0) {
+		giterr_set(GITERR_OS, "failed to acquire ssl init lock");
+		return -1;
+	}
+
+	/* if we had to wait for the lock, someone else did it, we can return */
+	if (git__ssl_init.val)
+		return 0;
+
 
 	SSL_library_init();
 	SSL_load_error_strings();
+
+	git_atomic_set(&git__ssl_init, 1);
+	git_mutex_unlock(&git__ssl_mutex);
+
+	return 0;
+}
+
+static int ssl_setup(gitno_socket *socket, const char *host, int flags)
+{
+	int ret;
+
+	if (init_ssl() < 0)
+		return -1;
+
 	socket->ssl.ctx = SSL_CTX_new(SSLv23_method());
 	if (socket->ssl.ctx == NULL)
 		return ssl_set_error(&socket->ssl, 0);
-- 
cgit v1.2.3


From 76f76162b2af4b5dfe093654851339b957f7305a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 11 Jun 2014 21:14:45 +0200
Subject: remote: update documentation

Add docs for git_clone_local_t and move the docs for the
git_clone_options to each field.
---
 include/git2/clone.h | 78 ++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 60 insertions(+), 18 deletions(-)

diff --git a/include/git2/clone.h b/include/git2/clone.h
index b2c944a78..05b7522ce 100644
--- a/include/git2/clone.h
+++ b/include/git2/clone.h
@@ -23,10 +23,31 @@
  */
 GIT_BEGIN_DECL
 
+/**
+ * Options for bypassing the git-aware transport on clone. Bypassing
+ * it means that instead of a fetch, libgit2 will copy the object
+ * database directory instead of figuring out what it needs, which is
+ * faster. If possible, it will hardlink the files to save space.
+ */
 typedef enum {
+	/**
+	 * Auto-detect (default), libgit2 will bypass the git-aware
+	 * transport for local paths, but use a normal fetch for
+	 * `file://` urls.
+	 */
 	GIT_CLONE_LOCAL_AUTO,
+	/**
+	 * Bypass the git-aware transport even for a `file://` url.
+	 */
 	GIT_CLONE_LOCAL,
+	/**
+	 * Do no bypass the git-aware transport
+	 */
 	GIT_CLONE_NO_LOCAL,
+	/**
+	 * Bypass the git-aware transport, but do not try to use
+	 * hardlinks.
+	 */
 	GIT_CLONE_LOCAL_NO_LINKS,
 } git_clone_local_t;
 
@@ -36,37 +57,58 @@ typedef enum {
  * Use the GIT_CLONE_OPTIONS_INIT to get the default settings, like this:
  *
  *		git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
- *
- * - `checkout_opts` are option passed to the checkout step.  To disable
- *   checkout, set the `checkout_strategy` to GIT_CHECKOUT_NONE.
- *   Generally you will want the use GIT_CHECKOUT_SAFE_CREATE to create
- *   all files in the working directory for the newly cloned repository.
- * - `bare` should be set to zero (false) to create a standard repo,
- *   or non-zero for a bare repo
- * - `ignore_cert_errors` should be set to 1 if errors validating the
- *   remote host's certificate should be ignored.
- *
- *   ** "origin" remote options: **
- *
- * - `remote_name` is the name to be given to the "origin" remote.  The
- *   default is "origin".
- * - `checkout_branch` gives the name of the branch to checkout.  NULL
- *   means use the remote's HEAD.
- * - `signature` is the identity used when updating the reflog. NULL means to
- *   use the default signature using the config.
  */
 
 typedef struct git_clone_options {
 	unsigned int version;
 
+	/**
+	 * These options are passed to the checkout step. To disable
+	 * checkout, set the `checkout_strategy` to
+	 * `GIT_CHECKOUT_NONE`. Generally you will want the use
+	 * GIT_CHECKOUT_SAFE_CREATE to create all files in the working
+	 * directory for the newly cloned repository.
+	 */
 	git_checkout_options checkout_opts;
+
+	/**
+	 * Callbacks to use for reporting fetch progress.
+	 */
 	git_remote_callbacks remote_callbacks;
 
+	/**
+	 * Set to zero (false) to create a standard repo, or non-zero
+	 * for a bare repo
+	 */
 	int bare;
+
+	/**
+	 * Set to 1 if errors validating the remote host's certificate
+	 * should be ignored.
+	 */
 	int ignore_cert_errors;
+
+	/**
+	 * Whether to use a fetch or copy the object database.
+	 */
 	git_clone_local_t local;
+
+	/**
+	 * The name to be given to the remote that will be
+	 * created. The default is "origin".
+	 */
 	const char *remote_name;
+
+	/**
+	 * The name of the branch to checkout. NULL means use the
+	 * remote's default branch.
+	 */
 	const char* checkout_branch;
+
+	/**
+	 * The identity used when updating the reflog. NULL means to
+	 * use the default signature using the config.
+	 */
 	git_signature *signature;
 } git_clone_options;
 
-- 
cgit v1.2.3


From 5fa0494328b78a1ce8dba983c3f8028d123a62a4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Wed, 11 Jun 2014 23:19:48 +0200
Subject: ssl: use locking

When using in a multithreaded context, OpenSSL needs to lock, and leaves
it up to application to provide said locks.

We were not doing this, and it's just luck that's kept us from crashing
up to now.
---
 src/netops.c | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/src/netops.c b/src/netops.c
index 7bce159ad..ba1a329e0 100644
--- a/src/netops.c
+++ b/src/netops.c
@@ -35,6 +35,11 @@
 #include "http_parser.h"
 #include "global.h"
 
+#if defined(GIT_SSL) && defined(GIT_THREADS)
+/* OpenSSL wants us to keep an array of locks */
+static git_mutex *openssl_locks;
+#endif
+
 #ifdef GIT_WIN32
 static void net_set_error(const char *str)
 {
@@ -387,6 +392,24 @@ cert_fail_name:
 	return -1;
 }
 
+#ifdef GIT_THREADS
+void openssl_locking_function(int mode, int n, const char *file, int line)
+{
+	int lock;
+
+	GIT_UNUSED(file);
+	GIT_UNUSED(line);
+
+	lock = mode & CRYPTO_LOCK;
+
+	if (lock) {
+		git_mutex_lock(&openssl_locks[n]);
+	} else {
+		git_mutex_unlock(&openssl_locks[n]);
+	}
+}
+#endif
+
 /**
  * The OpenSSL init functions are not reentrant so we need to init
  * them under lock.
@@ -409,6 +432,25 @@ static int init_ssl(void)
 	SSL_library_init();
 	SSL_load_error_strings();
 
+#ifdef GIT_THREADS
+	{
+		int num_locks, i;
+
+
+		CRYPTO_set_locking_callback(openssl_locking_function);
+
+		num_locks = CRYPTO_num_locks();
+		openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
+		for (i = 0; i < num_locks; i++) {
+			if (git_mutex_init(&openssl_locks[i]) < 0) {
+				git_mutex_unlock(&git__ssl_mutex);
+				giterr_set(GITERR_SSL, "failed to init lock %d", i);
+				return -1;
+			}
+		}
+	}
+#endif
+
 	git_atomic_set(&git__ssl_init, 1);
 	git_mutex_unlock(&git__ssl_mutex);
 
-- 
cgit v1.2.3


From cf15ac8aa96304a36699ae65398b7adac0d2ddde Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 12 Jun 2014 03:20:34 +0200
Subject: ssl: cargo-cult thread safety

OpenSSL's tests init everything in the main thread, so let's do that.
---
 src/global.c | 20 ++++++++++++++++++++
 src/global.h |  5 +++++
 src/netops.c | 43 +++++++++++++++++++++----------------------
 src/netops.h |  1 -
 4 files changed, 46 insertions(+), 23 deletions(-)

diff --git a/src/global.c b/src/global.c
index fe410587e..e9c940f2c 100644
--- a/src/global.c
+++ b/src/global.c
@@ -16,6 +16,11 @@ git_mutex git__mwindow_mutex;
 
 #define MAX_SHUTDOWN_CB 8
 
+#ifdef GIT_SSL
+# include <openssl/ssl.h>
+SSL_CTX *git__ssl_ctx;
+#endif
+
 git_mutex git__ssl_mutex;
 git_atomic git__ssl_init;
 
@@ -160,6 +165,15 @@ static pthread_key_t _tls_key;
 static pthread_once_t _once_init = PTHREAD_ONCE_INIT;
 int init_error = 0;
 
+static void init_ssl(void)
+{
+#ifdef GIT_SSL
+	SSL_load_error_strings();
+	OpenSSL_add_ssl_algorithms();
+	git__ssl_ctx = SSL_CTX_new(SSLv23_method());
+#endif
+}
+
 static void cb__free_status(void *st)
 {
 	git__free(st);
@@ -169,12 +183,18 @@ static void init_once(void)
 {
 	if ((init_error = git_mutex_init(&git__mwindow_mutex)) != 0)
 		return;
+	if ((init_error = git_mutex_init(&git__ssl_mutex)) != 0)
+		return;
 	pthread_key_create(&_tls_key, &cb__free_status);
 
+
 	/* Initialize any other subsystems that have global state */
 	if ((init_error = git_hash_global_init()) >= 0)
 		init_error = git_sysdir_global_init();
 
+	/* OpenSSL needs to be initialized from the main thread */
+	init_ssl();
+
 	GIT_MEMORY_BARRIER;
 }
 
diff --git a/src/global.h b/src/global.h
index 245f811e4..8904e2de5 100644
--- a/src/global.h
+++ b/src/global.h
@@ -15,6 +15,11 @@ typedef struct {
 	git_error error_t;
 } git_global_st;
 
+#ifdef GIT_SSL
+# include <openssl/ssl.h>
+extern SSL_CTX *git__ssl_ctx;
+#endif
+
 git_global_st *git__global_state(void);
 
 extern git_mutex git__mwindow_mutex;
diff --git a/src/netops.c b/src/netops.c
index ba1a329e0..54804d418 100644
--- a/src/netops.c
+++ b/src/netops.c
@@ -163,7 +163,7 @@ void gitno_buffer_setup_callback(
 void gitno_buffer_setup(gitno_socket *socket, gitno_buffer *buf, char *data, size_t len)
 {
 #ifdef GIT_SSL
-	if (socket->ssl.ctx) {
+	if (socket->ssl.ssl) {
 		gitno_buffer_setup_callback(socket, buf, data, len, gitno__recv_ssl, NULL);
 		return;
 	}
@@ -208,7 +208,6 @@ static int gitno_ssl_teardown(gitno_ssl *ssl)
 		ret = 0;
 
 	SSL_free(ssl->ssl);
-	SSL_CTX_free(ssl->ctx);
 	return ret;
 }
 
@@ -428,30 +427,39 @@ static int init_ssl(void)
 	if (git__ssl_init.val)
 		return 0;
 
-
-	SSL_library_init();
-	SSL_load_error_strings();
+	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);
+	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);
+	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx)) {
+		unsigned long err = ERR_get_error();
+		giterr_set(GITERR_SSL, "failed to set verify paths: %s\n", ERR_error_string(err, NULL));
+		return -1;
+	}
 
 #ifdef GIT_THREADS
 	{
 		int num_locks, i;
 
-
-		CRYPTO_set_locking_callback(openssl_locking_function);
-
 		num_locks = CRYPTO_num_locks();
 		openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
+		if (openssl_locks == NULL) {
+			git_mutex_unlock(&git__ssl_mutex);
+			return -1;
+		}
+		GITERR_CHECK_ALLOC(openssl_locks);
+
 		for (i = 0; i < num_locks; i++) {
-			if (git_mutex_init(&openssl_locks[i]) < 0) {
+			if (git_mutex_init(&openssl_locks[i]) != 0) {
 				git_mutex_unlock(&git__ssl_mutex);
 				giterr_set(GITERR_SSL, "failed to init lock %d", i);
 				return -1;
 			}
 		}
 	}
+
+	CRYPTO_set_locking_callback(openssl_locking_function);
 #endif
 
-	git_atomic_set(&git__ssl_init, 1);
+	git_atomic_inc(&git__ssl_init);
 	git_mutex_unlock(&git__ssl_mutex);
 
 	return 0;
@@ -464,16 +472,7 @@ static int ssl_setup(gitno_socket *socket, const char *host, int flags)
 	if (init_ssl() < 0)
 		return -1;
 
-	socket->ssl.ctx = SSL_CTX_new(SSLv23_method());
-	if (socket->ssl.ctx == NULL)
-		return ssl_set_error(&socket->ssl, 0);
-
-	SSL_CTX_set_mode(socket->ssl.ctx, SSL_MODE_AUTO_RETRY);
-	SSL_CTX_set_verify(socket->ssl.ctx, SSL_VERIFY_NONE, NULL);
-	if (!SSL_CTX_set_default_verify_paths(socket->ssl.ctx))
-		return ssl_set_error(&socket->ssl, 0);
-
-	socket->ssl.ssl = SSL_new(socket->ssl.ctx);
+	socket->ssl.ssl = SSL_new(git__ssl_ctx);
 	if (socket->ssl.ssl == NULL)
 		return ssl_set_error(&socket->ssl, 0);
 
@@ -610,7 +609,7 @@ int gitno_send(gitno_socket *socket, const char *msg, size_t len, int flags)
 	size_t off = 0;
 
 #ifdef GIT_SSL
-	if (socket->ssl.ctx)
+	if (socket->ssl.ssl)
 		return gitno_send_ssl(&socket->ssl, msg, len, flags);
 #endif
 
@@ -631,7 +630,7 @@ int gitno_send(gitno_socket *socket, const char *msg, size_t len, int flags)
 int gitno_close(gitno_socket *s)
 {
 #ifdef GIT_SSL
-	if (s->ssl.ctx &&
+	if (s->ssl.ssl &&
 		gitno_ssl_teardown(&s->ssl) < 0)
 		return -1;
 #endif
diff --git a/src/netops.h b/src/netops.h
index 8e3a2524f..dfb4ab7b4 100644
--- a/src/netops.h
+++ b/src/netops.h
@@ -16,7 +16,6 @@
 
 struct gitno_ssl {
 #ifdef GIT_SSL
-	SSL_CTX *ctx;
 	SSL *ssl;
 #else
 	size_t dummy;
-- 
cgit v1.2.3


From 8f897b6f2f4742a7d9189528e082cfe7cecd6f29 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 12 Jun 2014 14:50:08 +0200
Subject: ssl: init also without threads

---
 src/global.c | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/global.c b/src/global.c
index e9c940f2c..41428ec42 100644
--- a/src/global.c
+++ b/src/global.c
@@ -47,6 +47,15 @@ static void git__shutdown(void)
 
 }
 
+static void init_ssl(void)
+{
+#ifdef GIT_SSL
+	SSL_load_error_strings();
+	OpenSSL_add_ssl_algorithms();
+	git__ssl_ctx = SSL_CTX_new(SSLv23_method());
+#endif
+}
+
 /**
  * Handle the global state with TLS
  *
@@ -165,15 +174,6 @@ static pthread_key_t _tls_key;
 static pthread_once_t _once_init = PTHREAD_ONCE_INIT;
 int init_error = 0;
 
-static void init_ssl(void)
-{
-#ifdef GIT_SSL
-	SSL_load_error_strings();
-	OpenSSL_add_ssl_algorithms();
-	git__ssl_ctx = SSL_CTX_new(SSLv23_method());
-#endif
-}
-
 static void cb__free_status(void *st)
 {
 	git__free(st);
@@ -248,6 +248,7 @@ static git_global_st __state;
 
 int git_threads_init(void)
 {
+	init_ssl();
 	git_atomic_inc(&git__n_inits);
 	return 0;
 }
-- 
cgit v1.2.3


From 081e76bac26e1ed6adafb402d15b30c622866d61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Thu, 12 Jun 2014 16:20:52 +0200
Subject: ssl: init everything all the time

Bring together all of the OpenSSL initialization to
git_threads_init() so it's together and doesn't need locks.

Moving it here also gives us libssh2 thread safety (when built against
openssl).
---
 src/global.c | 53 ++++++++++++++++++++++++++++++++++----
 src/global.h |  2 --
 src/netops.c | 83 +++---------------------------------------------------------
 3 files changed, 51 insertions(+), 87 deletions(-)

diff --git a/src/global.c b/src/global.c
index 41428ec42..b144b050a 100644
--- a/src/global.c
+++ b/src/global.c
@@ -19,11 +19,9 @@ git_mutex git__mwindow_mutex;
 #ifdef GIT_SSL
 # include <openssl/ssl.h>
 SSL_CTX *git__ssl_ctx;
+static git_mutex *openssl_locks;
 #endif
 
-git_mutex git__ssl_mutex;
-git_atomic git__ssl_init;
-
 static git_global_shutdown_fn git__shutdown_callbacks[MAX_SHUTDOWN_CB];
 static git_atomic git__n_shutdown_callbacks;
 static git_atomic git__n_inits;
@@ -47,12 +45,59 @@ static void git__shutdown(void)
 
 }
 
+#if defined(GIT_THREADS) && defined(GIT_SSL)
+void openssl_locking_function(int mode, int n, const char *file, int line)
+{
+	int lock;
+
+	GIT_UNUSED(file);
+	GIT_UNUSED(line);
+
+	lock = mode & CRYPTO_LOCK;
+
+	if (lock) {
+		git_mutex_lock(&openssl_locks[n]);
+	} else {
+		git_mutex_unlock(&openssl_locks[n]);
+	}
+}
+#endif
+
+
 static void init_ssl(void)
 {
 #ifdef GIT_SSL
 	SSL_load_error_strings();
 	OpenSSL_add_ssl_algorithms();
 	git__ssl_ctx = SSL_CTX_new(SSLv23_method());
+	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);
+	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);
+	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx)) {
+		SSL_CTX_free(git__ssl_ctx);
+		git__ssl_ctx = NULL;
+	}
+
+# ifdef GIT_THREADS
+	{
+		int num_locks, i;
+
+		num_locks = CRYPTO_num_locks();
+		openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
+		if (openssl_locks == NULL) {
+			SSL_CTX_free(git__ssl_ctx);
+			git__ssl_ctx = NULL;
+		}
+
+		for (i = 0; i < num_locks; i++) {
+			if (git_mutex_init(&openssl_locks[i]) != 0) {
+				SSL_CTX_free(git__ssl_ctx);
+				git__ssl_ctx = NULL;
+			}
+		}
+
+		CRYPTO_set_locking_callback(openssl_locking_function);
+	}
+# endif
 #endif
 }
 
@@ -183,8 +228,6 @@ static void init_once(void)
 {
 	if ((init_error = git_mutex_init(&git__mwindow_mutex)) != 0)
 		return;
-	if ((init_error = git_mutex_init(&git__ssl_mutex)) != 0)
-		return;
 	pthread_key_create(&_tls_key, &cb__free_status);
 
 
diff --git a/src/global.h b/src/global.h
index 8904e2de5..745df3e4a 100644
--- a/src/global.h
+++ b/src/global.h
@@ -23,8 +23,6 @@ extern SSL_CTX *git__ssl_ctx;
 git_global_st *git__global_state(void);
 
 extern git_mutex git__mwindow_mutex;
-extern git_mutex git__ssl_mutex;
-extern git_atomic git__ssl_init;
 
 #define GIT_GLOBAL (git__global_state())
 
diff --git a/src/netops.c b/src/netops.c
index 54804d418..965e4775d 100644
--- a/src/netops.c
+++ b/src/netops.c
@@ -35,11 +35,6 @@
 #include "http_parser.h"
 #include "global.h"
 
-#if defined(GIT_SSL) && defined(GIT_THREADS)
-/* OpenSSL wants us to keep an array of locks */
-static git_mutex *openssl_locks;
-#endif
-
 #ifdef GIT_WIN32
 static void net_set_error(const char *str)
 {
@@ -391,86 +386,14 @@ cert_fail_name:
 	return -1;
 }
 
-#ifdef GIT_THREADS
-void openssl_locking_function(int mode, int n, const char *file, int line)
-{
-	int lock;
-
-	GIT_UNUSED(file);
-	GIT_UNUSED(line);
-
-	lock = mode & CRYPTO_LOCK;
-
-	if (lock) {
-		git_mutex_lock(&openssl_locks[n]);
-	} else {
-		git_mutex_unlock(&openssl_locks[n]);
-	}
-}
-#endif
-
-/**
- * The OpenSSL init functions are not reentrant so we need to init
- * them under lock.
- */
-static int init_ssl(void)
-{
-	if (git__ssl_init.val)
-		return 0;
-
-	if (git_mutex_lock(&git__ssl_mutex) < 0) {
-		giterr_set(GITERR_OS, "failed to acquire ssl init lock");
-		return -1;
-	}
-
-	/* if we had to wait for the lock, someone else did it, we can return */
-	if (git__ssl_init.val)
-		return 0;
-
-	SSL_CTX_set_mode(git__ssl_ctx, SSL_MODE_AUTO_RETRY);
-	SSL_CTX_set_verify(git__ssl_ctx, SSL_VERIFY_NONE, NULL);
-	if (!SSL_CTX_set_default_verify_paths(git__ssl_ctx)) {
-		unsigned long err = ERR_get_error();
-		giterr_set(GITERR_SSL, "failed to set verify paths: %s\n", ERR_error_string(err, NULL));
-		return -1;
-	}
-
-#ifdef GIT_THREADS
-	{
-		int num_locks, i;
-
-		num_locks = CRYPTO_num_locks();
-		openssl_locks = git__calloc(num_locks, sizeof(git_mutex));
-		if (openssl_locks == NULL) {
-			git_mutex_unlock(&git__ssl_mutex);
-			return -1;
-		}
-		GITERR_CHECK_ALLOC(openssl_locks);
-
-		for (i = 0; i < num_locks; i++) {
-			if (git_mutex_init(&openssl_locks[i]) != 0) {
-				git_mutex_unlock(&git__ssl_mutex);
-				giterr_set(GITERR_SSL, "failed to init lock %d", i);
-				return -1;
-			}
-		}
-	}
-
-	CRYPTO_set_locking_callback(openssl_locking_function);
-#endif
-
-	git_atomic_inc(&git__ssl_init);
-	git_mutex_unlock(&git__ssl_mutex);
-
-	return 0;
-}
-
 static int ssl_setup(gitno_socket *socket, const char *host, int flags)
 {
 	int ret;
 
-	if (init_ssl() < 0)
+	if (git__ssl_ctx == NULL) {
+		giterr_set(GITERR_NET, "OpenSSL initialization failed");
 		return -1;
+	}
 
 	socket->ssl.ssl = SSL_new(git__ssl_ctx);
 	if (socket->ssl.ssl == NULL)
-- 
cgit v1.2.3


From 9c3e4e97f6995bde7879a5907497c35f83ef6b56 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 13 Jun 2014 02:35:33 +0200
Subject: http: fix typo in credentials logic

We want to check whether the credentials callback is NULL, not whether
the payload is.
---
 src/transports/http.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/transports/http.c b/src/transports/http.c
index a7eff7365..ae608ab3d 100644
--- a/src/transports/http.c
+++ b/src/transports/http.c
@@ -260,7 +260,7 @@ static int on_headers_complete(http_parser *parser)
 
 	if (parser->status_code == 401 &&
 	    get_verb == s->verb) {
-		if (!t->owner->cred_acquire_payload) {
+		if (!t->owner->cred_acquire_cb) {
 			no_callback = 1;
 		} else {
 			int allowed_types = 0;
-- 
cgit v1.2.3


From 3382d8b14fca33f03c98295c07bb804cee62b7f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 13 Jun 2014 22:24:43 +0200
Subject: test: use read-only account

Don't write in plaintext the password of an account which has full
control over the repository. Instead use an account with read-only
access.
---
 tests/online/clone.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/online/clone.c b/tests/online/clone.c
index 8a2a64f95..4d4cdbf38 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -8,9 +8,9 @@
 
 #define LIVE_REPO_URL "http://github.com/libgit2/TestGitRepository"
 #define LIVE_EMPTYREPO_URL "http://github.com/libgit2/TestEmptyRepository"
-#define BB_REPO_URL "https://libgit2@bitbucket.org/libgit2/testgitrepository.git"
-#define BB_REPO_URL_WITH_PASS "https://libgit2:libgit2@bitbucket.org/libgit2/testgitrepository.git"
-#define BB_REPO_URL_WITH_WRONG_PASS "https://libgit2:wrong@bitbucket.org/libgit2/testgitrepository.git"
+#define BB_REPO_URL "https://libgit3@bitbucket.org/libgit2/testgitrepository.git"
+#define BB_REPO_URL_WITH_PASS "https://libgit3:libgit3@bitbucket.org/libgit2/testgitrepository.git"
+#define BB_REPO_URL_WITH_WRONG_PASS "https://libgit3:wrong@bitbucket.org/libgit2/testgitrepository.git"
 #define ASSEMBLA_REPO_URL "https://libgit2:_Libgit2@git.assembla.com/libgit2-test-repos.git"
 
 static git_repository *g_repo;
-- 
cgit v1.2.3


From 09561d33e45274eca4ecec7cca785737ed7a4397 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Carlos=20Mart=C3=ADn=20Nieto?= <cmn@dwim.me>
Date: Fri, 13 Jun 2014 22:27:46 +0200
Subject: test: remove assembla clone test

The assembla failure we were seeing referred to a private repository,
which is not what is there at the moment.

This reverts 1fd21b0342f
---
 tests/online/clone.c | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/tests/online/clone.c b/tests/online/clone.c
index 4d4cdbf38..4f4312a8c 100644
--- a/tests/online/clone.c
+++ b/tests/online/clone.c
@@ -11,7 +11,6 @@
 #define BB_REPO_URL "https://libgit3@bitbucket.org/libgit2/testgitrepository.git"
 #define BB_REPO_URL_WITH_PASS "https://libgit3:libgit3@bitbucket.org/libgit2/testgitrepository.git"
 #define BB_REPO_URL_WITH_WRONG_PASS "https://libgit3:wrong@bitbucket.org/libgit2/testgitrepository.git"
-#define ASSEMBLA_REPO_URL "https://libgit2:_Libgit2@git.assembla.com/libgit2-test-repos.git"
 
 static git_repository *g_repo;
 static git_clone_options g_options;
@@ -290,11 +289,6 @@ void test_online_clone__bitbucket_style(void)
 	cl_fixture_cleanup("./foo");
 }
 
-void test_online_clone__assembla_style(void)
-{
-	cl_git_pass(git_clone(&g_repo, ASSEMBLA_REPO_URL, "./foo", NULL));
-}
-
 static int cancel_at_half(const git_transfer_progress *stats, void *payload)
 {
 	GIT_UNUSED(payload);
-- 
cgit v1.2.3