rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/src/odb_pack.c

@@ -1,12 +1,12 @@
 /*
- * Copyright (C) 2009-2011 the libgit2 contributors
+ * Copyright (C) 2009-2012 the libgit2 contributors
  *
  * 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 "common.h"
-#include "git2/zlib.h"
+#include <zlib.h>
 #include "git2/repository.h"
 #include "git2/oid.h"
 #include "fileops.h"
@@ -133,23 +133,23 @@ static int pack_window_contains(git_mwindow *win, off_t offset);
 
 static int packfile_sort__cb(const void *a_, const void *b_);
 
-static int packfile_load__cb(void *_data, char *path);
+static int packfile_load__cb(void *_data, git_buf *path);
 static int packfile_refresh_all(struct pack_backend *backend);
 
 static int pack_entry_find(struct git_pack_entry *e,
-		struct pack_backend *backend, const git_oid *oid);
+	struct pack_backend *backend, const git_oid *oid);
 
 /* Can find the offset of an object given
  * a prefix of an identifier.
- * Throws GIT_EAMBIGUOUSOIDPREFIX if short oid
- * is ambiguous.
+ * Sets GIT_EAMBIGUOUS if short oid is ambiguous.
  * This method assumes that len is between
  * GIT_OID_MINPREFIXLEN and GIT_OID_HEXSZ.
  */
-static int pack_entry_find_prefix(struct git_pack_entry *e,
-					struct pack_backend *backend,
-					const git_oid *short_oid,
-					unsigned int len);
+static int pack_entry_find_prefix(
+	struct git_pack_entry *e,
+	struct pack_backend *backend,
+	const git_oid *short_oid,
+	unsigned int len);
 
 
 
