rugged 1.6.3 → 1.9.0

data/vendor/libgit2/src/libgit2/attrcache.c

@@ -13,6 +13,38 @@
 #include "sysdir.h"
 #include "ignore.h"
 #include "path.h"
+#include "hashmap_str.h"
+
+GIT_HASHMAP_STR_SETUP(git_attr_cache_filemap, git_attr_file_entry *);
+GIT_HASHMAP_STR_SETUP(git_attr_cache_macromap, git_attr_rule *);
+
+struct git_attr_cache {
+	char *cfg_attr_file; /* cached value of core.attributesfile */
+	char *cfg_excl_file; /* cached value of core.excludesfile */
+
+	/* hash path to git_attr_file_entry records */
+	git_attr_cache_filemap files;
+	/* hash name to git_attr_rule */
+	git_attr_cache_macromap macros;
+
+	git_mutex lock;
+	git_pool  pool;
+};
+
+const char *git_attr_cache_attributesfile(git_attr_cache *cache)
+{
+	return cache->cfg_attr_file;
+}
+
+const char *git_attr_cache_excludesfile(git_attr_cache *cache)
+{
+	return cache->cfg_excl_file;
+}
+
+git_pool *git_attr_cache_pool(git_attr_cache *cache)
+{
+	return &cache->pool;
+}
 
 GIT_INLINE(int) attr_cache_lock(git_attr_cache *cache)
 {
@@ -34,7 +66,12 @@ GIT_INLINE(void) attr_cache_unlock(git_attr_cache *cache)
 GIT_INLINE(git_attr_file_entry *) attr_cache_lookup_entry(
 	git_attr_cache *cache, const char *path)
 {
-	return git_strmap_get(cache->files, path);
+	git_attr_file_entry *result;
+
+	if (git_attr_cache_filemap_get(&result, &cache->files, path) == 0)
+		return result;
+
+	return NULL;
 }
 
 int git_attr_cache__alloc_file_entry(
@@ -92,7 +129,7 @@ static int attr_cache_make_entry(
 		git_repository_workdir(repo), path, &cache->pool)) < 0)
 		return error;
 
-	if ((error = git_strmap_set(cache->files, entry->path, entry)) < 0)
+	if ((error = git_attr_cache_filemap_put(&cache->files, entry->path, entry)) < 0)
 		return error;
 
 	*out = entry;
