rugged 0.21.1b2 → 0.21.2

data/vendor/libgit2/include/git2/tree.h

@@ -301,10 +301,8 @@ GIT_EXTERN(const git_tree_entry *) git_treebuilder_get(
  * If an entry named `filename` already exists, its attributes
  * will be updated with the given ones.
  *
- * The optional pointer `out` can be used to retrieve a pointer to the
- * newly created/updated entry.  Pass NULL if you do not need it. The
- * pointer may not be valid past the next operation in this
- * builder. Duplicate the entry if you want to keep it.
+ * The optional pointer `out` can be used to retrieve a pointer to
+ * the newly created/updated entry.  Pass NULL if you do not need it.
  *
  * No attempt is being made to ensure that the provided oid points
  * to an existing git object in the object database, nor that the

data/vendor/libgit2/include/git2/types.h

@@ -198,12 +198,12 @@ typedef enum {
 
 /** Valid modes for index and tree entries. */
 typedef enum {
-	GIT_FILEMODE_UNREADABLE          = 0000000,
-	GIT_FILEMODE_TREE                = 0040000,
-	GIT_FILEMODE_BLOB                = 0100644,
-	GIT_FILEMODE_BLOB_EXECUTABLE     = 0100755,
-	GIT_FILEMODE_LINK                = 0120000,
-	GIT_FILEMODE_COMMIT              = 0160000,
+	GIT_FILEMODE_NEW					= 0000000,
+	GIT_FILEMODE_TREE					= 0040000,
+	GIT_FILEMODE_BLOB					= 0100644,
+	GIT_FILEMODE_BLOB_EXECUTABLE		= 0100755,
+	GIT_FILEMODE_LINK					= 0120000,
+	GIT_FILEMODE_COMMIT					= 0160000,
 } git_filemode_t;
 
 typedef struct git_refspec git_refspec;
@@ -243,54 +243,6 @@ typedef struct git_transfer_progress {
  */
 typedef int (*git_transfer_progress_cb)(const git_transfer_progress *stats, void *payload);
 
-/**
- * Type for messages delivered by the transport.  Return a negative value
- * to cancel the network operation.
- *
- * @param str The message from the transport
- * @param len The length of the message
- * @param payload Payload provided by the caller
- */
-typedef int (*git_transport_message_cb)(const char *str, int len, void *payload);
-
-/**
- * Type of host certificate structure that is passed to the check callback
- */
-typedef enum git_cert_t {
-        /**
-         * The `data` argument to the callback will be a pointer to
-         * the DER-encoded data.
-         */
-	GIT_CERT_X509,
-        /**
-         * The `data` argument to the callback will be a pointer to a
-         * `git_cert_hostkey` structure.
-         */
-	GIT_CERT_HOSTKEY_LIBSSH2,
-} git_cert_t;
-
-/**
- * Parent type for `git_cert_hostkey` and `git_cert_x509`.
- */
-typedef struct {
-	/**
-	 * Type of certificate. A `GIT_CERT_` value.
-	 */
-	git_cert_t cert_type;
-} git_cert;
-
-/**
- * Callback for the user's custom certificate checks.
- *
- * @param type The type of certificate or host info, SSH or X.509
- * @param data The data for the certificate or host info
- * @param len The size of the certificate or host info
- * @param valid Whether the libgit2 checks (OpenSSL or WinHTTP) think
- * this certificate is valid
- * @param payload Payload provided by the caller
- */
-typedef int (*git_transport_certificate_check_cb)(git_cert *cert, int valid, void *payload);
-
 /**
  * Opaque structure representing a submodule.
  */

data/vendor/libgit2/include/git2/version.h

@@ -7,10 +7,10 @@
 #ifndef INCLUDE_git_version_h__
 #define INCLUDE_git_version_h__
 
-#define LIBGIT2_VERSION "0.21.0"
+#define LIBGIT2_VERSION "0.21.2"
 #define LIBGIT2_VER_MAJOR 0
 #define LIBGIT2_VER_MINOR 21
-#define LIBGIT2_VER_REVISION 0
+#define LIBGIT2_VER_REVISION 2
 
 #define LIBGIT2_SOVERSION 21
 

data/vendor/libgit2/src/attr.c

@@ -377,7 +377,7 @@ static int push_attr_file(
 	return error;
 }
 
-static int push_one_attr(void *ref, const char *path)
+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;
@@ -388,7 +388,7 @@ static int push_one_attr(void *ref, const char *path)
 
 	for (i = 0; !error && i < n_src; ++i)
 		error = push_attr_file(
-			info->repo, info->files, src[i], path, GIT_ATTR_FILE);
+			info->repo, info->files, src[i], path->ptr, GIT_ATTR_FILE);
 
 	return error;
 }
@@ -411,7 +411,7 @@ static int collect_attr_files(
 	const char *path,
 	git_vector *files)
 {
-	int error = 0;
+	int error;
 	git_buf dir = GIT_BUF_INIT;
 	const char *workdir = git_repository_workdir(repo);
 	attr_walk_up_info info = { NULL };
@@ -447,11 +447,7 @@ static int collect_attr_files(
 		giterr_clear(); /* no error even if there is no index */
 	info.files = files;
 
-	if (!strcmp(dir.ptr, "."))
-		error = push_one_attr(&info, "");
-	else
-		error = git_path_walk_up(&dir, workdir, push_one_attr, &info);
-
+	error = git_path_walk_up(&dir, workdir, push_one_attr, &info);
 	if (error < 0)
 		goto cleanup;
 

data/vendor/libgit2/src/attr_file.c

@@ -378,18 +378,6 @@ bool git_attr_fnmatch__match(
 		return (matchval != FNM_NOMATCH);
 	}
 
-	/* if path is a directory prefix of a negated pattern, then match */
-	if ((match->flags & GIT_ATTR_FNMATCH_NEGATIVE) && path->is_dir) {
-		size_t pathlen = strlen(path->path);
-		bool prefixed = (pathlen <= match->length) &&
-			((match->flags & GIT_ATTR_FNMATCH_ICASE) ?
-			 !strncasecmp(match->pattern, path->path, pathlen) :
-			 !strncmp(match->pattern, path->path, pathlen));
-
-		if (prefixed && git_path_at_end_of_segment(&match->pattern[pathlen]))
-			return true;
-	}
-
 	return (p_fnmatch(match->pattern, filename, flags) != FNM_NOMATCH);
 }
 
@@ -534,8 +522,7 @@ int git_attr_fnmatch__parse(
 	}
 
 	if (*pattern == '!' && (spec->flags & GIT_ATTR_FNMATCH_ALLOWNEG) != 0) {
-		spec->flags = spec->flags |
-			GIT_ATTR_FNMATCH_NEGATIVE | GIT_ATTR_FNMATCH_LEADINGDIR;
+		spec->flags = spec->flags | GIT_ATTR_FNMATCH_NEGATIVE;
 		pattern++;
 	}
 

data/vendor/libgit2/src/blame.c

@@ -316,6 +316,7 @@ static int blame_internal(git_blame *blame)
 	ent->suspect = o;
 
 	blame->ent = ent;
+	blame->path = blame->path;
 
 	git_blame__like_git(blame, blame->options.flags);
 

data/vendor/libgit2/src/buf_text.c

@@ -123,13 +123,9 @@ int git_buf_text_lf_to_crlf(git_buf *tgt, const git_buf *src)
 
 	for (; next; scan = next + 1, next = memchr(scan, '\n', end - scan)) {
 		size_t copylen = next - scan;
-		size_t needsize = tgt->size + copylen + 2 + 1;
-
-		/* if we find mixed line endings, bail */
-		if (next > start && next[-1] == '\r') {
-			git_buf_free(tgt);
-			return GIT_PASSTHROUGH;
-		}
+		/* don't convert existing \r\n to \r\r\n */
+		size_t extralen = (next > start && next[-1] == '\r') ? 1 : 2;
+		size_t needsize = tgt->size + copylen + extralen + 1;
 
 		if (tgt->asize < needsize && git_buf_grow(tgt, needsize) < 0)
 			return -1;
@@ -138,8 +134,8 @@ int git_buf_text_lf_to_crlf(git_buf *tgt, const git_buf *src)
 			memcpy(tgt->ptr + tgt->size, scan, copylen);
 			tgt->size += copylen;
 		}
-
-		tgt->ptr[tgt->size++] = '\r';
+		if (extralen == 2)
+			tgt->ptr[tgt->size++] = '\r';
 		tgt->ptr[tgt->size++] = '\n';
 	}
 

data/vendor/libgit2/src/buf_text.h

@@ -56,10 +56,9 @@ GIT_INLINE(int) git_buf_text_puts_escape_regex(git_buf *buf, const char *string)
 extern void git_buf_text_unescape(git_buf *buf);
 
 /**
- * Replace all \r\n with \n.
+ * Replace all \r\n with \n. Does not modify \r without trailing \n.
  *
- * @return 0 on success, -1 on memory error, GIT_PASSTHROUGH if the
- * source buffer has mixed line endings.
+ * @return 0 on success, -1 on memory error
  */
 extern int git_buf_text_crlf_to_lf(git_buf *tgt, const git_buf *src);
 

data/vendor/libgit2/src/buffer.c

@@ -7,7 +7,6 @@
 #include "buffer.h"
 #include "posix.h"
 #include "git2/buffer.h"
-#include "buf_text.h"
 #include <ctype.h>
 
 /* Used as default value for git_buf->ptr so that people can always
@@ -142,16 +141,6 @@ int git_buf_set(git_buf *buf, const void *data, size_t len)
 	return 0;
 }
 
-int git_buf_is_binary(const git_buf *buf)
-{
-	return git_buf_text_is_binary(buf);
-}
-
-int git_buf_contains_nul(const git_buf *buf)
-{
-	return git_buf_text_contains_nul(buf);
-}
-
 int git_buf_sets(git_buf *buf, const char *string)
 {
 	return git_buf_set(buf, string, string ? strlen(string) : 0);
@@ -189,10 +178,10 @@ int git_buf_puts(git_buf *buf, const char *string)
 	return git_buf_put(buf, string, strlen(string));
 }
 
-static const char base64_encode[] =
+static const char b64str[] =
 	"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-int git_buf_encode_base64(git_buf *buf, const char *data, size_t len)
+int git_buf_put_base64(git_buf *buf, const char *data, size_t len)
 {
 	size_t extra = len % 3;
 	uint8_t *write, a, b, c;
@@ -207,19 +196,19 @@ int git_buf_encode_base64(git_buf *buf, const char *data, size_t len)
 		b = *read++;
 		c = *read++;
 
-		*write++ = base64_encode[a >> 2];
-		*write++ = base64_encode[(a & 0x03) << 4 | b >> 4];
-		*write++ = base64_encode[(b & 0x0f) << 2 | c >> 6];
-		*write++ = base64_encode[c & 0x3f];
+		*write++ = b64str[a >> 2];
+		*write++ = b64str[(a & 0x03) << 4 | b >> 4];
+		*write++ = b64str[(b & 0x0f) << 2 | c >> 6];
+		*write++ = b64str[c & 0x3f];
 	}
 
 	if (extra > 0) {
 		a = *read++;
 		b = (extra > 1) ? *read++ : 0;
 
-		*write++ = base64_encode[a >> 2];
-		*write++ = base64_encode[(a & 0x03) << 4 | b >> 4];
-		*write++ = (extra > 1) ? base64_encode[(b & 0x0f) << 2] : '=';
+		*write++ = b64str[a >> 2];
+		*write++ = b64str[(a & 0x03) << 4 | b >> 4];
+		*write++ = (extra > 1) ? b64str[(b & 0x0f) << 2] : '=';
 		*write++ = '=';
 	}
 
@@ -229,56 +218,10 @@ int git_buf_encode_base64(git_buf *buf, const char *data, size_t len)
 	return 0;
 }
 
-/* The inverse of base64_encode, offset by '+' == 43. */
-static const int8_t base64_decode[] = {
-	62,
-	-1, -1, -1,
-	63,
-	52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-	-1, -1, -1, 0, -1, -1, -1,
-	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-	13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
-	-1, -1, -1, -1, -1, -1,
-	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
-	39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
-};
-
-#define BASE64_DECODE_VALUE(c) (((c) < 43 || (c) > 122) ? -1 : base64_decode[c - 43])
-
-int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len)
-{
-	size_t i;
-	int8_t a, b, c, d;
-	size_t orig_size = buf->size;
-
-	assert(len % 4 == 0);
-	ENSURE_SIZE(buf, buf->size + (len / 4 * 3) + 1);
-
-	for (i = 0; i < len; i += 4) {
-		if ((a = BASE64_DECODE_VALUE(base64[i])) < 0 ||
-			(b = BASE64_DECODE_VALUE(base64[i+1])) < 0 ||
-			(c = BASE64_DECODE_VALUE(base64[i+2])) < 0 ||
-			(d = BASE64_DECODE_VALUE(base64[i+3])) < 0) {
-			buf->size = orig_size;
-			buf->ptr[buf->size] = '\0';
-
-			giterr_set(GITERR_INVALID, "Invalid base64 input");
-			return -1;
-		}
-
-		buf->ptr[buf->size++] = ((a << 2) | (b & 0x30) >> 4);
-		buf->ptr[buf->size++] = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
-		buf->ptr[buf->size++] = (c & 0x03) << 6 | (d & 0x3f);
-	}
-
-	buf->ptr[buf->size] = '\0';
-	return 0;
-}
-
 static const char b85str[] =
 	"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!#$%&()*+-;<=>?@^_`{|}~";
 
