rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/src/transports/local.c

@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2009-2011 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/types.h"
+#include "git2/net.h"
+#include "git2/repository.h"
+#include "git2/object.h"
+#include "git2/tag.h"
+#include "refs.h"
+#include "transport.h"
+#include "posix.h"
+
+typedef struct {
+	git_transport parent;
+	git_repository *repo;
+	git_vector refs;
+} transport_local;
+
+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;
+
+	head = git__malloc(sizeof(git_remote_head));
+	if (head == NULL)
+		return GIT_ENOMEM;
+
+	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;
+
+	head = NULL;
+
+	/* 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;
+
+	error = git_object_lookup(&obj, t->repo, &head->oid, GIT_OBJ_ANY);
+	if (error < GIT_SUCCESS) {
+		git__rethrow(error, "Failed to lookup object");
+	}
+
+	/* If it's not an annotated tag, just get out */
+	if (git_object_type(obj) != GIT_OBJ_TAG)
+		goto out;
+
+	/* 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);
+
+	assert(ret < peel_len + 1);
+
+	git_oid_cpy(&head->oid, git_tag_target_oid((git_tag *) obj));
+
+	error = git_vector_insert(&t->refs, head);
+	if (error < GIT_SUCCESS)
+		goto out;
+
+ out:
+	git_reference_free(ref);
+	git_reference_free(resolved_ref);
+
+	git_object_free(obj);
+	if (head && error < GIT_SUCCESS) {
+		git__free(head->name);
+		git__free(head);
+	}
+
+	return error;
+}
+
+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");
+
+	/* 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;
+
+	for (i = 0; i < ref_names.count; ++i) {
+		error = add_ref(t, ref_names.strings[i]);
+		if (error < GIT_SUCCESS)
+			goto cleanup;
+	}
+
+cleanup:
+	git_strarray_free(&ref_names);
+	return error;
+}
+
+static int local_ls(git_transport *transport, git_headlist_cb list_cb, void *payload)
+{
+	transport_local  *t = (transport_local *) transport;
+	git_vector *refs = &t->refs;
+	unsigned int i;
+	git_remote_head *h;
+
+	assert(transport && transport->connected);
+
+	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 GIT_SUCCESS;
+}
+
+
+/*
+ * 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))
+{
+	git_repository *repo;
+	int error;
+	transport_local *t = (transport_local *) transport;
+	const char *path;
+	const char file_prefix[] = "file://";
+	GIT_UNUSED_ARG(direction);
+
+	/* The repo layer doesn't want the prefix */
+	if (!git__prefixcmp(transport->url, file_prefix))
+		path = transport->url + strlen(file_prefix);
+	else
+		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");
+
+	t->repo = repo;
+	t->parent.connected = 1;
+
+	return GIT_SUCCESS;
+}
+
+static int local_close(git_transport *GIT_UNUSED(transport))
+{
+	transport_local *t = (transport_local *)transport;
+
+	git_repository_free(t->repo);
+	t->repo = NULL;
+
+	return GIT_SUCCESS;
+}
+
+static void local_free(git_transport *transport)
+{
+	unsigned int i;
+	transport_local *t = (transport_local *) transport;
+	git_vector *vec = &t->refs;
+	git_remote_head *h;
+
+	assert(transport);
+
+	git_vector_foreach (vec, i, h) {
+		git__free(h->name);
+		git__free(h);
+	}
+	git_vector_free(vec);
+
+	git__free(t->parent.url);
+	git__free(t);
+}
+
+/**************
+ * Public API *
+ **************/
+
+int git_transport_local(git_transport **out)
+{
+	transport_local *t;
+
+	t = git__malloc(sizeof(transport_local));
+	if (t == NULL)
+		return GIT_ENOMEM;
+
+	memset(t, 0x0, sizeof(transport_local));
+
+	t->parent.connect = local_connect;
+	t->parent.ls = local_ls;
+	t->parent.close = local_close;
+	t->parent.free = local_free;
+
+	*out = (git_transport *) t;
+
+	return GIT_SUCCESS;
+}

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

