rugged 0.22.0b5 → 0.22.1b1

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

@@ -42,7 +42,7 @@ typedef struct git_index_reuc_entry {
  * @param index an existing index object
  * @return integer of count of current filename conflict entries
  */
-GIT_EXTERN(unsigned int) git_index_name_entrycount(git_index *index);
+GIT_EXTERN(size_t) git_index_name_entrycount(git_index *index);
 
 /**
  * Get a filename conflict entry from the index.
@@ -90,7 +90,7 @@ GIT_EXTERN(void) git_index_name_clear(git_index *index);
  * @param index an existing index object
  * @return integer of count of current resolve undo entries
  */
-GIT_EXTERN(unsigned int) git_index_reuc_entrycount(git_index *index);
+GIT_EXTERN(size_t) git_index_reuc_entrycount(git_index *index);
 
 /**
  * Finds the resolve undo entry that points to the given path in the Git

data/vendor/libgit2/include/git2/{threads.h → sys/openssl.h}

@@ -4,37 +4,35 @@
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
  */
-#ifndef INCLUDE_git_threads_h__
-#define INCLUDE_git_threads_h__
+#ifndef INCLUDE_git_openssl_h__
+#define INCLUDE_git_openssl_h__
 
-#include "common.h"
+#include "git2/common.h"
 
-/**
- * @file git2/threads.h
- * @brief Library level thread functions
- * @defgroup git_thread Threading functions
- * @ingroup Git
- * @{
- */
 GIT_BEGIN_DECL
 
 /**
  * Initialize the OpenSSL locks
  *
  * OpenSSL requires the application to determine how it performs
- * locking. This is a convenience function which libgit2 provides for
+ * locking.
+ *
+ * This is a last-resort convenience function which libgit2 provides for
  * allocating and initializing the locks as well as setting the
  * locking function to use the system's native locking functions.
  *
  * The locking function will be cleared and the memory will be freed
  * when you call git_threads_sutdown().
  *
+ * If your programming language has an OpenSSL package/bindings, it
+ * likely sets up locking. You should very strongly prefer that over
+ * this function.
+ *
  * @return 0 on success, -1 if there are errors or if libgit2 was not
  * built with OpenSSL and threading support.
  */
 GIT_EXTERN(int) git_openssl_set_locking(void);
 
-/** @} */
 GIT_END_DECL
 #endif
 

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

@@ -11,6 +11,15 @@
 #include "git2/types.h"
 #include "git2/oid.h"
 
+/**
+ * @file git2/sys/refs.h
+ * @brief Low-level Git ref creation
+ * @defgroup git_backend Git custom backend APIs
+ * @ingroup Git
+ * @{
+ */
+GIT_BEGIN_DECL
+
 /**
  * Create a new direct reference from an OID.
  *
@@ -35,4 +44,6 @@ GIT_EXTERN(git_reference *) git_reference__alloc_symbolic(
 	const char *name,
 	const char *target);
 
+/** @} */
+GIT_END_DECL
 #endif

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

@@ -251,7 +251,7 @@ GIT_EXTERN(int) git_tree_entry_to_object(
  * @param source Source tree to initialize the builder (optional)
  * @return 0 on success; error code otherwise
  */
-GIT_EXTERN(int) git_treebuilder_create(
+GIT_EXTERN(int) git_treebuilder_new(
 	git_treebuilder **out, git_repository *repo, const git_tree *source);
 
 /**

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

@@ -7,11 +7,11 @@
 #ifndef INCLUDE_git_version_h__
 #define INCLUDE_git_version_h__
 
-#define LIBGIT2_VERSION "0.21.0"
+#define LIBGIT2_VERSION "0.22.0"
 #define LIBGIT2_VER_MAJOR 0
-#define LIBGIT2_VER_MINOR 21
+#define LIBGIT2_VER_MINOR 22
 #define LIBGIT2_VER_REVISION 0
 
-#define LIBGIT2_SOVERSION 21
+#define LIBGIT2_SOVERSION 22
 
 #endif

data/vendor/libgit2/src/attr_file.c

@@ -781,8 +781,10 @@ int git_attr_assignment__parse(
 
 					error = git_vector_insert_sorted(
 						assigns, massign, &merge_assignments);
-					if (error < 0 && error != GIT_EEXISTS)
+					if (error < 0 && error != GIT_EEXISTS) {
+						git_attr_assignment__free(assign);
 						return error;
+					}
 				}
 			}
 		}

data/vendor/libgit2/src/buffer.c

@@ -67,7 +67,8 @@ int git_buf_try_grow(
 
 	if (!new_ptr) {
 		if (mark_oom) {
-			if (buf->ptr) git__free(buf->ptr);
+			if (buf->ptr && (buf->ptr != git_buf__initbuf))
+				git__free(buf->ptr);
 			buf->ptr = git_buf__oom;
 		}
 		return -1;

data/vendor/libgit2/src/checkout.c

@@ -67,6 +67,8 @@ typedef struct {
 	bool reload_submodules;
 	size_t total_steps;
 	size_t completed_steps;
+	git_checkout_perfdata perfdata;
+	git_buf last_mkdir;
 } checkout_data;
 
 typedef struct {
@@ -1101,7 +1103,7 @@ static int checkout_conflicts_mark_directoryfile(
 				goto done;
 			}
 
-			prefixed = git_path_equal_or_prefixed(path, entry->path);
+			prefixed = git_path_equal_or_prefixed(path, entry->path, NULL);
 
 			if (prefixed == GIT_PATH_EQUAL)
 				continue;
@@ -1289,50 +1291,140 @@ fail:
 	return error;
 }
 
+static int checkout_mkdir(
+	checkout_data *data,
+	const char *path,
+	const char *base,
+	mode_t mode,
+	unsigned int flags)
+{
+	struct git_futils_mkdir_perfdata mkdir_perfdata = {0};
+
+	int error = git_futils_mkdir_withperf(
+		path, base, mode, flags, &mkdir_perfdata);
+
+	data->perfdata.mkdir_calls += mkdir_perfdata.mkdir_calls;
+	data->perfdata.stat_calls += mkdir_perfdata.stat_calls;
+	data->perfdata.chmod_calls += mkdir_perfdata.chmod_calls;
+
+	return error;
+}
+
+static bool should_remove_existing(checkout_data *data)
+{
+	int ignorecase = 0;
+
+	git_repository__cvar(&ignorecase, data->repo, GIT_CVAR_IGNORECASE);
+
+	return (ignorecase &&
+		(data->strategy & GIT_CHECKOUT_DONT_REMOVE_EXISTING) == 0);
+}
+
+#define MKDIR_NORMAL \
+	GIT_MKDIR_PATH | GIT_MKDIR_VERIFY_DIR
+#define MKDIR_REMOVE_EXISTING \
+	MKDIR_NORMAL | GIT_MKDIR_REMOVE_FILES | GIT_MKDIR_REMOVE_SYMLINKS
+
+static int mkpath2file(
+	checkout_data *data, const char *path, unsigned int mode)
+{
+	git_buf *mkdir_path = &data->tmp;
+	struct stat st;
+	bool remove_existing = should_remove_existing(data);
+	int error;
+
+	if ((error = git_buf_sets(mkdir_path, path)) < 0)
+		return error;
+
+	git_buf_rtruncate_at_char(mkdir_path, '/');
+
+	if (!data->last_mkdir.size ||
+		data->last_mkdir.size != mkdir_path->size ||
+		memcmp(mkdir_path->ptr, data->last_mkdir.ptr, mkdir_path->size) != 0) {
+
+		if ((error = checkout_mkdir(
+				data, mkdir_path->ptr, data->opts.target_directory, mode,
+				remove_existing ? MKDIR_REMOVE_EXISTING : MKDIR_NORMAL)) < 0)
+			return error;
+
+		git_buf_swap(&data->last_mkdir, mkdir_path);
+	}
+
+	if (remove_existing) {
+		data->perfdata.stat_calls++;
+
+		if (p_lstat(path, &st) == 0) {
+
+			/* Some file, symlink or folder already exists at this name.
+			 * We would have removed it in remove_the_old unless we're on
+			 * a case inensitive filesystem (or the user has asked us not
+			 * to).  Remove the similarly named file to write the new.
+			 */
+			error = git_futils_rmdir_r(path, NULL, GIT_RMDIR_REMOVE_FILES);
+		} else if (errno != ENOENT) {
+			giterr_set(GITERR_OS, "Failed to stat file '%s'", path);
+			return GIT_EEXISTS;
+		} else {
+			giterr_clear();
+		}
+	}
+
+	return error;
+}
+
 static int buffer_to_file(
+	checkout_data *data,
 	struct stat *st,
 	git_buf *buf,
 	const char *path,
-	mode_t dir_mode,
-	int file_open_flags,
 	mode_t file_mode)
 {
 	int error;
 
-	if ((error = git_futils_mkpath2file(path, dir_mode)) < 0)
+	if ((error = mkpath2file(data, path, data->opts.dir_mode)) < 0)
 		return error;
 
 	if ((error = git_futils_writebuffer(
-			buf, path, file_open_flags, file_mode)) < 0)
+			buf, path, data->opts.file_open_flags, file_mode)) < 0)
 		return error;
 
-	if (st != NULL && (error = p_stat(path, st)) < 0)
-		giterr_set(GITERR_OS, "Error statting '%s'", path);
+	if (st) {
+		data->perfdata.stat_calls++;
 
-	else if (GIT_PERMS_IS_EXEC(file_mode) &&
-			(error = p_chmod(path, file_mode)) < 0)
-		giterr_set(GITERR_OS, "Failed to set permissions on '%s'", path);
+		if ((error = p_stat(path, st)) < 0) {
+			giterr_set(GITERR_OS, "Error statting '%s'", path);
+			return error;
+		}
+	}
+
+	if (GIT_PERMS_IS_EXEC(file_mode)) {
+		data->perfdata.chmod_calls++;
+
+		if ((error = p_chmod(path, file_mode)) < 0)
+			giterr_set(GITERR_OS, "Failed to set permissions on '%s'", path);
+	}
 
 	return error;
 }
 
 static int blob_content_to_file(
+	checkout_data *data,
 	struct stat *st,
 	git_blob *blob,
 	const char *path,
 	const char * hint_path,
-	mode_t entry_filemode,
-	git_checkout_options *opts)
+	mode_t entry_filemode)
 {
-	int error = 0;
-	mode_t file_mode = opts->file_mode ? opts->file_mode : entry_filemode;
+	mode_t file_mode = data->opts.file_mode ?
+		data->opts.file_mode : entry_filemode;
 	git_buf out = GIT_BUF_INIT;
 	git_filter_list *fl = NULL;
+	int error = 0;
 
 	if (hint_path == NULL)
 		hint_path = path;
 
-	if (!opts->disable_filters)
+	if (!data->opts.disable_filters)
 		error = git_filter_list_load(
 			&fl, git_blob_owner(blob), blob, hint_path,
 			GIT_FILTER_TO_WORKTREE, GIT_FILTER_OPT_DEFAULT);
@@ -1343,9 +1435,7 @@ static int blob_content_to_file(
 	git_filter_list_free(fl);
 
 	if (!error) {
-		error = buffer_to_file(
-			st, &out, path, opts->dir_mode, opts->file_open_flags, file_mode);
-
+		error = buffer_to_file(data, st, &out, path, file_mode);
 		st->st_mode = entry_filemode;
 
 		git_buf_free(&out);
@@ -1355,29 +1445,30 @@ static int blob_content_to_file(
 }
 
 static int blob_content_to_link(
+	checkout_data *data,
 	struct stat *st,
 	git_blob *blob,
-	const char *path,
-	mode_t dir_mode,
-	int can_symlink)
+	const char *path)
 {
 	git_buf linktarget = GIT_BUF_INIT;
 	int error;
 
-	if ((error = git_futils_mkpath2file(path, dir_mode)) < 0)
+	if ((error = mkpath2file(data, path, data->opts.dir_mode)) < 0)
 		return error;
 
 	if ((error = git_blob__getbuf(&linktarget, blob)) < 0)
 		return error;
 
-	if (can_symlink) {
+	if (data->can_symlink) {
 		if ((error = p_symlink(git_buf_cstr(&linktarget), path)) < 0)
-			giterr_set(GITERR_OS, "Could not create symlink %s\n", path);
+			giterr_set(GITERR_OS, "Could not create symlink %s", path);
 	} else {
 		error = git_futils_fake_symlink(git_buf_cstr(&linktarget), path);
 	}
 
 	if (!error) {
+		data->perfdata.stat_calls++;
+
 		if ((error = p_lstat(path, st)) < 0)
 			giterr_set(GITERR_CHECKOUT, "Could not stat symlink %s", path);
 
@@ -1421,6 +1512,7 @@ static int checkout_submodule_update_index(
 	if (git_buf_puts(&data->path, file->path) < 0)
 		return -1;
 
+	data->perfdata.stat_calls++;
 	if (p_stat(git_buf_cstr(&data->path), &st) < 0) {
 		giterr_set(
 			GITERR_CHECKOUT, "Could not stat submodule %s\n", file->path);
@@ -1436,15 +1528,17 @@ static int checkout_submodule(
 	checkout_data *data,
 	const git_diff_file *file)
 {
+	bool remove_existing = should_remove_existing(data);
 	int error = 0;
 
 	/* Until submodules are supported, UPDATE_ONLY means do nothing here */
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0)
 		return 0;
 
-	if ((error = git_futils_mkdir(
-			file->path, data->opts.target_directory,
-			data->opts.dir_mode, GIT_MKDIR_PATH)) < 0)
+	if ((error = checkout_mkdir(
+			data,
+			file->path, data->opts.target_directory, data->opts.dir_mode,
+			remove_existing ? MKDIR_REMOVE_EXISTING : MKDIR_NORMAL)) < 0)
 		return error;
 
 	if ((error = git_submodule_lookup(NULL, data->repo, file->path)) < 0) {
@@ -1481,10 +1575,13 @@ static void report_progress(
 			data->opts.progress_payload);
 }
 
-static int checkout_safe_for_update_only(const char *path, mode_t expected_mode)
+static int checkout_safe_for_update_only(
+	checkout_data *data, const char *path, mode_t expected_mode)
 {
 	struct stat st;
 
+	data->perfdata.stat_calls++;
+
 	if (p_lstat(path, &st) < 0) {
 		/* if doesn't exist, then no error and no update */
 		if (errno == ENOENT || errno == ENOTDIR)
@@ -1517,11 +1614,9 @@ static int checkout_write_content(
 		return error;
 
 	if (S_ISLNK(mode))
-		error = blob_content_to_link(
-			st, blob, full_path, data->opts.dir_mode, data->can_symlink);
+		error = blob_content_to_link(data, st, blob, full_path);
 	else
-		error = blob_content_to_file(
-			st, blob, full_path, hint_path, mode, &data->opts);
+		error = blob_content_to_file(data, st, blob, full_path, hint_path, mode);
 
 	git_blob_free(blob);
 
@@ -1552,7 +1647,7 @@ static int checkout_blob(
 
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0) {
 		int rval = checkout_safe_for_update_only(
-			git_buf_cstr(&data->path), file->mode);
+			data, git_buf_cstr(&data->path), file->mode);
 		if (rval <= 0)
 			return rval;
 	}
@@ -1807,7 +1902,7 @@ static int checkout_write_entry(
 	}
 
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0 &&
-		(error = checkout_safe_for_update_only(git_buf_cstr(&data->path), side->mode)) <= 0)
+		(error = checkout_safe_for_update_only(data, git_buf_cstr(&data->path), side->mode)) <= 0)
 		return error;
 
 	return checkout_write_content(data,
@@ -1906,7 +2001,7 @@ static int checkout_write_merge(
 		goto done;
 
 	if ((data->strategy & GIT_CHECKOUT_UPDATE_ONLY) != 0 &&
-		(error = checkout_safe_for_update_only(git_buf_cstr(&path_workdir), result.mode)) <= 0)
+		(error = checkout_safe_for_update_only(data, git_buf_cstr(&path_workdir), result.mode)) <= 0)
 		goto done;
 
 	if (!data->opts.disable_filters) {
@@ -1922,7 +2017,7 @@ static int checkout_write_merge(
 		out_data.size = result.len;
 	}
 
-	if ((error = git_futils_mkpath2file(path_workdir.ptr, 0755)) < 0 ||
+	if ((error = mkpath2file(data, path_workdir.ptr, data->opts.dir_mode)) < 0 ||
 		(error = git_filebuf_open(&output, git_buf_cstr(&path_workdir), GIT_FILEBUF_DO_NOT_BUFFER, result.mode)) < 0 ||
 		(error = git_filebuf_write(&output, out_data.ptr, out_data.size)) < 0 ||
 		(error = git_filebuf_commit(&output)) < 0)
@@ -2157,8 +2252,9 @@ static int checkout_data_init(
 	if (!data->opts.target_directory)
 		data->opts.target_directory = git_repository_workdir(repo);
 	else if (!git_path_isdir(data->opts.target_directory) &&
-			 (error = git_futils_mkdir(data->opts.target_directory, NULL,
-					GIT_DIR_MODE, GIT_MKDIR_VERIFY_DIR)) < 0)
+			 (error = checkout_mkdir(data,
+				data->opts.target_directory, NULL,
+				GIT_DIR_MODE, GIT_MKDIR_VERIFY_DIR)) < 0)
 		goto cleanup;
 
 	/* refresh config and index content unless NO_REFRESH is given */
@@ -2474,7 +2570,7 @@ int git_checkout_tree(
 	if ((error = git_repository_index(&index, repo)) < 0)
 		return error;
 
-	if (!(error = git_iterator_for_tree(&tree_i, tree, 0, NULL, NULL)))
+	if (!(error = git_iterator_for_tree(&tree_i, tree, GIT_ITERATOR_DONT_IGNORE_CASE, NULL, NULL)))
 		error = git_checkout_iterator(tree_i, index, opts);
 
 	git_iterator_free(tree_i);