@@ -271,12 +308,11 @@ bool git_attr_cache__is_cached(
 {
 	git_attr_cache *cache = git_repository_attr_cache(repo);
 	git_attr_file_entry *entry;
-	git_strmap *files;
 
-	if (!cache || !(files = cache->files))
+	if (!cache)
 		return false;
 
-	if ((entry = git_strmap_get(files, filename)) == NULL)
+	if (git_attr_cache_filemap_get(&entry, &cache->files, filename) != 0)
 		return false;
 
 	return entry && (entry->file[source_type] != NULL);
@@ -318,6 +354,9 @@ static int attr_cache__lookup_path(
 
 static void attr_cache__free(git_attr_cache *cache)
 {
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
+	git_attr_rule *rule;
+	git_attr_file_entry *entry;
 	bool unlock;
 
 	if (!cache)
@@ -325,30 +364,24 @@ static void attr_cache__free(git_attr_cache *cache)
 
 	unlock = (attr_cache_lock(cache) == 0);
 
-	if (cache->files != NULL) {
-		git_attr_file_entry *entry;
+	while (git_attr_cache_filemap_iterate(&iter, NULL, &entry, &cache->files) == 0) {
 		git_attr_file *file;
-		int i;
-
-		git_strmap_foreach_value(cache->files, entry, {
-			for (i = 0; i < GIT_ATTR_FILE_NUM_SOURCES; ++i) {
-				if ((file = git_atomic_swap(entry->file[i], NULL)) != NULL) {
-					GIT_REFCOUNT_OWN(file, NULL);
-					git_attr_file__free(file);
-				}
+		size_t i;
+
+		for (i = 0; i < GIT_ATTR_FILE_NUM_SOURCES; i++) {
+			if ((file = git_atomic_swap(entry->file[i], NULL)) != NULL) {
+				GIT_REFCOUNT_OWN(file, NULL);
+				git_attr_file__free(file);
 			}
-		});
-		git_strmap_free(cache->files);
+		}
 	}
 
-	if (cache->macros != NULL) {
-		git_attr_rule *rule;
+	iter = GIT_HASHMAP_ITER_INIT;
+	while (git_attr_cache_macromap_iterate(&iter, NULL, &rule, &cache->macros) == 0)
+		git_attr_rule__free(rule);
 
-		git_strmap_foreach_value(cache->macros, rule, {
-			git_attr_rule__free(rule);
-		});
-		git_strmap_free(cache->macros);
-	}
+	git_attr_cache_filemap_dispose(&cache->files);
+	git_attr_cache_macromap_dispose(&cache->macros);
 
 	git_pool_clear(&cache->pool);
 
@@ -401,9 +434,7 @@ int git_attr_cache__init(git_repository *repo)
 	/* allocate hashtable for attribute and ignore file contents,
 	 * hashtable for attribute macros, and string pool
 	 */
-	if ((ret = git_strmap_new(&cache->files)) < 0 ||
-	    (ret = git_strmap_new(&cache->macros)) < 0 ||
-	    (ret = git_pool_init(&cache->pool, 1)) < 0)
+	if ((ret = git_pool_init(&cache->pool, 1)) < 0)
 		goto cancel;
 
 	if (git_atomic_compare_and_swap(&repo->attrcache, NULL, cache) != NULL)
@@ -457,11 +488,11 @@ int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
 		goto out;
 	locked = true;
 
-	if ((preexisting = git_strmap_get(cache->macros, macro->match.pattern)) != NULL)
-	    git_attr_rule__free(preexisting);
+	if (git_attr_cache_macromap_get(&preexisting, &cache->macros, macro->match.pattern) == 0)
+		git_attr_rule__free(preexisting);
 
-	if ((error = git_strmap_set(cache->macros, macro->match.pattern, macro)) < 0)
-	    goto out;
+	if ((error = git_attr_cache_macromap_put(&cache->macros, macro->match.pattern, macro)) < 0)
+		goto out;
 
 out:
 	if (locked)
@@ -472,7 +503,12 @@ out:
 git_attr_rule *git_attr_cache__lookup_macro(
 	git_repository *repo, const char *name)
 {
-	git_strmap *macros = git_repository_attr_cache(repo)->macros;
+	git_attr_cache *cache = git_repository_attr_cache(repo);
+	git_attr_rule *rule;
+
+	if (!cache ||
+	    git_attr_cache_macromap_get(&rule, &cache->macros, name) != 0)
+		return NULL;
 
-	return git_strmap_get(macros, name);
+	return rule;
 }

data/vendor/libgit2/src/libgit2/attrcache.h

@@ -10,22 +10,18 @@
 #include "common.h"
 
 #include "attr_file.h"
-#include "strmap.h"
 
 #define GIT_ATTR_CONFIG       "core.attributesfile"
 #define GIT_IGNORE_CONFIG     "core.excludesfile"
 
-typedef struct {
-	char *cfg_attr_file; /* cached value of core.attributesfile */
-	char *cfg_excl_file; /* cached value of core.excludesfile */
-	git_strmap *files;	 /* hash path to git_attr_cache_entry records */
-	git_strmap *macros;	 /* hash name to vector<git_attr_assignment> */
-	git_mutex lock;
-	git_pool  pool;
-} git_attr_cache;
+typedef struct git_attr_cache git_attr_cache;
 
 extern int git_attr_cache__init(git_repository *repo);
 
+extern const char *git_attr_cache_attributesfile(git_attr_cache *ac);
+extern const char *git_attr_cache_excludesfile(git_attr_cache *ac);
+extern git_pool *git_attr_cache_pool(git_attr_cache *ac);
+
 /* get file - loading and reload as needed */
 extern int git_attr_cache__get(
 	git_attr_file **file,

data/vendor/libgit2/src/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,27 +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, GIT_OID_SHA1);
-	git_oid_clear(&hunk->final_commit_id, GIT_OID_SHA1);
+	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;
@@ -102,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;
 	}
@@ -115,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;
 	}
 }
 
@@ -137,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;
 	}
@@ -163,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);
 
@@ -176,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,
@@ -237,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;
@@ -250,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;
@@ -278,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;
 }
@@ -342,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);
@@ -366,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;
@@ -439,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);
 	}
 
@@ -477,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++;
@@ -491,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);
@@ -529,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/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/libgit2/blame_git.c

@@ -9,7 +9,6 @@
 
 #include "commit.h"
 #include "blob.h"
-#include "xdiff/xinclude.h"
 #include "diff_xdiff.h"
 
 /*

data/vendor/libgit2/src/libgit2/branch.c

@@ -134,9 +134,9 @@ int git_branch_create(
 	const git_commit *commit,
 	int force)
 {
-	char commit_id[GIT_OID_SHA1_HEXSIZE + 1];
+	char commit_id[GIT_OID_MAX_HEXSIZE + 1];
 
-	git_oid_tostr(commit_id, GIT_OID_SHA1_HEXSIZE + 1, git_commit_id(commit));
+	git_oid_tostr(commit_id, GIT_OID_MAX_HEXSIZE + 1, git_commit_id(commit));
 	return create_branch(ref_out, repository, branch_name, commit, commit_id, force);
 }