rugged 1.3.2 → 1.6.2

data/vendor/libgit2/src/{filter.c → libgit2/filter.c}

@@ -7,6 +7,7 @@
 
 #include "filter.h"
 
+#include "buf.h"
 #include "common.h"
 #include "futils.h"
 #include "hash.h"
@@ -17,6 +18,7 @@
 #include "blob.h"
 #include "attr_file.h"
 #include "array.h"
+#include "path.h"
 
 struct git_filter_source {
 	git_repository    *repo;
@@ -36,7 +38,7 @@ typedef struct {
 struct git_filter_list {
 	git_array_t(git_filter_entry) filters;
 	git_filter_source source;
-	git_buf *temp_buf;
+	git_str *temp_buf;
 	char path[GIT_FLEX_ARRAY];
 };
 
@@ -68,7 +70,7 @@ static void git_filter_global_shutdown(void);
 
 
 static int filter_def_scan_attrs(
-	git_buf *attrs, size_t *nattr, size_t *nmatch, const char *attr_str)
+	git_str *attrs, size_t *nattr, size_t *nmatch, const char *attr_str)
 {
 	const char *start, *scan = attr_str;
 	int has_eq;
@@ -92,9 +94,9 @@ static int filter_def_scan_attrs(
 				(*nmatch)++;
 
 			if (has_eq)
-				git_buf_putc(attrs, '=');
-			git_buf_put(attrs, start, scan - start);
-			git_buf_putc(attrs, '\0');
+				git_str_putc(attrs, '=');
+			git_str_put(attrs, start, scan - start);
+			git_str_putc(attrs, '\0');
 		}
 	}
 
@@ -152,7 +154,7 @@ static int filter_registry_insert(
 {
 	git_filter_def *fdef;
 	size_t nattr = 0, nmatch = 0, alloc_len;
-	git_buf attrs = GIT_BUF_INIT;
+	git_str attrs = GIT_STR_INIT;
 
 	if (filter_def_scan_attrs(&attrs, &nattr, &nmatch, filter->attributes) < 0)
 		return -1;
@@ -171,7 +173,7 @@ static int filter_registry_insert(
 	fdef->priority    = priority;
 	fdef->nattrs      = nattr;
 	fdef->nmatches    = nmatch;
-	fdef->attrdata    = git_buf_detach(&attrs);
+	fdef->attrdata    = git_str_detach(&attrs);
 
 	filter_def_set_attrs(fdef);
 
@@ -710,7 +712,7 @@ size_t git_filter_list_length(const git_filter_list *fl)
 
 struct buf_stream {
 	git_writestream parent;
-	git_buf *target;
+	git_str *target;
 	bool complete;
 };
 
@@ -721,7 +723,7 @@ static int buf_stream_write(
 	GIT_ASSERT_ARG(buf_stream);
 	GIT_ASSERT(buf_stream->complete == 0);
 
-	return git_buf_put(buf_stream->target, buffer, len);
+	return git_str_put(buf_stream->target, buffer, len);
 }
 
 static int buf_stream_close(git_writestream *s)
@@ -740,7 +742,7 @@ static void buf_stream_free(git_writestream *s)
 	GIT_UNUSED(s);
 }
 
-static void buf_stream_init(struct buf_stream *writer, git_buf *target)
+static void buf_stream_init(struct buf_stream *writer, git_str *target)
 {
 	memset(writer, 0, sizeof(struct buf_stream));
 
@@ -749,7 +751,7 @@ static void buf_stream_init(struct buf_stream *writer, git_buf *target)
 	writer->parent.free = buf_stream_free;
 	writer->target = target;
 
-	git_buf_clear(target);
+	git_str_clear(target);
 }
 
 int git_filter_list_apply_to_buffer(
@@ -757,13 +759,19 @@ int git_filter_list_apply_to_buffer(
 	git_filter_list *filters,
 	const char *in,
 	size_t in_len)
+{
+	GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_buffer, filters, in, in_len);
+}
+
+int git_filter_list__apply_to_buffer(
+	git_str *out,
+	git_filter_list *filters,
+	const char *in,
+	size_t in_len)
 {
 	struct buf_stream writer;
 	int error;
 
-	if ((error = git_buf_sanitize(out)) < 0)
-		return error;
-
 	buf_stream_init(&writer, out);
 
 	if ((error = git_filter_list_stream_buffer(filters,
@@ -775,23 +783,23 @@ int git_filter_list_apply_to_buffer(
 }
 
 int git_filter_list__convert_buf(
-	git_buf *out,
+	git_str *out,
 	git_filter_list *filters,
-	git_buf *in)
+	git_str *in)
 {
 	int error;
 
 	if (!filters || git_filter_list_length(filters) == 0) {
-		git_buf_swap(out, in);
-		git_buf_dispose(in);
+		git_str_swap(out, in);
+		git_str_dispose(in);
 		return 0;
 	}
 
-	error = git_filter_list_apply_to_buffer(out, filters,
+	error = git_filter_list__apply_to_buffer(out, filters,
 		in->ptr, in->size);
 
 	if (!error)
-		git_buf_dispose(in);
+		git_str_dispose(in);
 
 	return error;
 }
@@ -801,6 +809,15 @@ int git_filter_list_apply_to_file(
 	git_filter_list *filters,
 	git_repository *repo,
 	const char *path)
+{
+	GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_file, filters, repo, path);
+}
+
+int git_filter_list__apply_to_file(
+	git_str *out,
+	git_filter_list *filters,
+	git_repository *repo,
+	const char *path)
 {
 	struct buf_stream writer;
 	int error;
@@ -815,7 +832,7 @@ int git_filter_list_apply_to_file(
 	return error;
 }
 
-static int buf_from_blob(git_buf *out, git_blob *blob)
+static int buf_from_blob(git_str *out, git_blob *blob)
 {
 	git_object_size_t rawsize = git_blob_rawsize(blob);
 
@@ -824,7 +841,7 @@ static int buf_from_blob(git_buf *out, git_blob *blob)
 		return -1;
 	}
 
-	git_buf_attach_notowned(out, git_blob_rawcontent(blob), (size_t)rawsize);
+	git_str_attach_notowned(out, git_blob_rawcontent(blob), (size_t)rawsize);
 	return 0;
 }
 
@@ -832,6 +849,14 @@ int git_filter_list_apply_to_blob(
 	git_buf *out,
 	git_filter_list *filters,
 	git_blob *blob)
+{
+	GIT_BUF_WRAP_PRIVATE(out, git_filter_list__apply_to_blob, filters, blob);
+}
+
+int git_filter_list__apply_to_blob(
+	git_str *out,
+	git_filter_list *filters,
+	git_blob *blob)
 {
 	struct buf_stream writer;
 	int error;
@@ -849,12 +874,13 @@ int git_filter_list_apply_to_blob(
 struct buffered_stream {
 	git_writestream parent;
 	git_filter *filter;
-	int (*write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *);
+	int (*write_fn)(git_filter *, void **, git_str *, const git_str *, const git_filter_source *);
+	int (*legacy_write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *);
 	const git_filter_source *source;
 	void **payload;
-	git_buf input;
-	git_buf temp_buf;
-	git_buf *output;
+	git_str input;
+	git_str temp_buf;
+	git_str *output;
 	git_writestream *target;
 };
 
@@ -864,18 +890,48 @@ static int buffered_stream_write(
 	struct buffered_stream *buffered_stream = (struct buffered_stream *)s;
 	GIT_ASSERT_ARG(buffered_stream);
 
-	return git_buf_put(&buffered_stream->input, buffer, len);
+	return git_str_put(&buffered_stream->input, buffer, len);
 }
 
+#ifndef GIT_DEPRECATE_HARD
+# define BUF_TO_STRUCT(b, s) \
+	(b)->ptr = (s)->ptr; \
+	(b)->size = (s)->size;  \
+	(b)->reserved = (s)->asize;
+# define STRUCT_TO_BUF(s, b) \
+	(s)->ptr = (b)->ptr; \
+	(s)->size = (b)->size; \
+	(s)->asize = (b)->reserved;
+#endif
+
 static int buffered_stream_close(git_writestream *s)
 {
 	struct buffered_stream *buffered_stream = (struct buffered_stream *)s;
-	git_buf *writebuf;
+	git_str *writebuf;
 	git_error_state error_state = {0};
 	int error;
 
 	GIT_ASSERT_ARG(buffered_stream);
 
+#ifndef GIT_DEPRECATE_HARD
+	if (buffered_stream->write_fn == NULL) {
+		git_buf legacy_output = GIT_BUF_INIT,
+		        legacy_input = GIT_BUF_INIT;
+
+		BUF_TO_STRUCT(&legacy_output, buffered_stream->output);
+		BUF_TO_STRUCT(&legacy_input, &buffered_stream->input);
+
+		error = buffered_stream->legacy_write_fn(
+			buffered_stream->filter,
+			buffered_stream->payload,
+			&legacy_output,
+			&legacy_input,
+			buffered_stream->source);
+
+		STRUCT_TO_BUF(buffered_stream->output, &legacy_output);
+		STRUCT_TO_BUF(&buffered_stream->input, &legacy_input);
+	} else
+#endif
 	error = buffered_stream->write_fn(
 		buffered_stream->filter,
 		buffered_stream->payload,
@@ -886,9 +942,6 @@ static int buffered_stream_close(git_writestream *s)
 	if (error == GIT_PASSTHROUGH) {
 		writebuf = &buffered_stream->input;
 	} else if (error == 0) {
-		if ((error = git_buf_sanitize(buffered_stream->output)) < 0)
-			return error;
-
 		writebuf = buffered_stream->output;
 	} else {
 		/* close stream before erroring out taking care
@@ -911,8 +964,8 @@ static void buffered_stream_free(git_writestream *s)
 	struct buffered_stream *buffered_stream = (struct buffered_stream *)s;
 
 	if (buffered_stream) {
-		git_buf_dispose(&buffered_stream->input);
-		git_buf_dispose(&buffered_stream->temp_buf);
+		git_str_dispose(&buffered_stream->input);
+		git_str_dispose(&buffered_stream->temp_buf);
 		git__free(buffered_stream);
 	}
 }
@@ -920,8 +973,8 @@ static void buffered_stream_free(git_writestream *s)
 int git_filter_buffered_stream_new(
 	git_writestream **out,
 	git_filter *filter,
-	int (*write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *),
-	git_buf *temp_buf,
+	int (*write_fn)(git_filter *, void **, git_str *, const git_str *, const git_filter_source *),
+	git_str *temp_buf,
 	void **payload,
 	const git_filter_source *source,
 	git_writestream *target)
@@ -940,11 +993,42 @@ int git_filter_buffered_stream_new(
 	buffered_stream->target = target;
 
 	if (temp_buf)
-		git_buf_clear(temp_buf);
+		git_str_clear(temp_buf);
+
+	*out = (git_writestream *)buffered_stream;
+	return 0;
+}
+
+#ifndef GIT_DEPRECATE_HARD
+static int buffered_legacy_stream_new(
+	git_writestream **out,
+	git_filter *filter,
+	int (*legacy_write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *),
+	git_str *temp_buf,
+	void **payload,
+	const git_filter_source *source,
+	git_writestream *target)
+{
+	struct buffered_stream *buffered_stream = git__calloc(1, sizeof(struct buffered_stream));
+	GIT_ERROR_CHECK_ALLOC(buffered_stream);
+
+	buffered_stream->parent.write = buffered_stream_write;
+	buffered_stream->parent.close = buffered_stream_close;
+	buffered_stream->parent.free = buffered_stream_free;
+	buffered_stream->filter = filter;
+	buffered_stream->legacy_write_fn = legacy_write_fn;
+	buffered_stream->output = temp_buf ? temp_buf : &buffered_stream->temp_buf;
+	buffered_stream->payload = payload;
+	buffered_stream->source = source;
+	buffered_stream->target = target;
+
+	if (temp_buf)
+		git_str_clear(temp_buf);
 
 	*out = (git_writestream *)buffered_stream;
 	return 0;
 }
+#endif
 
 static int setup_stream(
 	git_writestream **out,
@@ -961,7 +1045,7 @@ static int setup_stream(
 	 */
 	if (!fe->filter->stream) {
 		/* Create a stream that proxies the one-shot apply */
-		return git_filter_buffered_stream_new(out,
+		return buffered_legacy_stream_new(out,
 			fe->filter, fe->filter->apply, filters->temp_buf,
 			&fe->payload, &filters->source, last_stream);
 	}
@@ -1031,8 +1115,8 @@ int git_filter_list_stream_file(
 	const char *path,
 	git_writestream *target)
 {
-	char buf[FILTERIO_BUFSIZE];
-	git_buf abspath = GIT_BUF_INIT;
+	char buf[GIT_BUFSIZE_FILTERIO];
+	git_str abspath = GIT_STR_INIT;
 	const char *base = repo ? git_repository_workdir(repo) : NULL;
 	git_vector filter_streams = GIT_VECTOR_INIT;
 	git_writestream *stream_start;
@@ -1041,8 +1125,8 @@ int git_filter_list_stream_file(
 
 	if ((error = stream_list_init(
 			&stream_start, &filter_streams, filters, target)) < 0 ||
-	    (error = git_path_join_unrooted(&abspath, path, base, NULL)) < 0 ||
-	    (error = git_path_validate_workdir_buf(repo, &abspath)) < 0)
+	    (error = git_fs_path_join_unrooted(&abspath, path, base, NULL)) < 0 ||
+	    (error = git_path_validate_str_length(repo, &abspath)) < 0)
 		goto done;
 
 	initialized = 1;
@@ -1067,7 +1151,7 @@ done:
 	if (fd >= 0)
 		p_close(fd);
 	filter_streams_free(&filter_streams);
-	git_buf_dispose(&abspath);
+	git_str_dispose(&abspath);
 	return error;
 }
 
@@ -1101,7 +1185,7 @@ int git_filter_list_stream_blob(
 	git_blob *blob,
 	git_writestream *target)
 {
-	git_buf in = GIT_BUF_INIT;
+	git_str in = GIT_STR_INIT;
 
 	if (buf_from_blob(&in, blob) < 0)
 		return -1;
@@ -1125,22 +1209,12 @@ int git_filter_list_stream_data(
 	git_buf *data,
 	git_writestream *target)
 {
-	int error;
-
-	if ((error = git_buf_sanitize(data)) < 0)
-		return error;
-
 	return git_filter_list_stream_buffer(filters, data->ptr, data->size, target);
 }
 
 int git_filter_list_apply_to_data(
 	git_buf *tgt, git_filter_list *filters, git_buf *src)
 {
-	int error;
-
-	if ((error = git_buf_sanitize(src)) < 0)
-	    return error;
-
 	return git_filter_list_apply_to_buffer(tgt, filters, src->ptr, src->size);
 }
 

data/vendor/libgit2/src/{filter.h → libgit2/filter.h}

@@ -19,7 +19,7 @@
 typedef struct {
 	git_filter_options options;
 	git_attr_session *attr_session;
-	git_buf *temp_buf;
+	git_str *temp_buf;
 } git_filter_session;
 
 #define GIT_FILTER_SESSION_INIT {GIT_FILTER_OPTIONS_INIT, 0}
@@ -36,14 +36,35 @@ extern int git_filter_list__load(
 	git_filter_mode_t mode,
 	git_filter_session *filter_session);
 
+int git_filter_list__apply_to_buffer(
+	git_str *out,
+	git_filter_list *filters,
+	const char *in,
+	size_t in_len);
+int git_filter_list__apply_to_file(
+	git_str *out,
+	git_filter_list *filters,
+	git_repository *repo,
+	const char *path);
+int git_filter_list__apply_to_blob(
+	git_str *out,
+	git_filter_list *filters,
+	git_blob *blob);
+
 /*
  * The given input buffer will be converted to the given output buffer.
  * The input buffer will be freed (_if_ it was allocated).
  */
 extern int git_filter_list__convert_buf(
-	git_buf *out,
+	git_str *out,
+	git_filter_list *filters,
+	git_str *in);
+
+extern int git_filter_list__apply_to_file(
+	git_str *out,
 	git_filter_list *filters,
-	git_buf *in);
+	git_repository *repo,
+	const char *path);
 
 /*
  * Available filters
@@ -55,8 +76,8 @@ extern git_filter *git_ident_filter_new(void);
 extern int git_filter_buffered_stream_new(
 	git_writestream **out,
 	git_filter *filter,
-	int (*write_fn)(git_filter *, void **, git_buf *, const git_buf *, const git_filter_source *),
-	git_buf *temp_buf,
+	int (*write_fn)(git_filter *, void **, git_str *, const git_str *, const git_filter_source *),
+	git_str *temp_buf,
 	void **payload,
 	const git_filter_source *source,
 	git_writestream *target);

data/vendor/libgit2/src/{ident.c → libgit2/ident.c}

@@ -9,7 +9,7 @@
 
 #include "git2/sys/filter.h"
 #include "filter.h"
-#include "buffer.h"
+#include "str.h"
 
 static int ident_find_id(
 	const char **id_start, const char **id_end, const char *start, size_t len)
@@ -40,9 +40,9 @@ static int ident_find_id(
 }
 
 static int ident_insert_id(
-	git_buf *to, const git_buf *from, const git_filter_source *src)
+	git_str *to, const git_str *from, const git_filter_source *src)
 {
-	char oid[GIT_OID_HEXSZ+1];
+	char oid[GIT_OID_SHA1_HEXSIZE+1];
 	const char *id_start, *id_end, *from_end = from->ptr + from->size;
 	size_t need_size;
 
@@ -57,23 +57,23 @@ static int ident_insert_id(
 		return GIT_PASSTHROUGH;
 
 	need_size = (size_t)(id_start - from->ptr) +
-		5 /* "$Id: " */ + GIT_OID_HEXSZ + 2 /* " $" */ +
+		5 /* "$Id: " */ + GIT_OID_SHA1_HEXSIZE + 2 /* " $" */ +
 		(size_t)(from_end - id_end);
 
-	if (git_buf_grow(to, need_size) < 0)
+	if (git_str_grow(to, need_size) < 0)
 		return -1;
 
-	git_buf_set(to, from->ptr, (size_t)(id_start - from->ptr));
-	git_buf_put(to, "$Id: ", 5);
-	git_buf_put(to, oid, GIT_OID_HEXSZ);
-	git_buf_put(to, " $", 2);
-	git_buf_put(to, id_end, (size_t)(from_end - id_end));
+	git_str_set(to, from->ptr, (size_t)(id_start - from->ptr));
+	git_str_put(to, "$Id: ", 5);
+	git_str_put(to, oid, GIT_OID_SHA1_HEXSIZE);
+	git_str_put(to, " $", 2);
+	git_str_put(to, id_end, (size_t)(from_end - id_end));
 
-	return git_buf_oom(to) ? -1 : 0;
+	return git_str_oom(to) ? -1 : 0;
 }
 
 static int ident_remove_id(
-	git_buf *to, const git_buf *from)
+	git_str *to, const git_str *from)
 {
 	const char *id_start, *id_end, *from_end = from->ptr + from->size;
 	size_t need_size;
@@ -84,27 +84,27 @@ static int ident_remove_id(
 	need_size = (size_t)(id_start - from->ptr) +
 		4 /* "$Id$" */ + (size_t)(from_end - id_end);
 
-	if (git_buf_grow(to, need_size) < 0)
+	if (git_str_grow(to, need_size) < 0)
 		return -1;
 
-	git_buf_set(to, from->ptr, (size_t)(id_start - from->ptr));
-	git_buf_put(to, "$Id$", 4);
-	git_buf_put(to, id_end, (size_t)(from_end - id_end));
+	git_str_set(to, from->ptr, (size_t)(id_start - from->ptr));
+	git_str_put(to, "$Id$", 4);
+	git_str_put(to, id_end, (size_t)(from_end - id_end));
 
-	return git_buf_oom(to) ? -1 : 0;
+	return git_str_oom(to) ? -1 : 0;
 }
 
 static int ident_apply(
 	git_filter     *self,
 	void          **payload,
-	git_buf        *to,
-	const git_buf  *from,
+	git_str        *to,
+	const git_str  *from,
 	const git_filter_source *src)
 {
 	GIT_UNUSED(self); GIT_UNUSED(payload);
 
 	/* Don't filter binary files */
-	if (git_buf_is_binary(from))
+	if (git_str_is_binary(from))
 		return GIT_PASSTHROUGH;
 
 	if (git_filter_source_mode(src) == GIT_FILTER_SMUDGE)