rugged 0.23.0b2 → 0.23.0b4

data/vendor/libgit2/src/checkout.c

@@ -150,6 +150,15 @@ static int checkout_notify(
 	}
 }
 
+GIT_INLINE(bool) is_workdir_base_or_new(
+	const git_oid *workdir_id,
+	const git_diff_file *baseitem,
+	const git_diff_file *newitem)
+{
+	return (git_oid__cmp(&baseitem->id, workdir_id) == 0 ||
+		git_oid__cmp(&newitem->id, workdir_id) == 0);
+}
+
 static bool checkout_is_workdir_modified(
 	checkout_data *data,
 	const git_diff_file *baseitem,
@@ -171,7 +180,7 @@ static bool checkout_is_workdir_modified(
 			return true;
 		}
 
-		if (git_submodule_status(&sm_status, sm) < 0 ||
+		if (git_submodule_status(&sm_status, data->repo, wditem->path, GIT_SUBMODULE_IGNORE_UNSPECIFIED) < 0 ||
 			GIT_SUBMODULE_STATUS_IS_WD_DIRTY(sm_status))
 			rval = true;
 		else if ((sm_oid = git_submodule_wd_id(sm)) == NULL)
@@ -193,8 +202,7 @@ static bool checkout_is_workdir_modified(
 		if (wditem->mtime.seconds == ie->mtime.seconds &&
 			wditem->mtime.nanoseconds == ie->mtime.nanoseconds &&
 			wditem->file_size == ie->file_size)
-			return (git_oid__cmp(&baseitem->id, &ie->id) != 0 &&
-				git_oid_cmp(&newitem->id, &ie->id) != 0);
+			return !is_workdir_base_or_new(&ie->id, baseitem, newitem);
 	}
 
 	/* depending on where base is coming from, we may or may not know
@@ -203,10 +211,13 @@ static bool checkout_is_workdir_modified(
 	if (baseitem->size && wditem->file_size != baseitem->size)
 		return true;
 
-	if (git_diff__oid_for_entry(&oid, data->diff, wditem, NULL) < 0)
+	if (git_diff__oid_for_entry(&oid, data->diff, wditem, wditem->mode, NULL) < 0)
 		return false;
 
-	return (git_oid__cmp(&baseitem->id, &oid) != 0);
+	/* Allow the checkout if the workdir is not modified *or* if the checkout
+	 * target's contents are already in the working directory.
+	 */
+	return !is_workdir_base_or_new(&oid, baseitem, newitem);
 }
 
 #define CHECKOUT_ACTION_IF(FLAG,YES,NO) \
@@ -1292,7 +1303,7 @@ static int checkout_get_actions(
 			(int)counts[CHECKOUT_ACTION__CONFLICT],
 			counts[CHECKOUT_ACTION__CONFLICT] == 1 ?
 			"conflict prevents" : "conflicts prevent");
-		error = GIT_EMERGECONFLICT;
+		error = GIT_ECONFLICT;
 		goto fail;
 	}
 
