rugged 0.1.2 → 0.16.0b1

data/ext/rugged/vendor/libgit2-dist/src/vector.c

@@ -0,0 +1,174 @@
+/*
+ * 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 "repository.h"
+#include "vector.h"
+
+static const double resize_factor = 1.75;
+static const size_t minimum_size = 8;
+
+static int resize_vector(git_vector *v)
+{
+	v->_alloc_size = ((unsigned int)(v->_alloc_size * resize_factor)) + 1;
+	if (v->_alloc_size < minimum_size)
+		v->_alloc_size = minimum_size;
+
+	v->contents = git__realloc(v->contents, v->_alloc_size * sizeof(void *));
+	if (v->contents == NULL)
+		return GIT_ENOMEM;
+
+	return GIT_SUCCESS;
+}
+
+
+void git_vector_free(git_vector *v)
+{
+	assert(v);
+	git__free(v->contents);
+}
+
+int git_vector_init(git_vector *v, unsigned int initial_size, git_vector_cmp cmp)
+{
+	assert(v);
+
+	memset(v, 0x0, sizeof(git_vector));
+
+	if (initial_size == 0)
+		initial_size = minimum_size;
+
+	v->_alloc_size = initial_size;
+	v->_cmp = cmp;
+
+	v->length = 0;
+	v->sorted = 1;
+
+	v->contents = git__malloc(v->_alloc_size * sizeof(void *));
+	if (v->contents == NULL)
+		return GIT_ENOMEM;
+
+	return GIT_SUCCESS;
+}
+
+int git_vector_insert(git_vector *v, void *element)
+{
+	assert(v);
+
+	if (v->length >= v->_alloc_size) {
+		if (resize_vector(v) < 0)
+			return GIT_ENOMEM;
+	}
+
+	v->contents[v->length++] = element;
+	v->sorted = 0;
+
+	return GIT_SUCCESS;
+}
+
+void git_vector_sort(git_vector *v)
+{
+	assert(v);
+
+	if (v->sorted || v->_cmp == NULL)
+		return;
+
+	git__tsort(v->contents, v->length, v->_cmp);
+	v->sorted = 1;
+}
+
+int git_vector_bsearch2(git_vector *v, git_vector_cmp key_lookup, const void *key)
+{
+	void **find;
+
+	assert(v && key && key_lookup);
+
+	/* need comparison function to sort the vector */
+	if (v->_cmp == NULL)
+		return git__throw(GIT_ENOTFOUND, "Can't sort vector. No comparison function set");
+
+	git_vector_sort(v);
+
+	find = git__bsearch(key, v->contents, v->length, key_lookup);
+	if (find != NULL)
+		return (int)(find - v->contents);
+
+	return git__throw(GIT_ENOTFOUND, "Can't find element");
+}
+
+int git_vector_search2(git_vector *v, git_vector_cmp key_lookup, const void *key)
+{
+	unsigned int i;
+
+	assert(v && key && key_lookup);
+
+	for (i = 0; i < v->length; ++i) {
+		if (key_lookup(key, v->contents[i]) == 0)
+			return i;
+	}
+
+	return git__throw(GIT_ENOTFOUND, "Can't find element");
+}
+
+static int strict_comparison(const void *a, const void *b)
+{
+	return (a == b) ? 0 : -1;
+}
+
+int git_vector_search(git_vector *v, const void *entry)
+{
+	return git_vector_search2(v, v->_cmp ? v->_cmp : strict_comparison, entry);
+}
+
+int git_vector_bsearch(git_vector *v, const void *key)
+{
+	return git_vector_bsearch2(v, v->_cmp, key);
+}
+
+int git_vector_remove(git_vector *v, unsigned int idx)
+{
+	unsigned int i;
+
+	assert(v);
+
+	if (idx >= v->length || v->length == 0)
+		return git__throw(GIT_ENOTFOUND, "Can't remove element. Index out of bounds");
+
+	for (i = idx; i < v->length - 1; ++i)
+		v->contents[i] = v->contents[i + 1];
+
+	v->length--;
+	return GIT_SUCCESS;
+}
+
+void git_vector_uniq(git_vector *v)
+{
+	git_vector_cmp cmp;
+	unsigned int i, j;
+
+	if (v->length <= 1)
+		return;
+
+	git_vector_sort(v);
+	cmp = v->_cmp ? v->_cmp : strict_comparison;
+
+	for (i = 0, j = 1 ; j < v->length; ++j)
+		if (!cmp(v->contents[i], v->contents[j]))
+			v->contents[i] = v->contents[j];
+		else
+			v->contents[++i] = v->contents[j];
+
+	v->length -= j - i - 1;
+}
+
+void git_vector_clear(git_vector *v)
+{
+	assert(v);
+	v->length = 0;
+	v->sorted = 1;
+}
+
+

data/ext/rugged/vendor/libgit2-dist/src/vector.h

