rugged 1.0.0 → 1.2.0

data/vendor/libgit2/src/repository.h

@@ -51,6 +51,7 @@ typedef enum {
 	GIT_CONFIGMAP_PROTECTHFS,       /* core.protectHFS */
 	GIT_CONFIGMAP_PROTECTNTFS,      /* core.protectNTFS */
 	GIT_CONFIGMAP_FSYNCOBJECTFILES, /* core.fsyncObjectFiles */
+	GIT_CONFIGMAP_LONGPATHS,        /* core.longpaths */
 	GIT_CONFIGMAP_CACHE_MAX
 } git_configmap_item;
 
@@ -116,6 +117,8 @@ typedef enum {
 	GIT_PROTECTNTFS_DEFAULT = GIT_CONFIGMAP_TRUE,
 	/* core.fsyncObjectFiles */
 	GIT_FSYNCOBJECTFILES_DEFAULT = GIT_CONFIGMAP_FALSE,
+	/* core.longpaths */
+	GIT_LONGPATHS_DEFAULT = GIT_CONFIGMAP_FALSE,
 } git_configmap_value;
 
 /* internal repository init flags */
@@ -152,9 +155,9 @@ struct git_repository {
 
 	unsigned int lru_counter;
 
-	git_atomic attr_session_key;
+	git_atomic32 attr_session_key;
 
-	git_configmap_value configmap_cache[GIT_CONFIGMAP_CACHE_MAX];
+	intptr_t configmap_cache[GIT_CONFIGMAP_CACHE_MAX];
 	git_strmap *submodule_cache;
 };
 
@@ -166,34 +169,11 @@ GIT_INLINE(git_attr_cache *) git_repository_attr_cache(git_repository *repo)
 int git_repository_head_tree(git_tree **tree, git_repository *repo);
 int git_repository_create_head(const char *git_dir, const char *ref_name);
 
-/*
- * Called for each HEAD.
- *
- * Can return either 0, causing the iteration over HEADs to
- * continue, or a non-0 value causing the iteration to abort. The
- * return value is passed back to the caller of
- * `git_repository_foreach_head`
- */
-typedef int (*git_repository_foreach_head_cb)(git_repository *repo, const char *path, void *payload);
+typedef int (*git_repository_foreach_worktree_cb)(git_repository *, void *);
 
-enum {
-	/* Skip enumeration of the main repository HEAD */
-	GIT_REPOSITORY_FOREACH_HEAD_SKIP_REPO      = (1u << 0),
-	/* Skip enumeration of worktree HEADs */
-	GIT_REPOSITORY_FOREACH_HEAD_SKIP_WORKTREES = (1u << 1),
-};
-
-/*
- * Iterate over repository and all worktree HEADs.
- *
- * This function will be called for the repository HEAD and for
- * all HEADS of linked worktrees. For each HEAD, the callback is
- * executed with the given payload. The return value equals the
- * return value of the last executed callback function.
- */
-int git_repository_foreach_head(git_repository *repo,
-				git_repository_foreach_head_cb cb,
-				int flags, void *payload);
+int git_repository_foreach_worktree(git_repository *repo,
+				    git_repository_foreach_worktree_cb cb,
+				    void *payload);
 
 /*
  * Weak pointers to repository internals.
@@ -255,4 +235,18 @@ extern size_t git_repository__reserved_names_posix_len;
 bool git_repository__reserved_names(
 	git_buf **out, size_t *outlen, git_repository *repo, bool include_ntfs);
 
+/*
+ * The default branch for the repository; the `init.defaultBranch`
+ * configuration option, if set, or `master` if it is not.
+ */
+int git_repository_initialbranch(git_buf *out, git_repository *repo);
+
+/*
+ * Given a relative `path`, this makes it absolute based on the
+ * repository's working directory.  This will perform validation
+ * to ensure that the path is not longer than MAX_PATH on Windows
+ * (unless `core.longpaths` is set in the repo config).
+ */
+int git_repository_workdir_path(git_buf *out, git_repository *repo, const char *path);
+
 #endif

data/vendor/libgit2/src/reset.c