@@ -1849,11 +1860,6 @@ static int checkout_create_submodules(
 	git_diff_delta *delta;
 	size_t i;
 
-	/* initial reload of submodules if .gitmodules was changed */
-	if (data->reload_submodules &&
-		(error = git_submodule_reload_all(data->repo, 1)) < 0)
-		return error;
-
 	git_vector_foreach(&data->diff->deltas, i, delta) {
 		if (actions[i] & CHECKOUT_ACTION__DEFER_REMOVE) {
 			/* this has a blocker directory that should only be removed iff
@@ -1874,8 +1880,7 @@ static int checkout_create_submodules(
 		}
 	}
 
-	/* final reload once submodules have been updated */
-	return git_submodule_reload_all(data->repo, 1);
+	return 0;
 }
 
 static int checkout_lookup_head_tree(git_tree **out, git_repository *repo)
@@ -2062,7 +2067,7 @@ static int checkout_write_merge(
 
 	if (result.path == NULL || result.mode == 0) {
 		giterr_set(GITERR_CHECKOUT, "Could not merge contents of file");
-		error = GIT_EMERGECONFLICT;
+		error = GIT_ECONFLICT;
 		goto done;
 	}
 
@@ -2357,7 +2362,7 @@ static int checkout_data_init(
 			/* cannot checkout if unresolved conflicts exist */
 			if ((data->opts.checkout_strategy & GIT_CHECKOUT_FORCE) == 0 &&
 				git_index_has_conflicts(data->index)) {
-				error = GIT_EMERGECONFLICT;
+				error = GIT_ECONFLICT;
 				giterr_set(GITERR_CHECKOUT,
 					"unresolved conflicts exist in the index");
 				goto cleanup;
@@ -2397,7 +2402,7 @@ static int checkout_data_init(
 			 &data->can_symlink, repo, GIT_CVAR_SYMLINKS)) < 0)
 		goto cleanup;
 
-	if (!data->opts.baseline) {
+	if (!data->opts.baseline && !data->opts.baseline_index) {
 		data->opts_free_baseline = true;
 
 		error = checkout_lookup_head_tree(&data->opts.baseline, repo);
@@ -2501,12 +2506,21 @@ int git_checkout_iterator(
 		(error = git_iterator_for_workdir_ext(
 			&workdir, data.repo, data.opts.target_directory, index, NULL,
 			iterflags | GIT_ITERATOR_DONT_AUTOEXPAND,
-			data.pfx, data.pfx)) < 0 ||
-		(error = git_iterator_for_tree(
-			&baseline, data.opts.baseline,
-			iterflags, data.pfx, data.pfx)) < 0)
+			data.pfx, data.pfx)) < 0)
 		goto cleanup;
 
+	if (data.opts.baseline_index) {
+		if ((error = git_iterator_for_index(
+				&baseline, data.opts.baseline_index,
+				iterflags, data.pfx, data.pfx)) < 0)
+			goto cleanup;
+	} else {
+		if ((error = git_iterator_for_tree(
+				&baseline, data.opts.baseline,
+				iterflags, data.pfx, data.pfx)) < 0)
+			goto cleanup;
+	}
+
 	/* Should not have case insensitivity mismatch */
 	assert(git_iterator_ignore_case(workdir) == git_iterator_ignore_case(baseline));
 

data/vendor/libgit2/src/clone.c

@@ -24,7 +24,7 @@
 #include "repository.h"
 #include "odb.h"
 
-static int clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link);
+static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link);
 
 static int create_branch(
 	git_reference **branch,
@@ -242,13 +242,9 @@ static int default_remote_create(
 		const char *url,
 		void *payload)
 {
-	int error;
-	git_remote_callbacks *callbacks = payload;
-
-	if ((error = git_remote_create(out, repo, name, url)) < 0)
-		return error;
+	GIT_UNUSED(payload);
 
-	return git_remote_set_callbacks(*out, callbacks);
+	return git_remote_create(out, repo, name, url);
 }
 
 /*
@@ -277,15 +273,12 @@ static int create_and_configure_origin(
 
 	if (!remote_create) {
 		remote_create = default_remote_create;
-		payload = (void *)&options->remote_callbacks;
+		payload = NULL;
 	}
 
 	if ((error = remote_create(&origin, repo, "origin", url, payload)) < 0)
 		goto on_error;
 
-	if ((error = git_remote_save(origin)) < 0)
-		goto on_error;
-
 	*out = origin;
 	return 0;
 
@@ -328,12 +321,12 @@ static int checkout_branch(git_repository *repo, git_remote *remote, const git_c
 	return error;
 }
 
-static int clone_into(git_repository *repo, git_remote *_remote, const git_checkout_options *co_opts, const char *branch)
+static int clone_into(git_repository *repo, git_remote *_remote, const git_fetch_options *opts, const git_checkout_options *co_opts, const char *branch)
 {
 	int error;
 	git_buf reflog_message = GIT_BUF_INIT;
+	git_fetch_options fetch_opts;
 	git_remote *remote;
-	const git_remote_callbacks *callbacks;
 
 	assert(repo && _remote);
 
@@ -345,18 +338,12 @@ static int clone_into(git_repository *repo, git_remote *_remote, const git_check
 	if ((error = git_remote_dup(&remote, _remote)) < 0)
 		return error;
 
-	callbacks = git_remote_get_callbacks(_remote);
-	if (!giterr__check_version(callbacks, 1, "git_remote_callbacks") &&
-	    (error = git_remote_set_callbacks(remote, callbacks)) < 0)
-		goto cleanup;
-
-	if ((error = git_remote_add_fetch(remote, "refs/tags/*:refs/tags/*")) < 0)
-		goto cleanup;
-
-	git_remote_set_update_fetchhead(remote, 0);
+	memcpy(&fetch_opts, opts, sizeof(git_fetch_options));
+	fetch_opts.update_fetchhead = 0;
+	fetch_opts.download_tags = GIT_REMOTE_DOWNLOAD_TAGS_ALL;
 	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
 
-	if ((error = git_remote_fetch(remote, NULL, git_buf_cstr(&reflog_message))) != 0)
+	if ((error = git_remote_fetch(remote, NULL, &fetch_opts, git_buf_cstr(&reflog_message))) != 0)
 		goto cleanup;
 
 	error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));
@@ -439,11 +426,11 @@ int git_clone(
 
 		if (clone_local == 1)
 			error = clone_local_into(
-				repo, origin, &options.checkout_opts,
+				repo, origin, &options.fetch_opts, &options.checkout_opts,
 				options.checkout_branch, link);
 		else if (clone_local == 0)
 			error = clone_into(
-				repo, origin, &options.checkout_opts,
+				repo, origin, &options.fetch_opts, &options.checkout_opts,
 				options.checkout_branch);
 		else
 			error = -1;
@@ -506,7 +493,7 @@ static bool can_link(const char *src, const char *dst, int link)
 #endif
 }
 
-static int clone_local_into(git_repository *repo, git_remote *remote, const git_checkout_options *co_opts, const char *branch, int link)
+static int clone_local_into(git_repository *repo, git_remote *remote, const git_fetch_options *fetch_opts, const git_checkout_options *co_opts, const char *branch, int link)
 {
 	int error, flags;
 	git_repository *src;
@@ -545,13 +532,26 @@ static int clone_local_into(git_repository *repo, git_remote *remote, const git_
 	if (can_link(git_repository_path(src), git_repository_path(repo), link))
 		flags |= GIT_CPDIR_LINK_FILES;
 
-	if ((error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
-				     flags, GIT_OBJECT_DIR_MODE)) < 0)
+	error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
+				flags, GIT_OBJECT_DIR_MODE);
+
+	/*
+	 * can_link() doesn't catch all variations, so if we hit an
+	 * error and did want to link, let's try again without trying
+	 * to link.
+	 */
+	if (error < 0 && link) {
+		flags &= ~GIT_CPDIR_LINK_FILES;
+		error = git_futils_cp_r(git_buf_cstr(&src_odb), git_buf_cstr(&dst_odb),
+					flags, GIT_OBJECT_DIR_MODE);
+	}
+
+	if (error < 0)
 		goto cleanup;
 
 	git_buf_printf(&reflog_message, "clone: from %s", git_remote_url(remote));
 
-	if ((error = git_remote_fetch(remote, NULL, git_buf_cstr(&reflog_message))) != 0)
+	if ((error = git_remote_fetch(remote, NULL, fetch_opts, git_buf_cstr(&reflog_message))) != 0)
 		goto cleanup;
 
 	error = checkout_branch(repo, remote, co_opts, branch, git_buf_cstr(&reflog_message));

data/vendor/libgit2/src/commit.c

@@ -309,6 +309,7 @@ int git_commit__parse(void *_commit, git_odb_object *odb_obj)
 	const char *buffer_end = buffer_start + git_odb_object_size(odb_obj);
 	git_oid parent_id;
 	size_t header_len;
+	git_signature dummy_sig;
 
 	buffer = buffer_start;
 
@@ -337,6 +338,15 @@ int git_commit__parse(void *_commit, git_odb_object *odb_obj)
 	if (git_signature__parse(commit->author, &buffer, buffer_end, "author ", '\n') < 0)
 		return -1;
 
+	/* Some tools create multiple author fields, ignore the extra ones */
+	while ((size_t)(buffer_end - buffer) >= strlen("author ") && !git__prefixcmp(buffer, "author ")) {
+		if (git_signature__parse(&dummy_sig, &buffer, buffer_end, "author ", '\n') < 0)
+			return -1;
+
+		git__free(dummy_sig.name);
+		git__free(dummy_sig.email);
+	}
+
 	/* Always parse the committer; we need the commit time */
 	commit->committer = git__malloc(sizeof(git_signature));
 	GITERR_CHECK_ALLOC(commit->committer);
@@ -508,3 +518,58 @@ int git_commit_nth_gen_ancestor(
 	*ancestor = parent;
 	return 0;
 }
+
+int git_commit_header_field(git_buf *out, const git_commit *commit, const char *field)
+{
+	const char *buf = commit->raw_header;
+	const char *h, *eol;
+
+	git_buf_sanitize(out);
+	while ((h = strchr(buf, '\n')) && h[1] != '\0' && h[1] != '\n') {
+		h++;
+		if (git__prefixcmp(h, field)) {
+			buf = h;
+			continue;
+		}
+
+		h += strlen(field);
+		eol = strchr(h, '\n');
+		if (h[0] != ' ') {
+			buf = h;
+			continue;
+		}
+		if (!eol)
+			goto malformed;
+
+		h++; /* skip the SP */
+
+		git_buf_put(out, h, eol - h);
+		if (git_buf_oom(out))
+			goto oom;
+
+		/* If the next line starts with SP, it's multi-line, we must continue */
+		while (eol[1] == ' ') {
+			git_buf_putc(out, '\n');
+			h = eol + 2;
+			eol = strchr(h, '\n');
+			if (!eol)
+				goto malformed;
+
+			git_buf_put(out, h, eol - h);
+		}
+
+		if (git_buf_oom(out))
+			goto oom;
+
+		return 0;
+	}
+
+	return GIT_ENOTFOUND;
+
+malformed:
+	giterr_set(GITERR_OBJECT, "malformed header");
+	return -1;
+oom:
+	giterr_set_oom();
+	return -1;
+}

data/vendor/libgit2/src/common.h

@@ -68,6 +68,11 @@
 
 #include <regex.h>
 
+#define DEFAULT_BUFSIZE 65536
+#define FILEIO_BUFSIZE DEFAULT_BUFSIZE
+#define FILTERIO_BUFSIZE DEFAULT_BUFSIZE
+#define NETIO_BUFSIZE DEFAULT_BUFSIZE
+
 /**
  * Check a pointer allocation result, returning -1 if it failed.
  */

data/vendor/libgit2/src/config.c

@@ -1194,6 +1194,26 @@ fail_parse:
 	return -1;
 }
 
