rugged 0.23.3 → 0.24.0b0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4df2826e70f1fb3fb4b440f2fc459b0d9fca6511
-  data.tar.gz: 69765b8342fc60b5e78244b6bd5316c4d2f0d8bc
+  metadata.gz: 9cbd379f155df87669ec3b453094bf4883ab30e5
+  data.tar.gz: 05db49343e6d30304224ac60e4c12ca3feea853f
 SHA512:
-  metadata.gz: 981a484bf2d8fe7d7aa706304980809be6fdd2b179bbd8c01832bb7f8eac485487cfd1a608d104b798079169012d78738ded561824301278830b14846f70dc14
-  data.tar.gz: c4d7f8b3670e499c6878586d4aa1564e8e2cbde7ebaf72e4548bc3be0ea4897231227a852645243f1cdd3a79154f5fc3fe47c334a85f25495ec08607bf648f34
+  metadata.gz: 3eca55c77bfdab68087f3ce9883485755f80968c77693828c9bb12c9bd54f0cd4544a62536e64b3bd16ac98640b37113194f693f08afcc7c8a5375987d4fddcf
+  data.tar.gz: 49e8e55c6cd7593e671f123099b8330076767eef59edde22a134262d1d594e137819c5917e500e5f843b90943f0af210998f7ea99b71d970a6a643c9ab4427fa

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2014 GitHub, Inc
+Copyright (c) 2015 GitHub, Inc
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/ext/rugged/rugged.c

@@ -109,6 +109,29 @@ static VALUE rb_git_features(VALUE self)
 	return ret_arr;
 }
 
