rugged 0.22.0b5 → 0.22.1b1

data/ext/rugged/rugged_revwalk.c

@@ -227,8 +227,7 @@ static VALUE rb_git_walker_push_range(VALUE self, VALUE range)
 {
 	git_revwalk *walk;
 	Data_Get_Struct(self, git_revwalk, walk);
-	int error = git_revwalk_push_range(walk, StringValuePtr(range));
-	rugged_exception_check(error);
+	rugged_exception_check(git_revwalk_push_range(walk, StringValueCStr(range)));
 	return Qnil;
 }
 

data/ext/rugged/rugged_submodule.c

@@ -862,7 +862,7 @@ static VALUE rb_git_submodule_update_rule(VALUE self)
 	git_submodule_update_t update;
 
 	Data_Get_Struct(self, git_submodule, submodule);
-	update = git_submodule_update(submodule);
+	update = git_submodule_update_strategy(submodule);
 
 	return rb_git_subm_update_rule_fromC(update);
 }

data/ext/rugged/rugged_tree.c

@@ -93,6 +93,69 @@ static VALUE rb_git_tree_entrycount(VALUE self)
 	return INT2FIX(git_tree_entrycount(tree));
 }
 
+struct rugged_treecount_cb_payload
+{
+	int count;
+	int limit;
+};
+
+static int rugged__treecount_cb(const char *root, const git_tree_entry *entry, void *data)
+{
+	struct rugged_treecount_cb_payload *payload = data;
+
+	if (payload->limit >= 0 && payload->count >= payload->limit) {
+		return -1;
+	} else if(git_tree_entry_type(entry) == GIT_OBJ_TREE) {
+		return 0;
+	} else {
+		++(payload->count);
+		return 1;
+	}
+}
+
+/*
+ *  call-seq:
+ *    tree.count_recursive(limit=nil) -> count
+ *
+ *  `limit` - The maximum number of blobs to the count in the repository.
+ *  Rugged will stop walking the tree after `limit` items to avoid long
+ *  execution times.
+ *
+ *  Return the number of blobs (up to the limit) contained in the tree and
+ *  all subtrees.
+ */
+static VALUE rb_git_tree_entrycount_recursive(int argc, VALUE* argv, VALUE self)
+{
+	git_tree *tree;
+	int error;
+	struct rugged_treecount_cb_payload payload;
+	VALUE rb_limit;
+
+	Data_Get_Struct(self, git_tree, tree);
+
+	rb_scan_args(argc, argv, "01", &rb_limit);
+
+	payload.limit = -1;
+	payload.count = 0;
+
+	if (!NIL_P(rb_limit)) {
+		Check_Type(rb_limit, T_FIXNUM);
+		payload.limit = FIX2INT(rb_limit);
+	}
+
+
+	error = git_tree_walk(tree, GIT_TREEWALK_PRE, &rugged__treecount_cb, (void *)&payload);
+
+	if (error && giterr_last()->klass == GITERR_CALLBACK) {
+		giterr_clear();
+		error = 0;
+	}
+
+	rugged_exception_check(error);
+
+	return INT2FIX(payload.count);
+}
+
 /*
  *  call-seq:
  *    tree[e] -> entry
@@ -631,13 +694,13 @@ static void rb_git_treebuilder_free(git_treebuilder *bld)
 
 /*
  *  call-seq:
- *    TreeBuilder.new(repository, [tree])
+ *    Tree::Builder.new(repository, [tree])
  *
- *  Create a new Rugged::Trebuilder instance to write a tree to
+ *  Create a new Rugged::Tree::Builder instance to write a tree to
  *  the given +repository+.
  *
- *  If an optional +tree+ is given, the returned TreeBuilder will be
- *  initialized with the entry of +tree+. Otherwise, the TreeBuilder
+ *  If an optional +tree+ is given, the returned Tree::Builder will be
+ *  initialized with the entry of +tree+. Otherwise, the Tree::Builder
  *  will be empty and has to be filled manually.
  */
 static VALUE rb_git_treebuilder_new(int argc, VALUE *argv, VALUE klass)
@@ -658,7 +721,7 @@ static VALUE rb_git_treebuilder_new(int argc, VALUE *argv, VALUE klass)
 	rugged_check_repo(rb_repo);
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
-	error = git_treebuilder_create(&builder, repo, tree);
+	error = git_treebuilder_new(&builder, repo, tree);
 	rugged_exception_check(error);
 
 	rb_builder = Data_Wrap_Struct(klass, NULL, &rb_git_treebuilder_free, builder);
@@ -813,6 +876,7 @@ void Init_rugged_tree(void)
 	 */
 	rb_cRuggedTree = rb_define_class_under(rb_mRugged, "Tree", rb_cRuggedObject);
 	rb_define_method(rb_cRuggedTree, "count", rb_git_tree_entrycount, 0);
