rugged 0.27.9 → 0.27.10

data/vendor/libgit2/src/attr_file.h

@@ -14,7 +14,7 @@
 #include "vector.h"
 #include "pool.h"
 #include "buffer.h"
-#include "fileops.h"
+#include "futils.h"
 
 #define GIT_ATTR_FILE			".gitattributes"
 #define GIT_ATTR_FILE_INREPO	"attributes"
@@ -32,19 +32,17 @@
 #define GIT_ATTR_FNMATCH_MATCH_ALL	(1U << 8)
 #define GIT_ATTR_FNMATCH_ALLOWNEG   (1U << 9)
 #define GIT_ATTR_FNMATCH_ALLOWMACRO (1U << 10)
-#define GIT_ATTR_FNMATCH_LEADINGDIR (1U << 11)
-#define GIT_ATTR_FNMATCH_NOLEADINGDIR (1U << 12)
 
 #define GIT_ATTR_FNMATCH__INCOMING \
-	(GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG | \
-	 GIT_ATTR_FNMATCH_ALLOWMACRO | GIT_ATTR_FNMATCH_NOLEADINGDIR)
+	(GIT_ATTR_FNMATCH_ALLOWSPACE | GIT_ATTR_FNMATCH_ALLOWNEG | GIT_ATTR_FNMATCH_ALLOWMACRO)
 
 typedef enum {
 	GIT_ATTR_FILE__IN_MEMORY   = 0,
 	GIT_ATTR_FILE__FROM_FILE   = 1,
 	GIT_ATTR_FILE__FROM_INDEX  = 2,
+	GIT_ATTR_FILE__FROM_HEAD   = 3,
 
-	GIT_ATTR_FILE_NUM_SOURCES  = 3
+	GIT_ATTR_FILE_NUM_SOURCES  = 4
 } git_attr_file_source;
 
 extern const char *git_attr__true;
@@ -134,7 +132,8 @@ extern int git_attr_get_many_with_session(
 typedef int (*git_attr_file_parser)(
 	git_repository *repo,
 	git_attr_file *file,
-	const char *data);
+	const char *data,
+	bool allow_macros);
 
 /*
  * git_attr_file API
@@ -153,7 +152,8 @@ int git_attr_file__load(
 	git_attr_session *attr_session,
 	git_attr_file_entry *ce,
 	git_attr_file_source source,
-	git_attr_file_parser parser);
+	git_attr_file_parser parser,
+	bool allow_macros);
 
 int git_attr_file__load_standalone(
 	git_attr_file **out, const char *path);
@@ -162,7 +162,7 @@ int git_attr_file__out_of_date(
 	git_repository *repo, git_attr_session *session, git_attr_file *file);
 
 int git_attr_file__parse_buffer(
-	git_repository *repo, git_attr_file *attrs, const char *data);
+	git_repository *repo, git_attr_file *attrs, const char *data, bool allow_macros);
 
 int git_attr_file__clear_rules(
 	git_attr_file *file, bool need_lock);

data/vendor/libgit2/src/attrcache.c

@@ -18,7 +18,7 @@ GIT_INLINE(int) attr_cache_lock(git_attr_cache *cache)
 	GIT_UNUSED(cache); /* avoid warning if threading is off */
 
 	if (git_mutex_lock(&cache->lock) < 0) {
-		giterr_set(GITERR_OS, "unable to get attr cache lock");
+		git_error_set(GIT_ERROR_OS, "unable to get attr cache lock");
 		return -1;
 	}
 	return 0;
