rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/src/transports/local.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.
@@ -13,6 +13,8 @@
 #include "refs.h"
 #include "transport.h"
 #include "posix.h"
+#include "path.h"
+#include "buffer.h"
 
 typedef struct {
 	git_transport parent;
@@ -24,109 +26,94 @@ static int add_ref(transport_local *t, const char *name)
 {
 	const char peeled[] = "^{}";
 	git_remote_head *head;
-	git_reference *ref, *resolved_ref;
-	git_object *obj = NULL;
-	int error = GIT_SUCCESS, peel_len, ret;
+	git_object *obj = NULL, *target = NULL;
+	git_buf buf = GIT_BUF_INIT;
 
 	head = git__malloc(sizeof(git_remote_head));
-	if (head == NULL)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(head);
 
 	head->name = git__strdup(name);
-	if (head->name == NULL) {
-		error = GIT_ENOMEM;
-		goto out;
-	}
-
-	error = git_reference_lookup(&ref, t->repo, name);
-	if (error < GIT_SUCCESS)
-		goto out;
-
-	error = git_reference_resolve(&resolved_ref, ref);
-	if (error < GIT_SUCCESS)
-		goto out;
-
-	git_oid_cpy(&head->oid, git_reference_oid(ref));
-
-	error = git_vector_insert(&t->refs, head);
-	if (error < GIT_SUCCESS)
-		goto out;
+	GITERR_CHECK_ALLOC(head->name);
 
-	head = NULL;
+	if (git_reference_name_to_oid(&head->oid, t->repo, name) < 0 ||
+		git_vector_insert(&t->refs, head) < 0)
+	{
+		git__free(head->name);
+		git__free(head);
+		return -1;
+	}
 
 	/* If it's not a tag, we don't need to try to peel it */
 	if (git__prefixcmp(name, GIT_REFS_TAGS_DIR))
-		goto out;
+		return 0;
 
-	error = git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY);
-	if (error < GIT_SUCCESS) {
-		git__rethrow(error, "Failed to lookup object");
-	}
+	if (git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY) < 0)
+		return -1;
+
+	head = NULL;
 
 	/* If it's not an annotated tag, just get out */
-	if (git_object_type(obj) != GIT_OBJ_TAG)
-		goto out;
+	if (git_object_type(obj) != GIT_OBJ_TAG) {
+		git_object_free(obj);
+		return 0;
+	}
 
 	/* And if it's a tag, peel it, and add it to the list */
 	head = git__malloc(sizeof(git_remote_head));
-	peel_len = strlen(name) + strlen(peeled);
-	head->name = git__malloc(peel_len + 1);
-	ret = p_snprintf(head->name, peel_len + 1, "%s%s", name, peeled);
+	GITERR_CHECK_ALLOC(head);
+	if (git_buf_join(&buf, 0, name, peeled) < 0)
+		return -1;
 
-	assert(ret < peel_len + 1);
+	head->name = git_buf_detach(&buf);
 
-	git_oid_cpy(&head->oid, git_tag_target_oid((git_tag *) obj));
+	if (git_tag_peel(&target, (git_tag *) obj) < 0)
+		goto on_error;
 
-	error = git_vector_insert(&t->refs, head);
-	if (error < GIT_SUCCESS)
-		goto out;
+	git_oid_cpy(&head->oid, git_object_id(target));
+	git_object_free(obj);
+	git_object_free(target);
 
- out:
-	git_reference_free(ref);
-	git_reference_free(resolved_ref);
+	if (git_vector_insert(&t->refs, head) < 0)
+		return -1;
 
-	git_object_free(obj);
-	if (head && error < GIT_SUCCESS) {
-		git__free(head->name);
-		git__free(head);
-	}
+	return 0;
 
-	return error;
+on_error:
+	git_object_free(obj);
+	git_object_free(target);
+	return -1;
 }
 
 static int store_refs(transport_local *t)
 {
-	int error;
 	unsigned int i;
 	git_strarray ref_names = {0};
 
 	assert(t);
 
-	error = git_vector_init(&t->refs, ref_names.count, NULL);
-	if (error < GIT_SUCCESS)
-		return error;
-
-	error = git_reference_listall(&ref_names, t->repo, GIT_REF_LISTALL);
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to list remote heads");
+	if (git_reference_list(&ref_names, t->repo, GIT_REF_LISTALL) < 0 ||
+		git_vector_init(&t->refs, (unsigned int)ref_names.count, NULL) < 0)
+		goto on_error;
 
 	/* Sort the references first */
 	git__tsort((void **)ref_names.strings, ref_names.count, &git__strcmp_cb);
 
 	/* Add HEAD */
-	error = add_ref(t, GIT_HEAD_FILE);
-	if (error < GIT_SUCCESS)
-		goto cleanup;
+	if (add_ref(t, GIT_HEAD_FILE) < 0)
+		goto on_error;
 
 	for (i = 0; i < ref_names.count; ++i) {
-		error = add_ref(t, ref_names.strings[i]);
-		if (error < GIT_SUCCESS)
-			goto cleanup;
+		if (add_ref(t, ref_names.strings[i]) < 0)
+			goto on_error;
 	}
 
-cleanup:
 	git_strarray_free(&ref_names);
-	return error;
+	return 0;
+
+on_error:
+	git_vector_free(&t->refs);
+	git_strarray_free(&ref_names);
+	return -1;
 }
 
 static int local_ls(git_transport *transport, git_headlist_cb list_cb, void *payload)
