rugged 0.22.2 → 0.23.0b1

data/vendor/libgit2/src/filter.h

@@ -8,6 +8,7 @@
 #define INCLUDE_filter_h__
 
 #include "common.h"
+#include "attr_file.h"
 #include "git2/filter.h"
 
 /* Amount of file to examine for NUL byte when checking binary-ness */
@@ -23,8 +24,24 @@ typedef enum {
 	GIT_CRLF_AUTO,
 } git_crlf_t;
 
+typedef struct {
+	git_attr_session *attr_session;
+	git_buf *temp_buf;
+	uint32_t flags;
+} git_filter_options;
+
+#define GIT_FILTER_OPTIONS_INIT {0}
+
 extern void git_filter_free(git_filter *filter);
 
+extern int git_filter_list__load_ext(
+	git_filter_list **filters,
+	git_repository *repo,
+	git_blob *blob, /* can be NULL */
+	const char *path,
+	git_filter_mode_t mode,
+	git_filter_options *filter_opts);
+
 /*
  * Available filters
  */

data/vendor/libgit2/src/global.c

@@ -36,16 +36,25 @@ void git__on_shutdown(git_global_shutdown_fn callback)
 	git__shutdown_callbacks[count - 1] = callback;
 }
 
+static void git__global_state_cleanup(git_global_st *st)
+{
+	if (!st)
+		return;
+
+	git__free(st->error_t.message);
+	st->error_t.message = NULL;
+}
+
 static void git__shutdown(void)
 {
 	int pos;
 
+	/* Shutdown subsystems that have registered */
 	for (pos = git_atomic_get(&git__n_shutdown_callbacks); pos > 0; pos = git_atomic_dec(&git__n_shutdown_callbacks)) {
 		git_global_shutdown_fn cb = git__swap(git__shutdown_callbacks[pos - 1], NULL);
 		if (cb != NULL)
 			cb();
 	}
-
 }
 
 #if defined(GIT_THREADS) && defined(GIT_SSL)
@@ -214,8 +223,14 @@ int git_libgit2_init(void)
 
 static void synchronized_threads_shutdown(void)
 {
+	void *ptr;
+
 	/* Shut down any subsystems that have global state */
 	git__shutdown();
+
+	ptr = TlsGetValue(_tls_index);
+	git__global_state_cleanup(ptr);
+
 	TlsFree(_tls_index);
 	git_mutex_free(&git__mwindow_mutex);
 }
@@ -255,6 +270,17 @@ git_global_st *git__global_state(void)
 	return ptr;
 }
 
+BOOL WINAPI DllMain(HINSTANCE dll, DWORD reason, LPVOID reserved)
+{
+	if (reason == DLL_THREAD_DETACH) {
+		void *ptr = TlsGetValue(_tls_index);
+		git__global_state_cleanup(ptr);
+		git__free(ptr);
+	}
+
+	return TRUE;
+}
+
 #elif defined(GIT_THREADS) && defined(_POSIX_THREADS)
 
 static pthread_key_t _tls_key;
@@ -263,9 +289,7 @@ int init_error = 0;
 
 static void cb__free_status(void *st)
 {
-	git_global_st *state = (git_global_st *) st;
-	git__free(state->error_t.message);
-
+	git__global_state_cleanup(st);
 	git__free(st);
 }
 
@@ -302,7 +326,7 @@ int git_libgit2_shutdown(void)
 	pthread_once_t new_once = PTHREAD_ONCE_INIT;
 	int ret;
 
-	if ((ret = git_atomic_dec(&git__n_inits)) > 0)
+	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
 		return ret;
 
 	/* Shut down any subsystems that have global state */
@@ -310,13 +334,15 @@ int git_libgit2_shutdown(void)
 
 	ptr = pthread_getspecific(_tls_key);
 	pthread_setspecific(_tls_key, NULL);
