rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/src/win32/pthread.c

@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "pthread.h"
+
+int pthread_create(pthread_t *GIT_RESTRICT thread,
+					const pthread_attr_t *GIT_RESTRICT GIT_UNUSED(attr),
+					void *(*start_routine)(void*), void *GIT_RESTRICT arg)
+{
+	GIT_UNUSED_ARG(attr);
+	*thread = (pthread_t) CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)start_routine, arg, 0, NULL);
+	return *thread ? GIT_SUCCESS : git__throw(GIT_EOSERR, "Failed to create pthread");
+}
+
+int pthread_join(pthread_t thread, void **value_ptr)
+{
+	int ret;
+	ret = WaitForSingleObject(thread, INFINITE);
+	if (ret && value_ptr)
+		GetExitCodeThread(thread, (void*) value_ptr);
+	return -(!!ret);
+}
+
+int pthread_mutex_init(pthread_mutex_t *GIT_RESTRICT mutex,
+						const pthread_mutexattr_t *GIT_RESTRICT GIT_UNUSED(mutexattr))
+{
+	GIT_UNUSED_ARG(mutexattr);
+	InitializeCriticalSection(mutex);
+	return 0;
+}
+
+int pthread_mutex_destroy(pthread_mutex_t *mutex)
+{
+	DeleteCriticalSection(mutex);
+	return 0;
+}
+
+int pthread_mutex_lock(pthread_mutex_t *mutex)
+{
+	EnterCriticalSection(mutex);
+	return 0;
+}
+
+int pthread_mutex_unlock(pthread_mutex_t *mutex)
+{
+	LeaveCriticalSection(mutex);
+	return 0;
+}
+
+int pthread_num_processors_np(void)
+{
+	DWORD_PTR p, s;
+	int n = 0;
+
+	if (GetProcessAffinityMask(GetCurrentProcess(), &p, &s))
+		for (; p; p >>= 1)
+			n += p&1;
+
+	return n ? n : 1;
+}
+

data/ext/rugged/vendor/libgit2-dist/src/win32/pthread.h

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#ifndef GIT_PTHREAD_H
+#define GIT_PTHREAD_H
+
+#include "../common.h"
+
+#if defined (_MSC_VER)
+#	define GIT_RESTRICT __restrict
+#else
+#	define GIT_RESTRICT __restrict__
+#endif
+
+typedef int pthread_mutexattr_t;
+typedef int pthread_condattr_t;
+typedef int pthread_attr_t;
+typedef CRITICAL_SECTION pthread_mutex_t;
+typedef HANDLE pthread_t;
+
+#define PTHREAD_MUTEX_INITIALIZER {(void*)-1};
+
+int pthread_create(pthread_t *GIT_RESTRICT,
+					const pthread_attr_t *GIT_RESTRICT,
+					void *(*start_routine)(void*), void *__restrict);
+
+int pthread_join(pthread_t, void **);
+
+int pthread_mutex_init(pthread_mutex_t *GIT_RESTRICT, const pthread_mutexattr_t *GIT_RESTRICT);
+int pthread_mutex_destroy(pthread_mutex_t *);
+int pthread_mutex_lock(pthread_mutex_t *);
+int pthread_mutex_unlock(pthread_mutex_t *);
+
+int pthread_num_processors_np(void);
+
+#endif

data/ext/rugged/vendor/libgit2-dist/src/win32/utf-conv.c

@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include "common.h"
+#include "utf-conv.h"
+
+/*
+ * Default codepage value
+ */
+static int _active_codepage = CP_UTF8;
+
+void gitwin_set_codepage(unsigned int codepage)
+{
+	_active_codepage = codepage;
+}
+
+unsigned int gitwin_get_codepage(void)
+{
+	return _active_codepage;
+}
+
+void gitwin_set_utf8(void)
+{
+	_active_codepage = CP_UTF8;
+}
+
+wchar_t* gitwin_to_utf16(const char* str)
+{
+	wchar_t* ret;
+	int cb;
+
+	if (!str) {
+		return NULL;
+	}
+
+	cb = strlen(str) * sizeof(wchar_t);
+	if (cb == 0) {
+		ret = (wchar_t*)git__malloc(sizeof(wchar_t));
+		ret[0] = 0;
+		return ret;
+	}
+
+	/* Add space for null terminator */
+	cb += sizeof(wchar_t);
+
+	ret = (wchar_t*)git__malloc(cb);
+
+	if (MultiByteToWideChar(_active_codepage, 0, str, -1, ret, cb) == 0) {
+		git__free(ret);
+		ret = NULL;
+	}
+
+	return ret;
+}
+
+char* gitwin_from_utf16(const wchar_t* str)
+{
+	char* ret;
+	int cb;
+
+	if (!str) {
+		return NULL;
+	}
+
+	cb = wcslen(str) * sizeof(char);
+	if (cb == 0) {
+		ret = (char*)git__malloc(sizeof(char));
+		ret[0] = 0;
+		return ret;
+	}
+
+	/* Add space for null terminator */
+	cb += sizeof(char);
+
+	ret = (char*)git__malloc(cb);
+
+	if (WideCharToMultiByte(_active_codepage, 0, str, -1, ret, cb, NULL, NULL) == 0) {
+		git__free(ret);
+		ret = NULL;
+	}
+
+	return ret;
+
+}

