rugged 0.16.0 → 0.17.0b1

data/ext/rugged/vendor/libgit2-dist/tests-clar/attr/repo.c

@@ -0,0 +1,273 @@
+#include "clar_libgit2.h"
+#include "fileops.h"
+#include "git2/attr.h"
+#include "attr.h"
+
+#include "attr_expect.h"
+
+static git_repository *g_repo = NULL;
+
+void test_attr_repo__initialize(void)
+{
+	/* Before each test, instantiate the attr repo from the fixtures and
+	 * rename the .gitted to .git so it is a repo with a working dir.
+	 * Also rename gitattributes to .gitattributes, because it contains
+	 * macro definitions which are only allowed in the root.
+	 */
+	g_repo = cl_git_sandbox_init("attr");
+}
+
+void test_attr_repo__cleanup(void)
+{
+	cl_git_sandbox_cleanup();
+	g_repo = NULL;
+}
+
+void test_attr_repo__get_one(void)
+{
+	struct attr_expected test_cases[] = {
+		{ "root_test1", "repoattr", EXPECT_TRUE, NULL },
+		{ "root_test1", "rootattr", EXPECT_TRUE, NULL },
+		{ "root_test1", "missingattr", EXPECT_UNDEFINED, NULL },
+		{ "root_test1", "subattr", EXPECT_UNDEFINED, NULL },
+		{ "root_test1", "negattr", EXPECT_UNDEFINED, NULL },
+		{ "root_test2", "repoattr", EXPECT_TRUE, NULL },
+		{ "root_test2", "rootattr", EXPECT_FALSE, NULL },
+		{ "root_test2", "missingattr", EXPECT_UNDEFINED, NULL },
+		{ "root_test2", "multiattr", EXPECT_FALSE, NULL },
+		{ "root_test3", "repoattr", EXPECT_TRUE, NULL },
+		{ "root_test3", "rootattr", EXPECT_UNDEFINED, NULL },
+		{ "root_test3", "multiattr", EXPECT_STRING, "3" },
+		{ "root_test3", "multi2", EXPECT_UNDEFINED, NULL },
+		{ "sub/subdir_test1", "repoattr", EXPECT_TRUE, NULL },
+		{ "sub/subdir_test1", "rootattr", EXPECT_TRUE, NULL },
+		{ "sub/subdir_test1", "missingattr", EXPECT_UNDEFINED, NULL },
+		{ "sub/subdir_test1", "subattr", EXPECT_STRING, "yes" },
+		{ "sub/subdir_test1", "negattr", EXPECT_FALSE, NULL },
+		{ "sub/subdir_test1", "another", EXPECT_UNDEFINED, NULL },
+		{ "sub/subdir_test2.txt", "repoattr", EXPECT_TRUE, NULL },
+		{ "sub/subdir_test2.txt", "rootattr", EXPECT_TRUE, NULL },
+		{ "sub/subdir_test2.txt", "missingattr", EXPECT_UNDEFINED, NULL },
+		{ "sub/subdir_test2.txt", "subattr", EXPECT_STRING, "yes" },
+		{ "sub/subdir_test2.txt", "negattr", EXPECT_FALSE, NULL },
+		{ "sub/subdir_test2.txt", "another", EXPECT_STRING, "zero" },
+		{ "sub/subdir_test2.txt", "reposub", EXPECT_TRUE, NULL },
+		{ "sub/sub/subdir.txt", "another", EXPECT_STRING, "one" },
+		{ "sub/sub/subdir.txt", "reposubsub", EXPECT_TRUE, NULL },
+		{ "sub/sub/subdir.txt", "reposub", EXPECT_UNDEFINED, NULL },
+		{ "does-not-exist", "foo", EXPECT_STRING, "yes" },
+		{ "sub/deep/file", "deepdeep", EXPECT_TRUE, NULL },
+		{ "sub/sub/d/no", "test", EXPECT_STRING, "a/b/d/*" },
+		{ "sub/sub/d/yes", "test", EXPECT_UNDEFINED, NULL },
+		{ NULL, NULL, 0, NULL }
+	}, *scan;
+
+	for (scan = test_cases; scan->path != NULL; scan++) {
+		const char *value;
+		cl_git_pass(git_attr_get(&value, g_repo, 0, scan->path, scan->attr));
+		attr_check_expected(scan->expected, scan->expected_str, scan->attr, value);
+	}
+
+	cl_assert(git_attr_cache__is_cached(g_repo, 0, ".git/info/attributes"));
+	cl_assert(git_attr_cache__is_cached(g_repo, 0, ".gitattributes"));
+	cl_assert(git_attr_cache__is_cached(g_repo, 0, "sub/.gitattributes"));
+}
+
+void test_attr_repo__get_many(void)
+{
+	const char *names[4] = { "repoattr", "rootattr", "missingattr", "subattr" };
+	const char *values[4];
+
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "root_test1", 4, names));
+
+	cl_assert(GIT_ATTR_TRUE(values[0]));
+	cl_assert(GIT_ATTR_TRUE(values[1]));
+	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
+	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
+
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "root_test2", 4, names));
+
+	cl_assert(GIT_ATTR_TRUE(values[0]));
+	cl_assert(GIT_ATTR_FALSE(values[1]));
+	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
+	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
+
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "sub/subdir_test1", 4, names));
+
+	cl_assert(GIT_ATTR_TRUE(values[0]));
+	cl_assert(GIT_ATTR_TRUE(values[1]));
+	cl_assert(GIT_ATTR_UNSPECIFIED(values[2]));
+	cl_assert_equal_s("yes", values[3]);
+}
+
+static int count_attrs(
+	const char *name,
+	const char *value,
+	void *payload)
+{
+	GIT_UNUSED(name);
+	GIT_UNUSED(value);
+
+	*((int *)payload) += 1;
+
+	return 0;
+}
+
+void test_attr_repo__foreach(void)
+{
+	int count;
+
+	count = 0;
+	cl_git_pass(git_attr_foreach(
+		g_repo, 0, "root_test1", &count_attrs, &count));
+	cl_assert(count == 2);
+
+	count = 0;
+	cl_git_pass(git_attr_foreach(g_repo, 0, "sub/subdir_test1",
+		&count_attrs, &count));
+	cl_assert(count == 4); /* repoattr, rootattr, subattr, negattr */
+
+	count = 0;
+	cl_git_pass(git_attr_foreach(g_repo, 0, "sub/subdir_test2.txt",
+		&count_attrs, &count));
+	cl_assert(count == 6); /* repoattr, rootattr, subattr, reposub, negattr, another */
+}
+
+void test_attr_repo__manpage_example(void)
+{
+	const char *value;
+
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "foo"));
+	cl_assert(GIT_ATTR_TRUE(value));
+
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "bar"));
+	cl_assert(GIT_ATTR_UNSPECIFIED(value));
+
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "baz"));
+	cl_assert(GIT_ATTR_FALSE(value));
+
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "merge"));
+	cl_assert_equal_s("filfre", value);
+
+	cl_git_pass(git_attr_get(&value, g_repo, 0, "sub/abc", "frotz"));
+	cl_assert(GIT_ATTR_UNSPECIFIED(value));
+}
+
+void test_attr_repo__macros(void)
+{
+	const char *names[5] = { "rootattr", "binary", "diff", "crlf", "frotz" };
+	const char *names2[5] = { "mymacro", "positive", "negative", "rootattr", "another" };
+	const char *names3[3] = { "macro2", "multi2", "multi3" };
+	const char *values[5];
+
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "binfile", 5, names));
+
+	cl_assert(GIT_ATTR_TRUE(values[0]));
+	cl_assert(GIT_ATTR_TRUE(values[1]));
+	cl_assert(GIT_ATTR_FALSE(values[2]));
+	cl_assert(GIT_ATTR_FALSE(values[3]));
+	cl_assert(GIT_ATTR_UNSPECIFIED(values[4]));
+
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_test", 5, names2));
+
+	cl_assert(GIT_ATTR_TRUE(values[0]));
+	cl_assert(GIT_ATTR_TRUE(values[1]));
+	cl_assert(GIT_ATTR_FALSE(values[2]));
+	cl_assert(GIT_ATTR_UNSPECIFIED(values[3]));
+	cl_assert_equal_s("77", values[4]);
+
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_test", 3, names3));
+
+	cl_assert(GIT_ATTR_TRUE(values[0]));
+	cl_assert(GIT_ATTR_FALSE(values[1]));
+	cl_assert_equal_s("answer", values[2]);
+}
+
+void test_attr_repo__bad_macros(void)
+{
+	const char *names[6] = { "rootattr", "positive", "negative",
+		"firstmacro", "secondmacro", "thirdmacro" };
+	const char *values[6];
+
+	cl_git_pass(git_attr_get_many(values, g_repo, 0, "macro_bad", 6, names));
+
+	/* these three just confirm that the "mymacro" rule ran */
+	cl_assert(GIT_ATTR_UNSPECIFIED(values[0]));
+	cl_assert(GIT_ATTR_TRUE(values[1]));
+	cl_assert(GIT_ATTR_FALSE(values[2]));
+
+	/* file contains:
+	 *     # let's try some malicious macro defs
+	 *     [attr]firstmacro -thirdmacro -secondmacro
+	 *     [attr]secondmacro firstmacro -firstmacro
+	 *     [attr]thirdmacro secondmacro=hahaha -firstmacro
+	 *     macro_bad firstmacro secondmacro thirdmacro
+	 *
+	 * firstmacro assignment list ends up with:
+	 *     -thirdmacro -secondmacro
+	 * secondmacro assignment list expands "firstmacro" and ends up with:
+	 *     -thirdmacro -secondmacro -firstmacro
+	 * thirdmacro assignment don't expand so list ends up with:
+	 *     secondmacro="hahaha"
+	 *
+	 * macro_bad assignment list ends up with:
+	 *     -thirdmacro -secondmacro firstmacro &&
+	 *     -thirdmacro -secondmacro -firstmacro secondmacro &&
+	 *     secondmacro="hahaha" thirdmacro
+	 *
+	 * so summary results should be:
+	 *     -firstmacro secondmacro="hahaha" thirdmacro
+	 */
+	cl_assert(GIT_ATTR_FALSE(values[3]));
+	cl_assert_equal_s("hahaha", values[4]);
+	cl_assert(GIT_ATTR_TRUE(values[5]));
+}
+
+#define CONTENT "I'm going to be dynamically processed\r\n" \
+	"And my line endings...\r\n" \
+	"...are going to be\n" \
+	"normalized!\r\n"
+
+#define GITATTR "* text=auto\n" \
+	"*.txt text\n" \
+	"*.data binary\n"
+
+static void add_to_workdir(const char *filename, const char *content)
+{
+	git_buf buf = GIT_BUF_INIT;
+
+	cl_git_pass(git_buf_joinpath(&buf, "attr", filename));
+	cl_git_rewritefile(git_buf_cstr(&buf), content);
+
+	git_buf_free(&buf);
+}
+
+static void assert_proper_normalization(git_index *index, const char *filename, const char *expected_sha)
+{
+	int index_pos;
+	git_index_entry *entry;
+
+	add_to_workdir(filename, CONTENT);
+	cl_git_pass(git_index_add(index, filename, 0));
+
+	index_pos = git_index_find(index, filename);
+	cl_assert(index_pos >= 0);
+
+	entry = git_index_get(index, index_pos);
+	cl_assert_equal_i(0, git_oid_streq(&entry->oid, expected_sha));
+}
+
+void test_attr_repo__staging_properly_normalizes_line_endings_according_to_gitattributes_directives(void)
+{
+	git_index* index;
+
+	cl_git_pass(git_repository_index(&index, g_repo));
+
+	add_to_workdir(".gitattributes", GITATTR);
+
+	assert_proper_normalization(index, "text.txt", "22c74203bace3c2e950278c7ab08da0fca9f4e9b");
+	assert_proper_normalization(index, "huh.dunno", "22c74203bace3c2e950278c7ab08da0fca9f4e9b");
+	assert_proper_normalization(index, "binary.data", "66eeff1fcbacf589e6d70aa70edd3fce5be2b37c");
+
+	git_index_free(index);
+}

