rugged 0.19.0 → 0.28.0

data/vendor/libgit2/src/crlf.c

@@ -5,112 +5,75 @@
  * a Linking Exception. For full terms see the included COPYING file.
  */
 
+#include "common.h"
+
 #include "git2/attr.h"
 #include "git2/blob.h"
 #include "git2/index.h"
+#include "git2/sys/filter.h"
 
-#include "common.h"
 #include "fileops.h"
 #include "hash.h"
 #include "filter.h"
 #include "buf_text.h"
 #include "repository.h"
 
+typedef enum {
+	GIT_CRLF_UNDEFINED,
+	GIT_CRLF_BINARY,
+	GIT_CRLF_TEXT,
+	GIT_CRLF_TEXT_INPUT,
+	GIT_CRLF_TEXT_CRLF,
+	GIT_CRLF_AUTO,
+	GIT_CRLF_AUTO_INPUT,
+	GIT_CRLF_AUTO_CRLF,
+} git_crlf_t;
+
 struct crlf_attrs {
-	int crlf_action;
-	int eol;
+	int attr_action; /* the .gitattributes setting */
+	int crlf_action; /* the core.autocrlf setting */
+
+	int auto_crlf;
+	int safe_crlf;
+	int core_eol;
 };
 
 struct crlf_filter {
 	git_filter f;
-	struct crlf_attrs attrs;
-	git_repository *repo;
-	char path[GIT_FLEX_ARRAY];
 };
 
-static int check_crlf(const char *value)
+static git_crlf_t check_crlf(const char *value)
 {
 	if (GIT_ATTR_TRUE(value))
 		return GIT_CRLF_TEXT;
-
-	if (GIT_ATTR_FALSE(value))
+	else if (GIT_ATTR_FALSE(value))
 		return GIT_CRLF_BINARY;
-
-	if (GIT_ATTR_UNSPECIFIED(value))
-		return GIT_CRLF_GUESS;
-
-	if (strcmp(value, "input") == 0)
-		return GIT_CRLF_INPUT;
-
-	if (strcmp(value, "auto") == 0)
+	else if (GIT_ATTR_UNSPECIFIED(value))
+		;
+	else if (strcmp(value, "input") == 0)
+		return GIT_CRLF_TEXT_INPUT;
+	else if (strcmp(value, "auto") == 0)
 		return GIT_CRLF_AUTO;
 
-	return GIT_CRLF_GUESS;
+	return GIT_CRLF_UNDEFINED;
 }
 
-static int check_eol(const char *value)
+static git_cvar_value check_eol(const char *value)
 {
 	if (GIT_ATTR_UNSPECIFIED(value))
-		return GIT_EOL_UNSET;
-
-	if (strcmp(value, "lf") == 0)
+		;
+	else if (strcmp(value, "lf") == 0)
 		return GIT_EOL_LF;
-
-	if (strcmp(value, "crlf") == 0)
+	else if (strcmp(value, "crlf") == 0)
 		return GIT_EOL_CRLF;
 
 	return GIT_EOL_UNSET;
 }
 
