rugged 0.17.0.b6 → 0.17.0.b7

data/vendor/libgit2/src/ignore.h

@@ -23,6 +23,7 @@ typedef struct {
 	git_attr_file *ign_internal;
 	git_vector ign_path;
 	git_vector ign_global;
+	unsigned int ignore_case:1;
 } git_ignores;
 
 extern int git_ignore__for_path(git_repository *repo, const char *path, git_ignores *ign);

data/vendor/libgit2/src/index.c

@@ -99,6 +99,13 @@ static int index_srch(const void *key, const void *array_member)
 	return strcmp(key, entry->path);
 }
 
+static int index_isrch(const void *key, const void *array_member)
+{
+	const git_index_entry *entry = array_member;
+
+	return strcasecmp(key, entry->path);
+}
+
 static int index_cmp(const void *a, const void *b)
 {
 	const git_index_entry *entry_a = a;
@@ -107,6 +114,14 @@ static int index_cmp(const void *a, const void *b)
 	return strcmp(entry_a->path, entry_b->path);
 }
 
+static int index_icmp(const void *a, const void *b)
+{
+	const git_index_entry *entry_a = a;
+	const git_index_entry *entry_b = b;
+
+	return strcasecmp(entry_a->path, entry_b->path);
+}
+
 static int unmerged_srch(const void *key, const void *array_member)
 {
 	const git_index_entry_unmerged *entry = array_member;
@@ -147,6 +162,14 @@ static unsigned int index_merge_mode(
 	return index_create_mode(mode);
 }
 
+static void index_set_ignore_case(git_index *index, bool ignore_case)
+{
+	index->entries._cmp = ignore_case ? index_icmp : index_cmp;
+	index->entries_search = ignore_case ? index_isrch : index_srch;
+	index->entries.sorted = 0;
+	git_vector_sort(&index->entries);
+}
+
 int git_index_open(git_index **index_out, const char *index_path)
 {
 	git_index *index;
@@ -162,6 +185,8 @@ int git_index_open(git_index **index_out, const char *index_path)
 	if (git_vector_init(&index->entries, 32, index_cmp) < 0)
 		return -1;
 
+	index->entries_search = index_srch;
+
 	/* Check if index file is stored on disk already */
 	if (git_path_exists(index->index_file_path) == true)
 		index->on_disk = 1;
@@ -228,8 +253,12 @@ void git_index_clear(git_index *index)
 
 int git_index_set_caps(git_index *index, unsigned int caps)
 {
+	int old_ignore_case;
+
 	assert(index);
 
+	old_ignore_case = index->ignore_case;
+
 	if (caps == GIT_INDEXCAP_FROM_OWNER) {
 		git_config *cfg;
 		int val;
@@ -247,7 +276,7 @@ int git_index_set_caps(git_index *index, unsigned int caps)
 		if (git_config_get_bool(&val, cfg, "core.filemode") == 0)
 			index->distrust_filemode = (val == 0);
 		if (git_config_get_bool(&val, cfg, "core.symlinks") == 0)
-			index->no_symlinks = (val != 0);
+			index->no_symlinks = (val == 0);
 	}
 	else {
 		index->ignore_case = ((caps & GIT_INDEXCAP_IGNORE_CASE) != 0);
@@ -255,6 +284,11 @@ int git_index_set_caps(git_index *index, unsigned int caps)
 		index->no_symlinks = ((caps & GIT_INDEXCAP_NO_SYMLINKS) != 0);
 	}
 
+	if (old_ignore_case != index->ignore_case)
+	{
+		index_set_ignore_case(index, index->ignore_case);
+	}
+
 	return 0;
 }
 
@@ -552,14 +586,14 @@ int git_index_remove(git_index *index, int position)
 
 int git_index_find(git_index *index, const char *path)
 {
-	return git_vector_bsearch2(&index->entries, index_srch, path);
+	return git_vector_bsearch2(&index->entries, index->entries_search, path);
 }
 
 unsigned int git_index__prefix_position(git_index *index, const char *path)
 {
 	unsigned int pos;
 
-	git_vector_bsearch3(&pos, &index->entries, index_srch, path);
+	git_vector_bsearch3(&pos, &index->entries, index->entries_search, path);
 
 	return pos;
 }
@@ -938,16 +972,28 @@ static int write_disk_entry(git_filebuf *file, git_index_entry *entry)
 
 static int write_entries(git_index *index, git_filebuf *file)
 {
+	int error = 0;
 	unsigned int i;
-
-	for (i = 0; i < index->entries.length; ++i) {
-		git_index_entry *entry;
-		entry = git_vector_get(&index->entries, i);
-		if (write_disk_entry(file, entry) < 0)
-			return -1;
+	git_vector case_sorted;
+	git_index_entry *entry;
+	git_vector *out = &index->entries;
+
+	/* If index->entries is sorted case-insensitively, then we need
+	 * to re-sort it case-sensitively before writing */
+	if (index->ignore_case) {
+		git_vector_dup(&case_sorted, &index->entries, index_cmp);
+		git_vector_sort(&case_sorted);
+		out = &case_sorted;
 	}
 
-	return 0;
+	git_vector_foreach(out, i, entry)
+		if ((error = write_disk_entry(file, entry)) < 0)
+			break;
+
+	if (index->ignore_case)
+		git_vector_free(&case_sorted);
+
+	return error;
 }
 
 static int write_index(git_index *index, git_filebuf *file)

data/vendor/libgit2/src/index.h

@@ -34,6 +34,8 @@ struct git_index {
 	git_tree_cache *tree;
 
 	git_vector unmerged;
+
+	git_vector_cmp entries_search;
 };
 
 extern void git_index__init_entry_from_stat(struct stat *st, git_index_entry *entry);

data/vendor/libgit2/src/indexer.c

@@ -324,8 +324,8 @@ int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t siz
 		if (git_vector_init(&idx->deltas, (unsigned int)(idx->nr_objects / 2), NULL) < 0)
 			return -1;
 
+		memset(stats, 0, sizeof(git_indexer_stats));
 		stats->total = (unsigned int)idx->nr_objects;
-		stats->processed = 0;
 	}
 
 	/* Now that we have data in the pack, let's try to parse it */
@@ -361,6 +361,7 @@ int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t siz
 			if (error < 0)
 				return error;
 
+			stats->received++;
 			continue;
 		}
 
@@ -379,6 +380,7 @@ int git_indexer_stream_add(git_indexer_stream *idx, const void *data, size_t siz
 		git__free(obj.data);
 
 		stats->processed = (unsigned int)++processed;
+		stats->received++;
 	}
 
 	return 0;
@@ -577,9 +579,11 @@ void git_indexer_stream_free(git_indexer_stream *idx)
 	git_vector_foreach(&idx->objects, i, e)
 		git__free(e);
 	git_vector_free(&idx->objects);
-	git_vector_foreach(&idx->pack->cache, i, pe)
-		git__free(pe);
-	git_vector_free(&idx->pack->cache);
+	if (idx->pack) {
+		git_vector_foreach(&idx->pack->cache, i, pe)
+			git__free(pe);
+		git_vector_free(&idx->pack->cache);
+	}
 	git_vector_foreach(&idx->deltas, i, delta)
 		git__free(delta);
 	git_vector_free(&idx->deltas);
@@ -595,11 +599,6 @@ int git_indexer_new(git_indexer **out, const char *packname)
 
 	assert(out && packname);
 
-	if (git_path_root(packname) < 0) {
-		giterr_set(GITERR_INDEXER, "Path is not absolute");
-		return -1;
-	}
-
 	idx = git__calloc(1, sizeof(git_indexer));
 	GITERR_CHECK_ALLOC(idx);
 

data/vendor/libgit2/src/iterator.c

@@ -17,6 +17,7 @@
 	(P)->base.type    = GIT_ITERATOR_ ## NAME_UC; \
 	(P)->base.start   = start ? git__strdup(start) : NULL; \
 	(P)->base.end     = end ? git__strdup(end) : NULL; \
+	(P)->base.ignore_case = 0; \
 	(P)->base.current = NAME_LC ## _iterator__current; \
 	(P)->base.at_end  = NAME_LC ## _iterator__at_end; \
 	(P)->base.advance = NAME_LC ## _iterator__advance; \
@@ -81,7 +82,7 @@ int git_iterator_for_nothing(git_iterator **iter)
 
 typedef struct tree_iterator_frame tree_iterator_frame;
 struct tree_iterator_frame {
-	tree_iterator_frame *next;
+	tree_iterator_frame *next, *prev;
 	git_tree *tree;
 	char *start;
 	unsigned int index;
@@ -90,7 +91,7 @@ struct tree_iterator_frame {
 typedef struct {
 	git_iterator base;
 	git_repository *repo;
-	tree_iterator_frame *stack;
+	tree_iterator_frame *stack, *tail;
 	git_index_entry entry;
 	git_buf path;
 	bool path_has_filename;
@@ -118,8 +119,10 @@ static void tree_iterator__pop_frame(tree_iterator *ti)
 {
 	tree_iterator_frame *tf = ti->stack;
 	ti->stack = tf->next;
-	if (ti->stack != NULL) /* don't free the initial tree */
-		git_tree_free(tf->tree);
+	if (ti->stack != NULL) {
+		git_tree_free(tf->tree); /* don't free the initial tree */
+		ti->stack->prev = NULL;  /* disconnect prev */
+	}
 	git__free(tf);
 }
 
@@ -220,6 +223,7 @@ static int tree_iterator__expand_tree(tree_iterator *ti)
 
 		tf->next  = ti->stack;
 		ti->stack = tf;
+		tf->next->prev = tf;
 
 		te = tree_iterator__tree_entry(ti);
 	}
@@ -311,7 +315,7 @@ int git_iterator_for_tree_range(
 	ITERATOR_BASE_INIT(ti, tree, TREE);
 
 	ti->repo  = repo;
-	ti->stack = tree_iterator__alloc_frame(tree, ti->base.start);
+	ti->stack = ti->tail = tree_iterator__alloc_frame(tree, ti->base.start);
 
 	if ((error = tree_iterator__expand_tree(ti)) < 0)
 		git_iterator_free((git_iterator *)ti);
@@ -336,7 +340,7 @@ static int index_iterator__current(
 
 	if (ie != NULL &&
 		ii->base.end != NULL &&
-		git__prefixcmp(ie->path, ii->base.end) > 0)
+		ITERATOR_PREFIXCMP(ii->base, ie->path, ii->base.end) > 0)
 	{
 		ii->current = git_index_entrycount(ii->index);
 		ie = NULL;
@@ -401,6 +405,7 @@ int git_iterator_for_index_range(
 	if ((error = git_repository_index(&ii->index, repo)) < 0)
 		git__free(ii);
 	else {
+		ii->base.ignore_case = ii->index->ignore_case;
 		ii->current = start ? git_index__prefix_position(ii->index, start) : 0;
 		*iter = (git_iterator *)ii;
 	}
@@ -428,12 +433,30 @@ typedef struct {
 	int is_ignored;
 } workdir_iterator;
 
-static workdir_iterator_frame *workdir_iterator__alloc_frame(void)
+static int git_path_with_stat_cmp_case(const void *a, const void *b)
+{
+	const git_path_with_stat *path_with_stat_a = a;
+	const git_path_with_stat *path_with_stat_b = b;
+
+	return strcmp(path_with_stat_a->path, path_with_stat_b->path);
+}
+
+static int git_path_with_stat_cmp_icase(const void *a, const void *b)
+{
+	const git_path_with_stat *path_with_stat_a = a;
+	const git_path_with_stat *path_with_stat_b = b;
+
+	return strcasecmp(path_with_stat_a->path, path_with_stat_b->path);
+}
+
+static workdir_iterator_frame *workdir_iterator__alloc_frame(workdir_iterator *wi)
 {
 	workdir_iterator_frame *wf = git__calloc(1, sizeof(workdir_iterator_frame));
+	git_vector_cmp entry_compare = CASESELECT(wi->base.ignore_case, git_path_with_stat_cmp_icase, git_path_with_stat_cmp_case);
+
 	if (wf == NULL)
 		return NULL;
-	if (git_vector_init(&wf->entries, 0, git_path_with_stat_cmp) != 0) {
+	if (git_vector_init(&wf->entries, 0, entry_compare) != 0) {
 		git__free(wf);
 		return NULL;
 	}
@@ -453,16 +476,22 @@ static void workdir_iterator__free_frame(workdir_iterator_frame *wf)
 
 static int workdir_iterator__update_entry(workdir_iterator *wi);
 
-static int workdir_iterator__entry_cmp(const void *prefix, const void *item)
+static int workdir_iterator__entry_cmp_case(const void *prefix, const void *item)
 {
 	const git_path_with_stat *ps = item;
 	return git__prefixcmp((const char *)prefix, ps->path);
 }
 
+static int workdir_iterator__entry_cmp_icase(const void *prefix, const void *item)
+{
+	const git_path_with_stat *ps = item;
+	return git__prefixcmp_icase((const char *)prefix, ps->path);
+}
+
 static int workdir_iterator__expand_dir(workdir_iterator *wi)
 {
 	int error;
-	workdir_iterator_frame *wf = workdir_iterator__alloc_frame();
+	workdir_iterator_frame *wf = workdir_iterator__alloc_frame(wi);
 	GITERR_CHECK_ALLOC(wf);
 
 	error = git_path_dirload_with_stat(wi->path.ptr, wi->root_len, &wf->entries);
@@ -476,12 +505,15 @@ static int workdir_iterator__expand_dir(workdir_iterator *wi)
 	if (!wi->stack)
 		wf->start = wi->base.start;
 	else if (wi->stack->start &&
-		git__prefixcmp(wi->stack->start, wi->path.ptr + wi->root_len) == 0)
+		ITERATOR_PREFIXCMP(wi->base, wi->stack->start, wi->path.ptr + wi->root_len) == 0)
 		wf->start = wi->stack->start;
 
 	if (wf->start)
 		git_vector_bsearch3(
-			&wf->index, &wf->entries, workdir_iterator__entry_cmp, wf->start);
+			&wf->index,
+			&wf->entries,
+			CASESELECT(wi->base.ignore_case, workdir_iterator__entry_cmp_icase, workdir_iterator__entry_cmp_case),
+			wf->start);
 
 	wf->next  = wi->stack;
 	wi->stack = wf;
@@ -525,7 +557,9 @@ static int workdir_iterator__advance(
 	while ((wf = wi->stack) != NULL) {
 		next = git_vector_get(&wf->entries, ++wf->index);
 		if (next != NULL) {
-			if (strcmp(next->path, DOT_GIT "/") == 0)
+			/* match git's behavior of ignoring anything named ".git" */
+			if (STRCMP_CASESELECT(wi->base.ignore_case, next->path, DOT_GIT "/") == 0 ||
+				STRCMP_CASESELECT(wi->base.ignore_case, next->path, DOT_GIT) == 0)
 				continue;
 			/* else found a good entry */
 			break;
@@ -602,13 +636,14 @@ static int workdir_iterator__update_entry(workdir_iterator *wi)
 		return -1;
 
 	if (wi->base.end &&
-		git__prefixcmp(wi->path.ptr + wi->root_len, wi->base.end) > 0)
+		ITERATOR_PREFIXCMP(wi->base, wi->path.ptr + wi->root_len, wi->base.end) > 0)
 		return 0;
 
 	wi->entry.path = ps->path;
 
-	/* skip over .git directory */
-	if (strcmp(ps->path, DOT_GIT "/") == 0)
+	/* skip over .git entry */
+	if (STRCMP_CASESELECT(wi->base.ignore_case, ps->path, DOT_GIT "/") == 0 ||
+		STRCMP_CASESELECT(wi->base.ignore_case, ps->path, DOT_GIT) == 0)
 		return workdir_iterator__advance((git_iterator *)wi, NULL);
 
 	/* if there is an error processing the entry, treat as ignored */
@@ -629,15 +664,10 @@ static int workdir_iterator__update_entry(workdir_iterator *wi)
 
 	/* detect submodules */
 	if (S_ISDIR(wi->entry.mode)) {
-		bool is_submodule = git_path_contains(&wi->path, DOT_GIT);
-
-		/* if there is no .git, still check submodules data */
-		if (!is_submodule) {
-			int res = git_submodule_lookup(NULL, wi->repo, wi->entry.path);
-			is_submodule = (res == 0);
-			if (res == GIT_ENOTFOUND)
-				giterr_clear();
-		}
+		int res = git_submodule_lookup(NULL, wi->repo, wi->entry.path);
+		bool is_submodule = (res == 0);
+		if (res == GIT_ENOTFOUND)
+			giterr_clear();
 
 		/* if submodule, mark as GITLINK and remove trailing slash */
 		if (is_submodule) {
@@ -659,19 +689,28 @@ int git_iterator_for_workdir_range(
 {
 	int error;
 	workdir_iterator *wi;
+	git_index *index;
 
 	assert(iter && repo);
 
-	if (git_repository_is_bare(repo)) {
-		giterr_set(GITERR_INVALID,
-			"Cannot scan working directory for bare repo");
-		return -1;
-	}
+	if ((error = git_repository__ensure_not_bare(repo, "scan working directory")) < 0)
+		return error;
 
 	ITERATOR_BASE_INIT(wi, workdir, WORKDIR);
 
 	wi->repo = repo;
 
+	if ((error = git_repository_index(&index, repo)) < 0) {
+		git__free(wi);
+		return error;
+	}
+
+	/* Set the ignore_case flag for the workdir iterator to match
+	 * that of the index. */
+	wi->base.ignore_case = index->ignore_case;
+
+	git_index_free(index);
+
 	if (git_buf_sets(&wi->path, git_repository_workdir(repo)) < 0 ||
 		git_path_to_dir(&wi->path) < 0 ||
 		git_ignore__for_path(repo, "", &wi->ignores) < 0)
@@ -696,6 +735,129 @@ int git_iterator_for_workdir_range(
 	return error;
 }
 
+typedef struct {
+	git_iterator base;
+	git_iterator *wrapped;
+	git_vector entries;
+	git_vector_cmp comparer;
+	git_pool entry_pool;
+	git_pool string_pool;
+	unsigned int position;
+} spoolandsort_iterator;
+
+static int spoolandsort_iterator__current(
+	git_iterator *self, const git_index_entry **entry)
+{
+	spoolandsort_iterator *si = (spoolandsort_iterator *)self;
+
+	if (si->position < si->entries.length)
+		*entry = (const git_index_entry *)git_vector_get_const(&si->entries, si->position);
+	else
+		*entry = NULL;
+
+	return 0;
+}
+
+static int spoolandsort_iterator__at_end(git_iterator *self)
+{
+	spoolandsort_iterator *si = (spoolandsort_iterator *)self;
+
+	return 0 == si->entries.length || si->entries.length - 1 <= si->position;
+}
+
+static int spoolandsort_iterator__advance(
+	git_iterator *self, const git_index_entry **entry)
+{
+	spoolandsort_iterator *si = (spoolandsort_iterator *)self;
+
+	if (si->position < si->entries.length)
+		*entry = (const git_index_entry *)git_vector_get_const(&si->entries, ++si->position);
+	else
+		*entry = NULL;
+
+	return 0;
+}
+
+static int spoolandsort_iterator__seek(git_iterator *self, const char *prefix)
+{
+	GIT_UNUSED(self);
+	GIT_UNUSED(prefix);
+
+	return -1;
+}
+
+static int spoolandsort_iterator__reset(git_iterator *self)
+{
+	spoolandsort_iterator *si = (spoolandsort_iterator *)self;
+
+	si->position = 0;
+
+	return 0;
+}
+
+static void spoolandsort_iterator__free(git_iterator *self)
+{
+	spoolandsort_iterator *si = (spoolandsort_iterator *)self;
+
+	git_pool_clear(&si->string_pool);
+	git_pool_clear(&si->entry_pool);
+	git_vector_free(&si->entries);
+	git_iterator_free(si->wrapped);
+}
+
+int git_iterator_spoolandsort_range(
+	git_iterator **iter,
+	git_iterator *towrap,
+	git_vector_cmp comparer,
+	bool ignore_case,
+	const char *start,
+	const char *end)
+{
+	spoolandsort_iterator *si;
+	const git_index_entry *item;
+
+	assert(iter && towrap && comparer);
+
+	ITERATOR_BASE_INIT(si, spoolandsort, SPOOLANDSORT);
+	si->base.ignore_case = ignore_case;
+	si->wrapped = towrap;
+	si->comparer = comparer;
+	si->position = 0;
+
+	if (git_vector_init(&si->entries, 16, si->comparer) < 0 ||
+		git_iterator_current(towrap, &item) < 0 ||
+		git_pool_init(&si->entry_pool, sizeof(git_index_entry), 0) ||
+		git_pool_init(&si->string_pool, 1, 0))
+	{
+		git__free(si);
+		return -1;
+	}
+
+	while (item)
+	{
+		git_index_entry *clone = git_pool_malloc(&si->entry_pool, 1);
+		memcpy(clone, item, sizeof(git_index_entry));
+
+		if (item->path)
+		{
+			clone->path = git_pool_strdup(&si->string_pool, item->path);
+		}
+
+		git_vector_insert(&si->entries, clone);
+
+		if (git_iterator_advance(towrap, &item) < 0)
+		{
+			git__free(si);
+			return -1;
+		}
+	}
+
+	git_vector_sort(&si->entries);
+
+	*iter = (git_iterator *)si;
+
+	return 0;
+}
 
 int git_iterator_current_tree_entry(
 	git_iterator *iter, const git_tree_entry **tree_entry)
@@ -705,6 +867,45 @@ int git_iterator_current_tree_entry(
 	return 0;
 }
 
+int git_iterator_current_parent_tree(
+	git_iterator *iter,
+	const char *parent_path,
+	const git_tree **tree_ptr)
+{
+	tree_iterator *ti = (tree_iterator *)iter;
+	tree_iterator_frame *tf;
+	const char *scan = parent_path;
+
+	if (iter->type != GIT_ITERATOR_TREE || ti->stack == NULL)
+		goto notfound;
+
+	for (tf = ti->tail; tf != NULL; tf = tf->prev) {
+		const git_tree_entry *te;
+
+		if (!*scan) {
+			*tree_ptr = tf->tree;
+			return 0;
+		}
+
+		te = git_tree_entry_byindex(tf->tree, tf->index);
+
+		if (strncmp(scan, te->filename, te->filename_len) != 0)
+			goto notfound;
+
+		scan += te->filename_len;
+
+		if (*scan) {
+			if (*scan != '/')
+				goto notfound;
+			scan++;
+		}
+	}
+
+notfound:
+	*tree_ptr = NULL;
+	return 0;
+}
+
 int git_iterator_current_is_ignored(git_iterator *iter)
 {
 	return (iter->type != GIT_ITERATOR_WORKDIR) ? 0 :
@@ -743,6 +944,18 @@ int git_iterator_cmp(
 	if (!path_prefix)
 		return -1;
 
-	return git__prefixcmp(entry->path, path_prefix);
+	return ITERATOR_PREFIXCMP(*iter, entry->path, path_prefix);
+}
+
+int git_iterator_current_workdir_path(git_iterator *iter, git_buf **path)
+{
+	workdir_iterator *wi = (workdir_iterator *)iter;
+
+	if (iter->type != GIT_ITERATOR_WORKDIR || !wi->entry.path)
+		*path = NULL;
+	else
+		*path = &wi->path;
+
+	return 0;
 }