rugged 0.17.0b2 → 0.17.0.b6

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

@@ -93,7 +93,7 @@ int git_commit_create(
 		int parent_count,
 		const git_commit *parents[])
 {
-	git_buf commit = GIT_BUF_INIT, cleaned_message = GIT_BUF_INIT;
+	git_buf commit = GIT_BUF_INIT;
 	int i;
 	git_odb *odb;
 
@@ -114,15 +114,9 @@ int git_commit_create(
 
 	git_buf_putc(&commit, '\n');
 
-	/* Remove comments by default */
-	if (git_message_prettify(&cleaned_message, message, 1) < 0)
+	if (git_buf_puts(&commit, message) < 0)
 		goto on_error;
 
-	if (git_buf_puts(&commit, git_buf_cstr(&cleaned_message)) < 0)
-		goto on_error;
-
-	git_buf_free(&cleaned_message);
-
 	if (git_repository_odb__weakptr(&odb, repo) < 0)
 		goto on_error;
 
@@ -138,7 +132,6 @@ int git_commit_create(
 
 on_error:
 	git_buf_free(&commit);
-	git_buf_free(&cleaned_message);
 	giterr_set(GITERR_OBJECT, "Failed to create commit.");
 	return -1;
 }
@@ -233,22 +226,28 @@ 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, commit->parent_oids.length)
+GIT_COMMIT_GETTER(unsigned int, parentcount, (unsigned int)commit->parent_oids.length)
 GIT_COMMIT_GETTER(const git_oid *, tree_oid, &commit->tree_oid);
 
-
 int git_commit_tree(git_tree **tree_out, git_commit *commit)
 {
 	assert(commit);
 	return git_tree_lookup(tree_out, commit->object.repo, &commit->tree_oid);
 }
 
+const git_oid *git_commit_parent_oid(git_commit *commit, unsigned int n)
+{
+	assert(commit);
+
+	return git_vector_get(&commit->parent_oids, n);
+}
+
 int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n)
 {
-	git_oid *parent_oid;
+	const git_oid *parent_oid;
 	assert(commit);
 
-	parent_oid = git_vector_get(&commit->parent_oids, n);
+	parent_oid = git_commit_parent_oid(commit, n);
 	if (parent_oid == NULL) {
 		giterr_set(GITERR_INVALID, "Parent %u does not exist", n);
 		return GIT_ENOTFOUND;
@@ -257,9 +256,36 @@ int git_commit_parent(git_commit **parent, git_commit *commit, unsigned int n)
 	return git_commit_lookup(parent, commit->object.repo, parent_oid);
 }
 
-const git_oid *git_commit_parent_oid(git_commit *commit, unsigned int n)
+int git_commit_nth_gen_ancestor(
+	git_commit **ancestor,
+	const git_commit *commit,
+	unsigned int n)
 {
-	assert(commit);
+	git_commit *current, *parent;
+	int error;
 
-	return git_vector_get(&commit->parent_oids, n);
+	assert(ancestor && commit);
+
+	current = (git_commit *)commit;
+
+	if (n == 0)
+		return git_commit_lookup(
+			ancestor,
+			commit->object.repo,
+			git_object_id((const git_object *)commit));
+
+	while (n--) {
+		error = git_commit_parent(&parent, (git_commit *)current, 0);
+
+		if (current != commit)
+			git_commit_free(current);
+
+		if (error < 0)
+			return error;
+
+		current = parent;
+	}
+
+	*ancestor = parent;
+	return 0;
 }

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

@@ -24,6 +24,7 @@
 
 # include <io.h>
 # include <direct.h>
+# include <winsock2.h>
 # include <windows.h>
 # include "win32/msvc-compat.h"
 # include "win32/mingw-compat.h"
@@ -48,15 +49,6 @@
 
 #include <regex.h>
 
-extern void git___throw(const char *, ...) GIT_FORMAT_PRINTF(1, 2);
-#define git__throw(error, ...) \
-	(git___throw(__VA_ARGS__), error)
-
-extern void git___rethrow(const char *, ...) GIT_FORMAT_PRINTF(1, 2);
-#define git__rethrow(error, ...) \
-	(git___rethrow(__VA_ARGS__), error)
-
-
 #define GITERR_CHECK_ALLOC(ptr) if (ptr == NULL) { return -1; }
 
 void giterr_set_oom(void);
@@ -67,5 +59,7 @@ void giterr_set_regex(const regex_t *regex, int error_code);
 
 #include "util.h"
 
+typedef struct git_transport git_transport;
+typedef struct gitno_buffer gitno_buffer;
 
 #endif /* INCLUDE_common_h__ */

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

@@ -136,17 +136,27 @@ int git_config_add_file(git_config *cfg, git_config_file *file, int priority)
  * Loop over all the variables
  */
 
-int git_config_foreach(git_config *cfg, int (*fn)(const char *, const char *, void *), void *data)
+int git_config_foreach(
+	git_config *cfg, int (*fn)(const char *, const char *, void *), void *data)
+{
+	return git_config_foreach_match(cfg, NULL, fn, data);
+}
+
+int git_config_foreach_match(
+	git_config *cfg,
+	const char *regexp,
+	int (*fn)(const char *, const char *, void *),
+	void *data)
 {
 	int ret = 0;
 	unsigned int i;
 	file_internal *internal;
 	git_config_file *file;
 
-	for(i = 0; i < cfg->files.length && ret == 0; ++i) {
+	for (i = 0; i < cfg->files.length && ret == 0; ++i) {
 		internal = git_vector_get(&cfg->files, i);
 		file = internal->file;
-		ret = file->foreach(file, fn, data);
+		ret = file->foreach(file, regexp, fn, data);
 	}
 
 	return ret;
@@ -400,7 +410,7 @@ int git_config_get_multivar(git_config *cfg, const char *name, const char *regex
 	file_internal *internal;
 	git_config_file *file;
 	int ret = GIT_ENOTFOUND;
-	unsigned int i;
+	size_t i;
 
 	assert(cfg->files.length);
 
@@ -424,7 +434,7 @@ int git_config_set_multivar(git_config *cfg, const char *name, const char *regex
 	file_internal *internal;
 	git_config_file *file;
 	int ret = GIT_ENOTFOUND;
-	unsigned int i;
+	size_t i;
 
 	for (i = cfg->files.length; i > 0; --i) {
 		internal = git_vector_get(&cfg->files, i - 1);

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

@@ -87,6 +87,7 @@ typedef struct {
 static int config_parse(diskfile_backend *cfg_file);
 static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_value);
 static int config_write(diskfile_backend *cfg, const char *key, const regex_t *preg, const char *value);
+static char *escape_value(const char *ptr);
 
 static void set_parse_error(diskfile_backend *backend, int col, const char *error_str)
 {
@@ -187,34 +188,57 @@ static void backend_free(git_config_file *_backend)
 	git__free(backend);
 }
 
-static int file_foreach(git_config_file *backend, int (*fn)(const char *, const char *, void *), void *data)
+static int file_foreach(
+	git_config_file *backend,
+	const char *regexp,
+	int (*fn)(const char *, const char *, void *),
+	void *data)
 {
 	diskfile_backend *b = (diskfile_backend *)backend;
 	cvar_t *var;
 	const char *key;
+	regex_t regex;
+	int result = 0;
 
 	if (!b->values)
 		return 0;
 
+	if (regexp != NULL) {
+		if ((result = regcomp(&regex, regexp, REG_EXTENDED)) < 0) {
+			giterr_set_regex(&regex, result);
+			regfree(&regex);
+			return -1;
+		}
+	}
+
 	git_strmap_foreach(b->values, key, var,
-		do {
-			if (fn(key, var->value, data) < 0)
-				break;
+		for (; var != NULL; var = CVAR_LIST_NEXT(var)) {
+			/* skip non-matching keys if regexp was provided */
+			if (regexp && regexec(&regex, key, 0, NULL, 0) != 0)
+				continue;
 
-			var = CVAR_LIST_NEXT(var);
-		} while (var != NULL);
+			/* abort iterator on non-zero return value */
+			if (fn(key, var->value, data)) {
+				result = GIT_EUSER;
+				goto cleanup;
+			}
+		}
 	);
 
-	return 0;
+cleanup:
+	if (regexp != NULL)
+		regfree(&regex);
+
+	return result;
 }
 
 static int config_set(git_config_file *cfg, const char *name, const char *value)
 {
 	cvar_t *var = NULL, *old_var;
 	diskfile_backend *b = (diskfile_backend *)cfg;
-	char *key;
+	char *key, *esc_value = NULL;
 	khiter_t pos;
-	int rval;
+	int rval, ret;
 
 	if (normalize_name(name, &key) < 0)
 		return -1;
@@ -237,12 +261,17 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
 		if (value) {
 			tmp = git__strdup(value);
 			GITERR_CHECK_ALLOC(tmp);
+			esc_value = escape_value(value);
+			GITERR_CHECK_ALLOC(esc_value);
 		}
 
 		git__free(existing->value);
 		existing->value = tmp;
 
-		return config_write(b, existing->key, NULL, value);
+		ret = config_write(b, existing->key, NULL, esc_value);
+
+		git__free(esc_value);
+		return ret;
 	}
 
 	var = git__malloc(sizeof(cvar_t));
@@ -256,13 +285,17 @@ static int config_set(git_config_file *cfg, const char *name, const char *value)
 	if (value) {
 		var->value = git__strdup(value);
 		GITERR_CHECK_ALLOC(var->value);
+		esc_value = escape_value(value);
+		GITERR_CHECK_ALLOC(esc_value);
 	}
 
-	if (config_write(b, key, NULL, value) < 0) {
+	if (config_write(b, key, NULL, esc_value) < 0) {
+		git__free(esc_value);
 		cvar_free(var);
 		return -1;
 	}
 
+	git__free(esc_value);
 	git_strmap_insert2(b->values, key, var, old_var, rval);
 	if (rval < 0)
 		return -1;
@@ -327,6 +360,7 @@ static int config_get_multivar(
 		result = regcomp(&regex, regex_str, REG_EXTENDED);
 		if (result < 0) {
 			giterr_set_regex(&regex, result);
+			regfree(&regex);
 			return -1;
 		}
 
@@ -386,6 +420,7 @@ static int config_set_multivar(
 	if (result < 0) {
 		git__free(key);
 		giterr_set_regex(&preg, result);
+		regfree(&preg);
 		return -1;
 	}
 
@@ -950,9 +985,12 @@ static int write_section(git_filebuf *file, const char *key)
 	if (dot == NULL) {
 		git_buf_puts(&buf, key);
 	} else {
+		char *escaped;
 		git_buf_put(&buf, key, dot - key);
-		/* TODO: escape  */
-		git_buf_printf(&buf, " \"%s\"", dot + 1);
+		escaped = escape_value(dot + 1);
+		GITERR_CHECK_ALLOC(escaped);
+		git_buf_printf(&buf, " \"%s\"", escaped);
+		git__free(escaped);
 	}
 	git_buf_puts(&buf, "]\n");
 
@@ -1155,13 +1193,44 @@ rewrite_fail:
 	return -1;
 }
 
+static const char *escapes = "ntb\"\\";
+static const char *escaped = "\n\t\b\"\\";
+
+/* Escape the values to write them to the file */
+static char *escape_value(const char *ptr)
+{
+	git_buf buf = GIT_BUF_INIT;
+	size_t len;
+	const char *esc;
+
+	assert(ptr);
+
+	len = strlen(ptr);
+	git_buf_grow(&buf, len);
+
+	while (*ptr != '\0') {
+		if ((esc = strchr(escaped, *ptr)) != NULL) {
+			git_buf_putc(&buf, '\\');
+			git_buf_putc(&buf, escapes[esc - escaped]);
+		} else {
+			git_buf_putc(&buf, *ptr);
+		}
+		ptr++;
+	}
+
+	if (git_buf_oom(&buf)) {
+		git_buf_free(&buf);
+		return NULL;
+	}
+
+	return git_buf_detach(&buf);
+}
+
 /* '\"' -> '"' etc */
 static char *fixup_line(const char *ptr, int quote_count)
 {
 	char *str = git__malloc(strlen(ptr) + 1);
 	char *out = str, *esc;
-	const char *escapes = "ntb\"\\";
-	const char *escaped = "\n\t\b\"\\";
 
 	if (str == NULL)
 		return NULL;
@@ -1274,10 +1343,8 @@ static int parse_variable(diskfile_backend *cfg, char **var_name, char **var_val
 	else
 		value_start = var_end + 1;
 
-	if (git__isspace(var_end[-1])) {
-		do var_end--;
-		while (git__isspace(var_end[0]));
-	}
+	do var_end--;
+	while (git__isspace(*var_end));
 
 	*var_name = git__strndup(line, var_end - line + 1);
 	GITERR_CHECK_ALLOC(*var_name);

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

@@ -19,12 +19,27 @@ GIT_INLINE(void) git_config_file_free(git_config_file *cfg)
 	cfg->free(cfg);
 }
 
+GIT_INLINE(int) git_config_file_set_string(
+	git_config_file *cfg, const char *name, const char *value)
+{
+	return cfg->set(cfg, name, value);
+}
+
 GIT_INLINE(int) git_config_file_foreach(
 	git_config_file *cfg,
 	int (*fn)(const char *key, const char *value, void *data),
 	void *data)
 {
-	return cfg->foreach(cfg, fn, data);
+	return cfg->foreach(cfg, NULL, fn, data);
+}
+
+GIT_INLINE(int) git_config_file_foreach_match(
+	git_config_file *cfg,
+	const char *regexp,
+	int (*fn)(const char *key, const char *value, void *data),
+	void *data)
+{
+	return cfg->foreach(cfg, regexp, fn, data);
 }
 
 #endif

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

@@ -184,7 +184,87 @@ static int crlf_apply_to_odb(git_filter *self, git_buf *dest, const git_buf *sou
 	return drop_crlf(dest, source);
 }
 
-int git_filter_add__crlf_to_odb(git_vector *filters, git_repository *repo, const char *path)
+static int convert_line_endings(git_buf *dest, const git_buf *source, const char *ending)
+{
+	const char *scan = git_buf_cstr(source),
+				  *next,
+				  *scan_end = git_buf_cstr(source) + git_buf_len(source);
+
+	while ((next = memchr(scan, '\n', scan_end - scan)) != NULL) {
+		if (next > scan)
+			git_buf_put(dest, scan, next-scan);
+		git_buf_puts(dest, ending);
+		scan = next + 1;
+	}
+
+	git_buf_put(dest, scan, scan_end - scan);
+	return 0;
+}
+
+static const char *line_ending(struct crlf_filter *filter)
+{
+	switch (filter->attrs.crlf_action) {
+	case GIT_CRLF_BINARY:
+	case GIT_CRLF_INPUT:
+		return "\n";
+
+	case GIT_CRLF_CRLF:
+		return "\r\n";
+
+	case GIT_CRLF_AUTO:
+	case GIT_CRLF_TEXT:
+	case GIT_CRLF_GUESS:
+		break;
+
+	default:
+		goto line_ending_error;
+	}
+
+	switch (filter->attrs.eol) {
+	case GIT_EOL_UNSET:
+		return GIT_EOL_NATIVE == GIT_EOL_CRLF
+			? "\r\n"
+			: "\n";
+
+	case GIT_EOL_CRLF:
+		return "\r\n";
+
+	case GIT_EOL_LF:
+		return "\n";
+
+	default:
+		goto line_ending_error;
+	}
+
+line_ending_error:
+	giterr_set(GITERR_INVALID, "Invalid input to line ending filter");
+	return NULL;
+}
+
+static int crlf_apply_to_workdir(git_filter *self, git_buf *dest, const git_buf *source)
+{
+	struct crlf_filter *filter = (struct crlf_filter *)self;
+	const char *workdir_ending = NULL;
+
+	assert (self && dest && source);
+
+	/* Empty file? Nothing to do. */
+	if (git_buf_len(source) == 0)
+		return 0;
+
+	/* Determine proper line ending */
+	workdir_ending = line_ending(filter);
+	if (!workdir_ending) return -1;
+
+	/* If the line ending is '\n', just copy the input */
+	if (!strcmp(workdir_ending, "\n"))
+		return git_buf_puts(dest, git_buf_cstr(source));
+
+	return convert_line_endings(dest, source, workdir_ending);
+}
+
+static int find_and_add_filter(git_vector *filters, git_repository *repo, const char *path,
+										 int (*apply)(struct git_filter *self, git_buf *dest, const git_buf *source))
 {
 	struct crlf_attrs ca;
 	struct crlf_filter *filter;
@@ -206,8 +286,7 @@ int git_filter_add__crlf_to_odb(git_vector *filters, git_repository *repo, const
 	if (ca.crlf_action == GIT_CRLF_GUESS) {
 		int auto_crlf;
 
-		if ((error = git_repository__cvar(
-			&auto_crlf, repo, GIT_CVAR_AUTO_CRLF)) < 0)
+		if ((error = git_repository__cvar(&auto_crlf, repo, GIT_CVAR_AUTO_CRLF)) < 0)
 			return error;
 
 		if (auto_crlf == GIT_AUTO_CRLF_FALSE)
@@ -219,10 +298,19 @@ int git_filter_add__crlf_to_odb(git_vector *filters, git_repository *repo, const
 	filter = git__malloc(sizeof(struct crlf_filter));
 	GITERR_CHECK_ALLOC(filter);
 
-	filter->f.apply = &crlf_apply_to_odb;
+	filter->f.apply = apply;
 	filter->f.do_free = NULL;
 	memcpy(&filter->attrs, &ca, sizeof(struct crlf_attrs));
 
 	return git_vector_insert(filters, filter);
 }
 
+int git_filter_add__crlf_to_odb(git_vector *filters, git_repository *repo, const char *path)
+{
+	return find_and_add_filter(filters, repo, path, &crlf_apply_to_odb);
+}
+
+int git_filter_add__crlf_to_workdir(git_vector *filters, git_repository *repo, const char *path)
+{
+	return find_and_add_filter(filters, repo, path, &crlf_apply_to_workdir);
+}