rugged 1.7.2 → 1.9.6

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;
@@ -81,9 +80,12 @@ static git_blame_hunk *new_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);
 }
 
@@ -104,7 +106,10 @@ static git_blame_hunk *dup_hunk(git_blame_hunk *hunk, git_blame *blame)
 	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;
 	}
@@ -117,12 +122,12 @@ static git_blame_hunk *dup_hunk(git_blame_hunk *hunk, git_blame *blame)
 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;
 	}
 }
 
@@ -139,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;
 	}
@@ -165,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);
 
@@ -178,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 blame->hunks.length;
+}
+
+size_t git_blame_linecount(git_blame *blame)
 {
 	GIT_ASSERT_ARG(blame);
-	return (uint32_t)blame->hunks.length;
+
+	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,
@@ -282,31 +333,55 @@ 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,
 		blame);
@@ -316,9 +391,19 @@ static git_blame_hunk *hunk_from_entry(git_blame__entry *e, git_blame *blame)
 
 	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;
 }
@@ -347,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);
@@ -371,17 +456,25 @@ 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);
 
+		if (!h) {
+			error = -1;
+			goto on_error;
+		}
+
 		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;
@@ -444,21 +537,20 @@ 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);
+		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);
 	}
@@ -484,13 +576,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);
 			GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
-
 			git_vector_insert_sorted(&blame->hunks, blame->current_hunk, NULL);
 		}
 		blame->current_diff_line++;
@@ -498,15 +589,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);

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/cache.c

@@ -14,6 +14,9 @@
 #include "odb.h"
 #include "object.h"
 #include "git2/oid.h"
+#include "hashmap_oid.h"
+
+GIT_HASHMAP_OID_FUNCTIONS(git_cache_oidmap, GIT_HASHMAP_INLINE, git_cached_obj *);
 
 bool git_cache__enabled = true;
 ssize_t git_cache__max_storage = (256 * 1024 * 1024);
