rugged 0.17.0.b6 → 0.17.0.b7

data/vendor/libgit2/src/clone.c

@@ -7,10 +7,6 @@
 
 #include <assert.h>
 
-#ifndef GIT_WIN32
-#include <dirent.h>
-#endif
-
 #include "git2/clone.h"
 #include "git2/remote.h"
 #include "git2/revparse.h"
@@ -22,118 +18,226 @@
 
 #include "common.h"
 #include "remote.h"
+#include "pkt.h"
 #include "fileops.h"
 #include "refs.h"
 #include "path.h"
 
-GIT_BEGIN_DECL
-
-struct HeadInfo {
-	git_repository *repo;
-	git_oid remote_head_oid;
-	git_buf branchname;
-};
-
-static int create_tracking_branch(git_repository *repo, const git_oid *target, const char *name)
+static int create_branch(
+	git_reference **branch,
+	git_repository *repo,
+	const git_oid *target,
+	const char *name)
 {
 	git_object *head_obj = NULL;
 	git_reference *branch_ref;
-	int retcode = GIT_ERROR;
+	int error;
 
 	/* Find the target commit */
-	if (git_object_lookup(&head_obj, repo, target, GIT_OBJ_ANY) < 0)
-		return GIT_ERROR;
+	if ((error = git_object_lookup(&head_obj, repo, target, GIT_OBJ_ANY)) < 0)
+		return error;
 
 	/* Create the new branch */
-	if (!git_branch_create(&branch_ref, repo, name, head_obj, 0)) {
-		git_config *cfg;
+	error = git_branch_create(&branch_ref, repo, name, head_obj, 0);
 
+	git_object_free(head_obj);
+
+	if (!error)
+		*branch = branch_ref;
+	else
 		git_reference_free(branch_ref);
-		/* Set up tracking */
-		if (!git_repository_config(&cfg, repo)) {
-			git_buf remote = GIT_BUF_INIT;
-			git_buf merge = GIT_BUF_INIT;
-			git_buf merge_target = GIT_BUF_INIT;
-			if (!git_buf_printf(&remote, "branch.%s.remote", name) &&
-				 !git_buf_printf(&merge, "branch.%s.merge", name) &&
-				 !git_buf_printf(&merge_target, "refs/heads/%s", name) &&
-				 !git_config_set_string(cfg, git_buf_cstr(&remote), "origin") &&
-				 !git_config_set_string(cfg, git_buf_cstr(&merge), git_buf_cstr(&merge_target))) {
-				retcode = 0;
-			}
-			git_buf_free(&remote);
-			git_buf_free(&merge);
-			git_buf_free(&merge_target);
-			git_config_free(cfg);
-		}
-	}
 
-	git_object_free(head_obj);
-	return retcode;
+	return error;
 }
 