@@ -33,12 +33,7 @@ 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)
 {
-	khiter_t pos = git_strmap_lookup_index(cache->files, path);
-
-	if (git_strmap_valid_index(cache->files, pos))
-		return git_strmap_value_at(cache->files, pos);
-	else
-		return NULL;
+	return git_strmap_get(cache->files, path);
 }
 
 int git_attr_cache__alloc_file_entry(
@@ -59,8 +54,8 @@ int git_attr_cache__alloc_file_entry(
 			cachesize++;
 	}
 
-	ce = git_pool_mallocz(pool, (uint32_t)cachesize);
-	GITERR_CHECK_ALLOC(ce);
+	ce = git_pool_mallocz(pool, cachesize);
+	GIT_ERROR_CHECK_ALLOC(ce);
 
 	if (baselen) {
 		memcpy(ce->fullpath, base, baselen);
@@ -80,18 +75,16 @@ int git_attr_cache__alloc_file_entry(
 static int attr_cache_make_entry(
 	git_attr_file_entry **out, git_repository *repo, const char *path)
 {
-	int error = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
 	git_attr_file_entry *entry = NULL;
+	int error;
 
-	error = git_attr_cache__alloc_file_entry(
-		&entry, git_repository_workdir(repo), path, &cache->pool);
+	if ((error = git_attr_cache__alloc_file_entry(&entry, git_repository_workdir(repo),
+						      path, &cache->pool)) < 0)
+		return error;
 
-	if (!error) {
-		git_strmap_insert(cache->files, entry->path, entry, &error);
-		if (error > 0)
-			error = 0;
-	}
+	if ((error = git_strmap_set(cache->files, entry->path, entry)) < 0)
+		return error;
 
 	*out = entry;
 	return error;
@@ -204,7 +197,7 @@ cleanup:
 	*out_file  = file;
 	*out_entry = entry;
 
-	git_buf_free(&path);
+	git_buf_dispose(&path);
 	return error;
 }
 
@@ -215,7 +208,8 @@ int git_attr_cache__get(
 	git_attr_file_source source,
 	const char *base,
 	const char *filename,
-	git_attr_file_parser parser)
+	git_attr_file_parser parser,
+	bool allow_macros)
 {
 	int error = 0;
 	git_attr_cache *cache = git_repository_attr_cache(repo);
@@ -228,7 +222,7 @@ int git_attr_cache__get(
 
 	/* load file if we don't have one or if existing one is out of date */
 	if (!file || (error = git_attr_file__out_of_date(repo, attr_session, file)) > 0)
-		error = git_attr_file__load(&updated, repo, attr_session, entry, source, parser);
+		error = git_attr_file__load(&updated, repo, attr_session, entry, source, parser, allow_macros);
 
 	/* if we loaded the file, insert into and/or update cache */
 	if (updated) {
@@ -250,7 +244,7 @@ int git_attr_cache__get(
 		}
 		/* no error if file simply doesn't exist */
 		if (error == GIT_ENOTFOUND) {
-			giterr_clear();
+			git_error_clear();
 			error = 0;
 		}
 	}
@@ -265,19 +259,15 @@ bool git_attr_cache__is_cached(
 	const char *filename)
 {
 	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_strmap *files;
-	khiter_t pos;
 	git_attr_file_entry *entry;
+	git_strmap *files;
 
 	if (!cache || !(files = cache->files))
 		return false;
 
-	pos = git_strmap_lookup_index(files, filename);
-	if (!git_strmap_valid_index(files, pos))
+	if ((entry = git_strmap_get(files, filename)) == NULL)
 		return false;
 
-	entry = git_strmap_value_at(files, pos);
-
 	return entry && (entry->file[source] != NULL);
 }
 
@@ -310,7 +300,7 @@ static int attr_cache__lookup_path(
 	}
 
 	git_config_entry_free(entry);
-	git_buf_free(&buf);
+	git_buf_dispose(&buf);
 
 	return error;
 }
@@ -374,11 +364,11 @@ int git_attr_cache__init(git_repository *repo)
 		return 0;
 
 	cache = git__calloc(1, sizeof(git_attr_cache));
-	GITERR_CHECK_ALLOC(cache);
+	GIT_ERROR_CHECK_ALLOC(cache);
 
 	/* set up lock */
 	if (git_mutex_init(&cache->lock) < 0) {
-		giterr_set(GITERR_OS, "unable to initialize lock for attr cache");
+		git_error_set(GIT_ERROR_OS, "unable to initialize lock for attr cache");
 		git__free(cache);
 		return -1;
 	}
@@ -400,8 +390,8 @@ 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_alloc(&cache->files)) < 0 ||
-		(ret = git_strmap_alloc(&cache->macros)) < 0)
+	if ((ret = git_strmap_new(&cache->files)) < 0 ||
+	    (ret = git_strmap_new(&cache->macros)) < 0)
 		goto cancel;
 
 	git_pool_init(&cache->pool, 1);
@@ -435,35 +425,43 @@ void git_attr_cache_flush(git_repository *repo)
 int git_attr_cache__insert_macro(git_repository *repo, git_attr_rule *macro)
 {
 	git_attr_cache *cache = git_repository_attr_cache(repo);
-	git_strmap *macros = cache->macros;
-	int error;
-
-	/* TODO: generate warning log if (macro->assigns.length == 0) */
-	if (macro->assigns.length == 0)
-		return 0;
+	git_attr_rule *preexisting;
+	bool locked = false;
+	int error = 0;
 
-	if (attr_cache_lock(cache) < 0) {
-		giterr_set(GITERR_OS, "unable to get attr cache lock");
-		error = -1;
-	} else {
-		git_strmap_insert(macros, macro->match.pattern, macro, &error);
-		git_mutex_unlock(&cache->lock);
+	/*
+	 * Callers assume that if we return success, that the
+	 * macro will have been adopted by the attributes cache.
+	 * Thus, we have to free the macro here if it's not being
+	 * added to the cache.
+	 *
+	 * TODO: generate warning log if (macro->assigns.length == 0)
+	 */
+	if (macro->assigns.length == 0) {
+		git_attr_rule__free(macro);
+		goto out;
 	}
 
-	return (error < 0) ? -1 : 0;
+	if ((error = attr_cache_lock(cache)) < 0)
+		goto out;
+	locked = true;
+
+	if ((preexisting = git_strmap_get(cache->macros, macro->match.pattern)) != NULL)
+	    git_attr_rule__free(preexisting);
+
+	if ((error = git_strmap_set(cache->macros, macro->match.pattern, macro)) < 0)
+	    goto out;
+
+out:
+	if (locked)
+		attr_cache_unlock(cache);
+	return error;
 }
 
 git_attr_rule *git_attr_cache__lookup_macro(
 	git_repository *repo, const char *name)
 {
 	git_strmap *macros = git_repository_attr_cache(repo)->macros;
-	khiter_t pos;
 
-	pos = git_strmap_lookup_index(macros, name);
-
-	if (!git_strmap_valid_index(macros, pos))
-		return NULL;
-
-	return (git_attr_rule *)git_strmap_value_at(macros, pos);
+	return git_strmap_get(macros, name);
 }
-

data/vendor/libgit2/src/attrcache.h

@@ -34,7 +34,8 @@ extern int git_attr_cache__get(
 	git_attr_file_source source,
 	const char *base,
 	const char *filename,
-	git_attr_file_parser parser);
+	git_attr_file_parser parser,
+	bool allow_macros);
 
 extern bool git_attr_cache__is_cached(
 	git_repository *repo,

data/vendor/libgit2/src/blame.c

@@ -14,6 +14,7 @@
 #include "git2/diff.h"
 #include "git2/blob.h"
 #include "git2/signature.h"
+#include "git2/mailmap.h"
 #include "util.h"
 #include "repository.h"
 #include "blame_git.h"
@@ -40,7 +41,12 @@ static int hunk_cmp(const void *_a, const void *_b)
 	git_blame_hunk *a = (git_blame_hunk*)_a,
 						*b = (git_blame_hunk*)_b;
 
-	return a->final_start_line_number - b->final_start_line_number;
+	if (a->final_start_line_number > b->final_start_line_number)
+		return 1;
+	else if (a->final_start_line_number < b->final_start_line_number)
+		return -1;
+	else
+		return 0;
 }
 
 static bool hunk_ends_at_or_before_line(git_blame_hunk *hunk, size_t line)
@@ -132,6 +138,12 @@ git_blame* git_blame__alloc(
 		return NULL;
 	}
 
+	if (opts.flags & GIT_BLAME_USE_MAILMAP &&
+	    git_mailmap_from_repository(&gbr->mailmap, repo) < 0) {
+		git_blame_free(gbr);
+		return NULL;
+	}
+
 	return gbr;
 }
 
