rugged 0.25.0b2 → 0.25.0b3

data/vendor/libgit2/include/git2/sys/stream.h

@@ -9,6 +9,7 @@
 
 #include "git2/common.h"
 #include "git2/types.h"
+#include "git2/proxy.h"
 
 GIT_BEGIN_DECL
 
@@ -32,7 +33,7 @@ typedef struct git_stream {
 	int proxy_support;
 	int (*connect)(struct git_stream *);
 	int (*certificate)(git_cert **, struct git_stream *);
-	int (*set_proxy)(struct git_stream *, const char *proxy_url);
+	int (*set_proxy)(struct git_stream *, const git_proxy_options *proxy_opts);
 	ssize_t (*read)(struct git_stream *, void *, size_t);
 	ssize_t (*write)(struct git_stream *, const char *, size_t, int);
 	int (*close)(struct git_stream *);

data/vendor/libgit2/include/git2/sys/transport.h

@@ -11,6 +11,7 @@
 #include "git2/net.h"
 #include "git2/types.h"
 #include "git2/strarray.h"
+#include "git2/proxy.h"
 
 /**
  * @file git2/sys/transport.h
@@ -53,6 +54,7 @@ struct git_transport {
 		const char *url,
 		git_cred_acquire_cb cred_acquire_cb,
 		void *cred_acquire_payload,
+		const git_proxy_options *proxy_opts,
 		int direction,
 		int flags);
 
@@ -65,7 +67,7 @@ struct git_transport {
 		git_transport *transport);
 
 	/* Executes the push whose context is in the git_push object. */
-	int (*push)(git_transport *transport, git_push *push, const git_remote_callbacks *callbacks);
+	int(*push)(git_transport *transport, git_push *push, const git_remote_callbacks *callbacks);
 
 	/* This function may be called after a successful call to connect(), when
 	 * the direction is FETCH. The function performs a negotiation to calculate

data/vendor/libgit2/include/git2/tag.h

@@ -347,6 +347,15 @@ GIT_EXTERN(int) git_tag_peel(
 	git_object **tag_target_out,
 	const git_tag *tag);
 
+/**
+ * Create an in-memory copy of a tag. The copy must be explicitly
+ * free'd or it will leak.
+ *
+ * @param out Pointer to store the copy of the tag
+ * @param source Original tag to copy
+ */
+GIT_EXTERN(int) git_tag_dup(git_tag **out, git_tag *source);
+
 /** @} */
 GIT_END_DECL
 #endif

data/vendor/libgit2/include/git2/tree.h

@@ -409,6 +409,61 @@ GIT_EXTERN(int) git_tree_walk(
 	git_treewalk_cb callback,
 	void *payload);
 
+/**
+ * Create an in-memory copy of a tree. The copy must be explicitly
+ * free'd or it will leak.
+ *
+ * @param out Pointer to store the copy of the tree
+ * @param source Original tree to copy
+ */
+GIT_EXTERN(int) git_tree_dup(git_tree **out, git_tree *source);
+
+/**
+ * The kind of update to perform
+ */
+typedef enum {
+	/** Update or insert an entry at the specified path */
+	GIT_TREE_UPDATE_UPSERT,
+	/** Remove an entry from the specified path */
+	GIT_TREE_UPDATE_REMOVE,
+} git_tree_update_t;
+
+/**
+ * An action to perform during the update of a tree
+ */
+typedef struct {
+	/** Update action. If it's an removal, only the path is looked at */
+	git_tree_update_t action;
+	/** The entry's id */
+	git_oid id;
+	/** The filemode/kind of object */
+	git_filemode_t filemode;
+	/** The full path from the root tree */
+	const char *path;
+} git_tree_update;
+
+/**
+ * Create a tree based on another one with the specified modifications
+ *
+ * Given the `baseline` perform the changes described in the list of
+ * `updates` and create a new tree.
+ *
+ * This function is optimized for common file/directory addition, removal and
+ * replacement in trees. It is much more efficient than reading the tree into a
+ * `git_index` and modifying that, but in exchange it is not as flexible.
+ *
+ * Deleting and adding the same entry is undefined behaviour, changing
+ * a tree to a blob or viceversa is not supported.
+ *
+ * @param out id of the new tree
+ * @param repo the repository in which to create the tree, must be the
+ * same as for `baseline`
+ * @param baseline the tree to base these changes on
+ * @param nupdates the number of elements in the update list
+ * @param updates the list of updates to perform
+ */
+GIT_EXTERN(int) git_tree_create_updated(git_oid *out, git_repository *repo, git_tree *baseline, size_t nupdates, const git_tree_update *updates);
+
 /** @} */
 
 GIT_END_DECL

data/vendor/libgit2/src/annotated_commit.c

@@ -19,39 +19,102 @@
 #include "git2/index.h"
 
 static int annotated_commit_init(
+	git_annotated_commit **out,
+	git_commit *commit,
+	const char *description)
+{
+	git_annotated_commit *annotated_commit;
+	int error = 0;
+
+	assert(out && commit);
+
+	*out = NULL;
+
+	annotated_commit = git__calloc(1, sizeof(git_annotated_commit));
+	GITERR_CHECK_ALLOC(annotated_commit);
+
+	annotated_commit->type = GIT_ANNOTATED_COMMIT_REAL;
+
+	if ((error = git_commit_dup(&annotated_commit->commit, commit)) < 0)
+		goto done;
+
+	git_oid_fmt(annotated_commit->id_str, git_commit_id(commit));
+	annotated_commit->id_str[GIT_OID_HEXSZ] = '\0';
+
+	if (!description)
+		description = annotated_commit->id_str;
+
+	annotated_commit->description = git__strdup(description);
+	GITERR_CHECK_ALLOC(annotated_commit->description);
+
+done:
+	if (!error)
+		*out = annotated_commit;
+
+	return error;
+}
+
+static int annotated_commit_init_from_id(
 	git_annotated_commit **out,
 	git_repository *repo,
 	const git_oid *id,
-	const char *ref_name,
-	const char *remote_url)
+	const char *description)
 {
-	git_annotated_commit *annotated_commit;
 	git_commit *commit = NULL;
 	int error = 0;
 
-	assert(out && id);
+	assert(out && repo && id);
 
 	*out = NULL;
 
-	if ((error = git_commit_lookup(&commit, repo, id)) < 0 ||
-		(error = git_annotated_commit_from_commit(&annotated_commit,
-			commit)) < 0)
+	if ((error = git_commit_lookup(&commit, repo, id)) < 0)
 		goto done;
 
-	if (ref_name) {
-		annotated_commit->ref_name = git__strdup(ref_name);
-		GITERR_CHECK_ALLOC(annotated_commit->ref_name);
-	}
+	error = annotated_commit_init(out, commit, description);
+
+done:
+	git_commit_free(commit);
+	return error;
+}
+
+int git_annotated_commit_lookup(
+	git_annotated_commit **out,
+	git_repository *repo,
+	const git_oid *id)
+{
+	return annotated_commit_init_from_id(out, repo, id, NULL);
+}
+
+int git_annotated_commit_from_commit(
+	git_annotated_commit **out,
+	git_commit *commit)
+{
+	return annotated_commit_init(out, commit, NULL);
+}
 
