rugged 0.27.10.1 → 0.28.0

data/vendor/libgit2/src/sysdir.c

@@ -57,12 +57,12 @@ static int get_passwd_home(git_buf *out, uid_t uid)
 	} while (error == ERANGE && buflen <= 8192);
 
 	if (error) {
-		giterr_set(GITERR_OS, "failed to get passwd entry");
+		git_error_set(GIT_ERROR_OS, "failed to get passwd entry");
 		goto out;
 	}
 
 	if (!pwdptr) {
-		giterr_set(GITERR_OS, "no passwd entry found for user");
+		git_error_set(GIT_ERROR_OS, "no passwd entry found for user");
 		goto out;
 	}
 
@@ -96,7 +96,7 @@ static int git_sysdir_guess_global_dirs(git_buf *out)
 	    error = get_passwd_home(out, euid);
 
 	if (error == GIT_ENOTFOUND) {
-		giterr_clear();
+		git_error_clear();
 		error = 0;
 	}
 
@@ -132,11 +132,11 @@ static int git_sysdir_guess_xdg_dirs(git_buf *out)
 	}
 
 	if (error == GIT_ENOTFOUND) {
-		giterr_clear();
+		git_error_clear();
 		error = 0;
 	}
 
-	git_buf_free(&env);
+	git_buf_dispose(&env);
 	return error;
 #endif
 }
@@ -168,7 +168,7 @@ static void git_sysdir_global_shutdown(void)
 	size_t i;
 
 	for (i = 0; i < ARRAY_SIZE(git_sysdir__dirs); ++i)
-		git_buf_free(&git_sysdir__dirs[i].buf);
+		git_buf_dispose(&git_sysdir__dirs[i].buf);
 }
 
 int git_sysdir_global_init(void)
@@ -189,7 +189,7 @@ static int git_sysdir_check_selector(git_sysdir_t which)
 	if (which < ARRAY_SIZE(git_sysdir__dirs))
 		return 0;
 
-	giterr_set(GITERR_INVALID, "config directory selector out of range");
+	git_error_set(GIT_ERROR_INVALID, "config directory selector out of range");
 	return -1;
 }
 
@@ -200,7 +200,7 @@ int git_sysdir_get(const git_buf **out, git_sysdir_t which)
 
 	*out = NULL;
 
-	GITERR_CHECK_ERROR(git_sysdir_check_selector(which));
+	GIT_ERROR_CHECK_ERROR(git_sysdir_check_selector(which));
 
 	*out = &git_sysdir__dirs[which].buf;
 	return 0;
