rugged 0.24.0b4 → 0.24.0b5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1a251ffaf27a3d8447d1c970d5e537a3b36cf31
-  data.tar.gz: 432c8fee3c8af31b9878a98f243d2257b8b81208
+  metadata.gz: bc796cda2006fded0d97c4defe401f810e34f19f
+  data.tar.gz: f0d1d335923bb6ca15116e10404046fb9a18a339
 SHA512:
-  metadata.gz: 23b487a868376093f2ef9c60e3b771c51b88fd9b40b2b5ff335462950be29833b1bbc197760fad7c25d3ed66bac5988faae145e5a3eb2be15288ae777c9e0c5a
-  data.tar.gz: 9d648ed4cf886ad0c217561519dfb74f7a665ac9c3be75719fafd23b2a911ed367ba4a82a162b8c7467ff5fd4cde178e657a778e1fa9dd3daf26bb3aed526cd2
+  metadata.gz: 30f6c194e1863b2a946d7b5ed52b5fa911717e1fc0dd5d55f1d4d992dacfc0af567715a2abe86a3c366bda619d0377fed896ac48e2da5c73b8e07486a179a831
+  data.tar.gz: 4b636574374df656c945b44a2e03d23c401fae824bb3f9b0e07da1418853268ee188e3e4e53756d8bfce80dedf9dc475397d5ecc8a9fc4a82dcb5fddad570c62

data/ext/rugged/rugged_tree.c

@@ -620,6 +620,10 @@ void rugged_parse_merge_options(git_merge_options *opts, VALUE rb_options)
 		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("fail_on_conflict")))) {
 			opts->tree_flags |= GIT_MERGE_TREE_FAIL_ON_CONFLICT;
 		}
+
+		if (RTEST(rb_hash_aref(rb_options, CSTR2SYM("skip_reuc")))) {
+			opts->tree_flags |= GIT_MERGE_TREE_SKIP_REUC;
+		}
 	}
 }
 

data/lib/rugged/version.rb

@@ -1,3 +1,3 @@
 module Rugged
-  Version = VERSION = '0.24.0b4'
+  Version = VERSION = '0.24.0b5'
 end

data/vendor/libgit2/CMakeLists.txt

@@ -137,13 +137,13 @@ FUNCTION(TARGET_OS_LIBRARIES target)
 	ENDIF()
 ENDFUNCTION()
 
-# For the MSVC IDE, this function splits up the source files like windows
-# explorer does. This is esp. useful with the libgit2_clar project, were
-# usually 2 or more files share the same name.  Sadly, this file grouping
-# is a per-directory option in cmake and not per-target, resulting in
-# empty virtual folders "tests" for the git2.dll
-FUNCTION(MSVC_SPLIT_SOURCES target)
-	IF(MSVC_IDE)
+# This function splits the sources files up into their appropriate
+# subdirectories.  This is especially useful for IDEs like Xcode and
+# Visual Studio, so that you can navigate into the libgit2_clar project,
+# and see the folders within the tests folder (instead of just seeing all
+# source and tests in a single folder.)
+FUNCTION(IDE_SPLIT_SOURCES target)
+	IF(MSVC_IDE OR CMAKE_GENERATOR STREQUAL Xcode)
 		GET_TARGET_PROPERTY(sources ${target} SOURCES)
 		FOREACH(source ${sources})
 			IF(source MATCHES ".*/")
@@ -560,7 +560,7 @@ IF(MSVC AND GIT_ARCH_64 AND NOT BUILD_SHARED_LIBS)
   SET_TARGET_PROPERTIES(git2 PROPERTIES STATIC_LIBRARY_FLAGS "/MACHINE:x64")
 ENDIF()
 
-MSVC_SPLIT_SOURCES(git2)
+IDE_SPLIT_SOURCES(git2)
 
 IF (SONAME)
 	SET_TARGET_PROPERTIES(git2 PROPERTIES VERSION ${LIBGIT2_VERSION_STRING})
@@ -629,7 +629,7 @@ IF (BUILD_CLAR)
 	TARGET_LINK_LIBRARIES(libgit2_clar ${GSSAPI_LIBRARIES})
 	TARGET_LINK_LIBRARIES(libgit2_clar ${ICONV_LIBRARIES})
 	TARGET_OS_LIBRARIES(libgit2_clar)
-	MSVC_SPLIT_SOURCES(libgit2_clar)
+	IDE_SPLIT_SOURCES(libgit2_clar)
 
 	IF (MSVC_IDE)
 		# Precompiled headers

data/vendor/libgit2/include/git2/common.h

@@ -20,7 +20,7 @@
 # define GIT_END_DECL	/* empty */
 #endif
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) && _MSC_VER < 1800
  GIT_BEGIN_DECL
 # include "inttypes.h"
  GIT_END_DECL

data/vendor/libgit2/include/git2/merge.h