+	rb_define_method(rb_cRuggedTree, "count_recursive", rb_git_tree_entrycount_recursive, -1);
 	rb_define_method(rb_cRuggedTree, "length", rb_git_tree_entrycount, 0);
 	rb_define_method(rb_cRuggedTree, "get_entry", rb_git_tree_get_entry, 1);
 	rb_define_method(rb_cRuggedTree, "get_entry_by_oid", rb_git_tree_get_entry_by_oid, 1);

data/lib/rugged/version.rb

@@ -1,3 +1,3 @@
 module Rugged
-  Version = VERSION = '0.22.0b5'
+  Version = VERSION = '0.22.1b1'
 end

data/vendor/libgit2/CMakeLists.txt

@@ -19,6 +19,7 @@ SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Mo
 
 INCLUDE(CheckLibraryExists)
 INCLUDE(AddCFlagIfSupported)
+INCLUDE(FindPkgConfig)
 
 # Build options
 #
@@ -212,7 +213,7 @@ ENDIF()
 
 # Optional external dependency: libssh2
 IF (USE_SSH)
-	FIND_PACKAGE(LIBSSH2)
+	PKG_CHECK_MODULES(LIBSSH2 libssh2)
 ENDIF()
 IF (LIBSSH2_FOUND)
 	ADD_DEFINITIONS(-DGIT_SSH)

data/vendor/libgit2/include/git2.h

@@ -57,7 +57,6 @@
 #include "git2/status.h"
 #include "git2/submodule.h"
 #include "git2/tag.h"
-#include "git2/threads.h"
 #include "git2/transport.h"
 #include "git2/tree.h"
 #include "git2/types.h"

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

@@ -104,6 +104,11 @@ GIT_BEGIN_DECL
  *   overwritten.  Normally, files that are ignored in the working directory
  *   are not considered "precious" and may be overwritten if the checkout
  *   target contains that file.
