rugged 0.27.7 → 0.27.10

data/vendor/libgit2/src/refspec.c

@@ -9,10 +9,10 @@
 
 #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)
 {
@@ -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,18 +132,18 @@ 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__dispose(refspec);
 	return -1;
@@ -168,7 +169,7 @@ int git_refspec_parse(git_refspec **out_refspec, const char *input, int is_fetch
 	*out_refspec = NULL;
 
 	refspec = git__malloc(sizeof(git_refspec));
-	GITERR_CHECK_ALLOC(refspec);
+	GIT_ERROR_CHECK_ALLOC(refspec);
 
 	if (git_refspec__parse(refspec, input, !!is_fetch) != 0) {
 		git__free(refspec);
@@ -212,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)
@@ -220,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);
@@ -250,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);
@@ -272,7 +266,7 @@ 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;
 	}
 
@@ -288,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;
 	}
 
@@ -341,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;
@@ -354,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)) {
@@ -367,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)) {
@@ -379,7 +373,7 @@ 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);
 	}
@@ -388,7 +382,7 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 
 	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/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

data/vendor/libgit2/src/regexp.h

@@ -0,0 +1,97 @@
+/*
+ * 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.
+ */
+
+#ifndef INCLUDE_regexp_h__
+#define INCLUDE_regexp_h__
+
+#include "common.h"
+
+#if defined(GIT_REGEX_BUILTIN) || defined(GIT_REGEX_PCRE)
+# include "pcre.h"
+typedef pcre *git_regexp;
+# define GIT_REGEX_INIT NULL
+#elif defined(GIT_REGEX_PCRE2)
+# define PCRE2_CODE_UNIT_WIDTH 8
+# include <pcre2.h>
+typedef pcre2_code *git_regexp;
+# define GIT_REGEX_INIT NULL
+#elif defined(GIT_REGEX_REGCOMP) || defined(GIT_REGEX_REGCOMP_L)
+# include <regex.h>
+typedef regex_t git_regexp;
+# define GIT_REGEX_INIT { 0 }
+#else
+# error "No regex backend"
+#endif
+
+/** Options supported by @git_regexp_compile. */
+typedef enum {
+	/** Enable case-insensitive matching */
+	GIT_REGEXP_ICASE = (1 << 0)
+} git_regexp_flags_t;
+
+/** Structure containing information about regular expression matching groups */
+typedef struct {
+	/** Start of the given match. -1 if the group didn't match anything */
+	ssize_t start;
+	/** End of the given match. -1 if the group didn't match anything */
+	ssize_t end;
+} git_regmatch;
+
+/**
+ * Compile a regular expression. The compiled expression needs to
+ * be cleaned up afterwards with `git_regexp_dispose`.
+ *
+ * @param r Pointer to the storage where to initialize the regular expression.
+ * @param pattern The pattern that shall be compiled.
+ * @param flags Flags to alter how the pattern shall be handled.
+ *              0 for defaults, otherwise see @git_regexp_flags_t.
+ * @return 0 on success, otherwise a negative return value.
+ */
+int git_regexp_compile(git_regexp *r, const char *pattern, int flags);
+
+/**
+ * Free memory associated with the regular expression
+ *
+ * @param r The regular expression structure to dispose.
+ */
+void git_regexp_dispose(git_regexp *r);
+
+/**
+ * Test whether a given string matches a compiled regular
+ * expression.
+ *
+ * @param r Compiled regular expression.
+ * @param string String to match against the regular expression.
+ * @return 0 if the string matches, a negative error code
+ *         otherwise. GIT_ENOTFOUND if no match was found,
+ *         GIT_EINVALIDSPEC if the regular expression matching
+ *         was invalid.
+ */
+int git_regexp_match(const git_regexp *r, const char *string);
+
+/**
+ * Search for matches inside of a given string.
+ *
+ * Given a regular expression with capturing groups, this
+ * function will populate provided @git_regmatch structures with
+ * offsets for each of the given matches. Non-matching groups
+ * will have start and end values of the respective @git_regmatch
+ * structure set to -1.
+ *
+ * @param r Compiled regular expression.
+ * @param string String to match against the regular expression.
+ * @param nmatches Number of @git_regmatch structures provided by
+ *                 the user.
+ * @param matches Pointer to an array of @git_regmatch structures.
+ * @return 0 if the string matches, a negative error code
+ *         otherwise. GIT_ENOTFOUND if no match was found,
+ *         GIT_EINVALIDSPEC if the regular expression matching
+ *         was invalid.
+ */
+int git_regexp_search(const git_regexp *r, const char *string, size_t nmatches, git_regmatch *matches);
+
+#endif