data/ext/rugged/vendor/libgit2-dist/src/win32/utf-conv.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (C) 2009-2011 the libgit2 contributors
+ *
+ * This file is part of libgit2, distributed under the GNU GPL v2 with
+ * a Linking Exception. For full terms see the included COPYING file.
+ */
+
+#include <wchar.h>
+
+#ifndef INCLUDE_git_utfconv_h__
+#define INCLUDE_git_utfconv_h__
+
+wchar_t* gitwin_to_utf16(const char* str);
+char* gitwin_from_utf16(const wchar_t* str);
+
+#endif
+

data/ext/rugged/vendor/libgit2-dist/tests-clay/buf/basic.c

@@ -0,0 +1,29 @@
+#include "clay_libgit2.h"
+#include "buffer.h"
+
+static const char *test_string = "Have you seen that? Have you seeeen that??";
+
+void test_buf_basic__resize(void)
+{
+	git_buf buf1 = GIT_BUF_INIT;
+	git_buf_puts(&buf1, test_string);
+	cl_assert(git_buf_oom(&buf1) == 0);
+	cl_assert(strcmp(git_buf_cstr(&buf1), test_string) == 0);
+
+	git_buf_puts(&buf1, test_string);
+	cl_assert(strlen(git_buf_cstr(&buf1)) == strlen(test_string) * 2);
+	git_buf_free(&buf1);
+}
+
+void test_buf_basic__printf(void)
+{
+	git_buf buf2 = GIT_BUF_INIT;
+	git_buf_printf(&buf2, "%s %s %d ", "shoop", "da", 23);
+	cl_assert(git_buf_oom(&buf2) == 0);
+	cl_assert(strcmp(git_buf_cstr(&buf2), "shoop da 23 ") == 0);
+
+	git_buf_printf(&buf2, "%s %d", "woop", 42);
+	cl_assert(git_buf_oom(&buf2) == 0);
+	cl_assert(strcmp(git_buf_cstr(&buf2), "shoop da 23 woop 42") == 0);
+	git_buf_free(&buf2);
+}

data/ext/rugged/vendor/libgit2-dist/tests-clay/clay.h