@@ -79,6 +79,11 @@ typedef enum {
 	 * GIT_EMERGECONFLICT and no index will be returned.
 	 */
 	GIT_MERGE_TREE_FAIL_ON_CONFLICT = (1 << 1),
+
+	/**
+	 * Do not write the REUC extension on the generated index
+	 */
+	GIT_MERGE_TREE_SKIP_REUC = (1 << 2),
 } git_merge_tree_flag_t;
 
 /**

data/vendor/libgit2/src/attr_file.c

@@ -35,11 +35,7 @@ int git_attr_file__new(
 		return -1;
 	}
 
-	if (git_pool_init(&attrs->pool, 1, 0) < 0) {
-		attr_file_free(attrs);
-		return -1;
-	}
-
+	git_pool_init(&attrs->pool, 1);
 	GIT_REFCOUNT_INC(attrs);
 	attrs->entry  = entry;
 	attrs->source = source;

data/vendor/libgit2/src/attrcache.c

@@ -388,10 +388,11 @@ int git_attr_cache__do_init(git_repository *repo)
 	 * hashtable for attribute macros, and string pool
 	 */
 	if ((ret = git_strmap_alloc(&cache->files)) < 0 ||
-		(ret = git_strmap_alloc(&cache->macros)) < 0 ||
-		(ret = git_pool_init(&cache->pool, 1, 0)) < 0)
+		(ret = git_strmap_alloc(&cache->macros)) < 0)
 		goto cancel;
 
+	git_pool_init(&cache->pool, 1);
+
 	cache = git__compare_and_swap(&repo->attrcache, NULL, cache);
 	if (cache)
 		goto cancel; /* raced with another thread, free this but no error */

data/vendor/libgit2/src/checkout.c

