Update diff to use iterators

This is a major reorganization of the diff code.  This changes
the diff functions to use the iterators for traversing the
content.  This allowed a lot of code to be simplified.  Also,
this moved the functions relating to outputting a diff into a
new file (diff_output.c).

This includes a number of other changes - adding utility
functions, extending iterators, etc. plus more tests for the
diff code.  This also takes the example diff.c program much
further in terms of emulating git-diff command line options.

examples/diff.c

@@ -116,7 +116,7 @@ void usage(const char *message, const char *arg)
 		fprintf(stderr, "%s: %s\n", message, arg);
 	else if (message)
 		fprintf(stderr, "%s\n", message);
-	fprintf(stderr, "usage: diff <tree-oid> <tree-oid>\n");
+	fprintf(stderr, "usage: diff [<tree-oid> [<tree-oid>]]\n");
 	exit(1);
 }
 
@@ -127,7 +127,7 @@ int main(int argc, char *argv[])
 	git_tree *t1 = NULL, *t2 = NULL;
 	git_diff_options opts = {0};
 	git_diff_list *diff;
-	int i, color = -1, compact = 0;
+	int i, color = -1, compact = 0, cached = 0;
 	char *a, *dir = ".", *treeish1 = NULL, *treeish2 = NULL;
 
 	/* parse arguments as copied from git-diff */
@@ -146,6 +146,8 @@ int main(int argc, char *argv[])
 		else if (!strcmp(a, "-p") || !strcmp(a, "-u") ||
 			!strcmp(a, "--patch"))
 			compact = 0;
+		else if (!strcmp(a, "--cached"))
+			cached = 1;
 		else if (!strcmp(a, "--name-status"))
 			compact = 1;
 		else if (!strcmp(a, "--color"))
@@ -162,6 +164,10 @@ int main(int argc, char *argv[])
 			opts.flags |= GIT_DIFF_IGNORE_WHITESPACE_CHANGE;
 		else if (!strcmp(a, "-w") || !strcmp(a, "--ignore-all-space"))
 			opts.flags |= GIT_DIFF_IGNORE_WHITESPACE;