+ *
+ * - GIT_CHECKOUT_DONT_REMOVE_EXISTING prevents checkout from removing
+ *   files or folders that fold to the same name on case insensitive
+ *   filesystems.  This can cause files to retain their existing names
+ *   and write through existing symbolic links.
  */
 typedef enum {
 	GIT_CHECKOUT_NONE = 0, /**< default is a dry run, no actual updates */
@@ -158,6 +163,9 @@ typedef enum {
 	/** Include common ancestor data in diff3 format files for conflicts */
 	GIT_CHECKOUT_CONFLICT_STYLE_DIFF3 = (1u << 21),
 
+	/** Don't overwrite existing files or folders */
+	GIT_CHECKOUT_DONT_REMOVE_EXISTING = (1u << 22),
+
 	/**
 	 * THE FOLLOWING OPTIONS ARE NOT YET IMPLEMENTED
 	 */

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

@@ -479,6 +479,10 @@ GIT_EXTERN(int) git_merge_trees(
  * or checked out.  If the index is to be converted to a tree, the caller
  * should resolve any conflicts that arose as part of the merge.
  *
+ * The merge performed uses the first common ancestor, unlike the
+ * `git-merge-recursive` strategy, which may produce an artificial common
+ * ancestor tree when there are multiple ancestors.
+ *
  * The returned index must be freed explicitly with `git_index_free`.
  *
  * @param out pointer to store the index result in
@@ -501,6 +505,10 @@ GIT_EXTERN(int) git_merge_commits(
  * to the index.  Callers should inspect the repository's index after this
  * completes, resolve any conflicts and prepare a commit.
  *
+ * The merge performed uses the first common ancestor, unlike the
+ * `git-merge-recursive` strategy, which may produce an artificial common
+ * ancestor tree when there are multiple ancestors.
+ *
  * For compatibility with git, the repository is put into a merging
  * state. Once the commit is done (or if the uses wishes to abort),
  * you should clear this state by calling

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

@@ -59,116 +59,6 @@ typedef int (*git_push_transfer_progress)(
 	size_t bytes,
 	void* payload);
 
-/**
- * Create a new push object
- *
- * @param out New push object
- * @param remote Remote instance
- *
- * @return 0 or an error code
- */
-GIT_EXTERN(int) git_push_new(git_push **out, git_remote *remote);
-
-/**
- * Set options on a push object
- *
- * @param push The push object
- * @param opts The options to set on the push object
- *
- * @return 0 or an error code
- */
-GIT_EXTERN(int) git_push_set_options(
-	git_push *push,
-	const git_push_options *opts);
-
-/**
- * Set the callbacks for a push
- *
- * @param push The push object
- * @param pack_progress_cb Function to call with progress information during
- * pack building. Be aware that this is called inline with pack building
- * operations, so performance may be affected.
- * @param pack_progress_cb_payload Payload for the pack progress callback.
- * @param transfer_progress_cb Function to call with progress information during
- * the upload portion of a push. Be aware that this is called inline with
- * pack building operations, so performance may be affected.
- * @param transfer_progress_cb_payload Payload for the network progress callback.
- * @return 0 or an error code
- */
-GIT_EXTERN(int) git_push_set_callbacks(
-	git_push *push,
-	git_packbuilder_progress pack_progress_cb,
-	void *pack_progress_cb_payload,
-	git_push_transfer_progress transfer_progress_cb,
-	void *transfer_progress_cb_payload);
-
-/**
- * Add a refspec to be pushed
- *
- * @param push The push object
- * @param refspec Refspec string
- *
- * @return 0 or an error code
- */
-GIT_EXTERN(int) git_push_add_refspec(git_push *push, const char *refspec);
-
-/**
- * Update remote tips after a push
- *
- * @param push The push object
- * @param signature The identity to use when updating reflogs
- * @param reflog_message The message to insert into the reflogs. If NULL, the
- *                       default is "update by push".
- *
- * @return 0 or an error code
- */
-GIT_EXTERN(int) git_push_update_tips(
-		git_push *push,
-		const git_signature *signature,
-		const char *reflog_message);
-
-/**
- * Perform the push
- *
- * This function will return an error in case of a protocol error or
- * the server being unable to unpack the data we sent.
- *
- * The return value does not reflect whether the server accepted or
- * refused any reference updates. Use `git_push_status_foreach()` in
- * order to find out which updates were accepted or rejected.
- *
- * @param push The push object
- *
- * @return 0 or an error code
- */
-GIT_EXTERN(int) git_push_finish(git_push *push);
-
-/**
- * Invoke callback `cb' on each status entry
- *
- * For each of the updated references, we receive a status report in the
- * form of `ok refs/heads/master` or `ng refs/heads/master <msg>`.
- * `msg != NULL` means the reference has not been updated for the given
- * reason.
- *
- * Return a non-zero value from the callback to stop the loop.
- *
- * @param push The push object
- * @param cb The callback to call on each object
- *
- * @return 0 on success, non-zero callback return value, or error code
- */
-GIT_EXTERN(int) git_push_status_foreach(git_push *push,
-			int (*cb)(const char *ref, const char *msg, void *data),
-			void *data);
-
-/**
- * Free the given push object
- *
- * @param push The push object
- */
-GIT_EXTERN(void) git_push_free(git_push *push);
-
 /** @} */
 GIT_END_DECL
 #endif

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

@@ -319,6 +319,19 @@ GIT_EXTERN(int) git_remote_ls(const git_remote_head ***out,  size_t *size, git_r
  */
 GIT_EXTERN(int) git_remote_download(git_remote *remote, const git_strarray *refspecs);
 
+/**
+ * Create a packfile and send it to the server
+ *
+ * Connect to the remote if it hasn't been done yet, negotiate with
+ * the remote git which objects are missing, create a packfile with the missing objects and send it.
+ *
+ * @param remote the remote
+ * @param refspecs the refspecs to use for this negotiation and
+ * upload. Use NULL or an empty array to use the base refspecs
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_remote_upload(git_remote *remote, const git_strarray *refspecs, const git_push_options *opts);
+
 /**
  * Check whether the remote is connected
  *
@@ -374,6 +387,14 @@ GIT_EXTERN(int) git_remote_update_tips(
 		const git_signature *signature,
 		const char *reflog_message);
 
+/**
+ * Prune tracking refs that are no longer present on remote
+ *
+ * @param remote the remote to prune
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_remote_prune(git_remote *remote);
+
 /**
  * Download new data and update tips
  *
@@ -407,7 +428,7 @@ GIT_EXTERN(int) git_remote_fetch(
  * @param reflog_message message to use for the reflog of upated references
  */
 GIT_EXTERN(int) git_remote_push(git_remote *remote,
-				git_strarray *refspecs,
+				const git_strarray *refspecs,
 				const git_push_options *opts,
 				const git_signature *signature, const char *reflog_message);
 
@@ -584,6 +605,14 @@ GIT_EXTERN(void) git_remote_set_autotag(
 	git_remote *remote,
 	git_remote_autotag_option_t value);
 
+/**
+ * Retrieve the ref-prune setting
+ *
+ * @param remote the remote to query
+ * @return the ref-prune setting
+ */
+GIT_EXTERN(int) git_remote_prune_refs(const git_remote *remote);
+
 /**
  * Give the remote a new name
  *

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

@@ -71,7 +71,7 @@ GIT_EXTERN(int) git_revert_commit(
 	const git_merge_options *merge_options);
 
 /**
- * Reverts the given commit, producing changes in the working directory.
+ * Reverts the given commit, producing changes in the index and working directory.
  *
  * @param repo the repository to revert
  * @param commit the commit to revert

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

@@ -10,6 +10,8 @@
 #include "common.h"
 #include "types.h"
 #include "oid.h"
+#include "remote.h"
+#include "checkout.h"
 
 /**
  * @file git2/submodule.h
@@ -105,6 +107,83 @@ typedef enum {
 	GIT_SUBMODULE_STATUS_WD_WD_MODIFIED | \
 	GIT_SUBMODULE_STATUS_WD_UNTRACKED)) != 0)
 
+/**
+ * Submodule update options structure
+ *
+ * Use the GIT_SUBMODULE_UPDATE_OPTIONS_INIT to get the default settings,
+ * like this:
+ *
+ * git_submodule_update_options opts = GIT_SUBMODULE_UPDATE_OPTIONS_INIT;
+ */
+typedef struct git_submodule_update_options {
+	unsigned int version;
+
+	/**
+	 * These options are passed to the checkout step. To disable
+	 * checkout, set the `checkout_strategy` to
+	 * `GIT_CHECKOUT_NONE`. Generally you will want the use
+	 * GIT_CHECKOUT_SAFE to update files in the working
+	 * directory. Use the `clone_checkout_strategy` field
+	 * to set the checkout strategy that will be used in
+	 * the case where update needs to clone the repository.
+	 */
+	git_checkout_options checkout_opts;
+
+	/**
+	 * Callbacks to use for reporting fetch progress, and for acquiring
+	 * credentials in the event they are needed.
+	 */
+	git_remote_callbacks remote_callbacks;
+
+	/**
+	 * The checkout strategy to use when the sub repository needs to
+	 * be cloned. Use GIT_CHECKOUT_SAFE_CREATE to create all files
+	 * in the working directory for the newly cloned repository.
+	 */
+	unsigned int clone_checkout_strategy;
+
+	/**
+	 * The identity used when updating the reflog. NULL means to
+	 * use the default signature using the config.
+	 */
+	git_signature *signature;
+} git_submodule_update_options;
+
+#define GIT_SUBMODULE_UPDATE_OPTIONS_VERSION 1
+#define GIT_SUBMODULE_UPDATE_OPTIONS_INIT \
+	{ GIT_CHECKOUT_OPTIONS_VERSION, \
+		{ GIT_CHECKOUT_OPTIONS_VERSION, GIT_CHECKOUT_SAFE}, \
+	GIT_REMOTE_CALLBACKS_INIT, GIT_CHECKOUT_SAFE_CREATE }
+
+/**
+ * Initializes a `git_submodule_update_options` with default values.
+ * Equivalent to creating an instance with GIT_SUBMODULE_UPDATE_OPTIONS_INIT.
+ *
+ * @param opts The `git_submodule_update_options` instance to initialize.
+ * @param version Version of struct; pass `GIT_SUBMODULE_UPDATE_OPTIONS_VERSION`
+ * @return Zero on success; -1 on failure.
+ */
+GIT_EXTERN(int) git_submodule_update_init_options(
+	git_submodule_update_options *opts, unsigned int version);
+
+/**
+ * Update a submodule. This will clone a missing submodule and
+ * checkout the subrepository to the commit specified in the index of
+ * containing repository.
+ *
+ * @param submodule Submodule object
+ * @param init If the submodule is not initialized, setting this flag to true
+ *        will initialize the submodule before updating. Otherwise, this will
+ *        return an error if attempting to update an uninitialzed repository.
+ *        but setting this to true forces them to be updated.
+ * @param options configuration options for the update.  If NULL, the
+ *        function works as though GIT_SUBMODULE_UPDATE_OPTIONS_INIT was passed.
+ * @return 0 on success, any non-zero return value from a callback
+ *         function, or a negative value to indicate an error (use
+ *         `giterr_last` for a detailed error message).
+ */
+GIT_EXTERN(int) git_submodule_update(git_submodule *submodule, int init, git_submodule_update_options *options);
+
 /**
  * Lookup submodule information by name or path.
  *
@@ -403,7 +482,7 @@ GIT_EXTERN(git_submodule_ignore_t) git_submodule_set_ignore(
  * @return The current git_submodule_update_t value that will be used
  *         for this submodule.
  */
-GIT_EXTERN(git_submodule_update_t) git_submodule_update(
+GIT_EXTERN(git_submodule_update_t) git_submodule_update_strategy(
 	git_submodule *submodule);
 
 /**