rugged 0.1.2 → 0.16.0b1

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

@@ -0,0 +1,99 @@
+/*
+ * 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_pack_h__
+#define INCLUDE_pack_h__
+
+#include "git2/oid.h"
+
+#include "common.h"
+#include "map.h"
+#include "mwindow.h"
+#include "odb.h"
+
+#define GIT_PACK_FILE_MODE 0444
+
+#define PACK_SIGNATURE 0x5041434b	/* "PACK" */
+#define PACK_VERSION 2
+#define pack_version_ok(v) ((v) == htonl(2) || (v) == htonl(3))
+struct git_pack_header {
+	uint32_t hdr_signature;
+	uint32_t hdr_version;
+	uint32_t hdr_entries;
+};
+
+/*
+ * The first four bytes of index formats later than version 1 should
+ * start with this signature, as all older git binaries would find this
+ * value illegal and abort reading the file.
+ *
+ * This is the case because the number of objects in a packfile
+ * cannot exceed 1,431,660,000 as every object would need at least
+ * 3 bytes of data and the overall packfile cannot exceed 4 GiB with
+ * version 1 of the index file due to the offsets limited to 32 bits.
+ * Clearly the signature exceeds this maximum.
+ *
+ * Very old git binaries will also compare the first 4 bytes to the
+ * next 4 bytes in the index and abort with a "non-monotonic index"
+ * error if the second 4 byte word is smaller than the first 4
+ * byte word. This would be true in the proposed future index
+ * format as idx_signature would be greater than idx_version.
+ */
+
+#define PACK_IDX_SIGNATURE 0xff744f63	/* "\377tOc" */
+
+struct git_pack_idx_header {
+	uint32_t idx_signature;
+	uint32_t idx_version;
+};
+
+struct git_pack_file {
+	git_mwindow_file mwf;
+	git_map index_map;
+
+	uint32_t num_objects;
+	uint32_t num_bad_objects;
+	git_oid *bad_object_sha1; /* array of git_oid */
+
+	int index_version;
+	git_time_t mtime;
+	unsigned pack_local:1, pack_keep:1, has_cache:1;
+	git_oid sha1;
+	git_vector cache;
+
+	/* something like ".git/objects/pack/xxxxx.pack" */
+	char pack_name[GIT_FLEX_ARRAY]; /* more */
+};
+
+struct git_pack_entry {
+	off_t offset;
+	git_oid sha1;
+	struct git_pack_file *p;
+};
+
+int git_packfile_unpack_header(
+		size_t *size_p,
+		git_otype *type_p,
+		git_mwindow_file *mwf,
+		git_mwindow **w_curs,
+		off_t *curpos);
+
+int git_packfile_unpack(git_rawobj *obj, struct git_pack_file *p, off_t *obj_offset);
+
+off_t get_delta_base(struct git_pack_file *p, git_mwindow **w_curs,
+		off_t *curpos, git_otype type,
+		off_t delta_obj_offset);
+
+void packfile_free(struct git_pack_file *p);
+int git_packfile_check(struct git_pack_file **pack_out, const char *path);
+int git_pack_entry_find(
+		struct git_pack_entry *e,
+		struct git_pack_file *p,
+		const git_oid *short_oid,
+		unsigned int len);
+
+#endif

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