@@ -0,0 +1,187 @@
+#ifndef __CLAY_TEST_H__
+#define __CLAY_TEST_H__
+
+#include <stdlib.h>
+
+void clay__assert(
+	int condition,
+	const char *file,
+	int line,
+	const char *error,
+	const char *description,
+	int should_abort);
+
+void cl_set_cleanup(void (*cleanup)(void *), void *opaque);
+void cl_fs_cleanup(void);
+
+#ifdef CLAY_FIXTURE_PATH
+const char *cl_fixture(const char *fixture_name);
+void cl_fixture_sandbox(const char *fixture_name);
+void cl_fixture_cleanup(const char *fixture_name);
+#endif
+
+/**
+ * Assertion macros with explicit error message
+ */
+#define cl_must_pass_(expr, desc) clay__assert((expr) >= 0, __FILE__, __LINE__, "Function call failed: " #expr, desc, 1)
+#define cl_must_fail_(expr, desc) clay__assert((expr) < 0, __FILE__, __LINE__, "Expected function call to fail: " #expr, desc, 1)
+#define cl_assert_(expr, desc) clay__assert((expr) != 0, __FILE__, __LINE__, "Expression is not true: " #expr, desc, 1)
+
+/**
+ * Check macros with explicit error message
+ */
+#define cl_check_pass_(expr, desc) clay__assert((expr) >= 0, __FILE__, __LINE__, "Function call failed: " #expr, desc, 0)
+#define cl_check_fail_(expr, desc) clay__assert((expr) < 0, __FILE__, __LINE__, "Expected function call to fail: " #expr, desc, 0)
+#define cl_check_(expr, desc) clay__assert((expr) != 0, __FILE__, __LINE__, "Expression is not true: " #expr, desc, 0)
+
+/**
+ * Assertion macros with no error message
+ */
+#define cl_must_pass(expr) cl_must_pass_(expr, NULL)
+#define cl_must_fail(expr) cl_must_fail_(expr, NULL)
+#define cl_assert(expr) cl_assert_(expr, NULL)
+
+/**
+ * Check macros with no error message
+ */
+#define cl_check_pass(expr) cl_check_pass_(expr, NULL)
+#define cl_check_fail(expr) cl_check_fail_(expr, NULL)
+#define cl_check(expr) cl_check_(expr, NULL)
+
+/**
+ * Forced failure/warning
+ */
+#define cl_fail(desc) clay__assert(0, __FILE__, __LINE__, "Test failed.", desc, 1)
+#define cl_warning(desc) clay__assert(0, __FILE__, __LINE__, "Warning during test execution:", desc, 0)
+
+/**
+ * Test method declarations
+ */
+extern void test_buf_basic__printf(void);
+extern void test_buf_basic__resize(void);
+extern void test_config_add__cleanup(void);
+extern void test_config_add__initialize(void);
+extern void test_config_add__to_existing_section(void);
+extern void test_config_add__to_new_section(void);
+extern void test_config_new__write_new_config(void);
+extern void test_config_read__blank_lines(void);
+extern void test_config_read__case_sensitive(void);
+extern void test_config_read__empty_files(void);
+extern void test_config_read__header_in_last_line(void);
+extern void test_config_read__invalid_ext_headers(void);
+extern void test_config_read__lone_variable(void);
+extern void test_config_read__multiline_value(void);
+extern void test_config_read__number_suffixes(void);
+extern void test_config_read__prefixes(void);
+extern void test_config_read__simple_read(void);
+extern void test_config_read__subsection_header(void);
+extern void test_config_stress__cleanup(void);
+extern void test_config_stress__dont_break_on_invalid_input(void);
+extern void test_config_stress__initialize(void);
+extern void test_config_write__cleanup(void);
+extern void test_config_write__delete_inexistent(void);
+extern void test_config_write__delete_value(void);
+extern void test_config_write__initialize(void);
+extern void test_config_write__replace_value(void);
+extern void test_core_dirent__dont_traverse_dot(void);
+extern void test_core_dirent__dont_traverse_empty_folders(void);
+extern void test_core_dirent__traverse_slash_terminated_folder(void);
+extern void test_core_dirent__traverse_subfolder(void);
+extern void test_core_dirent__traverse_weird_filenames(void);
+extern void test_core_filebuf__0(void);
+extern void test_core_filebuf__1(void);
+extern void test_core_filebuf__2(void);
+extern void test_core_filebuf__3(void);
+extern void test_core_filebuf__4(void);
+extern void test_core_filebuf__5(void);
+extern void test_core_oid__initialize(void);
+extern void test_core_oid__streq(void);
+extern void test_core_path__0(void);
+extern void test_core_path__1(void);
+extern void test_core_path__2(void);
+extern void test_core_path__5(void);
+extern void test_core_path__6(void);
+extern void test_core_rmdir__delete_recursive(void);
+extern void test_core_rmdir__fail_to_delete_non_empty_dir(void);
+extern void test_core_rmdir__initialize(void);
+extern void test_core_string__0(void);
+extern void test_core_string__1(void);
+extern void test_core_strtol__int32(void);
+extern void test_core_strtol__int64(void);
+extern void test_core_vector__0(void);
+extern void test_core_vector__1(void);
+extern void test_core_vector__2(void);
+extern void test_index_rename__single_file(void);
+extern void test_network_remotes__cleanup(void);
+extern void test_network_remotes__fnmatch(void);
+extern void test_network_remotes__initialize(void);
+extern void test_network_remotes__parsing(void);
+extern void test_network_remotes__refspec_parsing(void);
+extern void test_network_remotes__transform(void);
+extern void test_object_raw_chars__build_valid_oid_from_raw_bytes(void);
+extern void test_object_raw_chars__find_invalid_chars_in_oid(void);
+extern void test_object_raw_compare__compare_allocfmt_oids(void);
+extern void test_object_raw_compare__compare_fmt_oids(void);
+extern void test_object_raw_compare__compare_pathfmt_oids(void);
+extern void test_object_raw_compare__succeed_on_copy_oid(void);
+extern void test_object_raw_compare__succeed_on_oid_comparison_equal(void);
+extern void test_object_raw_compare__succeed_on_oid_comparison_greater(void);
+extern void test_object_raw_compare__succeed_on_oid_comparison_lesser(void);
+extern void test_object_raw_convert__succeed_on_oid_to_string_conversion(void);
+extern void test_object_raw_convert__succeed_on_oid_to_string_conversion_big(void);
+extern void test_object_raw_fromstr__fail_on_invalid_oid_string(void);
+extern void test_object_raw_fromstr__succeed_on_valid_oid_string(void);
+extern void test_object_raw_hash__hash_buffer_in_single_call(void);
+extern void test_object_raw_hash__hash_by_blocks(void);
+extern void test_object_raw_hash__hash_commit_object(void);
+extern void test_object_raw_hash__hash_junk_data(void);
+extern void test_object_raw_hash__hash_multi_byte_object(void);
+extern void test_object_raw_hash__hash_one_byte_object(void);
+extern void test_object_raw_hash__hash_tag_object(void);
+extern void test_object_raw_hash__hash_tree_object(void);
+extern void test_object_raw_hash__hash_two_byte_object(void);
+extern void test_object_raw_hash__hash_vector(void);
+extern void test_object_raw_hash__hash_zero_length_object(void);
+extern void test_object_raw_short__oid_shortener_no_duplicates(void);
+extern void test_object_raw_short__oid_shortener_stresstest_git_oid_shorten(void);
+extern void test_object_raw_size__validate_oid_size(void);
+extern void test_object_raw_type2string__check_type_is_loose(void);
+extern void test_object_raw_type2string__convert_string_to_type(void);
+extern void test_object_raw_type2string__convert_type_to_string(void);
+extern void test_object_tree_frompath__cleanup(void);
+extern void test_object_tree_frompath__fail_when_processing_an_invalid_path(void);
+extern void test_object_tree_frompath__fail_when_processing_an_unknown_tree_segment(void);
+extern void test_object_tree_frompath__initialize(void);
+extern void test_object_tree_frompath__retrieve_tree_from_path_to_treeentry(void);
+extern void test_odb_loose__cleanup(void);
+extern void test_odb_loose__exists(void);
+extern void test_odb_loose__initialize(void);
+extern void test_odb_loose__simple_reads(void);
+extern void test_odb_packed__cleanup(void);
+extern void test_odb_packed__initialize(void);
+extern void test_odb_packed__mass_read(void);
+extern void test_odb_packed__read_header_0(void);
+extern void test_odb_packed__read_header_1(void);
+extern void test_odb_sorting__alternate_backends_sorting(void);
+extern void test_odb_sorting__basic_backends_sorting(void);
+extern void test_odb_sorting__cleanup(void);
+extern void test_odb_sorting__initialize(void);
+extern void test_repo_getters__cleanup(void);
+extern void test_repo_getters__empty(void);
+extern void test_repo_getters__head_detached(void);
+extern void test_repo_getters__head_orphan(void);
+extern void test_repo_getters__initialize(void);
+extern void test_repo_init__bare_repo(void);
+extern void test_repo_init__bare_repo_noslash(void);
+extern void test_repo_init__initialize(void);
+extern void test_repo_init__standard_repo(void);
+extern void test_repo_init__standard_repo_noslash(void);
+extern void test_repo_open__bare_empty_repo(void);
+extern void test_repo_open__standard_empty_repo(void);
+extern void test_status_single__hash_single_file(void);
+extern void test_status_worktree__cleanup(void);
+extern void test_status_worktree__empty_repository(void);
+extern void test_status_worktree__initialize(void);
+extern void test_status_worktree__whole_repository(void);
+
+#endif

data/ext/rugged/vendor/libgit2-dist/tests-clay/clay_libgit2.h

@@ -0,0 +1,28 @@
+#ifndef __CLAY_LIBGIT2__
+#define __CLAY_LIBGIT2__
+
+#include "clay.h"
+#include <git2.h>
+#include "common.h"
+
+/**
+ * Special wrapper for `clay_must_pass` that passes
+ * the last library error as the test failure message.
+ *
+ * Use this wrapper around all `git_` library calls that
+ * return error codes!
+ */
+#define cl_git_pass(expr) do { \
+	git_clearerror(); \
+	if ((expr) != GIT_SUCCESS) \
+		clay__assert(0, __FILE__, __LINE__, "Function call failed: " #expr, git_lasterror(), 1); \
+	} while(0)
+
+/**
+ * Wrapper for `clay_must_fail` -- this one is
+ * just for consistency. Use with `git_` library
+ * calls that are supposed to fail!
+ */
+#define cl_git_fail(expr) cl_must_fail(expr)
+
+#endif