@@ -0,0 +1,45 @@
+/*
+ * 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 INCLUDE_vector_h__
+#define INCLUDE_vector_h__
+
+#include "git2/common.h"
+
+typedef int (*git_vector_cmp)(const void *, const void *);
+
+typedef struct git_vector {
+	unsigned int _alloc_size;
+	git_vector_cmp _cmp;
+	void **contents;
+	unsigned int length;
+	int sorted;
+} git_vector;
+
+int git_vector_init(git_vector *v, unsigned int initial_size, git_vector_cmp cmp);
+void git_vector_free(git_vector *v);
+void git_vector_clear(git_vector *v);
+
+int git_vector_search(git_vector *v, const void *entry);
+int git_vector_search2(git_vector *v, git_vector_cmp cmp, const void *key);
+
+int git_vector_bsearch(git_vector *v, const void *entry);
+int git_vector_bsearch2(git_vector *v, git_vector_cmp cmp, const void *key);
+
+void git_vector_sort(git_vector *v);
+
+GIT_INLINE(void *) git_vector_get(git_vector *v, unsigned int position)
+{
+	return (position < v->length) ? v->contents[position] : NULL;
+}
+
+#define git_vector_foreach(v, iter, elem)	\
+	for ((iter) = 0; (iter) < (v)->length && ((elem) = (v)->contents[(iter)], 1); (iter)++ )
+
+int git_vector_insert(git_vector *v, void *element);
+int git_vector_remove(git_vector *v, unsigned int idx);
+void git_vector_uniq(git_vector *v);
+#endif

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

@@ -0,0 +1,115 @@
+/*
+ * 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.
+ */
+#define GIT__WIN32_NO_WRAP_DIR
+#include "dir.h"
+#include "utf-conv.h"
+#include "git2/windows.h"
+
+static int init_filter(char *filter, size_t n, const char *dir)
+{
+	size_t len = strlen(dir);
+
+	if (len+3 >= n)
+		return 0;
+
+	strcpy(filter, dir);
+	if (len && dir[len-1] != '/')
+		strcat(filter, "/");
+	strcat(filter, "*");
+
+	return 1;
+}
+
+git__DIR *git__opendir(const char *dir)
+{
+	char filter[4096];
+	wchar_t* filter_w;
+	git__DIR *new;
+
+	if (!dir || !init_filter(filter, sizeof(filter), dir))
+		return NULL;
+
+	new = git__malloc(sizeof(*new));
+	if (!new)
+		return NULL;
+
+	new->dir = git__malloc(strlen(dir)+1);
+	if (!new->dir) {
+		git__free(new);
+		return NULL;
+	}
+	strcpy(new->dir, dir);
+
+	filter_w = gitwin_to_utf16(filter);
+	new->h = FindFirstFileW(filter_w, &new->f);
+	git__free(filter_w);
+
+	if (new->h == INVALID_HANDLE_VALUE) {
+		git__free(new->dir);
+		git__free(new);
+		return NULL;
+	}
+	new->first = 1;
+
+	return new;
+}
+
+struct git__dirent *git__readdir(git__DIR *d)
+{
+	if (!d || d->h == INVALID_HANDLE_VALUE)
+		return NULL;
+
+	if (d->first)
+		d->first = 0;
+	else {
+		if (!FindNextFileW(d->h, &d->f))
+			return NULL;
+	}
+
+	if (wcslen(d->f.cFileName) >= sizeof(d->entry.d_name))
+		return NULL;
+
+	d->entry.d_ino = 0;
+	WideCharToMultiByte(gitwin_get_codepage(), 0, d->f.cFileName, -1, d->entry.d_name, GIT_PATH_MAX, NULL, NULL);
+
+	return &d->entry;
+}
+
+void git__rewinddir(git__DIR *d)
+{
+	char filter[4096];
+	wchar_t* filter_w;
+
+	if (d) {
+		if (d->h != INVALID_HANDLE_VALUE)
+			FindClose(d->h);
+		d->h = INVALID_HANDLE_VALUE;
+		d->first = 0;
+
+		if (init_filter(filter, sizeof(filter), d->dir)) {
+			filter_w = gitwin_to_utf16(filter);
+			d->h = FindFirstFileW(filter_w, &d->f);
+			git__free(filter_w);
+
+			if (d->h != INVALID_HANDLE_VALUE)
+				d->first = 1;
+		}
+	}
+}
+
+int git__closedir(git__DIR *d)
+{
+	if (d) {
+		if (d->h != INVALID_HANDLE_VALUE)
+			FindClose(d->h);
+		if (d->dir)
+			git__free(d->dir);
+		git__free(d);
+	}
+	return 0;
+}
+

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

