rugged 0.16.0 → 0.17.0b1

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

@@ -1,104 +1,119 @@
 /*
- * 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 "global.h"
+#include "posix.h"
+#include "buffer.h"
 #include <stdarg.h>
 
-static struct {
-	int num;
-	const char *str;
-} error_codes[] = {
-	{GIT_ERROR, "Unspecified error"},
-	{GIT_ENOTOID, "Input was not a properly formatted Git object id."},
-	{GIT_ENOTFOUND, "Object does not exist in the scope searched."},
-	{GIT_ENOMEM, "Not enough space available."},
-	{GIT_EOSERR, "Consult the OS error information."},
-	{GIT_EOBJTYPE, "The specified object is of invalid type"},
-	{GIT_EOBJCORRUPTED, "The specified object has its data corrupted"},
-	{GIT_ENOTAREPO, "The specified repository is invalid"},
-	{GIT_EINVALIDTYPE, "The object or config variable type is invalid or doesn't match"},
-	{GIT_EMISSINGOBJDATA, "The object cannot be written that because it's missing internal data"},
-	{GIT_EPACKCORRUPTED, "The packfile for the ODB is corrupted"},
-	{GIT_EFLOCKFAIL, "Failed to adquire or release a file lock"},
-	{GIT_EZLIB, "The Z library failed to inflate/deflate an object's data"},
-	{GIT_EBUSY, "The queried object is currently busy"},
-	{GIT_EINVALIDPATH, "The path is invalid"},
-	{GIT_EBAREINDEX, "The index file is not backed up by an existing repository"},
-	{GIT_EINVALIDREFNAME, "The name of the reference is not valid"},
-	{GIT_EREFCORRUPTED, "The specified reference has its data corrupted"},
-	{GIT_ETOONESTEDSYMREF, "The specified symbolic reference is too deeply nested"},
-	{GIT_EPACKEDREFSCORRUPTED, "The pack-refs file is either corrupted of its format is not currently supported"},
-	{GIT_EINVALIDPATH, "The path is invalid" },
-	{GIT_EREVWALKOVER, "The revision walker is empty; there are no more commits left to iterate"},
-	{GIT_EINVALIDREFSTATE, "The state of the reference is not valid"},
-	{GIT_ENOTIMPLEMENTED, "This feature has not been implemented yet"},
-	{GIT_EEXISTS, "A reference with this name already exists"},
-	{GIT_EOVERFLOW, "The given integer literal is too large to be parsed"},
-	{GIT_ENOTNUM, "The given literal is not a valid number"},
-	{GIT_EAMBIGUOUSOIDPREFIX, "The given oid prefix is ambiguous"},
+/********************************************
+ * New error handling
+ ********************************************/
+
+static git_error g_git_oom_error = {
+	"Out of memory",
+	GITERR_NOMEMORY
 };
 
-const char *git_strerror(int num)
+static void set_error(int error_class, char *string)
 {
-	size_t i;
+	git_error *error = &GIT_GLOBAL->error_t;
 
-	if (num == GIT_EOSERR)
-		return strerror(errno);
-	for (i = 0; i < ARRAY_SIZE(error_codes); i++)
-		if (num == error_codes[i].num)
-			return error_codes[i].str;
+	git__free(error->message);
 
-	return "Unknown error";
-}
+	error->message = string;
+	error->klass = error_class;
 
-#define ERROR_MAX_LEN 1024
+	GIT_GLOBAL->last_error = error;
+}
 
-void git___rethrow(const char *msg, ...)
+void giterr_set_oom(void)
 {
-	char new_error[ERROR_MAX_LEN];
-	char *last_error;
-	char *old_error = NULL;
-
-	va_list va;
-
-	last_error = GIT_GLOBAL->error.last;
-
-	va_start(va, msg);
-	vsnprintf(new_error, ERROR_MAX_LEN, msg, va);
-	va_end(va);
-
-	old_error = git__strdup(last_error);
-
-	snprintf(last_error, ERROR_MAX_LEN, "%s \n	- %s", new_error, old_error);
+	GIT_GLOBAL->last_error = &g_git_oom_error;
+}
 
