rugged 0.25.0b5 → 0.25.0b6

data/vendor/libgit2/src/patch_parse.h

@@ -0,0 +1,54 @@
+/*
+ * 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_patch_parse_h__
+#define INCLUDE_patch_parse_h__
+
+typedef struct {
+	git_refcount rc;
+
+	/* Original content buffer */
+	const char *content;
+	size_t content_len;
+
+	git_patch_options opts;
+
+	/* The remaining (unparsed) buffer */
+	const char *remain;
+	size_t remain_len;
+
+	const char *line;
+	size_t line_len;
+	size_t line_num;
+} git_patch_parse_ctx;
+
+extern git_patch_parse_ctx *git_patch_parse_ctx_init(
+	const char *content,
+	size_t content_len,
+	const git_patch_options *opts);
+
+extern void git_patch_parse_ctx_free(git_patch_parse_ctx *ctx);
+
+/**
+ * Create a patch for a single file from the contents of a patch buffer.
+ *
+ * @param out The patch to be created
+ * @param contents The contents of a patch file
+ * @param contents_len The length of the patch file
+ * @param opts The git_patch_options
+ * @return 0 on success, <0 on failure.
+ */
+extern int git_patch_from_buffer(
+	git_patch **out,
+	const char *contents,
+	size_t contents_len,
+	const git_patch_options *opts);
+
+extern int git_patch_parse(
+	git_patch **out,
+	git_patch_parse_ctx *ctx);
+
+#endif

data/vendor/libgit2/src/path.c

@@ -306,6 +306,25 @@ int git_path_join_unrooted(
 	return 0;
 }
 
