rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/libgit2/fetch.c

@@ -17,9 +17,9 @@
 #include "remote.h"
 #include "refspec.h"
 #include "pack.h"
-#include "netops.h"
 #include "repository.h"
 #include "refs.h"
+#include "transports/smart.h"
 
 static int maybe_want(git_remote *remote, git_remote_head *head, git_refspec *tagspec, git_remote_autotag_option_t tagopt)
 {
@@ -59,8 +59,12 @@ static int mark_local(git_remote *remote)
 		return -1;
 
 	git_vector_foreach(&remote->refs, i, head) {
-		/* If we have the object, mark it so we don't ask for it */
-		if (git_odb_exists(odb, &head->oid))
+		/* If we have the object, mark it so we don't ask for it.
+		   However if we are unshallowing or changing history
+		   depth, we need to ask for it even though the head
+		   exists locally. */
+		if (remote->nego.depth == GIT_FETCH_DEPTH_FULL &&
+		    git_odb_exists(odb, &head->oid))
 			head->local = 1;
 		else
 			remote->need_pack = 1;
@@ -76,7 +80,7 @@ static int maybe_want_oid(git_remote *remote, git_refspec *spec)
 	oid_head = git__calloc(1, sizeof(git_remote_head));
 	GIT_ERROR_CHECK_ALLOC(oid_head);
 
-	git_oid__fromstr(&oid_head->oid, spec->src, GIT_OID_SHA1);
+	git_oid__fromstr(&oid_head->oid, spec->src, remote->repo->oid_type);
 
 	if (spec->dst) {
 		oid_head->name = git__strdup(spec->dst);
@@ -137,7 +141,7 @@ static int filter_wants(git_remote *remote, const git_fetch_options *opts)
 
 	/* Handle explicitly specified OID specs */
 	git_vector_foreach(&remote->active_refspecs, i, spec) {
-		if (!git_oid__is_hexstr(spec->src, GIT_OID_SHA1))
+		if (!git_oid__is_hexstr(spec->src, remote->repo->oid_type))
 			continue;
 
 		if (!(remote_caps & oid_mask)) {
@@ -166,9 +170,15 @@ cleanup:
 int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts)
 {
 	git_transport *t = remote->transport;
+	int error;
 
 	remote->need_pack = 0;
 
+	if (opts) {
+		GIT_ASSERT_ARG(opts->depth >= 0);
+		remote->nego.depth = opts->depth;
+	}
+
 	if (filter_wants(remote, opts) < 0)
 		return -1;
 
@@ -180,20 +190,40 @@ int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts)
 	 * Now we have everything set up so we can start tell the
 	 * server what we want and what we have.
 	 */
-	return t->negotiate_fetch(t,
+	remote->nego.refs = (const git_remote_head * const *)remote->refs.contents;
+	remote->nego.refs_len = remote->refs.length;
+
+	if (git_repository__shallow_roots(&remote->nego.shallow_roots,
+	                                  &remote->nego.shallow_roots_len,
+	                                  remote->repo) < 0)
+		return -1;
+
+	error = t->negotiate_fetch(t,
 		remote->repo,
-		(const git_remote_head * const *)remote->refs.contents,
-		remote->refs.length);
+		&remote->nego);
+
+	git__free(remote->nego.shallow_roots);
+
+	return error;
 }
 
 int git_fetch_download_pack(git_remote *remote)
 {
+	git_oidarray shallow_roots = { NULL };
 	git_transport *t = remote->transport;
+	int error;
 
 	if (!remote->need_pack)
 		return 0;
 
-	return t->download_pack(t, remote->repo, &remote->stats);
+	if ((error = t->download_pack(t, remote->repo, &remote->stats)) != 0 ||
+	    (error = t->shallow_roots(&shallow_roots, t)) != 0)
+		return error;
+
+	error = git_repository__shallow_roots_write(remote->repo, &shallow_roots);
+
+	git_oidarray_dispose(&shallow_roots);
+	return error;
 }
 
 int git_fetch_options_init(git_fetch_options *opts, unsigned int version)

data/vendor/libgit2/src/libgit2/fetch.h

@@ -11,8 +11,6 @@
 
 #include "git2/remote.h"
 
-#include "netops.h"
-
 int git_fetch_negotiate(git_remote *remote, const git_fetch_options *opts);
 
 int git_fetch_download_pack(git_remote *remote);

data/vendor/libgit2/src/libgit2/fetchhead.c

@@ -105,15 +105,14 @@ static int fetchhead_ref_write(
 	git_filebuf *file,
 	git_fetchhead_ref *fetchhead_ref)
 {
-	char oid[GIT_OID_SHA1_HEXSIZE + 1];
+	char oid[GIT_OID_MAX_HEXSIZE + 1];
 	const char *type, *name;
 	int head = 0;
 
 	GIT_ASSERT_ARG(file);
 	GIT_ASSERT_ARG(fetchhead_ref);
 
-	git_oid_fmt(oid, &fetchhead_ref->oid);
-	oid[GIT_OID_SHA1_HEXSIZE] = '\0';
+	git_oid_tostr(oid, GIT_OID_MAX_HEXSIZE + 1, &fetchhead_ref->oid);
 
 	if (git__prefixcmp(fetchhead_ref->ref_name, GIT_REFS_HEADS_DIR) == 0) {
 		type = "branch ";
@@ -174,7 +173,8 @@ static int fetchhead_ref_parse(
 	git_str *ref_name,
 	const char **remote_url,
 	char *line,
-	size_t line_num)
+	size_t line_num,
+	git_oid_t oid_type)
 {
 	char *oid_str, *is_merge_str, *desc, *name = NULL;
 	const char *type = NULL;
@@ -196,13 +196,13 @@ static int fetchhead_ref_parse(
 		*is_merge = 1;
 	}
 
-	if (strlen(oid_str) != GIT_OID_SHA1_HEXSIZE) {
+	if (strlen(oid_str) != git_oid_hexsize(oid_type)) {
 		git_error_set(GIT_ERROR_FETCHHEAD,
 			"invalid object ID in FETCH_HEAD line %"PRIuZ, line_num);
 		return -1;
 	}
 
-	if (git_oid__fromstr(oid, oid_str, GIT_OID_SHA1) < 0) {
+	if (git_oid__fromstr(oid, oid_str, oid_type) < 0) {
 		const git_error *oid_err = git_error_last();
 		const char *err_msg = oid_err ? oid_err->message : "invalid object ID";
 
@@ -269,7 +269,8 @@ static int fetchhead_ref_parse(
 	return error;
 }
 
-int git_repository_fetchhead_foreach(git_repository *repo,
+int git_repository_fetchhead_foreach(
+	git_repository *repo,
 	git_repository_fetchhead_foreach_cb cb,
 	void *payload)
 {
@@ -296,8 +297,9 @@ int git_repository_fetchhead_foreach(git_repository *repo,
 	while ((line = git__strsep(&buffer, "\n")) != NULL) {
 		++line_num;
 
-		if ((error = fetchhead_ref_parse(
-				&oid, &is_merge, &name, &remote_url, line, line_num)) < 0)
+		if ((error = fetchhead_ref_parse(&oid, &is_merge, &name,
+				&remote_url, line, line_num,
+				repo->oid_type)) < 0)
 			goto done;
 
 		if (git_str_len(&name) > 0)

data/vendor/libgit2/src/libgit2/filter.c

@@ -239,7 +239,7 @@ static void git_filter_global_shutdown(void)
 		git__free(fdef);
 	}
 
-	git_vector_free(&filter_registry.filters);
+	git_vector_dispose(&filter_registry.filters);
 
 	git_rwlock_wrunlock(&filter_registry.lock);
 	git_rwlock_free(&filter_registry.lock);
@@ -908,7 +908,7 @@ static int buffered_stream_close(git_writestream *s)
 {
 	struct buffered_stream *buffered_stream = (struct buffered_stream *)s;
 	git_str *writebuf;
-	git_error_state error_state = {0};
+	git_error *last_error;
 	int error;
 
 	GIT_ASSERT_ARG(buffered_stream);
@@ -946,9 +946,9 @@ static int buffered_stream_close(git_writestream *s)
 	} else {
 		/* close stream before erroring out taking care
 		 * to preserve the original error */
-		git_error_state_capture(&error_state, error);
+		git_error_save(&last_error);
 		buffered_stream->target->close(buffered_stream->target);
-		git_error_state_restore(&error_state);
+		git_error_restore(last_error);
 		return error;
 	}
 
@@ -1106,7 +1106,7 @@ static void filter_streams_free(git_vector *streams)
 
 	git_vector_foreach(streams, i, stream)
 		stream->free(stream);
-	git_vector_free(streams);
+	git_vector_dispose(streams);
 }
 
 int git_filter_list_stream_file(

data/vendor/libgit2/src/libgit2/git2.rc

@@ -10,7 +10,7 @@
 #endif
 
 #ifndef LIBGIT2_COMMENTS
-# define LIBGIT2_COMMENTS "For more information visit http://libgit2.github.com/"
+# define LIBGIT2_COMMENTS "For more information visit https://libgit2.org/"
 #endif
 
 #ifdef __GNUC__
@@ -25,8 +25,8 @@ VS_VERSION_INFO		VERSIONINFO
 #else
 VS_VERSION_INFO		VERSIONINFO	MOVEABLE IMPURE LOADONCALL DISCARDABLE
 #endif
-  FILEVERSION		LIBGIT2_VER_MAJOR,LIBGIT2_VER_MINOR,LIBGIT2_VER_REVISION,LIBGIT2_VER_PATCH
-  PRODUCTVERSION	LIBGIT2_VER_MAJOR,LIBGIT2_VER_MINOR,LIBGIT2_VER_REVISION,LIBGIT2_VER_PATCH
+  FILEVERSION		LIBGIT2_VERSION_MAJOR,LIBGIT2_VERSION_MINOR,LIBGIT2_VERSION_REVISION,LIBGIT2_VERSION_PATCH
+  PRODUCTVERSION	LIBGIT2_VERSION_MAJOR,LIBGIT2_VERSION_MINOR,LIBGIT2_VERSION_REVISION,LIBGIT2_VERSION_PATCH
   FILEFLAGSMASK		VS_FFI_FILEFLAGSMASK
 #ifdef _DEBUG
   FILEFLAGS		VS_FF_DEBUG

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/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/libgit2/ident.c

@@ -42,7 +42,7 @@ static int ident_find_id(
 static int ident_insert_id(
 	git_str *to, const git_str *from, const git_filter_source *src)
 {
-	char oid[GIT_OID_SHA1_HEXSIZE+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,7 +57,7 @@ static int ident_insert_id(
 		return GIT_PASSTHROUGH;
 
 	need_size = (size_t)(id_start - from->ptr) +
-		5 /* "$Id: " */ + GIT_OID_SHA1_HEXSIZE + 2 /* " $" */ +
+		5 /* "$Id: " */ + GIT_OID_MAX_HEXSIZE + 2 /* " $" */ +
 		(size_t)(from_end - id_end);
 
 	if (git_str_grow(to, need_size) < 0)
@@ -65,7 +65,7 @@ static int ident_insert_id(
 
 	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_SHA1_HEXSIZE);
+	git_str_puts(to, oid);
 	git_str_put(to, " $", 2);
 	git_str_put(to, id_end, (size_t)(from_end - id_end));
 

data/vendor/libgit2/src/libgit2/ignore.c

@@ -296,6 +296,8 @@ int git_ignore__for_path(
 {
 	int error = 0;
 	const char *workdir = git_repository_workdir(repo);
+	git_attr_cache *attrcache;
+	const char *excludes_file = NULL;
 	git_str infopath = GIT_STR_INIT;
 
 	GIT_ASSERT_ARG(repo);
@@ -358,10 +360,12 @@ 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_str_dispose(&infopath);
@@ -428,13 +432,13 @@ 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_str_dispose(&ignores->dir);
 }