rugged 0.17.0b2 → 0.17.0.b6

data/{ext/rugged/vendor/libgit2-dist → vendor/libgit2}/src/buffer.c

@@ -141,6 +141,42 @@ int git_buf_puts(git_buf *buf, const char *string)
 	return git_buf_put(buf, string, strlen(string));
 }
 
+int git_buf_puts_escaped(
+	git_buf *buf, const char *string, const char *esc_chars, const char *esc_with)
+{
+	const char *scan = string;
+	size_t total = 0, esc_with_len = strlen(esc_with);
+
+	while (*scan) {
+		size_t count = strcspn(scan, esc_chars);
+		total += count + 1 + esc_with_len;
+		scan += count + 1;
+	}
+
+	ENSURE_SIZE(buf, buf->size + total + 1);
+
+	for (scan = string; *scan; ) {
+		size_t count = strcspn(scan, esc_chars);
+
+		memmove(buf->ptr + buf->size, scan, count);
+		scan += count;
+		buf->size += count;
+
+		if (*scan) {
+			memmove(buf->ptr + buf->size, esc_with, esc_with_len);
+			buf->size += esc_with_len;
+
+			memmove(buf->ptr + buf->size, scan, 1);
+			scan += 1;
+			buf->size += 1;
+		}
+	}
+
+	buf->ptr[buf->size] = '\0';
+
+	return 0;
+}
+
 int git_buf_vprintf(git_buf *buf, const char *format, va_list ap)
 {
 	int len;
@@ -460,3 +496,7 @@ bool git_buf_is_binary(const git_buf *buf)
 	return ((printable >> 7) < nonprintable);
 }
 
+void git_buf_unescape(git_buf *buf)
+{
+	buf->size = git__unescape(buf->ptr);
+}

data/{ext/rugged/vendor/libgit2-dist → vendor/libgit2}/src/buffer.h

@@ -90,6 +90,18 @@ void git_buf_rtruncate_at_char(git_buf *path, char separator);
 int git_buf_join_n(git_buf *buf, char separator, int nbuf, ...);
 int git_buf_join(git_buf *buf, char separator, const char *str_a, const char *str_b);
 
+/**
+ * Copy string into buf prefixing every character that is contained in the
+ * esc_chars string with the esc_with string.
+ */
+int git_buf_puts_escaped(
+	git_buf *buf, const char *string, const char *esc_chars, const char *esc_with);
+
+GIT_INLINE(int) git_buf_puts_escape_regex(git_buf *buf, const char *string)
+{
+	return git_buf_puts_escaped(buf, string, "^.[]$()|*+?{}\\", "\\");
+}
+
 /**
  * Join two strings as paths, inserting a slash between as needed.
  * @return 0 on success, -1 on failure
@@ -121,6 +133,13 @@ GIT_INLINE(ssize_t) git_buf_rfind_next(git_buf *buf, char ch)
 	return idx;
 }
 
+GIT_INLINE(ssize_t) git_buf_rfind(git_buf *buf, char ch)
+{
+	ssize_t idx = (ssize_t)buf->size - 1;
+	while (idx >= 0 && buf->ptr[idx] != ch) idx--;
+	return idx;
+}
+
 /* Remove whitespace from the end of the buffer */
 void git_buf_rtrim(git_buf *buf);
 
@@ -132,4 +151,7 @@ int git_buf_common_prefix(git_buf *buf, const git_strarray *strings);
 /* Check if buffer looks like it contains binary data */
 bool git_buf_is_binary(const git_buf *buf);
 
+/* Unescape all characters in a buffer */
+void git_buf_unescape(git_buf *buf);
+
 #endif

data/{ext/rugged/vendor/libgit2-dist → vendor/libgit2}/src/cache.c

@@ -11,6 +11,7 @@
 #include "thread-utils.h"
 #include "util.h"
 #include "cache.h"