-static int crlf_input_action(struct crlf_attrs *ca)
-{
-	if (ca->crlf_action == GIT_CRLF_BINARY)
-		return GIT_CRLF_BINARY;
-
-	if (ca->eol == GIT_EOL_LF)
-		return GIT_CRLF_INPUT;
-
-	if (ca->eol == GIT_EOL_CRLF)
-		return GIT_CRLF_CRLF;
-
-	return ca->crlf_action;
-}
-
-static int crlf_load_attributes(struct crlf_attrs *ca, git_repository *repo, const char *path)
+static int has_cr_in_index(const git_filter_source *src)
 {
-#define NUM_CONV_ATTRS 3
-
-	static const char *attr_names[NUM_CONV_ATTRS] = {
-		"crlf", "eol", "text",
-	};
-
-	const char *attr_vals[NUM_CONV_ATTRS];
-	int error;
-
-	error = git_attr_get_many(attr_vals,
-		repo, 0, path, NUM_CONV_ATTRS, attr_names);
-
-	if (error == GIT_ENOTFOUND) {
-		ca->crlf_action = GIT_CRLF_GUESS;
-		ca->eol = GIT_EOL_UNSET;
-		return 0;
-	}
-
-	if (error == 0) {
-		ca->crlf_action = check_crlf(attr_vals[2]); /* text */
-		if (ca->crlf_action == GIT_CRLF_GUESS)
-			ca->crlf_action = check_crlf(attr_vals[0]); /* clrf */
-
-		ca->eol = check_eol(attr_vals[1]); /* eol */
-		return 0;
-	}
-
-	return -1;
-}
-
-static int has_cr_in_index(git_filter *self)
-{
-	struct crlf_filter *filter = (struct crlf_filter *)self;
+	git_repository *repo = git_filter_source_repo(src);
+	const char *path = git_filter_source_path(src);
 	git_index *index;
 	const git_index_entry *entry;
 	git_blob *blob;
@@ -118,19 +81,22 @@ static int has_cr_in_index(git_filter *self)
 	git_off_t blobsize;
 	bool found_cr;
 
-	if (git_repository_index__weakptr(&index, filter->repo) < 0) {
-		giterr_clear();
+	if (!path)
+		return false;
+
+	if (git_repository_index__weakptr(&index, repo) < 0) {
+		git_error_clear();
 		return false;
 	}
 
-	if (!(entry = git_index_get_bypath(index, filter->path, 0)) &&
-		!(entry = git_index_get_bypath(index, filter->path, 1)))
+	if (!(entry = git_index_get_bypath(index, path, 0)) &&
+		!(entry = git_index_get_bypath(index, path, 1)))
 		return false;
 
 	if (!S_ISREG(entry->mode)) /* don't crlf filter non-blobs */
 		return true;
 
-	if (git_blob_lookup(&blob, filter->repo, &entry->oid) < 0)
+	if (git_blob_lookup(&blob, repo, &entry->id) < 0)
 		return false;
 
 	blobcontent = git_blob_rawcontent(blob);
@@ -146,173 +112,302 @@ static int has_cr_in_index(git_filter *self)
 	return found_cr;
 }
 
-static int crlf_apply_to_odb(
-	git_filter *self, git_buf *dest, const git_buf *source)
+static int text_eol_is_crlf(struct crlf_attrs *ca)
 {
-	struct crlf_filter *filter = (struct crlf_filter *)self;
+	if (ca->auto_crlf == GIT_AUTO_CRLF_TRUE)
+		return 1;
+	else if (ca->auto_crlf == GIT_AUTO_CRLF_INPUT)
+		return 0;
 
-	assert(self && dest && source);
+	if (ca->core_eol == GIT_EOL_CRLF)
+		return 1;
+	if (ca->core_eol == GIT_EOL_UNSET && GIT_EOL_NATIVE == GIT_EOL_CRLF)
+		return 1;
 
-	/* Empty file? Nothing to do */
-	if (git_buf_len(source) == 0)
-		return 0;
+	return 0;
+}
 
-	/* Heuristics to see if we can skip the conversion.
-	 * Straight from Core Git.
-	 */
-	if (filter->attrs.crlf_action == GIT_CRLF_AUTO ||
-		filter->attrs.crlf_action == GIT_CRLF_GUESS) {
+static git_cvar_value output_eol(struct crlf_attrs *ca)
+{
+	switch (ca->crlf_action) {
+	case GIT_CRLF_BINARY:
+		return GIT_EOL_UNSET;
+	case GIT_CRLF_TEXT_CRLF:
+		return GIT_EOL_CRLF;
+	case GIT_CRLF_TEXT_INPUT:
+		return GIT_EOL_LF;
+	case GIT_CRLF_UNDEFINED:
+	case GIT_CRLF_AUTO_CRLF:
+		return GIT_EOL_CRLF;
+	case GIT_CRLF_AUTO_INPUT:
+		return GIT_EOL_LF;
+	case GIT_CRLF_TEXT:
+	case GIT_CRLF_AUTO:
+		return text_eol_is_crlf(ca) ? GIT_EOL_CRLF : GIT_EOL_LF;
+	}
 
-		git_buf_text_stats stats;
+	/* TODO: warn when available */
+	return ca->core_eol;
+}
 
-		/* Check heuristics for binary vs text... */
-		if (git_buf_text_gather_stats(&stats, source, false))
-			return -1;
+GIT_INLINE(int) check_safecrlf(
+	struct crlf_attrs *ca,
+	const git_filter_source *src,
+	git_buf_text_stats *stats)
+{
+	const char *filename = git_filter_source_path(src);
+
+	if (!ca->safe_crlf)
+		return 0;
 
+	if (output_eol(ca) == GIT_EOL_LF) {
 		/*
-		 * We're currently not going to even try to convert stuff
-		 * that has bare CR characters. Does anybody do that crazy
-		 * stuff?
+		 * CRLFs would not be restored by checkout:
+		 * check if we'd remove CRLFs
 		 */
-		if (stats.cr != stats.crlf)
-			return -1;
-
-		if (filter->attrs.crlf_action == GIT_CRLF_GUESS) {
-			/*
-			 * If the file in the index has any CR in it, do not convert.
-			 * This is the new safer autocrlf handling.
-			 */
-			if (has_cr_in_index(self))
+		if (stats->crlf) {
+			if (ca->safe_crlf == GIT_SAFE_CRLF_WARN) {
+				/* TODO: issue a warning when available */
+			} else {
+				if (filename && *filename)
+					git_error_set(
+						GIT_ERROR_FILTER, "CRLF would be replaced by LF in '%s'",
+						filename);
+				else
+					git_error_set(
+						GIT_ERROR_FILTER, "CRLF would be replaced by LF");
+
 				return -1;
+			}
 		}
+	} else if (output_eol(ca) == GIT_EOL_CRLF) {
+		/*
+		 * CRLFs would be added by checkout:
+		 * check if we have "naked" LFs
+		 */
+		if (stats->crlf != stats->lf) {
+			if (ca->safe_crlf == GIT_SAFE_CRLF_WARN) {
+				/* TODO: issue a warning when available */
+			} else {
+				if (filename && *filename)
+					git_error_set(
+						GIT_ERROR_FILTER, "LF would be replaced by CRLF in '%s'",
+						filename);
+				else
+					git_error_set(
+						GIT_ERROR_FILTER, "LF would be replaced by CRLF");
 
-		if (!stats.cr)
-			return -1;
+				return -1;
+			}
+		}
 	}
 
-	/* Actually drop the carriage returns */
-	return git_buf_text_crlf_to_lf(dest, source);
+	return 0;
 }
 
-static const char *line_ending(struct crlf_filter *filter)
+static int crlf_apply_to_odb(
+	struct crlf_attrs *ca,
+	git_buf *to,
+	const git_buf *from,
+	const git_filter_source *src)
 {
-	switch (filter->attrs.crlf_action) {
-	case GIT_CRLF_BINARY:
-	case GIT_CRLF_INPUT:
-		return "\n";
+	git_buf_text_stats stats;
+	bool is_binary;
+	int error;
 
-	case GIT_CRLF_CRLF:
-		return "\r\n";
+	/* Binary attribute? Empty file? Nothing to do */
+	if (ca->crlf_action == GIT_CRLF_BINARY || !git_buf_len(from))
+		return GIT_PASSTHROUGH;
 
-	case GIT_CRLF_AUTO:
-	case GIT_CRLF_TEXT:
-	case GIT_CRLF_GUESS:
-		break;
+	is_binary = git_buf_text_gather_stats(&stats, from, false);
 
-	default:
-		goto line_ending_error;
-	}
+	/* Heuristics to see if we can skip the conversion.
+	 * Straight from Core Git.
+	 */
+	if (ca->crlf_action == GIT_CRLF_AUTO ||
+		ca->crlf_action == GIT_CRLF_AUTO_INPUT ||
+		ca->crlf_action == GIT_CRLF_AUTO_CRLF) {
 
-	switch (filter->attrs.eol) {
-	case GIT_EOL_UNSET:
-		return GIT_EOL_NATIVE == GIT_EOL_CRLF
-			? "\r\n"
-			: "\n";
+		if (is_binary)
+			return GIT_PASSTHROUGH;
 
-	case GIT_EOL_CRLF:
-		return "\r\n";
+		/*
+		 * If the file in the index has any CR in it, do not convert.
+		 * This is the new safer autocrlf handling.
+		 */
+		if (has_cr_in_index(src))
+			return GIT_PASSTHROUGH;
+	}
 
-	case GIT_EOL_LF:
-		return "\n";
+	if ((error = check_safecrlf(ca, src, &stats)) < 0)
+		return error;
 
-	default:
-		goto line_ending_error;
-	}
+	/* If there are no CR characters to filter out, then just pass */
+	if (!stats.crlf)
+		return GIT_PASSTHROUGH;
 
-line_ending_error:
-	giterr_set(GITERR_INVALID, "Invalid input to line ending filter");
-	return NULL;
+	/* Actually drop the carriage returns */
+	return git_buf_text_crlf_to_lf(to, from);
 }
 
 static int crlf_apply_to_workdir(
-	git_filter *self, git_buf *dest, const git_buf *source)
+	struct crlf_attrs *ca,
+	git_buf *to,
+	const git_buf *from)
 {
-	struct crlf_filter *filter = (struct crlf_filter *)self;
-	const char *workdir_ending = NULL;
-
-	assert(self && dest && source);
+	git_buf_text_stats stats;
+	bool is_binary;
 
 	/* Empty file? Nothing to do. */
-	if (git_buf_len(source) == 0)
-		return -1;
-
-	/* Determine proper line ending */
-	workdir_ending = line_ending(filter);
-	if (!workdir_ending)
-		return -1;
-	if (!strcmp("\n", workdir_ending)) /* do nothing for \n ending */
-		return -1;
-
-	/* for now, only lf->crlf conversion is supported here */
-	assert(!strcmp("\r\n", workdir_ending));
-	return git_buf_text_lf_to_crlf(dest, source);
+	if (git_buf_len(from) == 0 || output_eol(ca) != GIT_EOL_CRLF)
+		return GIT_PASSTHROUGH;
+
+	is_binary = git_buf_text_gather_stats(&stats, from, false);
+
+	/* If there are no LFs, or all LFs are part of a CRLF, nothing to do */
+	if (stats.lf == 0 || stats.lf == stats.crlf)
+		return GIT_PASSTHROUGH;
+
+	if (ca->crlf_action == GIT_CRLF_AUTO ||
+		ca->crlf_action == GIT_CRLF_AUTO_INPUT ||
+		ca->crlf_action == GIT_CRLF_AUTO_CRLF) {
+
+		/* If we have any existing CR or CRLF line endings, do nothing */
+		if (stats.cr > 0)
+			return GIT_PASSTHROUGH;
+
+		/* Don't filter binary files */
+		if (is_binary)
+			return GIT_PASSTHROUGH;
+	}
+
+	return git_buf_text_lf_to_crlf(to, from);
 }
 
-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))
+static int convert_attrs(
+	struct crlf_attrs *ca,
+	const char **attr_values,
+	const git_filter_source *src)
 {
-	struct crlf_attrs ca;
-	struct crlf_filter *filter;
-	size_t pathlen;
 	int error;
 
-	/* Load gitattributes for the path */
-	if ((error = crlf_load_attributes(&ca, repo, path)) < 0)
+	memset(ca, 0, sizeof(struct crlf_attrs));
+
+	if ((error = git_repository__cvar(&ca->auto_crlf,
+		 git_filter_source_repo(src), GIT_CVAR_AUTO_CRLF)) < 0 ||
+		(error = git_repository__cvar(&ca->safe_crlf,
+		 git_filter_source_repo(src), GIT_CVAR_SAFE_CRLF)) < 0 ||
+		(error = git_repository__cvar(&ca->core_eol,
+		 git_filter_source_repo(src), GIT_CVAR_EOL)) < 0)
 		return error;
 
-	/*
-	 * Use the core Git logic to see if we should perform CRLF for this file
-	 * based on its attributes & the value of `core.autocrlf`
-	 */
-	ca.crlf_action = crlf_input_action(&ca);
+	/* downgrade FAIL to WARN if ALLOW_UNSAFE option is used */
+	if ((git_filter_source_flags(src) & GIT_FILTER_ALLOW_UNSAFE) &&
+		ca->safe_crlf == GIT_SAFE_CRLF_FAIL)
+		ca->safe_crlf = GIT_SAFE_CRLF_WARN;
+
+	if (attr_values) {
+		/* load the text attribute */
+		ca->crlf_action = check_crlf(attr_values[2]); /* text */
+
+		if (ca->crlf_action == GIT_CRLF_UNDEFINED)
+			ca->crlf_action = check_crlf(attr_values[0]); /* crlf */
+
+		if (ca->crlf_action != GIT_CRLF_BINARY) {
+			/* load the eol attribute */
+			int eol_attr = check_eol(attr_values[1]);
+
+			if (ca->crlf_action == GIT_CRLF_AUTO && eol_attr == GIT_EOL_LF)
+				ca->crlf_action = GIT_CRLF_AUTO_INPUT;
+			else if (ca->crlf_action == GIT_CRLF_AUTO && eol_attr == GIT_EOL_CRLF)
+				ca->crlf_action = GIT_CRLF_AUTO_CRLF;
+			else if (eol_attr == GIT_EOL_LF)
+				ca->crlf_action = GIT_CRLF_TEXT_INPUT;
+			else if (eol_attr == GIT_EOL_CRLF)
+				ca->crlf_action = GIT_CRLF_TEXT_CRLF;
+		}
 
-	if (ca.crlf_action == GIT_CRLF_BINARY)
-		return 0;
+		ca->attr_action = ca->crlf_action;
+	} else {
+		ca->crlf_action = GIT_CRLF_UNDEFINED;
+	}
 
-	if (ca.crlf_action == GIT_CRLF_GUESS) {
-		int auto_crlf;
+	if (ca->crlf_action == GIT_CRLF_TEXT)
+		ca->crlf_action = text_eol_is_crlf(ca) ? GIT_CRLF_TEXT_CRLF : GIT_CRLF_TEXT_INPUT;
+	if (ca->crlf_action == GIT_CRLF_UNDEFINED && ca->auto_crlf == GIT_AUTO_CRLF_FALSE)
+		ca->crlf_action = GIT_CRLF_BINARY;
+	if (ca->crlf_action == GIT_CRLF_UNDEFINED && ca->auto_crlf == GIT_AUTO_CRLF_TRUE)
+		ca->crlf_action = GIT_CRLF_AUTO_CRLF;
+	if (ca->crlf_action == GIT_CRLF_UNDEFINED && ca->auto_crlf == GIT_AUTO_CRLF_INPUT)
+		ca->crlf_action = GIT_CRLF_AUTO_INPUT;
 
-		if ((error = git_repository__cvar(&auto_crlf, repo, GIT_CVAR_AUTO_CRLF)) < 0)
-			return error;
+	return 0;
+}
 
-		if (auto_crlf == GIT_AUTO_CRLF_FALSE)
-			return 0;
-	}
+static int crlf_check(
+	git_filter *self,
+	void **payload, /* points to NULL ptr on entry, may be set */
+	const git_filter_source *src,
+	const char **attr_values)
+{
+	struct crlf_attrs ca;
+
+	GIT_UNUSED(self);
+
+	convert_attrs(&ca, attr_values, src);
+
+	if (ca.crlf_action == GIT_CRLF_BINARY)
+		return GIT_PASSTHROUGH;
 
-	/* If we're good, we create a new filter object and push it
-	 * into the filters array */
-	pathlen = strlen(path);
-	filter = git__malloc(sizeof(struct crlf_filter) + pathlen + 1);
-	GITERR_CHECK_ALLOC(filter);
+	*payload = git__malloc(sizeof(ca));
+	GIT_ERROR_CHECK_ALLOC(*payload);
+	memcpy(*payload, &ca, sizeof(ca));
 
-	filter->f.apply = apply;
-	filter->f.do_free = NULL;
-	memcpy(&filter->attrs, &ca, sizeof(struct crlf_attrs));
-	filter->repo = repo;
-	memcpy(filter->path, path, pathlen + 1);
+	return 0;
+}
+
+static int crlf_apply(
+	git_filter *self,
+	void **payload, /* may be read and/or set */
+	git_buf *to,
+	const git_buf *from,
+	const git_filter_source *src)
+{
+	/* initialize payload in case `check` was bypassed */
+	if (!*payload) {
+		int error = crlf_check(self, payload, src, NULL);
+
+		if (error < 0)
+			return error;
+	}
 
-	return git_vector_insert(filters, filter);
+	if (git_filter_source_mode(src) == GIT_FILTER_SMUDGE)
+		return crlf_apply_to_workdir(*payload, to, from);
+	else
+		return crlf_apply_to_odb(*payload, to, from, src);
 }
 
