rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/libgit2/refdb_fs.c

@@ -26,7 +26,6 @@
 #include <git2/branch.h>
 #include <git2/sys/refdb_backend.h>
 #include <git2/sys/refs.h>
-#include <git2/sys/reflog.h>
 
 #define DEFAULT_NESTING_LEVEL	5
 #define MAX_NESTING_LEVEL		10
@@ -62,8 +61,8 @@ typedef struct refdb_fs_backend {
 
 	git_oid_t oid_type;
 
-	int fsync : 1,
-	    sorted : 1;
+	unsigned int fsync : 1,
+	             sorted : 1;
 	int peeling_mode;
 	git_iterator_flag_t iterator_flags;
 	uint32_t direach_flags;
@@ -410,7 +409,9 @@ static const char *loose_parse_symbolic(git_str *file_content)
 static bool is_per_worktree_ref(const char *ref_name)
 {
 	return git__prefixcmp(ref_name, "refs/") != 0 ||
-	    git__prefixcmp(ref_name, "refs/bisect/") == 0;
+	       git__prefixcmp(ref_name, "refs/bisect/") == 0 ||
+	       git__prefixcmp(ref_name, "refs/worktree/") == 0 ||
+	       git__prefixcmp(ref_name, "refs/rewritten/") == 0;
 }
 
 static int loose_lookup(
@@ -799,86 +800,155 @@ static void refdb_fs_backend__iterator_free(git_reference_iterator *_iter)
 {
 	refdb_fs_iter *iter = GIT_CONTAINER_OF(_iter, refdb_fs_iter, parent);
 
-	git_vector_free(&iter->loose);
+	git_vector_dispose(&iter->loose);
 	git_pool_clear(&iter->pool);
 	git_sortedcache_free(iter->cache);
 	git__free(iter);
 }
 
-static int iter_load_loose_paths(refdb_fs_backend *backend, refdb_fs_iter *iter)
+struct iter_load_context {
+	refdb_fs_backend *backend;
+	refdb_fs_iter *iter;
+
+	/*
+	 * If we have a glob with a prefix (eg `refs/heads/ *`) then we can
+	 * optimize our prefix to avoid walking refs that we know won't
+	 * match. This is that prefix.
+	 */
+	const char *ref_prefix;
+	size_t ref_prefix_len;
+
+	/* Temporary variables to avoid unnecessary allocations */
+	git_str ref_name;
+	git_str path;
+};
+
+static void iter_load_optimize_prefix(struct iter_load_context *ctx)
 {
-	int error = 0;
-	git_str path = GIT_STR_INIT;
-	git_iterator *fsit = NULL;
-	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
-	const git_index_entry *entry = NULL;
-	const char *ref_prefix = GIT_REFS_DIR;
-	size_t ref_prefix_len = strlen(ref_prefix);
+	const char *pos, *last_sep = NULL;
 
-	if (!backend->commonpath) /* do nothing if no commonpath for loose refs */
-		return 0;
+	if (!ctx->iter->glob)
+		return;
 
-	fsit_opts.flags = backend->iterator_flags;
-
-	if (iter->glob) {
-		const char *last_sep = NULL;
-		const char *pos;
-		for (pos = iter->glob; *pos; ++pos) {
-			switch (*pos) {
-			case '?':
-			case '*':
-			case '[':
-			case '\\':
-				break;
-			case '/':
-				last_sep = pos;
-				/* FALLTHROUGH */
-			default:
-				continue;
-			}
+	for (pos = ctx->iter->glob; *pos; pos++) {
+		switch (*pos) {
+		case '?':
+		case '*':
+		case '[':
+		case '\\':
 			break;
+		case '/':
+			last_sep = pos;
+			/* FALLTHROUGH */
+		default:
+			continue;
 		}
-		if (last_sep) {
-			ref_prefix = iter->glob;
-			ref_prefix_len = (last_sep - ref_prefix) + 1;
-		}
+		break;
 	}
 
-	if ((error = git_str_puts(&path, backend->commonpath)) < 0 ||
-		(error = git_str_put(&path, ref_prefix, ref_prefix_len)) < 0) {
-		git_str_dispose(&path);
-		return error;
+	if (last_sep) {
+		ctx->ref_prefix = ctx->iter->glob;
+		ctx->ref_prefix_len = (last_sep - ctx->ref_prefix) + 1;
 	}
+}
+
+static int iter_load_paths(
+	struct iter_load_context *ctx,
+	const char *root_path,
+	bool worktree)
+{
+	git_iterator *fsit = NULL;
+	git_iterator_options fsit_opts = GIT_ITERATOR_OPTIONS_INIT;
+	const git_index_entry *entry;
+	int error = 0;
+
+	fsit_opts.flags = ctx->backend->iterator_flags;
+
+	git_str_clear(&ctx->path);
+	git_str_puts(&ctx->path, root_path);
+	git_str_put(&ctx->path, ctx->ref_prefix, ctx->ref_prefix_len);
 
-	if ((error = git_iterator_for_filesystem(&fsit, path.ptr, &fsit_opts)) < 0) {
-		git_str_dispose(&path);
-		return (iter->glob && error == GIT_ENOTFOUND)? 0 : error;
+	fsit_opts.flags = ctx->backend->iterator_flags;
+	fsit_opts.oid_type = ctx->backend->oid_type;
+
+	if ((error = git_iterator_for_filesystem(&fsit, ctx->path.ptr, &fsit_opts)) < 0) {
+		/*
+		 * Subdirectories - either glob provided or per-worktree refs - need
+		 * not exist.
+		 */
+		if ((worktree || ctx->iter->glob) && error == GIT_ENOTFOUND)
+			error = 0;
+
+		goto done;
 	}
 
-	error = git_str_sets(&path, ref_prefix);
+	git_str_clear(&ctx->ref_name);
+	git_str_put(&ctx->ref_name, ctx->ref_prefix, ctx->ref_prefix_len);
 
-	while (!error && !git_iterator_advance(&entry, fsit)) {
-		const char *ref_name;
+	while (git_iterator_advance(&entry, fsit) == 0) {
 		char *ref_dup;
 
-		git_str_truncate(&path, ref_prefix_len);
-		git_str_puts(&path, entry->path);
-		ref_name = git_str_cstr(&path);
+		git_str_truncate(&ctx->ref_name, ctx->ref_prefix_len);
+		git_str_puts(&ctx->ref_name, entry->path);
+
+		if (worktree) {
+			if (!is_per_worktree_ref(ctx->ref_name.ptr))
+				continue;
+		} else {
+			if (git_repository_is_worktree(ctx->backend->repo) &&
+			    is_per_worktree_ref(ctx->ref_name.ptr))
+				continue;
+		}
 
-		if (git__suffixcmp(ref_name, ".lock") == 0 ||
-			(iter->glob && wildmatch(iter->glob, ref_name, 0) != 0))
+		if (git__suffixcmp(ctx->ref_name.ptr, ".lock") == 0)
 			continue;
 
-		ref_dup = git_pool_strdup(&iter->pool, ref_name);
-		if (!ref_dup)
-			error = -1;
-		else
-			error = git_vector_insert(&iter->loose, ref_dup);
+		if (ctx->iter->glob && wildmatch(ctx->iter->glob, ctx->ref_name.ptr, 0))
+			continue;
+
+		ref_dup = git_pool_strdup(&ctx->iter->pool, ctx->ref_name.ptr);
+		GIT_ERROR_CHECK_ALLOC(ref_dup);
+
+		if ((error = git_vector_insert(&ctx->iter->loose, ref_dup)) < 0)
+			goto done;
 	}
 
+done:
 	git_iterator_free(fsit);
-	git_str_dispose(&path);
+	return error;
+}
+
+#define iter_load_context_init(b, i) { b, i, GIT_REFS_DIR, CONST_STRLEN(GIT_REFS_DIR) }
+#define iter_load_context_dispose(ctx) do {  \
+	git_str_dispose(&((ctx)->path));     \
+	git_str_dispose(&((ctx)->ref_name)); \
+} while(0)
 
+static int iter_load_loose_paths(
+	refdb_fs_backend *backend,
+	refdb_fs_iter *iter)
+{
+	struct iter_load_context ctx = iter_load_context_init(backend, iter);
+
+	int error = 0;
+
+	if (!backend->commonpath)
+		return 0;
+
+	iter_load_optimize_prefix(&ctx);
+
+	if ((error = iter_load_paths(&ctx,
+			backend->commonpath, false)) < 0)
+		goto done;
+
+	if (git_repository_is_worktree(backend->repo)) {
+		if ((error = iter_load_paths(&ctx,
+				backend->gitpath, true)) < 0)
+			goto done;
+	}
+
+done:
+	iter_load_context_dispose(&ctx);
 	return error;
 }
 
@@ -1782,7 +1852,7 @@ static int refdb_fs_backend__rename(
 		(error = refdb_fs_backend__lookup(&old, _backend, old_name)) < 0)
 		return error;
 
-	if ((error = refdb_fs_backend__delete(_backend, old_name, NULL, NULL)) < 0) {
+	if ((error = loose_lock(&file, backend, old->name)) < 0) {
 		git_reference_free(old);
 		return error;
 	}
@@ -1790,32 +1860,33 @@ static int refdb_fs_backend__rename(
 	new = git_reference__realloc(&old, new_name);
 	if (!new) {
 		git_reference_free(old);
+		git_filebuf_cleanup(&file);
 		return -1;
 	}
 
-	if ((error = loose_lock(&file, backend, new->name)) < 0) {
+	if ((error = refdb_fs_backend__delete_tail(_backend, &file, old_name, NULL, NULL)) < 0) {
 		git_reference_free(new);
+		git_filebuf_cleanup(&file);
 		return error;
 	}
 
-	/* Try to rename the refog; it's ok if the old doesn't exist */
-	error = refdb_reflog_fs__rename(_backend, old_name, new_name);
-	if (((error == 0) || (error == GIT_ENOTFOUND)) &&
-	    ((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) {
+	if ((error = loose_lock(&file, backend, new_name)) < 0) {
 		git_reference_free(new);
-		git_filebuf_cleanup(&file);
 		return error;
 	}
 
-	if (error < 0) {
+	/* Try to rename the refog; it's ok if the old doesn't exist */
+	error = refdb_reflog_fs__rename(_backend, old_name, new_name);
+	if (((error == 0) || (error == GIT_ENOTFOUND)) &&
+		((error = reflog_append(backend, new, git_reference_target(new), NULL, who, message)) < 0)) {
 		git_reference_free(new);
 		git_filebuf_cleanup(&file);
 		return error;
 	}
 
-
 	if ((error = loose_commit(&file, new)) < 0 || out == NULL) {
 		git_reference_free(new);
+		git_filebuf_cleanup(&file);
 		return error;
 	}
 
@@ -1949,9 +2020,9 @@ static int reflog_parse(git_reflog *log, const char *buf, size_t buf_size)
 		entry->committer = git__calloc(1, sizeof(*entry->committer));
 		GIT_ERROR_CHECK_ALLOC(entry->committer);
 
-		if (git_parse_advance_oid(&entry->oid_old, &parser) < 0 ||
+		if (git_parse_advance_oid(&entry->oid_old, &parser, log->oid_type) < 0 ||
 		    git_parse_advance_expected(&parser, " ", 1) < 0 ||
-		    git_parse_advance_oid(&entry->oid_cur, &parser) < 0)
+		    git_parse_advance_oid(&entry->oid_cur, &parser, log->oid_type) < 0)
 			goto next;
 
 		sig = parser.line;
@@ -2398,7 +2469,12 @@ static int refdb_reflog_fs__delete(git_refdb_backend *_backend, const char *name
 	if ((error = reflog_path(&path, backend->repo, name)) < 0)
 		goto out;
 
-	if (!git_fs_path_exists(path.ptr))
+	/*
+	 * If a reference was moved downwards, eg refs/heads/br2 -> refs/heads/br2/new-name,
+	 * refs/heads/br2 does exist but it's a directory. That's a valid situation.
+	 * Proceed only if it's a file.
+	 */
+	if (!git_fs_path_isfile(path.ptr))
 		goto out;
 
 	if ((error = p_unlink(path.ptr)) < 0)

data/vendor/libgit2/src/libgit2/reflog.c

@@ -13,7 +13,6 @@
 #include "refdb.h"
 
 #include "git2/sys/refdb_backend.h"
-#include "git2/sys/reflog.h"
 
 void git_reflog_entry__free(git_reflog_entry *entry)
 {
@@ -40,7 +39,7 @@ void git_reflog_free(git_reflog *reflog)
 		git_reflog_entry__free(entry);
 	}
 
-	git_vector_free(&reflog->entries);
+	git_vector_dispose(&reflog->entries);
 	git__free(reflog->ref_name);
 	git__free(reflog);
 }

data/vendor/libgit2/src/libgit2/reflog.h

@@ -37,4 +37,6 @@ GIT_INLINE(size_t) reflog_inverse_index(size_t idx, size_t total)
 	return (total - 1) - idx;
 }
 
+void git_reflog_entry__free(git_reflog_entry *entry);
+
 #endif

data/vendor/libgit2/src/libgit2/refs.c

@@ -72,6 +72,7 @@ git_reference *git_reference__alloc(
 	const git_oid *oid,
 	const git_oid *peel)
 {
+	git_oid_t oid_type;
 	git_reference *ref;
 
 	GIT_ASSERT_ARG_WITH_RETVAL(name, NULL);
@@ -84,10 +85,16 @@ git_reference *git_reference__alloc(
 	ref->type = GIT_REFERENCE_DIRECT;
 	git_oid_cpy(&ref->target.oid, oid);
 
+#ifdef GIT_EXPERIMENTAL_SHA256
+	oid_type = oid->type;
+#else
+	oid_type = GIT_OID_SHA1;
+#endif
+
 	if (peel != NULL)
 		git_oid_cpy(&ref->peel, peel);
 	else
-		git_oid_clear(&ref->peel, GIT_OID_SHA1);
+		git_oid_clear(&ref->peel, oid_type);
 
 	return ref;
 }
@@ -801,7 +808,7 @@ int git_reference_list(
 
 	if (git_reference_foreach_name(
 			repo, &cb__reflist_add, (void *)&ref_list) < 0) {
-		git_vector_free(&ref_list);
+		git_vector_dispose(&ref_list);
 		return -1;
 	}
 
@@ -828,17 +835,20 @@ static int is_valid_ref_char(char ch)
 	}
 }
 
-static int ensure_segment_validity(const char *name, char may_contain_glob)
+static int ensure_segment_validity(const char *name, char may_contain_glob, bool allow_caret_prefix)
 {
 	const char *current = name;
+	const char *start = current;
 	char prev = '\0';
 	const int lock_len = (int)strlen(GIT_FILELOCK_EXTENSION);
 	int segment_len;
 
 	if (*current == '.')
 		return -1; /* Refname starts with "." */
+	if (allow_caret_prefix && *current == '^')
+		start++;
 
-	for (current = name; ; current++) {
+	for (current = start; ; current++) {
 		if (*current == '\0' || *current == '/')
 			break;
 
@@ -870,7 +880,7 @@ static int ensure_segment_validity(const char *name, char may_contain_glob)
 	return segment_len;
 }
 
-static bool is_all_caps_and_underscore(const char *name, size_t len)
+static bool is_valid_normalized_name(const char *name, size_t len)
 {
 	size_t i;
 	char c;
@@ -881,6 +891,9 @@ static bool is_all_caps_and_underscore(const char *name, size_t len)
 	for (i = 0; i < len; i++)
 	{
 		c = name[i];
+		if (i == 0 && c == '^')
+			continue; /* The first character is allowed to be "^" for negative refspecs */
+
 		if ((c < 'A' || c > 'Z') && c != '_')
 			return false;
 	}
@@ -901,6 +914,7 @@ int git_reference__normalize_name(
 	int segment_len, segments_count = 0, error = GIT_EINVALIDSPEC;
 	unsigned int process_flags;
 	bool normalize = (buf != NULL);
+	bool allow_caret_prefix = true;
 	bool validate = (flags & GIT_REFERENCE_FORMAT__VALIDATION_DISABLE) == 0;
 
 #ifdef GIT_USE_ICONV
@@ -938,7 +952,7 @@ int git_reference__normalize_name(
 	while (true) {
 		char may_contain_glob = process_flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN;
 
-		segment_len = ensure_segment_validity(current, may_contain_glob);
+		segment_len = ensure_segment_validity(current, may_contain_glob, allow_caret_prefix);
 		if (segment_len < 0)
 			goto cleanup;
 
@@ -974,6 +988,12 @@ int git_reference__normalize_name(
 			break;
 
 		current += segment_len + 1;
+
+		/*
+		 * A caret prefix is only allowed in the first segment to signify a
+		 * negative refspec.
+		 */
+		allow_caret_prefix = false;
 	}
 
 	/* A refname can not be empty */
@@ -993,12 +1013,12 @@ int git_reference__normalize_name(
 
 	if ((segments_count == 1 ) &&
 	    !(flags & GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND) &&
-		!(is_all_caps_and_underscore(name, (size_t)segment_len) ||
+		!(is_valid_normalized_name(name, (size_t)segment_len) ||
 			((flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN) && !strcmp("*", name))))
 			goto cleanup;
 
 	if ((segments_count > 1)
-		&& (is_all_caps_and_underscore(name, strchr(name, '/') - name)))
+		&& (is_valid_normalized_name(name, strchr(name, '/') - name)))
 			goto cleanup;
 
 	error = 0;
@@ -1073,6 +1093,12 @@ int git_reference_cmp(
 	return git_oid__cmp(&ref1->target.oid, &ref2->target.oid);
 }
 
+int git_reference__cmp_cb(const void *a, const void *b)
+{
+	return git_reference_cmp(
+		(const git_reference *)a, (const git_reference *)b);
+}
+
 /*
  * Starting with the reference given by `ref_name`, follows symbolic
  * references until a direct reference is found and updated the OID

data/vendor/libgit2/src/libgit2/refs.h

@@ -12,7 +12,6 @@
 #include "git2/oid.h"
 #include "git2/refs.h"
 #include "git2/refdb.h"
-#include "strmap.h"
 #include "str.h"
 #include "oid.h"
 
@@ -92,6 +91,12 @@ int git_reference__is_tag(const char *ref_name);
 int git_reference__is_note(const char *ref_name);
 const char *git_reference__shorthand(const char *name);
 
+/*
+ * A `git_reference_cmp` wrapper suitable for passing to generic
+ * comparators, like `vector_cmp` / `tsort` / etc.
+ */
+int git_reference__cmp_cb(const void *a, const void *b);
+
 /**
  * Lookup a reference by name and try to resolve to an OID.
  *

data/vendor/libgit2/src/libgit2/refspec.c

@@ -22,6 +22,7 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 	const char *lhs, *rhs;
 	int valid = 0;
 	unsigned int flags;
+	bool is_neg_refspec = false;
 
 	GIT_ASSERT_ARG(refspec);
 	GIT_ASSERT_ARG(input);
@@ -34,6 +35,9 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 		refspec->force = 1;
 		lhs++;
 	}
+	if (*lhs == '^') {
+		is_neg_refspec = true;
+	}
 
 	rhs = strrchr(lhs, ':');
 
@@ -62,7 +66,14 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 
 	llen = (rhs ? (size_t)(rhs - lhs - 1) : strlen(lhs));
 	if (1 <= llen && memchr(lhs, '*', llen)) {
-		if ((rhs && !is_glob) || (!rhs && is_fetch))
+		/*
+		 * If the lefthand side contains a glob, then one of the following must be
+		 * true, otherwise the spec is invalid
+		 *   1) the rhs exists and also contains a glob
+		 *   2) it is a negative refspec (i.e. no rhs)
+		 *   3) the rhs doesn't exist and we're fetching
+		 */
+		if ((rhs && !is_glob) || (rhs && is_neg_refspec) || (!rhs && is_fetch && !is_neg_refspec))
 			goto invalid;
 		is_glob = 1;
 	} else if (rhs && is_glob)
@@ -225,6 +236,14 @@ int git_refspec_force(const git_refspec *refspec)
 	return refspec->force;
 }
 
+int git_refspec_src_matches_negative(const git_refspec *refspec, const char *refname)
+{
+	if (refspec == NULL || refspec->src == NULL || !git_refspec_is_negative(refspec))
+		return false;
+
+	return (wildmatch(refspec->src + 1, refname, 0) == 0);
+}
+
 int git_refspec_src_matches(const git_refspec *refspec, const char *refname)
 {
 	if (refspec == NULL || refspec->src == NULL)
@@ -340,6 +359,14 @@ int git_refspec_is_wildcard(const git_refspec *spec)
 	return (spec->src[strlen(spec->src) - 1] == '*');
 }
 
+int git_refspec_is_negative(const git_refspec *spec)
+{
+	GIT_ASSERT_ARG(spec);
+	GIT_ASSERT_ARG(spec->src);
+
+	return (spec->src[0] == '^' && spec->dst == NULL);
+}
+
 git_direction git_refspec_direction(const git_refspec *spec)
 {
 	GIT_ASSERT_ARG(spec);

data/vendor/libgit2/src/libgit2/refspec.h

@@ -45,6 +45,14 @@ int git_refspec__serialize(git_str *out, const git_refspec *refspec);
  */
 int git_refspec_is_wildcard(const git_refspec *spec);
 
+/**
+ * Determines if a refspec is a negative refspec.
+ *
+ * @param spec the refspec
+ * @return 1 if the refspec is a negative, 0 otherwise
+ */
+int git_refspec_is_negative(const git_refspec *spec);
+
 /**
  * DWIM `spec` with `refs` existing on the remote, append the dwim'ed
  * result in `out`.