rugged 1.3.1 → 1.9.0

data/vendor/libgit2/src/libgit2/grafts.c

@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "grafts.h"
+
+#include "futils.h"
+#include "oid.h"
+#include "oidarray.h"
+#include "parse.h"
+#include "hashmap_oid.h"
+
+GIT_HASHMAP_OID_SETUP(git_grafts_oidmap, git_commit_graft *);
+
+struct git_grafts {
+	/* Map of `git_commit_graft`s */
+	git_grafts_oidmap commits;
+
+	/* Type of object IDs */
+	git_oid_t oid_type;
+
+	/* File backing the graft. NULL if it's an in-memory graft */
+	char *path;
+	unsigned char path_checksum[GIT_HASH_SHA256_SIZE];
+};
+
+int git_grafts_new(git_grafts **out, git_oid_t oid_type)
+{
+	git_grafts *grafts;
+
+	GIT_ASSERT_ARG(out && oid_type);
+
+	grafts = git__calloc(1, sizeof(*grafts));
+	GIT_ERROR_CHECK_ALLOC(grafts);
+
+	grafts->oid_type = oid_type;
+
+	*out = grafts;
+	return 0;
+}
+
+int git_grafts_open(
+	git_grafts **out,
+	const char *path,
+	git_oid_t oid_type)
+{
+	git_grafts *grafts = NULL;
+	int error;
+
+	GIT_ASSERT_ARG(out && path && oid_type);
+
+	if ((error = git_grafts_new(&grafts, oid_type)) < 0)
+		goto error;
+
+	grafts->path = git__strdup(path);
+	GIT_ERROR_CHECK_ALLOC(grafts->path);
+
+	if ((error = git_grafts_refresh(grafts)) < 0)
+		goto error;
+
+	*out = grafts;
+
+error:
+	if (error < 0)
+		git_grafts_free(grafts);
+
+	return error;
+}
+
+int git_grafts_open_or_refresh(
+	git_grafts **out,
+	const char *path,
+	git_oid_t oid_type)
+{
+	GIT_ASSERT_ARG(out && path && oid_type);
+
+	return *out ? git_grafts_refresh(*out) : git_grafts_open(out, path, oid_type);
+}
+
+void git_grafts_free(git_grafts *grafts)
+{
+	if (!grafts)
+		return;
+	git__free(grafts->path);
+	git_grafts_clear(grafts);
+	git_grafts_oidmap_dispose(&grafts->commits);
+	git__free(grafts);
+}
+
+void git_grafts_clear(git_grafts *grafts)
+{
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+	git_commit_graft *graft;
+
+	if (!grafts)
+		return;
+
+	while (git_grafts_oidmap_iterate(&iter, NULL, &graft, &grafts->commits) == 0) {
+		git__free(graft->parents.ptr);
+		git__free(graft);
+	}
+
+	git_grafts_oidmap_clear(&grafts->commits);
+}
+
+int git_grafts_refresh(git_grafts *grafts)
+{
+	git_str contents = GIT_STR_INIT;
+	int error, updated = 0;
+
+	GIT_ASSERT_ARG(grafts);
+
+	if (!grafts->path)
+		return 0;
+
+	if ((error = git_futils_readbuffer_updated(&contents, grafts->path,
+				grafts->path_checksum, &updated)) < 0) {
+
+		if (error == GIT_ENOTFOUND) {
+			git_grafts_clear(grafts);
+			error = 0;
+		}
+
+		goto cleanup;
+	}
+
+	if (!updated) {
+		goto cleanup;
+	}
+
+	if ((error = git_grafts_parse(grafts, contents.ptr, contents.size)) < 0)
+		goto cleanup;
+
+cleanup:
+	git_str_dispose(&contents);
+	return error;
+}
+
+int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len)
+{
+	git_array_oid_t parents = GIT_ARRAY_INIT;
+	git_parse_ctx parser;
+	int error;
+
+	git_grafts_clear(grafts);
+
+	if ((error = git_parse_ctx_init(&parser, buf, len)) < 0)
+		goto error;
+
+	for (; parser.remain_len; git_parse_advance_line(&parser)) {
+		git_oid graft_oid;
+
+		if ((error = git_parse_advance_oid(&graft_oid, &parser, grafts->oid_type)) < 0) {
+			git_error_set(GIT_ERROR_GRAFTS, "invalid graft OID at line %" PRIuZ, parser.line_num);
+			goto error;
+		}
+
+		while (parser.line_len && git_parse_advance_expected(&parser, "\n", 1) != 0) {
+			git_oid *id = git_array_alloc(parents);
+			GIT_ERROR_CHECK_ALLOC(id);
+
+			if ((error = git_parse_advance_expected(&parser, " ", 1)) < 0 ||
+			    (error = git_parse_advance_oid(id, &parser, grafts->oid_type)) < 0) {
+				git_error_set(GIT_ERROR_GRAFTS, "invalid parent OID at line %" PRIuZ, parser.line_num);
+				goto error;
+			}
+		}
+
+		if ((error = git_grafts_add(grafts, &graft_oid, parents)) < 0)
+			goto error;
+
+		git_array_clear(parents);
+	}
+
+error:
+	git_array_clear(parents);
+	return error;
+}
+
+int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents)
+{
+	git_commit_graft *graft;
+	git_oid *parent_oid;
+	int error;
+	size_t i;
+
+	GIT_ASSERT_ARG(grafts && oid);
+
+	graft = git__calloc(1, sizeof(*graft));
+	GIT_ERROR_CHECK_ALLOC(graft);
+
+	git_array_init_to_size(graft->parents, git_array_size(parents));
+	git_array_foreach(parents, i, parent_oid) {
+		git_oid *id = git_array_alloc(graft->parents);
+		GIT_ERROR_CHECK_ALLOC(id);
+
+		git_oid_cpy(id, parent_oid);
+	}
+	git_oid_cpy(&graft->oid, oid);
+
+	if ((error = git_grafts_remove(grafts, &graft->oid)) < 0 && error != GIT_ENOTFOUND)
+		goto cleanup;
+
+	if ((error = git_grafts_oidmap_put(&grafts->commits, &graft->oid, graft)) < 0)
+		goto cleanup;
+
+	return 0;
+
+cleanup:
+	git_array_clear(graft->parents);
+	git__free(graft);
+	return error;
+}
+
+int git_grafts_remove(git_grafts *grafts, const git_oid *oid)
+{
+	git_commit_graft *graft;
+	int error;
+
+	GIT_ASSERT_ARG(grafts && oid);
+
+	if (git_grafts_oidmap_get(&graft, &grafts->commits, oid) != 0)
+		return GIT_ENOTFOUND;
+
+	if ((error = git_grafts_oidmap_remove(&grafts->commits, oid)) < 0)
+		return error;
+
+	git__free(graft->parents.ptr);
+	git__free(graft);
+
+	return 0;
+}
+
+int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid)
+{
+	GIT_ASSERT_ARG(out && grafts && oid);
+	return git_grafts_oidmap_get(out, &grafts->commits, oid);
+}
+
+int git_grafts_oids(git_oid **out, size_t *out_len, git_grafts *grafts)
+{
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+	git_array_oid_t array = GIT_ARRAY_INIT;
+	const git_oid *oid;
+	size_t existing;
+
+	GIT_ASSERT_ARG(out && grafts);
+
+	if ((existing = git_grafts_oidmap_size(&grafts->commits)) > 0)
+		git_array_init_to_size(array, existing);
+
+	while (git_grafts_oidmap_iterate(&iter, &oid, NULL, &grafts->commits) == 0) {
+		git_oid *cpy = git_array_alloc(array);
+		GIT_ERROR_CHECK_ALLOC(cpy);
+		git_oid_cpy(cpy, oid);
+	}
+
+	*out = array.ptr;
+	*out_len = array.size;
+
+	return 0;
+}
+
+size_t git_grafts_size(git_grafts *grafts)
+{
+	return git_grafts_oidmap_size(&grafts->commits);
+}