@@ -0,0 +1,180 @@
+/*
+ * 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.
+ */
+
+/*
+ * Function fnmatch() as specified in POSIX 1003.2-1992, section B.6.
+ * Compares a filename or pathname to a pattern.
+ */
+
+#include <ctype.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "fnmatch.h"
+
+#define EOS		'\0'
+
+#define RANGE_MATCH		1
+#define RANGE_NOMATCH		0
+#define RANGE_ERROR		(-1)
+
+static int rangematch(const char *, char, int, char **);
+
+int
+p_fnmatch(const char *pattern, const char *string, int flags)
+{
+		const char *stringstart;
+		char *newp;
+		char c, test;
+
+		for (stringstart = string;;)
+				switch (c = *pattern++) {
+				case EOS:
+						if ((flags & FNM_LEADING_DIR) && *string == '/')
+								return (0);
+						return (*string == EOS ? 0 : FNM_NOMATCH);
+				case '?':
+						if (*string == EOS)
+								return (FNM_NOMATCH);
+						if (*string == '/' && (flags & FNM_PATHNAME))
+								return (FNM_NOMATCH);
+						if (*string == '.' && (flags & FNM_PERIOD) &&
+							(string == stringstart ||
+							((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+								return (FNM_NOMATCH);
+						++string;
+						break;
+				case '*':
+						c = *pattern;
+						/* Collapse multiple stars. */
+						while (c == '*')
+								c = *++pattern;
+
+						if (*string == '.' && (flags & FNM_PERIOD) &&
+							(string == stringstart ||
+							((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+								return (FNM_NOMATCH);
+
+						/* Optimize for pattern with * at end or before /. */
+						if (c == EOS) {
+								if (flags & FNM_PATHNAME)
+										return ((flags & FNM_LEADING_DIR) ||
+											strchr(string, '/') == NULL ?
+											0 : FNM_NOMATCH);
+								else
+										return (0);
+						} else if (c == '/' && (flags & FNM_PATHNAME)) {
+								if ((string = strchr(string, '/')) == NULL)
+										return (FNM_NOMATCH);
+								break;
+						}
+
+						/* General case, use recursion. */
+						while ((test = *string) != EOS) {
+								if (!p_fnmatch(pattern, string, flags & ~FNM_PERIOD))
+										return (0);
+								if (test == '/' && (flags & FNM_PATHNAME))
+										break;
+								++string;
+						}
+						return (FNM_NOMATCH);
+				case '[':
+						if (*string == EOS)
+								return (FNM_NOMATCH);
+						if (*string == '/' && (flags & FNM_PATHNAME))
+								return (FNM_NOMATCH);
+						if (*string == '.' && (flags & FNM_PERIOD) &&
+							(string == stringstart ||
+							((flags & FNM_PATHNAME) && *(string - 1) == '/')))
+								return (FNM_NOMATCH);
+
+						switch (rangematch(pattern, *string, flags, &newp)) {
+						case RANGE_ERROR:
+								/* not a good range, treat as normal text */
+								goto normal;
+						case RANGE_MATCH:
+								pattern = newp;
+								break;
+						case RANGE_NOMATCH:
+								return (FNM_NOMATCH);
+						}
+						++string;
+						break;
+				case '\\':
+						if (!(flags & FNM_NOESCAPE)) {
+								if ((c = *pattern++) == EOS) {
+										c = '\\';
+										--pattern;
+								}
+						}
+						/* FALLTHROUGH */
+				default:
+				normal:
+						if (c != *string && !((flags & FNM_CASEFOLD) &&
+									(tolower((unsigned char)c) ==
+									tolower((unsigned char)*string))))
+								return (FNM_NOMATCH);
+						++string;
+						break;
+				}
+		/* NOTREACHED */
+}
+
+static int
+rangematch(const char *pattern, char test, int flags, char **newp)
+{
+		int negate, ok;
+		char c, c2;
+
+		/*
+			* A bracket expression starting with an unquoted circumflex
+			* character produces unspecified results (IEEE 1003.2-1992,
+			* 3.13.2). This implementation treats it like '!', for
+			* consistency with the regular expression syntax.
+			* J.T. Conklin (conklin@ngai.kaleida.com)
+			*/
+		if ((negate = (*pattern == '!' || *pattern == '^')) != 0)
+				++pattern;
+
+		if (flags & FNM_CASEFOLD)
+				test = (char)tolower((unsigned char)test);
+
+		/*
+			* A right bracket shall lose its special meaning and represent
+			* itself in a bracket expression if it occurs first in the list.
+			* -- POSIX.2 2.8.3.2
+			*/
+		ok = 0;
+		c = *pattern++;
+		do {
+				if (c == '\\' && !(flags & FNM_NOESCAPE))
+						c = *pattern++;
+				if (c == EOS)
+						return (RANGE_ERROR);
+				if (c == '/' && (flags & FNM_PATHNAME))
+						return (RANGE_NOMATCH);
+				if ((flags & FNM_CASEFOLD))
+						c = (char)tolower((unsigned char)c);
+				if (*pattern == '-'
+					&& (c2 = *(pattern+1)) != EOS && c2 != ']') {
+						pattern += 2;
+						if (c2 == '\\' && !(flags & FNM_NOESCAPE))
+								c2 = *pattern++;
+						if (c2 == EOS)
+								return (RANGE_ERROR);
+						if (flags & FNM_CASEFOLD)
+								c2 = (char)tolower((unsigned char)c2);
+						if (c <= test && test <= c2)
+								ok = 1;
+				} else if (c == test)
+						ok = 1;
+		} while ((c = *pattern++) != ']');
+
+		*newp = (char *)pattern;
+		return (ok == negate ? RANGE_NOMATCH : RANGE_MATCH);
+}
+