rugged 0.17.0.b7 → 0.18.0.b1

data/vendor/libgit2/src/tree-cache.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -104,7 +104,7 @@ static int read_tree_internal(git_tree_cache **out,
 	tree->name[name_len] = '\0';
 
 	/* Blank-terminated ASCII decimal number of entries in this tree */
-	if (git__strtol32(&count, buffer, &buffer, 10) < 0 || count < -1)
+	if (git__strtol32(&count, buffer, &buffer, 10) < 0)
 		goto corrupted;
 
 	tree->entries = count;

data/vendor/libgit2/src/tree-cache.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.

data/vendor/libgit2/src/tree.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -18,25 +18,65 @@ static bool valid_filemode(const int filemode)
 {
 	return (filemode == GIT_FILEMODE_TREE
 		|| filemode == GIT_FILEMODE_BLOB
-		|| filemode == GIT_FILEMODE_BLOB_GROUP_WRITABLE
 		|| filemode == GIT_FILEMODE_BLOB_EXECUTABLE
 		|| filemode == GIT_FILEMODE_LINK
 		|| filemode == GIT_FILEMODE_COMMIT);
 }
 
+GIT_INLINE(git_filemode_t) normalize_filemode(git_filemode_t filemode)
+{
+	/* Tree bits set, but it's not a commit */
+	if (filemode & GIT_FILEMODE_TREE && !(filemode & 0100000))
+		return GIT_FILEMODE_TREE;
+
+	/* If any of the x bits is set */
+	if (filemode & 0111)
+		return GIT_FILEMODE_BLOB_EXECUTABLE;
+
+	/* 16XXXX means commit */
+	if ((filemode & GIT_FILEMODE_COMMIT) == GIT_FILEMODE_COMMIT)
+		return GIT_FILEMODE_COMMIT;
+
+	/* 12XXXX means commit */
+	if ((filemode & GIT_FILEMODE_LINK) == GIT_FILEMODE_LINK)
+		return GIT_FILEMODE_LINK;
+
+	/* Otherwise, return a blob */
+	return GIT_FILEMODE_BLOB;
+}
+
 static int valid_entry_name(const char *filename)
 {
-	return *filename != '\0' && strchr(filename, '/') == NULL;
+	return *filename != '\0' &&
+		strchr(filename, '/') == NULL &&
+		(*filename != '.' ||
+		 (strcmp(filename, ".") != 0 &&
+		  strcmp(filename, "..") != 0 &&
+		  strcmp(filename, DOT_GIT) != 0));
 }
 
 static int entry_sort_cmp(const void *a, const void *b)
 {
-	const git_tree_entry *entry_a = (const git_tree_entry *)(a);
-	const git_tree_entry *entry_b = (const git_tree_entry *)(b);
+	const git_tree_entry *e1 = (const git_tree_entry *)a;
+	const git_tree_entry *e2 = (const git_tree_entry *)b;
 
 	return git_path_cmp(
-		entry_a->filename, entry_a->filename_len, git_tree_entry__is_tree(entry_a),
-		entry_b->filename, entry_b->filename_len, git_tree_entry__is_tree(entry_b));
+		e1->filename, e1->filename_len, git_tree_entry__is_tree(e1),
+		e2->filename, e2->filename_len, git_tree_entry__is_tree(e2),
+		git__strncmp);
+}
+
+int git_tree_entry_cmp(const git_tree_entry *e1, const git_tree_entry *e2)
+{
+	return entry_sort_cmp(e1, e2);
+}
+
+int git_tree_entry_icmp(const git_tree_entry *e1, const git_tree_entry *e2)
+{
+	return git_path_cmp(
+		e1->filename, e1->filename_len, git_tree_entry__is_tree(e1),
+		e2->filename, e2->filename_len, git_tree_entry__is_tree(e2),
+		git__strncasecmp);
 }
 
 static git_tree_entry *alloc_entry(const char *filename)
@@ -96,46 +136,57 @@ static int homing_search_cmp(const void *key, const void *array_member)
  * ambiguous because of folder vs file sorting, we look linearly
  * around the area for our target file.
  */
