rugged 0.27.9 → 0.27.10

data/vendor/libgit2/src/reflog.c

@@ -74,32 +74,30 @@ int git_reflog_write(git_reflog *reflog)
 
 int git_reflog_append(git_reflog *reflog, const git_oid *new_oid, const git_signature *committer, const char *msg)
 {
-	git_reflog_entry *entry;
 	const git_reflog_entry *previous;
-	const char *newline;
+	git_reflog_entry *entry;
 
 	assert(reflog && new_oid && committer);
 
 	entry = git__calloc(1, sizeof(git_reflog_entry));
-	GITERR_CHECK_ALLOC(entry);
+	GIT_ERROR_CHECK_ALLOC(entry);
 
 	if ((git_signature_dup(&entry->committer, committer)) < 0)
 		goto cleanup;
 
 	if (msg != NULL) {
-		if ((entry->msg = git__strdup(msg)) == NULL)
-			goto cleanup;
+		size_t i, msglen = strlen(msg);
 
-		newline = strchr(msg, '\n');
-
-		if (newline) {
-			if (newline[1] != '\0') {
-				giterr_set(GITERR_INVALID, "reflog message cannot contain newline");
-				goto cleanup;
-			}
+		if ((entry->msg = git__strndup(msg, msglen)) == NULL)
+			goto cleanup;
 
-			entry->msg[newline - msg] = '\0';
-		}
+		/*
+		 * Replace all newlines with spaces, except for
+		 * the final trailing newline.
+		 */
+		for (i = 0; i < msglen; i++)
+			if (entry->msg[i] == '\n')
+				entry->msg[i] = ' ';
 	}
 
 	previous = git_reflog_entry_byindex(reflog, 0);
@@ -194,7 +192,7 @@ int git_reflog_drop(git_reflog *reflog, size_t idx, int rewrite_previous_entry)
 	entry = (git_reflog_entry *)git_reflog_entry_byindex(reflog, idx);
 
 	if (entry == NULL) {
-		giterr_set(GITERR_REFERENCE, "no reflog entry at index %"PRIuZ, idx);
+		git_error_set(GIT_ERROR_REFERENCE, "no reflog entry at index %"PRIuZ, idx);
 		return GIT_ENOTFOUND;
 	}
 

data/vendor/libgit2/src/refs.c

@@ -9,7 +9,7 @@
 
 #include "hash.h"
 #include "repository.h"
-#include "fileops.h"
+#include "futils.h"
 #include "filebuf.h"
 #include "pack.h"
 #include "reflog.h"
@@ -59,7 +59,7 @@ git_reference *git_reference__alloc_symbolic(
 	if (!ref)
 		return NULL;
 
-	ref->type = GIT_REF_SYMBOLIC;
+	ref->type = GIT_REFERENCE_SYMBOLIC;
 
 	if ((ref->target.symbolic = git__strdup(target)) == NULL) {
 		git__free(ref);
@@ -82,7 +82,7 @@ git_reference *git_reference__alloc(
 	if (!ref)
 		return NULL;
 
-	ref->type = GIT_REF_OID;
+	ref->type = GIT_REFERENCE_DIRECT;
 	git_oid_cpy(&ref->target.oid, oid);
 
 	if (peel != NULL)
@@ -108,12 +108,12 @@ git_reference *git_reference__set_name(
 
 int git_reference_dup(git_reference **dest, git_reference *source)
 {
-	if (source->type == GIT_REF_SYMBOLIC)
+	if (source->type == GIT_REFERENCE_SYMBOLIC)
 		*dest = git_reference__alloc_symbolic(source->name, source->target.symbolic);
 	else
 		*dest = git_reference__alloc(source->name, &source->target.oid, &source->peel);
 
-	GITERR_CHECK_ALLOC(*dest);
+	GIT_ERROR_CHECK_ALLOC(*dest);
 
 	(*dest)->db = source->db;
 	GIT_REFCOUNT_INC((*dest)->db);
@@ -126,7 +126,7 @@ void git_reference_free(git_reference *reference)
 	if (reference == NULL)
 		return;
 
-	if (reference->type == GIT_REF_SYMBOLIC)
+	if (reference->type == GIT_REFERENCE_SYMBOLIC)
 		git__free(reference->target.symbolic);
 
 	if (reference->db)
@@ -140,7 +140,7 @@ int git_reference_delete(git_reference *ref)
 	const git_oid *old_id = NULL;
 	const char *old_target = NULL;
 
-	if (ref->type == GIT_REF_OID)
+	if (ref->type == GIT_REFERENCE_DIRECT)
 		old_id = &ref->target.oid;
 	else
 		old_target = ref->target.symbolic;
@@ -186,14 +186,14 @@ static int reference_normalize_for_repo(
 	bool validate)
 {
 	int precompose;
-	unsigned int flags = GIT_REF_FORMAT_ALLOW_ONELEVEL;
+	unsigned int flags = GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL;
 
-	if (!git_repository__cvar(&precompose, repo, GIT_CVAR_PRECOMPOSE) &&
+	if (!git_repository__configmap_lookup(&precompose, repo, GIT_CONFIGMAP_PRECOMPOSE) &&
 		precompose)
-		flags |= GIT_REF_FORMAT__PRECOMPOSE_UNICODE;
+		flags |= GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE;
 
 	if (!validate)
-		flags |= GIT_REF_FORMAT__VALIDATION_DISABLE;
+		flags |= GIT_REFERENCE_FORMAT__VALIDATION_DISABLE;
 
 	return git_reference_normalize_name(out, GIT_REFNAME_MAX, name, flags);
 }
@@ -205,7 +205,7 @@ int git_reference_lookup_resolved(
 	int max_nesting)
 {
 	git_refname_t scan_name;
-	git_ref_t scan_type;
+	git_reference_t scan_type;
 	int error = 0, nesting;
 	git_reference *ref = NULL;
 	git_refdb *refdb;
@@ -219,7 +219,7 @@ int git_reference_lookup_resolved(
 	else if (max_nesting < 0)
 		max_nesting = DEFAULT_NESTING_LEVEL;
 
-	scan_type = GIT_REF_SYMBOLIC;
+	scan_type = GIT_REFERENCE_SYMBOLIC;
 
 	if ((error = reference_normalize_for_repo(scan_name, repo, name, true)) < 0)
 		return error;
@@ -228,7 +228,7 @@ int git_reference_lookup_resolved(
 		return error;
 
 	for (nesting = max_nesting;
-		 nesting >= 0 && scan_type == GIT_REF_SYMBOLIC;
+		 nesting >= 0 && scan_type == GIT_REFERENCE_SYMBOLIC;
 		 nesting--)
 	{
 		if (nesting != max_nesting) {
@@ -242,8 +242,8 @@ int git_reference_lookup_resolved(
 		scan_type = ref->type;
 	}
 
-	if (scan_type != GIT_REF_OID && max_nesting != 0) {
-		giterr_set(GITERR_REFERENCE,
+	if (scan_type != GIT_REFERENCE_DIRECT && max_nesting != 0) {
+		git_error_set(GIT_ERROR_REFERENCE,
 			"cannot resolve reference (>%u levels deep)", max_nesting);
 		git_reference_free(ref);
 		return -1;
@@ -282,7 +282,7 @@ int git_reference__read_head(
 
 out:
 	git__free(name);
-	git_buf_free(&reference);
+	git_buf_dispose(&reference);
 
 	return error;
 }
@@ -339,22 +339,22 @@ int git_reference_dwim(git_reference **out, git_repository *repo, const char *re
 cleanup:
 	if (error && !foundvalid) {
 		/* never found a valid reference name */
-		giterr_set(GITERR_REFERENCE,
+		git_error_set(GIT_ERROR_REFERENCE,
 			"could not use '%s' as valid reference name", git_buf_cstr(&name));
 	}
 
 	if (error == GIT_ENOTFOUND)
-		giterr_set(GITERR_REFERENCE, "no reference found for shorthand '%s'", refname);
+		git_error_set(GIT_ERROR_REFERENCE, "no reference found for shorthand '%s'", refname);
 
-	git_buf_free(&name);
-	git_buf_free(&refnamebuf);
+	git_buf_dispose(&name);
+	git_buf_dispose(&refnamebuf);
 	return error;
 }
 
 /**
  * Getters
  */
-git_ref_t git_reference_type(const git_reference *ref)
+git_reference_t git_reference_type(const git_reference *ref)
 {
 	assert(ref);
 	return ref->type;
@@ -376,7 +376,7 @@ const git_oid *git_reference_target(const git_reference *ref)
 {
 	assert(ref);
 
-	if (ref->type != GIT_REF_OID)
+	if (ref->type != GIT_REFERENCE_DIRECT)
 		return NULL;
 
 	return &ref->target.oid;
@@ -386,7 +386,7 @@ const git_oid *git_reference_target_peel(const git_reference *ref)
 {
 	assert(ref);
 
-	if (ref->type != GIT_REF_OID || git_oid_iszero(&ref->peel))
+	if (ref->type != GIT_REFERENCE_DIRECT || git_oid_is_zero(&ref->peel))
 		return NULL;
 
 	return &ref->peel;
@@ -396,7 +396,7 @@ const char *git_reference_symbolic_target(const git_reference *ref)
 {
 	assert(ref);
 
-	if (ref->type != GIT_REF_SYMBOLIC)
+	if (ref->type != GIT_REFERENCE_SYMBOLIC)
 		return NULL;
 
 	return ref->target.symbolic;
@@ -436,8 +436,8 @@ static int reference__create(
 	if (oid != NULL) {
 		assert(symbolic == NULL);
 
-		if (!git_object__is_valid(repo, oid, GIT_OBJ_ANY)) {
-			giterr_set(GITERR_REFERENCE,
+		if (!git_object__is_valid(repo, oid, GIT_OBJECT_ANY)) {
+			git_error_set(GIT_ERROR_REFERENCE,
 				"target OID for the reference doesn't exist on the repository");
 			return -1;
 		}
@@ -455,7 +455,7 @@ static int reference__create(
 		ref = git_reference__alloc_symbolic(normalized, normalized_target);
 	}
 
-	GITERR_CHECK_ALLOC(ref);
+	GIT_ERROR_CHECK_ALLOC(ref);
 
 	if ((error = git_refdb_write(refdb, ref, force, signature, log_message, old_id, old_target)) < 0) {
 		git_reference_free(ref);
@@ -566,10 +566,10 @@ int git_reference_symbolic_create(
 
 static int ensure_is_an_updatable_direct_reference(git_reference *ref)
 {
-	if (ref->type == GIT_REF_OID)
+	if (ref->type == GIT_REFERENCE_DIRECT)
 		return 0;
 
-	giterr_set(GITERR_REFERENCE, "cannot set OID on symbolic reference");
+	git_error_set(GIT_ERROR_REFERENCE, "cannot set OID on symbolic reference");
 	return -1;
 }
 
@@ -594,10 +594,10 @@ int git_reference_set_target(
 
 static int ensure_is_an_updatable_symbolic_reference(git_reference *ref)
 {
-	if (ref->type == GIT_REF_SYMBOLIC)
+	if (ref->type == GIT_REFERENCE_SYMBOLIC)
 		return 0;
 
-	giterr_set(GITERR_REFERENCE, "cannot set symbolic target on a direct reference");
+	git_error_set(GIT_ERROR_REFERENCE, "cannot set symbolic target on a direct reference");
 	return -1;
 }
 
@@ -631,7 +631,7 @@ static int update_wt_heads(git_repository *repo, const char *path, void *payload
 	int error;
 
 	if ((error = git_reference__read_head(&head, repo, path)) < 0) {
-		giterr_set(GITERR_REFERENCE, "could not read HEAD when renaming references");
+		git_error_set(GIT_ERROR_REFERENCE, "could not read HEAD when renaming references");
 		goto out;
 	}
 
@@ -640,7 +640,7 @@ static int update_wt_heads(git_repository *repo, const char *path, void *payload
 		goto out;
 	}
 
-	if (git_reference_type(head) != GIT_REF_SYMBOLIC ||
+	if (git_reference_type(head) != GIT_REFERENCE_SYMBOLIC ||
 	    git__strcmp(head->target.symbolic, data->old_name) != 0) {
 		error = 0;
 		goto out;
@@ -648,7 +648,7 @@ static int update_wt_heads(git_repository *repo, const char *path, void *payload
 
 	/* Update HEAD it was pointing to the reference being renamed */
 	if ((error = git_repository_create_head(gitdir, data->new_name)) < 0) {
-		giterr_set(GITERR_REFERENCE, "failed to update HEAD after renaming reference");
+		git_error_set(GIT_ERROR_REFERENCE, "failed to update HEAD after renaming reference");
 		goto out;
 	}
 
@@ -692,7 +692,7 @@ static int reference__rename(git_reference **out, git_reference *ref, const char
 		payload.old_name = ref->name;
 		memcpy(&payload.new_name, &normalized, sizeof(normalized));
 
-		error = git_repository_foreach_head(repo, update_wt_heads, &payload);
+		error = git_repository_foreach_head(repo, update_wt_heads, 0, &payload);
 	}
 
 	return error;
@@ -723,14 +723,14 @@ int git_reference_rename(
 int git_reference_resolve(git_reference **ref_out, const git_reference *ref)
 {
 	switch (git_reference_type(ref)) {
-	case GIT_REF_OID:
+	case GIT_REFERENCE_DIRECT:
 		return git_reference_lookup(ref_out, ref->db->repo, ref->name);
 
-	case GIT_REF_SYMBOLIC:
+	case GIT_REFERENCE_SYMBOLIC:
 		return git_reference_lookup_resolved(ref_out, ref->db->repo, ref->target.symbolic, -1);
 
 	default:
-		giterr_set(GITERR_REFERENCE, "invalid reference");
+		git_error_set(GIT_ERROR_REFERENCE, "invalid reference");
 		return -1;
 	}
 }
@@ -749,7 +749,7 @@ int git_reference_foreach(
 
 	while (!(error = git_reference_next(&ref, iter))) {
 		if ((error = callback(ref, payload)) != 0) {
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 			break;
 		}
 	}
@@ -775,7 +775,7 @@ int git_reference_foreach_name(
 
 	while (!(error = git_reference_next_name(&refname, iter))) {
 		if ((error = callback(refname, payload)) != 0) {
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 			break;
 		}
 	}
@@ -802,7 +802,7 @@ int git_reference_foreach_glob(
 
 	while (!(error = git_reference_next_name(&refname, iter))) {
 		if ((error = callback(refname, payload)) != 0) {
-			giterr_set_after_callback(error);
+			git_error_set_after_callback(error);
 			break;
 		}
 	}
@@ -856,7 +856,7 @@ void git_reference_iterator_free(git_reference_iterator *iter)
 static int cb__reflist_add(const char *ref, void *data)
 {
 	char *name = git__strdup(ref);
-	GITERR_CHECK_ALLOC(name);
+	GIT_ERROR_CHECK_ALLOC(name);
 	return git_vector_insert((git_vector *)data, name);
 }
 
@@ -897,14 +897,13 @@ static int is_valid_ref_char(char ch)
 	case '\\':
 	case '?':
 	case '[':
-	case '*':
 		return 0;
 	default:
 		return 1;
 	}
 }
 
-static int ensure_segment_validity(const char *name)
+static int ensure_segment_validity(const char *name, char may_contain_glob)
 {
 	const char *current = name;
 	char prev = '\0';
@@ -927,6 +926,12 @@ static int ensure_segment_validity(const char *name)
 		if (prev == '@' && *current == '{')
 			return -1; /* Refname contains "@{" */
 
+		if (*current == '*') {
+			if (!may_contain_glob)
+				return -1;
+			may_contain_glob = 0;
+		}
+
 		prev = *current;
 	}
 
@@ -970,7 +975,7 @@ int git_reference__normalize_name(
 	int segment_len, segments_count = 0, error = GIT_EINVALIDSPEC;
 	unsigned int process_flags;
 	bool normalize = (buf != NULL);
-	bool validate = (flags & GIT_REF_FORMAT__VALIDATION_DISABLE) == 0;
+	bool validate = (flags & GIT_REFERENCE_FORMAT__VALIDATION_DISABLE) == 0;
 
 #ifdef GIT_USE_ICONV
 	git_path_iconv_t ic = GIT_PATH_ICONV_INIT;
@@ -988,7 +993,7 @@ int git_reference__normalize_name(
 		git_buf_clear(buf);
 
 #ifdef GIT_USE_ICONV
-	if ((flags & GIT_REF_FORMAT__PRECOMPOSE_UNICODE) != 0) {
+	if ((flags & GIT_REFERENCE_FORMAT__PRECOMPOSE_UNICODE) != 0) {
 		size_t namelen = strlen(current);
 		if ((error = git_path_iconv_init_precompose(&ic)) < 0 ||
 			(error = git_path_iconv(&ic, &current, &namelen)) < 0)
@@ -1005,19 +1010,20 @@ int git_reference__normalize_name(
 	}
 
 	while (true) {
-		segment_len = ensure_segment_validity(current);
-		if (segment_len < 0) {
-			if ((process_flags & GIT_REF_FORMAT_REFSPEC_PATTERN) &&
-					current[0] == '*' &&
-					(current[1] == '\0' || current[1] == '/')) {
-				/* Accept one wildcard as a full refname component. */
-				process_flags &= ~GIT_REF_FORMAT_REFSPEC_PATTERN;
-				segment_len = 1;
-			} else
-				goto cleanup;
-		}
+		char may_contain_glob = process_flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN;
+
+		segment_len = ensure_segment_validity(current, may_contain_glob);
+		if (segment_len < 0)
+			goto cleanup;
 
 		if (segment_len > 0) {
+			/*
+			 * There may only be one glob in a pattern, thus we reset
+			 * the pattern-flag in case the current segment has one.
+			 */
+			if (memchr(current, '*', segment_len))
+				process_flags &= ~GIT_REFERENCE_FORMAT_REFSPEC_PATTERN;
+
 			if (normalize) {
 				size_t cur_len = git_buf_len(buf);
 
@@ -1056,13 +1062,13 @@ int git_reference__normalize_name(
 	if (current[segment_len - 1] == '/')
 		goto cleanup;
 
-	if ((segments_count == 1 ) && !(flags & GIT_REF_FORMAT_ALLOW_ONELEVEL))
+	if ((segments_count == 1 ) && !(flags & GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL))
 		goto cleanup;
 
 	if ((segments_count == 1 ) &&
-	    !(flags & GIT_REF_FORMAT_REFSPEC_SHORTHAND) &&
+	    !(flags & GIT_REFERENCE_FORMAT_REFSPEC_SHORTHAND) &&
 		!(is_all_caps_and_underscore(name, (size_t)segment_len) ||
-			((flags & GIT_REF_FORMAT_REFSPEC_PATTERN) && !strcmp("*", name))))
+			((flags & GIT_REFERENCE_FORMAT_REFSPEC_PATTERN) && !strcmp("*", name))))
 			goto cleanup;
 
 	if ((segments_count > 1)
@@ -1073,12 +1079,12 @@ int git_reference__normalize_name(
 
 cleanup:
 	if (error == GIT_EINVALIDSPEC)
-		giterr_set(
-			GITERR_REFERENCE,
+		git_error_set(
+			GIT_ERROR_REFERENCE,
 			"the given reference name '%s' is not valid", name);
 
 	if (error && normalize)
-		git_buf_free(buf);
+		git_buf_dispose(buf);
 
 #ifdef GIT_USE_ICONV
 	git_path_iconv_clear(&ic);
@@ -1100,8 +1106,8 @@ int git_reference_normalize_name(
 		goto cleanup;
 
 	if (git_buf_len(&buf) > buffer_size - 1) {
-		giterr_set(
-		GITERR_REFERENCE,
+		git_error_set(
+		GIT_ERROR_REFERENCE,
 		"the provided buffer is too short to hold the normalization of '%s'", name);
 		error = GIT_EBUFS;
 		goto cleanup;
@@ -1112,17 +1118,17 @@ int git_reference_normalize_name(
 	error = 0;
 
 cleanup:
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 	return error;
 }
 
-#define GIT_REF_TYPEMASK (GIT_REF_OID | GIT_REF_SYMBOLIC)
+#define GIT_REFERENCE_TYPEMASK (GIT_REFERENCE_DIRECT | GIT_REFERENCE_SYMBOLIC)
 
 int git_reference_cmp(
 	const git_reference *ref1,
 	const git_reference *ref2)
 {
-	git_ref_t type1, type2;
+	git_reference_t type1, type2;
 	assert(ref1 && ref2);
 
 	type1 = git_reference_type(ref1);
@@ -1130,9 +1136,9 @@ int git_reference_cmp(
 
 	/* let's put symbolic refs before OIDs */
 	if (type1 != type2)
-		return (type1 == GIT_REF_SYMBOLIC) ? -1 : 1;
+		return (type1 == GIT_REFERENCE_SYMBOLIC) ? -1 : 1;
 
-	if (type1 == GIT_REF_SYMBOLIC)
+	if (type1 == GIT_REFERENCE_SYMBOLIC)
 		return strcmp(ref1->target.symbolic, ref2->target.symbolic);
 
 	return git_oid__cmp(&ref1->target.oid, &ref2->target.oid);
@@ -1148,7 +1154,7 @@ static int get_terminal(git_reference **out, git_repository *repo, const char *r
 	int error = 0;
 
 	if (nesting > MAX_NESTING_LEVEL) {
-		giterr_set(GITERR_REFERENCE, "reference chain too deep (%d)", nesting);
+		git_error_set(GIT_ERROR_REFERENCE, "reference chain too deep (%d)", nesting);
 		return GIT_ENOTFOUND;
 	}
 
@@ -1158,7 +1164,7 @@ static int get_terminal(git_reference **out, git_repository *repo, const char *r
 		return error;
 	}
 
-	if (git_reference_type(ref) == GIT_REF_OID) {
+	if (git_reference_type(ref) == GIT_REFERENCE_DIRECT) {
 		*out = ref;
 		error = 0;
 	} else {
@@ -1197,16 +1203,16 @@ int git_reference__update_terminal(
 
 	/* found a dangling symref */
 	if (error == GIT_ENOTFOUND && ref) {
-		assert(git_reference_type(ref) == GIT_REF_SYMBOLIC);
-		giterr_clear();
+		assert(git_reference_type(ref) == GIT_REFERENCE_SYMBOLIC);
+		git_error_clear();
 		error = reference__create(&ref2, repo, ref->target.symbolic, oid, NULL, 0, to_use,
 					  log_message, NULL, NULL);
 	} else if (error == GIT_ENOTFOUND) {
-		giterr_clear();
+		git_error_clear();
 		error = reference__create(&ref2, repo, ref_name, oid, NULL, 0, to_use,
 					  log_message, NULL, NULL);
 	}  else if (error == 0) {
-		assert(git_reference_type(ref) == GIT_REF_OID);
+		assert(git_reference_type(ref) == GIT_REFERENCE_DIRECT);
 		error = reference__create(&ref2, repo, ref->name, oid, NULL, 1, to_use,
 					  log_message, &ref->target.oid, NULL);
 	}
@@ -1264,7 +1270,7 @@ int git_reference__update_for_commit(
 
 done:
 	git_reference_free(ref_new);
-	git_buf_free(&reflog_msg);
+	git_buf_dispose(&reflog_msg);
 	git_commit_free(commit);
 	return error;
 }
@@ -1341,8 +1347,8 @@ int git_reference_is_note(const git_reference *ref)
 
 static int peel_error(int error, const git_reference *ref, const char* msg)
 {
-	giterr_set(
-		GITERR_INVALID,
+	git_error_set(
+		GIT_ERROR_INVALID,
 		"the reference '%s' cannot be peeled - %s", git_reference_name(ref), msg);
 	return error;
 }
@@ -1350,7 +1356,7 @@ static int peel_error(int error, const git_reference *ref, const char* msg)
 int git_reference_peel(
 	git_object **peeled,
 	const git_reference *ref,
-	git_otype target_type)
+	git_object_t target_type)
 {
 	const git_reference *resolved = NULL;
 	git_reference *allocated = NULL;
@@ -1359,7 +1365,7 @@ int git_reference_peel(
 
 	assert(ref);
 
-	if (ref->type == GIT_REF_OID) {
+	if (ref->type == GIT_REFERENCE_DIRECT) {
 		resolved = ref;
 	} else {
 		if ((error = git_reference_resolve(&allocated, ref)) < 0)
@@ -1374,12 +1380,12 @@ int git_reference_peel(
 	 * to a commit. So we only want to use the peeled value
 	 * if it is not zero and the target is not a tag.
 	 */
-	if (target_type != GIT_OBJ_TAG && !git_oid_iszero(&resolved->peel)) {
+	if (target_type != GIT_OBJECT_TAG && !git_oid_is_zero(&resolved->peel)) {
 		error = git_object_lookup(&target,
-			git_reference_owner(ref), &resolved->peel, GIT_OBJ_ANY);
+			git_reference_owner(ref), &resolved->peel, GIT_OBJECT_ANY);
 	} else {
 		error = git_object_lookup(&target,
-			git_reference_owner(ref), &resolved->target.oid, GIT_OBJ_ANY);
+			git_reference_owner(ref), &resolved->target.oid, GIT_OBJECT_ANY);
 	}
 
 	if (error < 0) {
@@ -1387,7 +1393,7 @@ int git_reference_peel(
 		goto cleanup;
 	}
 
-	if (target_type == GIT_OBJ_ANY && git_object_type(target) != GIT_OBJ_TAG)
+	if (target_type == GIT_OBJECT_ANY && git_object_type(target) != GIT_OBJECT_TAG)
 		error = git_object_dup(peeled, target);
 	else
 		error = git_object_peel(peeled, target, target_type);
@@ -1402,7 +1408,7 @@ cleanup:
 int git_reference__is_valid_name(const char *refname, unsigned int flags)
 {
 	if (git_reference__normalize_name(NULL, refname, flags) < 0) {
-		giterr_clear();
+		git_error_clear();
 		return false;
 	}
 
@@ -1411,7 +1417,7 @@ int git_reference__is_valid_name(const char *refname, unsigned int flags)
 
 int git_reference_is_valid_name(const char *refname)
 {
-	return git_reference__is_valid_name(refname, GIT_REF_FORMAT_ALLOW_ONELEVEL);
+	return git_reference__is_valid_name(refname, GIT_REFERENCE_FORMAT_ALLOW_ONELEVEL);
 }
 
 const char *git_reference__shorthand(const char *name)
@@ -1433,3 +1439,27 @@ const char *git_reference_shorthand(const git_reference *ref)
 {
 	return git_reference__shorthand(ref->name);
 }
+
+int git_reference__is_unborn_head(bool *unborn, const git_reference *ref, git_repository *repo)
+{
+	int error;
+	git_reference *tmp_ref;
+	assert(unborn && ref && repo);
+
+	if (ref->type == GIT_REFERENCE_DIRECT) {
+		*unborn = 0;
+		return 0;
+	}
+
+	error = git_reference_lookup_resolved(&tmp_ref, repo, ref->name, -1);
+	git_reference_free(tmp_ref);
+
+	if (error != 0 && error != GIT_ENOTFOUND)
+		return error;
+	else if (error == GIT_ENOTFOUND && git__strcmp(ref->name, GIT_HEAD_FILE) == 0)
+		*unborn = true;
+	else
+		*unborn = false;
+
+	return 0;
+}