12 files changed, 395 insertions, 214 deletions

diff --git a/src/attr.c b/src/attr.c
index 120d12737..56d04d3a9 100644
--- a/src/attr.c
+++ b/src/attr.c
@@ -6,12 +6,18 @@
 GIT__USE_STRMAP;
 
 static int collect_attr_files(
-	git_repository *repo, const char *path, git_vector *files);
+	git_repository *repo,
+	uint32_t flags,
+	const char *path,
+	git_vector *files);
 
 
 int git_attr_get(
-    git_repository *repo, const char *pathname,
-	const char *name, const char **value)
+    git_repository *repo,
+	uint32_t flags,
+	const char *pathname,
+	const char *name,
+	const char **value)
 {
 	int error;
 	git_attr_path path;
@@ -26,7 +32,7 @@ int git_attr_get(
 	if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)
 		return -1;
 
-	if ((error = collect_attr_files(repo, pathname, &files)) < 0)
+	if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0)
 		goto cleanup;
 
 	attr.name = name;
@@ -58,8 +64,12 @@ typedef struct {
 } attr_get_many_info;
 
 int git_attr_get_many(
-    git_repository *repo, const char *pathname,
-    size_t num_attr, const char **names, const char **values)
+    git_repository *repo,
+	uint32_t flags,
+	const char *pathname,
+    size_t num_attr,
+	const char **names,
+	const char **values)
 {
 	int error;
 	git_attr_path path;
@@ -75,7 +85,7 @@ int git_attr_get_many(
 	if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)
 		return -1;
 
-	if ((error = collect_attr_files(repo, pathname, &files)) < 0)
+	if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0)
 		goto cleanup;
 
 	info = git__calloc(num_attr, sizeof(attr_get_many_info));