@@ -1255,11 +1255,13 @@ static int checkout_get_actions(
 	int error = 0, act;
 	const git_index_entry *wditem;
 	git_vector pathspec = GIT_VECTOR_INIT, *deltas;
-	git_pool pathpool = GIT_POOL_INIT_STRINGPOOL;
+	git_pool pathpool;
 	git_diff_delta *delta;
 	size_t i, *counts = NULL;
 	uint32_t *actions = NULL;
 
+	git_pool_init(&pathpool, 1);
+
 	if (data->opts.paths.count > 0 &&
 		git_pathspec__vinit(&pathspec, &data->opts.paths, &pathpool) < 0)
 		return -1;
@@ -2439,10 +2441,11 @@ static int checkout_data_init(
 		git_config_entry_free(conflict_style);
 	}
 
+	git_pool_init(&data->pool, 1);
+
 	if ((error = git_vector_init(&data->removes, 0, git__strcmp_cb)) < 0 ||
 		(error = git_vector_init(&data->remove_conflicts, 0, NULL)) < 0 ||
 		(error = git_vector_init(&data->update_conflicts, 0, NULL)) < 0 ||
-		(error = git_pool_init(&data->pool, 1, 0)) < 0 ||
 		(error = git_buf_puts(&data->path, data->opts.target_directory)) < 0 ||
 		(error = git_path_to_dir(&data->path)) < 0 ||
 		(error = git_strmap_alloc(&data->mkdir_map)) < 0)

data/vendor/libgit2/src/commit_list.c

@@ -47,7 +47,7 @@ git_commit_list *git_commit_list_insert_by_date(git_commit_list_node *item, git_
 
 git_commit_list_node *git_commit_list_alloc_node(git_revwalk *walk)
 {
-	return (git_commit_list_node *)git_pool_malloc(&walk->commit_pool, COMMIT_ALLOC);
+	return (git_commit_list_node *)git_pool_mallocz(&walk->commit_pool, 1);
 }
 
 static int commit_error(git_commit_list_node *commit, const char *msg)

data/vendor/libgit2/src/diff.c

@@ -430,8 +430,9 @@ static git_diff *diff_list_alloc(
 	diff->new_src = new_iter->type;
 	memcpy(&diff->opts, &dflt, sizeof(diff->opts));
 
-	if (git_vector_init(&diff->deltas, 0, git_diff_delta__cmp) < 0 ||
-		git_pool_init(&diff->pool, 1, 0) < 0) {
+	git_pool_init(&diff->pool, 1);
+
+	if (git_vector_init(&diff->deltas, 0, git_diff_delta__cmp) < 0) {
 		git_diff_free(diff);
 		return NULL;
 	}

data/vendor/libgit2/src/diff_tform.c

@@ -134,11 +134,11 @@ int git_diff__merge(
 		return -1;
 	}
 
-	if (git_vector_init(
-			&onto_new, onto->deltas.length, git_diff_delta__cmp) < 0 ||
-		git_pool_init(&onto_pool, 1, 0) < 0)
+	if (git_vector_init(&onto_new, onto->deltas.length, git_diff_delta__cmp) < 0)
 		return -1;
 
+	git_pool_init(&onto_pool, 1);
+
 	for (i = 0, j = 0; i < onto->deltas.length || j < from->deltas.length; ) {
 		git_diff_delta *o = GIT_VECTOR_GET(&onto->deltas, i);
 		const git_diff_delta *f = GIT_VECTOR_GET(&from->deltas, j);

data/vendor/libgit2/src/index.c

@@ -439,7 +439,7 @@ int git_index_open(git_index **index_out, const char *index_path)
 		return -1;
 	}
 
-	git_pool_init(&index->tree_pool, 1, 0);
+	git_pool_init(&index->tree_pool, 1);
 
 	if (index_path != NULL) {
 		index->index_file_path = git__strdup(index_path);
@@ -2000,27 +2000,24 @@ size_t git_index_reuc_entrycount(git_index *index)
 	return index->reuc.length;
 }
 
+static int index_reuc_on_dup(void **old, void *new)
+{
+	index_entry_reuc_free(*old);
+	*old = new;
+	return GIT_EEXISTS;
+}
+
 static int index_reuc_insert(
 	git_index *index,
-	git_index_reuc_entry *reuc,
-	int replace)
+	git_index_reuc_entry *reuc)
 {
-	git_index_reuc_entry **existing = NULL;
-	size_t position;
+	int res;
 
 	assert(index && reuc && reuc->path != NULL);
+	assert(git_vector_is_sorted(&index->reuc));
 
-	if (!git_index_reuc_find(&position, index, reuc->path))
-		existing = (git_index_reuc_entry **)&index->reuc.contents[position];
-
-	if (!replace || !existing)
-		return git_vector_insert(&index->reuc, reuc);
-
-	/* exists, replace it */
-	git__free(*existing);
-	*existing = reuc;
-
-	return 0;
+	res = git_vector_insert_sorted(&index->reuc, reuc, &index_reuc_on_dup);
+	return res == GIT_EEXISTS ? 0 : res;
 }
 
 int git_index_reuc_add(git_index *index, const char *path,
@@ -2035,7 +2032,7 @@ int git_index_reuc_add(git_index *index, const char *path,
 
 	if ((error = index_entry_reuc_init(&reuc, path, ancestor_mode,
 			ancestor_oid, our_mode, our_oid, their_mode, their_oid)) < 0 ||
-		(error = index_reuc_insert(index, reuc, 1)) < 0)
+		(error = index_reuc_insert(index, reuc)) < 0)
 		index_entry_reuc_free(reuc);
 
 	return error;
@@ -2055,7 +2052,7 @@ const git_index_reuc_entry *git_index_reuc_get_bypath(
 	if (!index->reuc.length)
 		return NULL;
 
-	git_vector_sort(&index->reuc);
+	assert(git_vector_is_sorted(&index->reuc));
 
 	if (git_index_reuc_find(&pos, index, path) < 0)
 		return NULL;
@@ -2067,8 +2064,8 @@ const git_index_reuc_entry *git_index_reuc_get_byindex(
 	git_index *index, size_t n)
 {
 	assert(index);
+	assert(git_vector_is_sorted(&index->reuc));
 
-	git_vector_sort(&index->reuc);
 	return git_vector_get(&index->reuc, n);
 }
 
@@ -2077,7 +2074,7 @@ int git_index_reuc_remove(git_index *index, size_t position)
 	int error;
 	git_index_reuc_entry *reuc;
 
-	git_vector_sort(&index->reuc);
+	assert(git_vector_is_sorted(&index->reuc));
 
 	reuc = git_vector_get(&index->reuc, position);
 	error = git_vector_remove(&index->reuc, position);

data/vendor/libgit2/src/iterator.c

@@ -567,7 +567,7 @@ static bool tree_iterator__pop_frame(tree_iterator *ti, bool final)
 	tree_iterator__move_to_next(ti, tf);
 
 	if (!final) { /* if final, don't bother to clean up */
-		git_pool_free_array(&ti->pool, tf->n_entries, (void **)tf->entries);
+		// TODO: maybe free the pool so far?
 		git_buf_rtruncate_at_char(&ti->path, '/');
 	}
 
@@ -822,8 +822,9 @@ int git_iterator_for_tree(
 	if ((error = iterator__update_ignore_case((git_iterator *)ti, options ? options->flags : 0)) < 0)
 		goto fail;
 
-	if ((error = git_pool_init(&ti->pool, sizeof(tree_iterator_entry),0)) < 0 ||
-		(error = tree_iterator__create_root_frame(ti, tree)) < 0 ||
+	git_pool_init(&ti->pool, sizeof(tree_iterator_entry));
+
+	if ((error = tree_iterator__create_root_frame(ti, tree)) < 0 ||
 		(error = tree_iterator__push_frame(ti)) < 0) /* expand root now */
 		goto fail;
 

data/vendor/libgit2/src/merge.c

@@ -626,7 +626,7 @@ static int merge_conflict_resolve_one_renamed(
 		git_oid__cmp(&conflict->our_entry.id, &conflict->their_entry.id) != 0)
 		return 0;
 
-	if ((merged = git_pool_malloc(&diff_list->pool, sizeof(git_index_entry))) == NULL)
+	if ((merged = git_pool_mallocz(&diff_list->pool, sizeof(git_index_entry))) == NULL)
 		return -1;
 
 	if (ours_changed)
@@ -711,7 +711,7 @@ static int merge_conflict_resolve_automerge(
 		(error = git_odb_write(&automerge_oid, odb, result.ptr, result.len, GIT_OBJ_BLOB)) < 0)
 		goto done;
 
-	if ((index_entry = git_pool_malloc(&diff_list->pool, sizeof(git_index_entry))) == NULL)
+	if ((index_entry = git_pool_mallocz(&diff_list->pool, sizeof(git_index_entry))) == NULL)
 	GITERR_CHECK_ALLOC(index_entry);
 
 	index_entry->path = git_pool_strdup(&diff_list->pool, result.path);
@@ -1307,7 +1307,6 @@ GIT_INLINE(int) index_entry_dup_pool(
 {
 	if (src != NULL) {
 		memcpy(out, src, sizeof(git_index_entry));
-
 		if ((out->path = git_pool_strdup(pool, src->path)) == NULL)
 			return -1;
 	}
@@ -1343,7 +1342,7 @@ static git_merge_diff *merge_diff_from_index_entries(
 	git_merge_diff *conflict;
 	git_pool *pool = &diff_list->pool;
 
-	if ((conflict = git_pool_malloc(pool, sizeof(git_merge_diff))) == NULL)
+	if ((conflict = git_pool_mallocz(pool, sizeof(git_merge_diff))) == NULL)
 		return NULL;
 
 	if (index_entry_dup_pool(&conflict->ancestor_entry, pool, entries[TREE_IDX_ANCESTOR]) < 0 ||
@@ -1384,7 +1383,7 @@ static int merge_diff_list_insert_unmodified(
 	int error = 0;
 	git_index_entry *entry;
 
-	entry = git_pool_malloc(&diff_list->pool, sizeof(git_index_entry));
+	entry = git_pool_mallocz(&diff_list->pool, sizeof(git_index_entry));
 	GITERR_CHECK_ALLOC(entry);
 
 	if ((error = index_entry_dup_pool(entry, &diff_list->pool, tree_items[0])) >= 0)
@@ -1442,10 +1441,11 @@ git_merge_diff_list *git_merge_diff_list__alloc(git_repository *repo)
 
 	diff_list->repo = repo;
 
+	git_pool_init(&diff_list->pool, 1);
+
 	if (git_vector_init(&diff_list->staged, 0, NULL) < 0 ||
 		git_vector_init(&diff_list->conflicts, 0, NULL) < 0 ||
-		git_vector_init(&diff_list->resolved, 0, NULL) < 0 ||
-		git_pool_init(&diff_list->pool, 1, 0) < 0) {
+		git_vector_init(&diff_list->resolved, 0, NULL) < 0) {
 		git_merge_diff_list__free(diff_list);
 		return NULL;
 	}
@@ -1541,7 +1541,45 @@ static int merge_index_insert_reuc(
 		mode[0], oid[0], mode[1], oid[1], mode[2], oid[2]);
 }
 
-int index_from_diff_list(git_index **out, git_merge_diff_list *diff_list)
+static int index_update_reuc(git_index *index, git_merge_diff_list *diff_list)
+{
+	int error;
+	size_t i;
+	git_merge_diff *conflict;
+
+	/* Add each entry in the resolved conflict to the REUC independently, since
+	 * the paths may differ due to renames. */
+	git_vector_foreach(&diff_list->resolved, i, conflict) {
+		const git_index_entry *ancestor =
+			GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->ancestor_entry) ?
+			&conflict->ancestor_entry : NULL;
+
+		const git_index_entry *ours =
+			GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry) ?
+			&conflict->our_entry : NULL;
+
+		const git_index_entry *theirs =
+			GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry) ?
+			&conflict->their_entry : NULL;
+
+		if (ancestor != NULL &&
+			(error = merge_index_insert_reuc(index, TREE_IDX_ANCESTOR, ancestor)) < 0)
+			return error;
+
+		if (ours != NULL &&
+			(error = merge_index_insert_reuc(index, TREE_IDX_OURS, ours)) < 0)
+			return error;
+
+		if (theirs != NULL &&
+			(error = merge_index_insert_reuc(index, TREE_IDX_THEIRS, theirs)) < 0)
+			return error;
+	}
+
+	return 0;
+}
+
+static int index_from_diff_list(git_index **out,
+	git_merge_diff_list *diff_list, bool skip_reuc)
 {
 	git_index *index;
 	size_t i;
@@ -1600,31 +1638,8 @@ int index_from_diff_list(git_index **out, git_merge_diff_list *diff_list)
 		}
 	}
 
-	/* Add each entry in the resolved conflict to the REUC independently, since
-	 * the paths may differ due to renames. */
-	git_vector_foreach(&diff_list->resolved, i, conflict) {
-		const git_index_entry *ancestor =
-			GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->ancestor_entry) ?
-			&conflict->ancestor_entry : NULL;
-
-		const git_index_entry *ours =
-			GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->our_entry) ?
-			&conflict->our_entry : NULL;
-
-		const git_index_entry *theirs =
-			GIT_MERGE_INDEX_ENTRY_EXISTS(conflict->their_entry) ?
-			&conflict->their_entry : NULL;
-
-		if (ancestor != NULL &&
-			(error = merge_index_insert_reuc(index, TREE_IDX_ANCESTOR, ancestor)) < 0)
-			goto on_error;
-
-		if (ours != NULL &&
-			(error = merge_index_insert_reuc(index, TREE_IDX_OURS, ours)) < 0)
-			goto on_error;
-
-		if (theirs != NULL &&
-			(error = merge_index_insert_reuc(index, TREE_IDX_THEIRS, theirs)) < 0)
+	if (!skip_reuc) {
+		if ((error = index_update_reuc(index, diff_list)) < 0)
 			goto on_error;
 	}
 
@@ -1633,7 +1648,6 @@ int index_from_diff_list(git_index **out, git_merge_diff_list *diff_list)
 
 on_error:
 	git_index_free(index);
-
 	return error;
 }
 
@@ -1712,12 +1726,13 @@ int git_merge__iterators(
 		}
 	}
 
+	error = index_from_diff_list(out, diff_list,
+		(opts.tree_flags & GIT_MERGE_TREE_SKIP_REUC));
+
+done:
 	if (!given_opts || !given_opts->metric)
 		git__free(opts.metric);
 
-	error = index_from_diff_list(out, diff_list);
-
-done:
 	git_merge_diff_list__free(diff_list);
 	git_iterator_free(empty_ancestor);
 	git_iterator_free(empty_ours);

data/vendor/libgit2/src/pack-objects.c

@@ -135,8 +135,7 @@ int git_packbuilder_new(git_packbuilder **out, git_repository *repo)
 	if (!pb->walk_objects)
 		goto on_error;
 
-	if (git_pool_init(&pb->object_pool, sizeof(git_walk_object), 0) < 0)
-		goto on_error;
+	git_pool_init(&pb->object_pool, sizeof(git_walk_object));
 
 	pb->repo = repo;
 	pb->nr_threads = 1; /* do not spawn any thread by default */

data/vendor/libgit2/src/pathspec.c

@@ -237,9 +237,9 @@ int git_pathspec__init(git_pathspec *ps, const git_strarray *paths)
 	memset(ps, 0, sizeof(*ps));
 
 	ps->prefix = git_pathspec_prefix(paths);
+	git_pool_init(&ps->pool, 1);
 
-	if ((error = git_pool_init(&ps->pool, 1, 0)) < 0 ||
-		(error = git_pathspec__vinit(&ps->pathspec, paths, &ps->pool)) < 0)
+	if ((error = git_pathspec__vinit(&ps->pathspec, paths, &ps->pool)) < 0)
 		git_pathspec__clear(ps);
 
 	return error;
@@ -312,15 +312,11 @@ static git_pathspec_match_list *pathspec_match_alloc(
 	git_pathspec *ps, int datatype)
 {
 	git_pathspec_match_list *m = git__calloc(1, sizeof(git_pathspec_match_list));
-
-	if (m != NULL && git_pool_init(&m->pool, 1, 0) < 0) {
-		pathspec_match_free(m);
-		m = NULL;
-	}
-
 	if (!m)
 		return NULL;
 
+	git_pool_init(&m->pool, 1);
+
 	/* need to keep reference to pathspec and increment refcount because
 	 * failures array stores pointers to the pattern strings of the
 	 * pathspec that had no matches

data/vendor/libgit2/src/pool.c

@@ -8,67 +8,49 @@ struct git_pool_page {
 	git_pool_page *next;
 	uint32_t size;
 	uint32_t avail;
-	GIT_ALIGN(char data[GIT_FLEX_ARRAY], 8);
+	char data[GIT_FLEX_ARRAY];
 };
 
-struct pool_freelist {
-	struct pool_freelist *next;
-};
+static void *pool_alloc_page(git_pool *pool, uint32_t size);
 
-#define GIT_POOL_MIN_USABLE	4
-#define GIT_POOL_MIN_PAGESZ	2 * sizeof(void*)
+uint32_t git_pool__system_page_size(void)
+{
+	static uint32_t size = 0;
 
-static void *pool_alloc_page(git_pool *pool, uint32_t size);
-static void pool_insert_page(git_pool *pool, git_pool_page *page);
+	if (!size) {
+		size_t page_size;
+		if (git__page_size(&page_size) < 0)
+			page_size = 4096;
+		/* allow space for malloc overhead */
+		size = page_size - (2 * sizeof(void *)) - sizeof(git_pool_page);
+	}
 
-int git_pool_init(
-	git_pool *pool, uint32_t item_size, uint32_t items_per_page)
+	return size;
+}
+
+void git_pool_init(git_pool *pool, uint32_t item_size)
 {
+	const uint32_t align_size = sizeof(void *) - 1;
 	assert(pool);
 
-	if (!item_size)
-		item_size = 1;
-	/* round up item_size for decent object alignment */
-	if (item_size > 4)
-		item_size = (item_size + 7) & ~7;
-	else if (item_size == 3)
-		item_size = 4;
-
-	if (!items_per_page)
-		items_per_page = git_pool__suggest_items_per_page(item_size);
-	if (item_size * items_per_page < GIT_POOL_MIN_PAGESZ)
-		items_per_page = (GIT_POOL_MIN_PAGESZ + item_size - 1) / item_size;
+	if (item_size > 1)
+		item_size = (item_size + align_size) & ~align_size;
 
 	memset(pool, 0, sizeof(git_pool));
 	pool->item_size = item_size;
-	pool->page_size = item_size * items_per_page;
-
-	return 0;
+	pool->page_size = git_pool__system_page_size();
 }
 
 void git_pool_clear(git_pool *pool)
 {
 	git_pool_page *scan, *next;
 
-	for (scan = pool->open; scan != NULL; scan = next) {
+	for (scan = pool->pages; scan != NULL; scan = next) {
 		next = scan->next;
 		git__free(scan);
 	}
-	pool->open = NULL;
 
-	for (scan = pool->full; scan != NULL; scan = next) {
-		next = scan->next;
-		git__free(scan);
-	}
-	pool->full = NULL;
-
-	pool->free_list = NULL;
-
-	pool->items = 0;
-
-	pool->has_string_alloc     = 0;
-	pool->has_multi_item_alloc = 0;
-	pool->has_large_page_alloc = 0;
+	pool->pages = NULL;
 }
 
 void git_pool_swap(git_pool *a, git_pool *b)
@@ -83,110 +65,51 @@ void git_pool_swap(git_pool *a, git_pool *b)
 	memcpy(b, &temp, sizeof(temp));
 }
 
-static void pool_insert_page(git_pool *pool, git_pool_page *page)
-{
-	git_pool_page *scan;
-
-	/* If there are no open pages or this page has the most open space,
-	 * insert it at the beginning of the list.  This is the common case.
-	 */
-	if (pool->open == NULL || pool->open->avail < page->avail) {
-		page->next = pool->open;
-		pool->open = page;
-		return;
-	}
-
-	/* Otherwise insert into sorted position. */
-	for (scan = pool->open;
-		 scan->next && scan->next->avail > page->avail;
-		 scan = scan->next);
-	page->next = scan->next;
-	scan->next = page;
-}
-
 static void *pool_alloc_page(git_pool *pool, uint32_t size)
 {
 	git_pool_page *page;
-	uint32_t new_page_size;
+	const uint32_t new_page_size = (size <= pool->page_size) ? pool->page_size : size;
 	size_t alloc_size;
 
-	if (size <= pool->page_size)
-		new_page_size = pool->page_size;
-	else {
-		new_page_size = size;
-		pool->has_large_page_alloc = 1;
-	}
-
 	if (GIT_ADD_SIZET_OVERFLOW(&alloc_size, new_page_size, sizeof(git_pool_page)) ||
-		!(page = git__calloc(1, alloc_size)))
+		!(page = git__malloc(alloc_size)))
 		return NULL;
 
-	page->size  = new_page_size;
+	page->size = new_page_size;
 	page->avail = new_page_size - size;
+	page->next = pool->pages;
 
-	if (page->avail > 0)
-		pool_insert_page(pool, page);
-	else {
-		page->next = pool->full;
-		pool->full = page;
-	}
-
-	pool->items++;
+	pool->pages = page;
 
 	return page->data;
 }
 
-GIT_INLINE(void) pool_remove_page(
-	git_pool *pool, git_pool_page *page, git_pool_page *prev)
+static void *pool_alloc(git_pool *pool, uint32_t size)
 {
-	if (prev == NULL)
-		pool->open = page->next;
-	else
-		prev->next = page->next;
-}
-
-void *git_pool_malloc(git_pool *pool, uint32_t items)
-{
-	git_pool_page *scan = pool->open, *prev;
-	uint32_t size = ((items * pool->item_size) + 7) & ~7;
+	git_pool_page *page = pool->pages;
 	void *ptr = NULL;
 
-	pool->has_string_alloc = 0;
-	if (items > 1)
-		pool->has_multi_item_alloc = 1;
-	else if (pool->free_list != NULL) {
-		ptr = pool->free_list;
-		pool->free_list = ((struct pool_freelist *)pool->free_list)->next;
-		return ptr;
-	}
-
-	/* just add a block if there is no open one to accommodate this */
-	if (size >= pool->page_size || !scan || scan->avail < size)
+	if (!page || page->avail < size)
 		return pool_alloc_page(pool, size);
 
-	pool->items++;
-
-	/* find smallest block in free list with space */
-	for (scan = pool->open, prev = NULL;
-		 scan->next && scan->next->avail >= size;
-		 prev = scan, scan = scan->next);
+	ptr = &page->data[page->size - page->avail];
+	page->avail -= size;
 
-	/* allocate space from the block */
-	ptr = &scan->data[scan->size - scan->avail];
-	scan->avail -= size;
+	return ptr;
+}
 
-	/* move to full list if there is almost no space left */
-	if (scan->avail < pool->item_size || scan->avail < GIT_POOL_MIN_USABLE) {
-		pool_remove_page(pool, scan, prev);
-		scan->next = pool->full;
-		pool->full = scan;
-	}
-	/* reorder list if block is now smaller than the one after it */
-	else if (scan->next != NULL && scan->next->avail > scan->avail) {
-		pool_remove_page(pool, scan, prev);
-		pool_insert_page(pool, scan);
-	}
+void *git_pool_malloc(git_pool *pool, uint32_t items)
+{
+	const uint32_t size = items * pool->item_size;
+	return pool_alloc(pool, size);
+}
 
+void *git_pool_mallocz(git_pool *pool, uint32_t items)
+{
+	const uint32_t size = items * pool->item_size;
+	void *ptr = pool_alloc(pool, size);
+	if (ptr)
+		memset(ptr, 0x0, size);
 	return ptr;
 }
 
@@ -204,15 +127,12 @@ char *git_pool_strndup(git_pool *pool, const char *str, size_t n)
 		ptr[n] = '\0';
 	}
 
-	pool->has_string_alloc = 1;
-
 	return ptr;
 }
 
 char *git_pool_strdup(git_pool *pool, const char *str)
 {
 	assert(pool && str && pool->item_size == sizeof(char));
-
 	return git_pool_strndup(pool, str, strlen(str));
 }
 