data/vendor/libgit2/src/libgit2/grafts.h

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_graft_h__
+#define INCLUDE_graft_h__
+
+#include "common.h"
+#include "oidarray.h"
+
+/** graft commit */
+typedef struct {
+	git_oid oid;
+	git_array_oid_t parents;
+} git_commit_graft;
+
+typedef struct git_grafts git_grafts;
+
+int git_grafts_new(git_grafts **out, git_oid_t oid_type);
+int git_grafts_open(git_grafts **out, const char *path, git_oid_t oid_type);
+int git_grafts_open_or_refresh(git_grafts **out, const char *path, git_oid_t oid_type);
+void git_grafts_free(git_grafts *grafts);
+void git_grafts_clear(git_grafts *grafts);
+
+int git_grafts_refresh(git_grafts *grafts);
+int git_grafts_parse(git_grafts *grafts, const char *buf, size_t len);
+int git_grafts_add(git_grafts *grafts, const git_oid *oid, git_array_oid_t parents);
+int git_grafts_remove(git_grafts *grafts, const git_oid *oid);
+int git_grafts_get(git_commit_graft **out, git_grafts *grafts, const git_oid *oid);
+int git_grafts_oids(git_oid **out, size_t *out_len, git_grafts *grafts);
+size_t git_grafts_size(git_grafts *grafts);
+
+#endif