@@ -213,11 +213,11 @@ int git_sysdir_get_str(
 {
 	const git_buf *path = NULL;
 
-	GITERR_CHECK_ERROR(git_sysdir_check_selector(which));
-	GITERR_CHECK_ERROR(git_sysdir_get(&path, which));
+	GIT_ERROR_CHECK_ERROR(git_sysdir_check_selector(which));
+	GIT_ERROR_CHECK_ERROR(git_sysdir_get(&path, which));
 
 	if (!out || path->size >= outlen) {
-		giterr_set(GITERR_NOMEMORY, "buffer is too short for the path");
+		git_error_set(GIT_ERROR_NOMEMORY, "buffer is too short for the path");
 		return GIT_EBUFS;
 	}
 
@@ -232,7 +232,7 @@ int git_sysdir_set(git_sysdir_t which, const char *search_path)
 	const char *expand_path = NULL;
 	git_buf merge = GIT_BUF_INIT;
 
-	GITERR_CHECK_ERROR(git_sysdir_check_selector(which));
+	GIT_ERROR_CHECK_ERROR(git_sysdir_check_selector(which));
 
 	if (search_path != NULL)
 		expand_path = strstr(search_path, PATH_MAGIC);
@@ -262,7 +262,7 @@ int git_sysdir_set(git_sysdir_t which, const char *search_path)
 		git_buf_join(&merge, GIT_PATH_LIST_SEPARATOR, merge.ptr, expand_path);
 
 	git_buf_swap(&git_sysdir__dirs[which].buf, &merge);
-	git_buf_free(&merge);
+	git_buf_dispose(&merge);
 
 done:
 	if (git_buf_oom(&git_sysdir__dirs[which].buf))
@@ -281,7 +281,7 @@ static int git_sysdir_find_in_dirlist(
 	const char *scan, *next = NULL;
 	const git_buf *syspath;
 
-	GITERR_CHECK_ERROR(git_sysdir_get(&syspath, which));
+	GIT_ERROR_CHECK_ERROR(git_sysdir_get(&syspath, which));
 	if (!syspath || !git_buf_len(syspath))
 		goto done;
 
@@ -298,17 +298,17 @@ static int git_sysdir_find_in_dirlist(
 		if (!len)
 			continue;
 
-		GITERR_CHECK_ERROR(git_buf_set(path, scan, len));
+		GIT_ERROR_CHECK_ERROR(git_buf_set(path, scan, len));
 		if (name)
-			GITERR_CHECK_ERROR(git_buf_joinpath(path, path->ptr, name));
+			GIT_ERROR_CHECK_ERROR(git_buf_joinpath(path, path->ptr, name));
 
 		if (git_path_exists(path->ptr))
 			return 0;
 	}
 
 done:
-	git_buf_free(path);
-	giterr_set(GITERR_OS, "the %s file '%s' doesn't exist", label, name);
+	git_buf_dispose(path);
+	git_error_set(GIT_ERROR_OS, "the %s file '%s' doesn't exist", label, name);
 	return GIT_ENOTFOUND;
 }
 

data/vendor/libgit2/src/tag.c

@@ -36,7 +36,7 @@ const git_oid *git_tag_target_id(const git_tag *t)
 	return &t->target;
 }
 
-git_otype git_tag_target_type(const git_tag *t)
+git_object_t git_tag_target_type(const git_tag *t)
 {
 	assert(t);
 	return t->type;
@@ -61,7 +61,7 @@ const char *git_tag_message(const git_tag *t)
 
 static int tag_error(const char *str)
 {
-	giterr_set(GITERR_TAG, "failed to parse tag: %s", str);
+	git_error_set(GIT_ERROR_TAG, "failed to parse tag: %s", str);
 	return -1;
 }
 
@@ -84,7 +84,7 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end)
 		return tag_error("type field not found");
 	buffer += 5;
 
-	tag->type = GIT_OBJ_BAD;
+	tag->type = GIT_OBJECT_INVALID;
 
 	for (i = 1; i < ARRAY_SIZE(tag_types); ++i) {
 		size_t type_length = strlen(tag_types[i]);
@@ -99,7 +99,7 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end)
 		}
 	}
 
-	if (tag->type == GIT_OBJ_BAD)
+	if (tag->type == GIT_OBJECT_INVALID)
 		return tag_error("invalid object type");
 
 	if (buffer + 4 >= buffer_end)
@@ -116,9 +116,9 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end)
 
 	text_len = search - buffer;
 
-	GITERR_CHECK_ALLOC_ADD(&alloc_len, text_len, 1);
+	GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, text_len, 1);
 	tag->tag_name = git__malloc(alloc_len);
-	GITERR_CHECK_ALLOC(tag->tag_name);
+	GIT_ERROR_CHECK_ALLOC(tag->tag_name);
 
 	memcpy(tag->tag_name, buffer, text_len);
 	tag->tag_name[text_len] = '\0';
@@ -128,7 +128,7 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end)
 	tag->tagger = NULL;
 	if (buffer < buffer_end && *buffer != '\n') {
 		tag->tagger = git__malloc(sizeof(git_signature));
-		GITERR_CHECK_ALLOC(tag->tagger);
+		GIT_ERROR_CHECK_ALLOC(tag->tagger);
 
 		if (git_signature__parse(tag->tagger, &buffer, buffer_end, "tagger ", '\n') < 0)
 			return -1;
@@ -148,9 +148,9 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end)
 
 		text_len = buffer_end - ++buffer;
 
-		GITERR_CHECK_ALLOC_ADD(&alloc_len, text_len, 1);
+		GIT_ERROR_CHECK_ALLOC_ADD(&alloc_len, text_len, 1);
 		tag->message = git__malloc(alloc_len);
