rugged 1.1.0 → 1.2.0

data/vendor/libgit2/src/refs.c

@@ -50,7 +50,8 @@ git_reference *git_reference__alloc_symbolic(
 {
 	git_reference *ref;
 
-	assert(name && target);
+	GIT_ASSERT_ARG_WITH_RETVAL(name, NULL);
+	GIT_ASSERT_ARG_WITH_RETVAL(target, NULL);
 
 	ref = alloc_ref(name);
 	if (!ref)
@@ -73,7 +74,8 @@ git_reference *git_reference__alloc(
 {
 	git_reference *ref;
 
-	assert(name && oid);
+	GIT_ASSERT_ARG_WITH_RETVAL(name, NULL);
+	GIT_ASSERT_ARG_WITH_RETVAL(oid, NULL);
 
 	ref = alloc_ref(name);
 	if (!ref)
@@ -94,7 +96,8 @@ git_reference *git_reference__realloc(
 	size_t namelen, reflen;
 	git_reference *rewrite = NULL;
 
-	assert(ptr_to_ref && name);
+	GIT_ASSERT_ARG_WITH_RETVAL(ptr_to_ref, NULL);
+	GIT_ASSERT_ARG_WITH_RETVAL(name, NULL);
 
 	namelen = strlen(name);
 
@@ -215,7 +218,9 @@ int git_reference_lookup_resolved(
 	git_refdb *refdb;
 	int error = 0;
 
-	assert(ref_out && repo && name);
+	GIT_ASSERT_ARG(ref_out);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(name);
 
 	if ((error = reference_normalize_for_repo(normalized, repo, name, true)) < 0 ||
 	    (error = git_repository_refdb__weakptr(&refdb, repo)) < 0 ||
@@ -239,7 +244,7 @@ int git_reference_lookup_resolved(
 
 int git_reference_dwim(git_reference **out, git_repository *repo, const char *refname)
 {
-	int error = 0, i;
+	int error = 0, i, valid;
 	bool fallbackmode = true, foundvalid = false;
 	git_reference *ref;
 	git_buf refnamebuf = GIT_BUF_INIT, name = GIT_BUF_INIT;
@@ -265,10 +270,11 @@ int git_reference_dwim(git_reference **out, git_repository *repo, const char *re
 
 		git_buf_clear(&refnamebuf);
 
-		if ((error = git_buf_printf(&refnamebuf, formatters[i], git_buf_cstr(&name))) < 0)
+		if ((error = git_buf_printf(&refnamebuf, formatters[i], git_buf_cstr(&name))) < 0 ||
+		    (error = git_reference_name_is_valid(&valid, git_buf_cstr(&refnamebuf))) < 0)
 			goto cleanup;
 
-		if (!git_reference_is_valid_name(git_buf_cstr(&refnamebuf))) {
+		if (!valid) {
 			error = GIT_EINVALIDSPEC;
 			continue;
 		}
@@ -306,25 +312,25 @@ cleanup:
  */
 git_reference_t git_reference_type(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG(ref);
 	return ref->type;
 }
 
 const char *git_reference_name(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG_WITH_RETVAL(ref, NULL);
 	return ref->name;
 }
 
 git_repository *git_reference_owner(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG_WITH_RETVAL(ref, NULL);
 	return ref->db->repo;
 }
 
 const git_oid *git_reference_target(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG_WITH_RETVAL(ref, NULL);
 
 	if (ref->type != GIT_REFERENCE_DIRECT)
 		return NULL;
@@ -334,7 +340,7 @@ const git_oid *git_reference_target(const git_reference *ref)
 
 const git_oid *git_reference_target_peel(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG_WITH_RETVAL(ref, NULL);
 
 	if (ref->type != GIT_REFERENCE_DIRECT || git_oid_is_zero(&ref->peel))
 		return NULL;
@@ -344,7 +350,7 @@ const git_oid *git_reference_target_peel(const git_reference *ref)
 
 const char *git_reference_symbolic_target(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG_WITH_RETVAL(ref, NULL);
 
 	if (ref->type != GIT_REFERENCE_SYMBOLIC)
 		return NULL;
@@ -369,8 +375,9 @@ static int reference__create(
 	git_reference *ref = NULL;
 	int error = 0;
 
-	assert(repo && name);
-	assert(symbolic || signature);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(name);
+	GIT_ASSERT_ARG(symbolic || signature);
 
 	if (ref_out)
 		*ref_out = NULL;
@@ -384,7 +391,7 @@ static int reference__create(
 		return error;
 
 	if (oid != NULL) {
-		assert(symbolic == NULL);
+		GIT_ASSERT(symbolic == NULL);
 
 		if (!git_object__is_valid(repo, oid, GIT_OBJECT_ANY)) {
 			git_error_set(GIT_ERROR_REFERENCE,
@@ -456,7 +463,7 @@ int git_reference_create_matching(
 	int error;
 	git_signature *who = NULL;
 
-	assert(id);
+	GIT_ASSERT_ARG(id);
 
 	if ((error = git_reference__log_signature(&who, repo)) < 0)
 		return error;
@@ -491,7 +498,7 @@ int git_reference_symbolic_create_matching(
 	int error;
 	git_signature *who = NULL;
 
-	assert(target);
+	GIT_ASSERT_ARG(target);
 
 	if ((error = git_reference__log_signature(&who, repo)) < 0)
 		return error;
@@ -532,7 +539,9 @@ int git_reference_set_target(
 	int error;
 	git_repository *repo;
 
-	assert(out && ref && id);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(ref);
+	GIT_ASSERT_ARG(id);
 
 	repo = ref->db->repo;
 
@@ -559,7 +568,9 @@ int git_reference_symbolic_set_target(
 {
 	int error;
 
-	assert(out && ref && target);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(ref);
+	GIT_ASSERT_ARG(target);
 
 	if ((error = ensure_is_an_updatable_symbolic_reference(ref)) < 0)
 		return error;
@@ -610,7 +621,8 @@ int git_reference_rename(
 	git_repository *repo;
 	int error;
 
-	assert(out && ref);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(ref);
 
 	repo = git_reference_owner(ref);
 
@@ -776,7 +788,8 @@ int git_reference_list(
 {
 	git_vector ref_list;
 
-	assert(array && repo);
+	GIT_ASSERT_ARG(array);
+	GIT_ASSERT_ARG(repo);
 
 	array->strings = NULL;
 	array->count = 0;
@@ -860,7 +873,8 @@ static bool is_all_caps_and_underscore(const char *name, size_t len)
 	size_t i;
 	char c;
 
-	assert(name && len > 0);
+	GIT_ASSERT_ARG(name);
+	GIT_ASSERT_ARG(len > 0);
 
 	for (i = 0; i < len; i++)
 	{
@@ -891,7 +905,7 @@ int git_reference__normalize_name(
 	git_path_iconv_t ic = GIT_PATH_ICONV_INIT;
 #endif
 
-	assert(name);
+	GIT_ASSERT_ARG(name);
 
 	process_flags = flags;
 	current = (char *)name;
@@ -1023,7 +1037,8 @@ int git_reference_normalize_name(
 		goto cleanup;
 	}
 
-	git_buf_copy_cstr(buffer_out, buffer_size, &buf);
+	if ((error = git_buf_copy_cstr(buffer_out, buffer_size, &buf)) < 0)
+		goto cleanup;
 
 	error = 0;
 
@@ -1039,7 +1054,9 @@ int git_reference_cmp(
 	const git_reference *ref2)
 {
 	git_reference_t type1, type2;
-	assert(ref1 && ref2);
+
+	GIT_ASSERT_ARG(ref1);
+	GIT_ASSERT_ARG(ref2);
 
 	type1 = git_reference_type(ref1);
 	type2 = git_reference_type(ref2);
@@ -1162,7 +1179,8 @@ int git_reference_has_log(git_repository *repo, const char *refname)
 	int error;
 	git_refdb *refdb;
 
-	assert(repo && refname);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(refname);
 
 	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
 		return error;
@@ -1175,7 +1193,8 @@ int git_reference_ensure_log(git_repository *repo, const char *refname)
 	int error;
 	git_refdb *refdb;
 
-	assert(repo && refname);
+	GIT_ASSERT_ARG(repo);
+	GIT_ASSERT_ARG(refname);
 
 	if ((error = git_repository_refdb__weakptr(&refdb, repo)) < 0)
 		return error;
@@ -1190,7 +1209,7 @@ int git_reference__is_branch(const char *ref_name)
 
 int git_reference_is_branch(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG(ref);
 	return git_reference__is_branch(ref->name);
 }
 
@@ -1201,7 +1220,7 @@ int git_reference__is_remote(const char *ref_name)
 
 int git_reference_is_remote(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG(ref);
 	return git_reference__is_remote(ref->name);
 }
 
@@ -1212,7 +1231,7 @@ int git_reference__is_tag(const char *ref_name)
 
 int git_reference_is_tag(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG(ref);
 	return git_reference__is_tag(ref->name);
 }
 
@@ -1223,7 +1242,7 @@ int git_reference__is_note(const char *ref_name)
 
 int git_reference_is_note(const git_reference *ref)
 {
-	assert(ref);
+	GIT_ASSERT_ARG(ref);
 	return git_reference__is_note(ref->name);
 }
 
@@ -1245,7 +1264,7 @@ int git_reference_peel(
 	git_object *target = NULL;
 	int error;
 
-	assert(ref);
+	GIT_ASSERT_ARG(ref);
 
 	if (ref->type == GIT_REFERENCE_DIRECT) {
 		resolved = ref;
@@ -1287,19 +1306,30 @@ cleanup:
 	return error;
 }
 
-int git_reference__is_valid_name(const char *refname, unsigned int flags)
+int git_reference__name_is_valid(
+	int *valid,
+	const char *refname,
+	unsigned int flags)
 {
-	if (git_reference__normalize_name(NULL, refname, flags) < 0) {
-		git_error_clear();
-		return false;
-	}
+	int error;
 
-	return true;
+	GIT_ASSERT(valid && refname);
+
+	*valid = 0;
+
+	error = git_reference__normalize_name(NULL, refname, flags);
+
+	if (!error)
+		*valid = 1;
+	else if (error == GIT_EINVALIDSPEC)
+		error = 0;
+
+	return error;
 }
 
-int git_reference_is_valid_name(const char *refname)
+int git_reference_name_is_valid(int *valid, const char *refname)
 {
-	return git_reference__is_valid_name(refname, GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL);
+	return git_reference__name_is_valid(valid, refname, GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL);
 }
 
 const char *git_reference__shorthand(const char *name)
@@ -1313,7 +1343,7 @@ const char *git_reference__shorthand(const char *name)
 	else if (!git__prefixcmp(name, GIT_REFS_DIR))
 		return name + strlen(GIT_REFS_DIR);
 
-	/* No shorthands are avaiable, so just return the name */
+	/* No shorthands are available, so just return the name. */
 	return name;
 }
 
@@ -1326,7 +1356,10 @@ int git_reference__is_unborn_head(bool *unborn, const git_reference *ref, git_re
 {
 	int error;
 	git_reference *tmp_ref;
-	assert(unborn && ref && repo);
+
+	GIT_ASSERT_ARG(unborn);
+	GIT_ASSERT_ARG(ref);
+	GIT_ASSERT_ARG(repo);
 
 	if (ref->type == GIT_REFERENCE_DIRECT) {
 		*unborn = 0;
@@ -1345,3 +1378,18 @@ int git_reference__is_unborn_head(bool *unborn, const git_reference *ref, git_re
 
 	return 0;
 }
+
+/* Deprecated functions */
+
+#ifndef GIT_DEPRECATE_HARD
+
+int git_reference_is_valid_name(const char *refname)
+{
+	int valid = 0;
+
+	git_reference__name_is_valid(&valid, refname, GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL);
+
+	return valid;
+}
+
+#endif

data/vendor/libgit2/src/refs.h

@@ -85,7 +85,7 @@ git_reference *git_reference__realloc(git_reference **ptr_to_ref, const char *na
 
 int git_reference__normalize_name(git_buf *buf, const char *name, unsigned int flags);
 int git_reference__update_terminal(git_repository *repo, const char *ref_name, const git_oid *oid, const git_signature *sig, const char *log_message);
-int git_reference__is_valid_name(const char *refname, unsigned int flags);
+int git_reference__name_is_valid(int *valid, const char *name, unsigned int flags);
 int git_reference__is_branch(const char *ref_name);
 int git_reference__is_remote(const char *ref_name);
 int git_reference__is_tag(const char *ref_name);

data/vendor/libgit2/src/refspec.c

@@ -21,9 +21,11 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 	size_t llen;
 	int is_glob = 0;
 	const char *lhs, *rhs;
-	int flags;
+	int valid = 0;
+	unsigned int flags;
 
-	assert(refspec && input);
+	GIT_ASSERT_ARG(refspec);
+	GIT_ASSERT_ARG(input);
 
 	memset(refspec, 0x0, sizeof(git_refspec));
 	refspec->push = !is_fetch;
@@ -75,57 +77,69 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 
 	if (is_fetch) {
 		/*
-			* LHS
-			* - empty is allowed; it means HEAD.
-			* - otherwise it must be a valid looking ref.
-			*/
+		 * LHS
+		 * - empty is allowed; it means HEAD.
+		 * - otherwise it must be a valid looking ref.
+		 */
 		if (!*refspec->src)
 			; /* empty is ok */
-		else if (!git_reference__is_valid_name(refspec->src, flags))
+		else if (git_reference__name_is_valid(&valid, refspec->src, flags) < 0)
+			goto on_error;
+		else if (!valid)
 			goto invalid;
+
 		/*
-			* RHS
-			* - missing is ok, and is same as empty.
-			* - empty is ok; it means not to store.
-			* - otherwise it must be a valid looking ref.
-			*/
+		 * RHS
+		 * - missing is ok, and is same as empty.
+		 * - empty is ok; it means not to store.
+		 * - otherwise it must be a valid looking ref.
+		 */
 		if (!refspec->dst)
 			; /* ok */
 		else if (!*refspec->dst)
 			; /* ok */
-		else if (!git_reference__is_valid_name(refspec->dst, flags))
+		else if (git_reference__name_is_valid(&valid, refspec->dst, flags) < 0)
+			goto on_error;
+		else if (!valid)
 			goto invalid;
 	} else {
 		/*
-			* LHS
-			* - empty is allowed; it means delete.
-			* - when wildcarded, it must be a valid looking ref.
-			* - otherwise, it must be an extended SHA-1, but
-			*   there is no existing way to validate this.
-			*/
+		 * LHS
+		 * - empty is allowed; it means delete.
+		 * - when wildcarded, it must be a valid looking ref.
+		 * - otherwise, it must be an extended SHA-1, but
+		 *   there is no existing way to validate this.
+		 */
 		if (!*refspec->src)
 			; /* empty is ok */
 		else if (is_glob) {
-			if (!git_reference__is_valid_name(refspec->src, flags))
+			if (git_reference__name_is_valid(&valid, refspec->src, flags) < 0)
+				goto on_error;
+			else if (!valid)
 				goto invalid;
 		}
 		else {
 			; /* anything goes, for now */
 		}
+
 		/*
-			* RHS
-			* - missing is allowed, but LHS then must be a
-			*   valid looking ref.
-			* - empty is not allowed.
-			* - otherwise it must be a valid looking ref.
-			*/
+		 * RHS
+		 * - missing is allowed, but LHS then must be a
+		 *   valid looking ref.
+		 * - empty is not allowed.
+		 * - otherwise it must be a valid looking ref.
+		 */
 		if (!refspec->dst) {
-			if (!git_reference__is_valid_name(refspec->src, flags))
+			if (git_reference__name_is_valid(&valid, refspec->src, flags) < 0)
+				goto on_error;
+			else if (!valid)
 				goto invalid;
 		} else if (!*refspec->dst) {
 			goto invalid;
 		} else {
-			if (!git_reference__is_valid_name(refspec->dst, flags))
+			if (git_reference__name_is_valid(&valid, refspec->dst, flags) < 0)
+				goto on_error;
+			else if (!valid)
 				goto invalid;
 		}
 
@@ -141,11 +155,14 @@ int git_refspec__parse(git_refspec *refspec, const char *input, bool is_fetch)
 
 	return 0;
 
- invalid:
-        git_error_set(
-                GIT_ERROR_INVALID,
-                "'%s' is not a valid refspec.", input);
-        git_refspec__dispose(refspec);
+invalid:
+	git_error_set(GIT_ERROR_INVALID,
+	              "'%s' is not a valid refspec.", input);
+	git_refspec__dispose(refspec);
+	return GIT_EINVALIDSPEC;
+
+on_error:
+	git_refspec__dispose(refspec);
 	return -1;
 }
 
@@ -164,7 +181,8 @@ void git_refspec__dispose(git_refspec *refspec)
 int git_refspec_parse(git_refspec **out_refspec, const char *input, int is_fetch)
 {
 	git_refspec *refspec;
-	assert(out_refspec && input);
+	GIT_ASSERT_ARG(out_refspec);
+	GIT_ASSERT_ARG(input);
 
 	*out_refspec = NULL;
 
@@ -203,7 +221,7 @@ const char *git_refspec_string(const git_refspec *refspec)
 
 int git_refspec_force(const git_refspec *refspec)
 {
-	assert(refspec);
+	GIT_ASSERT_ARG(refspec);
 
 	return refspec->force;
 }
@@ -229,8 +247,11 @@ static int refspec_transform(
 {
 	const char *from_star, *to_star;
 	size_t replacement_len, star_offset;
+	int error;
+
+	if ((error = git_buf_sanitize(out)) < 0)
+		return error;
 
-	git_buf_sanitize(out);
 	git_buf_clear(out);
 
 	/*
@@ -242,7 +263,7 @@ static int refspec_transform(
 	from_star = strchr(from, '*');
 	to_star = strchr(to, '*');
 
-	assert(from_star && to_star);
+	GIT_ASSERT(from_star && to_star);
 
 	/* star offset, both in 'from' and in 'name' */
 	star_offset = from_star - from;
@@ -262,8 +283,14 @@ static int refspec_transform(
 
 int git_refspec_transform(git_buf *out, const git_refspec *spec, const char *name)
 {
-	assert(out && spec && name);
-	git_buf_sanitize(out);
+	int error;
+
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(spec);
+	GIT_ASSERT_ARG(name);
+
+	if ((error = git_buf_sanitize(out)) < 0)
+		return error;
 
 	if (!git_refspec_src_matches(spec, name)) {
 		git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the source", name);
@@ -278,8 +305,14 @@ int git_refspec_transform(git_buf *out, const git_refspec *spec, const char *nam
 
 int git_refspec_rtransform(git_buf *out, const git_refspec *spec, const char *name)
 {
-	assert(out && spec && name);
-	git_buf_sanitize(out);
+	int error;
+
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(spec);
+	GIT_ASSERT_ARG(name);
+
+	if ((error = git_buf_sanitize(out)) < 0)
+		return error;
 
 	if (!git_refspec_dst_matches(spec, name)) {
 		git_error_set(GIT_ERROR_INVALID, "ref '%s' doesn't match the destination", name);
@@ -306,14 +339,15 @@ int git_refspec__serialize(git_buf *out, const git_refspec *refspec)
 
 int git_refspec_is_wildcard(const git_refspec *spec)
 {
-	assert(spec && spec->src);
+	GIT_ASSERT_ARG(spec);
+	GIT_ASSERT_ARG(spec->src);
 
 	return (spec->src[strlen(spec->src) - 1] == '*');
 }
 
 git_direction git_refspec_direction(const git_refspec *spec)
 {
-	assert(spec);
+	GIT_ASSERT_ARG(spec);
 
 	return spec->push;
 }
@@ -332,7 +366,9 @@ int git_refspec__dwim_one(git_vector *out, git_refspec *spec, git_vector *refs)
 		NULL
 	};
 
-	assert(out && spec && refs);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(spec);
+	GIT_ASSERT_ARG(refs);
 
 	cur = git__calloc(1, sizeof(git_refspec));
 	GIT_ERROR_CHECK_ALLOC(cur);