-static int reference_matches_remote_head(const char *head_name, void *payload)
+static int setup_tracking_config(
+	git_repository *repo,
+	const char *branch_name,
+	const char *remote_name,
+	const char *merge_target)
+{
+	git_config *cfg;
+	git_buf remote_key = GIT_BUF_INIT, merge_key = GIT_BUF_INIT;
+	int error = -1;
+
+	if (git_repository_config__weakptr(&cfg, repo) < 0)
+		return -1;
+
+	if (git_buf_printf(&remote_key, "branch.%s.remote", branch_name) < 0)
+		goto cleanup;
+
+	if (git_buf_printf(&merge_key, "branch.%s.merge", branch_name) < 0)
+		goto cleanup;
+
+	if (git_config_set_string(cfg, git_buf_cstr(&remote_key), remote_name) < 0)
+		goto cleanup;
+
+	if (git_config_set_string(cfg, git_buf_cstr(&merge_key), merge_target) < 0)
+		goto cleanup;
+
+	error = 0;
+
+cleanup:
+	git_buf_free(&remote_key);
+	git_buf_free(&merge_key);
+	return error;
+}
+
+static int create_tracking_branch(
+	git_reference **branch,
+	git_repository *repo,
+	const git_oid *target,
+	const char *branch_name)
+{
+	int error;
+
+	if ((error = create_branch(branch, repo, target, branch_name)) < 0)
+		return error;
+
+	return setup_tracking_config(
+		repo,
+		branch_name,
+		GIT_REMOTE_ORIGIN,
+		git_reference_name(*branch));
+}
+
+struct head_info {
+	git_repository *repo;
+	git_oid remote_head_oid;
+	git_buf branchname;
+	const git_refspec *refspec;
+};
+
+static int reference_matches_remote_head(
+	const char *reference_name,
+	void *payload)
 {
-	struct HeadInfo *head_info = (struct HeadInfo *)payload;
+	struct head_info *head_info = (struct head_info *)payload;
 	git_oid oid;
 
+	/* TODO: Should we guard against references
+	 * which name doesn't start with refs/heads/ ?
+	 */
+
 	/* Stop looking if we've already found a match */
-	if (git_buf_len(&head_info->branchname) > 0) return 0;
+	if (git_buf_len(&head_info->branchname) > 0)
+		return 0;
+
+	if (git_reference_name_to_oid(
+		&oid,
+		head_info->repo,
+		reference_name) < 0) {
+			/* TODO: How to handle not found references?
+			 */
+			return -1;
+	}
 
-	if (!git_reference_name_to_oid(&oid, head_info->repo, head_name) &&
-		 !git_oid_cmp(&head_info->remote_head_oid, &oid)) {
-		git_buf_puts(&head_info->branchname,
-						 head_name+strlen("refs/remotes/origin/"));
+	if (git_oid_cmp(&head_info->remote_head_oid, &oid) == 0) {
+		/* Determine the local reference name from the remote tracking one */
+		if (git_refspec_transform_l(
+			&head_info->branchname, 
+			head_info->refspec,
+			reference_name) < 0)
+				return -1;
+		
+		if (git_buf_sets(
+			&head_info->branchname,
+			git_buf_cstr(&head_info->branchname) + strlen(GIT_REFS_HEADS_DIR)) < 0)
+				return -1;
 	}
+
 	return 0;
 }
 
-static int update_head_to_new_branch(git_repository *repo, const git_oid *target, const char *name)
+static int update_head_to_new_branch(
+	git_repository *repo,
+	const git_oid *target,
+	const char *name)
 {
-	int retcode = GIT_ERROR;
+	git_reference *tracking_branch = NULL;
+	int error;
 
-	if (!create_tracking_branch(repo, target, name)) {
-		git_reference *head;
-		if (!git_reference_lookup(&head, repo, GIT_HEAD_FILE)) {
-			git_buf targetbuf = GIT_BUF_INIT;
-			if (!git_buf_printf(&targetbuf, "refs/heads/%s", name)) {
-				retcode = git_reference_set_target(head, git_buf_cstr(&targetbuf));
-			}
-			git_buf_free(&targetbuf);
-			git_reference_free(head);
-		}
-	}
+	if ((error = create_tracking_branch(
+		&tracking_branch,
+		repo,
+		target,
+		name)) < 0)
+			return error;
 
-	return retcode;
+	error = git_repository_set_head(repo, git_reference_name(tracking_branch));
+
+	git_reference_free(tracking_branch);
+
+	return error;
 }
 
 static int update_head_to_remote(git_repository *repo, git_remote *remote)
 {
-	int retcode = GIT_ERROR;
+	int retcode = -1;
 	git_remote_head *remote_head;
-	git_oid oid;
-	struct HeadInfo head_info;
+	git_pkt_ref *pkt;
+	struct head_info head_info;
+	git_buf remote_master_name = GIT_BUF_INIT;
+
+	/* Did we just clone an empty repository? */
+	if (remote->refs.length == 0) {
+		return setup_tracking_config(
+			repo,
+			"master",
+			GIT_REMOTE_ORIGIN,
+			GIT_REFS_HEADS_MASTER_FILE);
+	}
 
 	/* Get the remote's HEAD. This is always the first ref in remote->refs. */
-	remote_head = remote->refs.contents[0];
+	pkt = remote->transport->refs.contents[0];
+	remote_head = &pkt->head;
 	git_oid_cpy(&head_info.remote_head_oid, &remote_head->oid);
 	git_buf_init(&head_info.branchname, 16);
 	head_info.repo = repo;
-
-	/* Check to see if "master" matches the remote head */
-	if (!git_reference_name_to_oid(&oid, repo, "refs/remotes/origin/master") &&
-		 !git_oid_cmp(&remote_head->oid, &oid)) {
-		retcode = update_head_to_new_branch(repo, &oid, "master");
+	head_info.refspec = git_remote_fetchspec(remote);
+	
+	/* Determine the remote tracking reference name from the local master */
+	if (git_refspec_transform_r(
+		&remote_master_name,
+		head_info.refspec,
+		GIT_REFS_HEADS_MASTER_FILE) < 0)
+			return -1;
+
+	/* Check to see if the remote HEAD points to the remote master */
+	if (reference_matches_remote_head(git_buf_cstr(&remote_master_name), &head_info) < 0)
+		goto cleanup;
+
+	if (git_buf_len(&head_info.branchname) > 0) {
+		retcode = update_head_to_new_branch(
+			repo,
+			&head_info.remote_head_oid,
+			git_buf_cstr(&head_info.branchname));
+
+		goto cleanup;
 	}
+
 	/* Not master. Check all the other refs. */
-	else if (!git_reference_foreach(repo, GIT_REF_LISTALL,
-												 reference_matches_remote_head,
-												 &head_info) &&
-				git_buf_len(&head_info.branchname) > 0) {
-		retcode = update_head_to_new_branch(repo, &head_info.remote_head_oid,
-														git_buf_cstr(&head_info.branchname));
+	if (git_reference_foreach(
+		repo,
+		GIT_REF_LISTALL,
+		reference_matches_remote_head,
+		&head_info) < 0)
+			goto cleanup;
+
+	if (git_buf_len(&head_info.branchname) > 0) {
+		retcode = update_head_to_new_branch(
+			repo,
+			&head_info.remote_head_oid,
+			git_buf_cstr(&head_info.branchname));
+
+		goto cleanup;
+	} else {
+		/* TODO: What should we do if nothing has been found?
+		 */
 	}
 
+cleanup:
+	git_buf_free(&remote_master_name);
 	git_buf_free(&head_info.branchname);
 	return retcode;
 }
@@ -156,7 +260,7 @@ static int setup_remotes_and_fetch(git_repository *repo,
 	if (!fetch_stats) fetch_stats = &dummy_stats;
 
 	/* Create the "origin" remote */
-	if (!git_remote_add(&origin, repo, "origin", origin_url)) {
+	if (!git_remote_add(&origin, repo, GIT_REMOTE_ORIGIN, origin_url)) {
 		/* Connect and download everything */
 		if (!git_remote_connect(origin, GIT_DIR_FETCH)) {
 			if (!git_remote_download(origin, &bytes, fetch_stats)) {
@@ -189,12 +293,28 @@ static bool path_is_okay(const char *path)
 	return true;
 }
 
+static bool should_checkout(
+	git_repository *repo,
+	bool is_bare,
+	git_checkout_opts *opts)
+{
+	if (is_bare)
+		return false;
 
-static int clone_internal(git_repository **out,
-								  const char *origin_url,
-								  const char *path,
-								  git_indexer_stats *fetch_stats,
-								  int is_bare)
+	if (!opts)
+		return false;
+
+	return !git_repository_head_orphan(repo);
+}
+
+static int clone_internal(
+	git_repository **out,
+	const char *origin_url,
+	const char *path,
+	git_indexer_stats *fetch_stats,
+	git_indexer_stats *checkout_stats,
+	git_checkout_opts *checkout_opts,
+	bool is_bare)
 {
 	int retcode = GIT_ERROR;
 	git_repository *repo = NULL;
@@ -210,13 +330,16 @@ static int clone_internal(git_repository **out,
 		if ((retcode = setup_remotes_and_fetch(repo, origin_url, fetch_stats)) < 0) {
 			/* Failed to fetch; clean up */
 			git_repository_free(repo);
-			git_futils_rmdir_r(path, GIT_DIRREMOVAL_FILES_AND_DIRS);
+			git_futils_rmdir_r(path, NULL, GIT_DIRREMOVAL_FILES_AND_DIRS);
 		} else {
 			*out = repo;
 			retcode = 0;
 		}
 	}
 
+	if (!retcode && should_checkout(repo, is_bare, checkout_opts))
+		retcode = git_checkout_head(*out, checkout_opts, checkout_stats);
+
 	return retcode;
 }
 
@@ -226,7 +349,15 @@ int git_clone_bare(git_repository **out,
 						 git_indexer_stats *fetch_stats)
 {
 	assert(out && origin_url && dest_path);
-	return clone_internal(out, origin_url, dest_path, fetch_stats, 1);
+
+	return clone_internal(
+		out,
+		origin_url,
+		dest_path,
+		fetch_stats,
+		NULL,
+		NULL,
+		1);
 }
 
 
@@ -237,18 +368,14 @@ int git_clone(git_repository **out,
 				  git_indexer_stats *checkout_stats,
 				  git_checkout_opts *checkout_opts)
 {
-	int retcode = GIT_ERROR;
-
 	assert(out && origin_url && workdir_path);
 
-	if (!(retcode = clone_internal(out, origin_url, workdir_path, fetch_stats, 0))) {
-		retcode = git_checkout_head(*out, checkout_opts, checkout_stats);
-	}
-
-	return retcode;
+	return clone_internal(
+		out,
+		origin_url,
+		workdir_path,
+		fetch_stats,
+		checkout_stats,
+		checkout_opts,
+		0);
 }
-
-
-
-
-GIT_END_DECL

data/vendor/libgit2/src/common.h

@@ -49,14 +49,24 @@
 
 #include <regex.h>
 
+/**
+ * Check a pointer allocation result, returning -1 if it failed.
+ */
 #define GITERR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
 
-void giterr_set_oom(void);
+/**
+ * Set the error message for this thread, formatting as needed.
+ */
 void giterr_set(int error_class, const char *string, ...);
-void giterr_clear(void);
-void giterr_set_str(int error_class, const char *string);
+
+/**
+ * Set the error message for a regex failure, using the internal regex
+ * error code lookup.
+ */
 void giterr_set_regex(const regex_t *regex, int error_code);
 
+/* NOTE: other giterr functions are in the public errors.h header file */
+
 #include "util.h"
 
 typedef struct git_transport git_transport;

data/vendor/libgit2/src/compress.c

@@ -0,0 +1,53 @@
+/*
+ * 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 "compress.h"
+
+#include <zlib.h>
+
+#define BUFFER_SIZE (1024 * 1024)
+
+int git__compress(git_buf *buf, const void *buff, size_t len)
+{
+	z_stream zs;
+	char *zb;
+	size_t have;
+
+	memset(&zs, 0, sizeof(zs));
+	if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK)
+		return -1;
+
+	zb = git__malloc(BUFFER_SIZE);
+	GITERR_CHECK_ALLOC(zb);
+
+	zs.next_in = (void *)buff;
+	zs.avail_in = (uInt)len;
+
+	do {
+		zs.next_out = (unsigned char *)zb;
+		zs.avail_out = BUFFER_SIZE;
+
+		if (deflate(&zs, Z_FINISH) == Z_STREAM_ERROR) {
+			git__free(zb);
+			return -1;
+		}
+
+		have = BUFFER_SIZE - (size_t)zs.avail_out;
+
+		if (git_buf_put(buf, zb, have) < 0) {
+			git__free(zb);
+			return -1;
+		}
+
+	} while (zs.avail_out == 0);
+
+	assert(zs.avail_in == 0);
+
+	deflateEnd(&zs);
+	git__free(zb);
+	return 0;
+}