rugged 0.17.0.b7 → 0.18.0.b1

data/vendor/libgit2/src/checkout.h

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) the libgit2 contributors. All rights reserved.
+ *
+ * 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_checkout_h__
+#define INCLUDE_checkout_h__
+
+#include "git2/checkout.h"
+#include "iterator.h"
+
+#define GIT_CHECKOUT__NOTIFY_CONFLICT_TREE (1u << 12)
+
+/**
+ * Update the working directory to match the target iterator.  The
+ * expected baseline value can be passed in via the checkout options
+ * or else will default to the HEAD commit.
+ */
+extern int git_checkout_iterator(
+	git_iterator *target,
+	git_checkout_opts *opts);
+
+#endif

data/vendor/libgit2/src/clone.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -18,7 +18,6 @@
 
 #include "common.h"
 #include "remote.h"
-#include "pkt.h"
 #include "fileops.h"
 #include "refs.h"
 #include "path.h"
@@ -29,18 +28,18 @@ static int create_branch(
 	const git_oid *target,
 	const char *name)
 {
-	git_object *head_obj = NULL;
-	git_reference *branch_ref;
+	git_commit *head_obj = NULL;
+	git_reference *branch_ref = NULL;
 	int error;
 
 	/* Find the target commit */
-	if ((error = git_object_lookup(&head_obj, repo, target, GIT_OBJ_ANY)) < 0)
+	if ((error = git_commit_lookup(&head_obj, repo, target)) < 0)
 		return error;
 
 	/* Create the new branch */
 	error = git_branch_create(&branch_ref, repo, name, head_obj, 0);
 
-	git_object_free(head_obj);
+	git_commit_free(head_obj);
 
 	if (!error)
 		*branch = branch_ref;
@@ -106,6 +105,7 @@ struct head_info {
 	git_oid remote_head_oid;
 	git_buf branchname;
 	const git_refspec *refspec;
+	bool found;
 };
 
 static int reference_matches_remote_head(
@@ -120,16 +120,16 @@ static int reference_matches_remote_head(
 	 */
 
 	/* Stop looking if we've already found a match */
-	if (git_buf_len(&head_info->branchname) > 0)
+	if (head_info->found)
 		return 0;
 
-	if (git_reference_name_to_oid(
+	if (git_reference_name_to_id(
 		&oid,
 		head_info->repo,
 		reference_name) < 0) {
-			/* TODO: How to handle not found references?
-			 */
-			return -1;
+			/* If the reference doesn't exists, it obviously cannot match the expected oid. */
+			giterr_clear();
+			return 0;
 	}
 
 	if (git_oid_cmp(&head_info->remote_head_oid, &oid) == 0) {
@@ -140,10 +140,14 @@ static int reference_matches_remote_head(
 			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;
+		if (git_buf_len(&head_info->branchname) > 0) {
+			if (git_buf_sets(
+				&head_info->branchname,
+				git_buf_cstr(&head_info->branchname) + strlen(GIT_REFS_HEADS_DIR)) < 0)
+					return -1;
+
+			head_info->found = 1;
+		}
 	}
 
 	return 0;
@@ -171,11 +175,19 @@ static int update_head_to_new_branch(
 	return error;
 }
 
+static int get_head_callback(git_remote_head *head, void *payload)
+{
+	git_remote_head **destination = (git_remote_head **)payload;
+
+	/* Save the first entry, and terminate the enumeration */
+	*destination = head;
+	return 1;
+}
+
 static int update_head_to_remote(git_repository *repo, git_remote *remote)
 {
 	int retcode = -1;
 	git_remote_head *remote_head;
-	git_pkt_ref *pkt;
 	struct head_info head_info;
 	git_buf remote_master_name = GIT_BUF_INIT;
 
@@ -189,12 +201,18 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 	}
 
 	/* Get the remote's HEAD. This is always the first ref in remote->refs. */
-	pkt = remote->transport->refs.contents[0];
-	remote_head = &pkt->head;
+	remote_head = NULL;
+	
+	if (!remote->transport->ls(remote->transport, get_head_callback, &remote_head))
+		return -1;
+
+	assert(remote_head);
+
 	git_oid_cpy(&head_info.remote_head_oid, &remote_head->oid);
 	git_buf_init(&head_info.branchname, 16);
 	head_info.repo = repo;
 	head_info.refspec = git_remote_fetchspec(remote);
+	head_info.found = 0;
 	
 	/* Determine the remote tracking reference name from the local master */
 	if (git_refspec_transform_r(
@@ -207,7 +225,7 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 	if (reference_matches_remote_head(git_buf_cstr(&remote_master_name), &head_info) < 0)
 		goto cleanup;
 
-	if (git_buf_len(&head_info.branchname) > 0) {
+	if (head_info.found) {
 		retcode = update_head_to_new_branch(
 			repo,
 			&head_info.remote_head_oid,
@@ -224,7 +242,7 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 		&head_info) < 0)
 			goto cleanup;
 
-	if (git_buf_len(&head_info.branchname) > 0) {
+	if (head_info.found) {
 		retcode = update_head_to_new_branch(
 			repo,
 			&head_info.remote_head_oid,
@@ -232,8 +250,10 @@ static int update_head_to_remote(git_repository *repo, git_remote *remote)
 
 		goto cleanup;
 	} else {
-		/* TODO: What should we do if nothing has been found?
-		 */
+		retcode = git_repository_set_head_detached(
+			repo,
+			&head_info.remote_head_oid);
+		goto cleanup;
 	}
 
 cleanup:
@@ -242,32 +262,110 @@ cleanup:
 	return retcode;
 }
 
+static int update_head_to_branch(
+		git_repository *repo,
+		const git_clone_options *options)
+{
+	int retcode;
+	git_buf remote_branch_name = GIT_BUF_INIT;
+	git_reference* remote_ref = NULL;
+	
+	assert(options->checkout_branch);
+
+	if ((retcode = git_buf_printf(&remote_branch_name, GIT_REFS_REMOTES_DIR "%s/%s",
+		options->remote_name, options->checkout_branch)) < 0 )
+		goto cleanup;
+
+	if ((retcode = git_reference_lookup(&remote_ref, repo, git_buf_cstr(&remote_branch_name))) < 0)
+		goto cleanup;
+
+	retcode = update_head_to_new_branch(repo, git_reference_target(remote_ref),
+		options->checkout_branch);
+
+cleanup:
+	git_reference_free(remote_ref);
+	git_buf_free(&remote_branch_name);
+	return retcode;
+}
+
 /*
  * submodules?
  */
 
+static int create_and_configure_origin(
+		git_remote **out,
+		git_repository *repo,
+		const char *url,
+		const git_clone_options *options)
+{
+	int error;
+	git_remote *origin = NULL;
+
+	if ((error = git_remote_create(&origin, repo, options->remote_name, url)) < 0)
+		goto on_error;
+
+	git_remote_set_cred_acquire_cb(origin, options->cred_acquire_cb,
+			options->cred_acquire_payload);
+	git_remote_set_autotag(origin, options->remote_autotag);
+	/*
+	 * Don't write FETCH_HEAD, we'll check out the remote tracking
+	 * branch ourselves based on the server's default.
+	 */
+	git_remote_set_update_fetchhead(origin, 0);
+
+	if (options->remote_callbacks &&
+	    (error = git_remote_set_callbacks(origin, options->remote_callbacks)) < 0)
+		goto on_error;
+
+	if (options->fetch_spec &&
+	    (error = git_remote_set_fetchspec(origin, options->fetch_spec)) < 0)
+		goto on_error;
+
+	if (options->push_spec &&
+	    (error = git_remote_set_pushspec(origin, options->push_spec)) < 0)
+		goto on_error;
+
+	if (options->pushurl &&
+	    (error = git_remote_set_pushurl(origin, options->pushurl)) < 0)
+		goto on_error;
+
+	if ((error = git_remote_save(origin)) < 0)
+		goto on_error;
+
+	*out = origin;
+	return 0;
 
+on_error:
+	git_remote_free(origin);
+	return error;
+}
 
-static int setup_remotes_and_fetch(git_repository *repo,
-											  const char *origin_url,
-											  git_indexer_stats *fetch_stats)
+
+static int setup_remotes_and_fetch(
+		git_repository *repo,
+		const char *url,
+		const git_clone_options *options)
 {
 	int retcode = GIT_ERROR;
-	git_remote *origin = NULL;
-	git_off_t bytes = 0;
-	git_indexer_stats dummy_stats;
+	git_remote *origin;
 
-	if (!fetch_stats) fetch_stats = &dummy_stats;
+	/* Construct an origin remote */
+	if (!create_and_configure_origin(&origin, repo, url, options)) {
+		git_remote_set_update_fetchhead(origin, 0);
 
-	/* Create the "origin" remote */
-	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)) {
+		if (!git_remote_connect(origin, GIT_DIRECTION_FETCH)) {
+			if (!(retcode = git_remote_download(origin, options->fetch_progress_cb,
+						options->fetch_progress_payload))) {
 				/* Create "origin/foo" branches for all remote branches */
 				if (!git_remote_update_tips(origin)) {
+					/* Point HEAD to the requested branch */
+					if (options->checkout_branch) {
+						if (!update_head_to_branch(repo, options))
+							retcode = 0;
+					}
 					/* Point HEAD to the same ref as the remote's head */
-					if (!update_head_to_remote(repo, origin)) {
+					else if (!update_head_to_remote(repo, origin)) {
 						retcode = 0;
 					}
 				}
@@ -304,78 +402,65 @@ static bool should_checkout(
 	if (!opts)
 		return false;
 
+	if (opts->checkout_strategy == GIT_CHECKOUT_NONE)
+		return false;
+
 	return !git_repository_head_orphan(repo);
 }
 
-static int clone_internal(
+static void normalize_options(git_clone_options *dst, const git_clone_options *src)
+{
+	git_clone_options default_options = GIT_CLONE_OPTIONS_INIT;
+	if (!src) src = &default_options;
+
+	*dst = *src;
+
+	/* Provide defaults for null pointers */
+	if (!dst->remote_name) dst->remote_name = "origin";
+	if (!dst->remote_autotag) dst->remote_autotag = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
+}
+
+int git_clone(
 	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)
+	const char *url,
+	const char *local_path,
+	const git_clone_options *options)
 {
 	int retcode = GIT_ERROR;
 	git_repository *repo = NULL;
-	git_indexer_stats dummy_stats;
+	git_clone_options normOptions;
+	int remove_directory_on_failure = 0;
 
-	if (!fetch_stats) fetch_stats = &dummy_stats;
+	assert(out && url && local_path);
 
-	if (!path_is_okay(path)) {
+	normalize_options(&normOptions, options);
+	GITERR_CHECK_VERSION(&normOptions, GIT_CLONE_OPTIONS_VERSION, "git_clone_options");
+
+	if (!path_is_okay(local_path)) {
 		return GIT_ERROR;
 	}
 
-	if (!(retcode = git_repository_init(&repo, path, is_bare))) {
-		if ((retcode = setup_remotes_and_fetch(repo, origin_url, fetch_stats)) < 0) {
+	/* Only remove the directory on failure if we create it */
+	remove_directory_on_failure = !git_path_exists(local_path);
+
+	if (!(retcode = git_repository_init(&repo, local_path, normOptions.bare))) {
+		if ((retcode = setup_remotes_and_fetch(repo, url, &normOptions)) < 0) {
 			/* Failed to fetch; clean up */
 			git_repository_free(repo);
-			git_futils_rmdir_r(path, NULL, GIT_DIRREMOVAL_FILES_AND_DIRS);
+
+			if (remove_directory_on_failure)
+				git_futils_rmdir_r(local_path, NULL, GIT_RMDIR_REMOVE_FILES);
+			else
+				git_futils_cleanupdir_r(local_path);
+
 		} else {
 			*out = repo;
 			retcode = 0;
 		}
 	}
 
-	if (!retcode && should_checkout(repo, is_bare, checkout_opts))
-		retcode = git_checkout_head(*out, checkout_opts, checkout_stats);
+	if (!retcode && should_checkout(repo, normOptions.bare, &normOptions.checkout_opts))
+		retcode = git_checkout_head(*out, &normOptions.checkout_opts);
 
 	return retcode;
 }
-
-int git_clone_bare(git_repository **out,
-						 const char *origin_url,
-						 const char *dest_path,
-						 git_indexer_stats *fetch_stats)
-{
-	assert(out && origin_url && dest_path);
-
-	return clone_internal(
-		out,
-		origin_url,
-		dest_path,
-		fetch_stats,
-		NULL,
-		NULL,
-		1);
-}
-
-
-int git_clone(git_repository **out,
-				  const char *origin_url,
-				  const char *workdir_path,
-				  git_indexer_stats *fetch_stats,
-				  git_indexer_stats *checkout_stats,
-				  git_checkout_opts *checkout_opts)
-{
-	assert(out && origin_url && workdir_path);
-
-	return clone_internal(
-		out,
-		origin_url,
-		workdir_path,
-		fetch_stats,
-		checkout_stats,
-		checkout_opts,
-		0);
-}

data/vendor/libgit2/src/commit.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -20,20 +20,20 @@
 
 static void clear_parents(git_commit *commit)
 {
-	unsigned int i;
+	size_t i;
 
-	for (i = 0; i < commit->parent_oids.length; ++i) {
-		git_oid *parent = git_vector_get(&commit->parent_oids, i);
+	for (i = 0; i < commit->parent_ids.length; ++i) {
+		git_oid *parent = git_vector_get(&commit->parent_ids, i);
 		git__free(parent);
 	}
 
-	git_vector_clear(&commit->parent_oids);
+	git_vector_clear(&commit->parent_ids);
 }
 
 void git_commit__free(git_commit *commit)
 {
 	clear_parents(commit);
-	git_vector_free(&commit->parent_oids);
+	git_vector_free(&commit->parent_ids);
 
 	git_signature_free(commit->author);
 	git_signature_free(commit->committer);
@@ -43,11 +43,6 @@ void git_commit__free(git_commit *commit)
 	git__free(commit);
 }
 
-const git_oid *git_commit_id(git_commit *c)
-{
-	return git_object_id((git_object *)c);
-}
-
 int git_commit_create_v(
 		git_oid *oid,
 		git_repository *repo,
@@ -126,7 +121,7 @@ int git_commit_create(
 	git_buf_free(&commit);
 
 	if (update_ref != NULL)
-		return git_reference__update(repo, oid, update_ref);
+		return git_reference__update_terminal(repo, update_ref, oid);
 
 	return 0;
 
@@ -140,27 +135,25 @@ int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len)
 {
 	const char *buffer = data;
 	const char *buffer_end = (const char *)data + len;
+	git_oid parent_id;
 
-	git_oid parent_oid;
-
-	git_vector_init(&commit->parent_oids, 4, NULL);
+	if (git_vector_init(&commit->parent_ids, 4, NULL) < 0)
+		return -1;
 
-	if (git_oid__parse(&commit->tree_oid, &buffer, buffer_end, "tree ") < 0)
+	if (git_oid__parse(&commit->tree_id, &buffer, buffer_end, "tree ") < 0)
 		goto bad_buffer;
 
 	/*
 	 * TODO: commit grafts!
 	 */
 
-	while (git_oid__parse(&parent_oid, &buffer, buffer_end, "parent ") == 0) {
-		git_oid *new_oid;
+	while (git_oid__parse(&parent_id, &buffer, buffer_end, "parent ") == 0) {
+		git_oid *new_id = git__malloc(sizeof(git_oid));
+		GITERR_CHECK_ALLOC(new_id);
 
-		new_oid = git__malloc(sizeof(git_oid));
-		GITERR_CHECK_ALLOC(new_oid);
+		git_oid_cpy(new_id, &parent_id);
 
-		git_oid_cpy(new_oid, &parent_oid);
-
-		if (git_vector_insert(&commit->parent_oids, new_oid) < 0)
+		if (git_vector_insert(&commit->parent_ids, new_id) < 0)
 			return -1;
 	}
 
@@ -177,24 +170,30 @@ int git_commit__parse_buffer(git_commit *commit, const void *data, size_t len)
 	if (git_signature__parse(commit->committer, &buffer, buffer_end, "committer ", '\n') < 0)
 		return -1;
 
-	if (git__prefixcmp(buffer, "encoding ") == 0) {
-		const char *encoding_end;
-		buffer += strlen("encoding ");
+	/* Parse add'l header entries until blank line found */
+	while (buffer < buffer_end && *buffer != '\n') {
+		const char *eoln = buffer;
+		while (eoln < buffer_end && *eoln != '\n')
+			++eoln;
+
+		if (git__prefixcmp(buffer, "encoding ") == 0) {
+			buffer += strlen("encoding ");
 
-		encoding_end = buffer;
-		while (encoding_end < buffer_end && *encoding_end != '\n')
-			encoding_end++;
+			commit->message_encoding = git__strndup(buffer, eoln - buffer);
+			GITERR_CHECK_ALLOC(commit->message_encoding);
+		}
 
-		commit->message_encoding = git__strndup(buffer, encoding_end - buffer);
-		GITERR_CHECK_ALLOC(commit->message_encoding);
+		if (eoln < buffer_end && *eoln == '\n')
+			++eoln;
 
-		buffer = encoding_end;
+		buffer = eoln;
 	}
 
-	/* parse commit message */
-	while (buffer < buffer_end - 1 && *buffer == '\n')
+	/* buffer is now at the end of the header, double-check and move forward into the message */
+	if (buffer < buffer_end && *buffer == '\n')
 		buffer++;
 
+	/* parse commit message */
 	if (buffer <= buffer_end) {
 		commit->message = git__strndup(buffer, buffer_end - buffer);
 		GITERR_CHECK_ALLOC(commit->message);
@@ -214,7 +213,7 @@ int git_commit__parse(git_commit *commit, git_odb_object *obj)
 }
 
 #define GIT_COMMIT_GETTER(_rvalue, _name, _return) \
-	_rvalue git_commit_##_name(git_commit *commit) \
+	_rvalue git_commit_##_name(const git_commit *commit) \
 	{\
 		assert(commit); \
 		return _return; \
@@ -226,34 +225,34 @@ GIT_COMMIT_GETTER(const char *, message, commit->message)
 GIT_COMMIT_GETTER(const char *, message_encoding, commit->message_encoding)
 GIT_COMMIT_GETTER(git_time_t, time, commit->committer->when.time)
 GIT_COMMIT_GETTER(int, time_offset, commit->committer->when.offset)
-GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)commit->parent_oids.length)
-GIT_COMMIT_GETTER(const git_oid *, tree_oid, &commit->tree_oid);
+GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)commit->parent_ids.length)
+GIT_COMMIT_GETTER(const git_oid *, tree_id, &commit->tree_id);
 
-int git_commit_tree(git_tree **tree_out, git_commit *commit)
+int git_commit_tree(git_tree **tree_out, const git_commit *commit)
 {
 	assert(commit);
-	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_oid);
+	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_id);
 }
 
-const git_oid *git_commit_parent_oid(git_commit *commit, unsigned int n)
+const git_oid *git_commit_parent_id(git_commit *commit, unsigned int n)
 {
 	assert(commit);
 
-	return git_vector_get(&commit->parent_oids, n);
+	return git_vector_get(&commit->parent_ids, n);
 }
 
 int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n)
 {
-	const git_oid *parent_oid;
+	const git_oid *parent_id;
 	assert(commit);
 
-	parent_oid = git_commit_parent_oid(commit, n);
-	if (parent_oid == NULL) {
+	parent_id = git_commit_parent_id(commit, n);
+	if (parent_id == NULL) {
 		giterr_set(GITERR_INVALID, "Parent %u does not exist", n);
 		return GIT_ENOTFOUND;
 	}
 
-	return git_commit_lookup(parent, commit->object.repo, parent_oid);
+	return git_commit_lookup(parent, commit->object.repo, parent_id);
 }
 
 int git_commit_nth_gen_ancestor(