+		else if (!strcmp(a, "--ignored"))
+			opts.flags |= GIT_DIFF_INCLUDE_IGNORED;
+		else if (!strcmp(a, "--untracked"))
+			opts.flags |= GIT_DIFF_INCLUDE_UNTRACKED;
 		else if (!check_uint16_param(a, "-U", &opts.context_lines) &&
 			!check_uint16_param(a, "--unified=", &opts.context_lines) &&
 			!check_uint16_param(a, "--inter-hunk-context=",
@@ -171,9 +177,6 @@ int main(int argc, char *argv[])
 			usage("Unknown arg", a);
 	}
 
-	if (!treeish1)
-		usage("Must provide at least one tree identifier (for now)", NULL);
-
 	/* open repo */
 
 	check(git_repository_discover(path, sizeof(path), dir, 0, "/"),
@@ -181,20 +184,40 @@ int main(int argc, char *argv[])
 	check(git_repository_open(&repo, path),
 		"Could not open repository");
 
+	if (treeish1)
 		check(resolve_to_tree(repo, treeish1, &t1), "Looking up first tree");
 	if (treeish2)
 		check(resolve_to_tree(repo, treeish2, &t2), "Looking up second tree");
 
-	if (!treeish2)
-		check(git_diff_index_to_tree(repo, &opts, t1, &diff), "Generating diff");
+	/* <sha1> <sha2> */
+	/* <sha1> --cached */
+	/* <sha1> */
+	/* --cached */
+	/* nothing */
+
+	if (t1 && t2)
+		check(git_diff_tree_to_tree(repo, &opts, t1, t2, &diff), "Diff");
+	else if (t1 && cached)
+		check(git_diff_index_to_tree(repo, &opts, t1, &diff), "Diff");
+	else if (t1) {
+		git_diff_list *diff2;
+		check(git_diff_index_to_tree(repo, &opts, t1, &diff), "Diff");
+		check(git_diff_workdir_to_index(repo, &opts, &diff2), "Diff");
+		check(git_diff_merge(diff, diff2), "Merge diffs");
+		git_diff_list_free(diff2);
+	}
+	else if (cached) {
+		check(resolve_to_tree(repo, "HEAD", &t1), "looking up HEAD");
+		check(git_diff_index_to_tree(repo, &opts, t1, &diff), "Diff");
+	}
 	else
-		check(git_diff_tree_to_tree(repo, &opts, t1, t2, &diff), "Generating diff");
+		check(git_diff_workdir_to_index(repo, &opts, &diff), "Diff");
 
 	if (color >= 0)
 		fputs(colors[0], stdout);
 
 	if (compact)
-		check(git_diff_print_compact(diff, &color, printer), "Displaying diff summary");
+		check(git_diff_print_compact(diff, &color, printer), "Displaying diff");
 	else
 		check(git_diff_print_patch(diff, &color, printer), "Displaying diff");
 

include/git2/diff.h

@@ -37,7 +37,9 @@ enum {
 	GIT_DIFF_IGNORE_WHITESPACE_CHANGE = (1 << 3),
 	GIT_DIFF_IGNORE_WHITESPACE_EOL = (1 << 4),
 	GIT_DIFF_IGNORE_SUBMODULES = (1 << 5),
-	GIT_DIFF_PATIENCE = (1 << 6)
+	GIT_DIFF_PATIENCE = (1 << 6),
+	GIT_DIFF_INCLUDE_IGNORED = (1 << 7),
+	GIT_DIFF_INCLUDE_UNTRACKED = (1 << 8)
 };
 
 /**
@@ -63,6 +65,26 @@ typedef struct {
  */
 typedef struct git_diff_list git_diff_list;
 
+enum {
+	GIT_DIFF_FILE_VALID_OID  = (1 << 0),
+	GIT_DIFF_FILE_FREE_PATH  = (1 << 1),
+	GIT_DIFF_FILE_BINARY     = (1 << 2),
+	GIT_DIFF_FILE_NOT_BINARY = (1 << 3),
+	GIT_DIFF_FILE_FREE_DATA  = (1 << 4),
+	GIT_DIFF_FILE_UNMAP_DATA = (1 << 5)
+};
+
+/**
+ * Description of one side of a diff.
+ */
+typedef struct {
+	git_oid oid;
+	char *path;
+	uint16_t mode;
+	git_off_t size;
+	unsigned int flags;
+} git_diff_file;
+
 /**
  * Description of changes to one file.
  *
@@ -77,17 +99,11 @@ typedef struct git_diff_list git_diff_list;
  * It will just use the git attributes for those files.
  */
 typedef struct {
+	git_diff_file old;
+	git_diff_file new;
 	git_status_t status;     /**< value from tree.h */
-	unsigned int old_attr;
-	unsigned int new_attr;
-	git_oid      old_oid;
-	git_oid      new_oid;
-	git_blob     *old_blob;
-	git_blob     *new_blob;
-	const char   *path;
-	const char   *new_path;  /**< NULL unless status is RENAMED or COPIED */
-	int          similarity; /**< for RENAMED and COPIED, value from 0 to 100 */
-	int          binary;     /**< files in diff are binary? */
+	unsigned int similarity; /**< for RENAMED and COPIED, value from 0 to 100 */
+	int binary;
 } git_diff_delta;
 
 /**
@@ -170,7 +186,18 @@ typedef int (*git_diff_output_fn)(
 /**@{*/
 
 /**
+ * Deallocate a diff list.
+ */
+GIT_EXTERN(void) git_diff_list_free(git_diff_list *diff);
+
+/**
  * Compute a difference between two tree objects.
+ *
+ * @param repo The repository containing the trees.
+ * @param opts Structure with options to influence diff or NULL for defaults.
+ * @param old A git_tree object to diff from.
+ * @param new A git_tree object to diff to.
+ * @param diff A pointer to a git_diff_list pointer that will be allocated.
  */
 GIT_EXTERN(int) git_diff_tree_to_tree(
 	git_repository *repo,
@@ -181,7 +208,11 @@ GIT_EXTERN(int) git_diff_tree_to_tree(
 
 /**
  * Compute a difference between a tree and the index.
- * @todo NOT IMPLEMENTED
+ *
+ * @param repo The repository containing the tree and index.
+ * @param opts Structure with options to influence diff or NULL for defaults.
+ * @param old A git_tree object to diff from.
+ * @param diff A pointer to a git_diff_list pointer that will be allocated.
  */
 GIT_EXTERN(int) git_diff_index_to_tree(
 	git_repository *repo,
@@ -190,28 +221,56 @@ GIT_EXTERN(int) git_diff_index_to_tree(
 	git_diff_list **diff);
 
 /**
- * Compute a difference between the working directory and a tree.
- * @todo NOT IMPLEMENTED
+ * Compute a difference between the working directory and the index.
+ *
+ * @param repo The repository.
+ * @param opts Structure with options to influence diff or NULL for defaults.
+ * @param diff A pointer to a git_diff_list pointer that will be allocated.
  */
-GIT_EXTERN(int) git_diff_workdir_to_tree(
+GIT_EXTERN(int) git_diff_workdir_to_index(
 	git_repository *repo,
 	const git_diff_options *opts, /**< can be NULL for defaults */
-	git_tree *old,
 	git_diff_list **diff);
 
 /**
- * Compute a difference between the working directory and the index.
- * @todo NOT IMPLEMENTED
+ * Compute a difference between the working directory and a tree.
+ *
+ * This returns strictly the differences between the tree and the
+ * files contained in the working directory, regardless of the state
+ * of files in the index.  There is no direct equivalent in C git.
+ *
+ * This is *NOT* the same as 'git diff HEAD' or 'git diff <SHA>'.  Those
+ * commands diff the tree, the index, and the workdir.  To emulate those
+ * functions, call `git_diff_index_to_tree` and `git_diff_workdir_to_index`,
+ * then call `git_diff_merge` on the results.
+ *
+ * @param repo The repository containing the tree.
+ * @param opts Structure with options to influence diff or NULL for defaults.
+ * @param old A git_tree object to diff from.
+ * @param diff A pointer to a git_diff_list pointer that will be allocated.
  */
-GIT_EXTERN(int) git_diff_workdir_to_index(
+GIT_EXTERN(int) git_diff_workdir_to_tree(
 	git_repository *repo,
 	const git_diff_options *opts, /**< can be NULL for defaults */
+	git_tree *old,
 	git_diff_list **diff);
 
 /**
- * Deallocate a diff list.
+ * Merge one diff list into another.
+ *
+ * This merges items from the "from" list into the "onto" list.  The
+ * resulting diff list will have all items that appear in either list.
+ * If an item appears in both lists, then it will be "merged" to appear
+ * as if the old version was from the "onto" list and the new version
+ * is from the "from" list (with the exception that if the item has a
+ * pending DELETE in the middle, then it will show as deleted).
+ *
+ * @param onto Diff to merge into.
+ * @param from Diff to merge.
  */
-GIT_EXTERN(void) git_diff_list_free(git_diff_list *diff);
+GIT_EXTERN(int) git_diff_merge(
+	git_diff_list *onto,
+	const git_diff_list *from);
 
 /**@}*/
 

include/git2/oid.h

@@ -160,6 +160,11 @@ GIT_EXTERN(int) git_oid_ncmp(const git_oid *a, const git_oid *b, unsigned int le
 GIT_EXTERN(int) git_oid_streq(const git_oid *a, const char *str);
 
 /**
+ * Check is an oid is all zeros.
+ */
+GIT_EXTERN(int) git_oid_iszero(const git_oid *a);
+
+/**
  * OID Shortener object
  */
 typedef struct git_oid_shorten git_oid_shorten;

include/git2/status.h

@@ -31,7 +31,7 @@ GIT_BEGIN_DECL
 #define GIT_STATUS_WT_MODIFIED		(1 << 4)
 #define GIT_STATUS_WT_DELETED		(1 << 5)
 
-#define GIT_STATUS_IGNORED			(1 << 6)
+#define GIT_STATUS_WT_IGNORED		(1 << 6)
 
 /**
  * Gather file statuses and run a callback for each one.

src/diff.h

@@ -10,15 +10,15 @@
 #include <stdio.h>
 #include "vector.h"
 #include "buffer.h"
+#include "iterator.h"
+#include "repository.h"
 
 struct git_diff_list {
 	git_repository   *repo;
 	git_diff_options opts;
-	git_vector       files;    /* vector of git_diff_file_delta */
-
-	/* the following are just used while processing the diff list */
-	git_buf          pfx;
-	git_status_t     status;
+	git_vector       deltas;    /* vector of git_diff_file_delta */
+	git_iterator_type_t old_src;
+	git_iterator_type_t new_src;
 };
 
 #endif

src/fileops.c

@@ -79,10 +79,6 @@ git_off_t git_futils_filesize(git_file fd)
 	return sb.st_size;
 }
 
-#define GIT_MODE_PERMS_MASK			0777
-#define GIT_CANONICAL_PERMS(MODE)	(((MODE) & 0100) ? 0755 : 0644)
-#define GIT_MODE_TYPE(MODE)			((MODE) & ~GIT_MODE_PERMS_MASK)
-
 mode_t git_futils_canonical_mode(mode_t raw_mode)
 {
 	if (S_ISREG(raw_mode))
@@ -181,6 +177,15 @@ int git_futils_mmap_ro(git_map *out, git_file fd, git_off_t begin, size_t len)
 	return p_mmap(out, len, GIT_PROT_READ, GIT_MAP_SHARED, fd, begin);
 }
 
+int git_futils_mmap_ro_file(git_map *out, const char *path)
+{
+	git_file fd = p_open(path, O_RDONLY /* | O_NOATIME */);
+	size_t len = git_futils_filesize(fd);
+	int result = git_futils_mmap_ro(out, fd, 0, len);
+	p_close(fd);
+	return result;
+}
+
 void git_futils_mmap_free(git_map *out)
 {
 	p_munmap(out);

src/fileops.h

@@ -81,6 +81,10 @@ extern int git_futils_mv_withpath(const char *from, const char *to, const mode_t
  */
 extern git_off_t git_futils_filesize(git_file fd);
 
+#define GIT_MODE_PERMS_MASK			0777
+#define GIT_CANONICAL_PERMS(MODE)	(((MODE) & 0100) ? 0755 : 0644)
+#define GIT_MODE_TYPE(MODE)			((MODE) & ~GIT_MODE_PERMS_MASK)
+
 /**
  * Convert a mode_t from the OS to a legal git mode_t value.
  */
@@ -109,6 +113,19 @@ extern int git_futils_mmap_ro(
 	size_t len);
 
 /**
+ * Read-only map an entire file.
+ *
+ * @param out buffer to populate with the mapping information.
+ * @param path path to file to be opened.
+ * @return
+ * - GIT_SUCCESS on success;
+ * - GIT_EOSERR on an unspecified OS related error.
+ */
+extern int git_futils_mmap_ro_file(
+	git_map *out,
+	const char *path);
+
+/**
  * Release the memory associated with a previous memory mapping.
  * @param map the mapping description previously configured.
  */

src/iterator.c

@@ -143,6 +143,16 @@ static void tree_iterator__free(git_iterator *self)
 	git_buf_free(&ti->path);
 }
 
+static int tree_iterator__reset(git_iterator *self)
+{
+	tree_iterator *ti = (tree_iterator *)self;
+	while (ti->stack && ti->stack->next)
+		tree_iterator__pop_frame(ti);
+	if (ti->stack)
+		ti->stack->index = 0;
+	return tree_iterator__expand_tree(ti);
+}
+
 int git_iterator_for_tree(
 	git_repository *repo, git_tree *tree, git_iterator **iter)
 {
@@ -155,6 +165,7 @@ int git_iterator_for_tree(
 	ti->base.current = tree_iterator__current;
 	ti->base.at_end  = tree_iterator__at_end;
 	ti->base.advance = tree_iterator__advance;
+	ti->base.reset   = tree_iterator__reset;
 	ti->base.free    = tree_iterator__free;
 	ti->repo         = repo;
 	ti->stack        = tree_iterator__alloc_frame(tree);
@@ -199,6 +210,13 @@ static int index_iterator__advance(
 	return GIT_SUCCESS;
 }
 
+static int index_iterator__reset(git_iterator *self)
+{
+	index_iterator *ii = (index_iterator *)self;
+	ii->current = 0;
+	return GIT_SUCCESS;
+}
+
 static void index_iterator__free(git_iterator *self)
 {
 	index_iterator *ii = (index_iterator *)self;
@@ -217,6 +235,7 @@ int git_iterator_for_index(git_repository *repo, git_iterator **iter)
 	ii->base.current = index_iterator__current;
 	ii->base.at_end  = index_iterator__at_end;
 	ii->base.advance = index_iterator__advance;
+	ii->base.reset   = index_iterator__reset;
 	ii->base.free    = index_iterator__free;
 	ii->current      = 0;
 
@@ -251,7 +270,7 @@ static workdir_iterator_frame *workdir_iterator__alloc_frame(void)
 	workdir_iterator_frame *wf = git__calloc(1, sizeof(workdir_iterator_frame));
 	if (wf == NULL)
 		return wf;
-	if (git_vector_init(&wf->entries, 0, git__strcmp_cb) != GIT_SUCCESS) {
+	if (git_vector_init(&wf->entries, 0, git_path_with_stat_cmp) != GIT_SUCCESS) {
 		git__free(wf);
 		return NULL;
 	}
@@ -261,7 +280,7 @@ static workdir_iterator_frame *workdir_iterator__alloc_frame(void)
 static void workdir_iterator__free_frame(workdir_iterator_frame *wf)
 {
 	unsigned int i;
-	char *path;
+	git_path_with_stat *path;
 
 	git_vector_foreach(&wf->entries, i, path)
 		git__free(path);
@@ -278,10 +297,7 @@ static int workdir_iterator__expand_dir(workdir_iterator *wi)
 	if (wf == NULL)
 		return GIT_ENOMEM;
 
-	/* allocate dir entries with extra byte (the "1" param) so we
-	 * can suffix directory names with a "/".
-	 */
-	error = git_path_dirload(wi->path.ptr, wi->root_len, 1, &wf->entries);
+	error = git_path_dirload_with_stat(wi->path.ptr, wi->root_len, &wf->entries);
 	if (error < GIT_SUCCESS || wf->entries.length == 0) {
 		workdir_iterator__free_frame(wf);
 		return GIT_ENOTFOUND;
@@ -319,7 +335,7 @@ static int workdir_iterator__advance(
 	int error;
 	workdir_iterator *wi = (workdir_iterator *)self;
 	workdir_iterator_frame *wf;
-	const char *next;
+	git_path_with_stat *next;
 
 	if (entry != NULL)
 		*entry = NULL;
@@ -330,7 +346,7 @@ static int workdir_iterator__advance(
 	while ((wf = wi->stack) != NULL) {
 		next = git_vector_get(&wf->entries, ++wf->index);
 		if (next != NULL) {
-			if (strcmp(next, DOT_GIT) == 0)
+			if (strcmp(next->path, DOT_GIT "/") == 0)
 				continue;
 			/* else found a good entry */
 			break;
@@ -355,6 +371,20 @@ static int workdir_iterator__advance(
 	return error;
 }
 
+static int workdir_iterator__reset(git_iterator *self)
+{
+	workdir_iterator *wi = (workdir_iterator *)self;
+	while (wi->stack != NULL && wi->stack->next != NULL) {
+		workdir_iterator_frame *wf = wi->stack;
+		wi->stack = wf->next;
+		workdir_iterator__free_frame(wf);
+		git_ignore__pop_dir(&wi->ignores);
+	}
+	if (wi->stack)
+		wi->stack->index = 0;
+	return GIT_SUCCESS;
+}
+
 static void workdir_iterator__free(git_iterator *self)
 {
 	workdir_iterator *wi = (workdir_iterator *)self;
@@ -372,39 +402,35 @@ static void workdir_iterator__free(git_iterator *self)
 static int workdir_iterator__update_entry(workdir_iterator *wi)
 {
 	int error;
-	struct stat st;
-	char *relpath = git_vector_get(&wi->stack->entries, wi->stack->index);
+	git_path_with_stat *ps = git_vector_get(&wi->stack->entries, wi->stack->index);
 
-	error = git_buf_joinpath(
-		&wi->path, git_repository_workdir(wi->repo), relpath);
+	git_buf_truncate(&wi->path, wi->root_len);
+	error = git_buf_put(&wi->path, ps->path, ps->path_len);
 	if (error < GIT_SUCCESS)
 		return error;
 
 	memset(&wi->entry, 0, sizeof(wi->entry));
-	wi->entry.path = relpath;
+	wi->entry.path = ps->path;
 
 	/* skip over .git directory */
-	if (strcmp(relpath, DOT_GIT) == 0)
+	if (strcmp(ps->path, DOT_GIT "/") == 0)
 		return workdir_iterator__advance((git_iterator *)wi, NULL);
 
 	/* if there is an error processing the entry, treat as ignored */
 	wi->is_ignored = 1;
 
-	if (p_lstat(wi->path.ptr, &st) < 0)
-		return GIT_SUCCESS;
-
 	/* TODO: remove shared code for struct stat conversion with index.c */
-	wi->entry.ctime.seconds = (git_time_t)st.st_ctime;
-	wi->entry.mtime.seconds = (git_time_t)st.st_mtime;
-	wi->entry.dev  = st.st_rdev;
-	wi->entry.ino  = st.st_ino;
-	wi->entry.mode = git_futils_canonical_mode(st.st_mode);
-	wi->entry.uid  = st.st_uid;
-	wi->entry.gid  = st.st_gid;
-	wi->entry.file_size = st.st_size;
+	wi->entry.ctime.seconds = (git_time_t)ps->st.st_ctime;
+	wi->entry.mtime.seconds = (git_time_t)ps->st.st_mtime;
+	wi->entry.dev  = ps->st.st_rdev;
+	wi->entry.ino  = ps->st.st_ino;
+	wi->entry.mode = git_futils_canonical_mode(ps->st.st_mode);
+	wi->entry.uid  = ps->st.st_uid;
+	wi->entry.gid  = ps->st.st_gid;
+	wi->entry.file_size = ps->st.st_size;
 
 	/* if this is a file type we don't handle, treat as ignored */
-	if (st.st_mode == 0)
+	if (wi->entry.mode == 0)
 		return GIT_SUCCESS;
 
 	/* okay, we are far enough along to look up real ignore rule */
@@ -412,18 +438,10 @@ static int workdir_iterator__update_entry(workdir_iterator *wi)
 	if (error != GIT_SUCCESS)
 		return GIT_SUCCESS;
 
-	if (S_ISDIR(st.st_mode)) {
-		if (git_path_contains(&wi->path, DOT_GIT) == GIT_SUCCESS) {
-			/* create submodule entry */
+	/* detect submodules */
+	if (S_ISDIR(wi->entry.mode) &&
+		git_path_contains(&wi->path, DOT_GIT) == GIT_SUCCESS)
 		wi->entry.mode = S_IFGITLINK;
-		} else {
-			/* create directory entry that can be advanced into as needed */
-			size_t pathlen = strlen(wi->entry.path);
-			wi->entry.path[pathlen] = '/';
-			wi->entry.path[pathlen + 1] = '\0';
-			wi->entry.mode = S_IFDIR;
-		}
-	}
 
 	return GIT_SUCCESS;
 }
@@ -439,11 +457,14 @@ int git_iterator_for_workdir(git_repository *repo, git_iterator **iter)
 	wi->base.current = workdir_iterator__current;
 	wi->base.at_end  = workdir_iterator__at_end;
 	wi->base.advance = workdir_iterator__advance;
+	wi->base.reset   = workdir_iterator__reset;
 	wi->base.free    = workdir_iterator__free;
 	wi->repo         = repo;
 
 	error = git_buf_sets(&wi->path, git_repository_workdir(repo));
 	if (error == GIT_SUCCESS)
+		error = git_path_to_dir(&wi->path);
+	if (error == GIT_SUCCESS)
 		error = git_ignore__for_path(repo, "", &wi->ignores);
 	if (error != GIT_SUCCESS) {
 		git__free(wi);

src/iterator.h

@@ -23,6 +23,7 @@ struct git_iterator {
 	int (*current)(git_iterator *, const git_index_entry **);
 	int (*at_end)(git_iterator *);
 	int (*advance)(git_iterator *, const git_index_entry **);
+	int (*reset)(git_iterator *);
 	void (*free)(git_iterator *);
 };
 
@@ -60,6 +61,11 @@ GIT_INLINE(int) git_iterator_advance(
 	return iter->advance(iter, entry);
 }
 
+GIT_INLINE(int) git_iterator_reset(git_iterator *iter)
+{
+	return iter->reset(iter);
+}
+
 GIT_INLINE(void) git_iterator_free(git_iterator *iter)
 {
 	iter->free(iter);

src/oid.c

@@ -190,6 +190,16 @@ int git_oid_streq(const git_oid *a, const char *str)
 	return git_oid_cmp(a, &id) == 0 ? GIT_SUCCESS : GIT_ERROR;
 }
 
+int git_oid_iszero(const git_oid *oid_a)
+{
+	const unsigned char *a = oid_a->id;
+	unsigned int i;
+	for (i = 0; i < GIT_OID_RAWSZ; ++i, ++a)
+		if (*a != 0)
+			return 0;
+	return 1;
+}
+
 typedef short node_index;
 
 typedef union {

src/path.c

@@ -583,3 +583,46 @@ int git_path_dirload(
 	return GIT_SUCCESS;
 }
 
+int git_path_with_stat_cmp(const void *a, const void *b)
+{
+	const git_path_with_stat *psa = a, *psb = b;
+	return git__strcmp_cb(psa->path, psb->path);
+}
+
+int git_path_dirload_with_stat(
+	const char *path,
+	size_t prefix_len,
+	git_vector *contents)
+{
+	int error;
+	unsigned int i;
+	git_path_with_stat *ps;
+	git_buf full = GIT_BUF_INIT;
+
+	if ((error = git_buf_set(&full, path, prefix_len)) != GIT_SUCCESS)
+		return error;
+
+	if ((error = git_path_dirload(path, prefix_len,
+		sizeof(git_path_with_stat) + 1, contents)) != GIT_SUCCESS) {
+		git_buf_free(&full);
+		return error;
+	}
+
+	git_vector_foreach(contents, i, ps) {
+		size_t path_len = strlen((char *)ps);
+
+		memmove(ps->path, ps, path_len + 1);
+		ps->path_len = path_len;
+
+		git_buf_joinpath(&full, full.ptr, ps->path);
+		p_lstat(full.ptr, &ps->st);
+		git_buf_truncate(&full, prefix_len);
+
+		if (S_ISDIR(ps->st.st_mode)) {
+			ps->path[path_len] = '/';
+			ps->path[path_len + 1] = '\0';
+		}
+	}
+
+	return error;
+}

src/path.h

@@ -246,4 +246,26 @@ extern int git_path_dirload(
 	size_t alloc_extra,
 	git_vector *contents);
 
+
+typedef struct {
+	struct stat st;
+	size_t      path_len;
+	char        path[GIT_FLEX_ARRAY];
+} git_path_with_stat;
+
+extern int git_path_with_stat_cmp(const void *a, const void *b);
+
+/**
+ * Load all directory entries along with stat info into a vector.
+ *
+ * This is just like git_path_dirload except that each entry in the
+ * vector is a git_path_with_stat structure that contains both the
+ * path and the stat info, plus directories will have a / suffixed
+ * to their path name.
+ */
+extern int git_path_dirload_with_stat(
+	const char *path,
+	size_t prefix_len,
+	git_vector *contents);
+
 #endif

src/posix.h

@@ -66,4 +66,6 @@ extern int p_rename(const char *from, const char *to);
 #	include "unix/posix.h"
 #endif
 
+#define p_readdir_r(d,e,r) readdir_r(d,e,r)
+
 #endif

src/status.c

@@ -131,7 +131,7 @@ static int status_entry_update_ignore(struct status_entry *e, git_ignores *ignor
 	if ((error = git_ignore__lookup(ignores, path, &ignored)) == GIT_SUCCESS &&
 		ignored)
 		e->status_flags =
-			(e->status_flags & ~GIT_STATUS_WT_NEW) | GIT_STATUS_IGNORED;
+			(e->status_flags & ~GIT_STATUS_WT_NEW) | GIT_STATUS_WT_IGNORED;
 
 	return error;
 }

src/unix/posix.h

@@ -21,6 +21,5 @@
 #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_readdir_r(d,e,r) readdir_r(d,e,r)
 
 #endif

src/vector.c

@@ -220,4 +220,14 @@ void git_vector_clear(git_vector *v)
 	v->sorted = 1;
 }
 
+void git_vector_swap(git_vector *a, git_vector *b)
+{
+	git_vector t;
+
+	if (!a || !b || a == b)
+		return;
 
+	memcpy(&t, a, sizeof(t));
+	memcpy(a, b, sizeof(t));
+	memcpy(b, &t, sizeof(t));
+}

src/vector.h

@@ -24,6 +24,7 @@ typedef struct git_vector {
 int git_vector_init(git_vector *v, unsigned int initial_size, git_vector_cmp cmp);
 void git_vector_free(git_vector *v);
 void git_vector_clear(git_vector *v);
+void git_vector_swap(git_vector *a, git_vector *b);
 
 int git_vector_search(git_vector *v, const void *entry);
 int git_vector_search2(git_vector *v, git_vector_cmp cmp, const void *key);
@@ -38,6 +39,11 @@ GIT_INLINE(void *) git_vector_get(git_vector *v, unsigned int position)
 	return (position < v->length) ? v->contents[position] : NULL;
 }
 
+GIT_INLINE(const void *) git_vector_get_const(const git_vector *v, unsigned int position)
+{
+	return (position < v->length) ? v->contents[position] : NULL;
+}
+
 GIT_INLINE(void *) git_vector_last(git_vector *v)
 {
 	return (v->length > 0) ? git_vector_get(v, v->length - 1) : NULL;

src/win32/dir.c

@@ -58,8 +58,11 @@ git__DIR *git__opendir(const char *dir)
 	return new;
 }
 
-int git__readdir_r(
-	git__DIR *d, struct git__dirent *entry, struct git__dirent **result)
+int git__readdir_ext(
+	git__DIR *d,
+	struct git__dirent *entry,
+	struct git__dirent **result,
+	int *is_dir)
 {
 	if (!d || !entry || !result || d->h == INVALID_HANDLE_VALUE)
 		return -1;
@@ -80,13 +83,16 @@ int git__readdir_r(
 		entry->d_name, GIT_PATH_MAX, NULL, NULL);
 
 	*result = entry;
+	if (is_dir != NULL)
+		*is_dir = ((d->f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0);
+
 	return 0;
 }
 
 struct git__dirent *git__readdir(git__DIR *d)
 {
 	struct git__dirent *result;
-	if (git__readdir_r(d, &d->entry, &result) < 0)
+	if (git__readdir_ext(d, &d->entry, &result, NULL) < 0)
 		return NULL;
 	return result;
 }

src/win32/dir.h

@@ -24,7 +24,8 @@ typedef struct {
 
 extern git__DIR *git__opendir(const char *);
 extern struct git__dirent *git__readdir(git__DIR *);
-extern int git__readdir_r(git__DIR*, struct git__dirent*, struct git__dirent**);
+extern int git__readdir_ext(
+	git__DIR *, struct git__dirent *, struct git__dirent **, int *);
 extern void git__rewinddir(git__DIR *);
 extern int git__closedir(git__DIR *);
 
@@ -33,10 +34,9 @@ extern int git__closedir(git__DIR *);
 #	define DIR git__DIR
 #	define opendir	git__opendir
 #	define readdir	git__readdir
+#   define readdir_r(d,e,r) git__readdir_ext((d),(e),(r),NULL)
 #	define rewinddir git__rewinddir
 #	define closedir git__closedir
 # endif
 
-#define p_readdir_r(d,e,r) git__readdir_r(d,e,r)
-
 #endif /* INCLUDE_dir_h__ */

src/xdiff/xdiff.h

@@ -69,12 +69,12 @@ extern "C" {
 
 typedef struct s_mmfile {
 	char *ptr;
-	long size;
+	size_t size;
 } mmfile_t;
 
 typedef struct s_mmbuffer {
 	char *ptr;
-	long size;
+	size_t size;
 } mmbuffer_t;
 
 typedef struct s_xpparam {

tests-clar/clar_libgit2.h

@@ -38,10 +38,13 @@ GIT_INLINE(void) cl_assert_strequal_internal(
 	if (!match) {
 		char buf[4096];
 		snprintf(buf, 4096, "'%s' != '%s'", a, b);
-		clar__assert(0, file, line, buf, err, 1);
+		clar__assert(0, file, line, err, buf, 1);
 	}
 }
 
+#define cl_assert_intequal(a,b) \
+	do { if ((a) != (b)) { char buf[128]; snprintf(buf,128,"%d != %d",(a),(b)); clar__assert(0,__FILE__,__LINE__,#a " != " #b,buf,1); } } while (0)
+
 /*
  * Some utility macros for building long strings
  */

tests-clar/diff/diff_helpers.c

@@ -29,12 +29,14 @@ int diff_file_fn(
 	diff_expects *e = cb_data;
 	(void)progress;
 	e->files++;
-	if (delta->old_attr == 0)
-		e->file_adds++;
-	else if (delta->new_attr == 0)
-		e->file_dels++;
-	else
-		e->file_mods++;
+	switch (delta->status) {
+	case GIT_STATUS_ADDED: e->file_adds++; break;
+	case GIT_STATUS_DELETED: e->file_dels++; break;
+	case GIT_STATUS_MODIFIED: e->file_mods++; break;
+	case GIT_STATUS_IGNORED: e->file_ignored++; break;
+	case GIT_STATUS_UNTRACKED: e->file_untracked++; break;
+	default: break;
+	}
 	return 0;
 }
 

tests-clar/diff/diff_helpers.h

@@ -9,6 +9,8 @@ typedef struct {
 	int file_adds;
 	int file_dels;
 	int file_mods;
+	int file_ignored;
+	int file_untracked;
 
 	int hunks;
 	int hunk_new_lines;

tests-clar/diff/iterator.c

@@ -338,7 +338,7 @@ static void workdir_iterator_test(
 
 void test_diff_iterator__workdir_0(void)
 {
-	workdir_iterator_test("attr", 24, 2, NULL, "ign");
+	workdir_iterator_test("attr", 25, 2, NULL, "ign");
 }
 
 static const char *status_paths[] = {
@@ -351,10 +351,10 @@ static const char *status_paths[] = {
 	"staged_delete_modified_file",
 	"staged_new_file",
 	"staged_new_file_modified_file",
+	"subdir.txt",
 	"subdir/current_file",
 	"subdir/modified_file",
 	"subdir/new_file",
-	"subdir.txt",
 	NULL
 };
 

tests-clar/diff/tree.c

@@ -100,7 +100,7 @@ void test_diff_tree__options(void)
 
 	git_diff_options opts = {0};
 	git_diff_list *diff = NULL;
-	diff_expects exp;
+	diff_expects actual;
 	int test_ab_or_cd[] = { 0, 0, 0, 0, 1, 1, 1, 1, 1 };
 	git_diff_options test_options[] = {
 		/* a vs b tests */
@@ -123,25 +123,26 @@ void test_diff_tree__options(void)
 	 */
 	diff_expects test_expects[] = {
 		/* a vs b tests */
-		{ 5, 3, 0, 2, 4, 0, 0, 51, 2, 46, 3 },
-		{ 5, 3, 0, 2, 4, 0, 0, 53, 4, 46, 3 },
-		{ 5, 0, 3, 2, 4, 0, 0, 52, 3, 3, 46 },
-		{ 5, 3, 0, 2, 5, 0, 0, 54, 3, 48, 3 },
+		{ 5, 3, 0, 2, 0, 0, 4, 0, 0, 51, 2, 46, 3 },
+		{ 5, 3, 0, 2, 0, 0, 4, 0, 0, 53, 4, 46, 3 },
+		{ 5, 0, 3, 2, 0, 0, 4, 0, 0, 52, 3, 3, 46 },
+		{ 5, 3, 0, 2, 0, 0, 5, 0, 0, 54, 3, 48, 3 },
 		/* c vs d tests */
-		{ 1, 0, 0, 1, 1, 0, 0, 22, 9, 10, 3 },
-		{ 1, 0, 0, 1, 1, 0, 0, 19, 12, 7, 0 },
-		{ 1, 0, 0, 1, 1, 0, 0, 20, 11, 8, 1 },
-		{ 1, 0, 0, 1, 1, 0, 0, 20, 11, 8, 1 },
-		{ 1, 0, 0, 1, 1, 0, 0, 18, 11, 0, 7 },
+		{ 1, 0, 0, 1, 0, 0, 1, 0, 0, 22, 9, 10, 3 },
+		{ 1, 0, 0, 1, 0, 0, 1, 0, 0, 19, 12, 7, 0 },
+		{ 1, 0, 0, 1, 0, 0, 1, 0, 0, 20, 11, 8, 1 },
+		{ 1, 0, 0, 1, 0, 0, 1, 0, 0, 20, 11, 8, 1 },
+		{ 1, 0, 0, 1, 0, 0, 1, 0, 0, 18, 11, 0, 7 },
 		{ 0 },
 	};
+	diff_expects *expected;
 	int i;
 
 	cl_assert(a);
 	cl_assert(b);
 
 	for (i = 0; test_expects[i].files > 0; i++) {
-		memset(&exp, 0, sizeof(exp)); /* clear accumulator */
+		memset(&actual, 0, sizeof(actual)); /* clear accumulator */
 		opts = test_options[i];
 
 		if (test_ab_or_cd[i] == 0)
@@ -150,17 +151,18 @@ void test_diff_tree__options(void)
 			cl_git_pass(git_diff_tree_to_tree(g_repo, &opts, c, d, &diff));
 
 		cl_git_pass(git_diff_foreach(
-			diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
-
-		cl_assert(exp.files     == test_expects[i].files);
-		cl_assert(exp.file_adds == test_expects[i].file_adds);
-		cl_assert(exp.file_dels == test_expects[i].file_dels);
-		cl_assert(exp.file_mods == test_expects[i].file_mods);
-		cl_assert(exp.hunks     == test_expects[i].hunks);
-		cl_assert(exp.lines     == test_expects[i].lines);
-		cl_assert(exp.line_ctxt == test_expects[i].line_ctxt);
-		cl_assert(exp.line_adds == test_expects[i].line_adds);
-		cl_assert(exp.line_dels == test_expects[i].line_dels);
+			diff, &actual, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+		expected = &test_expects[i];
+		cl_assert_intequal(actual.files,     expected->files);
+		cl_assert_intequal(actual.file_adds, expected->file_adds);
+ 		cl_assert_intequal(actual.file_dels, expected->file_dels);
+		cl_assert_intequal(actual.file_mods, expected->file_mods);
+		cl_assert_intequal(actual.hunks,     expected->hunks);
+		cl_assert_intequal(actual.lines,     expected->lines);
+		cl_assert_intequal(actual.line_ctxt, expected->line_ctxt);
+		cl_assert_intequal(actual.line_adds, expected->line_adds);
+		cl_assert_intequal(actual.line_dels, expected->line_dels);
 
 		git_diff_list_free(diff);
 		diff = NULL;

tests-clar/diff/workdir.c

+#include "clar_libgit2.h"
+#include "diff_helpers.h"
+
+static git_repository *g_repo = NULL;
+
+void test_diff_workdir__initialize(void)
+{
+	cl_fixture_sandbox("status");
+	cl_git_pass(p_rename("status/.gitted", "status/.git"));
+	cl_git_pass(git_repository_open(&g_repo, "status/.git"));
+}
+
+void test_diff_workdir__cleanup(void)
+{
+	git_repository_free(g_repo);
+	g_repo = NULL;
+	cl_fixture_cleanup("status");
+}
+
+void test_diff_workdir__to_index(void)
+{
+	git_diff_options opts = {0};
+	git_diff_list *diff = NULL;
+	diff_expects exp;
+
+	opts.context_lines = 3;
+	opts.interhunk_lines = 1;
+	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
+
+	memset(&exp, 0, sizeof(exp));
+
+	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff));
+
+	cl_git_pass(git_diff_foreach(
+		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	/* to generate these values:
+	 * - cd to tests/resources/status,
+	 * - mv .gitted .git
+	 * - git diff --name-status
+	 * - git diff
+	 * - mv .git .gitted
+	 */
+	cl_assert_intequal(12, exp.files);
+	cl_assert_intequal(0, exp.file_adds);
+	cl_assert_intequal(4, exp.file_dels);
+	cl_assert_intequal(4, exp.file_mods);
+	cl_assert_intequal(1, exp.file_ignored);
+	cl_assert_intequal(3, exp.file_untracked);
+
+	cl_assert_intequal(8, exp.hunks);
+
+	cl_assert_intequal(14, exp.lines);
+	cl_assert_intequal(5, exp.line_ctxt);
+	cl_assert_intequal(4, exp.line_adds);
+	cl_assert_intequal(5, exp.line_dels);
+
+	git_diff_list_free(diff);
+}
+
+void test_diff_workdir__to_tree(void)
+{
+	/* grabbed a couple of commit oids from the history of the attr repo */
+	const char *a_commit = "26a125ee1bf"; /* the current HEAD */
+	const char *b_commit = "0017bd4ab1ec3"; /* the start */
+	git_tree *a = resolve_commit_oid_to_tree(g_repo, a_commit);
+	git_tree *b = resolve_commit_oid_to_tree(g_repo, b_commit);
+	git_diff_options opts = {0};
+	git_diff_list *diff = NULL;
+	git_diff_list *diff2 = NULL;
+	diff_expects exp;
+
+	opts.context_lines = 3;
+	opts.interhunk_lines = 1;
+	opts.flags |= GIT_DIFF_INCLUDE_IGNORED | GIT_DIFF_INCLUDE_UNTRACKED;
+
+	memset(&exp, 0, sizeof(exp));
+
+	/* You can't really generate the equivalent of git_diff_workdir_to_tree()
+	 * using C git.  It really wants to interpose the index into the diff.
+	 *
+	 * To validate the following results with command line git, I ran the
+	 * following:
+	 * - git ls-tree 26a125
+	 * - find . ! -path ./.git/\* -a -type f | git hash-object --stdin-paths
+	 * The results are documented at the bottom of this file in the
+	 * long comment entitled "PREPARATION OF TEST DATA".
+	 */
+	cl_git_pass(git_diff_workdir_to_tree(g_repo, &opts, a, &diff));
+
+	cl_git_pass(git_diff_foreach(
+		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(exp.files == 13);
+	cl_assert(exp.file_adds == 0);
+	cl_assert(exp.file_dels == 4);
+	cl_assert(exp.file_mods == 4);
+	cl_assert(exp.file_ignored == 1);
+	cl_assert(exp.file_untracked == 4);
+
+	/* Since there is no git diff equivalent, let's just assume that the
+	 * text diffs produced by git_diff_foreach are accurate here.  We will
+	 * do more apples-to-apples test comparison below.
+	 */
+
+	git_diff_list_free(diff);
+	diff = NULL;
+	memset(&exp, 0, sizeof(exp));
+
+	/* This is a compatible emulation of "git diff <sha>" which looks like
+	 * a workdir to tree diff (even though it is not really).  This is what
+	 * you would get from "git diff --name-status 26a125ee1bf"
+	 */
+	cl_git_pass(git_diff_index_to_tree(g_repo, &opts, a, &diff));
+	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff2));
+	cl_git_pass(git_diff_merge(diff, diff2));
+	git_diff_list_free(diff2);
+
+	cl_git_pass(git_diff_foreach(
+		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(exp.files == 14);
+	cl_assert(exp.file_adds == 2);
+	cl_assert(exp.file_dels == 5);
+	cl_assert(exp.file_mods == 4);
+	cl_assert(exp.file_ignored == 1);
+	cl_assert(exp.file_untracked == 2);
+
+	cl_assert(exp.hunks == 11);
+
+	cl_assert(exp.lines == 17);
+	cl_assert(exp.line_ctxt == 4);
+	cl_assert(exp.line_adds == 8);
+	cl_assert(exp.line_dels == 5);
+
+	git_diff_list_free(diff);
+	diff = NULL;
+	memset(&exp, 0, sizeof(exp));
+
+	/* Again, emulating "git diff <sha>" for testing purposes using
+	 * "git diff --name-status 0017bd4ab1ec3" instead.
+	 */
+	cl_git_pass(git_diff_index_to_tree(g_repo, &opts, b, &diff));
+	cl_git_pass(git_diff_workdir_to_index(g_repo, &opts, &diff2));
+	cl_git_pass(git_diff_merge(diff, diff2));
+	git_diff_list_free(diff2);
+
+	cl_git_pass(git_diff_foreach(
+		diff, &exp, diff_file_fn, diff_hunk_fn, diff_line_fn));
+
+	cl_assert(exp.files == 15);
+	cl_assert(exp.file_adds == 5);
+	cl_assert(exp.file_dels == 4);
+	cl_assert(exp.file_mods == 3);
+	cl_assert(exp.file_ignored == 1);
+	cl_assert(exp.file_untracked == 2);
+
+	cl_assert(exp.hunks == 12);
+
+	cl_assert(exp.lines == 19);
+	cl_assert(exp.line_ctxt == 3);
+	cl_assert(exp.line_adds == 12);
+	cl_assert(exp.line_dels == 4);
+
+	git_tree_free(a);
+	git_tree_free(b);
+}
+
+/* PREPARATION OF TEST DATA
+ *
+ * Since there is no command line equivalent of git_diff_workdir_to_tree,
+ * it was a bit of a pain to confirm that I was getting the expected
+ * results in the first part of this tests.  Here is what I ended up
+ * doing to set my expectation for the file counts and results:
+ *
+ * Running "git ls-tree 26a125" and "git ls-tree aa27a6" shows:
+ *
+ *  A a0de7e0ac200c489c41c59dfa910154a70264e6e	current_file
+ *  B 5452d32f1dd538eb0405e8a83cc185f79e25e80f	file_deleted
+ *  C 452e4244b5d083ddf0460acf1ecc74db9dcfa11a	modified_file
+ *  D 32504b727382542f9f089e24fddac5e78533e96c	staged_changes
+ *  E 061d42a44cacde5726057b67558821d95db96f19	staged_changes_file_deleted
+ *  F 70bd9443ada07063e7fbf0b3ff5c13f7494d89c2	staged_changes_modified_file
+ *  G e9b9107f290627c04d097733a10055af941f6bca	staged_delete_file_deleted
+ *  H dabc8af9bd6e9f5bbe96a176f1a24baf3d1f8916	staged_delete_modified_file
+ *  I 53ace0d1cc1145a5f4fe4f78a186a60263190733	subdir/current_file
+ *  J 1888c805345ba265b0ee9449b8877b6064592058	subdir/deleted_file
+ *  K a6191982709b746d5650e93c2acf34ef74e11504	subdir/modified_file
+ *  L e8ee89e15bbe9b20137715232387b3de5b28972e	subdir.txt
+ *
+ * --------
+ *
+ * find . ! -path ./.git/\* -a -type f | git hash-object --stdin-paths
+ *
+ *  A a0de7e0ac200c489c41c59dfa910154a70264e6e current_file
+ *  M 6a79f808a9c6bc9531ac726c184bbcd9351ccf11 ignored_file
+ *  C 0a539630525aca2e7bc84975958f92f10a64c9b6 modified_file
+ *  N d4fa8600b4f37d7516bef4816ae2c64dbf029e3a new_file
+ *  D 55d316c9ba708999f1918e9677d01dfcae69c6b9 staged_changes
+ *  F 011c3440d5c596e21d836aa6d7b10eb581f68c49 staged_changes_modified_file
+ *  H dabc8af9bd6e9f5bbe96a176f1a24baf3d1f8916 staged_delete_modified_file
+ *  O 529a16e8e762d4acb7b9636ff540a00831f9155a staged_new_file
+ *  P 8b090c06d14ffa09c4e880088ebad33893f921d1 staged_new_file_modified_file
+ *  I 53ace0d1cc1145a5f4fe4f78a186a60263190733 subdir/current_file
+ *  K 57274b75eeb5f36fd55527806d567b2240a20c57 subdir/modified_file
+ *  Q 80a86a6931b91bc01c2dbf5ca55bdd24ad1ef466 subdir/new_file
+ *  L e8ee89e15bbe9b20137715232387b3de5b28972e subdir.txt
+ *
+ * --------
+ *
+ *  A - current_file (UNMODIFIED) -> not in results
+ *  B D file_deleted
+ *  M I ignored_file (IGNORED)
+ *  C M modified_file
+ *  N U new_file (UNTRACKED)
+ *  D M staged_changes
+ *  E D staged_changes_file_deleted
+ *  F M staged_changes_modified_file
+ *  G D staged_delete_file_deleted
+ *  H - staged_delete_modified_file (UNMODIFIED) -> not in results
+ *  O U staged_new_file
+ *  P U staged_new_file_modified_file
+ *  I - subdir/current_file (UNMODIFIED) -> not in results
+ *  J D subdir/deleted_file
+ *  K M subdir/modified_file
+ *  Q U subdir/new_file
+ *  L - subdir.txt (UNMODIFIED) -> not in results
+ *
+ * Expect 13 files, 0 ADD, 4 DEL, 4 MOD, 1 IGN, 4 UNTR
+ */

tests-clar/status/status_data.h

@@ -29,7 +29,7 @@ static const char *entry_paths0[] = {
 
 static const unsigned int entry_statuses0[] = {
 	GIT_STATUS_WT_DELETED,
-	GIT_STATUS_IGNORED,
+	GIT_STATUS_WT_IGNORED,
 	GIT_STATUS_WT_MODIFIED,
 	GIT_STATUS_WT_NEW,
 	GIT_STATUS_INDEX_MODIFIED,

tests-clar/status/worktree.c

@@ -143,7 +143,7 @@ void test_status_worktree__ignores(void)
 
 	for (i = 0; i < (int)entry_count0; i++) {
 		cl_git_pass(git_status_should_ignore(_repository, entry_paths0[i], &ignored));
-		cl_assert(ignored == (entry_statuses0[i] == GIT_STATUS_IGNORED));
+		cl_assert(ignored == (entry_statuses0[i] == GIT_STATUS_WT_IGNORED));
 	}
 
 	cl_git_pass(git_status_should_ignore(_repository, "nonexistent_file", &ignored));

tests/t18-status.c

@@ -83,7 +83,7 @@ static const char *entry_paths0[] = {
 
 static const unsigned int entry_statuses0[] = {
 	GIT_STATUS_WT_DELETED,
-	GIT_STATUS_IGNORED,
+	GIT_STATUS_WT_IGNORED,
 	GIT_STATUS_WT_MODIFIED,
 	GIT_STATUS_WT_NEW,
 	GIT_STATUS_INDEX_MODIFIED,
@@ -205,7 +205,7 @@ static const char *entry_paths2[] = {
 static const unsigned int entry_statuses2[] = {
 	GIT_STATUS_WT_DELETED,
 	GIT_STATUS_WT_DELETED,
-	GIT_STATUS_IGNORED,
+	GIT_STATUS_WT_IGNORED,
 	GIT_STATUS_WT_DELETED,
 	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED,
 	GIT_STATUS_WT_DELETED | GIT_STATUS_INDEX_MODIFIED,
@@ -291,7 +291,7 @@ static const unsigned int entry_statuses3[] = {
 	GIT_STATUS_WT_NEW,
 	GIT_STATUS_WT_NEW,
 	GIT_STATUS_WT_DELETED,
-	GIT_STATUS_IGNORED,
+	GIT_STATUS_WT_IGNORED,
 	GIT_STATUS_WT_MODIFIED,
 	GIT_STATUS_WT_NEW,
 	GIT_STATUS_INDEX_MODIFIED,