+/*
+ *  call-seq:
+ *    Rugged.valid_full_oid?(oid) -> true or false
+ *
+ *  Checks to see if a string contains a full 40-character sha1.
+ *
+ *    Rugged.valid_full_oid?('d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f')
+ *    #=> true
+ */
+static VALUE rb_git_valid_full_oid(VALUE self, VALUE hex)
+{
+	git_oid oid;
+	int errorcode;
+
+	Check_Type(hex, T_STRING);
+	errorcode = git_oid_fromstr(&oid, StringValueCStr(hex));
+	if (errorcode < 0) {
+		return Qfalse;
+	} else {
+		return Qtrue;
+	}
+}
+
 /*
  *  call-seq:
  *    Rugged.hex_to_raw(oid) -> raw_buffer
@@ -421,6 +444,7 @@ void Init_rugged(void)
 
 	rb_define_module_function(rb_mRugged, "libgit2_version", rb_git_libgit2_version, 0);
 	rb_define_module_function(rb_mRugged, "features", rb_git_features, 0);
+	rb_define_module_function(rb_mRugged, "valid_full_oid?", rb_git_valid_full_oid, 1);
 	rb_define_module_function(rb_mRugged, "hex_to_raw", rb_git_hex_to_raw, 1);
 	rb_define_module_function(rb_mRugged, "raw_to_hex", rb_git_raw_to_hex, 1);
 	rb_define_module_function(rb_mRugged, "minimize_oid", rb_git_minimize_oid, -1);

data/ext/rugged/rugged_config.c

@@ -306,6 +306,69 @@ static VALUE rb_git_config_open_default(VALUE klass)
 	return rugged_config_new(klass, Qnil, cfg);
 }
 
+/*
+ *  call-seq:
+ *    config.snapshot -> snapshot
+ *
+ *  Create a snapshot of the configuration.
+ *
+ *  Provides a consistent, read-only view of the configuration for
+ *  looking up complex values from a configuration.
+ */
+static VALUE rb_git_config_snapshot(VALUE self)
+{
+	git_config *config, *snapshot;
+
+	Data_Get_Struct(self, git_config, config);
+
+	rugged_exception_check(
+		git_config_snapshot(&snapshot, config)
+	);
+
+	return rugged_config_new(rb_obj_class(self), Qnil, snapshot);
+}
+
+/*
+ *  call-seq:
+ *    config.transaction { |config| }
+ *
+ *  Perform configuration changes in a transaction.
+ *
+ *  Locks the configuration, executes the given block and stores
+ *  any changes that were made to the configuration. If the block
+ *  throws an exception, all changes are rolled back automatically.
+ *
+ *  During the execution of the block, configuration changes don't
+ *  get stored to disk immediately, so reading from the configuration
+ *  will continue to return the values that were stored in the configuration
+ *  when the transaction was started.
+ */
+static VALUE rb_git_config_transaction(VALUE self)
+{
+	git_config *config;
+	git_transaction *tx;
+	VALUE rb_result;
+	int error = 0, exception = 0;
+
+	Data_Get_Struct(self, git_config, config);
+
+	git_config_lock(&tx, config);
+
+	rb_result = rb_protect(rb_yield, self, &exception);
+
+	if (!exception)
+		error = git_transaction_commit(tx);
+
+	git_transaction_free(tx);
+
+	if (exception)
+		rb_jump_tag(exception);
+	else if (error)
+		rugged_exception_check(error);
+
+	return rb_result;
+}
+
 void Init_rugged_config(void)
 {
 	/*
@@ -330,4 +393,6 @@ void Init_rugged_config(void)
 	rb_define_method(rb_cRuggedConfig, "each", rb_git_config_each_pair, 0);
 	rb_define_method(rb_cRuggedConfig, "to_hash", rb_git_config_to_hash, 0);
 
+	rb_define_method(rb_cRuggedConfig, "snapshot", rb_git_config_snapshot, 0);
+	rb_define_method(rb_cRuggedConfig, "transaction", rb_git_config_transaction, 0);
 }

data/ext/rugged/rugged_remote.c

@@ -181,6 +181,19 @@ void rugged_remote_init_callbacks_and_payload_from_options(
 	}
 }
 
+static int parse_prune_type(VALUE rb_prune_type)
+{
+	if (rb_prune_type == Qtrue) {
+		return GIT_FETCH_PRUNE;
+	} else if (rb_prune_type == Qfalse) {
+		return GIT_FETCH_NO_PRUNE;
+	} else if (rb_prune_type == Qnil) {
+		return GIT_FETCH_PRUNE_UNSPECIFIED;
+	} else {
+		rb_raise(rb_eTypeError, "wrong argument type for :prune (expected true, false or nil)");
+	}
+}
+
 static void rb_git_remote__free(git_remote *remote)
 {
 	git_remote_free(remote);
@@ -264,7 +277,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);
 
-	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks)) ||
+	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, NULL)) ||
 	    (error = git_remote_ls(&heads, &heads_len, remote)))
 		goto cleanup;
 
@@ -458,7 +471,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);
 
-	error = git_remote_connect(remote, direction, &callbacks);
+	error = git_remote_connect(remote, direction, &callbacks, NULL);
 	git_remote_disconnect(remote);
 
 	if (payload.exception)
@@ -502,6 +515,10 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
  *  :message ::
  *    The message to insert into the reflogs. Defaults to "fetch".
  *
+ *  :prune ::
+ *    Specifies the prune mode for the fetch. +true+ remove any remote-tracking references that
+ *    no longer exist, +false+ do not prune, +nil+ use configured settings Defaults to "nil".
+ *
  *  Example:
  *
  *    remote = Rugged::Remote.lookup(@repo, 'origin')
@@ -536,6 +553,9 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 		VALUE rb_val = rb_hash_aref(rb_options, CSTR2SYM("message"));
 		if (!NIL_P(rb_val))
 			log_message = StringValueCStr(rb_val);
+
+		VALUE rb_prune_type = rb_hash_aref(rb_options, CSTR2SYM("prune"));
+		opts.prune = parse_prune_type(rb_prune_type);
 	}
 
 	error = git_remote_fetch(remote, &refspecs, &opts, log_message);

data/ext/rugged/rugged_repo.c

@@ -215,7 +215,11 @@ static void rugged_repo_new_with_backend(git_repository **repo, VALUE rb_path, V
 	if (error) goto cleanup;
 
 	error = git_odb_add_backend(odb, odb_backend, 1);
-	if (error) goto cleanup;
+	if (error) {
+		assert(odb_backend->free);
+		odb_backend->free(odb_backend);
+		goto cleanup;
+	}
 
 	error = git_repository_wrap_odb(repo, odb);
 	if (error) goto cleanup;
@@ -224,7 +228,11 @@ static void rugged_repo_new_with_backend(git_repository **repo, VALUE rb_path, V
 	if (error) goto cleanup;
 
 	error = backend->refdb_backend(&refdb_backend, backend, path);
-	if (error) goto cleanup;
+	if (error) {
+		assert(refdb_backend->free);
+		refdb_backend->free(refdb_backend);
+		goto cleanup;
+	}
 
 	error = git_refdb_set_backend(refdb, refdb_backend);
 	if (error) goto cleanup;
@@ -248,9 +256,6 @@ cleanup:
 	git_odb_free(odb);
 	git_refdb_free(refdb);
 
-	if (odb_backend != NULL) odb_backend->free(odb_backend);
-	if (refdb_backend != NULL) refdb_backend->free(refdb_backend);
-
 	rugged_exception_check(error);
 }
 

data/ext/rugged/rugged_tree.c

@@ -815,8 +815,11 @@ static VALUE rb_git_treebuilder_remove(VALUE self, VALUE path)
 	Check_Type(path, T_STRING);
 
 	error = git_treebuilder_remove(builder, StringValueCStr(path));
-	if (error == GIT_ENOTFOUND)
+	if (error == GIT_ENOTFOUND) {
 		return Qfalse;
+	} else if (error == GIT_ERROR && giterr_last()->klass == GITERR_TREE) {
+		return Qfalse;
+	}
 
 	rugged_exception_check(error);
 	return Qtrue;

data/lib/rugged/version.rb

@@ -1,3 +1,3 @@
 module Rugged
-  Version = VERSION = '0.23.3'
+  Version = VERSION = '0.24.0b0'
 end

data/vendor/libgit2/CMakeLists.txt

@@ -19,6 +19,7 @@ CMAKE_POLICY(SET CMP0015 NEW)
 SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
 
 INCLUDE(CheckLibraryExists)
+INCLUDE(CheckFunctionExists)
 INCLUDE(AddCFlagIfSupported)
 INCLUDE(FindPkgConfig)
 
@@ -59,6 +60,10 @@ IF(MSVC)
 	# are linking statically
 	OPTION( STATIC_CRT		"Link the static CRT libraries"	ON  )
 
+	# If you want to embed a copy of libssh2 into libgit2, pass a
+	# path to libssh2
+	OPTION( EMBED_SSH_PATH		"Path to libssh2 to embed (Windows)" OFF )
+
 	ADD_DEFINITIONS(-D_SCL_SECURE_NO_WARNINGS)
 	ADD_DEFINITIONS(-D_CRT_SECURE_NO_DEPRECATE)
 	ADD_DEFINITIONS(-D_CRT_NONSTDC_NO_DEPRECATE)
@@ -95,6 +100,23 @@ SET(BIN_INSTALL_DIR bin CACHE PATH "Where to install binaries to.")
 SET(LIB_INSTALL_DIR lib CACHE PATH "Where to install libraries to.")
 SET(INCLUDE_INSTALL_DIR include CACHE PATH "Where to install headers to.")
 
+# Set a couple variables to be substituted inside the .pc file.
+# We can't just use LIB_INSTALL_DIR in the .pc file, as passing them as absolue
+# or relative paths is both valid and supported by cmake.
+SET (PKGCONFIG_PREFIX ${CMAKE_INSTALL_PREFIX})
+
+IF(IS_ABSOLUTE ${LIB_INSTALL_DIR})
+  SET (PKGCONFIG_LIBDIR ${LIB_INSTALL_DIR})
+ELSE(IS_ABSOLUTE ${LIB_INSTALL_DIR})
+  SET (PKGCONFIG_LIBDIR "\${prefix}/${LIB_INSTALL_DIR}")
+ENDIF (IS_ABSOLUTE ${LIB_INSTALL_DIR})
+
+IF(IS_ABSOLUTE ${INCLUDE_INSTALL_DIR})
+  SET (PKGCONFIG_INCLUDEDIR ${INCLUDE_INSTALL_DIR})
+ELSE(IS_ABSOLUTE ${INCLUDE_INSTALL_DIR})
+  SET (PKGCONFIG_INCLUDEDIR "\${prefix}/${INCLUDE_INSTALL_DIR}")
+ENDIF(IS_ABSOLUTE ${INCLUDE_INSTALL_DIR})
+
 FUNCTION(TARGET_OS_LIBRARIES target)
 	IF(WIN32)
 		TARGET_LINK_LIBRARIES(${target} ws2_32)
@@ -172,6 +194,13 @@ IF (COREFOUNDATION_FOUND)
 ENDIF()
 
 
+IF (WIN32 AND EMBED_SSH_PATH)
+	FILE(GLOB SRC_SSH "${EMBED_SSH_PATH}/src/*.c")
+	INCLUDE_DIRECTORIES("${EMBED_SSH_PATH}/include")
+	FILE(WRITE "${EMBED_SSH_PATH}/src/libssh2_config.h" "#define HAVE_WINCNG\n#define LIBSSH2_WINCNG\n#include \"../win32/libssh2_config.h\"")
+	ADD_DEFINITIONS(-DGIT_SSH)
+ENDIF()
+
 IF (WIN32 AND WINHTTP)
 	ADD_DEFINITIONS(-DGIT_WINHTTP)
 	INCLUDE_DIRECTORIES(deps/http-parser)
@@ -346,6 +375,7 @@ IF (MSVC)
 
 	IF (MSVC_CRTDBG)
 		SET(CRT_FLAG_DEBUG "${CRT_FLAG_DEBUG} /DGIT_MSVC_CRTDBG")
+		SET(CMAKE_C_STANDARD_LIBRARIES "${CMAKE_C_STANDARD_LIBRARIES}" "Dbghelp.lib")
 	ENDIF()
 
 	# /Zi - Create debugging information
@@ -440,6 +470,21 @@ ELSE ()
 	ENDIF ()
 ENDIF()
 
+CHECK_FUNCTION_EXISTS(futimens HAVE_FUTIMENS)
+IF (HAVE_FUTIMENS)
+	ADD_DEFINITIONS(-DHAVE_FUTIMENS)
+ENDIF ()
+
+CHECK_FUNCTION_EXISTS(qsort_r HAVE_QSORT_R)
+IF (HAVE_QSORT_R)
+	ADD_DEFINITIONS(-DHAVE_QSORT_R)
+ENDIF ()
+
+CHECK_FUNCTION_EXISTS(qsort_s HAVE_QSORT_S)
+IF (HAVE_QSORT_S)
+	ADD_DEFINITIONS(-DHAVE_QSORT_S)
+ENDIF ()
+
 IF( NOT CMAKE_CONFIGURATION_TYPES )
 	# Build Debug by default
 	IF (NOT CMAKE_BUILD_TYPE)
@@ -500,7 +545,7 @@ ELSE()
 ENDIF()
 
 # Compile and link libgit2
-ADD_LIBRARY(git2 ${SRC_H} ${SRC_GIT2} ${SRC_OS} ${SRC_ZLIB} ${SRC_HTTP} ${SRC_REGEX} ${SRC_SHA1} ${WIN_RC})
+ADD_LIBRARY(git2 ${SRC_H} ${SRC_GIT2} ${SRC_OS} ${SRC_ZLIB} ${SRC_HTTP} ${SRC_REGEX} ${SRC_SSH} ${SRC_SHA1} ${WIN_RC})
 TARGET_LINK_LIBRARIES(git2 ${SECURITY_DIRS})
 TARGET_LINK_LIBRARIES(git2 ${COREFOUNDATION_DIRS})
 TARGET_LINK_LIBRARIES(git2 ${SSL_LIBRARIES})
@@ -570,7 +615,7 @@ IF (BUILD_CLAR)
 		${CLAR_PATH}/clar.c
 		PROPERTIES OBJECT_DEPENDS ${CLAR_PATH}/clar.suite)
 
-	ADD_EXECUTABLE(libgit2_clar ${SRC_H} ${SRC_GIT2} ${SRC_OS} ${SRC_CLAR} ${SRC_TEST} ${SRC_ZLIB} ${SRC_HTTP} ${SRC_REGEX} ${SRC_SHA1})
+	ADD_EXECUTABLE(libgit2_clar ${SRC_H} ${SRC_GIT2} ${SRC_OS} ${SRC_CLAR} ${SRC_TEST} ${SRC_ZLIB} ${SRC_HTTP} ${SRC_REGEX} ${SRC_SSH} ${SRC_SHA1})
 
 	TARGET_LINK_LIBRARIES(libgit2_clar ${COREFOUNDATION_DIRS})
 	TARGET_LINK_LIBRARIES(libgit2_clar ${SECURITY_DIRS})

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

@@ -691,6 +691,24 @@ GIT_EXTERN(int) git_config_backend_foreach_match(
 	void *payload);
 
 
+/**
+ * Lock the backend with the highest priority
+ *
+ * Locking disallows anybody else from writing to that backend. Any
+ * updates made after locking will not be visible to a reader until
+ * the file is unlocked.
+ *
+ * You can apply the changes by calling `git_transaction_commit()`
+ * before freeing the transaction. Either of these actions will unlock
+ * the config.
+ *
+ * @param tx the resulting transaction, use this to commit or undo the
+ * changes
+ * @param cfg the configuration in which to lock
+ * @return 0 or an error code
+ */
+GIT_EXTERN(int) git_config_lock(git_transaction **tx, git_config *cfg);
+
 /** @} */
 GIT_END_DECL
 #endif

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

@@ -129,8 +129,12 @@ typedef enum {
 	 */
 	GIT_DIFF_INCLUDE_CASECHANGE = (1u << 11),
 
-	/** If the pathspec is set in the diff options, this flags means to
-	 *  apply it as an exact match instead of as an fnmatch pattern.
+	/** If the pathspec is set in the diff options, this flags indicates
+	 *  that the paths will be treated as literal paths instead of
+	 *  fnmatch patterns.  Each path in the list must either be a full
+	 *  path to a file or a directory.  (A trailing slash indicates that
+	 *  the path will _only_ match a directory).  If a directory is
+	 *  specified, all children will be included.
 	 */
 	GIT_DIFF_DISABLE_PATHSPEC_MATCH = (1u << 12),
 
@@ -835,6 +839,25 @@ GIT_EXTERN(int) git_diff_tree_to_workdir_with_index(
 	git_tree *old_tree,
 	const git_diff_options *opts); /**< can be NULL for defaults */
 
+/**
+ * Create a diff with the difference between two index objects.
+ *
+ * The first index will be used for the "old_file" side of the delta and the
+ * second index will be used for the "new_file" side of the delta.
+ *
+ * @param diff Output pointer to a git_diff pointer to be allocated.
+ * @param repo The repository containing the indexes.
+ * @param old_index A git_index object to diff from.
+ * @param new_index A git_index object to diff to.
+ * @param opts Structure with options to influence diff or NULL for defaults.
+ */
+GIT_EXTERN(int) git_diff_index_to_index(
+	git_diff **diff,
+	git_repository *repo,
+	git_index *old_index,
+	git_index *new_index,
+	const git_diff_options *opts); /**< can be NULL for defaults */
+
 /**
  * Merge one diff into another.
  *

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

@@ -113,18 +113,6 @@ GIT_EXTERN(const git_error *) giterr_last(void);
  */
 GIT_EXTERN(void) giterr_clear(void);
 
-/**
- * Get the last error data and clear it.
- *
- * This copies the last error into the given `git_error` struct
- * and returns 0 if the copy was successful, leaving the error
- * cleared as if `giterr_clear` had been called.
- *
- * If there was no existing error in the library, -1 will be returned
- * and the contents of `cpy` will be left unmodified.
- */
-GIT_EXTERN(int) giterr_detach(git_error *cpy);
-
 /**
  * Set the error message string for this thread.
  *

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

@@ -643,6 +643,17 @@ GIT_EXTERN(int) git_index_update_all(
  */
 GIT_EXTERN(int) git_index_find(size_t *at_pos, git_index *index, const char *path);
 
+/**
+ * Find the first position of any entries matching a prefix. To find the first position
+ * of a path inside a given folder, suffix the prefix with a '/'.
+ *
+ * @param at_pos the address to which the position of the index entry is written (optional)
+ * @param index an existing index object
+ * @param prefix the prefix to search for
+ * @return 0 with valid value in at_pos; an error code otherwise
+ */
+GIT_EXTERN(int) git_index_find_prefix(size_t *at_pos, git_index *index, const char *prefix);
+
 /**@}*/
 
 /** @name Conflict Index Entry Functions