-		GITERR_CHECK_ALLOC(tag->message);
+		GIT_ERROR_CHECK_ALLOC(tag->message);
 
 		memcpy(tag->message, buffer, text_len);
 		tag->message[text_len] = '\0';
@@ -159,6 +159,11 @@ static int tag_parse(git_tag *tag, const char *buffer, const char *buffer_end)
 	return 0;
 }
 
+int git_tag__parse_raw(void *_tag, const char *data, size_t size)
+{
+	return tag_parse(_tag, data, data + size);
+}
+
 int git_tag__parse(void *_tag, git_odb_object *odb_obj)
 {
 	git_tag *tag = _tag;
@@ -226,15 +231,15 @@ static int write_tag_annotation(
 	if (git_repository_odb__weakptr(&odb, repo) < 0)
 		goto on_error;
 
-	if (git_odb_write(oid, odb, tag.ptr, tag.size, GIT_OBJ_TAG) < 0)
+	if (git_odb_write(oid, odb, tag.ptr, tag.size, GIT_OBJECT_TAG) < 0)
 		goto on_error;
 
-	git_buf_free(&tag);
+	git_buf_dispose(&tag);
 	return 0;
 
 on_error:
-	git_buf_free(&tag);
-	giterr_set(GITERR_OBJECT, "failed to create tag annotation");
+	git_buf_dispose(&tag);
+	git_error_set(GIT_ERROR_OBJECT, "failed to create tag annotation");
 	return -1;
 }
 
@@ -257,7 +262,7 @@ static int git_tag_create__internal(
 	assert(!create_tag_annotation || (tagger && message));
 
 	if (git_object_owner(target) != repo) {
-		giterr_set(GITERR_INVALID, "the given target does not belong to this repository");
+		git_error_set(GIT_ERROR_INVALID, "the given target does not belong to this repository");
 		return -1;
 	}
 
@@ -268,8 +273,8 @@ static int git_tag_create__internal(
 	/** Ensure the tag name doesn't conflict with an already existing
 	 *	reference unless overwriting has explicitly been requested **/
 	if (error == 0 && !allow_ref_overwrite) {
-		git_buf_free(&ref_name);
-		giterr_set(GITERR_TAG, "tag already exists");
+		git_buf_dispose(&ref_name);
+		git_error_set(GIT_ERROR_TAG, "tag already exists");
 		return GIT_EEXISTS;
 	}
 
@@ -283,7 +288,7 @@ static int git_tag_create__internal(
 
 cleanup:
 	git_reference_free(new_ref);
-	git_buf_free(&ref_name);
+	git_buf_dispose(&ref_name);
 	return error;
 }
 
@@ -349,7 +354,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 		goto on_error;
 
 	if (tag.type != target_obj->cached.type) {
-		giterr_set(GITERR_TAG, "the type for the given target is invalid");
+		git_error_set(GIT_ERROR_TAG, "the type for the given target is invalid");
 		goto on_error;
 	}
 
@@ -366,13 +371,13 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 	/** Ensure the tag name doesn't conflict with an already existing
 	 *	reference unless overwriting has explicitly been requested **/
 	if (error == 0 && !allow_ref_overwrite) {
-		giterr_set(GITERR_TAG, "tag already exists");
+		git_error_set(GIT_ERROR_TAG, "tag already exists");
 		return GIT_EEXISTS;
 	}
 
 	/* write the buffer */
 	if ((error = git_odb_open_wstream(
-			&stream, odb, strlen(buffer), GIT_OBJ_TAG)) < 0)
+			&stream, odb, strlen(buffer), GIT_OBJECT_TAG)) < 0)
 		return error;
 
 	if (!(error = git_odb_stream_write(stream, buffer, strlen(buffer))))
@@ -381,7 +386,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 	git_odb_stream_free(stream);
 
 	if (error < 0) {
-		git_buf_free(&ref_name);
+		git_buf_dispose(&ref_name);
 		return error;
 	}
 