@@ -150,6 +162,8 @@ void git_blame_free(git_blame *blame)
 
 	git_array_clear(blame->line_index);
 
+	git_mailmap_free(blame->mailmap);
+
 	git__free(blame->path);
 	git_blob_free(blame->final_blob);
 	git__free(blame);
@@ -190,7 +204,7 @@ static int normalize_options(
 	memcpy(out, in, sizeof(git_blame_options));
 
 	/* No newest_commit => HEAD */
-	if (git_oid_iszero(&out->newest_commit)) {
+	if (git_oid_is_zero(&out->newest_commit)) {
 		if (git_reference_name_to_id(&out->newest_commit, repo, "HEAD") < 0) {
 			return -1;
 		}
@@ -254,7 +268,7 @@ static git_blame_hunk *split_hunk_in_vector(
 static int index_blob_lines(git_blame *blame)
 {
     const char *buf = blame->final_buf;
-    git_off_t len = blame->final_buf_size;
+    size_t len = blame->final_buf_size;
     int num = 0, incomplete = 0, bol = 1;
     size_t *i;
 
@@ -263,7 +277,7 @@ static int index_blob_lines(git_blame *blame)
     while (len--) {
         if (bol) {
             i = git_array_alloc(blame->line_index);
-            GITERR_CHECK_ALLOC(i);
+            GIT_ERROR_CHECK_ALLOC(i);
             *i = buf - blame->final_buf;
             bol = 0;
         }
@@ -273,13 +287,13 @@ static int index_blob_lines(git_blame *blame)
         }
     }
     i = git_array_alloc(blame->line_index);
-    GITERR_CHECK_ALLOC(i);
+    GIT_ERROR_CHECK_ALLOC(i);
     *i = buf - blame->final_buf;
     blame->num_lines = num + incomplete;
     return blame->num_lines;
 }
 
-static git_blame_hunk* hunk_from_entry(git_blame__entry *e)
+static git_blame_hunk* hunk_from_entry(git_blame__entry *e, git_blame *blame)
 {
 	git_blame_hunk *h = new_hunk(
 			e->lno+1, e->num_lines, e->s_lno+1, e->suspect->path);
@@ -289,8 +303,9 @@ static git_blame_hunk* hunk_from_entry(git_blame__entry *e)
 
 	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_signature_dup(&h->final_signature, git_commit_author(e->suspect->commit));
-	git_signature_dup(&h->orig_signature, git_commit_author(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);
 	h->boundary = e->is_boundary ? 1 : 0;
 	return h;
 }
@@ -305,7 +320,7 @@ static int load_blob(git_blame *blame)
 	if (error < 0)
 		goto cleanup;
 	error = git_object_lookup_bypath((git_object**)&blame->final_blob,
-			(git_object*)blame->final, blame->path, GIT_OBJ_BLOB);
+			(git_object*)blame->final, blame->path, GIT_OBJECT_BLOB);
 
 cleanup:
 	return error;
@@ -320,11 +335,18 @@ 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;
+
+	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;
+	}
+
 	blame->final_buf = git_blob_rawcontent(blame->final_blob);
-	blame->final_buf_size = git_blob_rawsize(blame->final_blob);
+	blame->final_buf_size = (size_t)git_blob_rawsize(blame->final_blob);
 
 	ent = git__calloc(1, sizeof(git_blame__entry));
-	GITERR_CHECK_ALLOC(ent);
+	GIT_ERROR_CHECK_ALLOC(ent);
 
 	ent->num_lines = index_blob_lines(blame);
 	ent->lno = blame->options.min_line - 1;
@@ -341,7 +363,7 @@ static int blame_internal(git_blame *blame)
 cleanup:
 	for (ent = blame->ent; ent; ) {
 		git_blame__entry *e = ent->next;
-		git_blame_hunk *h = hunk_from_entry(ent);
+		git_blame_hunk *h = hunk_from_entry(ent, blame);
 
 		git_vector_insert(&blame->hunks, h);
 
@@ -371,7 +393,7 @@ int git_blame_file(
 		goto on_error;
 
 	blame = git_blame__alloc(repo, normOptions, path);
-	GITERR_CHECK_ALLOC(blame);
+	GIT_ERROR_CHECK_ALLOC(blame);
 
 	if ((error = load_blob(blame)) < 0)
 		goto on_error;
@@ -393,7 +415,7 @@ on_error:
 
 static bool hunk_is_bufferblame(git_blame_hunk *hunk)
 {
-	return git_oid_iszero(&hunk->final_commit_id);
+	return git_oid_is_zero(&hunk->final_commit_id);
 }
 
 static int buffer_hunk_cb(
@@ -413,14 +435,14 @@ static int buffer_hunk_cb(
 	if (!blame->current_hunk) {
 		/* Line added at the end of the file */
 		blame->current_hunk = new_hunk(wedge_line, 0, wedge_line, blame->path);
-		GITERR_CHECK_ALLOC(blame->current_hunk);
+		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);
-		GITERR_CHECK_ALLOC(blame->current_hunk);
+		GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
 	}
 
 	return 0;
@@ -449,7 +471,7 @@ static int buffer_line_cb(
 			/* 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);
-			GITERR_CHECK_ALLOC(blame->current_hunk);
+			GIT_ERROR_CHECK_ALLOC(blame->current_hunk);
 
 			git_vector_insert_sorted(&blame->hunks, blame->current_hunk, NULL);
 		}
@@ -490,12 +512,12 @@ int git_blame_buffer(
 	assert(out && reference && buffer && buffer_len);
 
 	blame = git_blame__alloc(reference->repository, reference->options, reference->path);
-	GITERR_CHECK_ALLOC(blame);
+	GIT_ERROR_CHECK_ALLOC(blame);
 
 	/* Duplicate all of the hunk structures in the reference blame */
 	git_vector_foreach(&reference->hunks, i, hunk) {
 		git_blame_hunk *h = dup_hunk(hunk);
-		GITERR_CHECK_ALLOC(h);
+		GIT_ERROR_CHECK_ALLOC(h);
 
 		git_vector_insert(&blame->hunks, h);
 	}
@@ -509,9 +531,14 @@ int git_blame_buffer(
 	return 0;
 }
 
-int git_blame_init_options(git_blame_options *opts, unsigned int version)
+int git_blame_options_init(git_blame_options *opts, unsigned int version)
 {
 	GIT_INIT_STRUCTURE_FROM_TEMPLATE(
 		opts, version, git_blame_options, GIT_BLAME_OPTIONS_INIT);
 	return 0;
 }
+
+int git_blame_init_options(git_blame_options *opts, unsigned int version)
+{
+	return git_blame_options_init(opts, version);
+}