@@ -238,88 +158,23 @@ char *git_pool_strcat(git_pool *pool, const char *a, const char *b)
 			memcpy(((char *)ptr) + len_a, b, len_b);
 		*(((char *)ptr) + len_a + len_b) = '\0';
 	}
-	pool->has_string_alloc = 1;
-
 	return ptr;
 }
 
-void git_pool_free(git_pool *pool, void *ptr)
-{
-	struct pool_freelist *item = ptr;
-
-	assert(pool && pool->item_size >= sizeof(void*));
-
-	if (item) {
-		item->next = pool->free_list;
-		pool->free_list = item;
-	}
-}
-
-void git_pool_free_array(git_pool *pool, size_t count, void **ptrs)
-{
-	struct pool_freelist **items = (struct pool_freelist **)ptrs;
-	size_t i;
-
-	assert(pool && ptrs && pool->item_size >= sizeof(void*));
-
-	if (!count)
-		return;
-
-	for (i = count - 1; i > 0; --i)
-		items[i]->next = items[i - 1];
-
-	items[i]->next  = pool->free_list;
-	pool->free_list = items[count - 1];
-}
-
 uint32_t git_pool__open_pages(git_pool *pool)
 {
 	uint32_t ct = 0;
 	git_pool_page *scan;
-	for (scan = pool->open; scan != NULL; scan = scan->next) ct++;
-	return ct;
-}
-
-uint32_t git_pool__full_pages(git_pool *pool)
-{
-	uint32_t ct = 0;
-	git_pool_page *scan;
-	for (scan = pool->full; scan != NULL; scan = scan->next) ct++;
+	for (scan = pool->pages; scan != NULL; scan = scan->next) ct++;
 	return ct;
 }
 
 bool git_pool__ptr_in_pool(git_pool *pool, void *ptr)
 {
 	git_pool_page *scan;
-	for (scan = pool->open; scan != NULL; scan = scan->next)
-		if ((void *)scan->data <= ptr &&
-			(void *)(((char *)scan->data) + scan->size) > ptr)
-			return true;
-	for (scan = pool->full; scan != NULL; scan = scan->next)
+	for (scan = pool->pages; scan != NULL; scan = scan->next)
 		if ((void *)scan->data <= ptr &&
 			(void *)(((char *)scan->data) + scan->size) > ptr)
 			return true;
 	return false;
 }
