rugged 0.1.2 → 0.16.0b1

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

@@ -0,0 +1,18 @@
+/*
+ * 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_sha1_lookup_h__
+#define INCLUDE_sha1_lookup_h__
+
+#include <stdlib.h>
+
+int sha1_entry_pos(const void *table,
+			size_t elem_size,
+			size_t key_offset,
+			unsigned lo, unsigned hi, unsigned nr,
+			const unsigned char *key);
+
+#endif

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

@@ -0,0 +1,335 @@
+/*
+ * 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 "signature.h"
+#include "repository.h"
+#include "git2/common.h"
+
+void git_signature_free(git_signature *sig)
+{
+	if (sig == NULL)
+		return;
+
+	git__free(sig->name);
+	git__free(sig->email);
+	git__free(sig);
+}
+
+static const char *skip_leading_spaces(const char *buffer, const char *buffer_end)
+{
+	while (*buffer == ' ' && buffer < buffer_end)
+		buffer++;
+
+	return buffer;
+}
+
+static const char *skip_trailing_spaces(const char *buffer_start, const char *buffer_end)
+{
+	while (*buffer_end == ' ' && buffer_end > buffer_start)
+		buffer_end--;
+
+	return buffer_end;
+}
+
+static int process_trimming(const char *input, char **storage, const char *input_end, int fail_when_empty)
+{
+	const char *left, *right;
+	int trimmed_input_length;
+
+	left = skip_leading_spaces(input, input_end);
+	right = skip_trailing_spaces(input, input_end - 1);
+
+	if (right < left) {
+		if (fail_when_empty)
+			return git__throw(GIT_EINVALIDARGS, "Failed to trim. Input is either empty or only contains spaces");
+		else
+			right = left - 1;
+	}
+
+	trimmed_input_length = right - left + 1;
+
+	*storage = git__malloc(trimmed_input_length + 1);
+	if (*storage == NULL)
+		return GIT_ENOMEM;
+
+	memcpy(*storage, left, trimmed_input_length);
+	(*storage)[trimmed_input_length] = 0;
+
+	return GIT_SUCCESS;
+}
+
+int git_signature_new(git_signature **sig_out, const char *name, const char *email, git_time_t time, int offset)
+{
+	int error;
+	git_signature *p = NULL;
+
+	assert(name && email);
+
+	*sig_out = NULL;
+
+	if ((p = git__malloc(sizeof(git_signature))) == NULL) {
+		error = GIT_ENOMEM;
+		goto cleanup;
+	}
+
+	memset(p, 0x0, sizeof(git_signature));
+
+	error = process_trimming(name, &p->name, name + strlen(name), 1);
+	if (error < GIT_SUCCESS) {
+		git__rethrow(GIT_EINVALIDARGS, "Failed to create signature. 'name' argument is invalid");
+		goto cleanup;
+	}
+
+	error = process_trimming(email, &p->email, email + strlen(email), 1);
+	if (error < GIT_SUCCESS) {
+		git__rethrow(GIT_EINVALIDARGS, "Failed to create signature. 'email' argument is invalid");
+		goto cleanup;
+	}
+
+	p->when.time = time;
+	p->when.offset = offset;
+
+	*sig_out = p;
+
+	return error;
+
+cleanup:
+	git_signature_free(p);
+	return error;
+}
+
+git_signature *git_signature_dup(const git_signature *sig)
+{
+	git_signature *new;
+	if (git_signature_new(&new, sig->name, sig->email, sig->when.time, sig->when.offset) < GIT_SUCCESS)
+		return NULL;
+	return new;
+}
+
+int git_signature_now(git_signature **sig_out, const char *name, const char *email)
+{
+	int error;
+	time_t now;
+	time_t offset;
+	struct tm *utc_tm, *local_tm;
+	git_signature *sig;
+
+#ifndef GIT_WIN32
+	struct tm _utc, _local;
+#endif
+
+	*sig_out = NULL;
+
+	time(&now);
+
+	/**
+	 * On Win32, `gmtime_r` doesn't exist but
+	 * `gmtime` is threadsafe, so we can use that
+	 */
+#ifdef GIT_WIN32
+	utc_tm = gmtime(&now);
+	local_tm = localtime(&now);
+#else
+	utc_tm = gmtime_r(&now, &_utc);
+	local_tm = localtime_r(&now, &_local);
+#endif
+
+	offset = mktime(local_tm) - mktime(utc_tm);
+	offset /= 60;
+
+	/* mktime takes care of setting tm_isdst correctly */
+	if (local_tm->tm_isdst)
+		offset += 60;
+
+	if ((error = git_signature_new(&sig, name, email, now, (int)offset)) < GIT_SUCCESS)
+		return error;
+
+	*sig_out = sig;
+
+	return error;
+}
+
+static int parse_timezone_offset(const char *buffer, int *offset_out)
+{
+	int dec_offset;
+	int mins, hours, offset;
+
+	const char *offset_start;
+	const char *offset_end;
+
+	offset_start = buffer;
+
+	if (*offset_start == '\n') {
+		*offset_out = 0;
+		return GIT_SUCCESS;
+	}
+
+	if (offset_start[0] != '-' && offset_start[0] != '+')
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. It doesn't start with '+' or '-'");
+
+	if (offset_start[1] < '0' || offset_start[1] > '9')
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset.");
+
+	if (git__strtol32(&dec_offset, offset_start + 1, &offset_end, 10) < GIT_SUCCESS)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. It isn't a number");
+
+	if (offset_end - offset_start != 5)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. Invalid length");
+
+	if (dec_offset > 1400)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. Value too large");
+
+	hours = dec_offset / 100;
+	mins = dec_offset % 100;
+
+	if (hours > 14)	// see http://www.worldtimezone.com/faq.html
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. Hour value too large");
+
+	if (mins > 59)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse TZ offset. Minute value too large");
+
+	offset = (hours * 60) + mins;
+
+	if (offset_start[0] == '-')
+		offset *= -1;
+
+	*offset_out = offset;
+
+	return GIT_SUCCESS;
+}
+
+static int process_next_token(const char **buffer_out, char **storage,
+	const char *token_end, const char *right_boundary)
+{
+	int error = process_trimming(*buffer_out, storage, token_end, 0);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	*buffer_out = token_end + 1;
+
+	if (*buffer_out > right_boundary)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Signature too short");
+
+	return GIT_SUCCESS;
+}
+
+static const char *scan_for_previous_token(const char *buffer, const char *left_boundary)
+{
+	const char *start;
+
+	if (buffer <= left_boundary)
+		return NULL;
+
+	start = skip_trailing_spaces(left_boundary, buffer);
+
+	/* Search for previous occurence of space */
+	while (start[-1] != ' ' && start > left_boundary)
+		start--;
+
+	return start;
+}
+
+static int parse_time(git_time_t *time_out, const char *buffer)
+{
+	int time;
+	int error;
+
+	if (*buffer == '+' || *buffer == '-')
+		return git__throw(GIT_ERROR, "Failed while parsing time. '%s' rather look like a timezone offset.", buffer);
+
+	error = git__strtol32(&time, buffer, &buffer, 10);
+
+	if (error < GIT_SUCCESS)
+		return error;
+
+	*time_out = (git_time_t)time;
+
+	return GIT_SUCCESS;
+}
+
+int git_signature__parse(git_signature *sig, const char **buffer_out,
+		const char *buffer_end, const char *header, char ender)
+{
+	const char *buffer = *buffer_out;
+	const char *line_end, *name_end, *email_end, *tz_start, *time_start;
+	int error = GIT_SUCCESS;
+
+	memset(sig, 0x0, sizeof(git_signature));
+
+	if ((line_end = memchr(buffer, ender, buffer_end - buffer)) == NULL)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. No newline given");
+
+	if (header) {
+		const size_t header_len = strlen(header);
+
+		if (memcmp(buffer, header, header_len) != 0)
+			return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Expected prefix '%s' doesn't match actual", header);
+
+		buffer += header_len;
+	}
+
+	if (buffer > line_end)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Signature too short");
+
+	if ((name_end = strchr(buffer, '<')) == NULL)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Cannot find '<' in signature");
+
+	if ((email_end = strchr(name_end, '>')) == NULL)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Cannot find '>' in signature");
+
+	if (email_end < name_end)
+		return git__throw(GIT_EOBJCORRUPTED, "Failed to parse signature. Malformed e-mail");
+
+	error = process_next_token(&buffer, &sig->name, name_end, line_end);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	error = process_next_token(&buffer, &sig->email, email_end, line_end);
+	if (error < GIT_SUCCESS)
+		return error;
+
+	tz_start = scan_for_previous_token(line_end - 1, buffer);
+
+	if (tz_start == NULL)
+		goto clean_exit;	/* No timezone nor date */
+
+	time_start = scan_for_previous_token(tz_start - 1, buffer);
+	if (time_start == NULL || parse_time(&sig->when.time, time_start) < GIT_SUCCESS) {
+		/* The tz_start might point at the time */
+		parse_time(&sig->when.time, tz_start);
+		goto clean_exit;
+	}
+
+	if (parse_timezone_offset(tz_start, &sig->when.offset) < GIT_SUCCESS) {
+		sig->when.time = 0; /* Bogus timezone, we reset the time */
+	}
+
+clean_exit:
+	*buffer_out = line_end + 1;
+	return GIT_SUCCESS;
+}
+
+void git_signature__writebuf(git_buf *buf, const char *header, const git_signature *sig)
+{
+	int offset, hours, mins;
+	char sign;
+
+	offset = sig->when.offset;
+	sign = (sig->when.offset < 0) ? '-' : '+';
+
+	if (offset < 0)
+		offset = -offset;
+
+	hours = offset / 60;
+	mins = offset % 60;
+
+	git_buf_printf(buf, "%s%s <%s> %u %c%02d%02d\n",
+			header ? header : "", sig->name, sig->email,
+			(unsigned)sig->when.time, sign, hours, mins);
+}
+

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