-int git_buf_encode_base85(git_buf *buf, const char *data, size_t len)
+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);
 

data/vendor/libgit2/src/buffer.h

@@ -156,12 +156,10 @@ void git_buf_rtrim(git_buf *buf);
 int git_buf_cmp(const git_buf *a, const git_buf *b);
 
 /* Write data as base64 encoded in buffer */
-int git_buf_encode_base64(git_buf *buf, const char *data, size_t len);
-/* Decode the given bas64 and write the result to the buffer */
-int git_buf_decode_base64(git_buf *buf, const char *base64, size_t len);
+int git_buf_put_base64(git_buf *buf, const char *data, size_t len);
 
 /* Write data as "base85" encoded in buffer */
-int git_buf_encode_base85(git_buf *buf, const char *data, size_t len);
+int git_buf_put_base85(git_buf *buf, const char *data, size_t len);
 
 /*
  * Insert, remove or replace a portion of the buffer.

data/vendor/libgit2/src/cache.c

@@ -68,8 +68,8 @@ int git_cache_init(git_cache *cache)
 {
 	memset(cache, 0, sizeof(*cache));
 	cache->map = git_oidmap_alloc();
-	if (git_rwlock_init(&cache->lock)) {
-		giterr_set(GITERR_OS, "Failed to initialize cache rwlock");
+	if (git_mutex_init(&cache->lock)) {
+		giterr_set(GITERR_OS, "Failed to initialize cache mutex");
 		return -1;
 	}
 	return 0;
@@ -94,19 +94,19 @@ static void clear_cache(git_cache *cache)
 
 void git_cache_clear(git_cache *cache)
 {
-	if (git_rwlock_wrlock(&cache->lock) < 0)
+	if (git_mutex_lock(&cache->lock) < 0)
 		return;
 
 	clear_cache(cache);
 
-	git_rwlock_wrunlock(&cache->lock);
+	git_mutex_unlock(&cache->lock);
 }
 
 void git_cache_free(git_cache *cache)
 {
 	git_cache_clear(cache);
 	git_oidmap_free(cache->map);
-	git_rwlock_free(&cache->lock);
+	git_mutex_free(&cache->lock);
 	git__memzero(cache, sizeof(*cache));
 }
 
@@ -152,7 +152,7 @@ static void *cache_get(git_cache *cache, const git_oid *oid, unsigned int flags)
 	khiter_t pos;
 	git_cached_obj *entry = NULL;
 
-	if (!git_cache__enabled || git_rwlock_rdlock(&cache->lock) < 0)
+	if (!git_cache__enabled || git_mutex_lock(&cache->lock) < 0)
 		return NULL;
 
 	pos = kh_get(oid, cache->map, oid);
@@ -166,7 +166,7 @@ static void *cache_get(git_cache *cache, const git_oid *oid, unsigned int flags)
 		}
 	}
 
-	git_rwlock_rdunlock(&cache->lock);
+	git_mutex_unlock(&cache->lock);
 
 	return entry;
 }
@@ -185,7 +185,7 @@ static void *cache_store(git_cache *cache, git_cached_obj *entry)
 	if (!cache_should_store(entry->type, entry->size))
 		return entry;
 
-	if (git_rwlock_wrlock(&cache->lock) < 0)
+	if (git_mutex_lock(&cache->lock) < 0)
 		return entry;
 
 	/* soften the load on the cache */