+int git_config_lookup_map_enum(git_cvar_t *type_out, const char **str_out,
+			       const git_cvar_map *maps, size_t map_n, int enum_val)
+{
+	size_t i;
+
+	for (i = 0; i < map_n; i++) {
+		const git_cvar_map *m = &maps[i];
+
+		if (m->map_value != enum_val)
+			continue;
+
+		*type_out = m->cvar_type;
+		*str_out = m->str_match;
+		return 0;
+	}
+
+	giterr_set(GITERR_CONFIG, "invalid enum value");
+	return GIT_ENOTFOUND;
+}
+
 int git_config_parse_bool(int *out, const char *value)
 {
 	if (git__parse_bool(out, value) == 0)

data/vendor/libgit2/src/config.h

@@ -82,4 +82,10 @@ extern int git_config__get_int_force(
 extern int git_config__cvar(
 	int *out, git_config *config, git_cvar_cached cvar);
 
+/**
+ * The opposite of git_config_lookup_map_value, we take an enum value
+ * and map it to the string or bool value on the config.
+ */
+int git_config_lookup_map_enum(git_cvar_t *type_out, const char **str_out,
+			       const git_cvar_map *maps, size_t map_n, int enum_val);
 #endif

data/vendor/libgit2/src/config_file.c

@@ -156,7 +156,7 @@ int git_config_file_normalize_section(char *start, char *end)
 		if (end && scan >= end)
 			break;
 		if (isalnum(*scan))
-			*scan = (char)tolower(*scan);
+			*scan = (char)git__tolower(*scan);
 		else if (*scan != '-' || scan == start)
 			return GIT_EINVALIDSPEC;
 	}
@@ -1083,7 +1083,7 @@ static int parse_section_header(struct reader *reader, char **section_out)
 			goto fail_parse;
 		}
 
