rugged 0.27.10 → 0.27.10.1

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

@@ -23,61 +23,61 @@
 GIT_BEGIN_DECL
 
 /**
- * Instantiate a new mempack backend.
+ *	Instantiate a new mempack backend.
  *
- * The backend must be added to an existing ODB with the highest
- * priority.
+ *	The backend must be added to an existing ODB with the highest
+ *	priority.
  *
- *     git_mempack_new(&mempacker);
- *     git_repository_odb(&odb, repository);
- *     git_odb_add_backend(odb, mempacker, 999);
+ *		git_mempack_new(&mempacker);
+ *		git_repository_odb(&odb, repository);
+ *		git_odb_add_backend(odb, mempacker, 999);
  *
- * Once the backend has been loaded, all writes to the ODB will
- * instead be queued in memory, and can be finalized with
- * `git_mempack_dump`.
+ *	Once the backend has been loaded, all writes to the ODB will
+ *	instead be queued in memory, and can be finalized with
+ *	`git_mempack_dump`.
  *
- * Subsequent reads will also be served from the in-memory store
- * to ensure consistency, until the memory store is dumped.
+ *	Subsequent reads will also be served from the in-memory store
+ *	to ensure consistency, until the memory store is dumped.
  *
- * @param out Pointer where to store the ODB backend
- * @return 0 on success; error code otherwise
+ *	@param out Pointer where to store the ODB backend
+ *	@return 0 on success; error code otherwise
  */
 GIT_EXTERN(int) git_mempack_new(git_odb_backend **out);
 
 /**
- * Dump all the queued in-memory writes to a packfile.
+ *	Dump all the queued in-memory writes to a packfile.
  *
- * The contents of the packfile will be stored in the given buffer.
- * It is the caller's responsibility to ensure that the generated
- * packfile is available to the repository (e.g. by writing it
- * to disk, or doing something crazy like distributing it across
- * several copies of the repository over a network).
+ *	The contents of the packfile will be stored in the given buffer.
+ *	It is the caller's responsibility to ensure that the generated
+ *	packfile is available to the repository (e.g. by writing it
+ *	to disk, or doing something crazy like distributing it across
+ *	several copies of the repository over a network).
  *
- * Once the generated packfile is available to the repository,
- * call `git_mempack_reset` to cleanup the memory store.
+ *	Once the generated packfile is available to the repository,
+ *	call `git_mempack_reset` to cleanup the memory store.
  *
- * Calling `git_mempack_reset` before the packfile has been
- * written to disk will result in an inconsistent repository
- * (the objects in the memory store won't be accessible).
+ *	Calling `git_mempack_reset` before the packfile has been
+ *	written to disk will result in an inconsistent repository
+ *	(the objects in the memory store won't be accessible).
  *
- * @param pack Buffer where to store the raw packfile
- * @param repo The active repository where the backend is loaded
- * @param backend The mempack backend
- * @return 0 on success; error code otherwise
+ *	@param pack Buffer where to store the raw packfile
+ *	@param repo The active repository where the backend is loaded
+ *	@param backend The mempack backend
+ *	@return 0 on success; error code otherwise
  */
 GIT_EXTERN(int) git_mempack_dump(git_buf *pack, git_repository *repo, git_odb_backend *backend);
 
 /**
- * Reset the memory packer by clearing all the queued objects.
+ *	Reset the memory packer by clearing all the queued objects.
  *
- * This assumes that `git_mempack_dump` has been called before to
- * store all the queued objects into a single packfile.
+ *	This assumes that `git_mempack_dump` has been called before to
+ *	store all the queued objects into a single packfile.
  *
- * Alternatively, call `reset` without a previous dump to "undo"
- * all the recently written objects, giving transaction-like
- * semantics to the Git repository.
+ *	Alternatively, call `reset` without a previous dump to "undo"
+ *	all the recently written objects, giving transaction-like
+ *	semantics to the Git repository.
  *
- * @param backend The mempack backend
+ *	@param backend The mempack backend
  */
 GIT_EXTERN(void) git_mempack_reset(git_odb_backend *backend);
 

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