+#include "git2/oid.h"
 
 int git_cache_init(git_cache *cache, size_t size, git_cached_obj_freeptr free_ptr)
 {

data/vendor/libgit2/src/checkout.c

@@ -0,0 +1,230 @@
+/*
+ * 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 <assert.h>
+
+#include "git2/checkout.h"
+#include "git2/repository.h"
+#include "git2/refs.h"
+#include "git2/tree.h"
+#include "git2/commit.h"
+#include "git2/blob.h"
+#include "git2/config.h"
+
+#include "common.h"
+#include "refs.h"
+#include "buffer.h"
+#include "repository.h"
+#include "filter.h"
+#include "blob.h"
+
+GIT_BEGIN_DECL
+
+
+typedef struct tree_walk_data
+{
+	git_indexer_stats *stats;
+	git_checkout_opts *opts;
+	git_repository *repo;
+	git_odb *odb;
+	bool do_symlinks;
+} tree_walk_data;
+
+
+static int blob_contents_to_link(tree_walk_data *data, git_buf *fnbuf,
+											const git_oid *id)
+{
+	int retcode = GIT_ERROR;
+	git_blob *blob;
+
+	/* Get the link target */
+	if (!(retcode = git_blob_lookup(&blob, data->repo, id))) {
+		git_buf linktarget = GIT_BUF_INIT;
+		if (!(retcode = git_blob__getbuf(&linktarget, blob))) {
+			/* Create the link */
+			const char *new = git_buf_cstr(&linktarget),
+						  *old = git_buf_cstr(fnbuf);
+			retcode = data->do_symlinks
+				? p_symlink(new, old)
+				: git_futils_fake_symlink(new, old);
+		}
+		git_buf_free(&linktarget);
+		git_blob_free(blob);
+	}
+
+	return retcode;
+}
+
+
+static int blob_contents_to_file(git_repository *repo, git_buf *fnbuf,
+											const git_tree_entry *entry, tree_walk_data *data)
+{
+	int retcode = GIT_ERROR;
+	int fd = -1;
+	git_buf contents = GIT_BUF_INIT;
+	const git_oid *id = git_tree_entry_id(entry);
+	int file_mode = data->opts->file_mode;
+
+	/* Deal with pre-existing files */
+	if (git_path_exists(git_buf_cstr(fnbuf)) &&
+		 data->opts->existing_file_action == GIT_CHECKOUT_SKIP_EXISTING)
+		return 0;
+
+	/* Allow disabling of filters */
+	if (data->opts->disable_filters) {
+		git_blob *blob;
+		if (!(retcode = git_blob_lookup(&blob, repo, id))) {
+			retcode = git_blob__getbuf(&contents, blob);
+			git_blob_free(blob);
+		}
+	} else {
+		retcode = git_filter_blob_contents(&contents, repo, id, git_buf_cstr(fnbuf));
+	}
+	if (retcode < 0) goto bctf_cleanup;
+
+	/* Allow overriding of file mode */
+	if (!file_mode)
+		file_mode = git_tree_entry_filemode(entry);
+
+	if ((retcode = git_futils_mkpath2file(git_buf_cstr(fnbuf), data->opts->dir_mode)) < 0)
+		goto bctf_cleanup;
+
+	fd = p_open(git_buf_cstr(fnbuf), data->opts->file_open_flags, file_mode);
+	if (fd < 0) goto bctf_cleanup;
+
+	if (!p_write(fd, git_buf_cstr(&contents), git_buf_len(&contents)))
+		retcode = 0;
+	else
+		retcode = GIT_ERROR;
+	p_close(fd);
+
+bctf_cleanup:
+	git_buf_free(&contents);
+	return retcode;
+}
+
+static int checkout_walker(const char *path, const git_tree_entry *entry, void *payload)
+{
+	int retcode = 0;
+	tree_walk_data *data = (tree_walk_data*)payload;
+	int attr = git_tree_entry_filemode(entry);
+	git_buf fnbuf = GIT_BUF_INIT;
+	git_buf_join_n(&fnbuf, '/', 3,
+						git_repository_workdir(data->repo),
+						path,
+						git_tree_entry_name(entry));
+
+	switch(git_tree_entry_type(entry))
+	{
+	case GIT_OBJ_TREE:
+		/* Nothing to do; the blob handling creates necessary directories. */
+		break;
+
+	case GIT_OBJ_COMMIT:
+		/* Submodule */
+		git_futils_mkpath2file(git_buf_cstr(&fnbuf), data->opts->dir_mode);
+		retcode = p_mkdir(git_buf_cstr(&fnbuf), data->opts->dir_mode);
+		break;
+
+	case GIT_OBJ_BLOB:
+		if (S_ISLNK(attr)) {
+			retcode = blob_contents_to_link(data, &fnbuf,
+													  git_tree_entry_id(entry));
+		} else {
+			retcode = blob_contents_to_file(data->repo, &fnbuf, entry, data);
+		}
+		break;
+
+	default:
+		retcode = -1;
+		break;
+	}
+
+	git_buf_free(&fnbuf);
+	data->stats->processed++;
+	return retcode;
+}
+
+
+int git_checkout_head(git_repository *repo, git_checkout_opts *opts, git_indexer_stats *stats)
+{
+	int retcode = GIT_ERROR;
+	git_indexer_stats dummy_stats;
+	git_checkout_opts default_opts = {0};
+	git_tree *tree;
+	tree_walk_data payload;
+	git_config *cfg;
+
+	assert(repo);
+	if (!opts) opts = &default_opts;
+	if (!stats) stats = &dummy_stats;
+
+	/* Default options */
+	if (!opts->existing_file_action)
+		opts->existing_file_action = GIT_CHECKOUT_OVERWRITE_EXISTING;
+	/* opts->disable_filters is false by default */
+	if (!opts->dir_mode) opts->dir_mode = GIT_DIR_MODE;
+	if (!opts->file_open_flags)
+		opts->file_open_flags = O_CREAT | O_TRUNC | O_WRONLY;
+
+	if (git_repository_is_bare(repo)) {
+		giterr_set(GITERR_INVALID, "Checkout is not allowed for bare repositories");
+		return GIT_ERROR;
+	}
+
+	/* Determine if symlinks should be handled */
+	if (!git_repository_config(&cfg, repo)) {
+		int temp = true;
+		if (!git_config_get_bool(&temp, cfg, "core.symlinks")) {
+			payload.do_symlinks = !!temp;
+		}
+		git_config_free(cfg);
+	}
+
+	stats->total = stats->processed = 0;
+	payload.stats = stats;
+	payload.opts = opts;
+	payload.repo = repo;
+	if (git_repository_odb(&payload.odb, repo) < 0) return GIT_ERROR;
+
+	if (!git_repository_head_tree(&tree, repo)) {
+		git_index *idx;
+		if (!(retcode = git_repository_index(&idx, repo))) {
+			if (!(retcode = git_index_read_tree(idx, tree, stats))) {
+				git_index_write(idx);
+				retcode = git_tree_walk(tree, checkout_walker, GIT_TREEWALK_POST, &payload);
+			}
+			git_index_free(idx);
+		}
+		git_tree_free(tree);
+	}
+
+	git_odb_free(payload.odb);
+	return retcode;
+}
+
+
+int git_checkout_reference(git_reference *ref,
+									git_checkout_opts *opts,
+									git_indexer_stats *stats)
+{
+	git_repository *repo= git_reference_owner(ref);
+	git_reference *head = NULL;
+	int retcode = GIT_ERROR;
+
+	if ((retcode = git_reference_create_symbolic(&head, repo, GIT_HEAD_FILE,
+																git_reference_name(ref), true)) < 0)
+		return retcode;
+
+	retcode = git_checkout_head(git_reference_owner(ref), opts, stats);
+
+	git_reference_free(head);
+	return retcode;
+}
+
+
+GIT_END_DECL

