rugged 0.24.0b12 → 0.24.0b13

data/ext/rugged/rugged_reference.c

@@ -41,6 +41,18 @@ VALUE rugged_ref_new(VALUE klass, VALUE owner, git_reference *ref)
 	return rb_ref;
 }
 
+
+const char * rugged_refname_from_string_or_ref(VALUE rb_name_or_ref)
+{
+	if (rb_obj_is_kind_of(rb_name_or_ref, rb_cRuggedReference))
+		rb_name_or_ref = rb_funcall(rb_name_or_ref, rb_intern("canonical_name"), 0);
+
+	if (TYPE(rb_name_or_ref) != T_STRING)
+		rb_raise(rb_eTypeError, "Expecting a String or Rugged::Reference instance");
+
+	return StringValueCStr(rb_name_or_ref);
+}
+
 /*
  *  call-seq:
  *    Reference.valid_name?(ref_name) -> true or false

data/ext/rugged/rugged_repo.c

@@ -1934,7 +1934,7 @@ static int rugged__checkout_notify_cb(
 /**
  * The caller has to free the returned git_checkout_options paths strings array.
  */
-static void rugged_parse_checkout_options(git_checkout_options *opts, VALUE rb_options)
+void rugged_parse_checkout_options(git_checkout_options *opts, VALUE rb_options)
 {
 	VALUE rb_value;
 
@@ -2530,6 +2530,61 @@ static VALUE rb_git_repo_cherrypick(int argc, VALUE *argv, VALUE self)
 	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    repo.cherrypick_commit(commit, our_commit, [mainline, options]) -> nil
+ *
+ *  Cherry-pick the given commit on the given base in-memory and
+ *  return an index with the result.
+ *
+ *  `commit` can be either a string containing a commit id or a
+ *  `Rugged::Commit` object.
+ *
+ *  `our_commit` is the base commit, can be either a string containing
+ *  a commit id or a `Rugged::Commit` object.
+ *
+ *  `mainline` when cherry-picking a merge, this is the parent number
+ *   (starting from 1) which should be considered the mainline.
+ */
+static VALUE rb_git_repo_cherrypick_commit(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_options, rb_commit, rb_our_commit, rb_mainline;
+
+	git_repository *repo;
+	git_commit *commit, *our_commit;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
+	git_index *index;
+	int error, mainline;
+
+	rb_scan_args(argc, argv, "21:", &rb_commit, &rb_our_commit, &rb_mainline, &rb_options);
+
+	if (TYPE(rb_commit) == T_STRING) {
+		rb_commit = rugged_object_rev_parse(self, rb_commit, 1);
+	}
+	if (TYPE(rb_our_commit) == T_STRING) {
+		rb_our_commit = rugged_object_rev_parse(self, rb_our_commit, 1);
+	}
+
+	if (!rb_obj_is_kind_of(rb_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+	if (!rb_obj_is_kind_of(rb_our_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+	Data_Get_Struct(rb_commit, git_commit, commit);
+	Data_Get_Struct(rb_our_commit, git_commit, our_commit);
+
+	rugged_parse_merge_options(&opts, rb_options);
+
+	mainline = NIL_P(rb_mainline) ? 0 : FIX2UINT(rb_mainline);
+	error = git_cherrypick_commit(&index, repo, commit, our_commit, mainline, &opts);
+	rugged_exception_check(error);
+
+	return rugged_index_new(rb_cRuggedIndex, self, index);
+}
+
 void Init_rugged_repo(void)
 {
 	id_call = rb_intern("call");
@@ -2603,6 +2658,7 @@ void Init_rugged_repo(void)
 	rb_define_method(rb_cRuggedRepo, "checkout_head", rb_git_checkout_head, -1);
 
 	rb_define_method(rb_cRuggedRepo, "cherrypick", rb_git_repo_cherrypick, -1);
+	rb_define_method(rb_cRuggedRepo, "cherrypick_commit", rb_git_repo_cherrypick_commit, -1);
 	rb_define_method(rb_cRuggedRepo, "fetch_attributes", rb_git_repo_attributes, -1);
 
 	rb_cRuggedOdbObject = rb_define_class_under(rb_mRugged, "OdbObject", rb_cObject);

data/ext/rugged/rugged_revwalk.c

@@ -190,6 +190,29 @@ static VALUE rb_git_walker_simplify_first_parent(VALUE self)
 	return Qnil;
 }
 
+/*
+ *  call-seq:
+ *    walker.count -> Fixnum
+ *
+ *  Returns the amount of objects a walker iterated over.
+ */
+static VALUE rb_git_walker_count(VALUE self)
+{
+	git_revwalk *walk;
+	git_oid commit_oid;
+	int error = 0;
+	uint64_t count = 0;
+
+	Data_Get_Struct(self, git_revwalk, walk);
+
+	while (((error = git_revwalk_next(&commit_oid, walk)) == 0) && ++count != UINT64_MAX);
+
+	if (error != GIT_ITEROVER)
+		rugged_exception_check(error);
+
+	return ULONG2NUM(count);
+}
+
 /*
  *  call-seq:
  *    walker.reset -> nil
@@ -492,4 +515,5 @@ void Init_rugged_revwalk(void)
 	rb_define_method(rb_cRuggedWalker, "reset", rb_git_walker_reset, 0);
 	rb_define_method(rb_cRuggedWalker, "sorting", rb_git_walker_sorting, 1);
 	rb_define_method(rb_cRuggedWalker, "simplify_first_parent", rb_git_walker_simplify_first_parent, 0);
+	rb_define_method(rb_cRuggedWalker, "count", rb_git_walker_count, 0);
 }

data/lib/rugged/commit.rb

@@ -9,6 +9,10 @@ module Rugged
       "#<Rugged::Commit:#{object_id} {message: #{message.inspect}, tree: #{tree.inspect}, parents: #{parent_oids}}>"
     end
 
+    def header_field?(field)
+      !!header_field(field)
+    end
+
     # Return a diff between this commit and its first parent or another commit or tree.
     #
     # See Rugged::Tree#diff for more details.

data/lib/rugged/tag.rb

@@ -1,5 +1,24 @@
 module Rugged
   class Tag < Rugged::Reference
+    GPG_SIGNATURE_PREFIX = "-----BEGIN PGP SIGNATURE-----".freeze
+
+    def self.extract_signature(repo, oid, prefix=GPG_SIGNATURE_PREFIX)
+      object = repo.read(oid)
+
+      unless object.type == :tag
+        raise GitRPC::InvalidObject, "Invalid object type #{object.type}, expected tag"
+      end
+
+      if index = object.data.index(prefix)
+        [
+          object.data.byteslice(index..-1),
+          object.data.byteslice(0...index)
+        ]
+      else
+        [nil, object.data]
+      end
+    end
+
     def name
       canonical_name.sub(%r{^refs/tags/}, "")
     end

data/lib/rugged/version.rb

@@ -1,3 +1,3 @@
 module Rugged
-  Version = VERSION = '0.24.0b12'
+  Version = VERSION = '0.24.0b13'
 end

data/vendor/libgit2/CMakeLists.txt

@@ -257,7 +257,7 @@ IF (WIN32 AND WINHTTP)
 		LINK_DIRECTORIES(${LIBWINHTTP_PATH})
 	ENDIF ()
 
-	LINK_LIBRARIES(winhttp rpcrt4 crypt32)
+	LINK_LIBRARIES(winhttp rpcrt4 crypt32 ole32)
 	LIST(APPEND LIBGIT2_PC_LIBS "-lwinhttp" "-lrpcrt4" "-lcrypt32" "-lole32")
 ELSE ()
 	IF (CURL)
@@ -340,7 +340,8 @@ IF (LIBSSH2_FOUND)
 	ADD_DEFINITIONS(-DGIT_SSH)
 	INCLUDE_DIRECTORIES(${LIBSSH2_INCLUDE_DIRS})
 	LINK_DIRECTORIES(${LIBSSH2_LIBRARY_DIRS})
-	SET(LIBGIT2_PC_REQUIRES "${LIBGIT2_PC_REQUIRES} libssh2")
+	LIST(APPEND LIBGIT2_PC_LIBS ${LIBSSH2_LDFLAGS})
+	#SET(LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS} ${LIBSSH2_LDFLAGS}")
 	SET(SSH_LIBRARIES ${LIBSSH2_LIBRARIES})
 
 	CHECK_LIBRARY_EXISTS("${LIBSSH2_LIBRARIES}" libssh2_userauth_publickey_frommemory "${LIBSSH2_LIBRARY_DIRS}" HAVE_LIBSSH2_MEMORY_CREDENTIALS)

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

@@ -263,6 +263,18 @@ GIT_EXTERN(int) git_commit_nth_gen_ancestor(
  */
 GIT_EXTERN(int) git_commit_header_field(git_buf *out, const git_commit *commit, const char *field);
 
+/**
+ * Extract the signature from a commit
+ *
+ * @param signature the signature block
+ * @param signed_data signed data; this is the commit contents minus the signature block
+ * @param repo the repository in which the commit exists
+ * @param commit_id the commit from which to extract the data
+ * @param field the name of the header field containing the signature
+ * block; pass `NULL` to extract the default 'gpgsig'
+ */
+GIT_EXTERN(int) git_commit_extract_signature(git_buf *signature, git_buf *signed_data, git_repository *repo, git_oid *commit_id, const char *field);
+
 /**
  * Create new commit in the repository from a list of `git_object` pointers
  *

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

@@ -1194,7 +1194,7 @@ typedef enum {
 } git_diff_stats_format_t;
 
 /**
- * Accumlate diff statistics for all patches.
+ * Accumulate diff statistics for all patches.
  *
  * @param out Structure containg the diff statistics.
  * @param diff A git_diff generated by one of the above functions.

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

@@ -527,10 +527,6 @@ 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
@@ -553,10 +549,6 @@ 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/rebase.h

@@ -38,16 +38,30 @@ typedef struct {
 	 */
 	int quiet;
 
+	/**
+	 * Used by `git_rebase_init`, this will begin an in-memory rebase,
+	 * which will allow callers to step through the rebase operations and
+	 * commit the rebased changes, but will not rewind HEAD or update the
+	 * repository to be in a rebasing state.  This will not interfere with
+	 * the working directory (if there is one).
+	 */
+	int inmemory;
+
 	/**
 	 * Used by `git_rebase_finish`, this is the name of the notes reference
 	 * used to rewrite notes for rebased commits when finishing the rebase;
-	 * if NULL, the contents of the coniguration option `notes.rewriteRef`
+	 * if NULL, the contents of the configuration option `notes.rewriteRef`
 	 * is examined, unless the configuration option `notes.rewrite.rebase`
 	 * is set to false.  If `notes.rewriteRef` is also NULL, notes will
 	 * not be rewritten.
 	 */
 	const char *rewrite_notes_ref;
 
+	/**
+	 * Options to control how trees are merged during `git_rebase_next`.
+	 */
+	git_merge_options merge_options;
+
 	/**
 	 * Options to control how files are written during `git_rebase_init`,
 	 * `git_checkout_next` and `git_checkout_abort`.  Note that a minimum
@@ -101,7 +115,8 @@ typedef enum {
 
 #define GIT_REBASE_OPTIONS_VERSION 1
 #define GIT_REBASE_OPTIONS_INIT \
-	{GIT_REBASE_OPTIONS_VERSION, 0, NULL, GIT_CHECKOUT_OPTIONS_INIT}
+	{ GIT_REBASE_OPTIONS_VERSION, 0, 0, NULL, GIT_MERGE_OPTIONS_INIT, \
+	  GIT_CHECKOUT_OPTIONS_INIT}
 
 /** Indicates that a rebase operation is not (yet) in progress. */
 #define GIT_REBASE_NO_OPERATION SIZE_MAX
@@ -226,6 +241,21 @@ GIT_EXTERN(int) git_rebase_next(
 	git_rebase_operation **operation,
 	git_rebase *rebase);
 
+/**
+ * Gets the index produced by the last operation, which is the result
+ * of `git_rebase_next` and which will be committed by the next
+ * invocation of `git_rebase_commit`.  This is useful for resolving
+ * conflicts in an in-memory rebase before committing them.  You must
+ * call `git_index_free` when you are finished with this.
+ *
+ * This is only applicable for in-memory rebases; for rebases within
+ * a working directory, the changes were applied to the repository's
+ * index.
+ */
+GIT_EXTERN(int) git_rebase_inmemory_index(
+	git_index **index,
+	git_rebase *rebase);
+
 /**
  * Commits the current patch.  You must have resolved any conflicts that
  * were introduced during the patch application from the `git_rebase_next`

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

@@ -150,7 +150,7 @@ typedef struct git_stash_apply_options {
  *        `GIT_STASH_APPLY_OPTIONS_INIT` here.
  * @return Zero on success; -1 on failure.
  */
-int git_stash_apply_init_options(
+GIT_EXTERN(int) git_stash_apply_init_options(
 	git_stash_apply_options *opts, unsigned int version);
 
 /**

data/vendor/libgit2/src/attr_file.c

@@ -123,7 +123,7 @@ int git_attr_file__load(
 		break;
 	}
 	case GIT_ATTR_FILE__FROM_FILE: {
-		int fd;
+		int fd = -1;
 
 		/* For open or read errors, pretend that we got ENOTFOUND. */
 		/* TODO: issue warning when warning API is available */
@@ -133,7 +133,8 @@ int git_attr_file__load(
 			(fd = git_futils_open_ro(entry->fullpath)) < 0 ||
 			(error = git_futils_readbuffer_fd(&content, fd, (size_t)st.st_size)) < 0)
 			nonexistent = true;
-		else
+
+		if (fd >= 0)
 			p_close(fd);
 
 		break;

data/vendor/libgit2/src/checkout.c

@@ -1487,8 +1487,10 @@ static int blob_content_to_file(
 	if (!data->opts.disable_filters &&
 		(error = git_filter_list__load_ext(
 			&fl, data->repo, blob, hint_path,
-			GIT_FILTER_TO_WORKTREE, &filter_opts)))
+			GIT_FILTER_TO_WORKTREE, &filter_opts))) {
+		p_close(fd);
 		return error;
+	}
 
 	/* setup the writer */
 	memset(&writer, 0, sizeof(struct checkout_stream));
@@ -2519,7 +2521,8 @@ int git_checkout_iterator(
 
 	if (data.opts.baseline_index) {
 		if ((error = git_iterator_for_index(
-				&baseline, data.opts.baseline_index, &baseline_opts)) < 0)
+				&baseline, git_index_owner(data.opts.baseline_index),
+				data.opts.baseline_index, &baseline_opts)) < 0)
 			goto cleanup;
 	} else {
 		if ((error = git_iterator_for_tree(
@@ -2631,7 +2634,7 @@ int git_checkout_index(
 		return error;
 	GIT_REFCOUNT_INC(index);
 
-	if (!(error = git_iterator_for_index(&index_i, index, NULL)))
+	if (!(error = git_iterator_for_index(&index_i, repo, index, NULL)))
 		error = git_checkout_iterator(index_i, index, opts);
 
 	if (owned)

data/vendor/libgit2/src/commit.c

@@ -564,17 +564,97 @@ int git_commit_nth_gen_ancestor(
 
 int git_commit_header_field(git_buf *out, const git_commit *commit, const char *field)
 {
-	const char *buf = commit->raw_header;
-	const char *h, *eol;
+	const char *eol, *buf = commit->raw_header;
 
 	git_buf_sanitize(out);
+
+	while ((eol = strchr(buf, '\n'))) {
+		/* We can skip continuations here */
+		if (buf[0] == ' ') {
+			buf = eol + 1;
+			continue;
+		}
+
+		/* Skip until we find the field we're after */
+		if (git__prefixcmp(buf, field)) {
+			buf = eol + 1;
+			continue;
+		}
+
+		buf += strlen(field);
+		/* Check that we're not matching a prefix but the field itself */
+		if (buf[0] != ' ') {
+			buf = eol + 1;
+			continue;
+		}
+
+		buf++; /* skip the SP */
+
+		git_buf_put(out, buf, eol - buf);
+		if (git_buf_oom(out))
+			goto oom;
+
+		/* If the next line starts with SP, it's multi-line, we must continue */
+		while (eol[1] == ' ') {
+			git_buf_putc(out, '\n');
+			buf = eol + 2;
+			eol = strchr(buf, '\n');
+			if (!eol)
+				goto malformed;
+
+			git_buf_put(out, buf, eol - buf);
+		}
+
+		if (git_buf_oom(out))
+			goto oom;
+
+		return 0;
+	}
+
+	giterr_set(GITERR_OBJECT, "no such field '%s'", field);
+	return GIT_ENOTFOUND;
+
+malformed:
+	giterr_set(GITERR_OBJECT, "malformed header");
+	return -1;
+oom:
+	giterr_set_oom();
+	return -1;
+}
+
+int git_commit_extract_signature(git_buf *signature, git_buf *signed_data, git_repository *repo, git_oid *commit_id, const char *field)
+{
+	git_odb_object *obj;
+	git_odb *odb;
+	const char *buf;
+	const char *h, *eol;
+	int error;
+
+	git_buf_sanitize(signature);
+	git_buf_sanitize(signed_data);
+
+	if (!field)
+		field = "gpgsig";
+
+	if ((error = git_repository_odb__weakptr(&odb, repo)) < 0)
+		return error;
+
+	if ((error = git_odb_read(&obj, odb, commit_id)) < 0)
+		return error;
+
+	buf = git_odb_object_data(obj);
+
 	while ((h = strchr(buf, '\n')) && h[1] != '\0' && h[1] != '\n') {
 		h++;
-		if (git__prefixcmp(h, field)) {
+		if (git__prefixcmp(buf, field)) {
+			if (git_buf_put(signed_data, buf, h - buf) < 0)
+				return -1;
+
 			buf = h;
 			continue;
 		}
 
+		h = buf;
 		h += strlen(field);
 		eol = strchr(h, '\n');
 		if (h[0] != ' ') {
@@ -586,33 +666,44 @@ int git_commit_header_field(git_buf *out, const git_commit *commit, const char *
 
 		h++; /* skip the SP */
 
-		git_buf_put(out, h, eol - h);
-		if (git_buf_oom(out))
+		git_buf_put(signature, h, eol - h);
+		if (git_buf_oom(signature))
 			goto oom;
 
 		/* If the next line starts with SP, it's multi-line, we must continue */
 		while (eol[1] == ' ') {
-			git_buf_putc(out, '\n');
+			git_buf_putc(signature, '\n');
 			h = eol + 2;
 			eol = strchr(h, '\n');
 			if (!eol)
 				goto malformed;
 
-			git_buf_put(out, h, eol - h);
+			git_buf_put(signature, h, eol - h);
 		}
 
-		if (git_buf_oom(out))
+		if (git_buf_oom(signature))
 			goto oom;
 
-		return 0;
+		git_odb_object_free(obj);
+		return git_buf_puts(signed_data, eol+1);
 	}
 
-	return GIT_ENOTFOUND;
+	giterr_set(GITERR_INVALID, "this commit is not signed");
+	error = GIT_ENOTFOUND;
+	goto cleanup;
 
 malformed:
 	giterr_set(GITERR_OBJECT, "malformed header");
-	return -1;
+	error = -1;
+	goto cleanup;
 oom:
 	giterr_set_oom();
-	return -1;
+	error = -1;
+	goto cleanup;
+
+cleanup:
+	git_odb_object_free(obj);
+	git_buf_clear(signature);
+	git_buf_clear(signed_data);
+	return error;
 }