rugged 0.27.9 → 0.27.10

data/vendor/libgit2/src/refs.h

@@ -55,8 +55,8 @@ extern bool git_reference__enable_symbolic_ref_target_validation;
 #define GIT_STASH_FILE "stash"
 #define GIT_REFS_STASH_FILE GIT_REFS_DIR GIT_STASH_FILE
 
-#define GIT_REF_FORMAT__PRECOMPOSE_UNICODE	(1u << 16)
-#define GIT_REF_FORMAT__VALIDATION_DISABLE	(1u << 15)
+#define GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE	(1u << 16)
+#define GIT_REFERENCE_FORMAT__VALIDATION_DISABLE	(1u << 15)
 
 #define GIT_REFNAME_MAX 1024
 
@@ -64,7 +64,7 @@ typedef char git_refname_t[GIT_REFNAME_MAX];
 
 struct git_reference {
 	git_refdb *db;
-	git_ref_t type;
+	git_reference_t type;
 
 	union {
 		git_oid oid;
@@ -136,4 +136,6 @@ int git_reference__update_for_commit(
 	const git_oid *id,
 	const char *operation);
 
+int git_reference__is_unborn_head(bool *unborn, const git_reference *ref, git_repository *repo);
+
 #endif

data/vendor/libgit2/src/refspec.c

@@ -9,14 +9,14 @@
 
 #include "git2/errors.h"
 
-#include "util.h"
-#include "posix.h"
 #include "refs.h"
+#include "util.h"
 #include "vector.h"
+#include "wildmatch.h"
 
 int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 {
-	// Ported from https://github.com/git/git/blob/f06d47e7e0d9db709ee204ed13a8a7486149f494/remote.c#L518-636
+	/* Ported from https://github.com/git/git/blob/f06d47e7e0d9db709ee204ed13a8a7486149f494/remote.c#L518-636 */
 
 	size_t llen;
 	int is_glob = 0;
@@ -43,11 +43,11 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 	if (!is_fetch && rhs == lhs && rhs[1] == '\0') {
 		refspec->matching = 1;
 		refspec->string = git__strdup(input);
-		GITERR_CHECK_ALLOC(refspec->string);
+		GIT_ERROR_CHECK_ALLOC(refspec->string);
 		refspec->src = git__strdup("");
-		GITERR_CHECK_ALLOC(refspec->src);
+		GIT_ERROR_CHECK_ALLOC(refspec->src);
 		refspec->dst = git__strdup("");
-		GITERR_CHECK_ALLOC(refspec->dst);
+		GIT_ERROR_CHECK_ALLOC(refspec->dst);
 		return 0;
 	}
 
@@ -69,8 +69,9 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 
 	refspec->pattern = is_glob;
 	refspec->src = git__strndup(lhs, llen);
-	flags = GIT_REF_FORMAT_ALLOW_ONELEVEL | GIT_REF_FORMAT_REFSPEC_SHORTHAND
-		| (is_glob ? GIT_REF_FORMAT_REFSPEC_PATTERN : 0);
+	flags = GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL |
+		GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND |
+		(is_glob ? GIT_REFERENCE_FORMAT_REFSPEC_PATTERN : 0);
 
 	if (is_fetch) {
 		/*
@@ -131,24 +132,24 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 		/* if the RHS is empty, then it's a copy of the LHS */
 		if (!refspec->dst) {
 			refspec->dst = git__strdup(refspec->src);
-			GITERR_CHECK_ALLOC(refspec->dst);
+			GIT_ERROR_CHECK_ALLOC(refspec->dst);
 		}
 	}
 
 	refspec->string = git__strdup(input);
-	GITERR_CHECK_ALLOC(refspec->string);
+	GIT_ERROR_CHECK_ALLOC(refspec->string);
 
 	return 0;
 
  invalid:
-        giterr_set(
-                GITERR_INVALID,
+        git_error_set(
+                GIT_ERROR_INVALID,
                 "'%s' is not a valid refspec.", input);
-        git_refspec__free(refspec);
+        git_refspec__dispose(refspec);
 	return -1;
 }
 
-void git_refspec__free(git_refspec *refspec)
+void git_refspec__dispose(git_refspec *refspec)
 {
 	if (refspec == NULL)
 		return;
@@ -160,6 +161,31 @@ void git_refspec__free(git_refspec *refspec)
 	memset(refspec, 0x0, sizeof(git_refspec));
 }
 
+int git_refspec_parse(git_refspec **out_refspec, const char *input, int is_fetch)
+{
+	git_refspec *refspec;
+	assert(out_refspec && input);
+
+	*out_refspec = NULL;
+
+	refspec = git__malloc(sizeof(git_refspec));
+	GIT_ERROR_CHECK_ALLOC(refspec);
+
+	if (git_refspec__parse(refspec, input, !!is_fetch) != 0) {
+		git__free(refspec);
+		return -1;
+	}
+
+	*out_refspec = refspec;
+	return 0;
+}
+
+void git_refspec_free(git_refspec *refspec)
+{
+	git_refspec__dispose(refspec);
+	git__free(refspec);
+}
+
 const char *git_refspec_src(const git_refspec *refspec)
 {
 	return refspec == NULL ? NULL : refspec->src;
@@ -187,7 +213,7 @@ int git_refspec_src_matches(const git_refspec *refspec, const char *refname)
 	if (refspec == NULL || refspec->src == NULL)
 		return false;
 
-	return (p_fnmatch(refspec->src, refname, 0) == 0);
+	return (wildmatch(refspec->src, refname, 0) == 0);
 }
 
 int git_refspec_dst_matches(const git_refspec *refspec, const char *refname)
@@ -195,14 +221,13 @@ int git_refspec_dst_matches(const git_refspec *refspec, const char *refname)
 	if (refspec == NULL || refspec->dst == NULL)
 		return false;
 
-	return (p_fnmatch(refspec->dst, refname, 0) == 0);
+	return (wildmatch(refspec->dst, refname, 0) == 0);
 }
 
 static int refspec_transform(
 	git_buf *out, const char *from, const char *to, const char *name)
 {
 	const char *from_star, *to_star;
-	const char *name_slash, *from_slash;
 	size_t replacement_len, star_offset;
 
 	git_buf_sanitize(out);
@@ -225,17 +250,11 @@ static int refspec_transform(
 	/* the first half is copied over */
 	git_buf_put(out, to, to_star - to);
 
-	/* then we copy over the replacement, from the star's offset to the next slash in 'name' */
-	name_slash = strchr(name + star_offset, '/');
-	if (!name_slash)
-		name_slash = strrchr(name, '\0');
-
-	/* if there is no slash after the star in 'from', we want to copy everything over */
-	from_slash = strchr(from + star_offset, '/');
-	if (!from_slash)
-		name_slash = strrchr(name, '\0');
-
-	replacement_len = (name_slash - name) - star_offset;
+	/*
+	 * Copy over the name, but exclude the trailing part in "from" starting
+	 * after the glob
+	 */
+	replacement_len = strlen(name + star_offset) - strlen(from_star + 1);
 	git_buf_put(out, name + star_offset, replacement_len);
 
 	return git_buf_puts(out, to_star + 1);
@@ -247,12 +266,12 @@ int git_refspec_transform(git_buf *out, const git_refspec *spec, const char *nam
 	git_buf_sanitize(out);
 
 	if (!git_refspec_src_matches(spec, name)) {
-		giterr_set(GITERR_INVALID, "ref '%s' doesn't match the source", name);
+		git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the source", name);
 		return -1;
 	}
 
 	if (!spec->pattern)
-		return git_buf_puts(out, spec->dst);
+		return git_buf_puts(out, spec->dst ? spec->dst : "");
 
 	return refspec_transform(out, spec->src, spec->dst, name);
 }
@@ -263,7 +282,7 @@ int git_refspec_rtransform(git_buf *out, const git_refspec *spec, const char *na
 	git_buf_sanitize(out);
 
 	if (!git_refspec_dst_matches(spec, name)) {
-		giterr_set(GITERR_INVALID, "ref '%s' doesn't match the destination", name);
+		git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the destination", name);
 		return -1;
 	}
 
@@ -316,7 +335,7 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 	assert(out && spec && refs);
 
 	cur = git__calloc(1, sizeof(git_refspec));
-	GITERR_CHECK_ALLOC(cur);
+	GIT_ERROR_CHECK_ALLOC(cur);
 
 	cur->force = spec->force;
 	cur->push = spec->push;
@@ -329,7 +348,7 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 		for (j = 0; formatters[j]; j++) {
 			git_buf_clear(&buf);
 			git_buf_printf(&buf, formatters[j], spec->src);
-			GITERR_CHECK_ALLOC_BUF(&buf);
+			GIT_ERROR_CHECK_ALLOC_BUF(&buf);
 
 			key.name = (char *) git_buf_cstr(&buf);
 			if (!git_vector_search(&pos, refs, &key)) {
@@ -342,7 +361,7 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 	/* No shorthands found, copy over the name */
 	if (cur->src == NULL && spec->src != NULL) {
 		cur->src = git__strdup(spec->src);
-		GITERR_CHECK_ALLOC(cur->src);
+		GIT_ERROR_CHECK_ALLOC(cur->src);
 	}
 
 	if (spec->dst && git__prefixcmp(spec->dst, GIT_REFS_DIR)) {
@@ -354,16 +373,16 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 		}
 
 		git_buf_puts(&buf, spec->dst);
-		GITERR_CHECK_ALLOC_BUF(&buf);
+		GIT_ERROR_CHECK_ALLOC_BUF(&buf);
 
 		cur->dst = git_buf_detach(&buf);
 	}
 
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	if (cur->dst == NULL && spec->dst != NULL) {
 		cur->dst = git__strdup(spec->dst);
-		GITERR_CHECK_ALLOC(cur->dst);
+		GIT_ERROR_CHECK_ALLOC(cur->dst);
 	}
 
 	return git_vector_insert(out, cur);

data/vendor/libgit2/src/refspec.h

@@ -30,7 +30,7 @@ int git_refspec__parse(
 	const char *str,
 	bool is_fetch);
 
-void git_refspec__free(git_refspec *refspec);
+void git_refspec__dispose(git_refspec *refspec);
 
 int git_refspec__serialize(git_buf *out, const git_refspec *refspec);
 

data/vendor/libgit2/src/regexp.c

@@ -0,0 +1,221 @@
+/*
+ * 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 "regexp.h"
+
+#if defined(GIT_REGEX_BUILTIN) || defined(GIT_REGEX_PCRE)
+
+int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
+{
+	int erroffset, cflags = 0;
+	const char *error;
+
+	if (flags & GIT_REGEXP_ICASE)
+		cflags |= PCRE_CASELESS;
+
+	if ((*r = pcre_compile(pattern, cflags, &error, &erroffset, NULL)) == NULL) {
+		git_error_set_str(GIT_ERROR_REGEX, error);
+		return GIT_EINVALIDSPEC;
+	}
+
+	return 0;
+}
+
+void git_regexp_dispose(git_regexp *r)
+{
+	pcre_free(*r);
+	*r = NULL;
+}
+
+int git_regexp_match(const git_regexp *r, const char *string)
+{
+	int error;
+	if ((error = pcre_exec(*r, NULL, string, (int) strlen(string), 0, 0, NULL, 0)) < 0)
+		return (error == PCRE_ERROR_NOMATCH) ? GIT_ENOTFOUND : GIT_EINVALIDSPEC;
+	return 0;
+}
+
+int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches, git_regmatch *matches)
+{
+	int static_ovec[9], *ovec;
+	int error;
+	size_t i;
+
+	/* The ovec array always needs to be a mutiple of three */
+	if (nmatches <= ARRAY_SIZE(static_ovec) / 3)
+		ovec = static_ovec;
+	else
+		ovec = git__calloc(nmatches * 3, sizeof(*ovec));
+	GIT_ERROR_CHECK_ALLOC(ovec);
+
+	if ((error = pcre_exec(*r, NULL, string, (int) strlen(string), 0, 0, ovec, (int) nmatches * 3)) < 0)
+		goto out;
+
+	if (error == 0)
+		error = (int) nmatches;
+
+	for (i = 0; i < (unsigned int) error; i++) {
+		matches[i].start = (ovec[i * 2] < 0) ? -1 : ovec[i * 2];
+		matches[i].end = (ovec[i * 2 + 1] < 0) ? -1 : ovec[i * 2 + 1];
+	}
+	for (i = (unsigned int) error; i < nmatches; i++)
+		matches[i].start = matches[i].end = -1;
+
+out:
+	if (nmatches > ARRAY_SIZE(static_ovec) / 3)
+		git__free(ovec);
+	if (error < 0)
+		return (error == PCRE_ERROR_NOMATCH) ? GIT_ENOTFOUND : GIT_EINVALIDSPEC;
+	return 0;
+}
+
+#elif defined(GIT_REGEX_PCRE2)
+
+int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
+{
+	unsigned char errmsg[1024];
+	PCRE2_SIZE erroff;
+	int error, cflags = 0;
+
+	if (flags & GIT_REGEXP_ICASE)
+		cflags |= PCRE2_CASELESS;
+
+	if ((*r = pcre2_compile((const unsigned char *) pattern, PCRE2_ZERO_TERMINATED,
+				cflags, &error, &erroff, NULL)) == NULL) {
+		pcre2_get_error_message(error, errmsg, sizeof(errmsg));
+		git_error_set_str(GIT_ERROR_REGEX, (char *) errmsg);
+		return GIT_EINVALIDSPEC;
+	}
+
+	return 0;
+}
+
+void git_regexp_dispose(git_regexp *r)
+{
+	pcre2_code_free(*r);
+	*r = NULL;
+}
+
+int git_regexp_match(const git_regexp *r, const char *string)
+{
+	pcre2_match_data *data;
+	int error;
+
+	data = pcre2_match_data_create(1, NULL);
+	GIT_ERROR_CHECK_ALLOC(data);
+
+	if ((error = pcre2_match(*r, (const unsigned char *) string, strlen(string),
+			 0, 0, data, NULL)) < 0)
+		return (error == PCRE2_ERROR_NOMATCH) ? GIT_ENOTFOUND : GIT_EINVALIDSPEC;
+
+	pcre2_match_data_free(data);
+	return 0;
+}
+
+int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches, git_regmatch *matches)
+{
+	pcre2_match_data *data = NULL;
+	PCRE2_SIZE *ovec;
+	int error;
+	size_t i;
+
+	if ((data = pcre2_match_data_create(nmatches, NULL)) == NULL) {
+		git_error_set_oom();
+		goto out;
+	}
+
+	if ((error = pcre2_match(*r, (const unsigned char *) string, strlen(string),
+			     0, 0, data, NULL)) < 0)
+		goto out;
+
+	if (error == 0 || (unsigned int) error  > nmatches)
+		error = nmatches;
+	ovec = pcre2_get_ovector_pointer(data);
+
+	for (i = 0; i < (unsigned int) error; i++) {
+		matches[i].start = (ovec[i * 2] == PCRE2_UNSET) ? -1 : (ssize_t) ovec[i * 2];
+		matches[i].end = (ovec[i * 2 + 1] == PCRE2_UNSET) ? -1 :  (ssize_t) ovec[i * 2 + 1];
+	}
+	for (i = (unsigned int) error; i < nmatches; i++)
+		matches[i].start = matches[i].end = -1;
+
+out:
+	pcre2_match_data_free(data);
+	if (error < 0)
+		return (error == PCRE2_ERROR_NOMATCH) ? GIT_ENOTFOUND : GIT_EINVALIDSPEC;
+	return 0;
+}
+
+#elif defined(GIT_REGEX_REGCOMP) || defined(GIT_REGEX_REGCOMP_L)
+
+#if defined(GIT_REGEX_REGCOMP_L)
+# include <xlocale.h>
+#endif
+
+int git_regexp_compile(git_regexp *r, const char *pattern, int flags)
+{
+	int cflags = REG_EXTENDED, error;
+	char errmsg[1024];
+
+	if (flags & GIT_REGEXP_ICASE)
+		cflags |= REG_ICASE;
+
+# if defined(GIT_REGEX_REGCOMP)
+	if ((error = regcomp(r, pattern, cflags)) != 0)
+# else
+	if ((error = regcomp_l(r, pattern, cflags, (locale_t) 0)) != 0)
+# endif
+	{
+		regerror(error, r, errmsg, sizeof(errmsg));
+		git_error_set_str(GIT_ERROR_REGEX, errmsg);
+		return GIT_EINVALIDSPEC;
+	}
+
+	return 0;
+}
+
+void git_regexp_dispose(git_regexp *r)
+{
+	regfree(r);
+}
+
+int git_regexp_match(const git_regexp *r, const char *string)
+{
+	int error;
+	if ((error = regexec(r, string, 0, NULL, 0)) != 0)
+		return (error == REG_NOMATCH) ? GIT_ENOTFOUND : GIT_EINVALIDSPEC;
+	return 0;
+}
+
+int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches, git_regmatch *matches)
+{
+	regmatch_t static_m[3], *m;
+	int error;
+	size_t i;
+
+	if (nmatches <= ARRAY_SIZE(static_m))
+		m = static_m;
+	else
+		m = git__calloc(nmatches, sizeof(*m));
+
+	if ((error = regexec(r, string, nmatches, m, 0)) != 0)
+		goto out;
+
+	for (i = 0; i < nmatches; i++) {
+		matches[i].start = (m[i].rm_so < 0) ? -1 : m[i].rm_so;
+		matches[i].end = (m[i].rm_eo < 0) ? -1 : m[i].rm_eo;
+	}
+
+out:
+	if (nmatches > ARRAY_SIZE(static_m))
+		git__free(m);
+	if (error)
+		return (error == REG_NOMATCH) ? GIT_ENOTFOUND : GIT_EINVALIDSPEC;
+	return 0;
+}
+
+#endif