@@ -140,55 +127,74 @@ static int local_ls(git_transport *transport, git_headlist_cb list_cb, void *pay
 
 	git_vector_foreach(refs, i, h) {
 		if (list_cb(h, payload) < 0)
-			return git__throw(GIT_ERROR,
-				"The user callback returned an error code");
+			return -1;
 	}
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
-
 /*
  * Try to open the url as a git directory. The direction doesn't
  * matter in this case because we're calulating the heads ourselves.
  */
-static int local_connect(git_transport *transport, int GIT_UNUSED(direction))
+static int local_connect(git_transport *transport, int direction)
 {
 	git_repository *repo;
 	int error;
 	transport_local *t = (transport_local *) transport;
 	const char *path;
-	const char file_prefix[] = "file://";
-	GIT_UNUSED_ARG(direction);
+	git_buf buf = GIT_BUF_INIT;
+
+	GIT_UNUSED(direction);
 
 	/* The repo layer doesn't want the prefix */
-	if (!git__prefixcmp(transport->url, file_prefix))
-		path = transport->url + strlen(file_prefix);
-	else
+	if (!git__prefixcmp(transport->url, "file://")) {
+		if (git_path_fromurl(&buf, transport->url) < 0) {
+			git_buf_free(&buf);
+			return -1;
+		}
+		path = git_buf_cstr(&buf);
+
+	} else { /* We assume transport->url is already a path */
 		path = transport->url;
+	}
 
 	error = git_repository_open(&repo, path);
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to open remote");
 
-	error = store_refs(t);
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to retrieve references");
+	git_buf_free(&buf);
+
+	if (error < 0)
+		return -1;
 
 	t->repo = repo;
+
+	if (store_refs(t) < 0)
+		return -1;
+
 	t->parent.connected = 1;
 
-	return GIT_SUCCESS;
+	return 0;
+}
+
+static int local_negotiate_fetch(git_transport *transport, git_repository *repo, const git_vector *wants)
+{
+	GIT_UNUSED(transport);
+	GIT_UNUSED(repo);
+	GIT_UNUSED(wants);
+
+	giterr_set(GITERR_NET, "Fetch via local transport isn't implemented. Sorry");
+	return -1;
 }
 
-static int local_close(git_transport *GIT_UNUSED(transport))
+static int local_close(git_transport *transport)
 {
 	transport_local *t = (transport_local *)transport;
 
+	t->parent.connected = 0;
 	git_repository_free(t->repo);
 	t->repo = NULL;
 
-	return GIT_SUCCESS;
+	return 0;
 }
 
 static void local_free(git_transport *transport)
@@ -219,17 +225,17 @@ int git_transport_local(git_transport **out)
 	transport_local *t;
 
 	t = git__malloc(sizeof(transport_local));
-	if (t == NULL)
-		return GIT_ENOMEM;
+	GITERR_CHECK_ALLOC(t);
 
 	memset(t, 0x0, sizeof(transport_local));
 
 	t->parent.connect = local_connect;
 	t->parent.ls = local_ls;
+	t->parent.negotiate_fetch = local_negotiate_fetch;
 	t->parent.close = local_close;
 	t->parent.free = local_free;
 
 	*out = (git_transport *) t;
 
-	return GIT_SUCCESS;
+	return 0;
 }

data/ext/rugged/vendor/libgit2-dist/src/tree-cache.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.
@@ -69,7 +69,7 @@ const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char
 			return NULL;
 		}
 
-		if (end == NULL || end + 1 == '\0')
+		if (end == NULL || *end + 1 == '\0')
 			return tree;
 
 		ptr = end + 1;