@@ -389,7 +394,7 @@ int git_tag_create_frombuffer(git_oid *oid, git_repository *repo, const char *bu
 		&new_ref, repo, ref_name.ptr, oid, allow_ref_overwrite, NULL);
 
 	git_reference_free(new_ref);
-	git_buf_free(&ref_name);
+	git_buf_dispose(&ref_name);
 
 	return error;
 
@@ -409,7 +414,7 @@ int git_tag_delete(git_repository *repo, const char *tag_name)
 
 	error = retrieve_tag_reference(&tag_ref, &ref_name, repo, tag_name);
 
-	git_buf_free(&ref_name);
+	git_buf_dispose(&ref_name);
 
 	if (error < 0)
 		return error;
@@ -438,7 +443,7 @@ static int tags_cb(const char *ref, void *data)
 
 	if (!(error = git_reference_name_to_id(&oid, d->repo, ref))) {
 		if ((error = d->cb(ref, &oid, d->cb_data)) != 0)
-			giterr_set_after_callback_function(error, "git_tag_foreach");
+			git_error_set_after_callback_function(error, "git_tag_foreach");
 	}
 
 	return error;
@@ -473,7 +478,7 @@ static int tag_list_cb(const char *tag_name, git_oid *oid, void *data)
 		p_fnmatch(filter->pattern, tag_name + GIT_REFS_TAGS_DIR_LEN, 0) == 0)
 	{
 		char *matched = git__strdup(tag_name + GIT_REFS_TAGS_DIR_LEN);
-		GITERR_CHECK_ALLOC(matched);
+		GIT_ERROR_CHECK_ALLOC(matched);
 
 		return git_vector_insert(filter->taglist, matched);
 	}
@@ -513,5 +518,5 @@ int git_tag_list(git_strarray *tag_names, git_repository *repo)
 
 int git_tag_peel(git_object **tag_target, const git_tag *tag)
 {
-	return git_object_peel(tag_target, (const git_object *)tag, GIT_OBJ_ANY);
+	return git_object_peel(tag_target, (const git_object *)tag, GIT_OBJECT_ANY);
 }

data/vendor/libgit2/src/tag.h