-		name[name_length++] = (char) tolower(c);
+		name[name_length++] = (char)git__tolower(c);
 
 	} while ((c = line[pos++]) != ']');
 

data/vendor/libgit2/src/crlf.c

@@ -193,28 +193,29 @@ static const char *line_ending(struct crlf_attrs *ca)
 	case GIT_CRLF_CRLF:
 		return "\r\n";
 
+	case GIT_CRLF_GUESS:
+		if (ca->auto_crlf == GIT_AUTO_CRLF_FALSE)
+			return "\n";
+		break;
+
 	case GIT_CRLF_AUTO:
 	case GIT_CRLF_TEXT:
-	case GIT_CRLF_GUESS:
 		break;
 
 	default:
 		goto line_ending_error;
 	}
 
-	switch (ca->eol) {
-	case GIT_EOL_UNSET:
-		return GIT_EOL_NATIVE == GIT_EOL_CRLF ? "\r\n" : "\n";
-
-	case GIT_EOL_CRLF:
+	if (ca->auto_crlf == GIT_AUTO_CRLF_TRUE)
 		return "\r\n";
-
-	case GIT_EOL_LF:
+	else if (ca->auto_crlf == GIT_AUTO_CRLF_INPUT)
 		return "\n";
-
-	default:
-		goto line_ending_error;
-	}
+	else if (ca->eol == GIT_EOL_UNSET)
+		return GIT_EOL_NATIVE == GIT_EOL_CRLF ? "\r\n" : "\n";
+	else if (ca->eol == GIT_EOL_LF)
+		return "\n";
+	else if (ca->eol == GIT_EOL_CRLF)
+		return "\r\n";
 
 line_ending_error:
 	giterr_set(GITERR_INVALID, "Invalid input to line ending filter");