data/ext/rugged/vendor/libgit2-dist/{tests-clay → tests-clar}/buf/basic.c

@@ -1,4 +1,4 @@
-#include "clay_libgit2.h"
+#include "clar_libgit2.h"
 #include "buffer.h"
 
 static const char *test_string = "Have you seen that? Have you seeeen that??";
@@ -8,7 +8,7 @@ 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);
+	cl_assert_equal_s(git_buf_cstr(&buf1), test_string);
 
 	git_buf_puts(&buf1, test_string);
 	cl_assert(strlen(git_buf_cstr(&buf1)) == strlen(test_string) * 2);
@@ -20,10 +20,10 @@ 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);
+	cl_assert_equal_s(git_buf_cstr(&buf2), "shoop da 23 ");
 
 	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);
+	cl_assert_equal_s(git_buf_cstr(&buf2), "shoop da 23 woop 42");
 	git_buf_free(&buf2);
-}
+}

data/ext/rugged/vendor/libgit2-dist/tests-clar/clar_helpers.c

@@ -0,0 +1,181 @@
+#include "clar_libgit2.h"
+#include "posix.h"
+
+void clar_on_init(void)
+{
+	git_threads_init();
+}
+
+void clar_on_shutdown(void)
+{
+	git_threads_shutdown();
+}
+
+void cl_git_mkfile(const char *filename, const char *content)
+{
+	int fd;
+
+	fd = p_creat(filename, 0666);
+	cl_assert(fd != 0);
+
+	if (content) {
+		cl_must_pass(p_write(fd, content, strlen(content)));
+	} else {
+		cl_must_pass(p_write(fd, filename, strlen(filename)));
+		cl_must_pass(p_write(fd, "\n", 1));
+	}
+
+	cl_must_pass(p_close(fd));
+}
+
+void cl_git_write2file(const char *filename, const char *new_content, int flags)
+{
+	int fd = p_open(filename, flags, 0644);
+	cl_assert(fd >= 0);
+	if (!new_content)
+		new_content = "\n";
+	cl_must_pass(p_write(fd, new_content, strlen(new_content)));
+	cl_must_pass(p_close(fd));
+}
+
+void cl_git_append2file(const char *filename, const char *new_content)
+{
+	cl_git_write2file(filename, new_content, O_WRONLY | O_CREAT | O_APPEND);
+}
+
+void cl_git_rewritefile(const char *filename, const char *new_content)
+{
+	cl_git_write2file(filename, new_content, O_WRONLY | O_CREAT | O_TRUNC);
+}
+
+#ifdef GIT_WIN32
+
+#include "win32/utf-conv.h"
+
+char *cl_getenv(const char *name)
+{
+	wchar_t *name_utf16 = gitwin_to_utf16(name);
+	DWORD value_len, alloc_len;
+	wchar_t *value_utf16;
+	char *value_utf8;
+
+	cl_assert(name_utf16);
+	alloc_len = GetEnvironmentVariableW(name_utf16, NULL, 0);
+	if (alloc_len <= 0)
+		return NULL;
+
+	cl_assert(value_utf16 = git__calloc(alloc_len, sizeof(wchar_t)));
+
+	value_len = GetEnvironmentVariableW(name_utf16, value_utf16, alloc_len);
+	cl_assert_equal_i(value_len, alloc_len - 1);
+
+	cl_assert(value_utf8 = gitwin_from_utf16(value_utf16));
+
+	git__free(value_utf16);
+
+	return value_utf8;
+}
+
+int cl_setenv(const char *name, const char *value)
+{
+	wchar_t *name_utf16 = gitwin_to_utf16(name);
+	wchar_t *value_utf16 = value ? gitwin_to_utf16(value) : NULL;
+
+	cl_assert(name_utf16);
+	cl_assert(SetEnvironmentVariableW(name_utf16, value_utf16));
+
+	git__free(name_utf16);
+	git__free(value_utf16);
+
+	return 0;
+
+}
+#else
+
+#include <stdlib.h>
+char *cl_getenv(const char *name)
+{
+   return getenv(name);
+}
+
+int cl_setenv(const char *name, const char *value)
+{
+	return (value == NULL) ? unsetenv(name) : setenv(name, value, 1);
+}
+#endif
+
+static const char *_cl_sandbox = NULL;
+static git_repository *_cl_repo = NULL;
+
+git_repository *cl_git_sandbox_init(const char *sandbox)
+{
+	/* Copy the whole sandbox folder from our fixtures to our test sandbox
+	 * area.  After this it can be accessed with `./sandbox`
+	 */
+	cl_fixture_sandbox(sandbox);
+	_cl_sandbox = sandbox;
+
+	cl_git_pass(p_chdir(sandbox));
+
+	/* If this is not a bare repo, then rename `sandbox/.gitted` to
+	 * `sandbox/.git` which must be done since we cannot store a folder
+	 * named `.git` inside the fixtures folder of our libgit2 repo.
+	 */
+	if (p_access(".gitted", F_OK) == 0)
+		cl_git_pass(p_rename(".gitted", ".git"));
+
+	/* If we have `gitattributes`, rename to `.gitattributes`.  This may
+	 * be necessary if we don't want the attributes to be applied in the
+	 * libgit2 repo, but just during testing.
+	 */
+	if (p_access("gitattributes", F_OK) == 0)
+		cl_git_pass(p_rename("gitattributes", ".gitattributes"));
+
+	/* As with `gitattributes`, we may need `gitignore` just for testing. */
+	if (p_access("gitignore", F_OK) == 0)
+		cl_git_pass(p_rename("gitignore", ".gitignore"));
+
+	cl_git_pass(p_chdir(".."));
+
+	/* Now open the sandbox repository and make it available for tests */
+	cl_git_pass(git_repository_open(&_cl_repo, sandbox));
+
+	return _cl_repo;
+}
+
+void cl_git_sandbox_cleanup(void)
+{
+	if (_cl_repo) {
+		git_repository_free(_cl_repo);
+		_cl_repo = NULL;
+	}
+	if (_cl_sandbox) {
+		cl_fixture_cleanup(_cl_sandbox);
+		_cl_sandbox = NULL;
+	}
+}
+
+bool cl_toggle_filemode(const char *filename)
+{
+	struct stat st1, st2;
+
+	cl_must_pass(p_stat(filename, &st1));
+	cl_must_pass(p_chmod(filename, st1.st_mode ^ 0100));
+	cl_must_pass(p_stat(filename, &st2));
+
+	return (st1.st_mode != st2.st_mode);
+}
+
+bool cl_is_chmod_supported(void)
+{
+	static int _is_supported = -1;
+
+	if (_is_supported < 0) {
+		cl_git_mkfile("filemode.t", "Test if filemode can be modified");
+		_is_supported = cl_toggle_filemode("filemode.t");
+		cl_must_pass(p_unlink("filemode.t"));
+	}
+
+	return _is_supported;
+}
+