+void git_path_squash_slashes(git_buf *path)
+{
+	char *p, *q;
+
+	if (path->size == 0)
+		return;
+
+	for (p = path->ptr, q = path->ptr; *q; p++, q++) {
+		*p = *q;
+
+		while (*q == '/' && *(q+1) == '/') {
+			path->size--;
+			q++;
+		}
+	}
+
+	*p = '\0';
+}
+
 int git_path_prettify(git_buf *path_out, const char *path, const char *base)
 {
 	char buf[GIT_PATH_MAX];

data/vendor/libgit2/src/path.h

@@ -243,6 +243,12 @@ extern bool git_path_contains_file(git_buf *dir, const char *file);
 extern int git_path_join_unrooted(
 	git_buf *path_out, const char *path, const char *base, ssize_t *root_at);
 
+/**
+ * Removes multiple occurrences of '/' in a row, squashing them into a
+ * single '/'.
+ */
+extern void git_path_squash_slashes(git_buf *path);
+
 /**
  * Clean up path, prepending base if it is not already rooted.
  */

data/vendor/libgit2/src/pool.h

@@ -35,6 +35,8 @@ typedef struct {
 	uint32_t page_size;  /* size of page in bytes */
 } git_pool;
 
+#define GIT_POOL_INIT { NULL, 0, 0 }
+
 #else
 
 /**
@@ -57,6 +59,9 @@ typedef struct {
 	uint32_t item_size;
 	uint32_t page_size;
 } git_pool;
+
+#define GIT_POOL_INIT { GIT_VECTOR_INIT, 0, 0 }
+
 #endif
 
 /**

data/vendor/libgit2/src/remote.c

@@ -547,53 +547,6 @@ static int lookup_remote_prune_config(git_remote *remote, git_config *config, co
 	return error;
 }
 
-static int update_config_refspec(const git_remote *remote, git_config *config, int direction)
-{
-	git_buf name = GIT_BUF_INIT;
-	unsigned int push;
-	const char *dir;
-	size_t i;
-	int error = 0;
-	const char *cname;
-
-	push = direction == GIT_DIRECTION_PUSH;
-	dir = push ? "push" : "fetch";
-
-	if (git_buf_printf(&name, "remote.%s.%s", remote->name, dir) < 0)
-		return -1;
-	cname = git_buf_cstr(&name);
-
-	/* Clear out the existing config */
-	while (!error)
-		error = git_config_delete_multivar(config, cname, ".*");
-
-	if (error != GIT_ENOTFOUND)
-		return error;
-
-	for (i = 0; i < remote->refspecs.length; i++) {
-		git_refspec *spec = git_vector_get(&remote->refspecs, i);
-
-		if (spec->push != push)
-			continue;
-
-		// "$^" is a unmatcheable regexp: it will not match anything at all, so
-		// all values will be considered new and we will not replace any
-		// present value.
-		if ((error = git_config_set_multivar(
-				config, cname, "$^", spec->string)) < 0) {
-			goto cleanup;
-		}
-	}
-
-	giterr_clear();
-	error = 0;
-
-cleanup:
-	git_buf_free(&name);
-
-	return error;
-}
-
 const char *git_remote_name(const git_remote *remote)
 {
 	assert(remote);
@@ -1423,7 +1376,11 @@ static int update_tips_for_spec(
 		/* In autotag mode, don't overwrite any locally-existing tags */
 		error = git_reference_create(&ref, remote->repo, refname.ptr, &head->oid, !autotag, 
 				log_message);
-		if (error < 0 && error != GIT_EEXISTS)
+
+		if (error == GIT_EEXISTS)
+			continue;
+
+		if (error < 0)
 			goto on_error;
 
 		git_reference_free(ref);
@@ -2099,34 +2056,6 @@ int git_remote_add_push(git_repository *repo, const char *remote, const char *re
 	return write_add_refspec(repo, remote, refspec, false);
 }
 
-static int set_refspecs(git_remote *remote, git_strarray *array, int push)
-{
-	git_vector *vec = &remote->refspecs;
-	git_refspec *spec;
-	size_t i;
-
-	/* Start by removing any refspecs of the same type */
-	for (i = 0; i < vec->length; i++) {
-		spec = git_vector_get(vec, i);
-		if (spec->push != push)
-			continue;
-
-		git_refspec__free(spec);
-		git__free(spec);
-		git_vector_remove(vec, i);
-		i--;
-	}
-
-	/* And now we add the new ones */
-
-	for (i = 0; i < array->count; i++) {
-		if (add_refspec(remote, array->strings[i], !push) < 0)
-			return -1;
-	}
-
-	return 0;
-}
-
 static int copy_refspecs(git_strarray *array, const git_remote *remote, unsigned int push)
 {
 	size_t i;
@@ -2233,15 +2162,21 @@ static int remove_branch_config_related_entries(
 		if (git_buf_printf(&buf, "branch.%.*s.merge", (int)branch_len, branch) < 0)
 			break;
 
-		if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0)
-			break;
+		if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0) {
+			if (error != GIT_ENOTFOUND)
+				break;
+			giterr_clear();
+		}
 
 		git_buf_clear(&buf);
 		if (git_buf_printf(&buf, "branch.%.*s.remote", (int)branch_len, branch) < 0)
 			break;
 
-		if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0)
-			break;
+		if ((error = git_config_delete_entry(config, git_buf_cstr(&buf))) < 0) {
+			if (error != GIT_ENOTFOUND)
+				break;
+			giterr_clear();
+		}
 	}
 
 	if (error == GIT_ITEROVER)

data/vendor/libgit2/src/repository.c

@@ -264,7 +264,7 @@ cleanup:
  * the stack could remove directories name limits, but at the cost of doing
  * repeated malloc/frees inside the loop below, so let's not do it now.
  */
