rugged 0.24.6.1 → 0.25.0

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

@@ -83,6 +83,17 @@ struct git_odb_backend {
 		git_odb_writepack **, git_odb_backend *, git_odb *odb,
 		git_transfer_progress_cb progress_cb, void *progress_payload);
 
+	/**
+	 * "Freshens" an already existing object, updating its last-used
+	 * time.  This occurs when `git_odb_write` was called, but the
+	 * object already existed (and will not be re-written).  The
+	 * underlying implementation may want to update last-used timestamps.
+	 *
+	 * If callers implement this, they should return `0` if the object
+	 * exists and was freshened, and non-zero otherwise.
+	 */
+	int (* freshen)(git_odb_backend *, const git_oid *);
+
 	/**
 	 * Frees any resources held by the odb (including the `git_odb_backend`
 	 * itself). An odb backend implementation must provide this function.

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

@@ -0,0 +1,16 @@
+/*
+ * 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_sys_git_transport_h
+#define INCLUDE_sys_git_transport_h
+
+#include "git2/net.h"
+#include "git2/types.h"
+
+GIT_BEGIN_DECL
+
+GIT_END_DECL

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/time.h

@@ -0,0 +1,31 @@
+/*
+ * 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_git_time_h__
+#define INCLUDE_git_time_h__
+
+#include "git2/common.h"
+
+GIT_BEGIN_DECL
+
+/**
+ * Return a monotonic time value, useful for measuring running time
+ * and setting up timeouts.
+ *
+ * The returned value is an arbitrary point in time -- it can only be
+ * used when comparing it to another `git_time_monotonic` call.
+ *
+ * The time is returned in seconds, with a decimal fraction that differs
+ * on accuracy based on the underlying system, but should be least
+ * accurate to Nanoseconds.
+ *
+ * This function cannot fail.
+ */
+GIT_EXTERN(double) git_time_monotonic(void);
+
+GIT_END_DECL
+#endif
+

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/transaction.h

@@ -8,6 +8,14 @@
 #define INCLUDE_git_transaction_h__
 
 #include "common.h"
+
+/**
+ * @file git2/transaction.h
+ * @brief Git transactional reference routines
+ * @defgroup git_transaction Git transactional reference routines
+ * @ingroup Git
+ * @{
+ */
 GIT_BEGIN_DECL
 
 /**
@@ -107,5 +115,6 @@ GIT_EXTERN(int) git_transaction_commit(git_transaction *tx);
  */
 GIT_EXTERN(void) git_transaction_free(git_transaction *tx);
 
+/** @} */
 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/include/git2/version.h

@@ -7,12 +7,12 @@
 #ifndef INCLUDE_git_version_h__
 #define INCLUDE_git_version_h__
 
-#define LIBGIT2_VERSION "0.24.6"
+#define LIBGIT2_VERSION "0.25.0"
 #define LIBGIT2_VER_MAJOR 0
-#define LIBGIT2_VER_MINOR 24
-#define LIBGIT2_VER_REVISION 6
+#define LIBGIT2_VER_MINOR 25
+#define LIBGIT2_VER_REVISION 0
 #define LIBGIT2_VER_PATCH 0
 
-#define LIBGIT2_SOVERSION 24
+#define LIBGIT2_SOVERSION 25
 
 #endif

data/vendor/libgit2/include/git2.h

@@ -40,6 +40,7 @@
 #include "git2/pack.h"
 #include "git2/patch.h"
 #include "git2/pathspec.h"
+#include "git2/proxy.h"
 #include "git2/rebase.h"
 #include "git2/refdb.h"
 #include "git2/reflog.h"

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];
 };