data/vendor/libgit2/src/clone.c

@@ -0,0 +1,254 @@
+/*
+ * 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 <assert.h>
+
+#ifndef GIT_WIN32
+#include <dirent.h>
+#endif
+
+#include "git2/clone.h"
+#include "git2/remote.h"
+#include "git2/revparse.h"
+#include "git2/branch.h"
+#include "git2/config.h"
+#include "git2/checkout.h"
+#include "git2/commit.h"
+#include "git2/tree.h"
+
+#include "common.h"
+#include "remote.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)
+{
+	git_object *head_obj = NULL;
+	git_reference *branch_ref;
+	int retcode = GIT_ERROR;
+
+	/* Find the target commit */
+	if (git_object_lookup(&head_obj, repo, target, GIT_OBJ_ANY) < 0)
+		return GIT_ERROR;
+
+	/* Create the new branch */
+	if (!git_branch_create(&branch_ref, repo, name, head_obj, 0)) {
+		git_config *cfg;
+
+		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;
+}
+
+static int reference_matches_remote_head(const char *head_name, void *payload)
+{
+	struct HeadInfo *head_info = (struct HeadInfo *)payload;
+	git_oid oid;
+
+	/* Stop looking if we've already found a match */
+	if (git_buf_len(&head_info->branchname) > 0) return 0;
+
+	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/"));
+	}
+	return 0;
+}
+
+static int update_head_to_new_branch(git_repository *repo, const git_oid *target, const char *name)
+{
+	int retcode = GIT_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);
+		}
+	}
+
+	return retcode;
+}
+
+static int update_head_to_remote(git_repository *repo, git_remote *remote)
+{
+	int retcode = GIT_ERROR;
+	git_remote_head *remote_head;
+	git_oid oid;
+	struct HeadInfo head_info;
+
+	/* Get the remote's HEAD. This is always the first ref in remote->refs. */
+	remote_head = remote->refs.contents[0];
+	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");
+	}
+	/* 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));
+	}
+
+	git_buf_free(&head_info.branchname);
+	return retcode;
+}
+
+/*
+ * submodules?
+ */
+
+
+
+static int setup_remotes_and_fetch(git_repository *repo,
+											  const char *origin_url,
+											  git_indexer_stats *fetch_stats)
+{
+	int retcode = GIT_ERROR;
+	git_remote *origin = NULL;
+	git_off_t bytes = 0;
+	git_indexer_stats dummy_stats;
+
+	if (!fetch_stats) fetch_stats = &dummy_stats;
+
+	/* Create the "origin" remote */
+	if (!git_remote_add(&origin, repo, "origin", origin_url)) {
+		/* Connect and download everything */
+		if (!git_remote_connect(origin, GIT_DIR_FETCH)) {
+			if (!git_remote_download(origin, &bytes, fetch_stats)) {
+				/* Create "origin/foo" branches for all remote branches */
+				if (!git_remote_update_tips(origin)) {
+					/* Point HEAD to the same ref as the remote's head */
+					if (!update_head_to_remote(repo, origin)) {
+						retcode = 0;
+					}
+				}
+			}
+			git_remote_disconnect(origin);
+		}
+		git_remote_free(origin);
+	}
+
+	return retcode;
+}
+
+
+static bool path_is_okay(const char *path)
+{
+	/* The path must either not exist, or be an empty directory */
+	if (!git_path_exists(path)) return true;
+	if (!git_path_is_empty_dir(path)) {
+		giterr_set(GITERR_INVALID,
+					  "'%s' exists and is not an empty directory", path);
+		return false;
+	}
+	return true;
+}
+
+
+static int clone_internal(git_repository **out,
+								  const char *origin_url,
+								  const char *path,
+								  git_indexer_stats *fetch_stats,
+								  int is_bare)
+{
+	int retcode = GIT_ERROR;
+	git_repository *repo = NULL;
+	git_indexer_stats dummy_stats;
+
+	if (!fetch_stats) fetch_stats = &dummy_stats;
+
+	if (!path_is_okay(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) {
+			/* Failed to fetch; clean up */
+			git_repository_free(repo);
+			git_futils_rmdir_r(path, GIT_DIRREMOVAL_FILES_AND_DIRS);
+		} else {
+			*out = repo;
+			retcode = 0;
+		}
+	}
+
+	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, 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)
+{
+	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;
+}
+
+
+
+
+GIT_END_DECL