rugged 0.25.0b2 → 0.25.0b3

data/ext/rugged/rugged_rebase.c

@@ -128,7 +128,7 @@ static int rugged_get_annotated_commit(
 
 /*
  *  call-seq:
- *    Rebase.new(repo, branch, upstream[, onto][, options]) -> Rebase
+ *    Rebase.new(repo, branch, upstream[, onto][, options]) -> new_rebase
  *
  *  Initialize a new rebase operation. This will put +repo+ in a
  *  rebase state.
@@ -148,8 +148,8 @@ static int rugged_get_annotated_commit(
  *
  *  :inmemory ::
  *    Do not put the repository in a rebase state but perform all the
- *    operations in-memory. In case of conflicts, the RebaseOperation
- *    returned by #next will contain the index which can be used to
+ *    operations in-memory. In case of conflicts, the rebase operation
+ *    Hash returned by #next will contain the index which can be used to
  *    resolve conflicts.
  *
  *  :rewrite_notes_ref ::
@@ -189,11 +189,10 @@ cleanup:
 	git_annotated_commit_free(upstream);
 	git_annotated_commit_free(onto);
 
-	if (error) {
-		rugged_exception_check(error);
-	} else if (exception) {
+	if (exception)
 		rb_jump_tag(exception);
-	}
+
+	rugged_exception_check(error);
 
 	return rugged_rebase_new(klass, rb_repo, rebase);
 }
@@ -252,7 +251,7 @@ static VALUE rb_git_rebase_next(VALUE self)
 }
 /*
  *  call-seq:
- *    Rebase.inmemory_index -> Index
+ *    rebase.inmemory_index -> index
  *
  *  Gets the index produced by the last operation, which is the result
  *  of +next+ and which will be committed by the next invocation of
@@ -276,12 +275,15 @@ static VALUE rb_git_rebase_inmemory_index(VALUE self)
 
 /*
  *  call-seq:
- *    Rebase.commit(author = nil, committer, message = nil)
+ *    rebase.commit(author: nil, committer: committer, message: nil) -> oid or nil
  *
  *  Commit the current patch. Any conflicts must have been resolved.
  *
  *  If +author+ is +nil+, the existing author for the commit will be
  *  used. If +message+ is +nil+, the existing message will be used.
+ *
+ *  Returns a string containing the oid of the newly created commit,
+ *  or +nil+ if there are no changes to be committed.
  */
 static VALUE rb_git_rebase_commit(int argc, VALUE *argv, VALUE self)
 {
@@ -318,6 +320,11 @@ static VALUE rb_git_rebase_commit(int argc, VALUE *argv, VALUE self)
 	git_signature_free(author);
 	git_signature_free(committer);
 
+	if (error == GIT_EAPPLIED) {
+		giterr_clear();
+		return Qnil;
+	}
+
 	rugged_exception_check(error);
 
 	return rugged_create_oid(&id);
@@ -325,7 +332,7 @@ static VALUE rb_git_rebase_commit(int argc, VALUE *argv, VALUE self)
 
 /*
  *  call-seq:
- *    Rebase.abort()
+ *    rebase.abort -> nil
  *
  *  Abort the rebase currently in process, resetting the repository
  *  and working directory to their state before the rebase began.
@@ -342,7 +349,7 @@ static VALUE rb_git_rebase_abort(VALUE self)
 
 /*
  *  call-seq:
- *    Rebase.finish()
+ *    rebase.finish -> nil
  *
  *  Finish the rebase currently in progress once all patches have been
  *  applied.

data/ext/rugged/rugged_remote.c

@@ -291,7 +291,7 @@ static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
 	init_custom_headers(rb_options, &custom_headers);
 
-	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, &custom_headers)) ||
+	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, NULL, &custom_headers)) ||
 	    (error = git_remote_ls(&heads, &heads_len, remote)))
 		goto cleanup;
 
@@ -491,7 +491,7 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
 	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
 	init_custom_headers(rb_options, &custom_headers);
 
-	error = git_remote_connect(remote, direction, &callbacks, &custom_headers);
+	error = git_remote_connect(remote, direction, &callbacks, NULL, &custom_headers);
 	git_remote_disconnect(remote);
 
 	git_strarray_free(&custom_headers);

data/ext/rugged/rugged_tree.c

@@ -702,6 +702,136 @@ static VALUE rb_git_tree_merge(int argc, VALUE *argv, VALUE self)
 	return rugged_index_new(rb_cRuggedIndex, rb_repo, index);
 }
 
+static git_oid empty_tree = {{ 0x4b, 0x82, 0x5d, 0xc6, 0x42, 0xcb, 0x6e, 0xb9, 0xa0, 0x60,
+			       0xe5, 0x4b, 0xf8, 0xd6, 0x92, 0x88, 0xfb, 0xee, 0x49, 0x04 }};
+
+/*
+ *  call-seq:
+ *    Tree.empty(repo) -> tree
+ *
+ *  Look up the empty tree in the given repository +repo+. The empty
+ *  tree's id is hard-coded to exist in a repository.
+ *
+ *  Returns a new instance of the empty tree.
+ */
+static VALUE rb_git_tree_empty(VALUE self, VALUE rb_repo)
+{
+	git_repository *repo;
+	git_tree *tree;
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	rugged_exception_check(git_tree_lookup(&tree, repo, &empty_tree));
+
+	return rugged_object_new(rb_repo, (git_object *) tree);
+}
+
+/**
+ * Parse the updates and convert them into libgit2 ones. They will be
+ * heap-allocated and returned in 'out'. The strings will also be
+ * heap-allocated and will be stored in 'strings'.
+ */
+static void parse_tree_updates(git_tree_update **out, int *nupdates_out, VALUE rb_updates)
+{
+	int i, nupdates;
+	git_tree_update *updates;
+
+	Check_Type(rb_updates, T_ARRAY);
+	nupdates = RARRAY_LEN(rb_updates);
+	updates = xcalloc(nupdates, sizeof(git_tree_update));
+
+	for (i = 0; i < nupdates; i++) {
+		VALUE rb_update = rb_ary_entry(rb_updates, i);
+		VALUE rb_action, rb_oid, rb_filemode, rb_path;
+		ID action;
+		git_tree_update *update = &updates[i];
+
+		if (!RB_TYPE_P(rb_update, T_HASH))
+			goto on_error;
+
+		rb_action   = rb_hash_aref(rb_update, CSTR2SYM("action"));
+		rb_oid      = rb_hash_aref(rb_update, CSTR2SYM("oid"));
+		rb_filemode = rb_hash_aref(rb_update, CSTR2SYM("filemode"));
+		rb_path     = rb_hash_aref(rb_update, CSTR2SYM("path"));
+
+		if (!SYMBOL_P(rb_action) || !RB_TYPE_P(rb_path, T_STRING))
+			goto on_error;
+
+		update->path = StringValueCStr(rb_path);
+
+		action = SYM2ID(rb_action);
+
+		if (action == rb_intern("upsert")) {
+			if (!RB_TYPE_P(rb_oid, T_STRING) ||!RB_TYPE_P(rb_filemode, T_FIXNUM))
+				goto on_error;
+
+			update->action = GIT_TREE_UPDATE_UPSERT;
+			update->filemode = NUM2INT(rb_filemode);
+
+			if (git_oid_fromstr(&update->id, StringValueCStr(rb_oid)) < 0)
+				goto on_error;
+		} else if (action == rb_intern("remove")) {
+			update->action = GIT_TREE_UPDATE_REMOVE;
+		} else {
+			goto on_error;
+		}
+	}
+
+	*out = updates;
+	*nupdates_out = nupdates;
+
+	return;
+
+on_error:
+	xfree(updates);
+	rb_raise(rb_eTypeError, "Invalid type for tree update object");
+}
+
+/*
+ *  call-seq:
+ *    tree.update(updates)
+ *
+ *  Create a new Rugged::Tree based on the curent one by applying the
+ *  changes described in +updates+.
+ *
+ *  The updates are given as a list of +Hash+ containing:
+ *
+ *  :action ::
+ *    +:upsert+ or +:remove+ to add/insert an entry, or to remove it resp.
+ *
+ *  :oid ::
+ *    The +oid+ of the entry. This is ignored for removals.
+ *
+ *  :filemode ::
+ *    The octal filemode for the entry. This is ignored for remvals.
+ *
+ *  :path ::
+ *    The path of the entry. This may contain slashes and the
+ *    intermediate trees will be created.
+ *
+ */
+static VALUE rb_git_tree_update(VALUE self, VALUE rb_updates)
+{
+	git_repository *repo;
+	git_tree *tree = NULL;
+	git_tree_update *updates;
+	int nupdates, error;
+	git_oid id;
+
+	Data_Get_Struct(self, git_tree, tree);
+	repo = git_tree_owner(tree);
+
+	parse_tree_updates(&updates, &nupdates, rb_updates);
+
+	error = git_tree_create_updated(&id, repo, tree, nupdates, updates);
+	xfree(updates);
+
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&id);
+}
+
 static void rb_git_treebuilder_free(git_treebuilder *bld)
 {
 	git_treebuilder_free(bld);
@@ -904,6 +1034,8 @@ void Init_rugged_tree(void)
 	rb_define_method(rb_cRuggedTree, "each", rb_git_tree_each, 0);
 	rb_define_method(rb_cRuggedTree, "walk", rb_git_tree_walk, 1);
 	rb_define_method(rb_cRuggedTree, "merge", rb_git_tree_merge, -1);
+	rb_define_method(rb_cRuggedTree, "update", rb_git_tree_update, 1);
+	rb_define_singleton_method(rb_cRuggedTree, "empty", rb_git_tree_empty, 1);
 
 	rb_define_singleton_method(rb_cRuggedTree, "diff", rb_git_tree_diff_, -1);
 

data/lib/rugged/version.rb

@@ -1,3 +1,3 @@
 module Rugged
-  Version = VERSION = '0.25.0b2'
+  Version = VERSION = '0.25.0b3'
 end

data/vendor/libgit2/CMakeLists.txt

@@ -161,6 +161,8 @@ FUNCTION(TARGET_OS_LIBRARIES target)
 
 	IF(THREADSAFE)
 		TARGET_LINK_LIBRARIES(${target} ${CMAKE_THREAD_LIBS_INIT})
+		LIST(APPEND LIBGIT2_PC_LIBS ${CMAKE_THREAD_LIBS_INIT})
+		SET(LIBGIT2_PC_LIBS ${LIBGIT2_PC_LIBS} PARENT_SCOPE)
 	ENDIF()
 ENDFUNCTION()
 
@@ -412,7 +414,7 @@ IF (MSVC)
 	# /MTd - Statically link the multithreaded debug version of the CRT
 	# /MDd - Dynamically link the multithreaded debug version of the CRT
 	# /RTC1 - Run time checks
-	SET(CMAKE_C_FLAGS_DEBUG "/Zi /Od /D_DEBUG /RTC1 ${CRT_FLAG_DEBUG}")
+	SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Zi /Od /D_DEBUG /RTC1 ${CRT_FLAG_DEBUG}")
 
 	# /DNDEBUG - Disables asserts
 	# /MT - Statically link the multithreaded release version of the CRT
@@ -464,7 +466,7 @@ ELSE ()
 	ENDIF()
 
 	IF (WIN32 AND NOT CYGWIN)
-		SET(CMAKE_C_FLAGS_DEBUG "-D_DEBUG")
+		SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -D_DEBUG")
 	ENDIF ()
 
 	IF (MINGW) # MinGW always does PIC and complains if we tell it to
@@ -580,8 +582,10 @@ IF (CMAKE_SIZEOF_VOID_P EQUAL 8)
 	ADD_DEFINITIONS(-DGIT_ARCH_64)
 ELSEIF (CMAKE_SIZEOF_VOID_P EQUAL 4)
 	ADD_DEFINITIONS(-DGIT_ARCH_32)
+ELSEIF (CMAKE_SIZEOF_VOID_P)
+	MESSAGE(FATAL_ERROR "Unsupported architecture (pointer size is ${CMAKE_SIZEOF_VOID_P} bytes)")
 ELSE()
-	MESSAGE(FATAL_ERROR "Unsupported architecture")
+	MESSAGE(FATAL_ERROR "Unsupported architecture (CMAKE_SIZEOF_VOID_P is unset)")
 ENDIF()
 
 # Compile and link libgit2
@@ -608,6 +612,8 @@ IF (SONAME)
 	IF (LIBGIT2_FILENAME)
 		ADD_DEFINITIONS(-DLIBGIT2_FILENAME=\"${LIBGIT2_FILENAME}\")
 		SET_TARGET_PROPERTIES(git2 PROPERTIES OUTPUT_NAME ${LIBGIT2_FILENAME})
+	ELSEIF (DEFINED LIBGIT2_PREFIX)
+		SET_TARGET_PROPERTIES(git2 PROPERTIES PREFIX "${LIBGIT2_PREFIX}")
 	ENDIF()
 ENDIF()
 STRING(REPLACE ";" " " LIBGIT2_PC_LIBS "${LIBGIT2_PC_LIBS}")
@@ -686,6 +692,8 @@ IF (BUILD_CLAR)
 	# Add a test target which runs the cred callback tests, to be
 	# called after setting the url and user
 	ADD_TEST(libgit2_clar-cred_callback libgit2_clar -v -sonline::clone::cred_callback)
+	ADD_TEST(libgit2_clar-proxy_credentials_in_url libgit2_clar -v -sonline::clone::proxy_credentials_in_url)
+	ADD_TEST(libgit2_clar-proxy_credentials_request libgit2_clar -v	-sonline::clone::proxy_credentials_request)
 ENDIF ()
 
 IF (TAGS)

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/include/git2/blob.h

@@ -150,46 +150,48 @@ GIT_EXTERN(int) git_blob_create_fromworkdir(git_oid *id, git_repository *repo, c
  */
 GIT_EXTERN(int) git_blob_create_fromdisk(git_oid *id, git_repository *repo, const char *path);
 
-
-typedef int (*git_blob_chunk_cb)(char *content, size_t max_length, void *payload);
-
 /**
- * Write a loose blob to the Object Database from a
- * provider of chunks of data.
+ * Create a stream to write a new blob into the object db
+ *
+ * This function may need to buffer the data on disk and will in
+ * general not be the right choice if you know the size of the data
+ * to write. If you have data in memory, use
+ * `git_blob_create_frombuffer()`. If you do not, but know the size of
+ * the contents (and don't want/need to perform filtering), use
+ * `git_odb_open_wstream()`.
+ *
+ * Don't close this stream yourself but pass it to
+ * `git_blob_create_fromstream_commit()` to commit the write to the
+ * object db and get the object id.
  *
  * If the `hintpath` parameter is filled, it will be used to determine
  * what git filters should be applied to the object before it is written
  * to the object database.
  *
- * The implementation of the callback MUST respect the following rules:
- *
- *  - `content` must be filled by the callback. The maximum number of
- *    bytes that the buffer can accept per call is defined by the
- *    `max_length` parameter. Allocation and freeing of the buffer will
- *    be taken care of by libgit2.
- *
- *  - The `callback` must return the number of bytes that have been
- *    written to the `content` buffer.
- *
- *  - When there is no more data to stream, `callback` should return 0.
- *    This will prevent it from being invoked anymore.
- *
- *  - If an error occurs, the callback should return a negative value.
- *    This value will be returned to the caller.
- *
- * @param id Return the id of the written blob
+ * @param out the stream into which to write
  * @param repo Repository where the blob will be written.
  *        This repository can be bare or not.
  * @param hintpath If not NULL, will be used to select data filters
  *        to apply onto the content of the blob to be created.
- * @return 0 or error code (from either libgit2 or callback function)
+ * @return 0 or error code
  */
-GIT_EXTERN(int) git_blob_create_fromchunks(
-	git_oid *id,
+GIT_EXTERN(int) git_blob_create_fromstream(
+	git_writestream **out,
 	git_repository *repo,
-	const char *hintpath,
-	git_blob_chunk_cb callback,
-	void *payload);
+	const char *hintpath);
+
+/**
+ * Close the stream and write the blob to the object db
+ *
+ * The stream will be closed and freed.
+ *
+ * @param out the id of the new blob
+ * @param stream the stream to close
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_blob_create_fromstream_commit(
+	git_oid *out,
+	git_writestream *stream);
 
 /**
  * Write an in-memory buffer to the ODB as a blob
@@ -216,6 +218,15 @@ GIT_EXTERN(int) git_blob_create_frombuffer(
  */
 GIT_EXTERN(int) git_blob_is_binary(const git_blob *blob);
 
+/**
+ * Create an in-memory copy of a blob. The copy must be explicitly
+ * free'd or it will leak.
+ *
+ * @param out Pointer to store the copy of the object
+ * @param source Original object to copy
+ */
+GIT_EXTERN(int) git_blob_dup(git_blob **out, git_blob *source);
+
 /** @} */
 GIT_END_DECL
 #endif

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

@@ -440,6 +440,36 @@ GIT_EXTERN(int) git_commit_create_buffer(
 	size_t parent_count,
 	const git_commit *parents[]);
 
+/**
+ * Create a commit object from the given buffer and signature
+ *
+ * Given the unsigned commit object's contents, its signature and the
+ * header field in which to store the signature, attach the signature
+ * to the commit and write it into the given repository.
+ *
+ * @param out the resulting commit id
+ * @param commit_content the content of the unsigned commit object
+ * @param signature the signature to add to the commit
+ * @param signature_field which header field should contain this
+ * signature. Leave `NULL` for the default of "gpgsig"
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_commit_create_with_signature(
+	git_oid *out,
+	git_repository *repo,
+	const char *commit_content,
+	const char *signature,
+	const char *signature_field);
+
+/**
+ * Create an in-memory copy of a commit. The copy must be explicitly
+ * free'd or it will leak.
+ *
+ * @param out Pointer to store the copy of the commit
+ * @param source Original commit to copy
+ */
+GIT_EXTERN(int) git_commit_dup(git_commit **out, git_commit *source);
+
 /** @} */
 GIT_END_DECL
 #endif