@@ -224,16 +225,14 @@ line_ending_error:
 static int crlf_apply_to_workdir(
 	struct crlf_attrs *ca, git_buf *to, const git_buf *from)
 {
+	git_buf_text_stats stats;
 	const char *workdir_ending = NULL;
+	bool is_binary;
 
 	/* Empty file? Nothing to do. */
 	if (git_buf_len(from) == 0)
 		return 0;
 
-	/* Don't filter binary files */
-	if (git_buf_text_is_binary(from))
-		return GIT_PASSTHROUGH;
-
 	/* Determine proper line ending */
 	workdir_ending = line_ending(ca);
 	if (!workdir_ending)
@@ -243,6 +242,29 @@ static int crlf_apply_to_workdir(
 	if (strcmp(workdir_ending, "\r\n") != 0)
 		return GIT_PASSTHROUGH;
 
+	/* If there are no LFs, or all LFs are part of a CRLF, nothing to do */
+	is_binary = git_buf_text_gather_stats(&stats, from, false);
+
+	if (stats.lf == 0 || stats.lf == stats.crlf)
+		return GIT_PASSTHROUGH;
+
+	if (ca->crlf_action == GIT_CRLF_AUTO ||
+		ca->crlf_action == GIT_CRLF_GUESS) {
+
+		/* If we have any existing CR or CRLF line endings, do nothing */
+		if (ca->crlf_action == GIT_CRLF_GUESS &&
+			stats.cr > 0 && stats.crlf > 0)
+			return GIT_PASSTHROUGH;
+
+		/* If we have bare CR characters, do nothing */
+		if (stats.cr != stats.crlf)
+			return GIT_PASSTHROUGH;
+
+		/* Don't filter binary files */
+		if (is_binary)
+			return GIT_PASSTHROUGH;
+	}
+
 	return git_buf_text_lf_to_crlf(to, from);
 }
 
@@ -278,7 +300,7 @@ static int crlf_check(
 		return GIT_PASSTHROUGH;
 
 	if (ca.crlf_action == GIT_CRLF_GUESS ||
-		(ca.crlf_action == GIT_CRLF_AUTO &&
+		((ca.crlf_action == GIT_CRLF_AUTO || ca.crlf_action == GIT_CRLF_TEXT) &&
 		git_filter_source_mode(src) == GIT_FILTER_SMUDGE)) {
 
 		error = git_repository__cvar(