data/vendor/libgit2/src/{graph.c → libgit2/graph.c}

@@ -243,7 +243,7 @@ int git_graph_reachable_from_any(
 
 done:
 	git_commit_list_free(&result);
-	git_vector_free(&list);
+	git_vector_dispose(&list);
 	git_revwalk_free(walk);
 	return error;
 }

data/vendor/libgit2/src/libgit2/hashmap_oid.h

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+#ifndef INCLUDE_hashmap_oid_h__
+#define INCLUDE_hashmap_oid_h__
+
+#include "hashmap.h"
+
+GIT_INLINE(uint32_t) git_hashmap_oid_hashcode(const git_oid *oid)
+{
+	uint32_t hash;
+	memcpy(&hash, oid->id, sizeof(uint32_t));
+	return hash;
+}
+
+#define GIT_HASHMAP_OID_STRUCT(name, val_t) \
+	GIT_HASHMAP_STRUCT(name, const git_oid *, val_t)
+#define GIT_HASHMAP_OID_PROTOTYPES(name, val_t) \
+	GIT_HASHMAP_PROTOTYPES(name, const git_oid *, val_t)
+#define GIT_HASHMAP_OID_FUNCTIONS(name, scope, val_t) \
+	GIT_HASHMAP_FUNCTIONS(name, scope, const git_oid *, val_t, git_hashmap_oid_hashcode, git_oid_equal)
+
+#define GIT_HASHMAP_OID_SETUP(name, val_t) \
+	GIT_HASHMAP_OID_STRUCT(name, val_t) \
+	GIT_HASHMAP_OID_FUNCTIONS(name, GIT_HASHMAP_INLINE, val_t)
+
+#endif

data/vendor/libgit2/src/{ident.c → libgit2/ident.c}

@@ -9,7 +9,7 @@
 
 #include "git2/sys/filter.h"
 #include "filter.h"
-#include "buffer.h"
+#include "str.h"
 
 static int ident_find_id(
 	const char **id_start, const char **id_end, const char *start, size_t len)