@@ -0,0 +1,270 @@
+/*
+ * 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 "path.h"
+#include "posix.h"
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <ctype.h>
+
+/*
+ * Based on the Android implementation, BSD licensed.
+ * Check http://android.git.kernel.org/
+ */
+int git_path_basename_r(char *buffer, size_t bufflen, const char *path)
+{
+	const char *endp, *startp;
+	int len, result;
+
+	/* Empty or NULL string gets treated as "." */
+	if (path == NULL || *path == '\0') {
+		startp = ".";
+		len		= 1;
+		goto Exit;
+	}
+
+	/* Strip trailing slashes */
+	endp = path + strlen(path) - 1;
+	while (endp > path && *endp == '/')
+		endp--;
+
+	/* All slashes becomes "/" */
+	if (endp == path && *endp == '/') {
+		startp = "/";
+		len	= 1;
+		goto Exit;
+	}
+
+	/* Find the start of the base */
+	startp = endp;
+	while (startp > path && *(startp - 1) != '/')
+		startp--;
+
+	len = endp - startp +1;
+
+Exit:
+	result = len;
+	if (buffer == NULL) {
+		return result;
+	}
+	if (len > (int)bufflen-1) {
+		len	= (int)bufflen-1;
+		result = GIT_ENOMEM;
+	}
+
+	if (len >= 0) {
+		memmove(buffer, startp, len);
+		buffer[len] = 0;
+	}
+	return result;
+}
+
+/*
+ * Based on the Android implementation, BSD licensed.
+ * Check http://android.git.kernel.org/
+ */
+int git_path_dirname_r(char *buffer, size_t bufflen, const char *path)
+{
+	const char *endp;
+	int result, len;
+
+	/* Empty or NULL string gets treated as "." */
+	if (path == NULL || *path == '\0') {
+		path = ".";
+		len = 1;
+		goto Exit;
+	}
+
+	/* Strip trailing slashes */
+	endp = path + strlen(path) - 1;
+	while (endp > path && *endp == '/')
+		endp--;
+
+	/* Find the start of the dir */
+	while (endp > path && *endp != '/')
+		endp--;
+
+	/* Either the dir is "/" or there are no slashes */
+	if (endp == path) {
+		path = (*endp == '/') ? "/" : ".";
+		len = 1;
+		goto Exit;
+	}
+
+	do {
+		endp--;
+	} while (endp > path && *endp == '/');
+
+	len = endp - path +1;
+
+#ifdef GIT_WIN32
+	/* Mimic unix behavior where '/.git' returns '/': 'C:/.git' will return
+		'C:/' here */
+
+	if (len == 2 && isalpha(path[0]) && path[1] == ':') {
+		len = 3;
+		goto Exit;
+	}
+#endif
+
+Exit:
+	result = len;
+	if (len+1 > GIT_PATH_MAX) {
+		return GIT_ENOMEM;
+	}
+	if (buffer == NULL)
+		return result;
+
+	if (len > (int)bufflen-1) {
+		len	= (int)bufflen-1;
+		result = GIT_ENOMEM;
+	}
+
+	if (len >= 0) {
+		memmove(buffer, path, len);
+		buffer[len] = 0;
+	}
+	return result;
+}
+
+
+char *git_path_dirname(const char *path)
+{
+	char *dname = NULL;
+	int len;
+
+	len = (path ? strlen(path) : 0) + 2;
+	dname = (char *)git__malloc(len);
+	if (dname == NULL)
+		return NULL;
+
+	if (git_path_dirname_r(dname, len, path) < GIT_SUCCESS) {
+		git__free(dname);
+		return NULL;
+	}
+
+	return dname;
+}
+
+char *git_path_basename(const char *path)
+{
+	char *bname = NULL;
+	int len;
+
+	len = (path ? strlen(path) : 0) + 2;
+	bname = (char *)git__malloc(len);
+	if (bname == NULL)
+		return NULL;
+
+	if (git_path_basename_r(bname, len, path) < GIT_SUCCESS) {
+		git__free(bname);
+		return NULL;
+	}
+
+	return bname;
+}
+
+
+const char *git_path_topdir(const char *path)
+{
+	size_t len;
+	int i;
+
+	assert(path);
+	len = strlen(path);
+
+	if (!len || path[len - 1] != '/')
+		return NULL;
+
+	for (i = len - 2; i >= 0; --i)
+		if (path[i] == '/')
+			break;
+
+	return &path[i + 1];
+}
+
+void git_path_join_n(char *buffer_out, int count, ...)
+{
+	va_list ap;
+	int i;
+	char *buffer_start = buffer_out;
+
+	va_start(ap, count);
+	for (i = 0; i < count; ++i) {
+		const char *path;
+		int len;
+
+		path = va_arg(ap, const char *);
+
+		assert((i == 0) || path != buffer_start);
+
+		if (i > 0 && *path == '/' && buffer_out > buffer_start && buffer_out[-1] == '/')
+			path++;
+
+		if (!*path)
+			continue;
+
+		len = strlen(path);
+		memmove(buffer_out, path, len);
+		buffer_out = buffer_out + len;
+
+		if (i < count - 1 && buffer_out[-1] != '/')
+			*buffer_out++ = '/';
+	}
+	va_end(ap);
+
+	*buffer_out = '\0';
+}
+
+int git_path_root(const char *path)
+{
+	int offset = 0;
+
+#ifdef GIT_WIN32
+	/* Does the root of the path look like a windows drive ? */
+	if (isalpha(path[0]) && (path[1] == ':'))
+		offset += 2;
+#endif
+
+	if (*(path + offset) == '/')
+		return offset;
+
+	return -1;	/* Not a real error. Rather a signal than the path is not rooted */
+}
+
+int git_path_prettify(char *path_out, const char *path, const char *base)
+{
+	char *result;
+
+	if (base == NULL || git_path_root(path) >= 0) {
+		result = p_realpath(path, path_out);
+	} else {
+		char aux_path[GIT_PATH_MAX];
+		git_path_join(aux_path, base, path);
+		result = p_realpath(aux_path, path_out);
+	}
+
+	return result ? GIT_SUCCESS : GIT_EOSERR;
+}
+
+int git_path_prettify_dir(char *path_out, const char *path, const char *base)
+{
+	size_t end;
+
+	if (git_path_prettify(path_out, path, base) < GIT_SUCCESS)
+		return GIT_EOSERR;
+
+	end = strlen(path_out);
+
+	if (end && path_out[end - 1] != '/') {
+		path_out[end] = '/';
+		path_out[end + 1] = '\0';
+	}
+
+	return GIT_SUCCESS;
+}

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