-static int tree_key_search(git_vector *entries, const char *filename, size_t filename_len)
+static int tree_key_search(
+	size_t *at_pos, git_vector *entries, const char *filename, size_t filename_len)
 {
 	struct tree_key_search ksearch;
 	const git_tree_entry *entry;
-
-	int homing, i;
+	size_t homing, i;
 
 	ksearch.filename = filename;
 	ksearch.filename_len = filename_len;
 
 	/* Initial homing search; find an entry on the tree with
 	 * the same prefix as the filename we're looking for */
-	homing = git_vector_bsearch2(entries, &homing_search_cmp, &ksearch);
-	if (homing < 0)
-		return homing;
+	if (git_vector_bsearch2(&homing, entries, &homing_search_cmp, &ksearch) < 0)
+		return GIT_ENOTFOUND;
 
 	/* We found a common prefix. Look forward as long as
 	 * there are entries that share the common prefix */
-	for (i = homing; i < (int)entries->length; ++i) {
+	for (i = homing; i < entries->length; ++i) {
 		entry = entries->contents[i];
 
 		if (homing_search_cmp(&ksearch, entry) < 0)
 			break;
 
 		if (entry->filename_len == filename_len &&
-			memcmp(filename, entry->filename, filename_len) == 0)
-			return i;
+			memcmp(filename, entry->filename, filename_len) == 0) {
+			if (at_pos)
+				*at_pos = i;
+
+			return 0;
+		}
 	}
 
 	/* If we haven't found our filename yet, look backwards
 	 * too as long as we have entries with the same prefix */
-	for (i = homing - 1; i >= 0; --i) {
-		entry = entries->contents[i];
+	if (homing > 0) {
+		i = homing - 1;
 
-		if (homing_search_cmp(&ksearch, entry) > 0)
-			break;
+		do {
+			entry = entries->contents[i];
 
-		if (entry->filename_len == filename_len &&
-			memcmp(filename, entry->filename, filename_len) == 0)
-			return i;
+			if (homing_search_cmp(&ksearch, entry) > 0)
+				break;
+
+			if (entry->filename_len == filename_len &&
+				memcmp(filename, entry->filename, filename_len) == 0) {
+				if (at_pos)
+					*at_pos = i;
+
+				return 0;
+			}
+		} while (i-- > 0);
 	}
 
 	/* The filename doesn't exist at all */
@@ -164,25 +215,30 @@ git_tree_entry *git_tree_entry_dup(const git_tree_entry *entry)
 		return NULL;
 
 	memcpy(copy, entry, total_size);
+
 	return copy;
 }
 
 void git_tree__free(git_tree *tree)
 {
-	unsigned int i;
+	size_t i;
+	git_tree_entry *e;
 
-	for (i = 0; i < tree->entries.length; ++i) {
-		git_tree_entry *e = git_vector_get(&tree->entries, i);
+	git_vector_foreach(&tree->entries, i, e)
 		git_tree_entry_free(e);
-	}
 
 	git_vector_free(&tree->entries);
 	git__free(tree);
 }
 
-const git_oid *git_tree_id(const git_tree *c)
+const git_oid *git_tree_id(const git_tree *t)
 {
-	return git_object_id((const git_object *)c);
+	return git_object_id((const git_object *)t);
+}
+
+git_repository *git_tree_owner(const git_tree *t)
+{
+	return git_object_owner((const git_object *)t);
 }
 
 git_filemode_t git_tree_entry_filemode(const git_tree_entry *entry)
@@ -223,31 +279,36 @@ int git_tree_entry_to_object(
 	return git_object_lookup(object_out, repo, &entry->oid, GIT_OBJ_ANY);
 }
 
-static git_tree_entry *entry_fromname(git_tree *tree, const char *name, size_t name_len)
+static const git_tree_entry *entry_fromname(
+	git_tree *tree, const char *name, size_t name_len)
 {
-	int idx = tree_key_search(&tree->entries, name, name_len);
-	if (idx < 0)
+	size_t idx;
+
+	if (tree_key_search(&idx, &tree->entries, name, name_len) < 0)
 		return NULL;
 
 	return git_vector_get(&tree->entries, idx);
 }
 
-const git_tree_entry *git_tree_entry_byname(git_tree *tree, const char *filename)
+const git_tree_entry *git_tree_entry_byname(
+	git_tree *tree, const char *filename)
 {
 	assert(tree && filename);
 	return entry_fromname(tree, filename, strlen(filename));
 }
 
-const git_tree_entry *git_tree_entry_byindex(git_tree *tree, size_t idx)
+const git_tree_entry *git_tree_entry_byindex(
+	git_tree *tree, size_t idx)
 {
 	assert(tree);
 	return git_vector_get(&tree->entries, idx);
 }
 
-const git_tree_entry *git_tree_entry_byoid(git_tree *tree, const git_oid *oid)
+const git_tree_entry *git_tree_entry_byoid(
+	const git_tree *tree, const git_oid *oid)
 {
-	unsigned int i;
-	git_tree_entry *e;
+	size_t i;
+	const git_tree_entry *e;
 
 	assert(tree);
 
@@ -263,13 +324,16 @@ int git_tree__prefix_position(git_tree *tree, const char *path)
 {
 	git_vector *entries = &tree->entries;
 	struct tree_key_search ksearch;
-	unsigned int at_pos;
+	size_t at_pos;
+
+	if (!path)
+		return 0;
 
 	ksearch.filename = path;
 	ksearch.filename_len = strlen(path);
 
 	/* Find tree entry with appropriate prefix */
-	git_vector_bsearch3(&at_pos, entries, &homing_search_cmp, &ksearch);
+	git_vector_bsearch2(&at_pos, entries, &homing_search_cmp, &ksearch);
 
 	for (; at_pos < entries->length; ++at_pos) {
 		const git_tree_entry *entry = entries->contents[at_pos];
@@ -283,18 +347,27 @@ int git_tree__prefix_position(git_tree *tree, const char *path)
 			break;
 	}
 
-	return at_pos;
+	return (int)at_pos;
 }
 
-unsigned int git_tree_entrycount(const git_tree *tree)
+size_t git_tree_entrycount(const git_tree *tree)
 {
 	assert(tree);
-	return (unsigned int)tree->entries.length;
+	return tree->entries.length;
 }
 
-static int tree_error(const char *str)
+unsigned int git_treebuilder_entrycount(git_treebuilder *bld)
 {
-	giterr_set(GITERR_TREE, "%s", str);
+	assert(bld);
+	return (unsigned int)bld->entrycount;
+}
+
+static int tree_error(const char *str, const char *path)
+{
+	if (path)
+		giterr_set(GITERR_TREE, "%s - %s", str, path);
+	else
+		giterr_set(GITERR_TREE, "%s", str);
 	return -1;
 }
 
@@ -307,23 +380,26 @@ static int tree_parse_buffer(git_tree *tree, const char *buffer, const char *buf
 		git_tree_entry *entry;
 		int attr;
 
-		if (git__strtol32(&attr, buffer, &buffer, 8) < 0 ||
-			!buffer || !valid_filemode(attr))
-			return tree_error("Failed to parse tree. Can't parse filemode");
+		if (git__strtol32(&attr, buffer, &buffer, 8) < 0 || !buffer)
+			return tree_error("Failed to parse tree. Can't parse filemode", NULL);
+
+		attr = normalize_filemode(attr); /* make sure to normalize the filemode */
 
 		if (*buffer++ != ' ')
-			return tree_error("Failed to parse tree. Object is corrupted");
+			return tree_error("Failed to parse tree. Object is corrupted", NULL);
 
 		if (memchr(buffer, 0, buffer_end - buffer) == NULL)
-			return tree_error("Failed to parse tree. Object is corrupted");
+			return tree_error("Failed to parse tree. Object is corrupted", NULL);
 
 		/** Allocate the entry and store it in the entries vector */
 		{
 			entry = alloc_entry(buffer);
 			GITERR_CHECK_ALLOC(entry);
 
-			if (git_vector_insert(&tree->entries, entry) < 0)
+			if (git_vector_insert(&tree->entries, entry) < 0) {
+				git__free(entry);
 				return -1;
+			}
 
 			entry->attr = attr;
 		}
@@ -346,14 +422,13 @@ int git_tree__parse(git_tree *tree, git_odb_object *obj)
 	return tree_parse_buffer(tree, (char *)obj->raw.data, (char *)obj->raw.data + obj->raw.len);
 }
 
-static unsigned int find_next_dir(const char *dirname, git_index *index, unsigned int start)
+static size_t find_next_dir(const char *dirname, git_index *index, size_t start)
 {
-	unsigned int i, entries = git_index_entrycount(index);
-	size_t dirlen;
+	size_t dirlen, i, entries = git_index_entrycount(index);
 
 	dirlen = strlen(dirname);
 	for (i = start; i < entries; ++i) {
-		git_index_entry *entry = git_index_get(index, i);
+		const git_index_entry *entry = git_index_get_byindex(index, i);
 		if (strlen(entry->path) < dirlen ||
 		    memcmp(entry->path, dirname, dirlen) ||
 			(dirlen > 0 && entry->path[dirlen] != '/')) {
@@ -372,15 +447,21 @@ static int append_entry(
 {
 	git_tree_entry *entry;
 
+	if (!valid_entry_name(filename))
+		return tree_error("Failed to insert entry. Invalid name for a tree entry", filename);
+
 	entry = alloc_entry(filename);
 	GITERR_CHECK_ALLOC(entry);
 
 	git_oid_cpy(&entry->oid, id);
 	entry->attr = (uint16_t)filemode;
 
-	if (git_vector_insert(&bld->entries, entry) < 0)
+	if (git_vector_insert(&bld->entries, entry) < 0) {
+		git__free(entry);
 		return -1;
+	}
 
+	bld->entrycount++;
 	return 0;
 }
 
@@ -389,11 +470,10 @@ static int write_tree(
 	git_repository *repo,
 	git_index *index,
 	const char *dirname,
-	unsigned int start)
+	size_t start)
 {
 	git_treebuilder *bld = NULL;
-
-	unsigned int i, entries = git_index_entrycount(index);
+	size_t i, entries = git_index_entrycount(index);
 	int error;
 	size_t dirname_len = strlen(dirname);
 	const git_tree_cache *cache;
@@ -401,13 +481,11 @@ static int write_tree(
 	cache = git_tree_cache_get(index->tree, dirname);
 	if (cache != NULL && cache->entries >= 0){
 		git_oid_cpy(oid, &cache->oid);
-		return find_next_dir(dirname, index, start);
+		return (int)find_next_dir(dirname, index, start);
 	}
 
-	error = git_treebuilder_create(&bld, NULL);
-	if (bld == NULL) {
+	if ((error = git_treebuilder_create(&bld, NULL)) < 0 || bld == NULL)
 		return -1;
-	}
 
 	/*
 	 * This loop is unfortunate, but necessary. The index doesn't have
@@ -415,8 +493,8 @@ static int write_tree(
 	 * need to keep track of the current position.
 	 */
 	for (i = start; i < entries; ++i) {
-		git_index_entry *entry = git_index_get(index, i);
-		char *filename, *next_slash;
+		const git_index_entry *entry = git_index_get_byindex(index, i);
+		const char *filename, *next_slash;
 
 	/*
 	 * If we've left our (sub)tree, exit the loop and return. The
@@ -447,7 +525,8 @@ static int write_tree(
 			/* Write out the subtree */
 			written = write_tree(&sub_oid, repo, index, subdir, i);
 			if (written < 0) {
-				tree_error("Failed to write subtree");
+				tree_error("Failed to write subtree", subdir);
+				git__free(subdir);
 				goto on_error;
 			} else {
 				i = written - 1; /* -1 because of the loop increment */
@@ -465,18 +544,15 @@ static int write_tree(
 			} else {
 				last_comp = subdir;
 			}
+
 			error = append_entry(bld, last_comp, &sub_oid, S_IFDIR);
 			git__free(subdir);
-			if (error < 0) {
-				tree_error("Failed to insert dir");
+			if (error < 0)
 				goto on_error;
-			}
 		} else {
 			error = append_entry(bld, filename, &entry->oid, entry->mode);
-			if (error < 0) {
-				tree_error("Failed to insert file");
+			if (error < 0)
 				goto on_error;
-			}
 		}
 	}
 
@@ -484,50 +560,48 @@ static int write_tree(
 		goto on_error;
 
 	git_treebuilder_free(bld);
-	return i;
+	return (int)i;
 
 on_error:
 	git_treebuilder_free(bld);
 	return -1;
 }
 
-int git_tree_create_fromindex(git_oid *oid, git_index *index)
+int git_tree__write_index(
+	git_oid *oid, git_index *index, git_repository *repo)
 {
 	int ret;
-	git_repository *repo;
+	bool old_ignore_case = false;
 
-	repo = (git_repository *)GIT_REFCOUNT_OWNER(index);
+	assert(oid && index && repo);
 
-	if (repo == NULL)
-		return tree_error("Failed to create tree. "
-		  "The index file is not backed up by an existing repository");
+	if (git_index_has_conflicts(index)) {
+		giterr_set(GITERR_INDEX,
+			"Cannot create a tree from a not fully merged index.");
+		return GIT_EUNMERGED;
+	}
 
 	if (index->tree != NULL && index->tree->entries >= 0) {
 		git_oid_cpy(oid, &index->tree->oid);
 		return 0;
 	}
 
-	/* The tree cache didn't help us */
-	ret = write_tree(oid, repo, index, "", 0);
-	return ret < 0 ? ret : 0;
-}
+	/* The tree cache didn't help us; we'll have to write
+	 * out a tree. If the index is ignore_case, we must
+	 * make it case-sensitive for the duration of the tree-write
+	 * operation. */
 
-static void sort_entries(git_treebuilder *bld)
-{
-	git_vector_sort(&bld->entries);
-}
+	if (index->ignore_case) {
+		old_ignore_case = true;
+		git_index__set_ignore_case(index, false);
+	}
 
-GIT_INLINE(git_filemode_t) normalize_filemode(git_filemode_t filemode)
-{
-	/* 100664 mode is an early design mistake. Tree entries may bear
-	 * this mode in some old git repositories, but it's now deprecated.
-	 * We silently normalize while inserting new entries in a tree 
-	 * being built.
-	 */
-	if (filemode == GIT_FILEMODE_BLOB_GROUP_WRITABLE)
-		return GIT_FILEMODE_BLOB;
+	ret = write_tree(oid, repo, index, "", 0);
 
-	return filemode;
+	if (old_ignore_case)
+		git_index__set_ignore_case(index, true);
+
+	return ret < 0 ? ret : 0;
 }
 
 int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source)
@@ -547,13 +621,13 @@ int git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source)
 		goto on_error;
 
 	if (source != NULL) {
-		for (i = 0; i < source->entries.length; ++i) {
-			git_tree_entry *entry_src = source->entries.contents[i];
+		git_tree_entry *entry_src;
 
+		git_vector_foreach(&source->entries, i, entry_src) {
 			if (append_entry(
 				bld, entry_src->filename,
 				&entry_src->oid,
-				normalize_filemode((git_filemode_t)entry_src->attr)) < 0)
+				entry_src->attr) < 0)
 				goto on_error;
 		}
 	}
@@ -574,53 +648,51 @@ int git_treebuilder_insert(
 	git_filemode_t filemode)
 {
 	git_tree_entry *entry;
-	int pos;
+	size_t pos;
 
 	assert(bld && id && filename);
 
 	if (!valid_filemode(filemode))
-		return tree_error("Failed to insert entry. Invalid filemode");
-
-	filemode = normalize_filemode(filemode);
+		return tree_error("Failed to insert entry. Invalid filemode for file", filename);
 
 	if (!valid_entry_name(filename))
-		return tree_error("Failed to insert entry. Invalid name for a tree entry");
-
-	pos = tree_key_search(&bld->entries, filename, strlen(filename));
+		return tree_error("Failed to insert entry. Invalid name for a tree entry", filename);
 
-	if (pos >= 0) {
+	if (!tree_key_search(&pos, &bld->entries, filename, strlen(filename))) {
 		entry = git_vector_get(&bld->entries, pos);
-		if (entry->removed)
+		if (entry->removed) {
 			entry->removed = 0;
+			bld->entrycount++;
+		}
 	} else {
 		entry = alloc_entry(filename);
 		GITERR_CHECK_ALLOC(entry);
+
+		if (git_vector_insert(&bld->entries, entry) < 0) {
+			git__free(entry);
+			return -1;
+		}
+
+		bld->entrycount++;
 	}
 
 	git_oid_cpy(&entry->oid, id);
 	entry->attr = filemode;
 
-	if (pos < 0) {
-		if (git_vector_insert(&bld->entries, entry) < 0)
-			return -1;
-	}
-
-	if (entry_out != NULL) {
+	if (entry_out)
 		*entry_out = entry;
-	}
 
 	return 0;
 }
 
 static git_tree_entry *treebuilder_get(git_treebuilder *bld, const char *filename)
 {
-	int idx;
+	size_t idx;
 	git_tree_entry *entry;
 
 	assert(bld && filename);
 
-	idx = tree_key_search(&bld->entries, filename, strlen(filename));
-	if (idx < 0)
+	if (tree_key_search(&idx, &bld->entries, filename, strlen(filename)) < 0)
 		return NULL;
 
 	entry = git_vector_get(&bld->entries, idx);
@@ -640,27 +712,29 @@ int git_treebuilder_remove(git_treebuilder *bld, const char *filename)
 	git_tree_entry *remove_ptr = treebuilder_get(bld, filename);
 
 	if (remove_ptr == NULL || remove_ptr->removed)
-		return tree_error("Failed to remove entry. File isn't in the tree");
+		return tree_error("Failed to remove entry. File isn't in the tree", filename);
 
 	remove_ptr->removed = 1;
+	bld->entrycount--;
 	return 0;
 }
 
 int git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *bld)
 {
-	unsigned int i;
+	int error = 0;
+	size_t i;
 	git_buf tree = GIT_BUF_INIT;
 	git_odb *odb;
 
 	assert(bld);
 
-	sort_entries(bld);
+	git_vector_sort(&bld->entries);
 
 	/* Grow the buffer beforehand to an estimated size */
-	git_buf_grow(&tree, bld->entries.length * 72);
+	error = git_buf_grow(&tree, bld->entries.length * 72);
 
-	for (i = 0; i < bld->entries.length; ++i) {
-		git_tree_entry *entry = bld->entries.contents[i];
+	for (i = 0; i < bld->entries.length && !error; ++i) {
+		git_tree_entry *entry = git_vector_get(&bld->entries, i);
 
 		if (entry->removed)
 			continue;
@@ -668,50 +742,49 @@ int git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *b
 		git_buf_printf(&tree, "%o ", entry->attr);
 		git_buf_put(&tree, entry->filename, entry->filename_len + 1);
 		git_buf_put(&tree, (char *)entry->oid.id, GIT_OID_RAWSZ);
-	}
-
-	if (git_buf_oom(&tree))
-		goto on_error;
 
-	if (git_repository_odb__weakptr(&odb, repo) < 0)
-		goto on_error;
-
-
-	if (git_odb_write(oid, odb, tree.ptr, tree.size, GIT_OBJ_TREE) < 0)
-		goto on_error;
+		if (git_buf_oom(&tree))
+			error = -1;
+	}
 
-	git_buf_free(&tree);
-	return 0;
+	if (!error &&
+		!(error = git_repository_odb__weakptr(&odb, repo)))
+		error = git_odb_write(oid, odb, tree.ptr, tree.size, GIT_OBJ_TREE);
 
-on_error:
 	git_buf_free(&tree);
-	return -1;
+	return error;
 }
 
-void git_treebuilder_filter(git_treebuilder *bld, int (*filter)(const git_tree_entry *, void *), void *payload)
+void git_treebuilder_filter(
+	git_treebuilder *bld,
+	git_treebuilder_filter_cb filter,
+	void *payload)
 {
-	unsigned int i;
+	size_t i;
+	git_tree_entry *entry;
 
 	assert(bld && filter);
 
-	for (i = 0; i < bld->entries.length; ++i) {
-		git_tree_entry *entry = bld->entries.contents[i];
-		if (!entry->removed && filter(entry, payload))
+	git_vector_foreach(&bld->entries, i, entry) {
+		if (!entry->removed && filter(entry, payload)) {
 			entry->removed = 1;
+			bld->entrycount--;
+		}
 	}
 }
 
 void git_treebuilder_clear(git_treebuilder *bld)
 {
-	unsigned int i;
+	size_t i;
+	git_tree_entry *e;
+
 	assert(bld);
 
-	for (i = 0; i < bld->entries.length; ++i) {
-		git_tree_entry *e = bld->entries.contents[i];
+	git_vector_foreach(&bld->entries, i, e)
 		git_tree_entry_free(e);
-	}
 
 	git_vector_clear(&bld->entries);
+	bld->entrycount = 0;
 }
 
 void git_treebuilder_free(git_treebuilder *bld)
@@ -797,24 +870,25 @@ int git_tree_entry_bypath(
 }
 
 static int tree_walk(
-	git_tree *tree,
+	const git_tree *tree,
 	git_treewalk_cb callback,
 	git_buf *path,
 	void *payload,
 	bool preorder)
 {
 	int error = 0;
-	unsigned int i;
-
-	for (i = 0; i < tree->entries.length; ++i) {
-		git_tree_entry *entry = tree->entries.contents[i];
+	size_t i;
+	const git_tree_entry *entry;
 
+	git_vector_foreach(&tree->entries, i, entry) {
 		if (preorder) {
 			error = callback(path->ptr, entry, payload);
 			if (error > 0)
 				continue;
-			if (error < 0)
+			if (error < 0) {
+				giterr_clear();
 				return GIT_EUSER;
+			}
 		}
 
 		if (git_tree_entry__is_tree(entry)) {
@@ -841,6 +915,7 @@ static int tree_walk(
 		}
 
 		if (!preorder && callback(path->ptr, entry, payload) < 0) {
+			giterr_clear();
 			error = GIT_EUSER;
 			break;
 		}
@@ -849,25 +924,23 @@ static int tree_walk(
 	return error;
 }
 
-int git_tree_walk(git_tree *tree, git_treewalk_cb callback, int mode, void *payload)
+int git_tree_walk(
+	const git_tree *tree,
+	git_treewalk_mode mode,
+	git_treewalk_cb callback,
+	void *payload)
 {
 	int error = 0;
 	git_buf root_path = GIT_BUF_INIT;
 
-	switch (mode) {
-		case GIT_TREEWALK_POST:
-			error = tree_walk(tree, callback, &root_path, payload, false);
-			break;
-
-		case GIT_TREEWALK_PRE:
-			error = tree_walk(tree, callback, &root_path, payload, true);
-			break;
-
-		default:
-			giterr_set(GITERR_INVALID, "Invalid walking mode for tree walk");
-			return -1;
+	if (mode != GIT_TREEWALK_POST && mode != GIT_TREEWALK_PRE) {
+		giterr_set(GITERR_INVALID, "Invalid walking mode for tree walk");
+		return -1;
 	}
 
+	error = tree_walk(
+		tree, callback, &root_path, payload, (mode == GIT_TREEWALK_PRE));
+
 	git_buf_free(&root_path);
 
 	return error;