-
-uint32_t git_pool__system_page_size(void)
-{
-	static uint32_t size = 0;
-
-	if (!size) {
-		size_t page_size;
-		if (git__page_size(&page_size) < 0)
-			page_size = 4096;
-		size = page_size - 2 * sizeof(void *); /* allow space for malloc overhead */
-	}
-
-	return size;
-}
-
-uint32_t git_pool__suggest_items_per_page(uint32_t item_size)
-{
-	uint32_t page_bytes =
-		git_pool__system_page_size() - sizeof(git_pool_page);
-	return page_bytes / item_size;
-}
-

data/vendor/libgit2/src/pool.h

@@ -28,19 +28,11 @@ typedef struct git_pool_page git_pool_page;
  * For examples of how to set up a `git_pool` see `git_pool_init`.
  */
 typedef struct {
-	git_pool_page *open; /* pages with space left */
-	git_pool_page *full; /* pages with no space left */
-	void *free_list;     /* optional: list of freed blocks */
+	git_pool_page *pages; /* pages with space left */
 	uint32_t item_size;  /* size of single alloc unit in bytes */
 	uint32_t page_size;  /* size of page in bytes */
-	uint32_t items;
-	unsigned has_string_alloc : 1; /* was the strdup function used */
-	unsigned has_multi_item_alloc : 1; /* was items ever > 1 in malloc */
-	unsigned has_large_page_alloc : 1; /* are any pages > page_size */
 } git_pool;
 
