rugged 0.27.9 → 0.27.10

data/vendor/libgit2/src/posix.h

@@ -11,7 +11,6 @@
 
 #include <fcntl.h>
 #include <time.h>
-#include "fnmatch.h"
 
 /* stat: file mode type testing macros */
 #ifndef S_IFGITLINK
@@ -90,6 +89,18 @@
 #define EAFNOSUPPORT (INT_MAX-1)
 #endif
 
+/* Provide a 64-bit size for offsets. */
+
+#if defined(_MSC_VER)
+typedef __int64 off64_t;
+#elif defined(__HAIKU__)
+typedef __haiku_std_int64 off64_t;
+#elif defined(__APPLE__)
+typedef __int64_t off64_t;
+#else
+typedef int64_t off64_t;
+#endif
+
 typedef int git_file;
 
 /**

data/vendor/libgit2/src/proxy.c

@@ -9,24 +9,29 @@
 
 #include "git2/proxy.h"
 
-int git_proxy_init_options(git_proxy_options *opts, unsigned int version)
+int git_proxy_options_init(git_proxy_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_proxy_options, GIT_PROXY_OPTIONS_INIT);
 	return 0;
 }
 
+int git_proxy_init_options(git_proxy_options *opts, unsigned int version)
+{
+	return git_proxy_options_init(opts, version);
+}
+
 int git_proxy_options_dup(git_proxy_options *tgt, const git_proxy_options *src)
 {
 	if (!src) {
-		git_proxy_init_options(tgt, GIT_PROXY_OPTIONS_VERSION);
+		git_proxy_options_init(tgt, GIT_PROXY_OPTIONS_VERSION);
 		return 0;
 	}
 
 	memcpy(tgt, src, sizeof(git_proxy_options));
 	if (src->url) {
 		tgt->url = git__strdup(src->url);
-		GITERR_CHECK_ALLOC(tgt->url);
+		GIT_ERROR_CHECK_ALLOC(tgt->url);
 	}
 
 	return 0;

data/vendor/libgit2/src/push.c

@@ -36,7 +36,7 @@ int git_push_new(git_push **out, git_remote *remote)
 	*out = NULL;
 
 	p = git__calloc(1, sizeof(*p));
-	GITERR_CHECK_ALLOC(p);
+	GIT_ERROR_CHECK_ALLOC(p);
 
 	p->repo = remote->repo;
 	p->remote = remote;
@@ -70,10 +70,11 @@ int git_push_set_options(git_push *push, const git_push_options *opts)
 	if (!push || !opts)
 		return -1;
 
-	GITERR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");
+	GIT_ERROR_CHECK_VERSION(opts, GIT_PUSH_OPTIONS_VERSION, "git_push_options");
 
 	push->pb_parallelism = opts->pb_parallelism;
-	push->custom_headers = &opts->custom_headers;
+	push->connection.custom_headers = &opts->custom_headers;
+	push->connection.proxy = &opts->proxy_opts;
 
 	return 0;
 }
@@ -83,14 +84,14 @@ static void free_refspec(push_spec *spec)
 	if (spec == NULL)
 		return;
 
-	git_refspec__free(&spec->refspec);
+	git_refspec__dispose(&spec->refspec);
 	git__free(spec);
 }
 
 static int check_rref(char *ref)
 {
 	if (git__prefixcmp(ref, "refs/")) {
-		giterr_set(GITERR_INVALID, "not a valid reference '%s'", ref);
+		git_error_set(GIT_ERROR_INVALID, "not a valid reference '%s'", ref);
 		return -1;
 	}
 
@@ -108,10 +109,10 @@ static int check_lref(git_push *push, char *ref)
 		return 0;
 
 	if (error == GIT_ENOTFOUND)
-		giterr_set(GITERR_REFERENCE,
+		git_error_set(GIT_ERROR_REFERENCE,
 			"src refspec '%s' does not match any existing object", ref);
 	else
-		giterr_set(GITERR_INVALID, "not a valid reference '%s'", ref);
+		git_error_set(GIT_ERROR_INVALID, "not a valid reference '%s'", ref);
 	return -1;
 }
 
@@ -122,10 +123,10 @@ static int parse_refspec(git_push *push, push_spec **spec, const char *str)
 	*spec = NULL;
 
 	s = git__calloc(1, sizeof(*s));
-	GITERR_CHECK_ALLOC(s);
+	GIT_ERROR_CHECK_ALLOC(s);
 
 	if (git_refspec__parse(&s->refspec, str, false) < 0) {
-		giterr_set(GITERR_INVALID, "invalid refspec %s", str);
+		git_error_set(GIT_ERROR_INVALID, "invalid refspec %s", str);
 		goto on_error;
 	}
 
@@ -195,7 +196,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 			continue;
 
 		/* Update the remote ref */