@@ -0,0 +1,84 @@
+/*
+ * 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_path_h__
+#define INCLUDE_path_h__
+
+#include "common.h"
+
+/*
+ * The dirname() function shall take a pointer to a character string
+ * that contains a pathname, and return a pointer to a string that is a
+ * pathname of the parent directory of that file. Trailing '/' characters
+ * in the path are not counted as part of the path.
+ *
+ * If path does not contain a '/', then dirname() shall return a pointer to
+ * the string ".". If path is a null pointer or points to an empty string,
+ * dirname() shall return a pointer to the string "." .
+ *
+ * The `git_path_dirname` implementation is thread safe. The returned
+ * string must be manually free'd.
+ *
+ * The `git_path_dirname_r` implementation expects a string allocated
+ * by the user with big enough size.
+ */
+extern char *git_path_dirname(const char *path);
+extern int git_path_dirname_r(char *buffer, size_t bufflen, const char *path);
+
+/*
+ * This function returns the basename of the file, which is the last
+ * part of its full name given by fname, with the drive letter and
+ * leading directories stripped off. For example, the basename of
+ * c:/foo/bar/file.ext is file.ext, and the basename of a:foo is foo.
+ *
+ * Trailing slashes and backslashes are significant: the basename of
+ * c:/foo/bar/ is an empty string after the rightmost slash.
+ *
+ * The `git_path_basename` implementation is thread safe. The returned
+ * string must be manually free'd.
+ *
+ * The `git_path_basename_r` implementation expects a string allocated
+ * by the user with big enough size.
+ */
+extern char *git_path_basename(const char *path);
+extern int git_path_basename_r(char *buffer, size_t bufflen, const char *path);
+
+extern const char *git_path_topdir(const char *path);
+
+/**
+ * Join two paths together. Takes care of properly fixing the
+ * middle slashes and everything
+ *
+ * The paths are joined together into buffer_out; this is expected
+ * to be an user allocated buffer of `GIT_PATH_MAX` size
+ */
+extern void git_path_join_n(char *buffer_out, int npath, ...);
+
+GIT_INLINE(void) git_path_join(char *buffer_out, const char *path_a, const char *path_b)
+{
+	git_path_join_n(buffer_out, 2, path_a, path_b);
+}
+
+int git_path_root(const char *path);
+
+int git_path_prettify(char *path_out, const char *path, const char *base);
+int git_path_prettify_dir(char *path_out, const char *path, const char *base);
+
+#ifdef GIT_WIN32
+GIT_INLINE(void) git_path_mkposix(char *path)
+{
+	while (*path) {
+		if (*path == '\\')
+			*path = '/';
+
+		path++;
+	}
+}
+#else
+#	define git_path_mkposix(p) /* blank */
+#endif
+
+#endif