@@ -119,7 +129,9 @@ cleanup:
 
 
 int git_attr_foreach(
-    git_repository *repo, const char *pathname,
+    git_repository *repo,
+	uint32_t flags,
+	const char *pathname,
 	int (*callback)(const char *name, const char *value, void *payload),
 	void *payload)
 {
@@ -135,7 +147,7 @@ int git_attr_foreach(
 	if (git_attr_path__init(&path, pathname, git_repository_workdir(repo)) < 0)
 		return -1;
 
-	if ((error = collect_attr_files(repo, pathname, &files)) < 0)
+	if ((error = collect_attr_files(repo, flags, pathname, &files)) < 0)
 		goto cleanup;
 
 	seen = git_strmap_alloc();
@@ -203,113 +215,230 @@ int git_attr_add_macro(
 	return error;
 }
 
-bool git_attr_cache__is_cached(git_repository *repo, const char *path)
+bool git_attr_cache__is_cached(
+	git_repository *repo, git_attr_file_source source, const char *path)
 {
-	const char *cache_key = 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 *filename, const char **data)
+{
+	int error;
+	git_buf content = GIT_BUF_INIT;
+
+	error = git_futils_readbuffer(&content, filename);
+	*data = error ? NULL : git_buf_detach(&content);
+
+	return error;
+}
 
-	if (repo && git__prefixcmp(cache_key, git_repository_workdir(repo)) == 0)
-		cache_key += strlen(git_repository_workdir(repo));
+static int load_attr_blob_from_index(
+	git_repository *repo, const char *filename, git_blob **blob)
+{
+	int error;
+	git_index *index;
+	git_index_entry *entry;
+
+	if ((error = git_repository_index__weakptr(&index, repo)) < 0 ||
+		(error = git_index_find(index, filename)) < 0)
+		return error;
 
-	return git_strmap_exists(files, cache_key);
+	entry = git_index_get(index, error);
+
+	return git_blob_lookup(blob, repo, &entry->oid);
 }
 
-int git_attr_cache__lookup_or_create_file(
+int git_attr_cache__internal_file(
 	git_repository *repo,
-	const char *key,
 	const char *filename,
-	int (*loader)(git_repository *, const char *, git_attr_file *),
-	git_attr_file **file_ptr)
+	git_attr_file **file)
 {
-	int error;
+	int error = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_attr_file *file = NULL;
-	khiter_t pos;
-
-	pos = git_strmap_lookup_index(cache->files, key);
-	if (git_strmap_valid_index(cache->files, pos)) {
-		*file_ptr = git_strmap_value_at(cache->files, pos);
-		return 0;
-	}
+	khiter_t cache_pos = git_strmap_lookup_index(cache->files, filename);
 
-	if (loader && git_path_exists(filename) == false) {
-		*file_ptr = NULL;
+	if (git_strmap_valid_index(cache->files, cache_pos)) {
+		*file = git_strmap_value_at(cache->files, cache_pos);
 		return 0;
 	}
 
-	if (git_attr_file__new(&file, &cache->pool) < 0)
+	if (git_attr_file__new(file, 0, filename, &cache->pool) < 0)
 		return -1;
 
-	if (loader)
-		error = loader(repo, filename, file);
-	else
-		error = git_attr_file__set_path(repo, key, file);
-
-	if (!error) {
-		git_strmap_insert(cache->files, file->path, file, error);
-		if (error > 0)
-			error = 0;
-	}
-
-	if (error < 0) {
-		git_attr_file__free(file);
-		file = NULL;
-	}
+	git_strmap_insert(cache->files, (*file)->key + 2, *file, error);
+	if (error > 0)
+		error = 0;
 
-	*file_ptr = file;
 	return error;
 }
 
-/* add git_attr_file to vector of files, loading if needed */
 int git_attr_cache__push_file(
 	git_repository *repo,
-	git_vector     *stack,
-	const char     *base,
-	const char     *filename,
-	int (*loader)(git_repository *, const char *, git_attr_file *))
+	const char *base,
+	const char *filename,
+	git_attr_file_source source,
+	git_attr_file_parser parse,
+	git_vector *stack)
 {
-	int error;
+	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;
-	const char *cache_key;
+	git_blob *blob = NULL;
 
-	if (base != NULL) {
+	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;
 	}
 
-	/* either get attr_file from cache or read from disk */
-	cache_key = filename;
-	if (repo && git__prefixcmp(cache_key, git_repository_workdir(repo)) == 0)
-		cache_key += strlen(git_repository_workdir(repo));
+	relfile = filename;
+	if (workdir && git__prefixcmp(relfile, workdir) == 0)
+		relfile += strlen(workdir);
+
+	/* check cache */
+	if (cache && cache->files) {
+		git_buf  cache_key = GIT_BUF_INIT;
+		khiter_t cache_pos;
+
+		if (git_buf_printf(&cache_key, "%d#%s", (int)source, relfile) < 0)
+			return -1;
+
+		cache_pos = git_strmap_lookup_index(cache->files, cache_key.ptr);
+
+		git_buf_free(&cache_key);
+
+		if (git_strmap_valid_index(cache->files, cache_pos)) {
+			file = git_strmap_value_at(cache->files, cache_pos);
+			goto finish;
+		}
+	}
+
+	/* if not in cache, load data, parse, and cache */
+	if (git_attr_file__new(&file, source, relfile, &cache->pool) < 0)
+		return -1;
+
+	if (source == GIT_ATTR_FILE_FROM_FILE)
+		error = load_attr_file(filename, &content);
+	else
+		error = load_attr_blob_from_index(repo, relfile, &blob);
+
+	if (error) {
+		/* not finding a file is not an error for this function */
+		if (error == GIT_ENOTFOUND) {
+			giterr_clear();
+			error = 0;
+		}
+		goto finish;
+	}
+
+	if (blob)
+		content = git_blob_rawcontent(blob);
+
+	if (parse && (error = parse(repo, content, file)) < 0)
+		goto finish;
 
-	error = git_attr_cache__lookup_or_create_file(
-		repo, cache_key, filename, loader, &file);
+	git_strmap_insert(cache->files, file->key, file, error);
+	if (error > 0)
+		error = 0;
 
+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_attrs(R,S,B,F) \
-	git_attr_cache__push_file((R),(S),(B),(F),git_attr_file__from_file)
+#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,(S))
 
 typedef struct {
 	git_repository *repo;
+	uint32_t flags;
+	const char *workdir;
+	git_index *index;
 	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)
+{
+	int count = 0;
+
+	switch (flags & 0x03) {
+	case GIT_ATTR_CHECK_FILE_THEN_INDEX:
+		if (has_wd)
+			srcs[count++] = GIT_ATTR_FILE_FROM_FILE;
+		if (has_index)
+			srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;
+		break;
+	case GIT_ATTR_CHECK_INDEX_THEN_FILE:
+		if (has_index)
+			srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;
+		if (has_wd)
+			srcs[count++] = GIT_ATTR_FILE_FROM_FILE;
+		break;
+	case GIT_ATTR_CHECK_INDEX_ONLY:
+		if (has_index)
+			srcs[count++] = GIT_ATTR_FILE_FROM_INDEX;
+		break;
+	}
+
+	return count;
+}
+
 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;
-	return push_attrs(info->repo, info->files, path->ptr, GIT_ATTR_FILE);
+	git_attr_file_source src[2];
+
+	n_src = git_attr_cache__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, info->files);
+
+	return error;
 }
 
 static int collect_attr_files(
-	git_repository *repo, const char *path, git_vector *files)
+	git_repository *repo,
+	uint32_t flags,
+	const char *path,
+	git_vector *files)
 {
 	int error;
 	git_buf dir = GIT_BUF_INIT;
@@ -320,7 +449,11 @@ static int collect_attr_files(
 		git_vector_init(files, 4, NULL) < 0)
 		return -1;
 
-	error = git_path_find_dir(&dir, path, workdir);
+	/* given a unrooted path in a non-bare repo, resolve it */
+	if (workdir && git_path_root(path) < 0)
+		error = git_path_find_dir(&dir, path, workdir);
+	else
+		error = git_buf_sets(&dir, path);
 	if (error < 0)
 		goto cleanup;
 
@@ -331,29 +464,36 @@ static int collect_attr_files(
 	 * - $GIT_PREFIX/etc/gitattributes
 	 */
 
-	error = push_attrs(
+	error = push_attr_file(
 		repo, files, git_repository_path(repo), GIT_ATTR_FILE_INREPO);
 	if (error < 0)
 		goto cleanup;
 
-	info.repo = repo;
+	info.repo  = repo;
+	info.flags = flags;
+	info.workdir = workdir;
+	if (git_repository_index__weakptr(&info.index, repo) < 0)
+		giterr_clear(); /* no error even if there is no index */
 	info.files = files;
+
 	error = git_path_walk_up(&dir, workdir, push_one_attr, &info);
 	if (error < 0)
 		goto cleanup;
 
 	if (git_repository_attr_cache(repo)->cfg_attr_file != NULL) {
-		error = push_attrs(
+		error = push_attr_file(
 			repo, files, NULL, git_repository_attr_cache(repo)->cfg_attr_file);
 		if (error < 0)
 			goto cleanup;
 	}
 
-	error = git_futils_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);
-	if (!error)
-		error = push_attrs(repo, files, NULL, dir.ptr);
-	else if (error == GIT_ENOTFOUND)
-		error = 0;
+	if ((flags & GIT_ATTR_CHECK_NO_SYSTEM) == 0) {
+		error = git_futils_find_system_file(&dir, GIT_ATTR_FILE_SYSTEM);
+		if (!error)
+			error = push_attr_file(repo, files, NULL, dir.ptr);
+		else if (error == GIT_ENOTFOUND)
+			error = 0;
+	}
 
  cleanup:
 	if (error < 0)
diff --git a/src/attr.h b/src/attr.h
index 43caf1b81..a35b1160f 100644
--- a/src/attr.h
+++ b/src/attr.h
@@ -22,6 +22,9 @@ typedef struct {
 	const char *cfg_excl_file; /* cached value of core.excludesfile */
 } git_attr_cache;
 
+typedef int (*git_attr_file_parser)(
+	git_repository *, const char *, git_attr_file *);
+
 extern int git_attr_cache__init(git_repository *repo);
 
 extern int git_attr_cache__insert_macro(
@@ -30,21 +33,24 @@ extern int git_attr_cache__insert_macro(
 extern git_attr_rule *git_attr_cache__lookup_macro(
 	git_repository *repo, const char *name);
 
-extern int git_attr_cache__lookup_or_create_file(
+extern int git_attr_cache__push_file(
 	git_repository *repo,
-	const char *key,
+	const char *base,
 	const char *filename,
-	int (*loader)(git_repository *, const char *, git_attr_file *),
-	git_attr_file **file_ptr);
+	git_attr_file_source source,
+	git_attr_file_parser parse,
+	git_vector *stack);
 
-extern int git_attr_cache__push_file(
+extern int git_attr_cache__internal_file(
 	git_repository *repo,
-	git_vector     *stack,
-	const char     *base,
-	const char     *filename,
-	int (*loader)(git_repository *, const char *, git_attr_file *));
+	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, const char *path);
+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);
 
 #endif
diff --git a/src/attr_file.c b/src/attr_file.c
index 25c21b1fd..ab320a6c4 100644
--- a/src/attr_file.c
+++ b/src/attr_file.c
@@ -1,15 +1,22 @@
 #include "common.h"
 #include "repository.h"
 #include "filebuf.h"
+#include "git2/blob.h"
+#include "git2/tree.h"
 #include <ctype.h>
 
 const char *git_attr__true  = "[internal]__TRUE__";
 const char *git_attr__false = "[internal]__FALSE__";
+const char *git_attr__unset = "[internal]__UNSET__";
 
 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);
 
-int git_attr_file__new(git_attr_file **attrs_ptr, git_pool *pool)
+int git_attr_file__new(
+	git_attr_file **attrs_ptr,
+	git_attr_file_source from,
+	const char *path,
+	git_pool *pool)
 {
 	git_attr_file *attrs = NULL;
 
@@ -25,6 +32,18 @@ int git_attr_file__new(git_attr_file **attrs_ptr, git_pool *pool)
 		attrs->pool_is_allocated = true;
 	}
 
+	if (path) {
+		size_t len = strlen(path);
+
+		attrs->key = git_pool_malloc(attrs->pool, len + 3);
+		GITERR_CHECK_ALLOC(attrs->key);
+
+		attrs->key[0] = '0' + from;
+		attrs->key[1] = '#';
+		memcpy(&attrs->key[2], path, len);
+		attrs->key[len + 2] = '\0';
+	}
+
 	if (git_vector_init(&attrs->rules, 4, NULL) < 0)
 		goto fail;
 
@@ -37,31 +56,7 @@ fail:
 	return -1;
 }
 
-int git_attr_file__set_path(
-	git_repository *repo, const char *path, git_attr_file *file)
-{
-	if (file->path != NULL) {
-		git__free(file->path);
-		file->path = NULL;
-	}
-
-	if (repo == NULL)
-		file->path = git__strdup(path);
-	else {
-		const char *workdir = git_repository_workdir(repo);
-
-		if (workdir && git__prefixcmp(path, workdir) == 0)
-			file->path = git__strdup(path + strlen(workdir));
-		else
-			file->path = git__strdup(path);
-	}
-
-	GITERR_CHECK_ALLOC(file->path);
-
-	return 0;
-}
-
-int git_attr_file__from_buffer(
+int git_attr_file__parse_buffer(
 	git_repository *repo, const char *buffer, git_attr_file *attrs)
 {
 	int error = 0;
@@ -73,10 +68,10 @@ int git_attr_file__from_buffer(
 
 	scan = buffer;
 
-	if (attrs->path && git__suffixcmp(attrs->path, GIT_ATTR_FILE) == 0) {
-		context = git__strndup(attrs->path,
-			strlen(attrs->path) - strlen(GIT_ATTR_FILE));
-		GITERR_CHECK_ALLOC(context);
+	/* if subdir file path, convert context for file paths */
+	if (attrs->key && git__suffixcmp(attrs->key, "/" GIT_ATTR_FILE) == 0) {
+		context = attrs->key + 2;
+		context[strlen(context) - strlen(GIT_ATTR_FILE)] = '\0';
 	}
 
 	while (!error && *scan) {
@@ -112,28 +107,34 @@ int git_attr_file__from_buffer(
 	}
 
 	git_attr_rule__free(rule);
-	git__free(context);
+
+	/* restore file path used for context */
+	if (context)
+		context[strlen(context)] = '.'; /* first char of GIT_ATTR_FILE */
 
 	return error;
 }
 
-int git_attr_file__from_file(
-	git_repository *repo, const char *path, git_attr_file *file)
+int git_attr_file__new_and_load(
+	git_attr_file **attrs_ptr,
+	const char *path)
 {
 	int error;
-	git_buf fbuf = GIT_BUF_INIT;
+	git_buf content = GIT_BUF_INIT;
 
-	assert(path && file);
+	if ((error = git_attr_file__new(attrs_ptr, 0, path, NULL)) < 0)
+		return error;
 
-	if (file->path == NULL && git_attr_file__set_path(repo, path, file) < 0)
-		return -1;
-
-	if (git_futils_readbuffer(&fbuf, path) < 0)
-		return -1;
+	if (!(error = git_futils_readbuffer(&content, path)))
+		error = git_attr_file__parse_buffer(
+			NULL, git_buf_cstr(&content), *attrs_ptr);
 
-	error = git_attr_file__from_buffer(repo, fbuf.ptr, file);
+	git_buf_free(&content);
 
-	git_buf_free(&fbuf);
+	if (error) {
+		git_attr_file__free(*attrs_ptr);
+		*attrs_ptr = NULL;
+	}
 
 	return error;
 }
@@ -151,9 +152,6 @@ void git_attr_file__free(git_attr_file *file)
 
 	git_vector_free(&file->rules);
 
-	git__free(file->path);
-	file->path = NULL;
-
 	if (file->pool_is_allocated) {
 		git_pool_clear(file->pool);
 		git__free(file->pool);
@@ -504,7 +502,7 @@ int git_attr_assignment__parse(
 			assign->value = git_attr__false;
 			scan++;
 		} else if (*scan == '!') {
-			assign->value = NULL; /* explicit unspecified state */
+			assign->value = git_attr__unset; /* explicit unspecified state */
 			scan++;
 		} else if (*scan == '#') /* comment rest of line */
 			break;
diff --git a/src/attr_file.h b/src/attr_file.h
index 10851bc49..ec488c4dc 100644
--- a/src/attr_file.h
+++ b/src/attr_file.h
@@ -48,7 +48,7 @@ typedef struct {
 } git_attr_assignment;
 
 typedef struct {
-	char *path;				/* cache the path this was loaded from */
+	char *key;				/* cache "source#path" this was loaded from */
 	git_vector rules;		/* vector of <rule*> or <fnmatch*> */
 	git_pool *pool;
 	bool pool_is_allocated;
@@ -61,20 +61,25 @@ 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_pool *pool);
+extern int git_attr_file__new(
+	git_attr_file **attrs_ptr, git_attr_file_source src, const char *path, git_pool *pool);
+
+extern int git_attr_file__new_and_load(
+	git_attr_file **attrs_ptr, const char *path);
+
 extern void git_attr_file__free(git_attr_file *file);
 
-extern int git_attr_file__from_buffer(
+extern int git_attr_file__parse_buffer(
 	git_repository *repo, const char *buf, git_attr_file *file);
-extern int git_attr_file__from_file(
-	git_repository *repo, const char *path, git_attr_file *file);
-
-extern int git_attr_file__set_path(
-	git_repository *repo, const char *path, git_attr_file *file);
 
 extern int git_attr_file__lookup_one(
 	git_attr_file *file,
diff --git a/src/crlf.c b/src/crlf.c
index b495d2de0..5d09a1f40 100644
--- a/src/crlf.c
+++ b/src/crlf.c
@@ -82,7 +82,8 @@ static int crlf_load_attributes(struct crlf_attrs *ca, git_repository *repo, con
 	const char *attr_vals[NUM_CONV_ATTRS];
 	int error;
 
-	error = git_attr_get_many(repo, path, NUM_CONV_ATTRS, attr_names, attr_vals);
+	error = git_attr_get_many(
+		repo, 0, path, NUM_CONV_ATTRS, attr_names, attr_vals);
 
 	if (error == GIT_ENOTFOUND) {
 		ca->crlf_action = GIT_CRLF_GUESS;
diff --git a/src/diff_output.c b/src/diff_output.c
index ca28fd01e..c380db996 100644
--- a/src/diff_output.c
+++ b/src/diff_output.c
@@ -103,7 +103,7 @@ static int diff_output_cb(void *priv, mmbuffer_t *bufs, int len)
 static int update_file_is_binary_by_attr(git_repository *repo, git_diff_file *file)
 {
 	const char *value;
-	if (git_attr_get(repo, file->path, "diff", &value) < 0)
+	if (git_attr_get(repo, 0, file->path, "diff", &value) < 0)
 		return -1;
 
 	if (GIT_ATTR_FALSE(value))
diff --git a/src/ignore.c b/src/ignore.c
index 20b96c602..6f70b972d 100644
--- a/src/ignore.c
+++ b/src/ignore.c
@@ -5,29 +5,22 @@
 #define GIT_IGNORE_FILE_INREPO	"info/exclude"
 #define GIT_IGNORE_FILE			".gitignore"
 
-static int load_ignore_file(
-	git_repository *repo, const char *path, git_attr_file *ignores)
+static int parse_ignore_file(
+	git_repository *repo, const char *buffer, git_attr_file *ignores)
 {
 	int error;
-	git_buf fbuf = GIT_BUF_INIT;
 	git_attr_fnmatch *match = NULL;
 	const char *scan = NULL;
 	char *context = NULL;
 
-	if (ignores->path == NULL) {
-		if (git_attr_file__set_path(repo, path, ignores) < 0)
-			return -1;
-	}
+	GIT_UNUSED(repo);
 
-	if (git__suffixcmp(ignores->path, GIT_IGNORE_FILE) == 0) {
-		context = git__strndup(ignores->path,
-			strlen(ignores->path) - strlen(GIT_IGNORE_FILE));
-		GITERR_CHECK_ALLOC(context);
+	if (ignores->key && git__suffixcmp(ignores->key, "/" GIT_IGNORE_FILE) == 0) {
+		context = ignores->key + 2;
+		context[strlen(context) - strlen(GIT_IGNORE_FILE)] = '\0';
 	}
 
-	error = git_futils_readbuffer(&fbuf, path);
-
-	scan = fbuf.ptr;
+	scan = buffer;
 
 	while (!error && *scan) {
 		if (!match) {
@@ -54,23 +47,27 @@ static int load_ignore_file(
 		}
 	}
 
-	git_buf_free(&fbuf);
 	git__free(match);
-	git__free(context);
+	/* restore file path used for context */
+	if (context)
+		context[strlen(context)] = '.'; /* first char of GIT_IGNORE_FILE */
 
 	return error;
 }
 
-#define push_ignore(R,S,B,F) \
-	git_attr_cache__push_file((R),(S),(B),(F),load_ignore_file)
+#define push_ignore_file(R,S,B,F) \
+	git_attr_cache__push_file((R),(B),(F),GIT_ATTR_FILE_FROM_FILE,parse_ignore_file,(S))
 
 static int push_one_ignore(void *ref, git_buf *path)
 {
 	git_ignores *ign = (git_ignores *)ref;
-	return push_ignore(ign->repo, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
+	return push_ignore_file(ign->repo, &ign->ign_path, path->ptr, GIT_IGNORE_FILE);
 }
 
-int git_ignore__for_path(git_repository *repo, const char *path, git_ignores *ignores)
+int git_ignore__for_path(
+	git_repository *repo,
+	const char *path,
+	git_ignores *ignores)
 {
 	int error = 0;
 	const char *workdir = git_repository_workdir(repo);
@@ -86,30 +83,37 @@ int git_ignore__for_path(git_repository *repo, const char *path, git_ignores *ig
 		(error = git_attr_cache__init(repo)) < 0)
 		goto cleanup;
 
-	/* translate path into directory within workdir */
-	if ((error = git_path_find_dir(&ignores->dir, path, workdir)) < 0)
+	/* given a unrooted path in a non-bare repo, resolve it */
+	if (workdir && git_path_root(path) < 0)
+		error = git_path_find_dir(&ignores->dir, path, workdir);
+	else
+		error = git_buf_sets(&ignores->dir, path);
+	if (error < 0)
 		goto cleanup;
 
 	/* set up internals */
-	error = git_attr_cache__lookup_or_create_file(
-		repo, GIT_IGNORE_INTERNAL, NULL, NULL, &ignores->ign_internal);
+	error = git_attr_cache__internal_file(
+		repo, GIT_IGNORE_INTERNAL, &ignores->ign_internal);
 	if (error < 0)
 		goto cleanup;
 
 	/* load .gitignore up the path */
-	error = git_path_walk_up(&ignores->dir, workdir, push_one_ignore, ignores);
-	if (error < 0)
-		goto cleanup;
+	if (workdir != NULL) {
+		error = git_path_walk_up(
+			&ignores->dir, workdir, push_one_ignore, ignores);
+		if (error < 0)
+			goto cleanup;
+	}
 
 	/* load .git/info/exclude */
-	error = push_ignore(repo, &ignores->ign_global,
+	error = push_ignore_file(repo, &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(repo, &ignores->ign_global, NULL,
+		error = push_ignore_file(repo, &ignores->ign_global, NULL,
 			git_repository_attr_cache(repo)->cfg_excl_file);
 
 cleanup:
@@ -124,7 +128,7 @@ int git_ignore__push_dir(git_ignores *ign, const char *dir)
 	if (git_buf_joinpath(&ign->dir, ign->dir.ptr, dir) < 0)
 		return -1;
 	else
-		return push_ignore(
+		return push_ignore_file(
 			ign->repo, &ign->ign_path, ign->dir.ptr, GIT_IGNORE_FILE);
 }
 
@@ -132,7 +136,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);
-		if (git__suffixcmp(ign->dir.ptr, file->path) == 0)
+		if (git__suffixcmp(ign->dir.ptr, file->key + 2) == 0)
 			git_vector_pop(&ign->ign_path);
 		git_buf_rtruncate_at_char(&ign->dir, '/');
 	}
@@ -163,7 +167,8 @@ static bool ignore_lookup_in_rules(
 	return false;
 }
 
-int git_ignore__lookup(git_ignores *ignores, const char *pathname, int *ignored)
+int git_ignore__lookup(
+	git_ignores *ignores, const char *pathname, int *ignored)
 {
 	unsigned int i;
 	git_attr_file *file;
diff --git a/src/ignore.h b/src/ignore.h
index 49f72bf25..809d2edbd 100644
--- a/src/ignore.h
+++ b/src/ignore.h
@@ -25,13 +25,14 @@ typedef struct {
 	git_vector ign_global;
 } git_ignores;
 
-extern int git_ignore__for_path(
-	git_repository *repo, const char *path, git_ignores *ign);
+extern int git_ignore__for_path(git_repository *repo, const char *path, git_ignores *ign);
 
 extern int git_ignore__push_dir(git_ignores *ign, const char *dir);
+
 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);
 
 #endif
diff --git a/src/object.c b/src/object.c
index 8e8eac4e3..7189d60b1 100644
--- a/src/object.c
+++ b/src/object.c
@@ -292,3 +292,42 @@ size_t git_object__size(git_otype type)
 	return git_objects_table[type].size;
 }
 
+int git_object__resolve_to_type(git_object **obj, git_otype type)
+{
+	int error = 0;
+	git_object *scan, *next;
+
+	if (type == GIT_OBJ_ANY)
+		return 0;
+
+	scan = *obj;
+
+	while (!error && scan && git_object_type(scan) != type) {
+
+		switch (git_object_type(scan)) {
+		case GIT_OBJ_COMMIT:
+		{
+			git_tree *tree = NULL;
+			error = git_commit_tree(&tree, (git_commit *)scan);
+			next = (git_object *)tree;
+			break;
+		}
+
+		case GIT_OBJ_TAG:
+			error = git_tag_target(&next, (git_tag *)scan);
+			break;
+
+		default:
+			giterr_set(GITERR_REFERENCE, "Object does not resolve to type");
+			error = -1;
+			next = NULL;
+			break;
+		}
+
+		git_object_free(scan);
+		scan = next;
+	}
+
+	*obj = scan;
+	return error;
+}
diff --git a/src/repository.c b/src/repository.c
index cfabee420..d4de38104 100644
--- a/src/repository.c
+++ b/src/repository.c
@@ -862,3 +862,23 @@ int git_repository_is_bare(git_repository *repo)
 	assert(repo);
 	return repo->is_bare;
 }
+
+int git_repository_head_tree(git_tree **tree, git_repository *repo)
+{
+	git_oid head_oid;
+	git_object *obj = NULL;
+
+	if (git_reference_name_to_oid(&head_oid, repo, GIT_HEAD_FILE) < 0) {
+		/* cannot resolve HEAD - probably brand new repo */
+		giterr_clear();
+		*tree = NULL;
+		return 0;
+	}
+
+	if (git_object_lookup(&obj, repo, &head_oid, GIT_OBJ_ANY) < 0 ||
+		git_object__resolve_to_type(&obj, GIT_OBJ_TREE) < 0)
+		return -1;
+
+	*tree = (git_tree *)obj;
+	return 0;
+}
diff --git a/src/repository.h b/src/repository.h
index 1ffac58f1..91c69a655 100644
--- a/src/repository.h
+++ b/src/repository.h
@@ -98,6 +98,8 @@ struct git_repository {
  * export */
 void git_object__free(void *object);
 
+int git_object__resolve_to_type(git_object **obj, git_otype type);
+
 int git_oid__parse(git_oid *oid, const char **buffer_out, const char *buffer_end, const char *header);
 void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid);
 
@@ -106,6 +108,8 @@ GIT_INLINE(git_attr_cache *) git_repository_attr_cache(git_repository *repo)
 	return &repo->attrcache;
 }
 
+int git_repository_head_tree(git_tree **tree, git_repository *repo);
+
 /*
  * Weak pointers to repository internals.
  *
diff --git a/src/status.c b/src/status.c
index 356cbeb98..ff8535c66 100644
--- a/src/status.c
+++ b/src/status.c
@@ -18,41 +18,6 @@
 #include "git2/diff.h"
 #include "diff.h"
 
-static int resolve_head_to_tree(git_tree **tree, git_repository *repo)
-{
-	git_oid head_oid;
-	git_object *obj = NULL;
-
-	if (git_reference_name_to_oid(&head_oid, repo, GIT_HEAD_FILE) < 0) {
-		/* cannot resolve HEAD - probably brand new repo */
-		giterr_clear();
-		*tree = NULL;
-		return 0;
-	}
-
-	if (git_object_lookup(&obj, repo, &head_oid, GIT_OBJ_ANY) < 0)
-		goto fail;
-
-	switch (git_object_type(obj)) {
-	case GIT_OBJ_TREE:
-		*tree = (git_tree *)obj;
-		break;
-	case GIT_OBJ_COMMIT:
-		if (git_commit_tree(tree, (git_commit *)obj) < 0)
-			goto fail;
-		git_object_free(obj);
-		break;
-	default:
-		goto fail;
-	}
-
-	return 0;
-
-fail:
-	git_object_free(obj);
-	return -1;
-}
-
 static unsigned int index_delta2status(git_delta_t index_status)
 {
 	unsigned int st = GIT_STATUS_CURRENT;
@@ -120,11 +85,8 @@ int git_status_foreach_ext(
 
 	assert(show <= GIT_STATUS_SHOW_INDEX_THEN_WORKDIR);
 
-	switch (resolve_head_to_tree(&head, repo)) {
-	case 0: break;
-	case GIT_ENOTFOUND: return 0;
-	default: return -1;
-	}
+	if ((err = git_repository_head_tree(&head, repo)) < 0)
+		return err;
 
 	memset(&diffopt, 0, sizeof(diffopt));
 	memcpy(&diffopt.pathspec, &opts->pathspec, sizeof(diffopt.pathspec));
@@ -405,7 +367,7 @@ int git_status_file(
 	status_entry_update_from_index(e, index);
 
 	/* Try to find file in HEAD */
-	if ((error = resolve_head_to_tree(&tree, repo)) < 0)
+	if ((error = git_repository_head_tree(&tree, repo)) < 0)
 		goto cleanup;
 
 	if (tree != NULL) {