-#define GIT_POOL_INIT_STRINGPOOL { 0, 0, 0, 1, 4000, 0, 0, 0, 0 }
-
 /**
  * Initialize a pool.
  *
@@ -57,8 +49,7 @@ typedef struct {
  * Of course, you can use this in other ways, but those are the
  * two most common patterns.
  */
-extern int git_pool_init(
-	git_pool *pool, uint32_t item_size, uint32_t items_per_page);
+extern void git_pool_init(git_pool *pool, uint32_t item_size);
 
 /**
  * Free all items in pool
@@ -74,17 +65,7 @@ extern void git_pool_swap(git_pool *a, git_pool *b);
  * Allocate space for one or more items from a pool.
  */
 extern void *git_pool_malloc(git_pool *pool, uint32_t items);
-
-/**
- * Allocate space and zero it out.
- */
-GIT_INLINE(void *) git_pool_mallocz(git_pool *pool, uint32_t items)
-{
-	void *ptr = git_pool_malloc(pool, items);
-	if (ptr)
-		memset(ptr, 0, (size_t)items * (size_t)pool->item_size);
-	return ptr;
-}
+extern void *git_pool_mallocz(git_pool *pool, uint32_t items);
 
 /**
  * Allocate space and duplicate string data into it.
@@ -114,35 +95,10 @@ extern char *git_pool_strdup_safe(git_pool *pool, const char *str);
  */
 extern char *git_pool_strcat(git_pool *pool, const char *a, const char *b);
 