@@ -0,0 +1,18 @@
+/*
+ * 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_signature_h__
+#define INCLUDE_signature_h__
+
+#include "git2/common.h"
+#include "git2/signature.h"
+#include "repository.h"
+#include <time.h>
+
+int git_signature__parse(git_signature *sig, const char **buffer_out, const char *buffer_end, const char *header, char ender);
+void git_signature__writebuf(git_buf *buf, const char *header, const git_signature *sig);
+
+#endif

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

@@ -0,0 +1,696 @@
+/*
+ * 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 "git2.h"
+#include "fileops.h"
+#include "hash.h"
+#include "vector.h"
+#include "tree.h"
+#include "git2/status.h"
+#include "repository.h"
+
+struct status_entry {
+	git_index_time mtime;
+
+	git_oid head_oid;
+	git_oid index_oid;
+	git_oid wt_oid;
+
+	unsigned int status_flags:6;
+
+	char path[GIT_FLEX_ARRAY]; /* more */
+};
+
+static struct status_entry *status_entry_new(git_vector *entries, const char *path)
+{
+	struct status_entry *e = git__malloc(sizeof(*e) + strlen(path) + 1);
+	if (e == NULL)
+		return NULL;
+
+	memset(e, 0x0, sizeof(*e));
+
+	if (entries != NULL)
+		git_vector_insert(entries, e);
+
+	strcpy(e->path, path);
+
+	return e;
+}
+
+GIT_INLINE(void) status_entry_update_from_tree_entry(struct status_entry *e, const git_tree_entry *tree_entry)
+{
+	assert(e && tree_entry);
+
+	git_oid_cpy(&e->head_oid, &tree_entry->oid);
+}
+
+GIT_INLINE(void) status_entry_update_from_index_entry(struct status_entry *e, const git_index_entry *index_entry)
+{
+	assert(e && index_entry);
+
+	git_oid_cpy(&e->index_oid, &index_entry->oid);
+	e->mtime = index_entry->mtime;
+}
+
+static void status_entry_update_from_index(struct status_entry *e, git_index *index)
+{
+	int idx;
+	git_index_entry *index_entry;
+
+	assert(e && index);
+
+	idx = git_index_find(index, e->path);
+	if (idx < 0)
+		return;
+
+	index_entry = git_index_get(index, idx);
+
+	status_entry_update_from_index_entry(e, index_entry);
+}
+
+static int status_entry_update_from_workdir(struct status_entry *e, char* full_path)
+{
+	struct stat filest;
+
+	if (p_stat(full_path, &filest) < GIT_SUCCESS)
+		return git__throw(GIT_EOSERR, "Failed to determine status of file '%s'. Can't read file", full_path);
+
+	if (e->mtime.seconds == (git_time_t)filest.st_mtime)
+		git_oid_cpy(&e->wt_oid, &e->index_oid);
+	else
+		git_odb_hashfile(&e->wt_oid, full_path, GIT_OBJ_BLOB);
+
+	return GIT_SUCCESS;
+}
+
+static int status_entry_update_flags(struct status_entry *e)
+{
+	git_oid zero;
+	int head_zero, index_zero, wt_zero;
+
+	memset(&zero, 0x0, sizeof(git_oid));
+
+	head_zero = git_oid_cmp(&zero, &e->head_oid);
+	index_zero = git_oid_cmp(&zero, &e->index_oid);
+	wt_zero = git_oid_cmp(&zero, &e->wt_oid);
+
+	if (head_zero == 0 && index_zero == 0 && wt_zero == 0)
+		return GIT_ENOTFOUND;
+
+	if (head_zero == 0 && index_zero != 0)
+		e->status_flags |= GIT_STATUS_INDEX_NEW;
+	else if (index_zero == 0 && head_zero != 0)
+		e->status_flags |= GIT_STATUS_INDEX_DELETED;
+	else if (git_oid_cmp(&e->head_oid, &e->index_oid) != 0)
+		e->status_flags |= GIT_STATUS_INDEX_MODIFIED;
+
+	if (index_zero == 0 && wt_zero != 0)
+		e->status_flags |= GIT_STATUS_WT_NEW;
+	else if (wt_zero == 0 && index_zero != 0)
+		e->status_flags |= GIT_STATUS_WT_DELETED;
+	else if (git_oid_cmp(&e->index_oid, &e->wt_oid) != 0)
+		e->status_flags |= GIT_STATUS_WT_MODIFIED;
+
+	return GIT_SUCCESS;
+}
+
+struct status_st {
+	git_vector *vector;
+	git_index *index;
+	git_tree *tree;
+
+	int workdir_path_len;
+	char* head_tree_relative_path;
+	int head_tree_relative_path_len;
+	unsigned int tree_position;
+	unsigned int index_position;
+	int is_dir:1;
+};
+
+static int retrieve_head_tree(git_tree **tree_out, git_repository *repo)
+{
+	git_reference *resolved_head_ref;
+	git_commit *head_commit = NULL;
+	git_tree *tree;
+	int error = GIT_SUCCESS;
+
+	*tree_out = NULL;
+
+	error = git_repository_head(&resolved_head_ref, repo);
+	/*
+	 * We assume that a situation where HEAD exists but can not be resolved is valid.
+	 * A new repository fits this description for instance.
+	 */
+	if (error == GIT_ENOTFOUND)
+		return GIT_SUCCESS;
+	if (error < GIT_SUCCESS)
+		return git__rethrow(error, "HEAD can't be resolved");
+
+	if ((error = git_commit_lookup(&head_commit, repo, git_reference_oid(resolved_head_ref))) < GIT_SUCCESS)
+		return git__rethrow(error, "The tip of HEAD can't be retrieved");
+
+	if ((error = git_commit_tree(&tree, head_commit)) < GIT_SUCCESS) {
+		error = git__rethrow(error, "The tree of HEAD can't be retrieved");
+		goto exit;
+	}
+
+	*tree_out = tree;
+
+exit:
+	git_commit_free(head_commit);
+	return error;
+}
+
+enum path_type {
+	GIT_STATUS_PATH_NULL,
+	GIT_STATUS_PATH_IGNORE,
+	GIT_STATUS_PATH_FILE,
+	GIT_STATUS_PATH_FOLDER,
+};
+
+static int dirent_cb(void *state, char *full_path);
+static int alphasorted_futils_direach(
+	char *path, size_t path_sz,
+	int (*fn)(void *, char *), void *arg);
+
+static int process_folder(struct status_st *st, const git_tree_entry *tree_entry, char *full_path, enum path_type path_type)
+{
+	git_object *subtree = NULL;
+	git_tree *pushed_tree = NULL;
+	int error, pushed_tree_position = 0;
+	git_otype tree_entry_type = GIT_OBJ_BAD;
+
+	if (tree_entry != NULL) {
+		tree_entry_type = git_tree_entry_type(tree_entry);
+
+		switch (tree_entry_type) {
+		case GIT_OBJ_TREE:
+			error = git_tree_entry_2object(&subtree, ((git_object *)(st->tree))->repo, tree_entry);
+			pushed_tree = st->tree;
+			pushed_tree_position = st->tree_position;
+			st->tree = (git_tree *)subtree;
+			st->tree_position = 0;
+			st->head_tree_relative_path_len += 1 + tree_entry->filename_len; /* path + '/' + name */
+			break;
+
+		case GIT_OBJ_BLOB:
+			/* No op */
+			break;
+
+		default:
+			error = git__throw(GIT_EINVALIDTYPE, "Unexpected tree entry type");	/* TODO: How should we deal with submodules? */
+		}
+	}
+
+	if (full_path != NULL && path_type == GIT_STATUS_PATH_FOLDER)
+		error = alphasorted_futils_direach(full_path, GIT_PATH_MAX, dirent_cb, st);
+	else {
+		error = dirent_cb(st, NULL);
+	}
+
+	if (tree_entry_type == GIT_OBJ_TREE) {
+		git_object_free(subtree);
+		st->head_tree_relative_path_len -= 1 + tree_entry->filename_len;
+		st->tree = pushed_tree;
+		st->tree_position = pushed_tree_position;
+		st->tree_position++;
+	}
+
+	return error;
+}
+
+static int store_if_changed(struct status_st *st, struct status_entry *e)
+{
+	int error;
+	if ((error = status_entry_update_flags(e)) < GIT_SUCCESS)
+			return git__throw(error, "Failed to process the file '%s'. It doesn't exist in the workdir, in the HEAD nor in the index", e->path);
+
+	if (e->status_flags == GIT_STATUS_CURRENT) {
+		git__free(e);
+		return GIT_SUCCESS;
+	}
+
+	return git_vector_insert(st->vector, e);
+}
+
+static int determine_status(struct status_st *st,
+	int in_head, int in_index, int in_workdir,
+	const git_tree_entry *tree_entry,
+	const git_index_entry *index_entry,
+	char *full_path,
+	const char *status_path,
+	enum path_type path_type)
+{
+	struct status_entry *e;
+	int error = GIT_SUCCESS;
+	git_otype tree_entry_type = GIT_OBJ_BAD;
+
+	if (tree_entry != NULL)
+		tree_entry_type = git_tree_entry_type(tree_entry);
+
+	/* If we're dealing with a directory in the workdir, let's recursively tackle it first */
+	if (path_type == GIT_STATUS_PATH_FOLDER)
+		return process_folder(st, tree_entry, full_path, path_type);
+
+	/* Are we dealing with a file somewhere? */
+	if (in_workdir || in_index || (in_head && tree_entry_type == GIT_OBJ_BLOB)) {
+		e = status_entry_new(NULL, status_path);
+
+		if (in_head && tree_entry_type == GIT_OBJ_BLOB) {
+			status_entry_update_from_tree_entry(e, tree_entry);
+			st->tree_position++;
+		}
+
+		if (in_index) {
+			status_entry_update_from_index_entry(e, index_entry);
+			st->index_position++;
+		}
+
+		if (in_workdir)
+			if ((error = status_entry_update_from_workdir(e, full_path)) < GIT_SUCCESS)
+				return error;	/* The callee has already set the error message */
+
+		return store_if_changed(st, e);
+	}
+
+	/* Last option, we're dealing with a leftover folder tree entry */
+	assert(in_head && !in_index && !in_workdir && (tree_entry_type == GIT_OBJ_TREE));
+	return process_folder(st, tree_entry, full_path, path_type);
+}
+
+static int path_type_from(char *full_path, int is_dir)
+{
+	if (full_path == NULL)
+		return GIT_STATUS_PATH_NULL;
+
+	if (!is_dir)
+		return GIT_STATUS_PATH_FILE;
+
+	if (!git__suffixcmp(full_path, "/" DOT_GIT "/"))
+		return GIT_STATUS_PATH_IGNORE;
+
+	return GIT_STATUS_PATH_FOLDER;
+}
+
+static const char *status_path(const char *first, const char *second, const char *third)
+{
+	/* At least one of them can not be NULL */
+	assert(first != NULL || second != NULL || third != NULL);
+
+	/* TODO: Fixme. Ensure that when non null, they're all equal */
+	if (first != NULL)
+		return first;
+
+	if (second != NULL)
+		return second;
+
+	return third;
+}
+
+static int compare(const char *left, const char *right)
+{
+	if (left == NULL && right == NULL)
+		return 0;
+
+	if (left == NULL)
+		return 1;
+
+	if (right == NULL)
+		return -1;
+
+	return strcmp(left, right);
+}
+
+/* Greatly inspired from JGit IndexTreeWalker */
+/* https://github.com/spearce/jgit/blob/ed47e29c777accfa78c6f50685a5df2b8f5b8ff5/org.spearce.jgit/src/org/spearce/jgit/lib/IndexTreeWalker.java#L88 */
+
+static int dirent_cb(void *state, char *a)
+{
+	const git_tree_entry *m;
+	const git_index_entry *entry;
+	enum path_type path_type;
+	int cmpma, cmpmi, cmpai, error;
+	const char *pm, *pa, *pi;
+	const char *m_name, *i_name, *a_name;
+
+	struct status_st *st = (struct status_st *)state;
+
+	path_type = path_type_from(a, st->is_dir);
+
+	if (path_type == GIT_STATUS_PATH_IGNORE)
+		return GIT_SUCCESS;	/* Let's skip the ".git" directory */
+
+	a_name = (path_type != GIT_STATUS_PATH_NULL) ? a + st->workdir_path_len : NULL;
+
+	while (1) {
+		if (st->tree == NULL)
+			m = NULL;
+		else
+			m = git_tree_entry_byindex(st->tree, st->tree_position);
+
+		entry = git_index_get(st->index, st->index_position);
+
+		if ((m == NULL) && (a == NULL) && (entry == NULL))
+			return GIT_SUCCESS;
+
+		if (m != NULL) {
+			st->head_tree_relative_path[st->head_tree_relative_path_len] = '\0';
+
+			/* When the tree entry is a folder, append a forward slash to its name */
+			if (git_tree_entry_type(m) == GIT_OBJ_TREE)
+				git_path_join_n(st->head_tree_relative_path, 3, st->head_tree_relative_path, m->filename, "");
+			else
+				git_path_join(st->head_tree_relative_path, st->head_tree_relative_path, m->filename);
+		
+			m_name = st->head_tree_relative_path;
+		} else
+			m_name = NULL;
+
+		i_name = (entry != NULL) ? entry->path : NULL;
+
+		cmpma = compare(m_name, a_name);
+		cmpmi = compare(m_name, i_name);
+		cmpai = compare(a_name, i_name);
+
+		pm = ((cmpma <= 0) && (cmpmi <= 0)) ? m_name : NULL;
+		pa = ((cmpma >= 0) && (cmpai <= 0)) ? a_name : NULL;
+		pi = ((cmpmi >= 0) && (cmpai >= 0)) ? i_name : NULL;
+
+		if((error = determine_status(st, pm != NULL, pi != NULL, pa != NULL, m, entry, a, status_path(pm, pi, pa), path_type)) < GIT_SUCCESS)
+			return git__rethrow(error, "An error occured while determining the status of '%s'", a);
+
+		if ((pa != NULL) || (path_type == GIT_STATUS_PATH_FOLDER))
+			return GIT_SUCCESS;
+	}
+}
+
+static int status_cmp(const void *a, const void *b)
+{
+	const struct status_entry *entry_a = (const struct status_entry *)(a);
+	const struct status_entry *entry_b = (const struct status_entry *)(b);
+
+	return strcmp(entry_a->path, entry_b->path);
+}
+
+#define DEFAULT_SIZE 16
+
+int git_status_foreach(git_repository *repo, int (*callback)(const char *, unsigned int, void *), void *payload)
+{
+	git_vector entries;
+	git_index *index = NULL;
+	char temp_path[GIT_PATH_MAX];
+	char tree_path[GIT_PATH_MAX] = "";
+	struct status_st dirent_st;
+	int error = GIT_SUCCESS;
+	unsigned int i;
+	git_tree *tree;
+	struct status_entry *e;
+	const char *workdir;
+
+	if ((workdir = git_repository_workdir(repo)) == NULL)
+		return git__throw(GIT_ERROR,
+			"Cannot retrieve status on a bare repository");
+
+	if ((error = git_repository_index__weakptr(&index, repo)) < GIT_SUCCESS) {
+		return git__rethrow(error,
+			"Failed to determine statuses. Index can't be opened");
+	}
+
+	if ((error = retrieve_head_tree(&tree, repo)) < GIT_SUCCESS) {
+		error = git__rethrow(error, "Failed to determine statuses");
+		goto exit;
+	}
+
+	git_vector_init(&entries, DEFAULT_SIZE, status_cmp);
+
+	dirent_st.workdir_path_len = strlen(workdir);
+	dirent_st.tree_position = 0;
+	dirent_st.index_position = 0;
+	dirent_st.tree = tree;
+	dirent_st.index = index;
+	dirent_st.vector = &entries;
+	dirent_st.head_tree_relative_path = tree_path;
+	dirent_st.head_tree_relative_path_len = 0;
+	dirent_st.is_dir = 1;
+
+	strcpy(temp_path, workdir);
+
+	if (git_futils_isdir(temp_path)) {
+		error = git__throw(GIT_EINVALIDPATH,
+			"Failed to determine status of file '%s'. "
+			"The given path doesn't lead to a folder", temp_path);
+		goto exit;
+	}
+
+	error = alphasorted_futils_direach(
+		temp_path, sizeof(temp_path),
+		dirent_cb, &dirent_st
+	);
+
+	if (error < GIT_SUCCESS)
+		error = git__rethrow(error,
+			"Failed to determine statuses. "
+			"An error occured while processing the working directory");
+
+	if ((error == GIT_SUCCESS) && ((error = dirent_cb(&dirent_st, NULL)) < GIT_SUCCESS))
+		error = git__rethrow(error,
+			"Failed to determine statuses. "
+			"An error occured while post-processing the HEAD tree and the index");
+
+	for (i = 0; i < entries.length; ++i) {
+		e = (struct status_entry *)git_vector_get(&entries, i);
+
+		if (error == GIT_SUCCESS) {
+			error = callback(e->path, e->status_flags, payload);
+			if (error < GIT_SUCCESS)
+				error = git__rethrow(error,
+					"Failed to determine statuses. User callback failed");
+		}
+
+		git__free(e);
+	}
+
+exit:
+	git_vector_free(&entries);
+	git_tree_free(tree);
+	return error;
+}
+
+static int recurse_tree_entry(git_tree *tree, struct status_entry *e, const char *path)
+{
+	char *dir_sep;
+	const git_tree_entry *tree_entry;
+	git_tree *subtree;
+	int error = GIT_SUCCESS;
+
+	dir_sep = strchr(path, '/');
+	if (!dir_sep) {
+		tree_entry = git_tree_entry_byname(tree, path);
+		if (tree_entry == NULL)
+			return GIT_SUCCESS;	/* The leaf doesn't exist in the tree*/
+
+		status_entry_update_from_tree_entry(e, tree_entry);
+		return GIT_SUCCESS;
+	}
+
+	/* Retrieve subtree name */
+	*dir_sep = '\0';
+
+	tree_entry = git_tree_entry_byname(tree, path);
+	if (tree_entry == NULL)
+		return GIT_SUCCESS;	/* The subtree doesn't exist in the tree*/
+
+	*dir_sep = '/';
+
+	/* Retreive subtree */
+	if ((error = git_tree_lookup(&subtree, tree->object.repo, &tree_entry->oid)) < GIT_SUCCESS)
+		return git__throw(GIT_EOBJCORRUPTED, "Can't find tree object '%s'", tree_entry->filename);
+
+	error = recurse_tree_entry(subtree, e, dir_sep+1);
+	git_tree_free(subtree);
+	return error;
+}
+
+int git_status_file(unsigned int *status_flags, git_repository *repo, const char *path)
+{
+	struct status_entry *e;
+	git_index *index = NULL;
+	char temp_path[GIT_PATH_MAX];
+	int error = GIT_SUCCESS;
+	git_tree *tree = NULL;
+	const char *workdir;
+
+	assert(status_flags && repo && path);
+
+	if ((workdir = git_repository_workdir(repo)) == NULL)
+		return git__throw(GIT_ERROR,
+			"Cannot retrieve status on a bare repository");
+
+	git_path_join(temp_path, workdir, path);
+	if (git_futils_isdir(temp_path) == GIT_SUCCESS)
+		return git__throw(GIT_EINVALIDPATH,
+			"Failed to determine status of file '%s'. "
+			"Given path leads to a folder, not a file", path);
+
+	e = status_entry_new(NULL, path);
+	if (e == NULL)
+		return GIT_ENOMEM;
+
+	/* Find file in Workdir */
+	if (git_futils_exists(temp_path) == GIT_SUCCESS) {
+		if ((error = status_entry_update_from_workdir(e, temp_path)) < GIT_SUCCESS)
+			goto exit;	/* The callee has already set the error message */
+	}
+
+	/* Find file in Index */
+	if ((error = git_repository_index__weakptr(&index, repo)) < GIT_SUCCESS) {
+		error = git__rethrow(error,
+			"Failed to determine status of file '%s'."
+			"Index can't be opened", path);
+		goto exit;
+	}
+
+	status_entry_update_from_index(e, index);
+
+	if ((error = retrieve_head_tree(&tree, repo)) < GIT_SUCCESS) {
+		error = git__rethrow(error,
+			"Failed to determine status of file '%s'", path);
+		goto exit;
+	}
+
+	/* If the repository is not empty, try and locate the file in HEAD */
+	if (tree != NULL) {
+		strcpy(temp_path, path);
+
+		error = recurse_tree_entry(tree, e, temp_path);
+		if (error < GIT_SUCCESS) {
+			error = git__rethrow(error,
+				"Failed to determine status of file '%s'. "
+				"An error occured while processing the tree", path);
+			goto exit;
+		}
+	}
+
+	/* Determine status */
+	if ((error = status_entry_update_flags(e)) < GIT_SUCCESS) {
+		error = git__throw(error, "Nonexistent file");
+		goto exit;
+	}
+
+	*status_flags = e->status_flags;
+
+exit:
+	git_tree_free(tree);
+	git__free(e);
+	return error;
+}
+
+/*
+ * git_futils_direach is not supposed to return entries in an ordered manner.
+ * alphasorted_futils_direach wraps git_futils_direach and invokes the callback
+ * function by passing it alphabeticcally sorted paths parameters.
+ *
+ */
+
+struct alphasorted_dirent_info {
+	int is_dir;
+
+	char path[GIT_FLEX_ARRAY]; /* more */
+};
+
+static struct alphasorted_dirent_info *alphasorted_dirent_info_new(const char *path)
+{
+	int is_dir, size;
+	struct alphasorted_dirent_info *di;
+
+	is_dir = git_futils_isdir(path) == GIT_SUCCESS ? 1 : 0;
+	size = sizeof(*di) + (is_dir ? GIT_PATH_MAX : strlen(path)) + 2;
+
+	di = git__malloc(size);
+	if (di == NULL)
+		return NULL;
+
+	memset(di, 0x0, size);
+
+	strcpy(di->path, path);
+
+	if (is_dir) {
+		di->is_dir = 1;
+
+		/* 
+		 * Append a forward slash to the name to force folders 
+		 * to be ordered in a similar way than in a tree
+		 *
+		 * The file "subdir" should appear before the file "subdir.txt"
+		 * The folder "subdir" should appear after the file "subdir.txt"
+		 */
+		di->path[strlen(path)] = '/';
+	}
+
+	return di;
+}
+
+static int alphasorted_dirent_info_cmp(const void *a, const void *b)
+{
+	struct alphasorted_dirent_info *stra = (struct alphasorted_dirent_info *)a;
+	struct alphasorted_dirent_info *strb = (struct alphasorted_dirent_info *)b;
+
+	return strcmp(stra->path, strb->path);
+}
+
+static int alphasorted_dirent_cb(void *state, char *full_path)
+{
+	struct alphasorted_dirent_info *entry;
+	git_vector *entry_names;
+
+	entry_names = (git_vector *)state;
+	entry = alphasorted_dirent_info_new(full_path);
+
+	if (entry == NULL)
+		return GIT_ENOMEM;
+
+	if (git_vector_insert(entry_names, entry) < GIT_SUCCESS) {
+		git__free(entry);
+		return GIT_ENOMEM;
+	}
+
+	return GIT_SUCCESS;
+}
+
+static int alphasorted_futils_direach(
+	char *path,
+	size_t path_sz,
+	int (*fn)(void *, char *),
+	void *arg)
+{
+	struct alphasorted_dirent_info *entry;
+	git_vector entry_names;
+	unsigned int idx;
+	int error = GIT_SUCCESS;
+
+	if (git_vector_init(&entry_names, 16, alphasorted_dirent_info_cmp) < GIT_SUCCESS)
+		return GIT_ENOMEM;
+
+	error = git_futils_direach(path, path_sz, alphasorted_dirent_cb, &entry_names);
+
+	git_vector_sort(&entry_names);
+
+	for (idx = 0; idx < entry_names.length; ++idx) {
+		entry = (struct alphasorted_dirent_info *)git_vector_get(&entry_names, idx);
+
+		if (error == GIT_SUCCESS) {
+			((struct status_st *)arg)->is_dir = entry->is_dir;
+			error = fn(arg, entry->path);
+		}
+
+		git__free(entry);
+	}
+
+	git_vector_free(&entry_names);
+	return error;
+}