rugged 1.3.2.3 → 1.4.2

data/vendor/libgit2/src/apply.c

@@ -265,7 +265,7 @@ done:
 }
 
 static int apply_hunks(
-	git_buf *out,
+	git_str *out,
 	const char *source,
 	size_t source_len,
 	git_patch *patch,
@@ -286,7 +286,7 @@ static int apply_hunks(
 	}
 
 	git_vector_foreach(&image.lines, i, line)
-		git_buf_put(out, line->content, line->content_len);
+		git_str_put(out, line->content, line->content_len);
 
 done:
 	patch_image_free(&image);
@@ -295,24 +295,24 @@ done:
 }
 
 static int apply_binary_delta(
-	git_buf *out,
+	git_str *out,
 	const char *source,
 	size_t source_len,
 	git_diff_binary_file *binary_file)
 {
-	git_buf inflated = GIT_BUF_INIT;
+	git_str inflated = GIT_STR_INIT;
 	int error = 0;
 
 	/* no diff means identical contents */
 	if (binary_file->datalen == 0)
-		return git_buf_put(out, source, source_len);
+		return git_str_put(out, source, source_len);
 
 	error = git_zstream_inflatebuf(&inflated,
 		binary_file->data, binary_file->datalen);
 
 	if (!error && inflated.size != binary_file->inflatedlen) {
 		error = apply_err("inflated delta does not match expected length");
-		git_buf_dispose(out);
+		git_str_dispose(out);
 	}
 
 	if (error < 0)
@@ -330,7 +330,7 @@ static int apply_binary_delta(
 		out->asize = data_len;
 	}
 	else if (binary_file->type == GIT_DIFF_BINARY_LITERAL) {
-		git_buf_swap(out, &inflated);
+		git_str_swap(out, &inflated);
 	}
 	else {
 		error = apply_err("unknown binary delta type");
@@ -338,17 +338,17 @@ static int apply_binary_delta(
 	}
 
 done:
-	git_buf_dispose(&inflated);
+	git_str_dispose(&inflated);
 	return error;
 }
 
 static int apply_binary(
-	git_buf *out,
+	git_str *out,
 	const char *source,
 	size_t source_len,
 	git_patch *patch)
 {
-	git_buf reverse = GIT_BUF_INIT;
+	git_str reverse = GIT_STR_INIT;
 	int error = 0;
 
 	if (!patch->binary.contains_data) {
@@ -378,14 +378,14 @@ static int apply_binary(
 
 done:
 	if (error < 0)
-		git_buf_dispose(out);
+		git_str_dispose(out);
 
-	git_buf_dispose(&reverse);
+	git_str_dispose(&reverse);
 	return error;
 }
 
 int git_apply__patch(
-	git_buf *contents_out,
+	git_str *contents_out,
 	char **filename_out,
 	unsigned int *mode_out,
 	const char *source,
@@ -423,13 +423,13 @@ int git_apply__patch(
 	else if (patch->hunks.size)
 		error = apply_hunks(contents_out, source, source_len, patch, &ctx);
 	else
-		error = git_buf_put(contents_out, source, source_len);
+		error = git_str_put(contents_out, source, source_len);
 
 	if (error)
 		goto done;
 
 	if (patch->delta->status == GIT_DELTA_DELETED &&
-		git_buf_len(contents_out) > 0) {
+		git_str_len(contents_out) > 0) {
 		error = apply_err("removal patch leaves file contents");
 		goto done;
 	}
@@ -456,7 +456,7 @@ static int apply_one(
 	const git_apply_options *opts)
 {
 	git_patch *patch = NULL;
-	git_buf pre_contents = GIT_BUF_INIT, post_contents = GIT_BUF_INIT;
+	git_str pre_contents = GIT_STR_INIT, post_contents = GIT_STR_INIT;
 	const git_diff_delta *delta;
 	char *filename = NULL;
 	unsigned int mode;
@@ -579,8 +579,8 @@ static int apply_one(
 		git_strmap_delete(removed_paths, delta->new_file.path);
 
 done:
-	git_buf_dispose(&pre_contents);
-	git_buf_dispose(&post_contents);
+	git_str_dispose(&pre_contents);
+	git_str_dispose(&post_contents);
 	git__free(filename);
 	git_patch_free(patch);
 

data/vendor/libgit2/src/apply.h

@@ -11,10 +11,10 @@
 
 #include "git2/patch.h"
 #include "git2/apply.h"
-#include "buffer.h"
+#include "str.h"
 
 extern int git_apply__patch(
-	git_buf *out,
+	git_str *out,
 	char **filename,
 	unsigned int *mode,
 	const char *source,

data/vendor/libgit2/src/attr.c

@@ -338,7 +338,7 @@ GIT_INLINE(int) preload_attr_file(
 }
 
 static int system_attr_file(
-	git_buf *out,
+	git_str *out,
 	git_attr_session *attr_session)
 {
 	int error;
@@ -366,11 +366,11 @@ static int system_attr_file(
 	if (attr_session->sysdir.size == 0)
 		return GIT_ENOTFOUND;
 
-	/* We can safely provide a git_buf with no allocation (asize == 0) to
-	 * a consumer. This allows them to treat this as a regular `git_buf`,
-	 * but their call to `git_buf_dispose` will not attempt to free it.
+	/* We can safely provide a git_str with no allocation (asize == 0) to
+	 * a consumer. This allows them to treat this as a regular `git_str`,
+	 * but their call to `git_str_dispose` will not attempt to free it.
 	 */
-	git_buf_attach_notowned(
+	git_str_attach_notowned(
 		out, attr_session->sysdir.ptr, attr_session->sysdir.size);
 	return 0;
 }
@@ -380,7 +380,7 @@ static int attr_setup(
 	git_attr_session *attr_session,
 	git_attr_options *opts)
 {
-	git_buf system = GIT_BUF_INIT, info = GIT_BUF_INIT;
+	git_str system = GIT_STR_INIT, info = GIT_STR_INIT;
 	git_attr_file_source index_source = { GIT_ATTR_FILE_SOURCE_INDEX, NULL, GIT_ATTR_FILE, NULL };
 	git_attr_file_source head_source = { GIT_ATTR_FILE_SOURCE_HEAD, NULL, GIT_ATTR_FILE, NULL };
 	git_attr_file_source commit_source = { GIT_ATTR_FILE_SOURCE_COMMIT, NULL, GIT_ATTR_FILE, NULL };
@@ -411,7 +411,7 @@ static int attr_setup(
 	                               git_repository_attr_cache(repo)->cfg_attr_file)) < 0)
 		goto out;
 
-	if ((error = git_repository_item_path(&info, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
+	if ((error = git_repository__item_path(&info, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
 	    (error = preload_attr_file(repo, attr_session, info.ptr, GIT_ATTR_FILE_INREPO)) < 0) {
 		if (error != GIT_ENOTFOUND)
 			goto out;
@@ -447,8 +447,8 @@ static int attr_setup(
 		attr_session->init_setup = 1;
 
 out:
-	git_buf_dispose(&system);
-	git_buf_dispose(&info);
+	git_str_dispose(&system);
+	git_str_dispose(&info);
 
 	return error;
 }
@@ -625,11 +625,11 @@ static int collect_attr_files(
 	git_vector *files)
 {
 	int error = 0;
-	git_buf dir = GIT_BUF_INIT, attrfile = GIT_BUF_INIT;
+	git_str dir = GIT_STR_INIT, attrfile = GIT_STR_INIT;
 	const char *workdir = git_repository_workdir(repo);
 	attr_walk_up_info info = { NULL };
 
-	GIT_ASSERT(!git_path_is_absolute(path));
+	GIT_ASSERT(!git_fs_path_is_absolute(path));
 
 	if ((error = attr_setup(repo, attr_session, opts)) < 0)
 		return error;
@@ -637,23 +637,23 @@ static int collect_attr_files(
 	/* Resolve path in a non-bare repo */
 	if (workdir != NULL) {
 		if (!(error = git_repository_workdir_path(&dir, repo, path)))
-			error = git_path_find_dir(&dir);
+			error = git_fs_path_find_dir(&dir);
 	}
 	else {
-		error = git_path_dirname_r(&dir, path);
+		error = git_fs_path_dirname_r(&dir, path);
 	}
 
 	if (error < 0)
 		goto cleanup;
 
-	/* in precendence order highest to lowest:
+	/* in precedence order highest to lowest:
 	 * - $GIT_DIR/info/attributes
 	 * - path components with .gitattributes
 	 * - config core.attributesfile
 	 * - $GIT_PREFIX/etc/gitattributes
 	 */
 
-	if ((error = git_repository_item_path(&attrfile, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
+	if ((error = git_repository__item_path(&attrfile, repo, GIT_REPOSITORY_ITEM_INFO)) < 0 ||
 	    (error = push_attr_file(repo, attr_session, files, attrfile.ptr, GIT_ATTR_FILE_INREPO)) < 0) {
 		if (error != GIT_ENOTFOUND)
 			goto cleanup;
@@ -670,7 +670,7 @@ static int collect_attr_files(
 	if (!strcmp(dir.ptr, "."))
 		error = push_one_attr(&info, "");
 	else
-		error = git_path_walk_up(&dir, workdir, push_one_attr, &info);
+		error = git_fs_path_walk_up(&dir, workdir, push_one_attr, &info);
 
 	if (error < 0)
 		goto cleanup;
@@ -693,8 +693,8 @@ static int collect_attr_files(
  cleanup:
 	if (error < 0)
 		release_attr_files(files);
-	git_buf_dispose(&attrfile);
-	git_buf_dispose(&dir);
+	git_str_dispose(&attrfile);
+	git_str_dispose(&dir);
 
 	return error;
 }

data/vendor/libgit2/src/attr_file.c

@@ -117,13 +117,13 @@ int git_attr_file__load(
 	git_tree *tree = NULL;
 	git_tree_entry *tree_entry = NULL;
 	git_blob *blob = NULL;
-	git_buf content = GIT_BUF_INIT;
+	git_str content = GIT_STR_INIT;
 	const char *content_str;
 	git_attr_file *file;
 	struct stat st;
 	bool nonexistent = false;
 	int bom_offset;
-	git_buf_bom_t bom;
+	git_str_bom_t bom;
 	git_oid id;
 	git_object_size_t blobsize;
 
@@ -143,7 +143,7 @@ int git_attr_file__load(
 		blobsize = git_blob_rawsize(blob);
 
 		GIT_ERROR_CHECK_BLOBSIZE(blobsize);
-		git_buf_put(&content, git_blob_rawcontent(blob), (size_t)blobsize);
+		git_str_put(&content, git_blob_rawcontent(blob), (size_t)blobsize);
 		break;
 	}
 	case GIT_ATTR_FILE_SOURCE_FILE: {
@@ -198,7 +198,7 @@ int git_attr_file__load(
 		blobsize = git_blob_rawsize(blob);
 
 		GIT_ERROR_CHECK_BLOBSIZE(blobsize);
-		if ((error = git_buf_put(&content,
+		if ((error = git_str_put(&content,
 			git_blob_rawcontent(blob), (size_t)blobsize)) < 0)
 			goto cleanup;
 
@@ -213,10 +213,10 @@ int git_attr_file__load(
 		goto cleanup;
 
 	/* advance over a UTF8 BOM */
-	content_str = git_buf_cstr(&content);
-	bom_offset = git_buf_detect_bom(&bom, &content);
+	content_str = git_str_cstr(&content);
+	bom_offset = git_str_detect_bom(&bom, &content);
 
-	if (bom == GIT_BUF_BOM_UTF8)
+	if (bom == GIT_STR_BOM_UTF8)
 		content_str += bom_offset;
 
 	/* store the key of the attr_reader; don't bother with cache
@@ -250,7 +250,7 @@ cleanup:
 	git_tree_entry_free(tree_entry);
 	git_tree_free(tree);
 	git_commit_free(commit);
-	git_buf_dispose(&content);
+	git_str_dispose(&content);
 
 	return error;
 }
@@ -345,7 +345,7 @@ int git_attr_file__parse_buffer(
 	int error = 0;
 
 	/* If subdir file path, convert context for file paths */
-	if (attrs->entry && git_path_root(attrs->entry->path) < 0 &&
+	if (attrs->entry && git_fs_path_root(attrs->entry->path) < 0 &&
 	    !git__suffixcmp(attrs->entry->path, "/" GIT_ATTR_FILE))
 		context = attrs->entry->path;
 
@@ -435,7 +435,7 @@ int git_attr_file__lookup_one(
 
 int git_attr_file__load_standalone(git_attr_file **out, const char *path)
 {
-	git_buf content = GIT_BUF_INIT;
+	git_str content = GIT_STR_INIT;
 	git_attr_file_source source = { GIT_ATTR_FILE_SOURCE_FILE };
 	git_attr_file *file = NULL;
 	int error;
@@ -457,7 +457,7 @@ int git_attr_file__load_standalone(git_attr_file **out, const char *path)
 out:
 	if (error < 0)
 		git_attr_file__free(file);
-	git_buf_dispose(&content);
+	git_str_dispose(&content);
 
 	return error;
 }
@@ -558,9 +558,9 @@ int git_attr_path__init(
 	ssize_t root;
 
 	/* build full path as best we can */
-	git_buf_init(&info->full, 0);
+	git_str_init(&info->full, 0);
 
-	if (git_path_join_unrooted(&info->full, path, base, &root) < 0)
+	if (git_fs_path_join_unrooted(&info->full, path, base, &root) < 0)
 		return -1;
 
 	info->path = info->full.ptr + root;
@@ -596,7 +596,7 @@ int git_attr_path__init(
 
 	case GIT_DIR_FLAG_UNKNOWN:
 	default:
-		info->is_dir = (int)git_path_isdir(info->full.ptr);
+		info->is_dir = (int)git_fs_path_isdir(info->full.ptr);
 		break;
 	}
 
@@ -605,7 +605,7 @@ int git_attr_path__init(
 
 void git_attr_path__free(git_attr_path *info)
 {
-	git_buf_dispose(&info->full);
+	git_str_dispose(&info->full);
 	info->path = NULL;
 	info->basename = NULL;
 }
@@ -1020,8 +1020,8 @@ void git_attr_session__free(git_attr_session *session)
 	if (!session)
 		return;
 
-	git_buf_dispose(&session->sysdir);
-	git_buf_dispose(&session->tmp);
+	git_str_dispose(&session->sysdir);
+	git_str_dispose(&session->tmp);
 
 	memset(session, 0, sizeof(git_attr_session));
 }

data/vendor/libgit2/src/attr_file.h

@@ -13,7 +13,7 @@
 #include "git2/attr.h"
 #include "vector.h"
 #include "pool.h"
-#include "buffer.h"
+#include "str.h"
 #include "futils.h"
 
 #define GIT_ATTR_FILE			".gitattributes"
@@ -118,7 +118,7 @@ struct git_attr_file_entry {
 };
 
 typedef struct {
-	git_buf  full;
+	git_str  full;
 	char    *path;
 	char    *basename;
 	int      is_dir;
@@ -132,8 +132,8 @@ typedef struct {
 	int key;
 	unsigned int init_setup:1,
 		init_sysdir:1;
-	git_buf sysdir;
-	git_buf tmp;
+	git_str sysdir;
+	git_str tmp;
 } git_attr_session;
 
 extern int git_attr_session__init(git_attr_session *attr_session, git_repository *repo);

data/vendor/libgit2/src/attrcache.c

@@ -12,6 +12,7 @@
 #include "config.h"
 #include "sysdir.h"
 #include "ignore.h"
+#include "path.h"
 
 GIT_INLINE(int) attr_cache_lock(git_attr_cache *cache)
 {
@@ -43,11 +44,12 @@ int git_attr_cache__alloc_file_entry(
 	const char *path,
 	git_pool *pool)
 {
+	git_str fullpath_str = GIT_STR_INIT;
 	size_t baselen = 0, pathlen = strlen(path);
 	size_t cachesize = sizeof(git_attr_file_entry) + pathlen + 1;
 	git_attr_file_entry *ce;
 
-	if (base != NULL && git_path_root(path) < 0) {
+	if (base != NULL && git_fs_path_root(path) < 0) {
 		baselen = strlen(base);
 		cachesize += baselen;
 
@@ -66,7 +68,10 @@ int git_attr_cache__alloc_file_entry(
 	}
 	memcpy(&ce->fullpath[baselen], path, pathlen);
 
-	if (git_path_validate_workdir_with_len(repo, ce->fullpath, pathlen + baselen) < 0)
+	fullpath_str.ptr = ce->fullpath;
+	fullpath_str.size = pathlen + baselen;
+
+	if (git_path_validate_str_length(repo, &fullpath_str) < 0)
 		return -1;
 
 	ce->path = &ce->fullpath[baselen];
@@ -161,7 +166,7 @@ static int attr_cache_lookup(
 	git_attr_file_source *source)
 {
 	int error = 0;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	const char *wd = git_repository_workdir(repo);
 	const char *filename;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
@@ -169,11 +174,11 @@ static int attr_cache_lookup(
 	git_attr_file *file = NULL;
 
 	/* join base and path as needed */
-	if (source->base != NULL && git_path_root(source->filename) < 0) {
-		git_buf *p = attr_session ? &attr_session->tmp : &path;
+	if (source->base != NULL && git_fs_path_root(source->filename) < 0) {
+		git_str *p = attr_session ? &attr_session->tmp : &path;
 
-		if (git_buf_joinpath(p, source->base, source->filename) < 0 ||
-		    git_path_validate_workdir_buf(repo, p) < 0)
+		if (git_str_joinpath(p, source->base, source->filename) < 0 ||
+		    git_path_validate_str_length(repo, p) < 0)
 			return -1;
 
 		filename = p->ptr;
@@ -203,7 +208,7 @@ cleanup:
 	*out_file  = file;
 	*out_entry = entry;
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return error;
 }
 
@@ -281,7 +286,7 @@ bool git_attr_cache__is_cached(
 static int attr_cache__lookup_path(
 	char **out, git_config *cfg, const char *key, const char *fallback)
 {
-	git_buf buf = GIT_BUF_INIT;
+	git_str buf = GIT_STR_INIT;
 	int error;
 	git_config_entry *entry = NULL;
 
@@ -296,17 +301,17 @@ static int attr_cache__lookup_path(
 		/* expand leading ~/ as needed */
 		if (cfgval && cfgval[0] == '~' && cfgval[1] == '/') {
 			if (! (error = git_sysdir_expand_global_file(&buf, &cfgval[2])))
-				*out = git_buf_detach(&buf);
+				*out = git_str_detach(&buf);
 		} else if (cfgval) {
 			*out = git__strdup(cfgval);
 		}
 	}
 	else if (!git_sysdir_find_xdg_file(&buf, fallback)) {
-		*out = git_buf_detach(&buf);
+		*out = git_str_detach(&buf);
 	}
 
 	git_config_entry_free(entry);
-	git_buf_dispose(&buf);
+	git_str_dispose(&buf);
 
 	return error;
 }

data/vendor/libgit2/src/blame_git.c

@@ -393,7 +393,7 @@ static void fill_origin_blob(git_blame__origin *o, mmfile_t *file)
 	memset(file, 0, sizeof(*file));
 	if (o->blob) {
 		file->ptr = (char*)git_blob_rawcontent(o->blob);
-		file->size = (size_t)git_blob_rawsize(o->blob);
+		file->size = (long)git_blob_rawsize(o->blob);
 	}
 }
 

data/vendor/libgit2/src/blob.c

@@ -12,6 +12,7 @@
 #include "git2/repository.h"
 #include "git2/odb_backend.h"
 
+#include "buf.h"
 #include "filebuf.h"
 #include "filter.h"
 
@@ -35,12 +36,12 @@ git_object_size_t git_blob_rawsize(const git_blob *blob)
 		return (git_object_size_t)git_odb_object_size(blob->data.odb);
 }
 
-int git_blob__getbuf(git_buf *buffer, git_blob *blob)
+int git_blob__getbuf(git_str *buffer, git_blob *blob)
 {
 	git_object_size_t size = git_blob_rawsize(blob);
 
 	GIT_ERROR_CHECK_BLOBSIZE(size);
-	return git_buf_set(buffer, git_blob_rawcontent(blob), (size_t)size);
+	return git_str_set(buffer, git_blob_rawcontent(blob), (size_t)size);
 }
 
 void git_blob__free(void *_blob)
@@ -142,9 +143,9 @@ static int write_file_filtered(
 	git_repository* repo)
 {
 	int error;
-	git_buf tgt = GIT_BUF_INIT;
+	git_str tgt = GIT_STR_INIT;
 
-	error = git_filter_list_apply_to_file(&tgt, fl, repo, full_path);
+	error = git_filter_list__apply_to_file(&tgt, fl, repo, full_path);
 
 	/* Write the file to disk if it was properly filtered */
 	if (!error) {
@@ -153,7 +154,7 @@ static int write_file_filtered(
 		error = git_odb_write(id, odb, tgt.ptr, tgt.size, GIT_OBJECT_BLOB);
 	}
 
-	git_buf_dispose(&tgt);
+	git_str_dispose(&tgt);
 	return error;
 }
 
@@ -193,7 +194,7 @@ int git_blob__create_from_paths(
 	git_odb *odb = NULL;
 	git_object_size_t size;
 	mode_t mode;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 
 	GIT_ASSERT_ARG(hint_path || !try_load_filters);
 
@@ -204,7 +205,7 @@ int git_blob__create_from_paths(
 		content_path = path.ptr;
 	}
 
-	if ((error = git_path_lstat(content_path, &st)) < 0 ||
+	if ((error = git_fs_path_lstat(content_path, &st)) < 0 ||
 		(error = git_repository_odb(&odb, repo)) < 0)
 		goto done;
 
@@ -261,7 +262,7 @@ int git_blob__create_from_paths(
 
 done:
 	git_odb_free(odb);
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	return error;
 }
@@ -276,11 +277,11 @@ int git_blob_create_from_disk(
 	git_oid *id, git_repository *repo, const char *path)
 {
 	int error;
-	git_buf full_path = GIT_BUF_INIT;
+	git_str full_path = GIT_STR_INIT;
 	const char *workdir, *hintpath = NULL;
 
-	if ((error = git_path_prettify(&full_path, path, NULL)) < 0) {
-		git_buf_dispose(&full_path);
+	if ((error = git_fs_path_prettify(&full_path, path, NULL)) < 0) {
+		git_str_dispose(&full_path);
 		return error;
 	}
 
@@ -290,9 +291,9 @@ int git_blob_create_from_disk(
 		hintpath = full_path.ptr + strlen(workdir);
 
 	error = git_blob__create_from_paths(
-		id, NULL, repo, git_buf_cstr(&full_path), hintpath, 0, !!hintpath);
+		id, NULL, repo, git_str_cstr(&full_path), hintpath, 0, !!hintpath);
 
-	git_buf_dispose(&full_path);
+	git_str_dispose(&full_path);
 	return error;
 }
 
@@ -330,7 +331,7 @@ static int blob_writestream_write(git_writestream *_stream, const char *buffer,
 int git_blob_create_from_stream(git_writestream **out, git_repository *repo, const char *hintpath)
 {
 	int error;
-	git_buf path = GIT_BUF_INIT;
+	git_str path = GIT_STR_INIT;
 	blob_writestream *stream;
 
 	GIT_ASSERT_ARG(out);
@@ -349,11 +350,11 @@ int git_blob_create_from_stream(git_writestream **out, git_repository *repo, con
 	stream->parent.close = blob_writestream_close;
 	stream->parent.free  = blob_writestream_free;
 
-	if ((error = git_repository_item_path(&path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0
-		|| (error = git_buf_joinpath(&path, path.ptr, "streamed")) < 0)
+	if ((error = git_repository__item_path(&path, repo, GIT_REPOSITORY_ITEM_OBJECTS)) < 0
+		|| (error = git_str_joinpath(&path, path.ptr, "streamed")) < 0)
 		goto cleanup;
 
-	if ((error = git_filebuf_open_withsize(&stream->fbuf, git_buf_cstr(&path), GIT_FILEBUF_TEMPORARY,
+	if ((error = git_filebuf_open_withsize(&stream->fbuf, git_str_cstr(&path), GIT_FILEBUF_TEMPORARY,
 					       0666, 2 * 1024 * 1024)) < 0)
 		goto cleanup;
 
@@ -363,7 +364,7 @@ cleanup:
 	if (error < 0)
 		blob_writestream_free((git_writestream *) stream);
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return error;
 }
 
@@ -391,16 +392,25 @@ cleanup:
 
 int git_blob_is_binary(const git_blob *blob)
 {
-	git_buf content = GIT_BUF_INIT;
+	git_str content = GIT_STR_INIT;
 	git_object_size_t size;
 
 	GIT_ASSERT_ARG(blob);
 
 	size = git_blob_rawsize(blob);
 
-	git_buf_attach_notowned(&content, git_blob_rawcontent(blob),
+	git_str_attach_notowned(&content, git_blob_rawcontent(blob),
 		(size_t)min(size, GIT_FILTER_BYTES_TO_CHECK_NUL));
-	return git_buf_is_binary(&content);
+	return git_str_is_binary(&content);
+}
+
+int git_blob_data_is_binary(const char *str, size_t len)
+{
+	git_str content = GIT_STR_INIT;
+
+	git_str_attach_notowned(&content, str, len);
+
+	return git_str_is_binary(&content);
 }
 
 int git_blob_filter_options_init(
@@ -418,10 +428,10 @@ int git_blob_filter(
 	const char *path,
 	git_blob_filter_options *given_opts)
 {
-	int error = 0;
-	git_filter_list *fl = NULL;
 	git_blob_filter_options opts = GIT_BLOB_FILTER_OPTIONS_INIT;
 	git_filter_options filter_opts = GIT_FILTER_OPTIONS_INIT;
+	git_filter_list *fl = NULL;
+	int error = 0;
 
 	GIT_ASSERT_ARG(blob);
 	GIT_ASSERT_ARG(path);
@@ -430,9 +440,6 @@ int git_blob_filter(
 	GIT_ERROR_CHECK_VERSION(
 		given_opts, GIT_BLOB_FILTER_OPTIONS_VERSION, "git_blob_filter_options");
 
-	if (git_buf_sanitize(out) < 0)
-		return -1;
-
 	if (given_opts != NULL)
 		memcpy(&opts, given_opts, sizeof(git_blob_filter_options));