rugged 1.3.2.3 → 1.4.2

data/vendor/libgit2/src/hash/sha1/generic.c

@@ -278,7 +278,7 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
+int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 {
 	static const unsigned char pad[64] = { 0x80 };
 	unsigned int padlen[2];
@@ -294,7 +294,7 @@ int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
 
 	/* Output hash */
 	for (i = 0; i < 5; i++)
-		put_be32(out->id + i*4, ctx->H[i]);
+		put_be32(out + i*4, ctx->H[i]);
 
 	return 0;
 }

data/vendor/libgit2/src/hash/sha1/mbedtls.c

@@ -38,9 +38,9 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
+int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 {
 	GIT_ASSERT_ARG(ctx);
-	mbedtls_sha1_finish(&ctx->c, out->id);
+	mbedtls_sha1_finish(&ctx->c, out);
 	return 0;
 }

data/vendor/libgit2/src/hash/sha1/openssl.c

@@ -46,11 +46,11 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 	return 0;
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
+int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 {
 	GIT_ASSERT_ARG(ctx);
 
-	if (SHA1_Final(out->id, &ctx->c) != 1) {
+	if (SHA1_Final(out, &ctx->c) != 1) {
 		git_error_set(GIT_ERROR_SHA1, "hash_openssl: failed to finalize hash");
 		return -1;
 	}

data/vendor/libgit2/src/hash/sha1/sha1dc/sha1.c

@@ -70,7 +70,7 @@
 /* Not under GCC-alike or glibc */
 #elif defined(_BYTE_ORDER) && defined(_BIG_ENDIAN) && defined(_LITTLE_ENDIAN)
 /*
- * *BSD and newlib (embeded linux, cygwin, etc).
+ * *BSD and newlib (embedded linux, cygwin, etc).
  * the defined(_BIG_ENDIAN) && defined(_LITTLE_ENDIAN) part prevents
  * this condition from matching with Solaris/sparc.
  * (Solaris defines only one endian macro)

data/vendor/libgit2/src/hash/sha1/win32.c

@@ -181,14 +181,14 @@ GIT_INLINE(int) hash_cryptoapi_update(git_hash_sha1_ctx *ctx, const void *_data,
 	return 0;
 }
 
-GIT_INLINE(int) hash_cryptoapi_final(git_oid *out, git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) hash_cryptoapi_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 {
-	DWORD len = 20;
+	DWORD len = GIT_HASH_SHA1_SIZE;
 	int error = 0;
 
 	GIT_ASSERT(ctx->ctx.cryptoapi.valid);
 
-	if (!CryptGetHashParam(ctx->ctx.cryptoapi.hash_handle, HP_HASHVAL, out->id, &len, 0)) {
+	if (!CryptGetHashParam(ctx->ctx.cryptoapi.hash_handle, HP_HASHVAL, out, &len, 0)) {
 		git_error_set(GIT_ERROR_OS, "legacy hash data could not be finished");
 		error = -1;
 	}
@@ -262,9 +262,9 @@ GIT_INLINE(int) hash_cng_update(git_hash_sha1_ctx *ctx, const void *_data, size_
 	return 0;
 }
 
-GIT_INLINE(int) hash_cng_final(git_oid *out, git_hash_sha1_ctx *ctx)
+GIT_INLINE(int) hash_cng_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 {
-	if (ctx->prov->prov.cng.finish_hash(ctx->ctx.cng.hash_handle, out->id, GIT_OID_RAWSZ, 0) < 0) {
+	if (ctx->prov->prov.cng.finish_hash(ctx->ctx.cng.hash_handle, out, GIT_HASH_SHA1_SIZE, 0) < 0) {
 		git_error_set(GIT_ERROR_OS, "hash could not be finished");
 		return -1;
 	}
@@ -315,7 +315,7 @@ int git_hash_sha1_update(git_hash_sha1_ctx *ctx, const void *data, size_t len)
 	return (ctx->type == CNG) ? hash_cng_update(ctx, data, len) : hash_cryptoapi_update(ctx, data, len);
 }
 
-int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *ctx)
+int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *ctx)
 {
 	GIT_ASSERT_ARG(ctx);
 	GIT_ASSERT_ARG(ctx->type);

data/vendor/libgit2/src/hash/sha1.h

@@ -26,6 +26,8 @@ typedef struct git_hash_sha1_ctx git_hash_sha1_ctx;
 # include "sha1/generic.h"
 #endif
 
+#define GIT_HASH_SHA1_SIZE 20
+
 int git_hash_sha1_global_init(void);
 
 int git_hash_sha1_ctx_init(git_hash_sha1_ctx *ctx);
@@ -33,6 +35,6 @@ void git_hash_sha1_ctx_cleanup(git_hash_sha1_ctx *ctx);
 
 int git_hash_sha1_init(git_hash_sha1_ctx *c);
 int git_hash_sha1_update(git_hash_sha1_ctx *c, const void *data, size_t len);
-int git_hash_sha1_final(git_oid *out, git_hash_sha1_ctx *c);
+int git_hash_sha1_final(unsigned char *out, git_hash_sha1_ctx *c);
 
 #endif

data/vendor/libgit2/src/hash.c

@@ -12,71 +12,83 @@ int git_hash_global_init(void)
 	return git_hash_sha1_global_init();
 }
 
-int git_hash_ctx_init(git_hash_ctx *ctx)
+int git_hash_ctx_init(git_hash_ctx *ctx, git_hash_algorithm_t algorithm)
 {
 	int error;
 
-	if ((error = git_hash_sha1_ctx_init(&ctx->ctx.sha1)) < 0)
-		return error;
-
-	ctx->algo = GIT_HASH_ALGO_SHA1;
+	switch (algorithm) {
+	case GIT_HASH_ALGORITHM_SHA1:
+		error = git_hash_sha1_ctx_init(&ctx->ctx.sha1);
+		break;
+	default:
+		git_error_set(GIT_ERROR_INTERNAL, "unknown hash algorithm");
+		error = -1;
+	}
 
-	return 0;
+	ctx->algorithm = algorithm;
+	return error;
 }
 
 void git_hash_ctx_cleanup(git_hash_ctx *ctx)
 {
-	switch (ctx->algo) {
-		case GIT_HASH_ALGO_SHA1:
-			git_hash_sha1_ctx_cleanup(&ctx->ctx.sha1);
-			return;
-		default:
-			/* unreachable */ ;
+	switch (ctx->algorithm) {
+	case GIT_HASH_ALGORITHM_SHA1:
+		git_hash_sha1_ctx_cleanup(&ctx->ctx.sha1);
+		return;
+	default:
+		/* unreachable */ ;
 	}
 }
 
 int git_hash_init(git_hash_ctx *ctx)
 {
-	switch (ctx->algo) {
-		case GIT_HASH_ALGO_SHA1:
-			return git_hash_sha1_init(&ctx->ctx.sha1);
-		default:
-			/* unreachable */ ;
+	switch (ctx->algorithm) {
+	case GIT_HASH_ALGORITHM_SHA1:
+		return git_hash_sha1_init(&ctx->ctx.sha1);
+	default:
+		/* unreachable */ ;
 	}
-	GIT_ASSERT(0);
+
+	git_error_set(GIT_ERROR_INTERNAL, "unknown hash algorithm");
 	return -1;
 }
 
 int git_hash_update(git_hash_ctx *ctx, const void *data, size_t len)
 {
-	switch (ctx->algo) {
-		case GIT_HASH_ALGO_SHA1:
-			return git_hash_sha1_update(&ctx->ctx.sha1, data, len);
-		default:
-			/* unreachable */ ;
+	switch (ctx->algorithm) {
+	case GIT_HASH_ALGORITHM_SHA1:
+		return git_hash_sha1_update(&ctx->ctx.sha1, data, len);
+	default:
+		/* unreachable */ ;
 	}
-	GIT_ASSERT(0);
+
+	git_error_set(GIT_ERROR_INTERNAL, "unknown hash algorithm");
 	return -1;
 }
 
-int git_hash_final(git_oid *out, git_hash_ctx *ctx)
+int git_hash_final(unsigned char *out, git_hash_ctx *ctx)
 {
-	switch (ctx->algo) {
-		case GIT_HASH_ALGO_SHA1:
-			return git_hash_sha1_final(out, &ctx->ctx.sha1);
-		default:
-			/* unreachable */ ;
+	switch (ctx->algorithm) {
+	case GIT_HASH_ALGORITHM_SHA1:
+		return git_hash_sha1_final(out, &ctx->ctx.sha1);
+	default:
+		/* unreachable */ ;
 	}
-	GIT_ASSERT(0);
+
+	git_error_set(GIT_ERROR_INTERNAL, "unknown hash algorithm");
 	return -1;
 }
 
-int git_hash_buf(git_oid *out, const void *data, size_t len)
+int git_hash_buf(
+	unsigned char *out,
+	const void *data,
+	size_t len,
+	git_hash_algorithm_t algorithm)
 {
 	git_hash_ctx ctx;
 	int error = 0;
 
-	if (git_hash_ctx_init(&ctx) < 0)
+	if (git_hash_ctx_init(&ctx, algorithm) < 0)
 		return -1;
 
 	if ((error = git_hash_update(&ctx, data, len)) >= 0)
@@ -87,13 +99,17 @@ int git_hash_buf(git_oid *out, const void *data, size_t len)
 	return error;
 }
 
-int git_hash_vec(git_oid *out, git_buf_vec *vec, size_t n)
+int git_hash_vec(
+	unsigned char *out,
+	git_str_vec *vec,
+	size_t n,
+	git_hash_algorithm_t algorithm)
 {
 	git_hash_ctx ctx;
 	size_t i;
 	int error = 0;
 
-	if (git_hash_ctx_init(&ctx) < 0)
+	if (git_hash_ctx_init(&ctx, algorithm) < 0)
 		return -1;
 
 	for (i = 0; i < n; i++) {
@@ -108,3 +124,19 @@ done:
 
 	return error;
 }
+
+int git_hash_fmt(char *out, unsigned char *hash, size_t hash_len)
+{
+	static char hex[] = "0123456789abcdef";
+	char *str = out;
+	size_t i;
+
+	for (i = 0; i < hash_len; i++) {
+		*str++ = hex[hash[i] >> 4];
+		*str++ = hex[hash[i] & 0x0f];
+	}
+
+	*str++ = '\0';
+
+	return 0;
+}

data/vendor/libgit2/src/hash.h

@@ -10,37 +10,37 @@
 
 #include "common.h"
 
-#include "git2/oid.h"
+#include "hash/sha1.h"
 
 typedef struct {
 	void *data;
 	size_t len;
-} git_buf_vec;
+} git_str_vec;
 
 typedef enum {
-	GIT_HASH_ALGO_UNKNOWN = 0,
-	GIT_HASH_ALGO_SHA1,
-} git_hash_algo_t;
-
-#include "hash/sha1.h"
+	GIT_HASH_ALGORITHM_NONE = 0,
+	GIT_HASH_ALGORITHM_SHA1
+} git_hash_algorithm_t;
 
 typedef struct git_hash_ctx {
 	union {
 		git_hash_sha1_ctx sha1;
 	} ctx;
-	git_hash_algo_t algo;
+	git_hash_algorithm_t algorithm;
 } git_hash_ctx;
 
 int git_hash_global_init(void);
 
-int git_hash_ctx_init(git_hash_ctx *ctx);
+int git_hash_ctx_init(git_hash_ctx *ctx, git_hash_algorithm_t algorithm);
 void git_hash_ctx_cleanup(git_hash_ctx *ctx);
 
 int git_hash_init(git_hash_ctx *c);
 int git_hash_update(git_hash_ctx *c, const void *data, size_t len);
-int git_hash_final(git_oid *out, git_hash_ctx *c);
+int git_hash_final(unsigned char *out, git_hash_ctx *c);
+
+int git_hash_buf(unsigned char *out, const void *data, size_t len, git_hash_algorithm_t algorithm);
+int git_hash_vec(unsigned char *out, git_str_vec *vec, size_t n, git_hash_algorithm_t algorithm);
 
-int git_hash_buf(git_oid *out, const void *data, size_t len);
-int git_hash_vec(git_oid *out, git_buf_vec *vec, size_t n);
+int git_hash_fmt(char *out, unsigned char *hash, size_t hash_len);
 
 #endif

data/vendor/libgit2/src/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,7 +40,7 @@ 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];
 	const char *id_start, *id_end, *from_end = from->ptr + from->size;
@@ -60,20 +60,20 @@ static int ident_insert_id(
 		5 /* "$Id: " */ + GIT_OID_HEXSZ + 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_put(to, oid, GIT_OID_HEXSZ);
+	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

@@ -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,7 @@ int git_ignore__for_path(
 {
 	int error = 0;
 	const char *workdir = git_repository_workdir(repo);
-	git_buf infopath = GIT_BUF_INIT;
+	git_str infopath = GIT_STR_INIT;
 
 	GIT_ASSERT_ARG(repo);
 	GIT_ASSERT_ARG(ignores);
@@ -313,21 +314,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 +343,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;
@@ -363,7 +364,7 @@ int git_ignore__for_path(
 			git_repository_attr_cache(repo)->cfg_excl_file);
 
 cleanup:
-	git_buf_dispose(&infopath);
+	git_str_dispose(&infopath);
 	if (error < 0)
 		git_ignore__free(ignores);
 
@@ -372,7 +373,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 +410,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;
@@ -435,7 +436,7 @@ void git_ignore__free(git_ignores *ignores)
 	}
 	git_vector_free(&ignores->ign_global);
 
-	git_buf_dispose(&ignores->dir);
+	git_str_dispose(&ignores->dir);
 }
 
 static bool ignore_lookup_in_rules(
@@ -604,7 +605,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 +630,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 +646,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

@@ -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);