rugged 1.3.1 → 1.9.0

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

@@ -19,7 +19,6 @@
 #include "repository.h"
 #include "blame_git.h"
 
-
 static int hunk_byfinalline_search_cmp(const void *key, const void *entry)
 {
 	git_blame_hunk *hunk = (git_blame_hunk*)entry;
@@ -60,10 +59,11 @@ static bool hunk_starts_at_or_after_line(git_blame_hunk *hunk, size_t line)
 }
 
 static git_blame_hunk *new_hunk(
-		size_t start,
-		size_t lines,
-		size_t orig_start,
-		const char *path)
+	size_t start,
+	size_t lines,
+	size_t orig_start,
+	const char *path,
+	git_blame *blame)
 {
 	git_blame_hunk *hunk = git__calloc(1, sizeof(git_blame_hunk));
 	if (!hunk) return NULL;
@@ -72,25 +72,31 @@ static git_blame_hunk *new_hunk(
 	hunk->final_start_line_number = start;
 	hunk->orig_start_line_number = orig_start;
 	hunk->orig_path = path ? git__strdup(path) : NULL;
+	git_oid_clear(&hunk->orig_commit_id, blame->repository->oid_type);
+	git_oid_clear(&hunk->final_commit_id, blame->repository->oid_type);
 
 	return hunk;
 }
 
 static void free_hunk(git_blame_hunk *hunk)
 {
-	git__free((void*)hunk->orig_path);
+	git__free((char *)hunk->orig_path);
+	git__free((char *)hunk->summary);
 	git_signature_free(hunk->final_signature);
+	git_signature_free(hunk->final_committer);
 	git_signature_free(hunk->orig_signature);
+	git_signature_free(hunk->orig_committer);
 	git__free(hunk);
 }
 
-static git_blame_hunk *dup_hunk(git_blame_hunk *hunk)
+static git_blame_hunk *dup_hunk(git_blame_hunk *hunk, git_blame *blame)
 {
 	git_blame_hunk *newhunk = new_hunk(
 			hunk->final_start_line_number,
 			hunk->lines_in_hunk,
 			hunk->orig_start_line_number,
-			hunk->orig_path);
+			hunk->orig_path,
+			blame);
 
 	if (!newhunk)
 		return NULL;
@@ -100,7 +106,10 @@ static git_blame_hunk *dup_hunk(git_blame_hunk *hunk)
 	newhunk->boundary = hunk->boundary;
 
 	if (git_signature_dup(&newhunk->final_signature, hunk->final_signature) < 0 ||
-		git_signature_dup(&newhunk->orig_signature, hunk->orig_signature) < 0) {
+	    git_signature_dup(&newhunk->final_committer, hunk->final_committer) < 0 ||
+	    git_signature_dup(&newhunk->orig_signature, hunk->orig_signature) < 0 ||
+	    git_signature_dup(&newhunk->orig_committer, hunk->orig_committer) < 0 ||
+	    (newhunk->summary = git__strdup(hunk->summary)) == NULL) {
 		free_hunk(newhunk);
 		return NULL;
 	}
@@ -113,12 +122,12 @@ static git_blame_hunk *dup_hunk(git_blame_hunk *hunk)
 static void shift_hunks_by(git_vector *v, size_t start_line, int shift_by)
 {
 	size_t i;
-
-	if (!git_vector_bsearch2(&i, v, hunk_byfinalline_search_cmp, &start_line)) {
-		for (; i < v->length; i++) {
-			git_blame_hunk *hunk = (git_blame_hunk*)v->contents[i];
-			hunk->final_start_line_number += shift_by;
+	for (i = 0; i < v->length; i++) {
+		git_blame_hunk *hunk = (git_blame_hunk*)v->contents[i];
+		if(hunk->final_start_line_number < start_line){
+		        continue;
 		}
+		hunk->final_start_line_number += shift_by;
 	}
 }
 
@@ -135,10 +144,9 @@ git_blame *git_blame__alloc(
 	gbr->options = opts;
 
 	if (git_vector_init(&gbr->hunks, 8, hunk_cmp) < 0 ||
-		git_vector_init(&gbr->paths, 8, paths_cmp) < 0 ||
-		(gbr->path = git__strdup(path)) == NULL ||
-		git_vector_insert(&gbr->paths, git__strdup(path)) < 0)
-	{
+	    git_vector_init(&gbr->paths, 8, paths_cmp) < 0 ||
+	    (gbr->path = git__strdup(path)) == NULL ||
+	    git_vector_insert(&gbr->paths, git__strdup(path)) < 0) {
 		git_blame_free(gbr);
 		return NULL;
 	}
@@ -161,9 +169,11 @@ void git_blame_free(git_blame *blame)
 
 	git_vector_foreach(&blame->hunks, i, hunk)
 		free_hunk(hunk);
-	git_vector_free(&blame->hunks);
 
-	git_vector_free_deep(&blame->paths);
+	git_vector_dispose(&blame->hunks);
+	git_array_clear(blame->lines);
+
+	git_vector_dispose_deep(&blame->paths);
 
 	git_array_clear(blame->line_index);
 
@@ -174,31 +184,76 @@ void git_blame_free(git_blame *blame)
 	git__free(blame);
 }
 
-uint32_t git_blame_get_hunk_count(git_blame *blame)
+size_t git_blame_hunkcount(git_blame *blame)
 {
 	GIT_ASSERT_ARG(blame);
-	return (uint32_t)blame->hunks.length;
+
+	return blame->hunks.length;
+}
+
+size_t git_blame_linecount(git_blame *blame)
+{
+	GIT_ASSERT_ARG(blame);
+
+	return git_array_size(blame->line_index);
+}
+
+const git_blame_line *git_blame_line_byindex(
+	git_blame *blame,
+	size_t idx)
+{
+	GIT_ASSERT_ARG_WITH_RETVAL(blame, NULL);
+	GIT_ASSERT_WITH_RETVAL(idx > 0 && idx <= git_array_size(blame->line_index), NULL);
+
+	return git_array_get(blame->lines, idx - 1);
 }
 
-const git_blame_hunk *git_blame_get_hunk_byindex(git_blame *blame, uint32_t index)
+const git_blame_hunk *git_blame_hunk_byindex(
+	git_blame *blame,
+	size_t index)
 {
 	GIT_ASSERT_ARG_WITH_RETVAL(blame, NULL);
-	return (git_blame_hunk*)git_vector_get(&blame->hunks, index);
+	return git_vector_get(&blame->hunks, index);
 }
 
-const git_blame_hunk *git_blame_get_hunk_byline(git_blame *blame, size_t lineno)
+const git_blame_hunk *git_blame_hunk_byline(
+	git_blame *blame,
+	size_t lineno)
 {
 	size_t i, new_lineno = lineno;
 
 	GIT_ASSERT_ARG_WITH_RETVAL(blame, NULL);
 
-	if (!git_vector_bsearch2(&i, &blame->hunks, hunk_byfinalline_search_cmp, &new_lineno)) {
-		return git_blame_get_hunk_byindex(blame, (uint32_t)i);
-	}
+	if (git_vector_bsearch2(&i, &blame->hunks,
+			hunk_byfinalline_search_cmp, &new_lineno) != 0)
+		return NULL;
+
+	return git_blame_hunk_byindex(blame, i);
+}
 
-	return NULL;
+#ifndef GIT_DEPRECATE_HARD
+uint32_t git_blame_get_hunk_count(git_blame *blame)
+{
+	size_t count = git_blame_hunkcount(blame);
+	GIT_ASSERT(count < UINT32_MAX);
+	return (uint32_t)count;
 }
 
+const git_blame_hunk *git_blame_get_hunk_byindex(
+	git_blame *blame,
+	uint32_t index)
+{
+	return git_blame_hunk_byindex(blame, index);
+}
+
+const git_blame_hunk *git_blame_get_hunk_byline(
+	git_blame *blame,
+	size_t lineno)
+{
+	return git_blame_hunk_byline(blame, lineno);
+}
+#endif
+
 static int normalize_options(
 		git_blame_options *out,
 		const git_blame_options *in,
@@ -235,7 +290,8 @@ static git_blame_hunk *split_hunk_in_vector(
 		git_vector *vec,
 		git_blame_hunk *hunk,
 		size_t rel_line,
-		bool return_new)
+		bool return_new,
+		git_blame *blame)
 {
 	size_t new_line_count;
 	git_blame_hunk *nh;
@@ -248,8 +304,9 @@ static git_blame_hunk *split_hunk_in_vector(
 	}
 
 	new_line_count = hunk->lines_in_hunk - rel_line;
-	nh = new_hunk(hunk->final_start_line_number + rel_line, new_line_count,
-			hunk->orig_start_line_number + rel_line, hunk->orig_path);
+	nh = new_hunk(hunk->final_start_line_number + rel_line,
+		new_line_count, hunk->orig_start_line_number + rel_line,
+		hunk->orig_path, blame);
 
 	if (!nh)
 		return NULL;
@@ -276,42 +333,77 @@ static int index_blob_lines(git_blame *blame)
     const char *buf = blame->final_buf;
     size_t len = blame->final_buf_size;
     int num = 0, incomplete = 0, bol = 1;
+    git_blame_line *line = NULL;
     size_t *i;
 
     if (len && buf[len-1] != '\n')
         incomplete++; /* incomplete line at the end */
+
     while (len--) {
         if (bol) {
             i = git_array_alloc(blame->line_index);
             GIT_ERROR_CHECK_ALLOC(i);
             *i = buf - blame->final_buf;
+
+            GIT_ASSERT(line == NULL);
+            line = git_array_alloc(blame->lines);
+            GIT_ERROR_CHECK_ALLOC(line);
+
+            line->ptr = buf;
             bol = 0;
         }
+
         if (*buf++ == '\n') {
+            GIT_ASSERT(line);
+            line->len = (buf - line->ptr) - 1;
+            line = NULL;
+
             num++;
             bol = 1;
         }
     }
+
     i = git_array_alloc(blame->line_index);
     GIT_ERROR_CHECK_ALLOC(i);
     *i = buf - blame->final_buf;
+
+    if (!bol) {
+        GIT_ASSERT(line);
+        line->len = buf - line->ptr;
+	line = NULL;
+    }
+
+    GIT_ASSERT(!line);
+
     blame->num_lines = num + incomplete;
     return blame->num_lines;
 }
 
 static git_blame_hunk *hunk_from_entry(git_blame__entry *e, git_blame *blame)
 {
+	const char *summary;
 	git_blame_hunk *h = new_hunk(
-			e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path);
+		e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path,
+		blame);
 
 	if (!h)
 		return NULL;
 
 	git_oid_cpy(&h->final_commit_id, git_commit_id(e->suspect->commit));
 	git_oid_cpy(&h->orig_commit_id, git_commit_id(e->suspect->commit));
-	git_commit_author_with_mailmap(
-		&h->final_signature, e->suspect->commit, blame->mailmap);
-	git_signature_dup(&h->orig_signature, h->final_signature);
+
+	if (git_commit_author_with_mailmap(
+		&h->final_signature, e->suspect->commit, blame->mailmap) < 0 ||
+	    git_commit_committer_with_mailmap(
+		&h->final_committer, e->suspect->commit, blame->mailmap) < 0 ||
+	    git_signature_dup(&h->orig_signature, h->final_signature) < 0 ||
+	    git_signature_dup(&h->orig_committer, h->final_committer) < 0 ||
+	    (summary = git_commit_summary(e->suspect->commit)) == NULL ||
+	    (h->summary = git__strdup(summary)) == NULL) {
+		free_hunk(h);
+		return NULL;
+	}
+
 	h->boundary = e->is_boundary ? 1 : 0;
 	return h;
 }
@@ -340,12 +432,12 @@ static int blame_internal(git_blame *blame)
 
 	if ((error = load_blob(blame)) < 0 ||
 	    (error = git_blame__get_origin(&o, blame, blame->final, blame->path)) < 0)
-		goto cleanup;
+		goto on_error;
 
 	if (git_blob_rawsize(blame->final_blob) > SIZE_MAX) {
 		git_error_set(GIT_ERROR_NOMEMORY, "blob is too large to blame");
 		error = -1;
-		goto cleanup;
+		goto on_error;
 	}
 
 	blame->final_buf = git_blob_rawcontent(blame->final_blob);
@@ -364,17 +456,19 @@ static int blame_internal(git_blame *blame)
 
 	blame->ent = ent;
 
-	error = git_blame__like_git(blame, blame->options.flags);
+	if ((error = git_blame__like_git(blame, blame->options.flags)) < 0)
+		goto on_error;
 
-cleanup:
-	for (ent = blame->ent; ent; ) {
-		git_blame__entry *e = ent->next;
+	for (ent = blame->ent; ent; ent = ent->next) {
 		git_blame_hunk *h = hunk_from_entry(ent, blame);
-
 		git_vector_insert(&blame->hunks, h);
+	}
 
+on_error:
+	for (ent = blame->ent; ent; ) {
+		git_blame__entry *next = ent->next;
 		git_blame__free_entry(ent);
-		ent = e;
+		ent = next;
 	}
 
 	return error;
@@ -437,20 +531,21 @@ static int buffer_hunk_cb(
 
 	GIT_UNUSED(delta);
 
-	wedge_line = (hunk->old_lines == 0) ? hunk->new_start : hunk->old_start;
+	wedge_line = (hunk->new_start >= hunk->old_start || hunk->old_lines==0) ? hunk->new_start : hunk->old_start;
 	blame->current_diff_line = wedge_line;
-
-	blame->current_hunk = (git_blame_hunk*)git_blame_get_hunk_byline(blame, wedge_line);
+	blame->current_hunk = (git_blame_hunk*)git_blame_hunk_byline(blame, wedge_line);
 	if (!blame->current_hunk) {
 		/* Line added at the end of the file */
-		blame->current_hunk = new_hunk(wedge_line, 0, wedge_line, blame->path);
+		blame->current_hunk = new_hunk(wedge_line, 0, wedge_line,
+			blame->path, blame);
+		blame->current_diff_line++;
 		GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
-
 		git_vector_insert(&blame->hunks, blame->current_hunk);
 	} else if (!hunk_starts_at_or_after_line(blame->current_hunk, wedge_line)){
 		/* If this hunk doesn't start between existing hunks, split a hunk up so it does */
 		blame->current_hunk = split_hunk_in_vector(&blame->hunks, blame->current_hunk,
-				wedge_line - blame->current_hunk->orig_start_line_number, true);
+				wedge_line - blame->current_hunk->final_start_line_number, true,
+				blame);
 		GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
 	}
 
@@ -475,13 +570,12 @@ static int buffer_line_cb(
 		    hunk_ends_at_or_before_line(blame->current_hunk, blame->current_diff_line)) {
 			/* Append to the current buffer-blame hunk */
 			blame->current_hunk->lines_in_hunk++;
-			shift_hunks_by(&blame->hunks, blame->current_diff_line+1, 1);
+			shift_hunks_by(&blame->hunks, blame->current_diff_line, 1);
 		} else {
 			/* Create a new buffer-blame hunk with this line */
 			shift_hunks_by(&blame->hunks, blame->current_diff_line, 1);
-			blame->current_hunk = new_hunk(blame->current_diff_line, 1, 0, blame->path);
+			blame->current_hunk = new_hunk(blame->current_diff_line, 1, 0, blame->path, blame);
 			GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
-
 			git_vector_insert_sorted(&blame->hunks, blame->current_hunk, NULL);
 		}
 		blame->current_diff_line++;
@@ -489,15 +583,16 @@ static int buffer_line_cb(
 
 	if (line->origin == GIT_DIFF_LINE_DELETION) {
 		/* Trim the line from the current hunk; remove it if it's now empty */
-		size_t shift_base = blame->current_diff_line + blame->current_hunk->lines_in_hunk+1;
+		size_t shift_base = blame->current_diff_line + blame->current_hunk->lines_in_hunk;
 
 		if (--(blame->current_hunk->lines_in_hunk) == 0) {
 			size_t i;
-			shift_base--;
+			size_t i_next;
 			if (!git_vector_search2(&i, &blame->hunks, ptrs_equal_cmp, blame->current_hunk)) {
 				git_vector_remove(&blame->hunks, i);
 				free_hunk(blame->current_hunk);
-				blame->current_hunk = (git_blame_hunk*)git_blame_get_hunk_byindex(blame, (uint32_t)i);
+				i_next = min( i , blame->hunks.length -1);
+				blame->current_hunk = (git_blame_hunk*)git_blame_hunk_byindex(blame, (uint32_t)i_next);
 			}
 		}
 		shift_hunks_by(&blame->hunks, shift_base, -1);
@@ -527,7 +622,7 @@ int git_blame_buffer(
 
 	/* Duplicate all of the hunk structures in the reference blame */
 	git_vector_foreach(&reference->hunks, i, hunk) {
-		git_blame_hunk *h = dup_hunk(hunk);
+		git_blame_hunk *h = dup_hunk(hunk, blame);
 		GIT_ERROR_CHECK_ALLOC(h);
 
 		git_vector_insert(&blame->hunks, h);

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

@@ -71,6 +71,7 @@ struct git_blame {
 	git_blame_options options;
 
 	git_vector hunks;
+	git_array_t(git_blame_line) lines;
 	git_vector paths;
 
 	git_blob *final_blob;

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

@@ -9,7 +9,6 @@
 
 #include "commit.h"
 #include "blob.h"
-#include "xdiff/xinclude.h"
 #include "diff_xdiff.h"
 
 /*
@@ -393,7 +392,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 → libgit2/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)
@@ -51,11 +52,12 @@ void git_blob__free(void *_blob)
 	git__free(blob);
 }
 
-int git_blob__parse_raw(void *_blob, const char *data, size_t size)
+int git_blob__parse_raw(void *_blob, const char *data, size_t size, git_oid_t oid_type)
 {
 	git_blob *blob = (git_blob *) _blob;
 
 	GIT_ASSERT_ARG(blob);
+	GIT_UNUSED(oid_type);
 
 	blob->raw = 1;
 	blob->data.raw.data = data;
@@ -63,11 +65,12 @@ int git_blob__parse_raw(void *_blob, const char *data, size_t size)
 	return 0;
 }
 
-int git_blob__parse(void *_blob, git_odb_object *odb_obj)
+int git_blob__parse(void *_blob, git_odb_object *odb_obj, git_oid_t oid_type)
 {
 	git_blob *blob = (git_blob *) _blob;
 
 	GIT_ASSERT_ARG(blob);
+	GIT_UNUSED(oid_type);
 
 	git_cached_obj_incref((git_cached_obj *)odb_obj);
 	blob->raw = 0;
@@ -100,7 +103,7 @@ static int write_file_stream(
 	git_oid *id, git_odb *odb, const char *path, git_object_size_t file_size)
 {
 	int fd, error;
-	char buffer[FILEIO_BUFSIZE];
+	char buffer[GIT_BUFSIZE_FILEIO];
 	git_odb_stream *stream = NULL;
 	ssize_t read_len = -1;
 	git_object_size_t written = 0;
@@ -142,9 +145,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 +156,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 +196,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 +207,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 +264,7 @@ int git_blob__create_from_paths(
 
 done:
 	git_odb_free(odb);
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 
 	return error;
 }
@@ -276,11 +279,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 +293,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 +333,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 +352,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 +366,7 @@ cleanup:
 	if (error < 0)
 		blob_writestream_free((git_writestream *) stream);
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return error;
 }
 
@@ -391,16 +394,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 +430,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 +442,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));
 

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

@@ -36,9 +36,9 @@ struct git_blob {
 	} while(0)
 
 void git_blob__free(void *blob);
-int git_blob__parse(void *blob, git_odb_object *obj);
-int git_blob__parse_raw(void *blob, const char *data, size_t size);
-int git_blob__getbuf(git_buf *buffer, git_blob *blob);
+int git_blob__parse(void *blob, git_odb_object *obj, git_oid_t oid_type);
+int git_blob__parse_raw(void *blob, const char *data, size_t size, git_oid_t oid_type);
+int git_blob__getbuf(git_str *buffer, git_blob *blob);
 
 extern int git_blob__create_from_paths(
 	git_oid *out_oid,