@@ -40,9 +40,9 @@ static int ident_find_id(
 }
 
 static int ident_insert_id(
-	git_buf *to, const git_buf *from, const git_filter_source *src)
+	git_str *to, const git_str *from, const git_filter_source *src)
 {
-	char oid[GIT_OID_HEXSZ+1];
+	char oid[GIT_OID_MAX_HEXSIZE + 1];
 	const char *id_start, *id_end, *from_end = from->ptr + from->size;
 	size_t need_size;
 
@@ -57,23 +57,23 @@ static int ident_insert_id(
 		return GIT_PASSTHROUGH;
 
 	need_size = (size_t)(id_start - from->ptr) +
-		5 /* "$Id: " */ + GIT_OID_HEXSZ + 2 /* " $" */ +
+		5 /* "$Id: " */ + GIT_OID_MAX_HEXSIZE + 2 /* " $" */ +
 		(size_t)(from_end - id_end);
 
-	if (git_buf_grow(to, need_size) < 0)
+	if (git_str_grow(to, need_size) < 0)
 		return -1;
 
-	git_buf_set(to, from->ptr, (size_t)(id_start - from->ptr));
-	git_buf_put(to, "$Id: ", 5);
-	git_buf_put(to, oid, GIT_OID_HEXSZ);
-	git_buf_put(to, " $", 2);
-	git_buf_put(to, id_end, (size_t)(from_end - id_end));
+	git_str_set(to, from->ptr, (size_t)(id_start - from->ptr));
+	git_str_put(to, "$Id: ", 5);
+	git_str_puts(to, oid);
+	git_str_put(to, " $", 2);
+	git_str_put(to, id_end, (size_t)(from_end - id_end));
 
-	return git_buf_oom(to) ? -1 : 0;
+	return git_str_oom(to) ? -1 : 0;
 }
 
 static int ident_remove_id(
-	git_buf *to, const git_buf *from)
+	git_str *to, const git_str *from)
 {
 	const char *id_start, *id_end, *from_end = from->ptr + from->size;
 	size_t need_size;
@@ -84,27 +84,27 @@ static int ident_remove_id(
 	need_size = (size_t)(id_start - from->ptr) +
 		4 /* "$Id$" */ + (size_t)(from_end - id_end);
 
-	if (git_buf_grow(to, need_size) < 0)
+	if (git_str_grow(to, need_size) < 0)
 		return -1;
 
-	git_buf_set(to, from->ptr, (size_t)(id_start - from->ptr));
-	git_buf_put(to, "$Id$", 4);
-	git_buf_put(to, id_end, (size_t)(from_end - id_end));
+	git_str_set(to, from->ptr, (size_t)(id_start - from->ptr));
+	git_str_put(to, "$Id$", 4);
+	git_str_put(to, id_end, (size_t)(from_end - id_end));
 
-	return git_buf_oom(to) ? -1 : 0;
+	return git_str_oom(to) ? -1 : 0;
 }
 
 static int ident_apply(
 	git_filter     *self,
 	void          **payload,
-	git_buf        *to,
-	const git_buf  *from,
+	git_str        *to,
+	const git_str  *from,
 	const git_filter_source *src)
 {
 	GIT_UNUSED(self); GIT_UNUSED(payload);
 
 	/* Don't filter binary files */
-	if (git_buf_is_binary(from))
+	if (git_str_is_binary(from))
 		return GIT_PASSTHROUGH;
 
 	if (git_filter_source_mode(src) == GIT_FILTER_SMUDGE)

data/vendor/libgit2/src/{ignore.c → libgit2/ignore.c}

@@ -10,9 +10,10 @@
 #include "git2/ignore.h"
 #include "common.h"
 #include "attrcache.h"
-#include "path.h"
+#include "fs_path.h"
 #include "config.h"
 #include "wildmatch.h"
+#include "path.h"
 
 #define GIT_IGNORE_INTERNAL		"[internal]exclude"
 
@@ -105,7 +106,7 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match
 	size_t i;
 	git_attr_fnmatch *rule;
 	char *path;
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 
 	*out = 0;
 
@@ -115,12 +116,12 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match
 
 	/* path of the file relative to the workdir, so we match the rules in subdirs */
 	if (match->containing_dir) {
-		git_buf_puts(&buf, match->containing_dir);
+		git_str_puts(&buf, match->containing_dir);
 	}
-	if (git_buf_puts(&buf, match->pattern) < 0)
+	if (git_str_puts(&buf, match->pattern) < 0)
 		return -1;
 
-	path = git_buf_detach(&buf);
+	path = git_str_detach(&buf);
 
 	git_vector_foreach(rules, i, rule) {
 		if (!(rule->flags & GIT_ATTR_FNMATCH_HASWILD)) {
@@ -133,12 +134,12 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match
 				continue;
 		}
 
-		git_buf_clear(&buf);
+		git_str_clear(&buf);
 		if (rule->containing_dir)
-			git_buf_puts(&buf, rule->containing_dir);
-		git_buf_puts(&buf, rule->pattern);
+			git_str_puts(&buf, rule->containing_dir);
+		git_str_puts(&buf, rule->pattern);
 
-		if (git_buf_oom(&buf))
+		if (git_str_oom(&buf))
 			goto out;
 
 		/*
@@ -151,7 +152,7 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match
 			effective_flags &= ~WM_PATHNAME;
 
 		/* if we found a match, we want to keep this rule */
-		if ((wildmatch(git_buf_cstr(&buf), path, effective_flags)) == WM_MATCH) {
+		if ((wildmatch(git_str_cstr(&buf), path, effective_flags)) == WM_MATCH) {
 			*out = 1;
 			error = 0;
 			goto out;
@@ -162,7 +163,7 @@ static int does_negate_rule(int *out, git_vector *rules, git_attr_fnmatch *match
 
 out:
 	git__free(path);
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 	return error;
 }
 
@@ -181,7 +182,7 @@ static int parse_ignore_file(
 
 	/* if subdir file path, convert context for file paths */
 	if (attrs->entry &&
-		git_path_root(attrs->entry->path) < 0 &&
+		git_fs_path_root(attrs->entry->path) < 0 &&
 		!git__suffixcmp(attrs->entry->path, "/" GIT_IGNORE_FILE))
 		context = attrs->entry->path;
 
@@ -295,7 +296,9 @@ int git_ignore__for_path(
 {
 	int error = 0;
 	const char *workdir = git_repository_workdir(repo);
-	git_buf infopath = GIT_BUF_INIT;
+	git_attr_cache *attrcache;
+	const char *excludes_file = NULL;
+	git_str infopath = GIT_STR_INIT;
 
 	GIT_ASSERT_ARG(repo);
 	GIT_ASSERT_ARG(ignores);
@@ -313,21 +316,21 @@ int git_ignore__for_path(
 		goto cleanup;
 
 	/* given a unrooted path in a non-bare repo, resolve it */
-	if (workdir && git_path_root(path) < 0) {
-		git_buf local = GIT_BUF_INIT;
-
-		if ((error = git_path_dirname_r(&local, path)) < 0 ||
-		    (error = git_path_resolve_relative(&local, 0)) < 0 ||
-		    (error = git_path_to_dir(&local)) < 0 ||
-		    (error = git_buf_joinpath(&ignores->dir, workdir, local.ptr)) < 0 ||
-		    (error = git_path_validate_workdir_buf(repo, &ignores->dir)) < 0) {
+	if (workdir && git_fs_path_root(path) < 0) {
+		git_str local = GIT_STR_INIT;
+
+		if ((error = git_fs_path_dirname_r(&local, path)) < 0 ||
+		    (error = git_fs_path_resolve_relative(&local, 0)) < 0 ||
+		    (error = git_fs_path_to_dir(&local)) < 0 ||
+		    (error = git_str_joinpath(&ignores->dir, workdir, local.ptr)) < 0 ||
+		    (error = git_path_validate_str_length(repo, &ignores->dir)) < 0) {
 			/* Nothing, we just want to stop on the first error */
 		}
 
-		git_buf_dispose(&local);
+		git_str_dispose(&local);
 	} else {
-		if (!(error = git_buf_joinpath(&ignores->dir, path, "")))
-		    error = git_path_validate_filesystem(ignores->dir.ptr, ignores->dir.size);
+		if (!(error = git_str_joinpath(&ignores->dir, path, "")))
+		    error = git_path_validate_str_length(NULL, &ignores->dir);
 	}
 
 	if (error < 0)
@@ -342,14 +345,14 @@ int git_ignore__for_path(
 
 	/* load .gitignore up the path */
 	if (workdir != NULL) {
-		error = git_path_walk_up(
+		error = git_fs_path_walk_up(
 			&ignores->dir, workdir, push_one_ignore, ignores);
 		if (error < 0)
 			goto cleanup;
 	}
 
 	/* load .git/info/exclude if possible */
-	if ((error = git_repository_item_path(&infopath, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
+	if ((error = git_repository__item_path(&infopath, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
 		(error = push_ignore_file(ignores, &ignores->ign_global, infopath.ptr, GIT_IGNORE_FILE_INREPO)) < 0) {
 		if (error != GIT_ENOTFOUND)
 			goto cleanup;
@@ -357,13 +360,15 @@ int git_ignore__for_path(
 	}
 
 	/* load core.excludesfile */
-	if (git_repository_attr_cache(repo)->cfg_excl_file != NULL)
+	attrcache = git_repository_attr_cache(repo);
+	excludes_file = git_attr_cache_excludesfile(attrcache);
+
+	if (excludes_file != NULL)
 		error = push_ignore_file(
-			ignores, &ignores->ign_global, NULL,
-			git_repository_attr_cache(repo)->cfg_excl_file);
+			ignores, &ignores->ign_global, NULL, excludes_file);
 
 cleanup:
-	git_buf_dispose(&infopath);
+	git_str_dispose(&infopath);
 	if (error < 0)
 		git_ignore__free(ignores);
 
@@ -372,7 +377,7 @@ cleanup:
 
 int git_ignore__push_dir(git_ignores *ign, const char *dir)
 {
-	if (git_buf_joinpath(&ign->dir, ign->dir.ptr, dir) < 0)
+	if (git_str_joinpath(&ign->dir, ign->dir.ptr, dir) < 0)
 		return -1;
 
 	ign->depth++;
@@ -409,8 +414,8 @@ int git_ignore__pop_dir(git_ignores *ign)
 	}
 
 	if (--ign->depth > 0) {
-		git_buf_rtruncate_at_char(&ign->dir, '/');
-		git_path_to_dir(&ign->dir);
+		git_str_rtruncate_at_char(&ign->dir, '/');
+		git_fs_path_to_dir(&ign->dir);
 	}
 
 	return 0;
@@ -427,15 +432,15 @@ void git_ignore__free(git_ignores *ignores)
 		git_attr_file__free(file);
 		ignores->ign_path.contents[i] = NULL;
 	}
-	git_vector_free(&ignores->ign_path);
+	git_vector_dispose(&ignores->ign_path);
 
 	git_vector_foreach(&ignores->ign_global, i, file) {
 		git_attr_file__free(file);
 		ignores->ign_global.contents[i] = NULL;
 	}
-	git_vector_free(&ignores->ign_global);
+	git_vector_dispose(&ignores->ign_global);
 
-	git_buf_dispose(&ignores->dir);
+	git_str_dispose(&ignores->dir);
 }
 
 static bool ignore_lookup_in_rules(
@@ -604,7 +609,7 @@ int git_ignore__check_pathspec_for_exact_ignores(
 	size_t i;
 	git_attr_fnmatch *match;
 	int ignored;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	const char *filename;
 	git_index *idx;
 
@@ -629,7 +634,7 @@ int git_ignore__check_pathspec_for_exact_ignores(
 			break;
 
 		/* is there a file on disk that matches this exactly? */
-		if (!git_path_isfile(path.ptr))
+		if (!git_fs_path_isfile(path.ptr))
 			continue;
 
 		/* is that file ignored? */
@@ -645,7 +650,7 @@ int git_ignore__check_pathspec_for_exact_ignores(
 	}
 
 	git_index_free(idx);
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	return error;
 }

data/vendor/libgit2/src/{ignore.h → libgit2/ignore.h}

@@ -26,7 +26,7 @@
  */
 typedef struct {
 	git_repository *repo;
-	git_buf dir; /* current directory reflected in ign_path */
+	git_str dir; /* current directory reflected in ign_path */
 	git_attr_file *ign_internal;
 	git_vector ign_path;
 	git_vector ign_global;
@@ -48,7 +48,7 @@ enum {
 	GIT_IGNORE_UNCHECKED = -2,
 	GIT_IGNORE_NOTFOUND = -1,
 	GIT_IGNORE_FALSE = 0,
-	GIT_IGNORE_TRUE = 1,
+	GIT_IGNORE_TRUE = 1
 };
 
 extern int git_ignore__lookup(int *out, git_ignores *ign, const char *path, git_dir_flag dir_flag);