-/**
- * Push a block back onto the free list for the pool.
- *
- * This is allowed only if the item_size is >= sizeof(void*).
- *
- * In some cases, it is helpful to "release" an allocated block
- * for reuse.  Pools don't support a general purpose free, but
- * they will keep a simple free blocks linked list provided the
- * native block size is large enough to hold a void pointer
- */
-extern void git_pool_free(git_pool *pool, void *ptr);
-
-/**
- * Push an array of pool allocated blocks efficiently onto the free list.
- *
- * This has the same constraints as `git_pool_free()` above.
- */
-extern void git_pool_free_array(git_pool *pool, size_t count, void **ptrs);
-
 /*
  * Misc utilities
  */
-
 extern uint32_t git_pool__open_pages(git_pool *pool);
-
-extern uint32_t git_pool__full_pages(git_pool *pool);
-
 extern bool git_pool__ptr_in_pool(git_pool *pool, void *ptr);
 
-extern uint32_t git_pool__suggest_items_per_page(uint32_t item_size);
-
 #endif

data/vendor/libgit2/src/refdb_fs.c

@@ -626,8 +626,9 @@ static int refdb_fs_backend__iterator(
 	iter = git__calloc(1, sizeof(refdb_fs_iter));
 	GITERR_CHECK_ALLOC(iter);
 
-	if (git_pool_init(&iter->pool, 1, 0) < 0 ||
-		git_vector_init(&iter->loose, 8, NULL) < 0)
+	git_pool_init(&iter->pool, 1);
+
+	if (git_vector_init(&iter->loose, 8, NULL) < 0)
 		goto fail;
 
 	if (glob != NULL &&

data/vendor/libgit2/src/repository.c

@@ -689,6 +689,7 @@ int git_repository_config__weakptr(git_config **out, git_repository *repo)
 		git_buf_free(&global_buf);
 		git_buf_free(&xdg_buf);
 		git_buf_free(&system_buf);
+		git_buf_free(&programdata_buf);
 	}
 
 	*out = repo->_config;

data/vendor/libgit2/src/revwalk.c

@@ -535,12 +535,10 @@ int git_revwalk_new(git_revwalk **revwalk_out, git_repository *repo)
 	walk->commits = git_oidmap_alloc();
 	GITERR_CHECK_ALLOC(walk->commits);
 
-	if (git_pqueue_init(
-			&walk->iterator_time, 0, 8, git_commit_list_time_cmp) < 0 ||
-		git_pool_init(&walk->commit_pool, 1,
-			git_pool__suggest_items_per_page(COMMIT_ALLOC) * COMMIT_ALLOC) < 0)
+	if (git_pqueue_init(&walk->iterator_time, 0, 8, git_commit_list_time_cmp) < 0)
 		return -1;
 
+	git_pool_init(&walk->commit_pool, COMMIT_ALLOC);
 	walk->get_next = &revwalk_next_unsorted;
 	walk->enqueue = &revwalk_enqueue_unsorted;
 

data/vendor/libgit2/src/sortedcache.c

@@ -20,8 +20,9 @@ int git_sortedcache_new(
 	sc = git__calloc(1, alloclen);
 	GITERR_CHECK_ALLOC(sc);
 
-	if (git_pool_init(&sc->pool, 1, 0) < 0 ||
-		git_vector_init(&sc->items, 4, item_cmp) < 0 ||
+	git_pool_init(&sc->pool, 1);
+
+	if (git_vector_init(&sc->items, 4, item_cmp) < 0 ||
 		git_strmap_alloc(&sc->map) < 0)
 		goto fail;
 

data/vendor/libgit2/src/transaction.c

@@ -77,8 +77,7 @@ int git_transaction_new(git_transaction **out, git_repository *repo)
 
 	assert(out && repo);
 
-	if ((error = git_pool_init(&pool, 1, 0)) < 0)
-		return error;
+	git_pool_init(&pool, 1);
 
 	tx = git_pool_mallocz(&pool, sizeof(git_transaction));
 	if (!tx) {

data/vendor/libgit2/src/xdiff/xdiff.h

@@ -20,7 +20,7 @@
  *
  */
 
-#include "util.h"
+#include "../util.h"
 
 #if !defined(XDIFF_H)
 #define XDIFF_H

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rugged
 version: !ruby/object:Gem::Version
-  version: 0.24.0b4
+  version: 0.24.0b5
 platform: ruby
 authors:
 - Scott Chacon
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-23 00:00:00.000000000 Z
+date: 2015-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler