rugged 0.22.2 → 0.23.0b1

data/vendor/libgit2/src/checkout.h

@@ -12,13 +12,6 @@
 
 #define GIT_CHECKOUT__NOTIFY_CONFLICT_TREE (1u << 12)
 
-/** Internal structure; this is exposed in future versions. */
-typedef struct {
-	size_t mkdir_calls;
-	size_t stat_calls;
-	size_t chmod_calls;
-} git_checkout_perfdata;
-
 /**
  * Update the working directory to match the target iterator.  The
  * expected baseline value can be passed in via the checkout options

data/vendor/libgit2/src/cherrypick.c

@@ -10,6 +10,7 @@
 #include "filebuf.h"
 #include "merge.h"
 #include "vector.h"
+#include "index.h"
 
 #include "git2/types.h"
 #include "git2/merge.h"
@@ -71,7 +72,7 @@ static int cherrypick_normalize_opts(
 	const char *their_label)
 {
 	int error = 0;
-	unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE_CREATE |
+	unsigned int default_checkout_strategy = GIT_CHECKOUT_SAFE |
 		GIT_CHECKOUT_ALLOW_CONFLICTS;
 
 	GIT_UNUSED(repo);
@@ -171,7 +172,8 @@ int git_cherrypick(
 	char commit_oidstr[GIT_OID_HEXSZ + 1];
 	const char *commit_msg, *commit_summary;
 	git_buf their_label = GIT_BUF_INIT;
-	git_index *index_new = NULL;
+	git_index *index = NULL;
+	git_indexwriter indexwriter = GIT_INDEXWRITER_INIT;
 	int error = 0;
 
 	assert(repo && commit);
@@ -192,21 +194,25 @@ int git_cherrypick(
 	if ((error = write_merge_msg(repo, commit_msg)) < 0 ||
 		(error = git_buf_printf(&their_label, "%.7s... %s", commit_oidstr, commit_summary)) < 0 ||
 		(error = cherrypick_normalize_opts(repo, &opts, given_opts, git_buf_cstr(&their_label))) < 0 ||
+		(error = git_indexwriter_init_for_operation(&indexwriter, repo, &opts.checkout_opts.checkout_strategy)) < 0 ||
 		(error = write_cherrypick_head(repo, commit_oidstr)) < 0 ||
 		(error = git_repository_head(&our_ref, repo)) < 0 ||
 		(error = git_reference_peel((git_object **)&our_commit, our_ref, GIT_OBJ_COMMIT)) < 0 ||
-		(error = git_cherrypick_commit(&index_new, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 ||
-		(error = git_merge__check_result(repo, index_new)) < 0 ||
-		(error = git_merge__append_conflicts_to_merge_msg(repo, index_new)) < 0 ||
-		(error = git_checkout_index(repo, index_new, &opts.checkout_opts)) < 0)
+		(error = git_cherrypick_commit(&index, repo, commit, our_commit, opts.mainline, &opts.merge_opts)) < 0 ||
+		(error = git_merge__check_result(repo, index)) < 0 ||
+		(error = git_merge__append_conflicts_to_merge_msg(repo, index)) < 0 ||
+		(error = git_checkout_index(repo, index, &opts.checkout_opts)) < 0 ||
+		(error = git_indexwriter_commit(&indexwriter)) < 0)
 		goto on_error;
+
 	goto done;
 
 on_error:
 	cherrypick_state_cleanup(repo);
 
 done:
-	git_index_free(index_new);
+	git_indexwriter_cleanup(&indexwriter);
+	git_index_free(index);
 	git_commit_free(our_commit);
 	git_reference_free(our_ref);
 	git_buf_free(&their_label);

data/vendor/libgit2/src/clone.c

@@ -24,18 +24,18 @@
 #include "repository.h"
 #include "odb.h"
 
-static int clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link, const git_signature *signature);
+static int clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link);
 
 static int create_branch(
 	git_reference **branch,
 	git_repository *repo,
 	const git_oid *target,
 	const char *name,
-	const git_signature *signature,
 	const char *log_message)
 {
 	git_commit *head_obj = NULL;
 	git_reference *branch_ref = NULL;
+	git_buf refname = GIT_BUF_INIT;
 	int error;
 
 	/* Find the target commit */
@@ -43,8 +43,11 @@ static int create_branch(
 		return error;
 
 	/* Create the new branch */
-	error = git_branch_create(&branch_ref, repo, name, head_obj, 0, signature, log_message);
+	if ((error = git_buf_printf(&refname, GIT_REFS_HEADS_DIR "%s", name)) < 0)
+		return error;
 
+	error = git_reference_create(&branch_ref, repo, git_buf_cstr(&refname), target, 0, log_message);
+	git_buf_free(&refname);
 	git_commit_free(head_obj);
 
 	if (!error)
@@ -93,12 +96,11 @@ static int create_tracking_branch(
 	git_repository *repo,
 	const git_oid *target,
 	const char *branch_name,
-	const git_signature *signature,
 	const char *log_message)
 {
 	int error;
 
-	if ((error = create_branch(branch, repo, target, branch_name, signature, log_message)) < 0)
+	if ((error = create_branch(branch, repo, target, branch_name, log_message)) < 0)
 		return error;
 
 	return setup_tracking_config(
@@ -112,7 +114,6 @@ static int update_head_to_new_branch(
 	git_repository *repo,
 	const git_oid *target,
 	const char *name,
-	const git_signature *signature,
 	const char *reflog_message)
 {
 	git_reference *tracking_branch = NULL;
@@ -122,12 +123,11 @@ static int update_head_to_new_branch(
 		name += strlen(GIT_REFS_HEADS_DIR);
 
 	error = create_tracking_branch(&tracking_branch, repo, target, name,
-			signature, reflog_message);
+			reflog_message);
 
 	if (!error)
 		error = git_repository_set_head(
-			repo, git_reference_name(tracking_branch),
-			signature, reflog_message);
+			repo, git_reference_name(tracking_branch));
 
 	git_reference_free(tracking_branch);
 
@@ -141,7 +141,6 @@ static int update_head_to_new_branch(
 static int update_head_to_remote(
 		git_repository *repo,
 		git_remote *remote,
-		const git_signature *signature,
 		const char *reflog_message)
 {
 	int error = 0;
@@ -169,7 +168,7 @@ static int update_head_to_remote(
 	error = git_remote_default_branch(&branch, remote);
 	if (error == GIT_ENOTFOUND) {
 		error = git_repository_set_head_detached(
-			repo, remote_head_id, signature, reflog_message);
+			repo, remote_head_id);
 		goto cleanup;
 	}
 
@@ -192,7 +191,7 @@ static int update_head_to_remote(
 		repo,
 		remote_head_id,
 		git_buf_cstr(&branch),
-		signature, reflog_message);
+		reflog_message);
 
 cleanup:
 	git_buf_free(&remote_master_name);
@@ -205,7 +204,6 @@ static int update_head_to_branch(
 		git_repository *repo,
 		const char *remote_name,
 		const char *branch,
-		const git_signature *signature,
 		const char *reflog_message)
 {
 	int retcode;
@@ -222,7 +220,7 @@ static int update_head_to_branch(
 		goto cleanup;
 
 	retcode = update_head_to_new_branch(repo, git_reference_target(remote_ref), branch,
-			signature, reflog_message);
+			reflog_message);
 
 cleanup:
 	git_reference_free(remote_ref);
@@ -313,16 +311,16 @@ static bool should_checkout(
 	return !git_repository_head_unborn(repo);
 }
 
-static int checkout_branch(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature, const char *reflog_message)
+static int checkout_branch(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, const char *reflog_message)
 {
 	int error;
 
 	if (branch)
 		error = update_head_to_branch(repo, git_remote_name(remote), branch,
-				signature, reflog_message);
+				reflog_message);
 	/* Point HEAD to the same ref as the remote's head */
 	else
-		error = update_head_to_remote(repo, remote, signature, reflog_message);
+		error = update_head_to_remote(repo, remote, reflog_message);
 
 	if (!error && should_checkout(repo, git_repository_is_bare(repo), co_opts))
 		error = git_checkout_head(repo, co_opts);
@@ -330,7 +328,7 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c
 	return error;
 }
 
-static int clone_into(git_repository *repo, git_remote *_remote, const git_checkout_options *co_opts, const char *branch, const git_signature *signature)
+static int clone_into(git_repository *repo, git_remote *_remote, const git_checkout_options *co_opts, const char *branch)
 {
 	int error;
 	git_buf reflog_message = GIT_BUF_INIT;
@@ -358,10 +356,10 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_check
 	git_remote_set_update_fetchhead(remote, 0);
 	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
 
-	if ((error = git_remote_fetch(remote, NULL, signature, git_buf_cstr(&reflog_message))) != 0)
+	if ((error = git_remote_fetch(remote, NULL, git_buf_cstr(&reflog_message))) != 0)
 		goto cleanup;
 
-	error = checkout_branch(repo, remote, co_opts, branch, signature, git_buf_cstr(&reflog_message));
+	error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));
 
 cleanup:
 	git_remote_free(remote);
@@ -442,11 +440,11 @@ int git_clone(
 		if (clone_local == 1)
 			error = clone_local_into(
 				repo, origin, &options.checkout_opts,
-				options.checkout_branch, link, options.signature);
+				options.checkout_branch, link);
 		else if (clone_local == 0)
 			error = clone_into(
 				repo, origin, &options.checkout_opts,
-				options.checkout_branch, options.signature);
+				options.checkout_branch);
 		else
 			error = -1;
 
@@ -508,7 +506,7 @@ static bool can_link(const char *src, const char *dst, int link)
 #endif
 }
 
-static int clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link, const git_signature *signature)
+static int clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link)
 {
 	int error, flags;
 	git_repository *src;
@@ -553,10 +551,10 @@ static int clone_local_into(git_repository *repo, git_remote *remote, const git_
 
 	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
 
-	if ((error = git_remote_fetch(remote, NULL, signature, git_buf_cstr(&reflog_message))) != 0)
+	if ((error = git_remote_fetch(remote, NULL, git_buf_cstr(&reflog_message))) != 0)
 		goto cleanup;
 
-	error = checkout_branch(repo, remote, co_opts, branch, signature, git_buf_cstr(&reflog_message));
+	error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));
 
 cleanup:
 	git_buf_free(&reflog_message);