-		if (git_oid_iszero(&push_spec->loid)) {
+		if (git_oid_is_zero(&push_spec->loid)) {
 			error = git_reference_lookup(&remote_ref, push->remote->repo, git_buf_cstr(&remote_ref_name));
 
 			if (error >= 0) {
@@ -212,7 +213,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 			if (error != GIT_ENOTFOUND)
 				goto on_error;
 
-			giterr_clear();
+			git_error_clear();
 			fire_callback = 0;
 		}
 
@@ -228,7 +229,7 @@ int git_push_update_tips(git_push *push, const git_remote_callbacks *callbacks)
 	error = 0;
 
 on_error:
-	git_buf_free(&remote_ref_name);
+	git_buf_dispose(&remote_ref_name);
 	return error;
 }
 
@@ -241,10 +242,10 @@ static int enqueue_tag(git_object **out, git_push *push, git_oid *id)
 	git_object *obj = NULL, *target = NULL;
 	int error;
 
-	if ((error = git_object_lookup(&obj, push->repo, id, GIT_OBJ_TAG)) < 0)
+	if ((error = git_object_lookup(&obj, push->repo, id, GIT_OBJECT_TAG)) < 0)
 		return error;
 
-	while (git_object_type(obj) == GIT_OBJ_TAG) {
+	while (git_object_type(obj) == GIT_OBJECT_TAG) {
 		if ((error = git_packbuilder_insert(push->pb, git_object_id(obj), NULL)) < 0)
 			break;
 
@@ -277,10 +278,10 @@ static int queue_objects(git_push *push)
 	git_revwalk_sorting(rw, GIT_SORT_TIME);
 
 	git_vector_foreach(&push->specs, i, spec) {
-		git_otype type;
+		git_object_t type;
 		size_t size;
 
-		if (git_oid_iszero(&spec->loid))
+		if (git_oid_is_zero(&spec->loid))
 			/*
 			 * Delete reference on remote side;
 			 * nothing to do here.
@@ -293,13 +294,13 @@ static int queue_objects(git_push *push)
 		if (git_odb_read_header(&size, &type, push->repo->_odb, &spec->loid) < 0)
 			goto on_error;
 
-		if (type == GIT_OBJ_TAG) {
+		if (type == GIT_OBJECT_TAG) {
 			git_object *target;
 
 			if ((error = enqueue_tag(&target, push, &spec->loid)) < 0)
 				goto on_error;
 
-			if (git_object_type(target) == GIT_OBJ_COMMIT) {
+			if (git_object_type(target) == GIT_OBJECT_COMMIT) {
 				if (git_revwalk_push(rw, git_object_id(target)) < 0) {
 					git_object_free(target);
 					goto on_error;
@@ -318,11 +319,11 @@ static int queue_objects(git_push *push)
 		if (!spec->refspec.force) {
 			git_oid base;
 
-			if (git_oid_iszero(&spec->roid))
+			if (git_oid_is_zero(&spec->roid))
 				continue;
 
 			if (!git_odb_exists(push->repo->_odb, &spec->roid)) {
-				giterr_set(GITERR_REFERENCE, 
+				git_error_set(GIT_ERROR_REFERENCE,
 					"cannot push because a reference that you are trying to update on the remote contains commits that are not present locally.");
 				error = GIT_ENONFASTFORWARD;
 				goto on_error;
@@ -333,7 +334,7 @@ static int queue_objects(git_push *push)
 
 			if (error == GIT_ENOTFOUND ||
 				(!error && !git_oid_equal(&base, &spec->roid))) {
-				giterr_set(GITERR_REFERENCE,
+				git_error_set(GIT_ERROR_REFERENCE,
 					"cannot push non-fastforwardable reference");
 				error = GIT_ENONFASTFORWARD;
 				goto on_error;
@@ -345,7 +346,7 @@ static int queue_objects(git_push *push)
 	}
 
 	git_vector_foreach(&push->remote->refs, i, head) {
-		if (git_oid_iszero(&head->oid))
+		if (git_oid_is_zero(&head->oid))
 			continue;
 
 		/* TODO */
@@ -362,13 +363,13 @@ on_error:
 static int add_update(git_push *push, push_spec *spec)
 {
 	git_push_update *u = git__calloc(1, sizeof(git_push_update));
-	GITERR_CHECK_ALLOC(u);
+	GIT_ERROR_CHECK_ALLOC(u);
 
 	u->src_refname = git__strdup(spec->refspec.src);
-	GITERR_CHECK_ALLOC(u->src_refname);
+	GIT_ERROR_CHECK_ALLOC(u->src_refname);
 
 	u->dst_refname = git__strdup(spec->refspec.dst);
-	GITERR_CHECK_ALLOC(u->dst_refname);
+	GIT_ERROR_CHECK_ALLOC(u->dst_refname);
 
 	git_oid_cpy(&u->src, &spec->roid);
 	git_oid_cpy(&u->dst, &spec->loid);
@@ -389,7 +390,7 @@ static int calculate_work(git_push *push)
 			/* This is a create or update.  Local ref must exist. */
 			if (git_reference_name_to_id(
 					&spec->loid, push->repo, spec->refspec.src) < 0) {
-				giterr_set(GITERR_REFERENCE, "no such reference '%s'", spec->refspec.src);
+				git_error_set(GIT_ERROR_REFERENCE, "no such reference '%s'", spec->refspec.src);
 				return -1;
 			}
 		}
@@ -415,7 +416,7 @@ static int do_push(git_push *push, const git_remote_callbacks *callbacks)
 	git_transport *transport = push->remote->transport;
 
 	if (!transport->push) {
-		giterr_set(GITERR_NET, "remote transport doesn't support push");
+		git_error_set(GIT_ERROR_NET, "remote transport doesn't support push");
 		error = -1;
 		goto on_error;
 	}
@@ -475,7 +476,7 @@ int git_push_finish(git_push *push, const git_remote_callbacks *callbacks)
 	int error;
 
 	if (!git_remote_connected(push->remote) &&
-	    (error = git_remote_connect(push->remote, GIT_DIRECTION_PUSH, callbacks, NULL, push->custom_headers)) < 0)
+	    (error = git_remote__connect(push->remote, GIT_DIRECTION_PUSH, callbacks, &push->connection)) < 0)
 		return error;
 
 	if ((error = filter_refs(push->remote)) < 0 ||
@@ -484,7 +485,7 @@ int git_push_finish(git_push *push, const git_remote_callbacks *callbacks)
 
 	if (!push->unpack_ok) {
 		error = -1;
-		giterr_set(GITERR_NET, "unpacking the sent packfile failed on the remote");
+		git_error_set(GIT_ERROR_NET, "unpacking the sent packfile failed on the remote");
 	}
 
 	return error;
@@ -500,7 +501,7 @@ int git_push_status_foreach(git_push *push,
 	git_vector_foreach(&push->status, i, status) {
 		int error = cb(status->ref, status->msg, data);
 		if (error)
-			return giterr_set_after_callback(error);
+			return git_error_set_after_callback(error);
 	}
 
 	return 0;
@@ -546,9 +547,14 @@ void git_push_free(git_push *push)
 	git__free(push);
 }
 
-int git_push_init_options(git_push_options *opts, unsigned int version)
+int git_push_options_init(git_push_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_push_options, GIT_PUSH_OPTIONS_INIT);
 	return 0;
 }
+
+int git_push_init_options(git_push_options *opts, unsigned int version)
+{
+	return git_push_options_init(opts, version);
+}

data/vendor/libgit2/src/push.h

@@ -11,6 +11,7 @@
 
 #include "git2.h"
 #include "refspec.h"
+#include "remote.h"
 
 typedef struct push_spec {
 	struct git_refspec refspec;
@@ -40,7 +41,7 @@ struct git_push {
 
 	/* options */
 	unsigned pb_parallelism;
-	const git_strarray *custom_headers;
+	git_remote_connection_opts connection;
 };
 
 /**

data/vendor/libgit2/src/reader.c

@@ -0,0 +1,265 @@
+/*
+ * 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 "reader.h"
+
+#include "futils.h"
+#include "blob.h"
+
+#include "git2/tree.h"
+#include "git2/blob.h"
+#include "git2/index.h"
+#include "git2/repository.h"
+
+/* tree reader */
+
+typedef struct {
+	git_reader reader;
+	git_tree *tree;
+} tree_reader;
+
+static int tree_reader_read(
+	git_buf *out,
+	git_oid *out_id,
+	git_filemode_t *out_filemode,
+	git_reader *_reader,
+	const char *filename)
+{
+	tree_reader *reader = (tree_reader *)_reader;
+	git_tree_entry *tree_entry = NULL;
+	git_blob *blob = NULL;
+	git_object_size_t blobsize;
+	int error;
+
+	if ((error = git_tree_entry_bypath(&tree_entry, reader->tree, filename)) < 0 ||
+	    (error = git_blob_lookup(&blob, git_tree_owner(reader->tree), git_tree_entry_id(tree_entry))) < 0)
+		goto done;
+
+	blobsize = git_blob_rawsize(blob);
+	GIT_ERROR_CHECK_BLOBSIZE(blobsize);
+
+	if ((error = git_buf_set(out, git_blob_rawcontent(blob), (size_t)blobsize)) < 0)
+		goto done;
+
+	if (out_id)
+		git_oid_cpy(out_id, git_tree_entry_id(tree_entry));
+
+	if (out_filemode)
+		*out_filemode = git_tree_entry_filemode(tree_entry);
+
+done:
+	git_blob_free(blob);
+	git_tree_entry_free(tree_entry);
+	return error;
+}
+
+int git_reader_for_tree(git_reader **out, git_tree *tree)
+{
+	tree_reader *reader;
+
+	assert(out && tree);
+
+	reader = git__calloc(1, sizeof(tree_reader));
+	GIT_ERROR_CHECK_ALLOC(reader);
+
+	reader->reader.read = tree_reader_read;
+	reader->tree = tree;
+
+	*out = (git_reader *)reader;
+	return 0;
+}
+
+/* workdir reader */
+
+typedef struct {
+	git_reader reader;
+	git_repository *repo;
+	git_index *index;
+} workdir_reader;
+
+static int workdir_reader_read(
+	git_buf *out,
+	git_oid *out_id,
+	git_filemode_t *out_filemode,
+	git_reader *_reader,
+	const char *filename)
+{
+	workdir_reader *reader = (workdir_reader *)_reader;
+	git_buf path = GIT_BUF_INIT;
+	struct stat st;
+	git_filemode_t filemode;
+	git_filter_list *filters = NULL;
+	const git_index_entry *idx_entry;
+	git_oid id;
+	int error;
+
+	if ((error = git_buf_joinpath(&path,
+		git_repository_workdir(reader->repo), filename)) < 0)
+		goto done;
+
+	if ((error = p_lstat(path.ptr, &st)) < 0) {
+		if (error == -1 && errno == ENOENT)
+			error = GIT_ENOTFOUND;
+
+		git_error_set(GIT_ERROR_OS, "could not stat '%s'", path.ptr);
+		goto done;
+	}
+
+	filemode = git_futils_canonical_mode(st.st_mode);
+
+	/*
+	 * Patch application - for example - uses the filtered version of
+	 * the working directory data to match git.  So we will run the
+	 * workdir -> ODB filter on the contents in this workdir reader.
+	 */
+	if ((error = git_filter_list_load(&filters, reader->repo, NULL, filename,
+		GIT_FILTER_TO_ODB, GIT_FILTER_DEFAULT)) < 0)
+		goto done;
+
+	if ((error = git_filter_list_apply_to_file(out,
+	    filters, reader->repo, path.ptr)) < 0)
+		goto done;
+
+	if (out_id || reader->index) {
+		if ((error = git_odb_hash(&id, out->ptr, out->size, GIT_OBJECT_BLOB)) < 0)
+			goto done;
+	}
+
+	if (reader->index) {
+		if (!(idx_entry = git_index_get_bypath(reader->index, filename, 0)) ||
+		    filemode != idx_entry->mode ||
+		    !git_oid_equal(&id, &idx_entry->id)) {
+			error = GIT_READER_MISMATCH;
+			goto done;
+		}
+	}
+
+	if (out_id)
+		git_oid_cpy(out_id, &id);
+
+	if (out_filemode)
+		*out_filemode = filemode;
+
+done:
+	git_filter_list_free(filters);
+	git_buf_dispose(&path);
+	return error;
+}
+
+int git_reader_for_workdir(
+	git_reader **out,
+	git_repository *repo,
+	bool validate_index)
+{
+	workdir_reader *reader;
+	int error;
+
+	assert(out && repo);
+
+	reader = git__calloc(1, sizeof(workdir_reader));
+	GIT_ERROR_CHECK_ALLOC(reader);
+
+	reader->reader.read = workdir_reader_read;
+	reader->repo = repo;
+
+	if (validate_index &&
+	    (error = git_repository_index__weakptr(&reader->index, repo)) < 0) {
+		git__free(reader);
+		return error;
+	}
+
+	*out = (git_reader *)reader;
+	return 0;
+}
+
+/* index reader */
+
+typedef struct {
+	git_reader reader;
+	git_repository *repo;
+	git_index *index;
+} index_reader;
+
+static int index_reader_read(
+	git_buf *out,
+	git_oid *out_id,
+	git_filemode_t *out_filemode,
+	git_reader *_reader,
+	const char *filename)
+{
+	index_reader *reader = (index_reader *)_reader;
+	const git_index_entry *entry;
+	git_blob *blob;
+	int error;
+
+	if ((entry = git_index_get_bypath(reader->index, filename, 0)) == NULL)
+		return GIT_ENOTFOUND;
+
+	if ((error = git_blob_lookup(&blob, reader->repo, &entry->id)) < 0)
+		goto done;
+
+	if (out_id)
+		git_oid_cpy(out_id, &entry->id);
+
+	if (out_filemode)
+		*out_filemode = entry->mode;
+
+	error = git_blob__getbuf(out, blob);
+
+done:
+	git_blob_free(blob);
+	return error;
+}
+
+int git_reader_for_index(
+	git_reader **out,
+	git_repository *repo,
+	git_index *index)
+{
+	index_reader *reader;
+	int error;
+
+	assert(out && repo);
+
+	reader = git__calloc(1, sizeof(index_reader));
+	GIT_ERROR_CHECK_ALLOC(reader);
+
+	reader->reader.read = index_reader_read;
+	reader->repo = repo;
+
+	if (index) {
+		reader->index = index;
+	} else if ((error = git_repository_index__weakptr(&reader->index, repo)) < 0) {
+		git__free(reader);
+		return error;
+	}
+
+	*out = (git_reader *)reader;
+	return 0;
+}
+
+/* generic */
+
+int git_reader_read(
+	git_buf *out,
+	git_oid *out_id,
+	git_filemode_t *out_filemode,
+	git_reader *reader,
+	const char *filename)
+{
+	assert(out && reader && filename);
+
+	return reader->read(out, out_id, out_filemode, reader, filename);
+}
+
+void git_reader_free(git_reader *reader)
+{
+	if (!reader)
+		return;
+
+	git__free(reader);
+}