@@ -33,7 +33,7 @@ int git_reset_default(
 	int error;
 	git_index *index = NULL;
 
-	assert(pathspecs != NULL && pathspecs->count > 0);
+	GIT_ASSERT_ARG(pathspecs && pathspecs->count > 0);
 
 	memset(&entry, 0, sizeof(git_index_entry));
 
@@ -62,10 +62,10 @@ int git_reset_default(
 	for (i = 0, max_i = git_diff_num_deltas(diff); i < max_i; ++i) {
 		const git_diff_delta *delta = git_diff_get_delta(diff, i);
 
-		assert(delta->status == GIT_DELTA_ADDED ||
-			delta->status == GIT_DELTA_MODIFIED ||
-			delta->status == GIT_DELTA_CONFLICTED ||
-			delta->status == GIT_DELTA_DELETED);
+		GIT_ASSERT(delta->status == GIT_DELTA_ADDED ||
+		           delta->status == GIT_DELTA_MODIFIED ||
+		           delta->status == GIT_DELTA_CONFLICTED ||
+		           delta->status == GIT_DELTA_DELETED);
 
 		error = git_index_conflict_remove(index, delta->old_file.path);
 		if (error < 0) {
@@ -113,7 +113,8 @@ static int reset(
 	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
 	git_buf log_message = GIT_BUF_INIT;
 
-	assert(repo && target);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(target);
 
 	if (checkout_opts)
 		opts = *checkout_opts;

data/vendor/libgit2/src/revert.c

@@ -129,7 +129,10 @@ int git_revert_commit(
 	git_tree *parent_tree = NULL, *our_tree = NULL, *revert_tree = NULL;
 	int parent = 0, error = 0;
 
-	assert(out && repo && revert_commit && our_commit);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(revert_commit);
+	GIT_ASSERT_ARG(our_commit);
 
 	if (git_commit_parentcount(revert_commit) > 1) {
 		if (!mainline)
@@ -180,7 +183,8 @@ int git_revert(
 	git_indexwriter indexwriter = GIT_INDEXWRITER_INIT;
 	int error;
 
-	assert(repo && commit);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(commit);
 
 	GIT_ERROR_CHECK_VERSION(given_opts, GIT_REVERT_OPTIONS_VERSION, "git_revert_options");
 
@@ -231,7 +235,9 @@ int git_revert_options_init(git_revert_options *opts, unsigned int version)
 	return 0;
 }
 
+#ifndef GIT_DEPRECATE_HARD
 int git_revert_init_options(git_revert_options *opts, unsigned int version)
 {
 	return git_revert_options_init(opts, version);
 }
+#endif

data/vendor/libgit2/src/revparse.c

@@ -317,7 +317,7 @@ static int handle_at_syntax(git_object **out, git_reference **ref, const char *s
 	git_buf identifier = GIT_BUF_INIT;
 	git_time_t timestamp;
 
-	assert(*out == NULL);
+	GIT_ASSERT(*out == NULL);
 
 	if (git_buf_put(&identifier, spec, identifier_len) < 0)
 		return -1;
@@ -524,7 +524,7 @@ static int extract_curly_braces_content(git_buf *buf, const char *spec, size_t *
 {
 	git_buf_clear(buf);
 
-	assert(spec[*pos] == '^' || spec[*pos] == '@');
+	GIT_ASSERT_ARG(spec[*pos] == '^' || spec[*pos] == '@');
 
 	(*pos)++;
 
@@ -537,7 +537,8 @@ static int extract_curly_braces_content(git_buf *buf, const char *spec, size_t *
 		if (spec[*pos] == '\0')
 			return GIT_EINVALIDSPEC;
 
-		git_buf_putc(buf, spec[(*pos)++]);
+		if (git_buf_putc(buf, spec[(*pos)++]) < 0)
+			return -1;
 	}
 
 	(*pos)++;
@@ -549,7 +550,7 @@ static int extract_path(git_buf *buf, const char *spec, size_t *pos)
 {
 	git_buf_clear(buf);
 
-	assert(spec[*pos] == ':');
+	GIT_ASSERT_ARG(spec[*pos] == ':');
 
 	(*pos)++;
 
@@ -567,7 +568,7 @@ static int extract_how_many(int *n, const char *spec, size_t *pos)
 	int parsed, accumulated;
 	char kind = spec[*pos];
 
-	assert(spec[*pos] == '^' || spec[*pos] == '~');
+	GIT_ASSERT_ARG(spec[*pos] == '^' || spec[*pos] == '~');
 
 	accumulated = 0;
 
@@ -585,7 +586,7 @@ static int extract_how_many(int *n, const char *spec, size_t *pos)
 			*pos = end_ptr - spec;
 		}
 
-	} 	while (spec[(*pos)] == kind && kind == '~');
+	} while (spec[(*pos)] == kind && kind == '~');
 
 	*n = accumulated;
 
@@ -659,7 +660,7 @@ static int ensure_left_hand_identifier_is_not_known_yet(git_object *object, git_
 	return GIT_EINVALIDSPEC;
 }
 
-int revparse__ext(
+static int revparse(
 	git_object **object_out,
 	git_reference **reference_out,
 	size_t *identifier_len_out,
@@ -675,7 +676,10 @@ int revparse__ext(
 
 	bool should_return_reference = true;
 
-	assert(object_out && reference_out && repo && spec);
+	GIT_ASSERT_ARG(object_out);
+	GIT_ASSERT_ARG(reference_out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(spec);
 
 	*object_out = NULL;
 	*reference_out = NULL;
@@ -835,7 +839,7 @@ int git_revparse_ext(
 	git_object *obj = NULL;
 	git_reference *ref = NULL;
 
-	if ((error = revparse__ext(&obj, &ref, &identifier_len, repo, spec)) < 0)
+	if ((error = revparse(&obj, &ref, &identifier_len, repo, spec)) < 0)
 		goto cleanup;
 
 	*object_out = obj;
@@ -881,14 +885,16 @@ int git_revparse(
 	const char *dotdot;
 	int error = 0;
 
-	assert(revspec && repo && spec);
+	GIT_ASSERT_ARG(revspec);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(spec);
 
 	memset(revspec, 0x0, sizeof(*revspec));
 
 	if ((dotdot = strstr(spec, "..")) != NULL) {
 		char *lstr;
 		const char *rstr;
-		revspec->flags = GIT_REVPARSE_RANGE;
+		revspec->flags = GIT_REVSPEC_RANGE;
 
 		/*
 		 * Following git.git, don't allow '..' because it makes command line
@@ -904,7 +910,7 @@ int git_revparse(
 		lstr = git__substrdup(spec, dotdot - spec);
 		rstr = dotdot + 2;
 		if (dotdot[2] == '.') {
-			revspec->flags |= GIT_REVPARSE_MERGE_BASE;
+			revspec->flags |= GIT_REVSPEC_MERGE_BASE;
 			rstr++;
 		}
 
@@ -922,7 +928,7 @@ int git_revparse(
 
 		git__free((void*)lstr);
 	} else {
-		revspec->flags = GIT_REVPARSE_SINGLE;
+		revspec->flags = GIT_REVSPEC_SINGLE;
 		error = git_revparse_single(&revspec->from, repo, spec);
 	}
 

data/vendor/libgit2/src/revwalk.c

@@ -99,7 +99,8 @@ int git_revwalk_push(git_revwalk *walk, const git_oid *oid)
 {
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
 
-	assert(walk && oid);
+	GIT_ASSERT_ARG(walk);
+	GIT_ASSERT_ARG(oid);
 
 	return git_revwalk__push_commit(walk, oid, &opts);
 }
@@ -108,7 +109,9 @@ int git_revwalk_push(git_revwalk *walk, const git_oid *oid)
 int git_revwalk_hide(git_revwalk *walk, const git_oid *oid)
 {
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
-	assert(walk && oid);
+
+	GIT_ASSERT_ARG(walk);
+	GIT_ASSERT_ARG(oid);
 
 	opts.uninteresting = 1;
 	return git_revwalk__push_commit(walk, oid, &opts);
@@ -133,7 +136,8 @@ int git_revwalk__push_glob(git_revwalk *walk, const char *glob, const git_revwal
 	git_reference_iterator *iter;
 	size_t wildcard;
 
-	assert(walk && glob);
+	GIT_ASSERT_ARG(walk);
+	GIT_ASSERT_ARG(glob);
 
 	if (given_opts)
 		memcpy(&opts, given_opts, sizeof(opts));
@@ -172,7 +176,9 @@ out:
 int git_revwalk_push_glob(git_revwalk *walk, const char *glob)
 {
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
-	assert(walk && glob);
+
+	GIT_ASSERT_ARG(walk);
+	GIT_ASSERT_ARG(glob);
 
 	return git_revwalk__push_glob(walk, glob, &opts);
 }
@@ -180,7 +186,9 @@ int git_revwalk_push_glob(git_revwalk *walk, const char *glob)
 int git_revwalk_hide_glob(git_revwalk *walk, const char *glob)
 {
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
-	assert(walk && glob);
+
+	GIT_ASSERT_ARG(walk);
+	GIT_ASSERT_ARG(glob);
 
 	opts.uninteresting = 1;
 	return git_revwalk__push_glob(walk, glob, &opts);
@@ -189,7 +197,8 @@ int git_revwalk_hide_glob(git_revwalk *walk, const char *glob)
 int git_revwalk_push_head(git_revwalk *walk)
 {
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
-	assert(walk);
+
+	GIT_ASSERT_ARG(walk);
 
 	return git_revwalk__push_ref(walk, GIT_HEAD_FILE, &opts);
 }
@@ -197,7 +206,8 @@ int git_revwalk_push_head(git_revwalk *walk)
 int git_revwalk_hide_head(git_revwalk *walk)
 {
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
-	assert(walk);
+
+	GIT_ASSERT_ARG(walk);
 
 	opts.uninteresting = 1;
 	return git_revwalk__push_ref(walk, GIT_HEAD_FILE, &opts);
@@ -206,7 +216,9 @@ int git_revwalk_hide_head(git_revwalk *walk)
 int git_revwalk_push_ref(git_revwalk *walk, const char *refname)
 {
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
-	assert(walk && refname);
+
+	GIT_ASSERT_ARG(walk);
+	GIT_ASSERT_ARG(refname);
 
 	return git_revwalk__push_ref(walk, refname, &opts);
 }
@@ -226,7 +238,7 @@ int git_revwalk_push_range(git_revwalk *walk, const char *range)
 		goto out;
 	}
 
-	if (revspec.flags & GIT_REVPARSE_MERGE_BASE) {
+	if (revspec.flags & GIT_REVSPEC_MERGE_BASE) {
 		/* TODO: support "<commit>...<commit>" */
 		git_error_set(GIT_ERROR_INVALID, "symmetric differences not implemented in revwalk");
 		error = GIT_EINVALIDSPEC;
@@ -249,7 +261,10 @@ out:
 int git_revwalk_hide_ref(git_revwalk *walk, const char *refname)
 {
 	git_revwalk__push_options opts = GIT_REVWALK__PUSH_OPTIONS_INIT;
-	assert(walk && refname);
+
+	GIT_ASSERT_ARG(walk);
+	GIT_ASSERT_ARG(refname);
+
 	opts.uninteresting = 1;
 	return git_revwalk__push_ref(walk, refname, &opts);
 }
@@ -659,13 +674,11 @@ int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
 	git_revwalk *walk = git__calloc(1, sizeof(git_revwalk));
 	GIT_ERROR_CHECK_ALLOC(walk);
 
-	if (git_oidmap_new(&walk->commits) < 0)
+	if (git_oidmap_new(&walk->commits) < 0 ||
+	    git_pqueue_init(&walk->iterator_time, 0, 8, git_commit_list_time_cmp) < 0 ||
+	    git_pool_init(&walk->commit_pool, COMMIT_ALLOC) < 0)
 		return -1;
 
-	if (git_pqueue_init(&walk->iterator_time, 0, 8, git_commit_list_time_cmp) < 0)
-		return -1;
-
-	git_pool_init(&walk->commit_pool, COMMIT_ALLOC);
 	walk->get_next = &revwalk_next_unsorted;
 	walk->enqueue = &revwalk_enqueue_unsorted;
 
@@ -696,13 +709,14 @@ void git_revwalk_free(git_revwalk *walk)
 
 git_repository *git_revwalk_repository(git_revwalk *walk)
 {
-	assert(walk);
+	GIT_ASSERT_ARG_WITH_RETVAL(walk, NULL);
+
 	return walk->repo;
 }
 
 int git_revwalk_sorting(git_revwalk *walk, unsigned int sort_mode)
 {
-	assert(walk);
+	GIT_ASSERT_ARG(walk);
 
 	if (walk->walking)
 		git_revwalk_reset(walk);
@@ -734,7 +748,8 @@ int git_revwalk_next(git_oid *oid, git_revwalk *walk)
 	int error;
 	git_commit_list_node *next;
 
-	assert(walk && oid);
+	GIT_ASSERT_ARG(walk);
+	GIT_ASSERT_ARG(oid);
 
 	if (!walk->walking) {
 		if ((error = prepare_walk(walk)) < 0)
@@ -759,7 +774,7 @@ int git_revwalk_reset(git_revwalk *walk)
 {
 	git_commit_list_node *commit;
 
-	assert(walk);
+	GIT_ASSERT_ARG(walk);
 
 	git_oidmap_foreach_value(walk->commits, commit, {
 		commit->seen = 0;
@@ -789,7 +804,7 @@ int git_revwalk_add_hide_cb(
 	git_revwalk_hide_cb hide_cb,
 	void *payload)
 {
-	assert(walk);
+	GIT_ASSERT_ARG(walk);
 
 	if (walk->walking)
 		git_revwalk_reset(walk);

data/vendor/libgit2/src/runtime.c

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+#include "runtime.h"
+
+static git_runtime_shutdown_fn shutdown_callback[32];
+static git_atomic32 shutdown_callback_count;
+
+static git_atomic32 init_count;
+
+static int init_common(git_runtime_init_fn init_fns[], size_t cnt)
+{
+	size_t i;
+	int ret;
+
+	/* Initialize subsystems that have global state */
+	for (i = 0; i < cnt; i++) {
+		if ((ret = init_fns[i]()) != 0)
+			break;
+	}
+
+	GIT_MEMORY_BARRIER;
+
+	return ret;
+}
+
+static void shutdown_common(void)
+{
+	git_runtime_shutdown_fn cb;
+	int pos;
+
+	for (pos = git_atomic32_get(&shutdown_callback_count);
+	     pos > 0;
+	     pos = git_atomic32_dec(&shutdown_callback_count)) {
+		cb = git_atomic_swap(shutdown_callback[pos - 1], NULL);
+
+		if (cb != NULL)
+			cb();
+	}
+}
+
+int git_runtime_shutdown_register(git_runtime_shutdown_fn callback)
+{
+	int count = git_atomic32_inc(&shutdown_callback_count);
+
+	if (count > (int)ARRAY_SIZE(shutdown_callback) || count == 0) {
+		git_error_set(GIT_ERROR_INVALID,
+		              "too many shutdown callbacks registered");
+		git_atomic32_dec(&shutdown_callback_count);
+		return -1;
+	}
+
+	shutdown_callback[count - 1] = callback;
+
+	return 0;
+}
+
+#if defined(GIT_THREADS) && defined(GIT_WIN32)
+
+/*
+ * On Win32, we use a spinlock to provide locking semantics.  This is
+ * lighter-weight than a proper critical section.
+ */
+static volatile LONG init_spinlock = 0;
+
+GIT_INLINE(int) init_lock(void)
+{
+	while (InterlockedCompareExchange(&init_spinlock, 1, 0)) { Sleep(0); }
+	return 0;
+}
+
+GIT_INLINE(int) init_unlock(void)
+{
+	InterlockedExchange(&init_spinlock, 0);
+	return 0;
+}
+
+#elif defined(GIT_THREADS) && defined(_POSIX_THREADS)
+
+/*
+ * On POSIX, we need to use a proper mutex for locking.  We might prefer
+ * a spinlock here, too, but there's no static initializer for a
+ * pthread_spinlock_t.
+ */
+static pthread_mutex_t init_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+GIT_INLINE(int) init_lock(void)
+{
+	return pthread_mutex_lock(&init_mutex) == 0 ? 0 : -1;
+}
+
+GIT_INLINE(int) init_unlock(void)
+{
+	return pthread_mutex_unlock(&init_mutex) == 0 ? 0 : -1;
+}
+
+#elif defined(GIT_THREADS)
+# error unknown threading model
+#else
+
+# define init_lock() git__noop()
+# define init_unlock() git__noop()
+
+#endif
+
+int git_runtime_init(git_runtime_init_fn init_fns[], size_t cnt)
+{
+	int ret;
+
+	if (init_lock() < 0)
+		return -1;
+
+	/* Only do work on a 0 -> 1 transition of the refcount */
+	if ((ret = git_atomic32_inc(&init_count)) == 1) {
+		if (init_common(init_fns, cnt) < 0)
+			ret = -1;
+	}
+
+	if (init_unlock() < 0)
+		return -1;
+
+	return ret;
+}
+
+int git_runtime_init_count(void)
+{
+	int ret;
+
+	if (init_lock() < 0)
+		return -1;
+
+	ret = git_atomic32_get(&init_count);
+
+	if (init_unlock() < 0)
+		return -1;
+
+	return ret;
+}
+
+int git_runtime_shutdown(void)
+{
+	int ret;
+
+	/* Enter the lock */
+	if (init_lock() < 0)
+		return -1;
+
+	/* Only do work on a 1 -> 0 transition of the refcount */
+	if ((ret = git_atomic32_dec(&init_count)) == 0)
+		shutdown_common();
+
+	/* Exit the lock */
+	if (init_unlock() < 0)
+		return -1;
+
+	return ret;
+}