data/vendor/libgit2/src/commit.c

@@ -104,7 +104,7 @@ int git_commit_create_from_callback(
 
 	if (update_ref != NULL) {
 		error = git_reference__update_for_commit(
-			repo, ref, update_ref, id, committer, "commit");
+			repo, ref, update_ref, id, "commit");
 		git_reference_free(ref);
 		return error;
 	}
@@ -295,7 +295,7 @@ int git_commit_amend(
 
 	if (!error && update_ref) {
 		error = git_reference__update_for_commit(
-			repo, ref, NULL, id, committer, "commit");
+			repo, ref, NULL, id, "commit");
 		git_reference_free(ref);
 	}
 
@@ -400,7 +400,7 @@ GIT_COMMIT_GETTER(const char *, raw_header, commit->raw_header)
 GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time)
 GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset)
 GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)git_array_size(commit->parent_ids))
-GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id);
+GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id)
 
 const char *git_commit_message(const git_commit *commit)
 {

data/vendor/libgit2/src/common.h

@@ -17,6 +17,11 @@
 # define GIT_INLINE(type) static inline type
 #endif
 
+/** Support for gcc/clang __has_builtin intrinsic */
+#ifndef __has_builtin
+# define __has_builtin(x) 0
+#endif
+
 #include <assert.h>
 #include <errno.h>
 #include <limits.h>
@@ -59,7 +64,7 @@
 #include "git2/types.h"
 #include "git2/errors.h"
 #include "thread-utils.h"
-#include "bswap.h"
+#include "integer.h"
 
 #include <regex.h>
 
@@ -176,6 +181,23 @@ GIT_INLINE(void) git__init_structure(void *structure, size_t len, unsigned int v
 	GITERR_CHECK_VERSION(&(VERSION), _tmpl.version, #TYPE);	\
 	memcpy((PTR), &_tmpl, sizeof(_tmpl)); } while (0)
 
+
+/** Check for additive overflow, setting an error if would occur. */
+#define GIT_ADD_SIZET_OVERFLOW(out, one, two) \
+	(git__add_sizet_overflow(out, one, two) ? (giterr_set_oom(), 1) : 0)
+
+/** Check for additive overflow, setting an error if would occur. */
+#define GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize) \
+	(git__multiply_sizet_overflow(out, nelem, elsize) ? (giterr_set_oom(), 1) : 0)
+
+/** Check for additive overflow, failing if it would occur. */
+#define GITERR_CHECK_ALLOC_ADD(out, one, two) \
+	if (GIT_ADD_SIZET_OVERFLOW(out, one, two)) { return -1; }
+
+/** Check for multiplicative overflow, failing if it would occur. */
+#define GITERR_CHECK_ALLOC_MULTIPLY(out, nelem, elsize) \
+	if (GIT_MULTIPLY_SIZET_OVERFLOW(out, nelem, elsize)) { return -1; }
+
 /* NOTE: other giterr functions are in the public errors.h header file */
 
 #include "util.h"

data/vendor/libgit2/src/config.c

@@ -19,6 +19,14 @@
 
 #include <ctype.h>
 
+void git_config_entry_free(git_config_entry *entry)
+{
+	if (!entry)
+		return;
+
+	entry->free(entry);
+}
+
 typedef struct {
 	git_refcount rc;
 
@@ -638,7 +646,7 @@ int git_config__update_entry(
 	bool only_if_existing)
 {
 	int error = 0;
-	const git_config_entry *ce = NULL;
+	git_config_entry *ce = NULL;
 
 	if ((error = git_config__lookup_entry(&ce, config, key, false)) < 0)
 		return error;
@@ -657,6 +665,7 @@ int git_config__update_entry(
 	else
 		error = git_config_set_string(config, key, value);
 
+	git_config_entry_free(ce);
 	return error;
 }
 
@@ -677,7 +686,7 @@ enum {
 };
 
 static int get_entry(
-	const git_config_entry **out,
+	git_config_entry **out,
 	const git_config *cfg,
 	const char *name,
 	bool normalize_name,
@@ -721,13 +730,13 @@ cleanup:
 }
 
 int git_config_get_entry(
-	const git_config_entry **out, const git_config *cfg, const char *name)
+	git_config_entry **out, const git_config *cfg, const char *name)
 {
 	return get_entry(out, cfg, name, true, GET_ALL_ERRORS);
 }
 
 int git_config__lookup_entry(
-	const git_config_entry **out,
+	git_config_entry **out,
 	const git_config *cfg,
 	const char *key,
 	bool no_errors)
@@ -743,76 +752,154 @@ int git_config_get_mapped(
 	const git_cvar_map *maps,
 	size_t map_n)
 {
-	const git_config_entry *entry;
+	git_config_entry *entry;
 	int ret;
 
 	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
 		return ret;
 
-	return git_config_lookup_map_value(out, maps, map_n, entry->value);
+	ret = git_config_lookup_map_value(out, maps, map_n, entry->value);
+	git_config_entry_free(entry);
+
+	return ret;
 }
 
 int git_config_get_int64(int64_t *out, const git_config *cfg, const char *name)
 {
-	const git_config_entry *entry;
+	git_config_entry *entry;
 	int ret;
 
 	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
 		return ret;
 
-	return git_config_parse_int64(out, entry->value);
+	ret = git_config_parse_int64(out, entry->value);
+	git_config_entry_free(entry);
+
+	return ret;
 }
 
 int git_config_get_int32(int32_t *out, const git_config *cfg, const char *name)
 {
-	const git_config_entry *entry;
+	git_config_entry *entry;
 	int ret;
 
 	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
 		return ret;
 
-	return git_config_parse_int32(out, entry->value);
+	ret = git_config_parse_int32(out, entry->value);
+	git_config_entry_free(entry);
+
+	return ret;
 }
 
 int git_config_get_bool(int *out, const git_config *cfg, const char *name)
 {
-	const git_config_entry *entry;
+	git_config_entry *entry;
 	int ret;
 
 	if ((ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
 		return ret;
 
-	return git_config_parse_bool(out, entry->value);
+	ret = git_config_parse_bool(out, entry->value);
+	git_config_entry_free(entry);
+
+	return ret;
+}
+
+static int is_readonly(const git_config *cfg)
+{
+	size_t i;
+	file_internal *internal;
+
+	git_vector_foreach(&cfg->files, i, internal) {
+		if (!internal || !internal->file)
+			continue;
+
+		if (!internal->file->readonly)
+			return 0;
+	}
+
+	return 1;
+}
+
+int git_config_get_path(git_buf *out, const git_config *cfg, const char *name)
+{
+	git_config_entry *entry;
+	int error;
+
+	if ((error = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS)) < 0)
+		return error;
+
+	 error = git_config_parse_path(out, entry->value);
+	 git_config_entry_free(entry);
+
+	 return error;
 }
 
 int git_config_get_string(
 	const char **out, const git_config *cfg, const char *name)
 {
-	const git_config_entry *entry;
-	int ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
+	git_config_entry *entry;
+	int ret;
+
+	if (!is_readonly(cfg)) {
+		giterr_set(GITERR_CONFIG, "get_string called on a live config object");
+		return -1;
+	}
+
+	ret = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
 	*out = !ret ? (entry->value ? entry->value : "") : NULL;
+
+	git_config_entry_free(entry);
+
 	return ret;
 }
 
-const char *git_config__get_string_force(
+int git_config_get_string_buf(
+	git_buf *out, const git_config *cfg, const char *name)
+{
+	git_config_entry *entry;
+	int ret;
+	const char *str;
+
+	git_buf_sanitize(out);
+
+	ret  = get_entry(&entry, cfg, name, true, GET_ALL_ERRORS);
+	str = !ret ? (entry->value ? entry->value : "") : NULL;
+
+	if (str)
+		ret = git_buf_puts(out, str);
+
+	git_config_entry_free(entry);
+
+	return ret;
+}
+
+char *git_config__get_string_force(
 	const git_config *cfg, const char *key, const char *fallback_value)
 {
-	const git_config_entry *entry;
+	git_config_entry *entry;
+	char *ret;
+
 	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
-	return (entry && entry->value) ? entry->value : fallback_value;
+	ret = (entry && entry->value) ? git__strdup(entry->value) : fallback_value ? git__strdup(fallback_value) : NULL;
+	git_config_entry_free(entry);
+
+	return ret;
 }
 
 int git_config__get_bool_force(
 	const git_config *cfg, const char *key, int fallback_value)
 {
 	int val = fallback_value;
-	const git_config_entry *entry;
+	git_config_entry *entry;
 
 	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
 
 	if (entry && git_config_parse_bool(&val, entry->value) < 0)
 		giterr_clear();
 
+	git_config_entry_free(entry);
 	return val;
 }
 
@@ -820,13 +907,14 @@ int git_config__get_int_force(
 	const git_config *cfg, const char *key, int fallback_value)
 {
 	int32_t val = (int32_t)fallback_value;
-	const git_config_entry *entry;
+	git_config_entry *entry;
 
 	get_entry(&entry, cfg, key, false, GET_NO_ERRORS);
 
 	if (entry && git_config_parse_int32(&val, entry->value) < 0)
 		giterr_clear();
 
+	git_config_entry_free(entry);
 	return (int)val;
 }
 
@@ -1184,6 +1272,36 @@ fail_parse:
 	return -1;
 }
 
+int git_config_parse_path(git_buf *out, const char *value)
+{
+	int error = 0;
+	const git_buf *home;
+
+	assert(out && value);
+
+	git_buf_sanitize(out);
+
+	if (value[0] == '~') {
+		if (value[1] != '\0' && value[1] != '/') {
+			giterr_set(GITERR_CONFIG, "retrieving a homedir by name is not supported");
+			return -1;
+		}
+
+		if ((error = git_sysdir_get(&home, GIT_SYSDIR_GLOBAL)) < 0)
+			return error;
+
+		git_buf_sets(out, home->ptr);
+		git_buf_puts(out, value + 1);
+
+		if (git_buf_oom(out))
+			return -1;
+
+		return 0;
+	}
+
+	return git_buf_sets(out, value);
+}
+
 /* Take something the user gave us and make it nice for our hash function */
 int git_config__normalize_name(const char *in, char **out)
 {