@@ -159,9 +159,9 @@ static int pack_entry_find_prefix(struct git_pack_entry *e,
  *
  ***********************************************************/
 
-GIT_INLINE(void) pack_window_free_all(struct pack_backend *GIT_UNUSED(backend), struct git_pack_file *p)
+GIT_INLINE(void) pack_window_free_all(struct pack_backend *backend, struct git_pack_file *p)
 {
-	GIT_UNUSED_ARG(backend);
+	GIT_UNUSED(backend);
 	git_mwindow_free_all(&p->mwf);
 }
 
@@ -207,35 +207,30 @@ static int packfile_sort__cb(const void *a_, const void *b_)
 
 
 
-static int packfile_load__cb(void *_data, char *path)
+static int packfile_load__cb(void *_data, git_buf *path)
 {
 	struct pack_backend *backend = (struct pack_backend *)_data;
 	struct git_pack_file *pack;
 	int error;
-	size_t i;
+	unsigned int i;
 
-	if (git__suffixcmp(path, ".idx") != 0)
-		return GIT_SUCCESS; /* not an index */
+	if (git__suffixcmp(path->ptr, ".idx") != 0)
+		return 0; /* not an index */
 
 	for (i = 0; i < backend->packs.length; ++i) {
 		struct git_pack_file *p = git_vector_get(&backend->packs, i);
-		if (memcmp(p->pack_name, path, strlen(path) - strlen(".idx")) == 0)
-			return GIT_SUCCESS;
+		if (memcmp(p->pack_name, git_buf_cstr(path), git_buf_len(path) - strlen(".idx")) == 0)
+			return 0;
 	}
 
-	error = git_packfile_check(&pack, path);
-	if (error == GIT_ENOTFOUND) {
+	error = git_packfile_check(&pack, path->ptr);
+	if (error == GIT_ENOTFOUND)
 		/* ignore missing .pack file as git does */
-		return GIT_SUCCESS;
-	} else if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to load packfile");
-
-	if (git_vector_insert(&backend->packs, pack) < GIT_SUCCESS) {
-		git__free(pack);
-		return GIT_ENOMEM;
-	}
+		return 0;
+	else if (error < 0)
+		return error;
 
-	return GIT_SUCCESS;
+	return git_vector_insert(&backend->packs, pack);
 }
 
 static int packfile_refresh_all(struct pack_backend *backend)
@@ -244,38 +239,41 @@ static int packfile_refresh_all(struct pack_backend *backend)
 	struct stat st;
 
 	if (backend->pack_folder == NULL)
-		return GIT_SUCCESS;
+		return 0;
 
 	if (p_stat(backend->pack_folder, &st) < 0 || !S_ISDIR(st.st_mode))
-		return git__throw(GIT_ENOTFOUND, "Failed to refresh packfiles. Backend not found");
+		return git_odb__error_notfound("failed to refresh packfiles", NULL);
 
 	if (st.st_mtime != backend->pack_folder_mtime) {
-		char path[GIT_PATH_MAX];
-		strcpy(path, backend->pack_folder);
+		git_buf path = GIT_BUF_INIT;
+		git_buf_sets(&path, backend->pack_folder);
 
 		/* reload all packs */
-		error = git_futils_direach(path, GIT_PATH_MAX, packfile_load__cb, (void *)backend);
-		if (error < GIT_SUCCESS)
-			return git__rethrow(error, "Failed to refresh packfiles");
+		error = git_path_direach(&path, packfile_load__cb, (void *)backend);
+
+		git_buf_free(&path);
+
+		if (error < 0)
+			return error;
 
 		git_vector_sort(&backend->packs);
 		backend->pack_folder_mtime = st.st_mtime;
 	}
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static int pack_entry_find(struct git_pack_entry *e, struct pack_backend *backend, const git_oid *oid)
 {
 	int error;
-	size_t i;
+	unsigned int i;
 
-	if ((error = packfile_refresh_all(backend)) < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to find pack entry");
+	if ((error = packfile_refresh_all(backend)) < 0)
+		return error;
 
 	if (backend->last_found &&
-		git_pack_entry_find(e, backend->last_found, oid, GIT_OID_HEXSZ) == GIT_SUCCESS)
-		return GIT_SUCCESS;
+		git_pack_entry_find(e, backend->last_found, oid, GIT_OID_HEXSZ) == 0)
+		return 0;
 
 	for (i = 0; i < backend->packs.length; ++i) {
 		struct git_pack_file *p;
@@ -284,13 +282,13 @@ static int pack_entry_find(struct git_pack_entry *e, struct pack_backend *backen
 		if (p == backend->last_found)
 			continue;
 
-		if (git_pack_entry_find(e, p, oid, GIT_OID_HEXSZ) == GIT_SUCCESS) {
+		if (git_pack_entry_find(e, p, oid, GIT_OID_HEXSZ) == 0) {
 			backend->last_found = p;
-			return GIT_SUCCESS;
+			return 0;
 		}
 	}
 
-	return git__throw(GIT_ENOTFOUND, "Failed to find pack entry");
+	return git_odb__error_notfound("failed to find pack entry", oid);
 }
 
 static int pack_entry_find_prefix(
@@ -300,19 +298,18 @@ static int pack_entry_find_prefix(
 	unsigned int len)
 {
 	int error;
-	size_t i;
+	unsigned int i;
 	unsigned found = 0;
 
-	if ((error = packfile_refresh_all(backend)) < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to find pack entry");
+	if ((error = packfile_refresh_all(backend)) < 0)
+		return error;
 
 	if (backend->last_found) {
 		error = git_pack_entry_find(e, backend->last_found, short_oid, len);
-		if (error == GIT_EAMBIGUOUSOIDPREFIX) {
-			return git__rethrow(error, "Failed to find pack entry. Ambiguous sha1 prefix");
-		} else if (error == GIT_SUCCESS) {
+		if (error == GIT_EAMBIGUOUS)
+			return error;
+		if (!error)
 			found = 1;
-		}
 	}
 
 	for (i = 0; i < backend->packs.length; ++i) {
@@ -323,24 +320,21 @@ static int pack_entry_find_prefix(
 			continue;
 
 		error = git_pack_entry_find(e, p, short_oid, len);
-		if (error == GIT_EAMBIGUOUSOIDPREFIX) {
-			return git__rethrow(error, "Failed to find pack entry. Ambiguous sha1 prefix");
-		} else if (error == GIT_SUCCESS) {
-			found++;
-			if (found > 1)
+		if (error == GIT_EAMBIGUOUS)
+			return error;
+		if (!error) {
+			if (++found > 1)
 				break;
 			backend->last_found = p;
 		}
 	}
 
-	if (!found) {
-		return git__rethrow(GIT_ENOTFOUND, "Failed to find pack entry");
-	} else if (found > 1) {
-		return git__rethrow(GIT_EAMBIGUOUSOIDPREFIX, "Failed to find pack entry. Ambiguous sha1 prefix");
-	} else {
-		return GIT_SUCCESS;
-	}
-
+	if (!found)
+		return git_odb__error_notfound("no matching pack entry for prefix", short_oid);
+	else if (found > 1)
+		return git_odb__error_ambiguous("found multiple pack entries");
+	else
+		return 0;
 }
 
 
@@ -372,17 +366,15 @@ static int pack_backend__read(void **buffer_p, size_t *len_p, git_otype *type_p,
 	git_rawobj raw;
 	int error;
 
-	if ((error = pack_entry_find(&e, (struct pack_backend *)backend, oid)) < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to read pack backend");
-
-	if ((error = git_packfile_unpack(&raw, e.p, &e.offset)) < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to read pack backend");
+	if ((error = pack_entry_find(&e, (struct pack_backend *)backend, oid)) < 0 ||
+		(error = git_packfile_unpack(&raw, e.p, &e.offset)) < 0)
+		return error;
 
 	*buffer_p = raw.data;
 	*len_p = raw.len;
 	*type_p = raw.type;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static int pack_backend__read_prefix(
@@ -394,46 +386,44 @@ static int pack_backend__read_prefix(
 	const git_oid *short_oid,
 	unsigned int len)
 {
+	int error = 0;
+
 	if (len < GIT_OID_MINPREFIXLEN)
-		return git__throw(GIT_EAMBIGUOUSOIDPREFIX, "Failed to read pack backend. Prefix length is lower than %d.", GIT_OID_MINPREFIXLEN);
+		error = git_odb__error_ambiguous("prefix length too short");
 
-	if (len >= GIT_OID_HEXSZ) {
+	else if (len >= GIT_OID_HEXSZ) {
 		/* We can fall back to regular read method */
-		int error = pack_backend__read(buffer_p, len_p, type_p, backend, short_oid);
-		if (error == GIT_SUCCESS)
+		error = pack_backend__read(buffer_p, len_p, type_p, backend, short_oid);
+		if (!error)
 			git_oid_cpy(out_oid, short_oid);
-
-		return error;
 	} else {
 		struct git_pack_entry e;
 		git_rawobj raw;
-		int error;
 
-		if ((error = pack_entry_find_prefix(&e, (struct pack_backend *)backend, short_oid, len)) < GIT_SUCCESS)
-			return git__rethrow(error, "Failed to read pack backend");
-
-		if ((error = git_packfile_unpack(&raw, e.p, &e.offset)) < GIT_SUCCESS)
-			return git__rethrow(error, "Failed to read pack backend");
-
-		*buffer_p = raw.data;
-		*len_p = raw.len;
-		*type_p = raw.type;
-		git_oid_cpy(out_oid, &e.sha1);
+		if ((error = pack_entry_find_prefix(
+				&e, (struct pack_backend *)backend, short_oid, len)) == 0 &&
+			(error = git_packfile_unpack(&raw, e.p, &e.offset)) == 0)
+		{
+			*buffer_p = raw.data;
+			*len_p = raw.len;
+			*type_p = raw.type;
+			git_oid_cpy(out_oid, &e.sha1);
+		}
 	}
 
-	return GIT_SUCCESS;
+	return error;
 }
 
 static int pack_backend__exists(git_odb_backend *backend, const git_oid *oid)
 {
 	struct git_pack_entry e;
-	return pack_entry_find(&e, (struct pack_backend *)backend, oid) == GIT_SUCCESS;
+	return pack_entry_find(&e, (struct pack_backend *)backend, oid) == 0;
 }
 
 static void pack_backend__free(git_odb_backend *_backend)
 {
 	struct pack_backend *backend;
-	size_t i;
+	unsigned int i;
 
 	assert(_backend);
 
@@ -451,27 +441,22 @@ static void pack_backend__free(git_odb_backend *_backend)
 
 int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
 {
-	struct pack_backend *backend;
-	char path[GIT_PATH_MAX];
+	struct pack_backend *backend = NULL;
+	git_buf path = GIT_BUF_INIT;
 
 	backend = git__calloc(1, sizeof(struct pack_backend));
-	if (backend == NULL)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(backend);
 
-	if (git_vector_init(&backend->packs, 8, packfile_sort__cb) < GIT_SUCCESS) {
+	if (git_vector_init(&backend->packs, 8, packfile_sort__cb) < 0 ||
+		git_buf_joinpath(&path, objects_dir, "pack") < 0)
+	{
 		git__free(backend);
-		return GIT_ENOMEM;
+		return -1;
 	}
 
-	git_path_join(path, objects_dir, "pack");
-	if (git_futils_isdir(path) == GIT_SUCCESS) {
-		backend->pack_folder = git__strdup(path);
+	if (git_path_isdir(git_buf_cstr(&path)) == true) {
+		backend->pack_folder = git_buf_detach(&path);
 		backend->pack_folder_mtime = 0;
-
-		if (backend->pack_folder == NULL) {
-			git__free(backend);
-			return GIT_ENOMEM;
-		}
 	}
 
 	backend->parent.read = &pack_backend__read;
@@ -481,5 +466,8 @@ int git_odb_backend_pack(git_odb_backend **backend_out, const char *objects_dir)
 	backend->parent.free = &pack_backend__free;
 
 	*backend_out = (git_odb_backend *)backend;
-	return GIT_SUCCESS;
+
+	git_buf_free(&path);
+
+	return 0;
 }

data/ext/rugged/vendor/libgit2-dist/src/oid.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2011 the libgit2 contributors
+ * Copyright (C) 2009-2012 the libgit2 contributors
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -11,51 +11,39 @@
 #include <string.h>
 #include <limits.h>
 
-static signed char from_hex[] = {
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 00 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 10 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 20 */
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, /* 30 */
--1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 40 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 50 */
--1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 60 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 70 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 80 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* 90 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* a0 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* b0 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* c0 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* d0 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* e0 */
--1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, /* f0 */
-};
 static char to_hex[] = "0123456789abcdef";
 
+static int oid_error_invalid(const char *msg)
+{
+	giterr_set(GITERR_INVALID, "Unable to parse OID - %s", msg);
+	return -1;
+}
+
 int git_oid_fromstrn(git_oid *out, const char *str, size_t length)
 {
 	size_t p;
 	int v;
 
 	if (length < 4)
-		return git__throw(GIT_ENOTOID, "Failed to generate sha1. Given string is too short");
+		return oid_error_invalid("input too short");
 
 	if (length > GIT_OID_HEXSZ)
 		length = GIT_OID_HEXSZ;
 
 	for (p = 0; p < length - 1; p += 2) {
-		v = (from_hex[(unsigned char)str[p + 0]] << 4)
-				| from_hex[(unsigned char)str[p + 1]];
+		v = (git__fromhex(str[p + 0]) << 4)
+				| git__fromhex(str[p + 1]);
 
 		if (v < 0)
-			return git__throw(GIT_ENOTOID, "Failed to generate sha1. Given string is not a valid sha1 hash");
+			return oid_error_invalid("contains invalid characters");
 
 		out->id[p / 2] = (unsigned char)v;
 	}
 
 	if (length % 2) {
-		v = (from_hex[(unsigned char)str[p + 0]] << 4);
+		v = (git__fromhex(str[p + 0]) << 4);
 		if (v < 0)
-			return git__throw(GIT_ENOTOID, "Failed to generate sha1. Given string is not a valid sha1 hash");
+			return oid_error_invalid("contains invalid characters");
 
 		out->id[p / 2] = (unsigned char)v;
 		p += 2;
@@ -63,7 +51,7 @@ int git_oid_fromstrn(git_oid *out, const char *str, size_t length)
 
 	memset(out->id + p / 2, 0, (GIT_OID_HEXSZ - p) / 2);
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 int git_oid_fromstr(git_oid *out, const char *str)
@@ -106,7 +94,7 @@ char *git_oid_allocfmt(const git_oid *oid)
 	return str;
 }
 
-char *git_oid_to_string(char *out, size_t n, const git_oid *oid)
+char *git_oid_tostr(char *out, size_t n, const git_oid *oid)
 {
 	char str[GIT_OID_HEXSZ];
 
@@ -127,8 +115,9 @@ char *git_oid_to_string(char *out, size_t n, const git_oid *oid)
 	return out;
 }
 
-int git_oid__parse(git_oid *oid, const char **buffer_out,
-		const char *buffer_end, const char *header)
+int git_oid__parse(
+	git_oid *oid, const char **buffer_out,
+	const char *buffer_end, const char *header)
 {
 	const size_t sha_len = GIT_OID_HEXSZ;
 	const size_t header_len = strlen(header);
@@ -136,20 +125,20 @@ int git_oid__parse(git_oid *oid, const char **buffer_out,
 	const char *buffer = *buffer_out;
 
 	if (buffer + (header_len + sha_len + 1) > buffer_end)
-		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse OID. Buffer too small");
+		return -1;
 
 	if (memcmp(buffer, header, header_len) != 0)
-		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse OID. Buffer and header do not match");
+		return -1;
 
 	if (buffer[header_len + sha_len] != '\n')
-		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse OID. Buffer not terminated correctly");
+		return -1;
 
-	if (git_oid_fromstr(oid, buffer + header_len) < GIT_SUCCESS)
-		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse OID. Failed to generate sha1");
+	if (git_oid_fromstr(oid, buffer + header_len) < 0)
+		return -1;
 
 	*buffer_out = buffer + (header_len + sha_len + 1);
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 void git_oid__writebuf(git_buf *buf, const char *header, const git_oid *oid)
@@ -200,12 +189,21 @@ int git_oid_ncmp(const git_oid *oid_a, const git_oid *oid_b, unsigned int len)
 int git_oid_streq(const git_oid *a, const char *str)
 {
 	git_oid id;
-	int error;
 
-	if ((error = git_oid_fromstr(&id, str)) < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to convert '%s' to oid.", str);
+	if (git_oid_fromstr(&id, str) < 0)
+		return -1;
+
+	return git_oid_cmp(a, &id) == 0 ? 0 : -1;
+}
 
-	return git_oid_cmp(a, &id) == 0 ? GIT_SUCCESS : GIT_ERROR;
+int git_oid_iszero(const git_oid *oid_a)
+{
+	const unsigned char *a = oid_a->id;
+	unsigned int i;
+	for (i = 0; i < GIT_OID_RAWSZ; ++i, ++a)
+		if (*a != 0)
+			return 0;
+	return 1;
 }
 
 typedef short node_index;
@@ -224,15 +222,14 @@ struct git_oid_shorten {
 static int resize_trie(git_oid_shorten *self, size_t new_size)
 {
 	self->nodes = git__realloc(self->nodes, new_size * sizeof(trie_node));
-	if (self->nodes == NULL)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(self->nodes);
 
 	if (new_size > self->size) {
 		memset(&self->nodes[self->size], 0x0, (new_size - self->size) * sizeof(trie_node));
 	}
 
 	self->size = new_size;
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static trie_node *push_leaf(git_oid_shorten *os, node_index idx, int push_at, const char *oid)
@@ -241,7 +238,7 @@ static trie_node *push_leaf(git_oid_shorten *os, node_index idx, int push_at, co
 	node_index idx_leaf;
 
 	if (os->node_count >= os->size) {
-		if (resize_trie(os, os->size * 2) < GIT_SUCCESS)
+		if (resize_trie(os, os->size * 2) < 0)
 			return NULL;
 	}
 
@@ -263,19 +260,19 @@ git_oid_shorten *git_oid_shorten_new(size_t min_length)
 {
 	git_oid_shorten *os;
 
-	os = git__malloc(sizeof(git_oid_shorten));
+	assert((size_t)((int)min_length) == min_length);
+
+	os = git__calloc(1, sizeof(git_oid_shorten));
 	if (os == NULL)
 		return NULL;
 
-	memset(os, 0x0, sizeof(git_oid_shorten));
-
-	if (resize_trie(os, 16) < GIT_SUCCESS) {
+	if (resize_trie(os, 16) < 0) {
 		git__free(os);
 		return NULL;
 	}
 
 	os->node_count = 1;
-	os->min_length = min_length;
+	os->min_length = (int)min_length;
 
 	return os;
 }
@@ -333,24 +330,27 @@ void git_oid_shorten_free(git_oid_shorten *os)
  */
 int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 {
-	int i, is_leaf;
+	int i;
+	bool is_leaf;
 	node_index idx;
 
 	if (os->full)
-		return GIT_ENOMEM;
+		return -1;
 
 	if (text_oid == NULL)
 		return os->min_length;
 
 	idx = 0;
-	is_leaf = 0;
+	is_leaf = false;
 
 	for (i = 0; i < GIT_OID_HEXSZ; ++i) {
-		int c = from_hex[(int)text_oid[i]];
+		int c = git__fromhex(text_oid[i]);
 		trie_node *node;
 
-		if (c == -1)
-			return git__throw(GIT_ENOTOID, "Failed to shorten OID. Invalid hex value");
+		if (c == -1) {
+			giterr_set(GITERR_INVALID, "Unable to shorten OID - invalid hex value");
+			return -1;
+		}
 
 		node = &os->nodes[idx];
 
@@ -360,23 +360,22 @@ int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid)
 			tail = node->tail;
 			node->tail = NULL;
 
-			node = push_leaf(os, idx, from_hex[(int)tail[0]], &tail[1]);
-			if (node == NULL)
-				return GIT_ENOMEM;
+			node = push_leaf(os, idx, git__fromhex(tail[0]), &tail[1]);
+			GITERR_CHECK_ALLOC(node);
 		}
 
 		if (node->children[c] == 0) {
 			if (push_leaf(os, idx, c, &text_oid[i + 1]) == NULL)
-				return GIT_ENOMEM;
+				return -1;
 			break;
 		}
 
 		idx = node->children[c];
-		is_leaf = 0;
+		is_leaf = false;
 
 		if (idx < 0) {
 			node->children[c] = idx = -idx;
-			is_leaf = 1;
+			is_leaf = true;
 		}
 	}
 

data/ext/rugged/vendor/libgit2-dist/src/oidmap.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2012 the libgit2 contributors
+ *
+ * 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_oidmap_h__
+#define INCLUDE_oidmap_h__
+
+#include "common.h"
+#include "git2/oid.h"
+
+#define kmalloc git__malloc
+#define kcalloc git__calloc
+#define krealloc git__realloc
+#define kfree git__free
+#include "khash.h"
+
+__KHASH_TYPE(oid, const git_oid *, void *);
+typedef khash_t(oid) git_oidmap;
+
+GIT_INLINE(khint_t) hash_git_oid(const git_oid *oid)
+{
+	int i;
+	khint_t h = 0;
+	for (i = 0; i < 20; ++i)
+		h = (h << 5) - h + oid->id[i];
+	return h;
+}
+
+GIT_INLINE(int) hash_git_oid_equal(const git_oid *a, const git_oid *b)
+{
+	return (memcmp(a->id, b->id, sizeof(a->id)) == 0);
+}
+
+#define GIT__USE_OIDMAP \
+	__KHASH_IMPL(oid, static inline, const git_oid *, void *, 1, hash_git_oid, hash_git_oid_equal)
+
+#define git_oidmap_alloc() kh_init(oid)
+#define git_oidmap_free(h) kh_destroy(oid,h), h = NULL
+
+#endif