@@ -0,0 +1,201 @@
+/*
+ * Copyright (C) 2009-2011 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 "tree-cache.h"
+
+static git_tree_cache *find_child(const git_tree_cache *tree, const char *path)
+{
+	size_t i, dirlen;
+	const char *end;
+
+	end = strchr(path, '/');
+	if (end == NULL) {
+		end = strrchr(path, '\0');
+	}
+
+	dirlen = end - path;
+
+	for (i = 0; i < tree->children_count; ++i) {
+		const char *childname = tree->children[i]->name;
+
+		if (strlen(childname) == dirlen && !memcmp(path, childname, dirlen))
+			return tree->children[i];
+	}
+
+	return NULL;
+}
+
+void git_tree_cache_invalidate_path(git_tree_cache *tree, const char *path)
+{
+	const char *ptr = path, *end;
+
+	if (tree == NULL)
+		return;
+
+	tree->entries = -1;
+
+	while (ptr != NULL) {
+		end = strchr(ptr, '/');
+
+		if (end == NULL) /* End of path */
+			break;
+
+		tree = find_child(tree, ptr);
+		if (tree == NULL) /* We don't have that tree */
+			return;
+
+		tree->entries = -1;
+		ptr = end + 1;
+	}
+}
+
+const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char *path)
+{
+	const char *ptr = path, *end;
+
+	if (tree == NULL) {
+		return NULL;
+	}
+
+	while (1) {
+		end = strchr(ptr, '/');
+
+		tree = find_child(tree, ptr);
+		if (tree == NULL) { /* Can't find it */
+			return NULL;
+		}
+
+		if (end == NULL || end + 1 == '\0')
+			return tree;
+
+		ptr = end + 1;
+	}
+}
+
+static int read_tree_internal(git_tree_cache **out,
+		const char **buffer_in, const char *buffer_end, git_tree_cache *parent)
+{
+	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 >= buffer_end) {
+		error = GIT_EOBJCORRUPTED;
+		goto cleanup;
+	}
+
+	name_len = strlen(name_start);
+	if ((tree = git__malloc(sizeof(git_tree_cache) + name_len + 1)) == NULL)
+		return GIT_ENOMEM;
+
+	memset(tree, 0x0, sizeof(git_tree_cache));
+	tree->parent = parent;
+
+	/* NUL-terminated tree name */
+	memcpy(tree->name, name_start, name_len);
+	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;
+	}
+
+	tree->entries = count;
+
+	if (*buffer != ' ' || ++buffer >= buffer_end) {
+		error = GIT_EOBJCORRUPTED;
+		goto cleanup;
+	}
+
+	 /* Number of children of the tree, newline-terminated */
+	if (git__strtol32(&count, buffer, &buffer, 10) < GIT_SUCCESS ||
+		count < 0) {
+		error = GIT_EOBJCORRUPTED;
+		goto cleanup;
+	}
+
+	tree->children_count = count;
+
+	if (*buffer != '\n' || ++buffer >= buffer_end) {
+		error = GIT_EOBJCORRUPTED;
+		goto cleanup;
+	}
+
+	/* 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;
+		}
+
+		git_oid_fromraw(&tree->oid, (const unsigned char *)buffer);
+		buffer += GIT_OID_RAWSZ;
+	}
+
+	/* 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;
+
+		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;
+		}
+	}
+
+	*buffer_in = buffer;
+	*out = tree;
+	return GIT_SUCCESS;
+
+ cleanup:
+	git_tree_cache_free(tree);
+	return error;
+}
+
+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 (buffer < buffer_end)
+		return GIT_EOBJCORRUPTED;
+
+	return error;
+}
+
+void git_tree_cache_free(git_tree_cache *tree)
+{
+	unsigned int i;
+
+	if (tree == NULL)
+		return;
+
+	for (i = 0; i < tree->children_count; ++i)
+		git_tree_cache_free(tree->children[i]);
+
+	git__free(tree->children);
+	git__free(tree);
+}

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2009-2011 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_tree_cache_h__
+#define INCLUDE_tree_cache_h__
+
+#include "common.h"
+#include "git2/oid.h"
+
+struct git_tree_cache {
+	struct git_tree_cache *parent;
+	struct git_tree_cache **children;
+	size_t children_count;
+
+	ssize_t entries;
+	git_oid oid;
+	char name[GIT_FLEX_ARRAY];
+};
+
+typedef struct git_tree_cache git_tree_cache;
+
+int git_tree_cache_read(git_tree_cache **tree, const char *buffer, size_t buffer_size);
+void git_tree_cache_invalidate_path(git_tree_cache *tree, const char *path);
+const git_tree_cache *git_tree_cache_get(const git_tree_cache *tree, const char *path);
+void git_tree_cache_free(git_tree_cache *tree);
+
+#endif