@@ -227,7 +227,7 @@ static void *cache_store(git_cache *cache, git_cached_obj *entry)
 		}
 	}
 
-	git_rwlock_wrunlock(&cache->lock);
+	git_mutex_unlock(&cache->lock);
 	return entry;
 }
 

data/vendor/libgit2/src/cache.h

@@ -30,7 +30,7 @@ typedef struct {
 
 typedef struct {
 	git_oidmap *map;
-	git_rwlock  lock;
+	git_mutex   lock;
 	ssize_t     used_memory;
 } git_cache;
 

data/vendor/libgit2/src/checkout.c

@@ -46,7 +46,6 @@ enum {
 
 typedef struct {
 	git_repository *repo;
-	git_iterator *target;
 	git_diff *diff;
 	git_checkout_options opts;
 	bool opts_free_baseline;
@@ -55,8 +54,6 @@ typedef struct {
 	git_pool pool;
 	git_vector removes;
 	git_vector conflicts;
-	git_vector *reuc;
-	git_vector *names;
 	git_buf path;
 	size_t workdir_len;
 	git_buf tmp;
@@ -119,7 +116,6 @@ static int checkout_notify(
 		case GIT_DELTA_ADDED:
 		case GIT_DELTA_IGNORED:
 		case GIT_DELTA_UNTRACKED:
-		case GIT_DELTA_UNREADABLE:
 			target = &delta->new_file;
 			break;
 		case GIT_DELTA_DELETED:
@@ -142,7 +138,6 @@ static int checkout_notify(
 static bool checkout_is_workdir_modified(
 	checkout_data *data,
 	const git_diff_file *baseitem,
-	const git_diff_file *newitem,
 	const git_index_entry *wditem)
 {
 	git_oid oid;
@@ -174,16 +169,13 @@ static bool checkout_is_workdir_modified(
 
 	/* Look at the cache to decide if the workdir is modified.  If not,
 	 * we can simply compare the oid in the cache to the baseitem instead
-	 * of hashing the file.  If so, we allow the checkout to proceed if the
-	 * oid is identical (ie, the staged item is what we're trying to check
-	 * out.)
+	 * of hashing the file.
 	 */
 	if ((ie = git_index_get_bypath(data->index, wditem->path, 0)) != NULL) {
 		if (wditem->mtime.seconds == ie->mtime.seconds &&
 			wditem->mtime.nanoseconds == ie->mtime.nanoseconds &&
 			wditem->file_size == ie->file_size)
-			return (git_oid__cmp(&baseitem->id, &ie->id) != 0 &&
-				git_oid_cmp(&newitem->id, &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
@@ -409,7 +401,7 @@ static int checkout_action_with_wd(
 
 	switch (delta->status) {
 	case GIT_DELTA_UNMODIFIED: /* case 14/15 or 33 */
-		if (checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd)) {
+		if (checkout_is_workdir_modified(data, &delta->old_file, wd)) {
 			GITERR_CHECK_ERROR(
 				checkout_notify(data, GIT_CHECKOUT_NOTIFY_DIRTY, delta, wd) );
 			*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, NONE);
@@ -422,13 +414,13 @@ static int checkout_action_with_wd(
 			*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, &delta->new_file, wd))
+		if (checkout_is_workdir_modified(data, &delta->old_file, wd))
 			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
 		else
 			*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, &delta->new_file, wd))
+		if (checkout_is_workdir_modified(data, &delta->old_file, wd))
 			*action = CHECKOUT_ACTION_IF(FORCE, UPDATE_BLOB, CONFLICT);
 		else
 			*action = CHECKOUT_ACTION_IF(SAFE, UPDATE_BLOB, NONE);
@@ -451,7 +443,7 @@ static int checkout_action_with_wd(
 			} else
 				*action = CHECKOUT_ACTION_IF(FORCE, REMOVE, CONFLICT);
 		}
-		else if (checkout_is_workdir_modified(data, &delta->old_file, &delta->new_file, wd))
+		else if (checkout_is_workdir_modified(data, &delta->old_file, wd))
 			*action = CHECKOUT_ACTION_IF(FORCE, REMOVE_AND_UPDATE, CONFLICT);
 		else
 			*action = CHECKOUT_ACTION_IF(SAFE, REMOVE_AND_UPDATE, NONE);
@@ -796,16 +788,11 @@ done:
 static int checkout_conflicts_load(checkout_data *data, git_iterator *workdir, git_vector *pathspec)
 {
 	git_index_conflict_iterator *iterator = NULL;
-	git_index *index;
 	const git_index_entry *ancestor, *ours, *theirs;
 	checkout_conflictdata *conflict;
 	int error = 0;
 
-	/* Only write conficts from sources that have them: indexes. */
-	if ((index = git_iterator_get_index(data->target)) == NULL)
-		return 0;
-
-	if ((error = git_index_conflict_iterator_new(&iterator, index)) < 0)
+	if ((error = git_index_conflict_iterator_new(&iterator, data->index)) < 0)
 		goto done;
 
 	data->conflicts._cmp = checkout_conflictdata_cmp;
@@ -832,10 +819,6 @@ static int checkout_conflicts_load(checkout_data *data, git_iterator *workdir, g
 		git_vector_insert(&data->conflicts, conflict);
 	}
 
-	/* Collect the REUC and NAME entries */
-	data->reuc = &index->reuc;
-	data->names = &index->names;
-
 	if (error == GIT_ITEROVER)
 		error = 0;
 
@@ -974,20 +957,16 @@ done:
 static int checkout_conflicts_coalesce_renames(
 	checkout_data *data)
 {
-	git_index *index;
 	const git_index_name_entry *name_entry;
 	checkout_conflictdata *ancestor_conflict, *our_conflict, *their_conflict;
 	size_t i, names;
 	int error = 0;
 
-	if ((index = git_iterator_get_index(data->target)) == NULL)
-		return 0;
-
 	/* Juggle entries based on renames */
-	names = git_index_name_entrycount(index);
+	names = git_index_name_entrycount(data->index);
 
 	for (i = 0; i < names; i++) {
-		name_entry = git_index_name_get_byindex(index, i);
+		name_entry = git_index_name_get_byindex(data->index, i);
 
 		if ((error = checkout_conflicts_load_byname_entry(
 			&ancestor_conflict, &our_conflict, &their_conflict,
@@ -1031,17 +1010,13 @@ done:
 static int checkout_conflicts_mark_directoryfile(
 	checkout_data *data)
 {
-	git_index *index;
 	checkout_conflictdata *conflict;
 	const git_index_entry *entry;
 	size_t i, j, len;
 	const char *path;
 	int prefixed, error = 0;
 
-	if ((index = git_iterator_get_index(data->target)) == NULL)
-		return 0;
-
-	len = git_index_entrycount(index);
+	len = git_index_entrycount(data->index);
 
 	/* Find d/f conflicts */
 	git_vector_foreach(&data->conflicts, i, conflict) {
@@ -1052,7 +1027,7 @@ static int checkout_conflicts_mark_directoryfile(
 		path = conflict->ours ?
 			conflict->ours->path : conflict->theirs->path;
 
-		if ((error = git_index_find(&j, index, path)) < 0) {
+		if ((error = git_index_find(&j, data->index, path)) < 0) {
 			if (error == GIT_ENOTFOUND)
 				giterr_set(GITERR_INDEX,
 					"Index inconsistency, could not find entry for expected conflict '%s'", path);
@@ -1061,7 +1036,7 @@ static int checkout_conflicts_mark_directoryfile(
 		}
 
 		for (; j < len; j++) {
-			if ((entry = git_index_get_byindex(index, j)) == NULL) {
+			if ((entry = git_index_get_byindex(data->index, j)) == NULL) {
 				giterr_set(GITERR_INDEX,
 					"Index inconsistency, truncated index while loading expected conflict '%s'", path);
 				error = -1;
@@ -1761,10 +1736,12 @@ static int checkout_write_merge(
 	checkout_conflictdata *conflict)
 {
 	git_buf our_label = GIT_BUF_INIT, their_label = GIT_BUF_INIT,
-		path_suffixed = GIT_BUF_INIT, path_workdir = GIT_BUF_INIT;
+		path_suffixed = GIT_BUF_INIT, path_workdir = GIT_BUF_INIT,
+		in_data = GIT_BUF_INIT, out_data = GIT_BUF_INIT;
 	git_merge_file_options opts = GIT_MERGE_FILE_OPTIONS_INIT;
 	git_merge_file_result result = {0};
 	git_filebuf output = GIT_FILEBUF_INIT;
+	git_filter_list *fl = NULL;
 	int error = 0;
 
 	if (data->opts.checkout_strategy & GIT_CHECKOUT_CONFLICT_STYLE_DIFF3)
@@ -1810,13 +1787,29 @@ static int checkout_write_merge(
 		(error = checkout_safe_for_update_only(git_buf_cstr(&path_workdir), result.mode)) <= 0)
 		goto done;
 
+	if (!data->opts.disable_filters) {
+		in_data.ptr = (char *)result.ptr;
+		in_data.size = result.len;
+
+		if ((error = git_filter_list_load(&fl, data->repo, NULL, git_buf_cstr(&path_workdir),
+				GIT_FILTER_TO_WORKTREE, GIT_FILTER_OPT_DEFAULT)) < 0 ||
+			(error = git_filter_list_apply_to_data(&out_data, fl, &in_data)) < 0)
+			goto done;
+	} else {
+		out_data.ptr = (char *)result.ptr;
+		out_data.size = result.len;
+	}
+
 	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.ptr, result.len)) < 0 ||
+		(error = git_filebuf_open(&output, git_buf_cstr(&path_workdir), GIT_FILEBUF_DO_NOT_BUFFER, result.mode)) < 0 ||
+		(error = git_filebuf_write(&output, out_data.ptr, out_data.size)) < 0 ||
 		(error = git_filebuf_commit(&output)) < 0)
 		goto done;
 
 done:
+	git_filter_list_free(fl);
+
+	git_buf_free(&out_data);
 	git_buf_free(&our_label);
 	git_buf_free(&their_label);
 
@@ -1827,24 +1820,6 @@ done:
 	return error;
 }
 
-static int checkout_conflict_update_index(
-	checkout_data *data,
-	checkout_conflictdata *conflict)
-{
-	int error = 0;
-
-	if (conflict->ancestor)
-		error = git_index_add(data->index, conflict->ancestor);
-
-	if (!error && conflict->ours)
-		error = git_index_add(data->index, conflict->ours);
-
-	if (!error && conflict->theirs)
-		error = git_index_add(data->index, conflict->theirs);
-
-	return error;
-}
-
 static int checkout_create_conflicts(checkout_data *data)
 {
 	checkout_conflictdata *conflict;
@@ -1907,12 +1882,6 @@ static int checkout_create_conflicts(checkout_data *data)
 		else if (!error)
 			error = checkout_write_merge(data, conflict);
 
-		/* Update the index extensions (REUC and NAME) if we're checking
-		 * out a different index. (Otherwise just leave them there.)
-		 */
-		if (!error && (data->strategy & GIT_CHECKOUT_DONT_UPDATE_INDEX) == 0)
-			error = checkout_conflict_update_index(data, conflict);
-
 		if (error)
 			break;
 
@@ -1925,37 +1894,6 @@ static int checkout_create_conflicts(checkout_data *data)
 	return error;
 }
 
-static int checkout_extensions_update_index(checkout_data *data)
-{
-	const git_index_reuc_entry *reuc_entry;
-	const git_index_name_entry *name_entry;
-	size_t i;
-	int error = 0;
-
-	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0)
-		return 0;
-
-	if (data->reuc) {
-		git_vector_foreach(data->reuc, i, reuc_entry) {
-			if ((error = git_index_reuc_add(data->index, reuc_entry->path,
-				reuc_entry->mode[0], &reuc_entry->oid[0],
-				reuc_entry->mode[1], &reuc_entry->oid[1],
-				reuc_entry->mode[2], &reuc_entry->oid[2])) < 0)
-				goto done;
-		}
-	}
-
-	if (data->names) {
-		git_vector_foreach(data->names, i, name_entry) {
-			if ((error = git_index_name_add(data->index, name_entry->ancestor,
-				name_entry->ours, name_entry->theirs)) < 0)
-				goto done;
-		}
-	}
-
-done:
-	return error;
-}
 
 static void checkout_data_clear(checkout_data *data)
 {
@@ -1999,7 +1937,6 @@ static int checkout_data_init(
 		return error;
 
 	data->repo = repo;
-	data->target = target;
 
 	GITERR_CHECK_VERSION(
 		proposed, GIT_CHECKOUT_OPTIONS_VERSION, "git_checkout_options");
@@ -2024,15 +1961,15 @@ static int checkout_data_init(
 			(error = git_config_refresh(cfg)) < 0)
 			goto cleanup;
 
-		/* Get the repository index and reload it (unless we're checking
-		 * out the index; then it has the changes we're trying to check
-		 * out and those should not be overwritten.)
+		/* if we are checking out the index, don't reload,
+		 * otherwise get index and force reload
 		 */
-		if ((error = git_repository_index(&data->index, data->repo)) < 0)
-			goto cleanup;
-
-		if (data->index != git_iterator_get_index(target)) {
-			if ((error = git_index_read(data->index, true)) < 0)
+		if ((data->index = git_iterator_get_index(target)) != NULL) {
+			GIT_REFCOUNT_INC(data->index);
+		} else {
+			/* otherwise, grab and reload the index */
+			if ((error = git_repository_index(&data->index, data->repo)) < 0 ||
+				(error = git_index_read(data->index, true)) < 0)
 				goto cleanup;
 
 			/* cannot checkout if unresolved conflicts exist */
@@ -2044,7 +1981,7 @@ static int checkout_data_init(
 				goto cleanup;
 			}
 
-			/* clean conflict data in the current index */
+			/* clean conflict data when doing a tree or commit checkout */
 			git_index_name_clear(data->index);
 			git_index_reuc_clear(data->index);
 		}
@@ -2144,7 +2081,6 @@ int git_checkout_iterator(
 
 	diff_opts.flags =
 		GIT_DIFF_INCLUDE_UNMODIFIED |
-		GIT_DIFF_INCLUDE_UNREADABLE |
 		GIT_DIFF_INCLUDE_UNTRACKED |
 		GIT_DIFF_RECURSE_UNTRACKED_DIRS | /* needed to match baseline */
 		GIT_DIFF_INCLUDE_IGNORED |
@@ -2214,10 +2150,6 @@ int git_checkout_iterator(
 		(error = checkout_create_conflicts(&data)) < 0)
 		goto cleanup;
 
-	if (data.index != git_iterator_get_index(target) &&
-		(error = checkout_extensions_update_index(&data)) < 0)
-		goto cleanup;
-
 	assert(data.completed_steps == data.total_steps);
 
 cleanup:
@@ -2240,7 +2172,7 @@ int git_checkout_index(
 	git_index *index,
 	const git_checkout_options *opts)
 {
-	int error, owned = 0;
+	int error;
 	git_iterator *index_i;
 
 	if (!index && !repo) {
@@ -2248,16 +2180,10 @@ int git_checkout_index(
 			"Must provide either repository or index to checkout");
 		return -1;
 	}
-
-	if (index && repo &&
-		git_index_owner(index) &&
-		git_index_owner(index) != repo) {
+	if (index && repo && git_index_owner(index) != repo) {
 		giterr_set(GITERR_CHECKOUT,
 			"Index to checkout does not match repository");
 		return -1;
-	} else if(index && repo && !git_index_owner(index)) {
-		GIT_REFCOUNT_OWN(index, repo);
-		owned = 1;
 	}
 
 	if (!repo)
@@ -2270,9 +2196,6 @@ int git_checkout_index(
 	if (!(error = git_iterator_for_index(&index_i, index, 0, NULL, NULL)))
 		error = git_checkout_iterator(index_i, opts);
 
-	if (owned)
-		GIT_REFCOUNT_OWN(index, NULL);
-
 	git_iterator_free(index_i);
 	git_index_free(index);