@@ -7,15 +7,10 @@
 #ifndef INCLUDE_sys_git_merge_h__
 #define INCLUDE_sys_git_merge_h__
 
-#include "git2/common.h"
-#include "git2/types.h"
-#include "git2/index.h"
-#include "git2/merge.h"
-
 /**
  * @file git2/sys/merge.h
  * @brief Git merge driver backend and plugin routines
- * @defgroup git_merge Git merge driver APIs
+ * @defgroup git_backend Git custom backend APIs
  * @ingroup Git
  * @{
  */
@@ -73,7 +68,7 @@ GIT_EXTERN(const git_merge_file_options *) git_merge_driver_source_file_options(
  * initialization operations (in case libgit2 is being used in a way that
  * doesn't need the merge driver).
  */
-typedef int GIT_CALLBACK(git_merge_driver_init_fn)(git_merge_driver *self);
+typedef int (*git_merge_driver_init_fn)(git_merge_driver *self);
 
 /**
  * Shutdown callback on merge driver
@@ -85,7 +80,7 @@ typedef int GIT_CALLBACK(git_merge_driver_init_fn)(git_merge_driver *self);
  *
  * Typically this function will free the `git_merge_driver` object itself.
  */
-typedef void GIT_CALLBACK(git_merge_driver_shutdown_fn)(git_merge_driver *self);
+typedef void (*git_merge_driver_shutdown_fn)(git_merge_driver *self);
 
 /**
  * Callback to perform the merge.
@@ -105,7 +100,7 @@ typedef void GIT_CALLBACK(git_merge_driver_shutdown_fn)(git_merge_driver *self);
  *
  * The `src` contains the data about the file to be merged.
  */
-typedef int GIT_CALLBACK(git_merge_driver_apply_fn)(
+typedef int (*git_merge_driver_apply_fn)(
 	git_merge_driver *self,
 	const char **path_out,
 	uint32_t *mode_out,

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

@@ -30,39 +30,39 @@ struct git_odb_backend {
 
 	/* read and read_prefix each return to libgit2 a buffer which
 	 * will be freed later. The buffer should be allocated using
-	 * the function git_odb_backend_data_alloc to ensure that libgit2
-	 * can safely free it later. */
-	int GIT_CALLBACK(read)(
-		void **, size_t *, git_object_t *, git_odb_backend *, const git_oid *);
+	 * the function git_odb_backend_malloc to ensure that it can
+	 * be safely freed later. */
+	int (* read)(
+		void **, size_t *, git_otype *, git_odb_backend *, const git_oid *);
 
 	/* To find a unique object given a prefix of its oid.  The oid given
 	 * must be so that the remaining (GIT_OID_HEXSZ - len)*4 bits are 0s.
 	 */
-	int GIT_CALLBACK(read_prefix)(
-		git_oid *, void **, size_t *, git_object_t *,
+	int (* read_prefix)(
+		git_oid *, void **, size_t *, git_otype *,
 		git_odb_backend *, const git_oid *, size_t);
 
-	int GIT_CALLBACK(read_header)(
-		size_t *, git_object_t *, git_odb_backend *, const git_oid *);
+	int (* read_header)(
+		size_t *, git_otype *, git_odb_backend *, const git_oid *);
 
 	/**
 	 * Write an object into the backend. The id of the object has
 	 * already been calculated and is passed in.
 	 */
-	int GIT_CALLBACK(write)(
-		git_odb_backend *, const git_oid *, const void *, size_t, git_object_t);
+	int (* write)(
+		git_odb_backend *, const git_oid *, const void *, size_t, git_otype);
 
-	int GIT_CALLBACK(writestream)(
-		git_odb_stream **, git_odb_backend *, git_object_size_t, git_object_t);
+	int (* writestream)(
+		git_odb_stream **, git_odb_backend *, git_off_t, git_otype);
 
-	int GIT_CALLBACK(readstream)(
-		git_odb_stream **, size_t *, git_object_t *,
+	int (* readstream)(
+		git_odb_stream **, size_t *, git_otype *,
 		git_odb_backend *, const git_oid *);
 
-	int GIT_CALLBACK(exists)(
+	int (* exists)(
 		git_odb_backend *, const git_oid *);
 
-	int GIT_CALLBACK(exists_prefix)(
+	int (* exists_prefix)(
 		git_oid *, git_odb_backend *, const git_oid *, size_t);
 
 	/**
@@ -75,14 +75,14 @@ struct git_odb_backend {
 	 * implementation to achieve this could be to internally invoke this
 	 * endpoint on failed lookups (ie. `exists()`, `read()`, `read_header()`).
 	 */
-	int GIT_CALLBACK(refresh)(git_odb_backend *);
+	int (* refresh)(git_odb_backend *);
 
-	int GIT_CALLBACK(foreach)(
+	int (* foreach)(
 		git_odb_backend *, git_odb_foreach_cb cb, void *payload);
 
-	int GIT_CALLBACK(writepack)(
+	int (* writepack)(
 		git_odb_writepack **, git_odb_backend *, git_odb *odb,
-		git_indexer_progress_cb progress_cb, void *progress_payload);
+		git_transfer_progress_cb progress_cb, void *progress_payload);
 
 	/**
 	 * "Freshens" an already existing object, updating its last-used
@@ -93,13 +93,13 @@ struct git_odb_backend {
 	 * If callers implement this, they should return `0` if the object
 	 * exists and was freshened, and non-zero otherwise.
 	 */
-	int GIT_CALLBACK(freshen)(git_odb_backend *, const git_oid *);
+	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.
 	 */
-	void GIT_CALLBACK(free)(git_odb_backend *);
+	void (* free)(git_odb_backend *);
 };
 
 #define GIT_ODB_BACKEND_VERSION 1
@@ -117,52 +117,8 @@ GIT_EXTERN(int) git_odb_init_backend(
 	git_odb_backend *backend,
 	unsigned int version);
 
-/**
- * Allocate data for an ODB object.  Custom ODB backends may use this
- * to provide data back to the ODB from their read function.  This
- * memory should not be freed once it is returned to libgit2.  If a
- * custom ODB uses this function but encounters an error and does not
- * return this data to libgit2, then they should use the corresponding
- * git_odb_backend_data_free function.
- *
- * @param backend the ODB backend that is allocating this memory
- * @param len the number of bytes to allocate
- * @return the allocated buffer on success or NULL if out of memory
- */
-GIT_EXTERN(void *) git_odb_backend_data_alloc(git_odb_backend *backend, size_t len);
-
-/**
- * Frees custom allocated ODB data.  This should only be called when
- * memory allocated using git_odb_backend_data_alloc is not returned
- * to libgit2 because the backend encountered an error in the read
- * function after allocation and did not return this data to libgit2.
- *
- * @param backend the ODB backend that is freeing this memory
- * @param data the buffer to free
- */
-GIT_EXTERN(void) git_odb_backend_data_free(git_odb_backend *backend, void *data);
-
-
-/*
- * Users can avoid deprecated functions by defining `GIT_DEPRECATE_HARD`.
- */
-#ifndef GIT_DEPRECATE_HARD
-
-/**
- * Allocate memory for an ODB object from a custom backend.  This is
- * an alias of `git_odb_backend_data_alloc` and is preserved for
- * backward compatibility.
- *
- * This function is deprecated, but there is no plan to remove this
- * function at this time.
- *
- * @deprecated git_odb_backend_data_alloc
- * @see git_odb_backend_data_alloc
- */
 GIT_EXTERN(void *) git_odb_backend_malloc(git_odb_backend *backend, size_t len);
 
-#endif
-
 GIT_END_DECL
 
 #endif

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

@@ -38,44 +38,42 @@ struct git_reference_iterator {
 	/**
 	 * Return the current reference and advance the iterator.
 	 */
-	int GIT_CALLBACK(next)(
+	int (*next)(
 		git_reference **ref,
 		git_reference_iterator *iter);
 
 	/**
 	 * Return the name of the current reference and advance the iterator
 	 */
-	int GIT_CALLBACK(next_name)(
+	int (*next_name)(
 		const char **ref_name,
 		git_reference_iterator *iter);
 
 	/**
 	 * Free the iterator
 	 */
-	void GIT_CALLBACK(free)(
+	void (*free)(
 		git_reference_iterator *iter);
 };
 
 /** An instance for a custom backend */
 struct git_refdb_backend {
-	unsigned int version; /**< The backend API version */
+	unsigned int version;
 
 	/**
-	 * Queries the refdb backend for the existence of a reference.
-	 *
-	 * A refdb implementation must provide this function.
+	 * Queries the refdb backend to determine if the given ref_name
+	 * exists.  A refdb implementation must provide this function.
 	 */
-	int GIT_CALLBACK(exists)(
+	int (*exists)(
 		int *exists,
 		git_refdb_backend *backend,
 		const char *ref_name);
 
 	/**
-	 * Queries the refdb backend for a given reference.
-	 *
-	 * A refdb implementation must provide this function.
+	 * Queries the refdb backend for a given reference.  A refdb
+	 * implementation must provide this function.
 	 */
-	int GIT_CALLBACK(lookup)(
+	int (*lookup)(
 		git_reference **out,
 		git_refdb_backend *backend,
 		const char *ref_name);
@@ -85,123 +83,89 @@ struct git_refdb_backend {
 	 *
 	 * A refdb implementation must provide this function.
 	 */
-	int GIT_CALLBACK(iterator)(
+	int (*iterator)(
 		git_reference_iterator **iter,
 		struct git_refdb_backend *backend,
 		const char *glob);
 
-	/**
-	 * Writes the given reference to the refdb.
-	 *
-	 * A refdb implementation must provide this function.
+	/*
+	 * Writes the given reference to the refdb.  A refdb implementation
+	 * must provide this function.
 	 */
-	int GIT_CALLBACK(write)(git_refdb_backend *backend,
+	int (*write)(git_refdb_backend *backend,
 		     const git_reference *ref, int force,
 		     const git_signature *who, const char *message,
 		     const git_oid *old, const char *old_target);
 
-	/**
-	 * Rename a reference in the refdb.
-	 *
-	 * A refdb implementation must provide this function.
-	 */
-	int GIT_CALLBACK(rename)(
+	int (*rename)(
 		git_reference **out, git_refdb_backend *backend,
 		const char *old_name, const char *new_name, int force,
 		const git_signature *who, const char *message);
 
 	/**
-	 * Deletes the given reference from the refdb.
-	 *
-	 * If it exists, its reflog should be deleted as well.
-	 *
-	 * A refdb implementation must provide this function.
+	 * Deletes the given reference (and if necessary its reflog)
+	 * from the refdb.  A refdb implementation must provide this
+	 * function.
 	 */
-	int GIT_CALLBACK(del)(git_refdb_backend *backend, const char *ref_name, const git_oid *old_id, const char *old_target);
+	int (*del)(git_refdb_backend *backend, const char *ref_name, const git_oid *old_id, const char *old_target);
 
 	/**
 	 * Suggests that the given refdb compress or optimize its references.
-	 *
-	 * This mechanism is implementation specific. For on-disk reference
-	 * databases, this may pack all loose references.
-	 *
-	 * A refdb implementation may provide this function; if it is not
-	 * provided, nothing will be done.
+	 * This mechanism is implementation specific.  (For on-disk reference
+	 * databases, this may pack all loose references.)    A refdb
+	 * implementation may provide this function; if it is not provided,
+	 * nothing will be done.
 	 */
-	int GIT_CALLBACK(compress)(git_refdb_backend *backend);
+	int (*compress)(git_refdb_backend *backend);
 
 	/**
 	 * Query whether a particular reference has a log (may be empty)
-	 *
-	 * A refdb implementation must provide this function.
 	 */
-	int GIT_CALLBACK(has_log)(git_refdb_backend *backend, const char *refname);
+	int (*has_log)(git_refdb_backend *backend, const char *refname);
 
 	/**
 	 * Make sure a particular reference will have a reflog which
 	 * will be appended to on writes.
-	 *
-	 * A refdb implementation must provide this function.
 	 */
-	int GIT_CALLBACK(ensure_log)(git_refdb_backend *backend, const char *refname);
+	int (*ensure_log)(git_refdb_backend *backend, const char *refname);
 
 	/**
 	 * Frees any resources held by the refdb (including the `git_refdb_backend`
-	 * itself).
-	 *
-	 * A refdb backend implementation must provide this function.
+	 * itself). A refdb backend implementation must provide this function.
 	 */
-	void GIT_CALLBACK(free)(git_refdb_backend *backend);
+	void (*free)(git_refdb_backend *backend);
 
 	/**
 	 * Read the reflog for the given reference name.
-	 *
-	 * A refdb implementation must provide this function.
 	 */
-	int GIT_CALLBACK(reflog_read)(git_reflog **out, git_refdb_backend *backend, const char *name);
+	int (*reflog_read)(git_reflog **out, git_refdb_backend *backend, const char *name);
 
 	/**
 	 * Write a reflog to disk.
-	 *
-	 * A refdb implementation must provide this function.
 	 */
-	int GIT_CALLBACK(reflog_write)(git_refdb_backend *backend, git_reflog *reflog);
+	int (*reflog_write)(git_refdb_backend *backend, git_reflog *reflog);
 
 	/**
-	 * Rename a reflog.
-	 *
-	 * A refdb implementation must provide this function.
+	 * Rename a reflog
 	 */
-	int GIT_CALLBACK(reflog_rename)(git_refdb_backend *_backend, const char *old_name, const char *new_name);
+	int (*reflog_rename)(git_refdb_backend *_backend, const char *old_name, const char *new_name);
 
 	/**
 	 * Remove a reflog.
-	 *
-	 * A refdb implementation must provide this function.
 	 */
-	int GIT_CALLBACK(reflog_delete)(git_refdb_backend *backend, const char *name);
+	int (*reflog_delete)(git_refdb_backend *backend, const char *name);
 
 	/**
-	 * Lock a reference.
-	 *
-	 * The opaque parameter will be passed to the unlock function.
-	 *
-	 * A refdb implementation may provide this function; if it is not
-	 * provided, the transaction API will fail to work.
+	 * Lock a reference. The opaque parameter will be passed to the unlock function
 	 */
-	int GIT_CALLBACK(lock)(void **payload_out, git_refdb_backend *backend, const char *refname);
+	int (*lock)(void **payload_out, git_refdb_backend *backend, const char *refname);
 
 	/**
-	 * Unlock a reference.
-	 *
-	 * Only one of target or symbolic_target will be set.
-	 * `success` will be true if the reference should be update, false if
-	 * the lock must be discarded.
-	 *
-	 * A refdb implementation must provide this function if a `lock`
-	 * implementation is provided.
+	 * Unlock a reference. Only one of target or symbolic_target
+	 * will be set. success indicates whether to update the
+	 * reference or discard the lock (if it's false)
 	 */
-	int GIT_CALLBACK(unlock)(git_refdb_backend *backend, void *payload, int success, int update_reflog,
+	int (*unlock)(git_refdb_backend *backend, void *payload, int success, int update_reflog,
 		      const git_reference *ref, const git_signature *sig, const char *message);
 };