@@ -82,24 +82,19 @@ static int read_tree_internal(git_tree_cache **out,
 	git_tree_cache *tree = NULL;
 	const char *name_start, *buffer;
 	int count;
-	int error = GIT_SUCCESS;
 	size_t name_len;
 
 	buffer = name_start = *buffer_in;
 
-	if ((buffer = memchr(buffer, '\0', buffer_end - buffer)) == NULL) {
-		error = GIT_EOBJCORRUPTED;
-		goto cleanup;
-	}
+	if ((buffer = memchr(buffer, '\0', buffer_end - buffer)) == NULL)
+		goto corrupted;
 
-	if (++buffer >= buffer_end) {
-		error = GIT_EOBJCORRUPTED;
-		goto cleanup;
-	}
+	if (++buffer >= buffer_end)
+		goto corrupted;
 
 	name_len = strlen(name_start);
-	if ((tree = git__malloc(sizeof(git_tree_cache) + name_len + 1)) == NULL)
-		return GIT_ENOMEM;
+	tree = git__malloc(sizeof(git_tree_cache) + name_len + 1);
+	GITERR_CHECK_ALLOC(tree);
 
 	memset(tree, 0x0, sizeof(git_tree_cache));
 	tree->parent = parent;
@@ -109,39 +104,28 @@ static int read_tree_internal(git_tree_cache **out,
 	tree->name[name_len] = '\0';
 
 	/* Blank-terminated ASCII decimal number of entries in this tree */
-	if (git__strtol32(&count, buffer, &buffer, 10) < GIT_SUCCESS || count < -1) {
-		error = GIT_EOBJCORRUPTED;
-		goto cleanup;
-	}
+	if (git__strtol32(&count, buffer, &buffer, 10) < 0 || count < -1)
+		goto corrupted;
 
 	tree->entries = count;
 
-	if (*buffer != ' ' || ++buffer >= buffer_end) {
-		error = GIT_EOBJCORRUPTED;
-		goto cleanup;
-	}
+	if (*buffer != ' ' || ++buffer >= buffer_end)
+		goto corrupted;
 
 	 /* Number of children of the tree, newline-terminated */
-	if (git__strtol32(&count, buffer, &buffer, 10) < GIT_SUCCESS ||
-		count < 0) {
-		error = GIT_EOBJCORRUPTED;
-		goto cleanup;
-	}
+	if (git__strtol32(&count, buffer, &buffer, 10) < 0 || count < 0)
+		goto corrupted;
 
 	tree->children_count = count;
 
-	if (*buffer != '\n' || ++buffer >= buffer_end) {
-		error = GIT_EOBJCORRUPTED;
-		goto cleanup;
-	}
+	if (*buffer != '\n' || ++buffer > buffer_end)
+		goto corrupted;
 
 	/* The SHA1 is only there if it's not invalidated */
 	if (tree->entries >= 0) {
 		/* 160-bit SHA-1 for this tree and it's children */
-		if (buffer + GIT_OID_RAWSZ > buffer_end) {
-			error = GIT_EOBJCORRUPTED;
-			goto cleanup;
-		}
+		if (buffer + GIT_OID_RAWSZ > buffer_end)
+			goto corrupted;
 
 		git_oid_fromraw(&tree->oid, (const unsigned char *)buffer);
 		buffer += GIT_OID_RAWSZ;
@@ -150,40 +134,39 @@ static int read_tree_internal(git_tree_cache **out,
 	/* Parse children: */
 	if (tree->children_count > 0) {
 		unsigned int i;
-		int err;
 
 		tree->children = git__malloc(tree->children_count * sizeof(git_tree_cache *));
-		if (tree->children == NULL)
-			goto cleanup;
+		GITERR_CHECK_ALLOC(tree->children);
 
 		for (i = 0; i < tree->children_count; ++i) {
-			err = read_tree_internal(&tree->children[i], &buffer, buffer_end, tree);
-
-			if (err < GIT_SUCCESS)
-				goto cleanup;
+			if (read_tree_internal(&tree->children[i], &buffer, buffer_end, tree) < 0)
+				return -1;
 		}
 	}
 
 	*buffer_in = buffer;
 	*out = tree;
-	return GIT_SUCCESS;
+	return 0;
 
- cleanup:
+ corrupted:
 	git_tree_cache_free(tree);
-	return error;
+	giterr_set(GITERR_INDEX, "Corruped TREE extension in index");
+	return -1;
 }
 
 int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size)
 {
 	const char *buffer_end = buffer + buffer_size;
-	int error;
 
-	error = read_tree_internal(tree, &buffer, buffer_end, NULL);
+	if (read_tree_internal(tree, &buffer, buffer_end, NULL) < 0)
+		return -1;
 
-	if (buffer < buffer_end)
-		return GIT_EOBJCORRUPTED;
+	if (buffer < buffer_end) {
+		giterr_set(GITERR_INDEX, "Corruped TREE extension in index (unexpected trailing data)");
+		return -1;
+	}
 
-	return error;
+	return 0;
 }
 
 void git_tree_cache_free(git_tree_cache *tree)

data/ext/rugged/vendor/libgit2-dist/src/tree-cache.h

@@ -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.