@@ -17,7 +17,7 @@ struct git_tag {
 	git_object object;
 
 	git_oid target;
-	git_otype type;
+	git_object_t type;
 
 	char *tag_name;
 	git_signature *tagger;
@@ -26,5 +26,6 @@ struct git_tag {
 
 void git_tag__free(void *tag);
 int git_tag__parse(void *tag, git_odb_object *obj);
+int git_tag__parse_raw(void *tag, const char *data, size_t size);
 
 #endif

data/vendor/libgit2/src/trace.c

@@ -31,7 +31,7 @@ int git_trace_set(git_trace_level_t level, git_trace_callback callback)
 	GIT_UNUSED(level);
 	GIT_UNUSED(callback);
 
-	giterr_set(GITERR_INVALID,
+	git_error_set(GIT_ERROR_INVALID,
 		"this version of libgit2 was not built with tracing.");
 	return -1;
 #endif

data/vendor/libgit2/src/trace.h

@@ -35,7 +35,7 @@ GIT_INLINE(void) git_trace__write_fmt(
 
 	callback(level, git_buf_cstr(&message));
 
-	git_buf_free(&message);
+	git_buf_dispose(&message);
 }
 
 #define git_trace_level()		(git_trace__data.level)

data/vendor/libgit2/src/trailer.c

@@ -36,7 +36,7 @@ static const char *next_line(const char *str)
 	if (nl) {
 		return nl + 1;
 	} else {
-		// return pointer to the NUL terminator:
+		/* return pointer to the NUL terminator: */
 		return str + strlen(str);
 	}
 }
@@ -310,12 +310,12 @@ int git_message_trailers(git_message_trailer_array *trailer_arr, const char *mes
 				}
 
 				if (isalnum(*ptr) || *ptr == '-') {
-					// legal key character
+					/* legal key character */
 					NEXT(S_KEY);
 				}
 
 				if (*ptr == ' ' || *ptr == '\t') {
-					// optional whitespace before separator
+					/* optional whitespace before separator */
 					*ptr = 0;
 					NEXT(S_KEY_WS);
 				}
@@ -325,7 +325,7 @@ int git_message_trailers(git_message_trailer_array *trailer_arr, const char *mes
 					NEXT(S_SEP_WS);
 				}
 
-				// illegal character
+				/* illegal character */
 				GOTO(S_IGNORE);
 			}
 			case S_KEY_WS: {
@@ -341,7 +341,7 @@ int git_message_trailers(git_message_trailer_array *trailer_arr, const char *mes
 					NEXT(S_SEP_WS);
 				}
 
-				// illegal character
+				/* illegal character */
 				GOTO(S_IGNORE);
 			}
 			case S_SEP_WS: {
@@ -369,7 +369,7 @@ int git_message_trailers(git_message_trailer_array *trailer_arr, const char *mes
 			}
 			case S_VALUE_NL: {
 				if (*ptr == ' ') {
-					// continuation;
+					/* continuation; */
 					NEXT(S_VALUE);
 				}
 

data/vendor/libgit2/src/transaction.c

@@ -30,7 +30,7 @@ typedef struct {
 	const char *name;
 	void *payload;
 
-	git_ref_t ref_type;
+	git_reference_t ref_type;
 	union {
 		git_oid id;
 		char *symbolic;
@@ -60,7 +60,7 @@ int git_transaction_config_new(git_transaction **out, git_config *cfg)
 	assert(out && cfg);
 
 	tx = git__calloc(1, sizeof(git_transaction));
-	GITERR_CHECK_ALLOC(tx);
+	GIT_ERROR_CHECK_ALLOC(tx);
 
 	tx->type = TRANSACTION_CONFIG;
 	tx->cfg = cfg;
@@ -111,16 +111,16 @@ int git_transaction_lock_ref(git_transaction *tx, const char *refname)
 	assert(tx && refname);
 
 	node = git_pool_mallocz(&tx->pool, sizeof(transaction_node));
-	GITERR_CHECK_ALLOC(node);
+	GIT_ERROR_CHECK_ALLOC(node);
 
 	node->name = git_pool_strdup(&tx->pool, refname);
-	GITERR_CHECK_ALLOC(node->name);
+	GIT_ERROR_CHECK_ALLOC(node->name);
 
 	if ((error = git_refdb_lock(&node->payload, tx->db, refname)) < 0)
 		return error;
 
 	git_strmap_insert(tx->locks, node->name, node, &error);
-	if (error < 0) 
+	if (error < 0)
 		goto cleanup;
 
 	return 0;
@@ -133,12 +133,12 @@ cleanup:
 
 static int find_locked(transaction_node **out, git_transaction *tx, const char *refname)
 {
-	git_strmap_iter pos;
 	transaction_node *node;
+	size_t pos;
 
 	pos = git_strmap_lookup_index(tx->locks, refname);
 	if (!git_strmap_valid_index(tx->locks, pos)) {
-		giterr_set(GITERR_REFERENCE, "the specified reference is not locked");
+		git_error_set(GIT_ERROR_REFERENCE, "the specified reference is not locked");
 		return GIT_ENOTFOUND;
 	}
 
@@ -169,7 +169,7 @@ static int copy_common(transaction_node *node, git_transaction *tx, const git_si
 
 	if (msg) {
 		node->message = git_pool_strdup(&tx->pool, msg);
-		GITERR_CHECK_ALLOC(node->message);
+		GIT_ERROR_CHECK_ALLOC(node->message);
 	}
 
 	return 0;
@@ -189,7 +189,7 @@ int git_transaction_set_target(git_transaction *tx, const char *refname, const g
 		return error;
 
 	git_oid_cpy(&node->target.id, target);
-	node->ref_type = GIT_REF_OID;
+	node->ref_type = GIT_REFERENCE_DIRECT;
 
 	return 0;
 }
@@ -208,8 +208,8 @@ int git_transaction_set_symbolic_target(git_transaction *tx, const char *refname
 		return error;
 
 	node->target.symbolic = git_pool_strdup(&tx->pool, target);
-	GITERR_CHECK_ALLOC(node->target.symbolic);
-	node->ref_type = GIT_REF_SYMBOLIC;
+	GIT_ERROR_CHECK_ALLOC(node->target.symbolic);
+	node->ref_type = GIT_REFERENCE_SYMBOLIC;
 
 	return 0;
 }
@@ -223,7 +223,7 @@ int git_transaction_remove(git_transaction *tx, const char *refname)
 		return error;
 
 	node->remove = true;
-	node->ref_type = GIT_REF_OID; /* the id will be ignored */
+	node->ref_type = GIT_REFERENCE_DIRECT; /* the id will be ignored */
 
 	return 0;
 }
@@ -235,18 +235,18 @@ static int dup_reflog(git_reflog **out, const git_reflog *in, git_pool *pool)
 	size_t len, i;
 
 	reflog = git_pool_mallocz(pool, sizeof(git_reflog));
-	GITERR_CHECK_ALLOC(reflog);
+	GIT_ERROR_CHECK_ALLOC(reflog);
 
 	reflog->ref_name = git_pool_strdup(pool, in->ref_name);
-	GITERR_CHECK_ALLOC(reflog->ref_name);
+	GIT_ERROR_CHECK_ALLOC(reflog->ref_name);
 
 	len = in->entries.length;
 	reflog->entries.length = len;
 	reflog->entries.contents = git_pool_mallocz(pool, len * sizeof(void *));
-	GITERR_CHECK_ALLOC(reflog->entries.contents);
+	GIT_ERROR_CHECK_ALLOC(reflog->entries.contents);
 
 	entries = git_pool_mallocz(pool, len * sizeof(git_reflog_entry));
-	GITERR_CHECK_ALLOC(entries);
+	GIT_ERROR_CHECK_ALLOC(entries);
 
 	for (i = 0; i < len; i++) {
 		const git_reflog_entry *src;
@@ -260,7 +260,7 @@ static int dup_reflog(git_reflog **out, const git_reflog *in, git_pool *pool)
 		git_oid_cpy(&tgt->oid_cur, &src->oid_cur);
 
 		tgt->msg = git_pool_strdup(pool, src->msg);
-		GITERR_CHECK_ALLOC(tgt->msg);
+		GIT_ERROR_CHECK_ALLOC(tgt->msg);
 
 		if (git_signature__pdup(&tgt->committer, src->committer, pool) < 0)
 			return -1;
@@ -292,22 +292,22 @@ static int update_target(git_refdb *db, transaction_node *node)
 	git_reference *ref;
 	int error, update_reflog;
 
-	if (node->ref_type == GIT_REF_OID) {
+	if (node->ref_type == GIT_REFERENCE_DIRECT) {
 		ref = git_reference__alloc(node->name, &node->target.id, NULL);
-	} else if (node->ref_type == GIT_REF_SYMBOLIC) {
+	} else if (node->ref_type == GIT_REFERENCE_SYMBOLIC) {
 		ref = git_reference__alloc_symbolic(node->name, node->target.symbolic);
 	} else {
 		abort();
 	}
 
-	GITERR_CHECK_ALLOC(ref);
+	GIT_ERROR_CHECK_ALLOC(ref);
 	update_reflog = node->reflog == NULL;
 
 	if (node->remove) {
 		error =  git_refdb_unlock(db, node->payload, 2, false, ref, NULL, NULL);
-	} else if (node->ref_type == GIT_REF_OID) {
+	} else if (node->ref_type == GIT_REFERENCE_DIRECT) {
 		error = git_refdb_unlock(db, node->payload, true, update_reflog, ref, node->sig, node->message);
-	} else if (node->ref_type == GIT_REF_SYMBOLIC) {
+	} else if (node->ref_type == GIT_REFERENCE_SYMBOLIC) {
 		error = git_refdb_unlock(db, node->payload, true, update_reflog, ref, node->sig, node->message);
 	} else {
 		abort();
@@ -339,7 +339,7 @@ int git_transaction_commit(git_transaction *tx)
 				return error;
 		}
 
-		if (node->ref_type != GIT_REF_INVALID) {
+		if (node->ref_type != GIT_REFERENCE_INVALID) {
 			if ((error = update_target(tx->db, node)) < 0)
 				return error;
 		}