data/ext/rugged/vendor/libgit2-dist/tests-clar/clar_libgit2.h

@@ -0,0 +1,55 @@
+#ifndef __CLAR_LIBGIT2__
+#define __CLAR_LIBGIT2__
+
+#include "clar.h"
+#include <git2.h>
+#include "common.h"
+
+/**
+ * Special wrapper for `clar_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 { \
+	giterr_clear(); \
+	if ((expr) != 0) \
+		clar__assert(0, __FILE__, __LINE__, "Function call failed: " #expr, giterr_last() ? giterr_last()->message : NULL, 1); \
+	} while(0)
+
+/**
+ * Wrapper for `clar_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)
+
+/*
+ * Some utility macros for building long strings
+ */
+#define REP4(STR)	 STR STR STR STR
+#define REP15(STR)	 REP4(STR) REP4(STR) REP4(STR) STR STR STR
+#define REP16(STR)	 REP4(REP4(STR))
+#define REP256(STR)  REP16(REP16(STR))
+#define REP1024(STR) REP4(REP256(STR))
+
+/* Write the contents of a buffer to disk */
+void cl_git_mkfile(const char *filename, const char *content);
+void cl_git_append2file(const char *filename, const char *new_content);
+void cl_git_rewritefile(const char *filename, const char *new_content);
+void cl_git_write2file(const char *filename, const char *new_content, int mode);
+
+bool cl_toggle_filemode(const char *filename);
+bool cl_is_chmod_supported(void);
+
+/* Environment wrappers */
+char *cl_getenv(const char *name);
+int cl_setenv(const char *name, const char *value);
+
+/* Git sandbox setup helpers */
+
+git_repository *cl_git_sandbox_init(const char *sandbox);
+void cl_git_sandbox_cleanup(void);
+
+#endif