-static int find_ceiling_dir_offset(
+static size_t find_ceiling_dir_offset(
 	const char *path,
 	const char *ceiling_directories)
 {
@@ -278,7 +278,7 @@ static int find_ceiling_dir_offset(
 	min_len = (size_t)(git_path_root(path) + 1);
 
 	if (ceiling_directories == NULL || min_len == 0)
-		return (int)min_len;
+		return min_len;
 
 	for (sep = ceil = ceiling_directories; *sep; ceil = sep + 1) {
 		for (sep = ceil; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++);
@@ -305,7 +305,7 @@ static int find_ceiling_dir_offset(
 		}
 	}
 
-	return (int)(max_len <= min_len ? min_len : max_len);
+	return (max_len <= min_len ? min_len : max_len);
 }
 
 /*
@@ -357,29 +357,50 @@ static int find_repo(
 {
 	int error;
 	git_buf path = GIT_BUF_INIT;
+	git_buf repo_link = GIT_BUF_INIT;
 	struct stat st;
 	dev_t initial_device = 0;
-	bool try_with_dot_git = ((flags & GIT_REPOSITORY_OPEN_BARE) != 0);
-	int ceiling_offset;
+	int min_iterations;
+	bool in_dot_git;
+	size_t ceiling_offset = 0;
 
 	git_buf_free(repo_path);
 
-	if ((error = git_path_prettify(&path, start_path, NULL)) < 0)
+	error = git_path_prettify(&path, start_path, NULL);
+	if (error < 0)
 		return error;
 
-	ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);
+	/* in_dot_git toggles each loop:
+	 * /a/b/c/.git, /a/b/c, /a/b/.git, /a/b, /a/.git, /a
+	 * With GIT_REPOSITORY_OPEN_BARE or GIT_REPOSITORY_OPEN_NO_DOTGIT, we
+	 * assume we started with /a/b/c.git and don't append .git the first
+	 * time through.
+	 * min_iterations indicates the number of iterations left before going
+	 * further counts as a search. */
+	if (flags & (GIT_REPOSITORY_OPEN_BARE | GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
+		in_dot_git = true;
+		min_iterations = 1;
+	} else {
+		in_dot_git = false;
+		min_iterations = 2;
+	}
 
-	if (!try_with_dot_git &&
-		(error = git_buf_joinpath(&path, path.ptr, DOT_GIT)) < 0)
-		return error;
+	for (;;) {
+		if (!(flags & GIT_REPOSITORY_OPEN_NO_DOTGIT)) {
+			if (!in_dot_git) {
+				error = git_buf_joinpath(&path, path.ptr, DOT_GIT);
+				if (error < 0)
+					break;
+			}
+			in_dot_git = !in_dot_git;
+		}
 
-	while (!error && !git_buf_len(repo_path)) {
 		if (p_stat(path.ptr, &st) == 0) {
 			/* check that we have not crossed device boundaries */
 			if (initial_device == 0)
 				initial_device = st.st_dev;
 			else if (st.st_dev != initial_device &&
-				(flags & GIT_REPOSITORY_OPEN_CROSS_FS) == 0)
+				 !(flags & GIT_REPOSITORY_OPEN_CROSS_FS))
 				break;
 
 			if (S_ISDIR(st.st_mode)) {
@@ -390,41 +411,37 @@ static int find_repo(
 				}
 			}
 			else if (S_ISREG(st.st_mode)) {
-				git_buf repo_link = GIT_BUF_INIT;
-
-				if (!(error = read_gitfile(&repo_link, path.ptr))) {
-					if (valid_repository_path(&repo_link)) {
-						git_buf_swap(repo_path, &repo_link);
-
-						if (link_path)
-							error = git_buf_put(link_path, 
-								path.ptr, path.size);
-					}
-
-					git_buf_free(&repo_link);
+				error = read_gitfile(&repo_link, path.ptr);
+				if (error < 0)
 					break;
+				if (valid_repository_path(&repo_link)) {
+					git_buf_swap(repo_path, &repo_link);
+
+					if (link_path)
+						error = git_buf_put(link_path, path.ptr, path.size);
 				}
-				git_buf_free(&repo_link);
+				break;
 			}
 		}
 
-		/* move up one directory level */
+		/* Move up one directory. If we're in_dot_git, we'll search the
+		 * parent itself next. If we're !in_dot_git, we'll search .git
+		 * in the parent directory next (added at the top of the loop). */
 		if (git_path_dirname_r(&path, path.ptr) < 0) {
 			error = -1;
 			break;
 		}
 
-		if (try_with_dot_git) {
-			/* if we tried original dir with and without .git AND either hit
-			 * directory ceiling or NO_SEARCH was requested, then be done.
-			 */
-			if (path.ptr[ceiling_offset] == '\0' ||
-				(flags & GIT_REPOSITORY_OPEN_NO_SEARCH) != 0)
-				break;
-			/* otherwise look first for .git item */
-			error = git_buf_joinpath(&path, path.ptr, DOT_GIT);
-		}
-		try_with_dot_git = !try_with_dot_git;
+		/* Once we've checked the directory (and .git if applicable),
+		 * find the ceiling for a search. */
+		if (min_iterations && (--min_iterations == 0))
+			ceiling_offset = find_ceiling_dir_offset(path.ptr, ceiling_dirs);
+
+		/* Check if we should stop searching here. */
+		if (min_iterations == 0
+		    && (path.ptr[ceiling_offset] == 0
+			|| (flags & GIT_REPOSITORY_OPEN_NO_SEARCH)))
+			break;
 	}
 
 	if (!error && parent_path && !(flags & GIT_REPOSITORY_OPEN_BARE)) {
@@ -438,14 +455,16 @@ static int find_repo(
 			return -1;
 	}
 
-	git_buf_free(&path);
-
+	/* If we didn't find the repository, and we don't have any other error
+	 * to report, report that. */
 	if (!git_buf_len(repo_path) && !error) {
 		giterr_set(GITERR_REPOSITORY,
 			"Could not find repository from '%s'", start_path);
 		error = GIT_ENOTFOUND;
 	}
 
+	git_buf_free(&path);
+	git_buf_free(&repo_link);
 	return error;
 }
 
@@ -480,6 +499,172 @@ int git_repository_open_bare(
 	return 0;
 }
 
+static int _git_repository_open_ext_from_env(
+	git_repository **out,
+	const char *start_path)
+{
+	git_repository *repo = NULL;
+	git_index *index = NULL;
+	git_odb *odb = NULL;
+	git_buf dir_buf = GIT_BUF_INIT;
+	git_buf ceiling_dirs_buf = GIT_BUF_INIT;
+	git_buf across_fs_buf = GIT_BUF_INIT;
+	git_buf index_file_buf = GIT_BUF_INIT;
+	git_buf namespace_buf = GIT_BUF_INIT;
+	git_buf object_dir_buf = GIT_BUF_INIT;
+	git_buf alts_buf = GIT_BUF_INIT;
+	git_buf work_tree_buf = GIT_BUF_INIT;
+	git_buf common_dir_buf = GIT_BUF_INIT;
+	const char *ceiling_dirs = NULL;
+	unsigned flags = 0;
+	int error;
+
+	if (!start_path) {
+		error = git__getenv(&dir_buf, "GIT_DIR");
+		if (error == GIT_ENOTFOUND) {
+			giterr_clear();
+			start_path = ".";
+		} else if (error < 0)
+			goto error;
+		else {
+			start_path = git_buf_cstr(&dir_buf);
+			flags |= GIT_REPOSITORY_OPEN_NO_SEARCH;
+			flags |= GIT_REPOSITORY_OPEN_NO_DOTGIT;
+		}
+	}
+
+	error = git__getenv(&ceiling_dirs_buf, "GIT_CEILING_DIRECTORIES");
+	if (error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0)
+		goto error;
+	else
+		ceiling_dirs = git_buf_cstr(&ceiling_dirs_buf);
+
+	error = git__getenv(&across_fs_buf, "GIT_DISCOVERY_ACROSS_FILESYSTEM");
+	if (error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0)
+		goto error;
+	else {
+		int across_fs = 0;
+		error = git_config_parse_bool(&across_fs, git_buf_cstr(&across_fs_buf));
+		if (error < 0)
+			goto error;
+		if (across_fs)
+			flags |= GIT_REPOSITORY_OPEN_CROSS_FS;
+	}
+
+	error = git__getenv(&index_file_buf, "GIT_INDEX_FILE");
+	if (error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0)
+		goto error;
+	else {
+		error = git_index_open(&index, git_buf_cstr(&index_file_buf));
+		if (error < 0)
+			goto error;
+	}
+
+	error = git__getenv(&namespace_buf, "GIT_NAMESPACE");
+	if (error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0)
+		goto error;
+
+	error = git__getenv(&object_dir_buf, "GIT_OBJECT_DIRECTORY");
+	if (error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0)
+		goto error;
+	else {
+		error = git_odb_open(&odb, git_buf_cstr(&object_dir_buf));
+		if (error < 0)
+			goto error;
+	}
+
+	error = git__getenv(&work_tree_buf, "GIT_WORK_TREE");
+	if (error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0)
+		goto error;
+	else {
+		giterr_set(GITERR_INVALID, "GIT_WORK_TREE unimplemented");
+		error = GIT_ERROR;
+		goto error;
+	}
+
+	error = git__getenv(&work_tree_buf, "GIT_COMMON_DIR");
+	if (error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0)
+		goto error;
+	else {
+		giterr_set(GITERR_INVALID, "GIT_COMMON_DIR unimplemented");
+		error = GIT_ERROR;
+		goto error;
+	}
+
+	error = git_repository_open_ext(&repo, start_path, flags, ceiling_dirs);
+	if (error < 0)
+		goto error;
+
+	if (odb)
+		git_repository_set_odb(repo, odb);
+
+	error = git__getenv(&alts_buf, "GIT_ALTERNATE_OBJECT_DIRECTORIES");
+	if (error == GIT_ENOTFOUND)
+		giterr_clear();
+	else if (error < 0)
+		goto error;
+        else {
+		const char *end;
+		char *alt, *sep;
+		if (!odb) {
+			error = git_repository_odb(&odb, repo);
+			if (error < 0)
+				goto error;
+		}
+
+		end = git_buf_cstr(&alts_buf) + git_buf_len(&alts_buf);
+		for (sep = alt = alts_buf.ptr; sep != end; alt = sep+1) {
+			for (sep = alt; *sep && *sep != GIT_PATH_LIST_SEPARATOR; sep++)
+				;
+			if (*sep)
+				*sep = '\0';
+			error = git_odb_add_disk_alternate(odb, alt);
+			if (error < 0)
+				goto error;
+		}
+	}
+
+	error = git_repository_set_namespace(repo, git_buf_cstr(&namespace_buf));
+	if (error < 0)
+		goto error;
+
+	git_repository_set_index(repo, index);
+
+	if (out) {
+		*out = repo;
+		goto success;
+	}
+error:
+	git_repository_free(repo);
+success:
+	git_odb_free(odb);
+	git_index_free(index);
+	git_buf_free(&common_dir_buf);
+	git_buf_free(&work_tree_buf);
+	git_buf_free(&alts_buf);
+	git_buf_free(&object_dir_buf);
+	git_buf_free(&namespace_buf);
+	git_buf_free(&index_file_buf);
+	git_buf_free(&across_fs_buf);
+	git_buf_free(&ceiling_dirs_buf);
+	git_buf_free(&dir_buf);
+	return error;
+}
+
 int git_repository_open_ext(
 	git_repository **repo_ptr,
 	const char *start_path,
@@ -492,6 +677,9 @@ int git_repository_open_ext(
 	git_repository *repo;
 	git_config *config = NULL;
 
+	if (flags & GIT_REPOSITORY_OPEN_FROM_ENV)
+		return _git_repository_open_ext_from_env(repo_ptr, start_path);
+
 	if (repo_ptr)
 		*repo_ptr = NULL;