-	if (remote_url) {
-		annotated_commit->remote_url = git__strdup(remote_url);
-		GITERR_CHECK_ALLOC(annotated_commit->remote_url);
+int git_annotated_commit_from_revspec(
+	git_annotated_commit **out,
+	git_repository *repo,
+	const char *revspec)
+{
+	git_object *obj, *commit;
+	int error;
+
+	assert(out && repo && revspec);
+
+	if ((error = git_revparse_single(&obj, repo, revspec)) < 0)
+		return error;
+
+	if ((error = git_object_peel(&commit, obj, GIT_OBJ_COMMIT))) {
+		git_object_free(obj);
+		return error;
 	}
 
-	*out = annotated_commit;
+	error = annotated_commit_init(out, (git_commit *)commit, revspec);
+
+	git_object_free(obj);
+	git_object_free(commit);
 
-done:
-	git_commit_free(commit);
 	return error;
 }
 
@@ -70,8 +133,15 @@ int git_annotated_commit_from_ref(
 	if ((error = git_reference_resolve(&resolved, ref)) < 0)
 		return error;
 	
-	error = annotated_commit_init(out, repo, git_reference_target(resolved),
-		git_reference_name(ref), NULL);
+	error = annotated_commit_init_from_id(out,
+		repo,
+		git_reference_target(resolved),
+		git_reference_name(ref));
+
+	if (!error) {
+		(*out)->ref_name = git__strdup(git_reference_name(ref));
+		GITERR_CHECK_ALLOC((*out)->ref_name);
+	}
 
 	git_reference_free(resolved);
 	return error;
@@ -97,41 +167,6 @@ int git_annotated_commit_from_head(
 	return error;
 }
 
-int git_annotated_commit_from_commit(
-	git_annotated_commit **out,
-	git_commit *commit)
-{
-	git_annotated_commit *annotated_commit;
-
-	assert(out && commit);
-
-	*out = NULL;
-
-	annotated_commit = git__calloc(1, sizeof(git_annotated_commit));
-	GITERR_CHECK_ALLOC(annotated_commit);
-
-	annotated_commit->type = GIT_ANNOTATED_COMMIT_REAL;
-
-	git_cached_obj_incref(commit);
-	annotated_commit->commit = commit;
-
-	git_oid_fmt(annotated_commit->id_str, git_commit_id(commit));
-	annotated_commit->id_str[GIT_OID_HEXSZ] = '\0';
-
-	*out = annotated_commit;
-	return 0;
-}
-
-int git_annotated_commit_lookup(
-	git_annotated_commit **out,
-	git_repository *repo,
-	const git_oid *id)
-{
-	assert(out && repo && id);
-
-	return annotated_commit_init(out, repo, id, NULL, NULL);
-}
-
 int git_annotated_commit_from_fetchhead(
 	git_annotated_commit **out,
 	git_repository *repo,
@@ -141,33 +176,16 @@ int git_annotated_commit_from_fetchhead(
 {
 	assert(repo && id && branch_name && remote_url);
 
-	return annotated_commit_init(out, repo, id, branch_name, remote_url);
-}
-
-int git_annotated_commit_from_revspec(
-	git_annotated_commit **out,
-	git_repository *repo,
-	const char *revspec)
-{
-	git_object *obj, *commit;
-	int error;
-
-	assert(out && repo && revspec);
-
-	if ((error = git_revparse_single(&obj, repo, revspec)) < 0)
-		return error;
-
-	if ((error = git_object_peel(&commit, obj, GIT_OBJ_COMMIT))) {
-		git_object_free(obj);
-		return error;
-	}
+	if (annotated_commit_init_from_id(out, repo, id, branch_name) < 0)
+		return -1;
 
-	error = annotated_commit_init(out, repo, git_object_id(commit), revspec, NULL);
+	(*out)->ref_name = git__strdup(branch_name);
+	GITERR_CHECK_ALLOC((*out)->ref_name);
 
-	git_object_free(obj);
-	git_object_free(commit);
+	(*out)->remote_url = git__strdup(remote_url);
+	GITERR_CHECK_ALLOC((*out)->remote_url);
 
-	return error;
+	return 0;
 }
 
 
@@ -187,8 +205,9 @@ void git_annotated_commit_free(git_annotated_commit *annotated_commit)
 		case GIT_ANNOTATED_COMMIT_REAL:
 			git_commit_free(annotated_commit->commit);
 			git_tree_free(annotated_commit->tree);
-			git__free(annotated_commit->ref_name);
-			git__free(annotated_commit->remote_url);
+			git__free((char *)annotated_commit->description);
+			git__free((char *)annotated_commit->ref_name);
+			git__free((char *)annotated_commit->remote_url);
 			break;
 		case GIT_ANNOTATED_COMMIT_VIRTUAL:
 			git_index_free(annotated_commit->index);

data/vendor/libgit2/src/annotated_commit.h

@@ -33,8 +33,11 @@ struct git_annotated_commit {
 	git_index *index;
 	git_array_oid_t parents;
 
-	char *ref_name;
-	char *remote_url;
+	/* how this commit was looked up */
+	const char *description;
+
+	const char *ref_name;
+	const char *remote_url;
 
 	char id_str[GIT_OID_HEXSZ+1];
 };

data/vendor/libgit2/src/array.h

@@ -82,4 +82,44 @@ on_oom:
 
 #define git_array_valid_index(a, i) ((i) < (a).size)
 
+#define git_array_foreach(a, i, element) \
+	for ((i) = 0; (i) < (a).size && ((element) = &(a).ptr[(i)]); (i)++)
+
+
+GIT_INLINE(int) git_array__search(
+	size_t *out,
+	void *array_ptr,
+	size_t item_size,
+	size_t array_len,
+	int (*compare)(const void *, const void *),
+	const void *key)
+{
+	size_t lim;
+	unsigned char *part, *array = array_ptr, *base = array_ptr;
+	int cmp = -1;
+
+	for (lim = array_len; lim != 0; lim >>= 1) {
+		part = base + (lim >> 1) * item_size;
+		cmp = (*compare)(key, part);
+
+		if (cmp == 0) {
+			base = part;
+			break;
+		}
+		if (cmp > 0) { /* key > p; take right partition */
+			base = part + 1 * item_size;
+			lim--;
+		} /* else take left partition */
+	}
+
+	if (out)
+		*out = (base - array) / item_size;
+
+	return (cmp == 0) ? 0 : GIT_ENOTFOUND;
+}
+
+#define git_array_search(out, a, cmp, key) \
+	git_array__search(out, (a).ptr, sizeof(*(a).ptr), (a).size, \
+		(cmp), (key))
+
 #endif

data/vendor/libgit2/src/blame.c

@@ -178,7 +178,7 @@ const git_blame_hunk *git_blame_get_hunk_byline(git_blame *blame, size_t lineno)
 	return NULL;
 }
 
-static void normalize_options(
+static int normalize_options(
 		git_blame_options *out,
 		const git_blame_options *in,
 		git_repository *repo)
@@ -190,7 +190,9 @@ static void normalize_options(
 
 	/* No newest_commit => HEAD */
 	if (git_oid_iszero(&out->newest_commit)) {
-		git_reference_name_to_id(&out->newest_commit, repo, "HEAD");
+		if (git_reference_name_to_id(&out->newest_commit, repo, "HEAD") < 0) {
+			return -1;
+		}
 	}
 
 	/* min_line 0 really means 1 */
@@ -204,6 +206,8 @@ static void normalize_options(
 		out->flags |= GIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVES;
 	if (out->flags & GIT_BLAME_TRACK_COPIES_SAME_COMMIT_MOVES)
 		out->flags |= GIT_BLAME_TRACK_COPIES_SAME_FILE;
+
+	return 0;
 }
 
 static git_blame_hunk *split_hunk_in_vector(
@@ -362,7 +366,8 @@ int git_blame_file(
 	git_blame *blame = NULL;
 
 	assert(out && repo && path);
-	normalize_options(&normOptions, options, repo);
+	if ((error = normalize_options(&normOptions, options, repo)) < 0)
+		goto on_error;
 
 	blame = git_blame__alloc(repo, normOptions, path);
 	GITERR_CHECK_ALLOC(blame);