-	git__free(old_error);
+void giterr_set(int error_class, const char *string, ...)
+{
+	git_buf buf = GIT_BUF_INIT;
+	va_list arglist;
+
+	int unix_error_code = 0;
+
+#ifdef GIT_WIN32
+	DWORD win32_error_code = 0;
+#endif
+
+	if (error_class == GITERR_OS) {
+		unix_error_code = errno;
+		errno = 0;
+
+#ifdef GIT_WIN32
+		win32_error_code = GetLastError();
+		SetLastError(0);
+#endif
+	}
+
+	va_start(arglist, string);
+	git_buf_vprintf(&buf, string, arglist);
+	va_end(arglist);
+
+	/* automatically suffix strerror(errno) for GITERR_OS errors */
+	if (error_class == GITERR_OS) {
+
+		if (unix_error_code != 0) {
+			git_buf_PUTS(&buf, ": ");
+			git_buf_puts(&buf, strerror(unix_error_code));
+		}
+
+#ifdef GIT_WIN32
+		else if (win32_error_code != 0) {
+			LPVOID lpMsgBuf = NULL;
+
+			FormatMessage(
+				FORMAT_MESSAGE_ALLOCATE_BUFFER | 
+				FORMAT_MESSAGE_FROM_SYSTEM |
+				FORMAT_MESSAGE_IGNORE_INSERTS,
+				NULL, win32_error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
+
+			if (lpMsgBuf) {
+				git_buf_PUTS(&buf, ": ");
+				git_buf_puts(&buf, lpMsgBuf);
+				LocalFree(lpMsgBuf);
+			}
+		}
+#endif
+	}
+
+	if (!git_buf_oom(&buf))
+		set_error(error_class, git_buf_detach(&buf));
 }
 
-void git___throw(const char *msg, ...)
+void giterr_set_str(int error_class, const char *string)
 {
-	va_list va;
+	char *message = git__strdup(string);
 
-	va_start(va, msg);
-	vsnprintf(GIT_GLOBAL->error.last, ERROR_MAX_LEN, msg, va);
-	va_end(va);
+	if (message)
+		set_error(error_class, message);
 }
 
-const char *git_lasterror(void)
+void giterr_set_regex(const regex_t *regex, int error_code)
 {
-	char *last_error = GIT_GLOBAL->error.last;
-
-	if (!last_error[0])
-		return NULL;
+	char error_buf[1024];
+	regerror(error_code, regex, error_buf, sizeof(error_buf));
+	giterr_set_str(GITERR_REGEX, error_buf);
+}
 
-	return last_error;
+void giterr_clear(void)
+{
+	GIT_GLOBAL->last_error = NULL;
 }
 
-void git_clearerror(void)
+const git_error *giterr_last(void)
 {
-	char *last_error = GIT_GLOBAL->error.last;
-	last_error[0] = '\0';
+	return GIT_GLOBAL->last_error;
 }
+

data/ext/rugged/vendor/libgit2-dist/src/fetch.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.
@@ -9,6 +9,7 @@
 #include "git2/oid.h"
 #include "git2/refs.h"
 #include "git2/revwalk.h"
+#include "git2/indexer.h"
 
 #include "common.h"
 #include "transport.h"
@@ -28,19 +29,17 @@ struct filter_payload {
 static int filter_ref__cb(git_remote_head *head, void *payload)
 {
 	struct filter_payload *p = payload;
-	int error;
 
 	if (!p->found_head && strcmp(head->name, GIT_HEAD_FILE) == 0) {
 		p->found_head = 1;
 	} else {
 		/* If it doesn't match the refpec, we don't want it */
-		error = git_refspec_src_match(p->spec, head->name);
+		if (!git_refspec_src_matches(p->spec, head->name))
+			return 0;
 
-		if (error == GIT_ENOMATCH)
-			return GIT_SUCCESS;
-
-		if (error < GIT_SUCCESS)
-			return git__rethrow(error, "Error matching remote ref name");
+		/* Don't even try to ask for the annotation target */
+		if (!git__suffixcmp(head->name, "^{}"))
+			return 0;
 	}
 
 	/* If we have the object, mark it so we don't ask for it */
@@ -54,7 +53,6 @@ static int filter_ref__cb(git_remote_head *head, void *payload)
 
 static int filter_wants(git_remote *remote)
 {
-	int error;
 	struct filter_payload p;
 
 	git_vector_clear(&remote->refs);
@@ -69,9 +67,8 @@ static int filter_wants(git_remote *remote)
 	p.found_head = 0;
 	p.remote = remote;
 
-	error = git_repository_odb__weakptr(&p.odb, remote->repo);
-	if (error < GIT_SUCCESS)
-		return error;
+	if (git_repository_odb__weakptr(&p.odb, remote->repo) < 0)
+		return -1;
 
 	return remote->transport->ls(remote->transport, &filter_ref__cb, &p);
 }
@@ -83,19 +80,16 @@ static int filter_wants(git_remote *remote)
  */
 int git_fetch_negotiate(git_remote *remote)
 {
-	int error;
 	git_transport *t = remote->transport;
 
-	error = filter_wants(remote);
-	if (error < GIT_SUCCESS)
-		return git__rethrow(error, "Failed to filter the reference list for wants");
+	if (filter_wants(remote) < 0) {
+		giterr_set(GITERR_NET, "Failed to filter the reference list for wants");
+		return -1;
+	}
 
 	/* Don't try to negotiate when we don't want anything */
-	if (remote->refs.length == 0)
-		return GIT_SUCCESS;
-
-	if (!remote->need_pack)
-		return GIT_SUCCESS;
+	if (remote->refs.length == 0 || !remote->need_pack)
+		return 0;
 
 	/*
 	 * Now we have everything set up so we can start tell the server
@@ -104,69 +98,103 @@ int git_fetch_negotiate(git_remote *remote)
 	return t->negotiate_fetch(t, remote->repo, &remote->refs);
 }
 
-int git_fetch_download_pack(char **out, git_remote *remote)
+int git_fetch_download_pack(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats)
 {
-	if(!remote->need_pack) {
-		*out = NULL;
-		return GIT_SUCCESS;
-	}
+	if(!remote->need_pack)
+		return 0;
 
-	return remote->transport->download_pack(out, remote->transport, remote->repo);
+	return remote->transport->download_pack(remote->transport, remote->repo, bytes, stats);
 }
 
 /* Receiving data from a socket and storing it is pretty much the same for git and HTTP */
-int git_fetch__download_pack(char **out, const char *buffered, size_t buffered_size,
-                             GIT_SOCKET fd, git_repository *repo)
+int git_fetch__download_pack(
+	const char *buffered,
+	size_t buffered_size,
+	git_transport *t,
+	git_repository *repo,
+	git_off_t *bytes,
+	git_indexer_stats *stats)
 {
-	git_filebuf file = GIT_FILEBUF_INIT;
-	int error;
-	char buff[1024], path[GIT_PATH_MAX];
-	static const char suff[] = "/objects/pack/pack-received";
+	int recvd;
+	char buff[1024];
 	gitno_buffer buf;
+	git_indexer_stream *idx;
 
-
-	git_path_join(path, repo->path_repository, suff);
-
-	gitno_buffer_setup(&buf, buff, sizeof(buff), fd);
+	gitno_buffer_setup(t, &buf, buff, sizeof(buff));
 
 	if (memcmp(buffered, "PACK", strlen("PACK"))) {
-		return git__throw(GIT_ERROR, "The pack doesn't start with the signature");
+		giterr_set(GITERR_NET, "The pack doesn't start with the signature");
+		return -1;
 	}
 
-	error = git_filebuf_open(&file, path, GIT_FILEBUF_TEMPORARY);
-	if (error < GIT_SUCCESS)
-		goto cleanup;
+	if (git_indexer_stream_new(&idx, git_repository_path(repo)) < 0)
+		return -1;
 
-	/* Part of the packfile has been received, don't loose it */
-	error = git_filebuf_write(&file, buffered, buffered_size);
-	if (error < GIT_SUCCESS)
-		goto cleanup;
+	memset(stats, 0, sizeof(git_indexer_stats));
+	if (git_indexer_stream_add(idx, buffered, buffered_size, stats) < 0)
+		goto on_error;
 
-	while (1) {
-		error = git_filebuf_write(&file, buf.data, buf.offset);
-		if (error < GIT_SUCCESS)
-			goto cleanup;
+	*bytes = buffered_size;
+
+	do {
+		if (git_indexer_stream_add(idx, buf.data, buf.offset, stats) < 0)
+			goto on_error;
 
 		gitno_consume_n(&buf, buf.offset);
-		error = gitno_recv(&buf);
-		if (error < GIT_SUCCESS)
-			goto cleanup;
-		if (error == 0) /* Orderly shutdown */
-			break;
-	}
+		if ((recvd = gitno_recv(&buf)) < 0)
+			goto on_error;
 
-	*out = git__strdup(file.path_lock);
-	if (*out == NULL) {
-		error = GIT_ENOMEM;
-		goto cleanup;
-	}
+		*bytes += recvd;
+	} while(recvd > 0);
+
+	if (git_indexer_stream_finalize(idx, stats))
+		goto on_error;
+
+	git_indexer_stream_free(idx);
+	return 0;
 
-	/* A bit dodgy, but we need to keep the pack at the temporary path */
-	error = git_filebuf_commit_at(&file, file.path_lock, GIT_PACK_FILE_MODE);
-cleanup:
-	if (error < GIT_SUCCESS)
-		git_filebuf_cleanup(&file);
+on_error:
+	git_indexer_stream_free(idx);
+	return -1;
+}
+
+int git_fetch_setup_walk(git_revwalk **out, git_repository *repo)
+{
+	git_revwalk *walk;
+	git_strarray refs;
+	unsigned int i;
+	git_reference *ref;
+
+	if (git_reference_list(&refs, repo, GIT_REF_LISTALL) < 0)
+		return -1;
+
+	if (git_revwalk_new(&walk, repo) < 0)
+		return -1;
+
+	git_revwalk_sorting(walk, GIT_SORT_TIME);
+
+	for (i = 0; i < refs.count; ++i) {
+		/* No tags */
+		if (!git__prefixcmp(refs.strings[i], GIT_REFS_TAGS_DIR))
+			continue;
+
+		if (git_reference_lookup(&ref, repo, refs.strings[i]) < 0)
+			goto on_error;
+
+		if (git_reference_type(ref) == GIT_REF_SYMBOLIC)
+			continue;
+		if (git_revwalk_push(walk, git_reference_oid(ref)) < 0)
+			goto on_error;
+
+		git_reference_free(ref);
+	}
 
-	return error;
+	git_strarray_free(&refs);
+	*out = walk;
+	return 0;
 
+on_error:
+	git_reference_free(ref);
+	git_strarray_free(&refs);
+	return -1;
 }

data/ext/rugged/vendor/libgit2-dist/src/fetch.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.
@@ -10,9 +10,10 @@
 #include "netops.h"
 
 int git_fetch_negotiate(git_remote *remote);
-int git_fetch_download_pack(char **out, git_remote *remote);
+int git_fetch_download_pack(git_remote *remote, git_off_t *bytes, git_indexer_stats *stats);
 
-int git_fetch__download_pack(char **out, const char *buffered, size_t buffered_size,
-                             GIT_SOCKET fd, git_repository *repo);
+int git_fetch__download_pack(const char *buffered, size_t buffered_size, git_transport *t,
+			     git_repository *repo, git_off_t *bytes, git_indexer_stats *stats);
+int git_fetch_setup_walk(git_revwalk **out, git_repository *repo);
 
 #endif