+
+	git__global_state_cleanup(ptr);
 	git__free(ptr);
 
 	pthread_key_delete(_tls_key);
 	git_mutex_free(&git__mwindow_mutex);
 	_once_init = new_once;
 
-	return ret;
+	return 0;
 }
 
 git_global_st *git__global_state(void)
@@ -358,10 +384,13 @@ int git_libgit2_shutdown(void)
 	int ret;
 
 	/* Shut down any subsystems that have global state */
-	if (ret = git_atomic_dec(&git__n_inits))
-		git__shutdown();
+	if ((ret = git_atomic_dec(&git__n_inits)) != 0)
+		return ret;
 
-	return ret;
+	git__shutdown();
+	git__global_state_cleanup(&__state);
+
+	return 0;
 }
 
 git_global_st *git__global_state(void)

data/vendor/libgit2/src/hash/hash_generic.c

@@ -18,7 +18,7 @@
  * rotate with a loop.
  */
 
-#define SHA_ASM(op, x, n) ({ unsigned int __res; __asm__(op " %1,%0":"=r" (__res):"i" (n), "0" (x)); __res; })
+#define SHA_ASM(op, x, n) (__extension__ ({ unsigned int __res; __asm__(op " %1,%0":"=r" (__res):"i" (n), "0" (x)); __res; }))
 #define SHA_ROL(x,n)	SHA_ASM("rol", x, n)
 #define SHA_ROR(x,n)	SHA_ASM("ror", x, n)
 

data/vendor/libgit2/src/hashsig.c