-int git_filter_add__crlf_to_odb(
-	git_vector *filters, git_repository *repo, const char *path)
+static void crlf_cleanup(
+	git_filter *self,
+	void       *payload)
 {
-	return find_and_add_filter(filters, repo, path, &crlf_apply_to_odb);
+	GIT_UNUSED(self);
+	git__free(payload);
 }
 
-int git_filter_add__crlf_to_workdir(
-	git_vector *filters, git_repository *repo, const char *path)
+git_filter *git_crlf_filter_new(void)
 {
-	return find_and_add_filter(filters, repo, path, &crlf_apply_to_workdir);
+	struct crlf_filter *f = git__calloc(1, sizeof(struct crlf_filter));
+	if (f == NULL)
+		return NULL;
+
+	f->f.version = GIT_FILTER_VERSION;
+	f->f.attributes = "crlf eol text";
+	f->f.initialize = NULL;
+	f->f.shutdown = git_filter_free;
+	f->f.check    = crlf_check;
+	f->f.apply    = crlf_apply;
+	f->f.cleanup  = crlf_cleanup;
+
+	return (git_filter *)f;
 }

data/vendor/libgit2/src/date.c

@@ -823,15 +823,13 @@ static void pending_number(struct tm *tm, int *num)
 }
 
 static git_time_t approxidate_str(const char *date,
-									const struct timeval *tv,
-									int *error_ret)
+	time_t time_sec,
+	int *error_ret)
 {
 	int number = 0;
 	int touched = 0;
 	struct tm tm = {0}, now;
-	time_t time_sec;
 
-	time_sec = tv->tv_sec;
 	p_localtime_r(&time_sec, &tm);
 	now = tm;
 
@@ -861,7 +859,7 @@ static git_time_t approxidate_str(const char *date,
 
 int git__date_parse(git_time_t *out, const char *date)
 {
-	struct timeval tv;
+	time_t time_sec;
 	git_time_t timestamp;
 	int offset, error_ret=0;
 
@@ -870,7 +868,37 @@ int git__date_parse(git_time_t *out, const char *date)
 		return 0;
 	}
 
-	p_gettimeofday(&tv, NULL);
-	*out = approxidate_str(date, &tv, &error_ret);
+	if (time(&time_sec) == -1)
+		return -1;
+
+	*out = approxidate_str(date, time_sec, &error_ret);
    return error_ret;
 }
+
+int git__date_rfc2822_fmt(char *out, size_t len, const git_time *date)
+{
+	int written;
+	struct tm gmt;
+	time_t t;
+
+	assert(out && date);
+
+	t = (time_t) (date->time + date->offset * 60);
+
+	if (p_gmtime_r (&t, &gmt) == NULL)
+		return -1;
+
+	written = p_snprintf(out, len, "%.3s, %u %.3s %.4u %02u:%02u:%02u %+03d%02d",
+		weekday_names[gmt.tm_wday],
+		gmt.tm_mday,
+		month_names[gmt.tm_mon],
+		gmt.tm_year + 1900,
+		gmt.tm_hour, gmt.tm_min, gmt.tm_sec,
+		date->offset / 60, date->offset % 60);
+
+	if (written < 0 || (written > (int) len - 1))
+		return -1;
+
+	return 0;
+}
+