@@ -45,9 +48,6 @@ int git_cache_init(git_cache *cache)
 {
 	memset(cache, 0, sizeof(*cache));
 
-	if ((git_oidmap_new(&cache->map)) < 0)
-		return -1;
-
 	if (git_rwlock_init(&cache->lock)) {
 		git_error_set(GIT_ERROR_OS, "failed to initialize cache rwlock");
 		return -1;
@@ -60,15 +60,15 @@ int git_cache_init(git_cache *cache)
 static void clear_cache(git_cache *cache)
 {
 	git_cached_obj *evict = NULL;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	if (git_cache_size(cache) == 0)
 		return;
 
-	git_oidmap_foreach_value(cache->map, evict, {
+	while (git_cache_oidmap_iterate(&iter, NULL, &evict, &cache->map) == 0)
 		git_cached_obj_decref(evict);
-	});
 
-	git_oidmap_clear(cache->map);
+	git_cache_oidmap_clear(&cache->map);
 	git_atomic_ssize_add(&git_cache__current_storage, -cache->used_memory);
 	cache->used_memory = 0;
 }
@@ -83,10 +83,15 @@ void git_cache_clear(git_cache *cache)
 	git_rwlock_wrunlock(&cache->lock);
 }
 
+size_t git_cache_size(git_cache *cache)
+{
+	return git_cache_oidmap_size(&cache->map);
+}
+
 void git_cache_dispose(git_cache *cache)
 {
 	git_cache_clear(cache);
-	git_oidmap_free(cache->map);
+	git_cache_oidmap_dispose(&cache->map);
 	git_rwlock_free(&cache->lock);
 	git__memzero(cache, sizeof(*cache));
 }
@@ -94,8 +99,9 @@ void git_cache_dispose(git_cache *cache)
 /* Called with lock */
 static void cache_evict_entries(git_cache *cache)
 {
-	size_t evict_count = git_cache_size(cache) / 2048, i;
+	size_t evict_count = git_cache_size(cache) / 2048;
 	ssize_t evicted_memory = 0;
+	git_hashmap_iter_t iter = GIT_HASHMAP_ITER_INIT;
 
 	if (evict_count < 8)
 		evict_count = 8;
@@ -106,17 +112,16 @@ static void cache_evict_entries(git_cache *cache)
 		return;
 	}
 
-	i = 0;
 	while (evict_count > 0) {
-		git_cached_obj *evict;
 		const git_oid *key;
+		git_cached_obj *evict;
 
-		if (git_oidmap_iterate((void **) &evict, cache->map, &i, &key) == GIT_ITEROVER)
+		if (git_cache_oidmap_iterate(&iter, &key, &evict, &cache->map) != 0)
 			break;
 
 		evict_count--;
 		evicted_memory += evict->size;
-		git_oidmap_delete(cache->map, key);
+		git_cache_oidmap_remove(&cache->map, key);
 		git_cached_obj_decref(evict);
 	}
 
@@ -132,12 +137,12 @@ static bool cache_should_store(git_object_t object_type, size_t object_size)
 
 static void *cache_get(git_cache *cache, const git_oid *oid, unsigned int flags)
 {
-	git_cached_obj *entry;
+	git_cached_obj *entry = NULL;
 
 	if (!git_cache__enabled || git_rwlock_rdlock(&cache->lock) < 0)
 		return NULL;
 
-	if ((entry = git_oidmap_get(cache->map, oid)) != NULL) {
+	if (git_cache_oidmap_get(&entry, &cache->map, oid) == 0) {
 		if (flags && entry->flags != flags) {
 			entry = NULL;
 		} else {
@@ -172,8 +177,8 @@ static void *cache_store(git_cache *cache, git_cached_obj *entry)
 		cache_evict_entries(cache);
 
 	/* not found */
-	if ((stored_entry = git_oidmap_get(cache->map, &entry->oid)) == NULL) {
-		if (git_oidmap_set(cache->map, &entry->oid, entry) == 0) {
+	if (git_cache_oidmap_get(&stored_entry, &cache->map, &entry->oid) != 0) {
+		if (git_cache_oidmap_put(&cache->map, &entry->oid, entry) == 0) {
 			git_cached_obj_incref(entry);
 			cache->used_memory += entry->size;
 			git_atomic_ssize_add(&git_cache__current_storage, (ssize_t)entry->size);
@@ -187,7 +192,7 @@ static void *cache_store(git_cache *cache, git_cached_obj *entry)
 			entry = stored_entry;
 		} else if (stored_entry->flags == GIT_CACHE_STORE_RAW &&
 			   entry->flags == GIT_CACHE_STORE_PARSED) {
-			if (git_oidmap_set(cache->map, &entry->oid, entry) == 0) {
+			if (git_cache_oidmap_put(&cache->map, &entry->oid, entry) == 0) {
 				git_cached_obj_decref(stored_entry);
 				git_cached_obj_incref(entry);
 			} else {

data/vendor/libgit2/src/libgit2/cache.h

@@ -14,7 +14,7 @@
 #include "git2/odb.h"
 
 #include "thread.h"
-#include "oidmap.h"
+#include "hashmap_oid.h"
 
 enum {
 	GIT_CACHE_STORE_ANY = 0,
@@ -30,10 +30,12 @@ typedef struct {
 	git_atomic32 refcount;
 } git_cached_obj;
 
+GIT_HASHMAP_OID_STRUCT(git_cache_oidmap, git_cached_obj *);
+
 typedef struct {
-	git_oidmap *map;
-	git_rwlock  lock;
-	ssize_t     used_memory;
+	git_cache_oidmap map;
+	git_rwlock       lock;
+	ssize_t          used_memory;
 } git_cache;
 
 extern bool git_cache__enabled;
@@ -45,6 +47,7 @@ int git_cache_set_max_object_size(git_object_t type, size_t size);
 int git_cache_init(git_cache *cache);
 void git_cache_dispose(git_cache *cache);
 void git_cache_clear(git_cache *cache);
+size_t git_cache_size(git_cache *cache);
 
 void *git_cache_store_raw(git_cache *cache, git_odb_object *entry);
 void *git_cache_store_parsed(git_cache *cache, git_object *entry);
@@ -53,11 +56,6 @@ git_odb_object *git_cache_get_raw(git_cache *cache, const git_oid *oid);
 git_object *git_cache_get_parsed(git_cache *cache, const git_oid *oid);
 void *git_cache_get_any(git_cache *cache, const git_oid *oid);
 
-GIT_INLINE(size_t) git_cache_size(git_cache *cache)
-{
-	return (size_t)git_oidmap_size(cache->map);
-}
-
 GIT_INLINE(void) git_cached_obj_incref(void *_obj)
 {
 	git_cached_obj *obj = _obj;