@@ -34,8 +34,8 @@ typedef struct {
 struct git_hashsig {
 	hashsig_heap mins;
 	hashsig_heap maxs;
+	size_t lines;
 	git_hashsig_option_t opt;
-	int considered;
 };
 
 #define HEAP_LCHILD_OF(I) (((I)<<1)+1)
@@ -135,25 +135,23 @@ static void hashsig_in_progress_init(
 {
 	int i;
 
-	switch (sig->opt) {
-	case GIT_HASHSIG_IGNORE_WHITESPACE:
+	/* no more than one can be set */
+	assert(!(sig->opt & GIT_HASHSIG_IGNORE_WHITESPACE) ||
+		   !(sig->opt & GIT_HASHSIG_SMART_WHITESPACE));
+
+	if (sig->opt & GIT_HASHSIG_IGNORE_WHITESPACE) {
 		for (i = 0; i < 256; ++i)
 			prog->ignore_ch[i] = git__isspace_nonlf(i);
 		prog->use_ignores = 1;
-		break;
-	case GIT_HASHSIG_SMART_WHITESPACE:
+	} else if (sig->opt & GIT_HASHSIG_SMART_WHITESPACE) {
 		for (i = 0; i < 256; ++i)
 			prog->ignore_ch[i] = git__isspace(i);
 		prog->use_ignores = 1;
-		break;
-	default:
+	} else {
 		memset(prog, 0, sizeof(*prog));
-		break;
 	}
 }
 
-#define HASHSIG_IN_PROGRESS_INIT { 1 }
-
 static int hashsig_add_hashes(
 	git_hashsig *sig,
 	const uint8_t *data,
@@ -174,12 +172,13 @@ static int hashsig_add_hashes(
 			if (use_ignores)
 				for (; scan < end && git__isspace_nonlf(ch); ch = *scan)
 					++scan;
-			else if (sig->opt != GIT_HASHSIG_NORMAL)
+			else if (sig->opt &
+					 (GIT_HASHSIG_IGNORE_WHITESPACE | GIT_HASHSIG_SMART_WHITESPACE))
 				for (; scan < end && ch == '\r'; ch = *scan)
 					++scan;
 
 			/* peek at next character to decide what to do next */
-			if (sig->opt == GIT_HASHSIG_SMART_WHITESPACE)
+			if (sig->opt & GIT_HASHSIG_SMART_WHITESPACE)
 				use_ignores = (ch == '\n');
 
 			if (scan >= end)
@@ -187,8 +186,10 @@ static int hashsig_add_hashes(
 			++scan;
 
 			/* check run terminator */
-			if (ch == '\n' || ch == '\0')
+			if (ch == '\n' || ch == '\0') {
+				sig->lines++;
 				break;
+			}
 
 			++len;
 			HASHSIG_HASH_MIX(state, ch);
@@ -198,8 +199,6 @@ static int hashsig_add_hashes(
 			hashsig_heap_insert(&sig->mins, (hashsig_t)state);
 			hashsig_heap_insert(&sig->maxs, (hashsig_t)state);
 
-			sig->considered++;
-
 			while (scan < end && (*scan == '\n' || !*scan))
 				++scan;
 		}
@@ -212,7 +211,8 @@ static int hashsig_add_hashes(
 
 static int hashsig_finalize_hashes(git_hashsig *sig)
 {
-	if (sig->mins.size < HASHSIG_HEAP_MIN_SIZE) {
+	if (sig->mins.size < HASHSIG_HEAP_MIN_SIZE &&
+		!(sig->opt & GIT_HASHSIG_ALLOW_SMALL_FILES)) {
 		giterr_set(GITERR_INVALID,
 			"File too small for similarity signature calculation");
 		return GIT_EBUFS;
@@ -336,6 +336,18 @@ static int hashsig_heap_compare(const hashsig_heap *a, const hashsig_heap *b)
 
 int git_hashsig_compare(const git_hashsig *a, const git_hashsig *b)
 {
+	/* if we have no elements in either file then each file is either
+	 * empty or blank.  if we're ignoring whitespace then the files are
+	 * similar, otherwise they're dissimilar.
+	 */
+	if (a->mins.size == 0 && b->mins.size == 0) {
+		if ((!a->lines && !b->lines) ||
+			(a->opt & GIT_HASHSIG_IGNORE_WHITESPACE))
+			return HASHSIG_SCALE;
+		else
+			return 0;
+	}
+
 	/* if we have fewer than the maximum number of elements, then just use
 	 * one array since the two arrays will be the same
 	 */

data/vendor/libgit2/src/ignore.c

@@ -161,7 +161,7 @@ static int push_ignore_file(
 	git_attr_file *file = NULL;
 
 	error = git_attr_cache__get(
-		&file, ignores->repo, GIT_ATTR_FILE__FROM_FILE,
+		&file, ignores->repo, NULL, GIT_ATTR_FILE__FROM_FILE,
 		base, filename, parse_ignore_file);
 	if (error < 0)
 		return error;
@@ -189,7 +189,7 @@ static int get_internal_ignores(git_attr_file **out, git_repository *repo)
 		return error;
 
 	error = git_attr_cache__get(
-		out, repo, GIT_ATTR_FILE__IN_MEMORY, NULL, GIT_IGNORE_INTERNAL, NULL);
+		out, repo, NULL, GIT_ATTR_FILE__IN_MEMORY, NULL, GIT_IGNORE_INTERNAL, NULL);
 
 	/* if internal rules list is empty, insert default rules */
 	if (!error && !(*out)->rules.length)

data/vendor/libgit2/src/index.c

@@ -656,39 +656,15 @@ int git_index__changed_relative_to(
 
 int git_index_write(git_index *index)
 {
-	git_filebuf file = GIT_FILEBUF_INIT;
+	git_indexwriter writer = GIT_INDEXWRITER_INIT;
 	int error;
 
-	if (!index->index_file_path)
-		return create_index_error(-1,
-			"Failed to read index: The index is in-memory only");
+	if ((error = git_indexwriter_init(&writer, index)) == 0)
+		error = git_indexwriter_commit(&writer);
 
-	if (index_sort_if_needed(index, true) < 0)
-		return -1;
-	git_vector_sort(&index->reuc);
+	git_indexwriter_cleanup(&writer);
 
-	if ((error = git_filebuf_open(
-		&file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS, GIT_INDEX_FILE_MODE)) < 0) {
-		if (error == GIT_ELOCKED)
-			giterr_set(GITERR_INDEX, "The index is locked. This might be due to a concurrent or crashed process");
-
-		return error;
-	}
-
-	if ((error = write_index(index, &file)) < 0) {
-		git_filebuf_cleanup(&file);
-		return error;
-	}
-
-	if ((error = git_filebuf_commit(&file)) < 0)
-		return error;
-
-	if (git_futils_filestamp_check(&index->stamp, index->index_file_path) < 0)
-		/* index could not be read from disk! */;
-	else
-		index->on_disk = 1;
-
-	return 0;
+	return error;
 }
 
 const char * git_index_path(const git_index *index)
@@ -770,7 +746,7 @@ static int index_entry_create(
 	git_repository *repo,
 	const char *path)
 {
-	size_t pathlen = strlen(path);
+	size_t pathlen = strlen(path), alloclen;
 	struct entry_internal *entry;
 
 	if (!git_path_isvalid(repo, path,
@@ -779,7 +755,9 @@ static int index_entry_create(
 		return -1;
 	}
 
-	entry = git__calloc(sizeof(struct entry_internal) + pathlen + 1, 1);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, sizeof(struct entry_internal), pathlen);
+	GITERR_CHECK_ALLOC_ADD(&alloclen, alloclen, 1);
+	entry = git__calloc(1, alloclen);
 	GITERR_CHECK_ALLOC(entry);
 
 	entry->pathlen = pathlen;
@@ -826,9 +804,16 @@ static int index_entry_init(
 
 static git_index_reuc_entry *reuc_entry_alloc(const char *path)
 {
-	size_t pathlen = strlen(path);
-	struct reuc_entry_internal *entry =
-		git__calloc(sizeof(struct reuc_entry_internal) + pathlen + 1, 1);
+	size_t pathlen = strlen(path),
+		structlen = sizeof(struct reuc_entry_internal),
+		alloclen;
+	struct reuc_entry_internal *entry;
+
+	if (GIT_ADD_SIZET_OVERFLOW(&alloclen, structlen, pathlen) ||
+		GIT_ADD_SIZET_OVERFLOW(&alloclen, alloclen, 1))
+		return NULL;
+
+	entry = git__calloc(1, alloclen);
 	if (!entry)
 		return NULL;
 
@@ -1097,6 +1082,58 @@ static int index_conflict_to_reuc(git_index *index, const char *path)
 	return ret;
 }
 
+static bool valid_filemode(const int filemode)
+{
+	return (filemode == GIT_FILEMODE_BLOB ||
+		filemode == GIT_FILEMODE_BLOB_EXECUTABLE ||
+		filemode == GIT_FILEMODE_LINK ||
+		filemode == GIT_FILEMODE_COMMIT);
+}
+
+int git_index_add_frombuffer(
+    git_index *index, git_index_entry *source_entry,
+    const void *buffer, size_t len)
+{
+	git_index_entry *entry = NULL;
+	int error = 0;
+	git_oid id;
+
+	assert(index && source_entry->path);
+
+	if (INDEX_OWNER(index) == NULL)
+		return create_index_error(-1,
+			"Could not initialize index entry. "
+			"Index is not backed up by an existing repository.");
+
+	if (!valid_filemode(source_entry->mode)) {
+		giterr_set(GITERR_INDEX, "invalid filemode");
+		return -1;
+	}
+
+	if (index_entry_dup(&entry, INDEX_OWNER(index), source_entry) < 0)
+		return -1;
+
+	error = git_blob_create_frombuffer(&id, INDEX_OWNER(index), buffer, len);
+	if (error < 0) {
+		index_entry_free(entry);
+		return error;
+	}
+
+	git_oid_cpy(&entry->id, &id);
+	entry->file_size = len;
+
+	if ((error = index_insert(index, &entry, 1)) < 0)
+		return error;
+
+	/* Adding implies conflict was resolved, move conflict entries to REUC */
+	if ((error = index_conflict_to_reuc(index, entry->path)) < 0 && error != GIT_ENOTFOUND)
+		return error;
+
+	git_tree_cache_invalidate_path(index->tree, entry->path);
+	return 0;
+}
+
+
 int git_index_add_bypath(git_index *index, const char *path)
 {
 	git_index_entry *entry = NULL;
@@ -1131,14 +1168,6 @@ int git_index_remove_bypath(git_index *index, const char *path)
 	return 0;
 }
 
-static bool valid_filemode(const int filemode)
-{
-	return (filemode == GIT_FILEMODE_BLOB ||
-		filemode == GIT_FILEMODE_BLOB_EXECUTABLE ||
-		filemode == GIT_FILEMODE_LINK ||
-		filemode == GIT_FILEMODE_COMMIT);
-}
-
 
 int git_index_add(git_index *index, const git_index_entry *source_entry)
 {
@@ -2686,3 +2715,91 @@ int git_index_snapshot_find(
 {
 	return index_find_in_entries(out, entries, entry_srch, path, path_len, stage);
 }
+
+int git_indexwriter_init(
+	git_indexwriter *writer,
+	git_index *index)
+{
+	int error;
+
+	GIT_REFCOUNT_INC(index);
+
+	writer->index = index;
+
+	if (!index->index_file_path)
+		return create_index_error(-1,
+			"Failed to write index: The index is in-memory only");
+
+	if ((error = git_filebuf_open(
+		&writer->file, index->index_file_path, GIT_FILEBUF_HASH_CONTENTS, GIT_INDEX_FILE_MODE)) < 0) {
+
+		if (error == GIT_ELOCKED)
+			giterr_set(GITERR_INDEX, "The index is locked. This might be due to a concurrent or crashed process");
+
+		return error;
+	}
+
+	writer->should_write = 1;
+
+	return 0;
+}
+
+int git_indexwriter_init_for_operation(
+	git_indexwriter *writer,
+	git_repository *repo,
+	unsigned int *checkout_strategy)
+{
+	git_index *index;
+	int error;
+
+	if ((error = git_repository_index__weakptr(&index, repo)) < 0 ||
+		(error = git_indexwriter_init(writer, index)) < 0)
+		return error;
+
+	writer->should_write = (*checkout_strategy & GIT_CHECKOUT_DONT_WRITE_INDEX) == 0;
+	*checkout_strategy |= GIT_CHECKOUT_DONT_WRITE_INDEX;
+
+	return 0;
+}
+
+int git_indexwriter_commit(git_indexwriter *writer)
+{
+	int error;
+
+	if (!writer->should_write)
+		return 0;
+
+	if (index_sort_if_needed(writer->index, true) < 0)
+		return -1;
+
+	git_vector_sort(&writer->index->reuc);
+
+	if ((error = write_index(writer->index, &writer->file)) < 0) {
+		git_indexwriter_cleanup(writer);
+		return error;
+	}
+
+	if ((error = git_filebuf_commit(&writer->file)) < 0)
+		return error;
+
+	if ((error = git_futils_filestamp_check(
+		&writer->index->stamp, writer->index->index_file_path)) < 0) {
+		giterr_set(GITERR_OS, "Could not read index timestamp");
+		return -1;
+	}
+
+	writer->index->on_disk = 1;
+
+	git_index_free(writer->index);
+	writer->index = NULL;
+
+	return 0;
+}
+
+void git_indexwriter_cleanup(git_indexwriter *writer)
+{
+	git_filebuf_cleanup(&writer->file);
+
+	git_index_free(writer->index);
+	writer->index = NULL;
+}