rugged 1.3.1 → 1.9.0

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

@@ -69,7 +69,7 @@ int git_attr_file__clear_rules(git_attr_file *file, bool need_lock)
 
 	git_vector_foreach(&file->rules, i, rule)
 		git_attr_rule__free(rule);
-	git_vector_free(&file->rules);
+	git_vector_dispose(&file->rules);
 
 	if (need_lock)
 		git_mutex_unlock(&file->lock);
@@ -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;
 
@@ -135,7 +135,7 @@ int git_attr_file__load(
 		break;
 	case GIT_ATTR_FILE_SOURCE_INDEX: {
 		if ((error = attr_file_oid_from_index(&id, repo, entry->path)) < 0 ||
-			(error = git_blob_lookup(&blob, repo, &id)) < 0)
+		    (error = git_blob_lookup(&blob, repo, &id)) < 0)
 			return error;
 
 		/* Do not assume that data straight from the ODB is NULL-terminated;
@@ -143,7 +143,9 @@ 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);
+		if (blobsize > GIT_ATTR_MAX_FILE_SIZE) /* TODO: issue warning when warning API is available */
+			goto cleanup;
+		git_str_put(&content, git_blob_rawcontent(blob), (size_t)blobsize);
 		break;
 	}
 	case GIT_ATTR_FILE_SOURCE_FILE: {
@@ -155,6 +157,7 @@ int git_attr_file__load(
 		if (p_stat(entry->fullpath, &st) < 0 ||
 			S_ISDIR(st.st_mode) ||
 			(fd = git_futils_open_ro(entry->fullpath)) < 0 ||
+			(st.st_size > GIT_ATTR_MAX_FILE_SIZE) ||
 			(error = git_futils_readbuffer_fd(&content, fd, (size_t)st.st_size)) < 0)
 			nonexistent = true;
 
@@ -198,7 +201,9 @@ int git_attr_file__load(
 		blobsize = git_blob_rawsize(blob);
 
 		GIT_ERROR_CHECK_BLOBSIZE(blobsize);
-		if ((error = git_buf_put(&content,
+		if (blobsize > GIT_ATTR_MAX_FILE_SIZE) /* TODO: issue warning when warning API is available */
+			goto cleanup;
+		if ((error = git_str_put(&content,
 			git_blob_rawcontent(blob), (size_t)blobsize)) < 0)
 			goto cleanup;
 
@@ -213,10 +218,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 +255,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 +350,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 +440,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 +462,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 +563,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 +601,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 +610,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;
 }
@@ -991,7 +996,7 @@ static void git_attr_rule__clear(git_attr_rule *rule)
 	if (!(rule->match.flags & GIT_ATTR_FNMATCH_IGNORE)) {
 		git_vector_foreach(&rule->assigns, i, assign)
 			GIT_REFCOUNT_DEC(assign, git_attr_assignment__free);
-		git_vector_free(&rule->assigns);
+		git_vector_dispose(&rule->assigns);
 	}
 
 	/* match.pattern is stored in a git_pool, so no need to free */
@@ -1020,8 +1025,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 → libgit2/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"
@@ -21,6 +21,8 @@
 #define GIT_ATTR_FILE_SYSTEM	"gitattributes"
 #define GIT_ATTR_FILE_XDG		"attributes"
 
+#define GIT_ATTR_MAX_FILE_SIZE	100 * 1024 * 1024
+
 #define GIT_ATTR_FNMATCH_NEGATIVE	(1U << 0)
 #define GIT_ATTR_FNMATCH_DIRECTORY	(1U << 1)
 #define GIT_ATTR_FNMATCH_FULLPATH	(1U << 2)
@@ -118,7 +120,7 @@ struct git_attr_file_entry {
 };
 
 typedef struct {
-	git_buf  full;
+	git_str  full;
 	char    *path;
 	char    *basename;
 	int      is_dir;
@@ -132,8 +134,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 → libgit2/attrcache.c}

@@ -12,6 +12,39 @@
 #include "config.h"
 #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)
 {
@@ -33,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(
@@ -43,11 +81,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 +105,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];
@@ -87,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;
@@ -161,7 +203,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 +211,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 +245,7 @@ cleanup:
 	*out_file  = file;
 	*out_entry = entry;
 
-	git_buf_dispose(&path);
+	git_str_dispose(&path);
 	return error;
 }
 
@@ -266,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);
@@ -281,7 +322,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;
 
@@ -295,24 +336,27 @@ 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);
+			if (! (error = git_sysdir_expand_homedir_file(&buf, &cfgval[2])))
+				*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;
 }
 
 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)
@@ -320,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);
 
@@ -396,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)
@@ -452,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)
@@ -467,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/{attrcache.h → 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,