data/ext/rugged/vendor/libgit2-dist/tests-clar/commit/commit.c

@@ -0,0 +1,44 @@
+#include "clar_libgit2.h"
+
+static git_repository *_repo;
+
+void test_commit_commit__initialize(void)
+{
+	cl_fixture_sandbox("testrepo.git");
+	cl_git_pass(git_repository_open(&_repo, "testrepo.git"));
+}
+
+void test_commit_commit__cleanup(void)
+{
+	git_repository_free(_repo);
+	cl_fixture_cleanup("testrepo.git");
+}
+
+void test_commit_commit__create_unexisting_update_ref(void)
+{
+	git_oid oid;
+	git_tree *tree;
+	git_commit *commit;
+	git_signature *s;
+	git_reference *ref;
+
+	git_oid_fromstr(&oid, "a65fedf39aefe402d3bb6e24df4d4f5fe4547750");
+	cl_git_pass(git_commit_lookup(&commit, _repo, &oid));
+
+	git_oid_fromstr(&oid, "944c0f6e4dfa41595e6eb3ceecdb14f50fe18162");
+	cl_git_pass(git_tree_lookup(&tree, _repo, &oid));
+
+	cl_git_pass(git_signature_now(&s, "alice", "alice@example.com"));
+
+	cl_git_fail(git_reference_lookup(&ref, _repo, "refs/heads/foo/bar"));
+	cl_git_pass(git_commit_create(&oid, _repo, "refs/heads/foo/bar", s, s,
+				      NULL, "some msg", tree, 1, (const git_commit **) &commit));
+
+	cl_git_pass(git_reference_lookup(&ref, _repo, "refs/heads/foo/bar"));
+	cl_assert(!git_oid_cmp(&oid, git_reference_oid(ref)));
+
+	git_tree_free(tree);
+	git_commit_free(commit);
+	git_signature_free(s);
+	git_reference_free(ref);
+}