rugged 0.17.0.b7 → 0.18.0.b1

data/vendor/libgit2/src/repository.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -19,8 +19,9 @@
 #include "buffer.h"
 #include "odb.h"
 #include "object.h"
-#include "attr.h"
+#include "attrcache.h"
 #include "strmap.h"
+#include "refdb.h"
 
 #define DOT_GIT ".git"
 #define GIT_DIR DOT_GIT "/"
@@ -79,11 +80,11 @@ enum {
 /** Internal structure for repository object */
 struct git_repository {
 	git_odb *_odb;
+	git_refdb *_refdb;
 	git_config *_config;
 	git_index *_index;
 
 	git_cache objects;
-	git_refcache references;
 	git_attr_cache attrcache;
 	git_strmap *submodules;
 
@@ -112,6 +113,7 @@ int git_repository_head_tree(git_tree **tree, git_repository *repo);
  */
 int git_repository_config__weakptr(git_config **out, git_repository *repo);
 int git_repository_odb__weakptr(git_odb **out, git_repository *repo);
+int git_repository_refdb__weakptr(git_refdb **out, git_repository *repo);
 int git_repository_index__weakptr(git_index **out, git_repository *repo);
 
 /*

data/vendor/libgit2/src/reset.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -8,134 +8,152 @@
 #include "common.h"
 #include "commit.h"
 #include "tag.h"
+#include "merge.h"
+#include "diff.h"
 #include "git2/reset.h"
 #include "git2/checkout.h"
+#include "git2/merge.h"
+#include "git2/refs.h"
 
 #define ERROR_MSG "Cannot perform reset"
 
-static int reset_error_invalid(const char *msg)
-{
-	giterr_set(GITERR_INVALID, "%s - %s", ERROR_MSG, msg);
-	return -1;
-}
-
-static int update_head(git_repository *repo, git_object *commit)
+int git_reset_default(
+	git_repository *repo,
+	git_object *target,
+	git_strarray* pathspecs)
 {
+	git_object *commit = NULL;
+	git_tree *tree = NULL;
+	git_diff_list *diff = NULL;
+	git_diff_options opts = GIT_DIFF_OPTIONS_INIT;
+	size_t i;
+	git_diff_delta *delta;
+	git_index_entry entry;
 	int error;
-	git_reference *head = NULL, *target = NULL;
+	git_index *index = NULL;
 
-	error = git_repository_head(&head, repo);
+	assert(pathspecs != NULL && pathspecs->count > 0); 
 
-	if (error < 0 && error != GIT_EORPHANEDHEAD)
-		return error;
+	memset(&entry, 0, sizeof(git_index_entry));
+
+	if ((error = git_repository_index(&index, repo)) < 0)
+		goto cleanup;
 
-	if (error == GIT_EORPHANEDHEAD) {
-		giterr_clear();
+	if (target) {
+		if (git_object_owner(target) != repo) {
+			giterr_set(GITERR_OBJECT,
+				"%s_default - The given target does not belong to this repository.", ERROR_MSG);
+			return -1;
+		}
 
-		/*
-		 * TODO: This is a bit weak as this doesn't support chained
-		 * symbolic references. yet.
-		 */
-		if ((error = git_reference_lookup(&head, repo, GIT_HEAD_FILE)) < 0)
+		if ((error = git_object_peel(&commit, target, GIT_OBJ_COMMIT)) < 0 ||
+			(error = git_commit_tree(&tree, (git_commit *)commit)) < 0)
 			goto cleanup;
+	}
 
-		if ((error = git_reference_create_oid(
-			&target,
-			repo,
-			git_reference_target(head),
-			git_object_id(commit), 0)) < 0)
-				goto cleanup;
-	} else {
-		if ((error = git_reference_set_oid(head, git_object_id(commit))) < 0)
+	opts.pathspec = *pathspecs;
+	opts.flags = GIT_DIFF_REVERSE;
+
+	if ((error = git_diff_tree_to_index(
+		&diff, repo, tree, index, &opts)) < 0)
 			goto cleanup;
+
+	git_vector_foreach(&diff->deltas, i, delta) {
+		if ((error = git_index_conflict_remove(index, delta->old_file.path)) < 0)
+			goto cleanup;
+
+		assert(delta->status == GIT_DELTA_ADDED ||
+			delta->status == GIT_DELTA_MODIFIED ||
+			delta->status == GIT_DELTA_DELETED);
+
+		if (delta->status == GIT_DELTA_DELETED) {
+			if ((error = git_index_remove(index, delta->old_file.path, 0)) < 0)
+				goto cleanup;
+		} else {
+			entry.mode = delta->new_file.mode;
+			git_oid_cpy(&entry.oid, &delta->new_file.oid);
+			entry.path = (char *)delta->new_file.path;
+
+			if ((error = git_index_add(index, &entry)) < 0)
+				goto cleanup;
+		}
 	}
 
-	error = 0;
+	error = git_index_write(index);
 
 cleanup:
-	git_reference_free(head);
-	git_reference_free(target);
+	git_object_free(commit);
+	git_tree_free(tree);
+	git_index_free(index);
+	git_diff_list_free(diff);
+
 	return error;
 }
 
 int git_reset(
 	git_repository *repo,
 	git_object *target,
-	git_reset_type reset_type)
+	git_reset_t reset_type)
 {
 	git_object *commit = NULL;
 	git_index *index = NULL;
 	git_tree *tree = NULL;
-	int error = -1;
-	git_checkout_opts opts;
+	int error = 0;
+	git_checkout_opts opts = GIT_CHECKOUT_OPTS_INIT;
 
 	assert(repo && target);
-	assert(reset_type == GIT_RESET_SOFT
-		|| reset_type == GIT_RESET_MIXED
-		|| reset_type == GIT_RESET_HARD);
 
-	if (git_object_owner(target) != repo)
-		return reset_error_invalid("The given target does not belong to this repository.");
-
-	if (reset_type != GIT_RESET_SOFT
-		&& git_repository__ensure_not_bare(
-			repo,
-			reset_type == GIT_RESET_MIXED ? "reset mixed" : "reset hard") < 0)
-				return GIT_EBAREREPO;
-
-	if (git_object_peel(&commit, target, GIT_OBJ_COMMIT) < 0) {
-		reset_error_invalid("The given target does not resolve to a commit");
-		goto cleanup;
+	if (git_object_owner(target) != repo) {
+		giterr_set(GITERR_OBJECT,
+			"%s - The given target does not belong to this repository.", ERROR_MSG);
+		return -1;
 	}
 
-	//TODO: Check for unmerged entries
+	if (reset_type != GIT_RESET_SOFT &&
+		(error = git_repository__ensure_not_bare(repo,
+			reset_type == GIT_RESET_MIXED ? "reset mixed" : "reset hard")) < 0)
+		return error;
 
-	if (update_head(repo, commit) < 0)
+	if ((error = git_object_peel(&commit, target, GIT_OBJ_COMMIT)) < 0 ||
+		(error = git_repository_index(&index, repo)) < 0 ||
+		(error = git_commit_tree(&tree, (git_commit *)commit)) < 0)
 		goto cleanup;
 
-	if (reset_type == GIT_RESET_SOFT) {
-		error = 0;
+	if (reset_type == GIT_RESET_SOFT &&
+		(git_repository_state(repo) == GIT_REPOSITORY_STATE_MERGE ||
+		 git_index_has_conflicts(index)))
+	{
+		giterr_set(GITERR_OBJECT, "%s (soft) in the middle of a merge.", ERROR_MSG);
+		error = GIT_EUNMERGED;
 		goto cleanup;
 	}
 
-	if (git_commit_tree(&tree, (git_commit *)commit) < 0) {
-		giterr_set(GITERR_OBJECT, "%s - Failed to retrieve the commit tree.", ERROR_MSG);
+	/* move HEAD to the new target */
+	if ((error = git_reference__update_terminal(repo, GIT_HEAD_FILE,
+		git_object_id(commit))) < 0)
 		goto cleanup;
-	}
 
-	if (git_repository_index(&index, repo) < 0) {
-		giterr_set(GITERR_OBJECT, "%s - Failed to retrieve the index.", ERROR_MSG);
-		goto cleanup;
-	}
+	if (reset_type == GIT_RESET_HARD) {
+		/* overwrite working directory with HEAD */
+		opts.checkout_strategy = GIT_CHECKOUT_FORCE;
 
-	if (git_index_read_tree(index, tree, NULL) < 0) {
-		giterr_set(GITERR_INDEX, "%s - Failed to update the index.", ERROR_MSG);
-		goto cleanup;
-	}
-
-	if (git_index_write(index) < 0) {
-		giterr_set(GITERR_INDEX, "%s - Failed to write the index.", ERROR_MSG);
-		goto cleanup;
+		if ((error = git_checkout_tree(repo, (git_object *)tree, &opts)) < 0)
+			goto cleanup;
 	}
 
-	if (reset_type == GIT_RESET_MIXED) {
-		error = 0;
-		goto cleanup;
-	}
+	if (reset_type > GIT_RESET_SOFT) {
+		/* reset index to the target content */
 
-	memset(&opts, 0, sizeof(opts));
-	opts.checkout_strategy =
-		GIT_CHECKOUT_CREATE_MISSING
-		| GIT_CHECKOUT_OVERWRITE_MODIFIED
-		| GIT_CHECKOUT_REMOVE_UNTRACKED;
+		if ((error = git_index_read_tree(index, tree)) < 0 ||
+			(error = git_index_write(index)) < 0)
+			goto cleanup;
 
-	if (git_checkout_index(repo, &opts, NULL) < 0) {
-		giterr_set(GITERR_INDEX, "%s - Failed to checkout the index.", ERROR_MSG);
-		goto cleanup;
+		if ((error = git_repository_merge_cleanup(repo)) < 0) {
+			giterr_set(GITERR_INDEX, "%s - failed to clean up merge data", ERROR_MSG);
+			goto cleanup;
+		}
 	}
 
-	error = 0;
-
 cleanup:
 	git_object_free(commit);
 	git_index_free(index);

data/vendor/libgit2/src/revparse.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * Copyright (C) the libgit2 contributors. All rights reserved.
  *
  * This file is part of libgit2, distributed under the GNU GPL v2 with
  * a Linking Exception. For full terms see the included COPYING file.
@@ -10,15 +10,10 @@
 #include "common.h"
 #include "buffer.h"
 #include "tree.h"
+#include "refdb.h"
 
 #include "git2.h"
 
-static int revspec_error(const char *revspec)
-{
-	giterr_set(GITERR_INVALID, "Failed to parse revision specifier - Invalid pattern '%s'", revspec);
-	return -1;
-}
-
 static int disambiguate_refname(git_reference **out, git_repository *repo, const char *refname)
 {
 	int error, i;
@@ -51,7 +46,7 @@ static int disambiguate_refname(git_reference **out, git_repository *repo, const
 			goto cleanup;
 
 		if (!git_reference_is_valid_name(git_buf_cstr(&refnamebuf))) {
-			error = GIT_ENOTFOUND;
+			error = GIT_EINVALIDSPEC;
 			continue;
 		}
 
@@ -73,10 +68,9 @@ cleanup:
 	return error;
 }
 
-static int maybe_sha_or_abbrev(git_object**out, git_repository *repo, const char *spec)
+static int maybe_sha_or_abbrev(git_object** out, git_repository *repo, const char *spec, size_t speclen)
 {
 	git_oid oid;
-	size_t speclen = strlen(spec);
 
 	if (git_oid_fromstrn(&oid, spec, speclen) < 0)
 		return GIT_ENOTFOUND;
@@ -84,23 +78,41 @@ static int maybe_sha_or_abbrev(git_object**out, git_repository *repo, const char
 	return git_object_lookup_prefix(out, repo, &oid, speclen, GIT_OBJ_ANY);
 }
 
+static int maybe_sha(git_object** out, git_repository *repo, const char *spec)
+{
+	size_t speclen = strlen(spec);
+
+	if (speclen != GIT_OID_HEXSZ)
+		return GIT_ENOTFOUND;
+
+	return maybe_sha_or_abbrev(out, repo, spec, speclen);
+}
+
+static int maybe_abbrev(git_object** out, git_repository *repo, const char *spec)
+{
+	size_t speclen = strlen(spec);
+
+	return maybe_sha_or_abbrev(out, repo, spec, speclen);
+}
+
 static int build_regex(regex_t *regex, const char *pattern)
 {
 	int error;
 
 	if (*pattern == '\0') {
 		giterr_set(GITERR_REGEX, "Empty pattern");
-		return -1;
+		return GIT_EINVALIDSPEC;
 	}
 
 	error = regcomp(regex, pattern, REG_EXTENDED);
 	if (!error)
 		return 0;
-	
-	giterr_set_regex(regex, error);
+
+	error = giterr_set_regex(regex, error);
+
 	regfree(regex);
 
-	return -1;
+	return error;
 }
 
 static int maybe_describe(git_object**out, git_repository *repo, const char *spec)
@@ -113,7 +125,7 @@ static int maybe_describe(git_object**out, git_repository *repo, const char *spe
 
 	if (substr == NULL)
 		return GIT_ENOTFOUND;
-	
+
 	if (build_regex(&regex, ".+-[0-9]+-g[0-9a-fA-F]+") < 0)
 		return -1;
 
@@ -123,7 +135,7 @@ static int maybe_describe(git_object**out, git_repository *repo, const char *spe
 	if (error)
 		return GIT_ENOTFOUND;
 
-	return maybe_sha_or_abbrev(out, repo, substr+2);
+	return maybe_abbrev(out, repo, substr+2);
 }
 
 static int revparse_lookup_object(git_object **out, git_repository *repo, const char *spec)
@@ -131,7 +143,7 @@ static int revparse_lookup_object(git_object **out, git_repository *repo, const
 	int error;
 	git_reference *ref;
 
-	error = maybe_describe(out, repo, spec);
+	error = maybe_sha(out, repo, spec);
 	if (!error)
 		return 0;
 
@@ -140,7 +152,7 @@ static int revparse_lookup_object(git_object **out, git_repository *repo, const
 
 	error = disambiguate_refname(&ref, repo, spec);
 	if (!error) {
-		error = git_object_lookup(out, repo, git_reference_oid(ref), GIT_OBJ_ANY);
+		error = git_object_lookup(out, repo, git_reference_target(ref), GIT_OBJ_ANY);
 		git_reference_free(ref);
 		return error;
 	}
@@ -148,7 +160,14 @@ static int revparse_lookup_object(git_object **out, git_repository *repo, const
 	if (error < 0 && error != GIT_ENOTFOUND)
 		return error;
 
-	error = maybe_sha_or_abbrev(out, repo, spec);
+	error = maybe_abbrev(out, repo, spec);
+	if (!error)
+		return 0;
+
+	if (error < 0 && error != GIT_ENOTFOUND)
+		return error;
+
+	error = maybe_describe(out, repo, spec);
 	if (!error)
 		return 0;
 
@@ -161,7 +180,7 @@ static int revparse_lookup_object(git_object **out, git_repository *repo, const
 
 static int try_parse_numeric(int *n, const char *curly_braces_content)
 {
-	int content;
+	int32_t content;
 	const char *end_ptr;
 
 	if (git__strtol32(&content, curly_braces_content, &end_ptr, 10) < 0)
@@ -170,16 +189,17 @@ static int try_parse_numeric(int *n, const char *curly_braces_content)
 	if (*end_ptr != '\0')
 		return -1;
 
-	*n = content;
+	*n = (int)content;
 	return 0;
 }
 
-static int retrieve_previously_checked_out_branch_or_revision(git_object **out, git_reference **base_ref, git_repository *repo, const char *spec, const char *identifier, unsigned int position)
+static int retrieve_previously_checked_out_branch_or_revision(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, size_t position)
 {
 	git_reference *ref = NULL;
 	git_reflog *reflog = NULL;
 	regex_t preg;
-	int numentries, i, cur, error = -1;
+	int error = -1;
+	size_t i, numentries, cur;
 	const git_reflog_entry *entry;
 	const char *msg;
 	regmatch_t regexmatches[2];
@@ -188,7 +208,7 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
 	cur = position;
 
 	if (*identifier != '\0' || *base_ref != NULL)
-		return revspec_error(spec);
+		return GIT_EINVALIDSPEC;
 
 	if (build_regex(&preg, "checkout: moving from (.*) to .*") < 0)
 		return -1;
@@ -201,10 +221,10 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
 
 	numentries  = git_reflog_entrycount(reflog);
 
-	for (i = numentries - 1; i >= 0; i--) {
+	for (i = 0; i < numentries; i++) {
 		entry = git_reflog_entry_byindex(reflog, i);
-		msg = git_reflog_entry_msg(entry);
-		
+		msg = git_reflog_entry_message(entry);
+
 		if (regexec(&preg, msg, 2, regexmatches, 0))
 			continue;
 
@@ -212,7 +232,7 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
 
 		if (cur > 0)
 			continue;
-		
+
 		git_buf_put(&buf, msg+regexmatches[1].rm_so, regexmatches[1].rm_eo - regexmatches[1].rm_so);
 
 		if ((error = disambiguate_refname(base_ref, repo, git_buf_cstr(&buf))) == 0)
@@ -221,11 +241,11 @@ static int retrieve_previously_checked_out_branch_or_revision(git_object **out,
 		if (error < 0 && error != GIT_ENOTFOUND)
 			goto cleanup;
 
-		error = maybe_sha_or_abbrev(out, repo, git_buf_cstr(&buf));
+		error = maybe_abbrev(out, repo, git_buf_cstr(&buf));
 
 		goto cleanup;
 	}
-	
+
 	error = GIT_ENOTFOUND;
 
 cleanup:
@@ -236,49 +256,47 @@ cleanup:
 	return error;
 }
 
-static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, unsigned int identifier)
+static int retrieve_oid_from_reflog(git_oid *oid, git_reference *ref, size_t identifier)
 {
 	git_reflog *reflog;
 	int error = -1;
-	unsigned int numentries;
+	size_t numentries;
 	const git_reflog_entry *entry;
 	bool search_by_pos = (identifier <= 100000000);
 
 	if (git_reflog_read(&reflog, ref) < 0)
 		return -1;
 
-	numentries  = git_reflog_entrycount(reflog);
+	numentries = git_reflog_entrycount(reflog);
 
 	if (search_by_pos) {
 		if (numentries < identifier + 1) {
 			giterr_set(
 				GITERR_REFERENCE,
-				"Reflog for '%s' has only %d entries, asked for %d",
-				git_reference_name(ref),
-				numentries,
-				identifier);
+				"Reflog for '%s' has only "PRIuZ" entries, asked for "PRIuZ,
+				git_reference_name(ref), numentries, identifier);
 
 			error = GIT_ENOTFOUND;
 			goto cleanup;
 		}
 
 		entry = git_reflog_entry_byindex(reflog, identifier);
-		git_oid_cpy(oid, git_reflog_entry_oidold(entry));
+		git_oid_cpy(oid, git_reflog_entry_id_new(entry));
 		error = 0;
 		goto cleanup;
 
 	} else {
-		int i;
+		size_t i;
 		git_time commit_time;
 
-		for (i = numentries - 1; i >= 0; i--) {
+		for (i = 0; i < numentries; i++) {
 			entry = git_reflog_entry_byindex(reflog, i);
 			commit_time = git_reflog_entry_committer(entry)->when;
-					
-			if (commit_time.time - identifier > 0)
+
+			if (commit_time.time > (git_time_t)identifier)
 				continue;
 
-			git_oid_cpy(oid, git_reflog_entry_oidnew(entry));
+			git_oid_cpy(oid, git_reflog_entry_id_new(entry));
 			error = 0;
 			goto cleanup;
 		}
@@ -291,7 +309,7 @@ cleanup:
 	return error;
 }
 
-static int retrieve_revobject_from_reflog(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, unsigned int position)
+static int retrieve_revobject_from_reflog(git_object **out, git_reference **base_ref, git_repository *repo, const char *identifier, size_t position)
 {
 	git_reference *ref;
 	git_oid oid;
@@ -306,7 +324,7 @@ static int retrieve_revobject_from_reflog(git_object **out, git_reference **base
 	}
 
 	if (position == 0) {
-		error = git_object_lookup(out, repo, git_reference_oid(ref), GIT_OBJ_ANY);
+		error = git_object_lookup(out, repo, git_reference_target(ref), GIT_OBJ_ANY);
 		goto cleanup;
 	}
 
@@ -333,9 +351,14 @@ static int retrieve_remote_tracking_reference(git_reference **base_ref, const ch
 		*base_ref = NULL;
 	}
 
-	if ((error = git_branch_tracking(&tracking, ref)) < 0)
+	if (!git_reference_is_branch(ref)) {
+		error = GIT_EINVALIDSPEC;
+		goto cleanup;
+	}
+
+	if ((error = git_branch_upstream(&tracking, ref)) < 0)
 		goto cleanup;
-	
+
 	*base_ref = tracking;
 
 cleanup:
@@ -358,13 +381,13 @@ static int handle_at_syntax(git_object **out, git_reference **ref, const char *s
 	is_numeric = !try_parse_numeric(&parsed, curly_braces_content);
 
 	if (*curly_braces_content == '-' && (!is_numeric || parsed == 0)) {
-		error = revspec_error(spec);
+		error = GIT_EINVALIDSPEC;
 		goto cleanup;
 	}
 
 	if (is_numeric) {
 		if (parsed < 0)
-			error = retrieve_previously_checked_out_branch_or_revision(out, ref, repo, spec, git_buf_cstr(&identifier), -parsed);
+			error = retrieve_previously_checked_out_branch_or_revision(out, ref, repo, git_buf_cstr(&identifier), -parsed);
 		else
 			error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), parsed);
 
@@ -380,7 +403,7 @@ static int handle_at_syntax(git_object **out, git_reference **ref, const char *s
 	if (git__date_parse(&timestamp, curly_braces_content) < 0)
 		goto cleanup;
 
-	error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (unsigned int)timestamp);
+	error = retrieve_revobject_from_reflog(out, ref, repo, git_buf_cstr(&identifier), (size_t)timestamp);
 
 cleanup:
 	git_buf_free(&identifier);
@@ -394,7 +417,7 @@ static git_otype parse_obj_type(const char *str)
 
 	if (!strcmp(str, "tree"))
 		return GIT_OBJ_TREE;
-	
+
 	if (!strcmp(str, "blob"))
 		return GIT_OBJ_BLOB;
 
@@ -409,7 +432,7 @@ static int dereference_to_non_tag(git_object **out, git_object *obj)
 	if (git_object_type(obj) == GIT_OBJ_TAG)
 		return git_tag_peel(out, (git_tag *)obj);
 
-	return git_object__dup(out, obj);
+	return git_object_dup(out, obj);
 }
 
 static int handle_caret_parent_syntax(git_object **out, git_object *obj, int n)
@@ -417,8 +440,9 @@ static int handle_caret_parent_syntax(git_object **out, git_object *obj, int n)
 	git_object *temp_commit = NULL;
 	int error;
 
-	if (git_object_peel(&temp_commit, obj, GIT_OBJ_COMMIT) < 0)
-		return -1;
+	if ((error = git_object_peel(&temp_commit, obj, GIT_OBJ_COMMIT)) < 0)
+		return (error == GIT_EAMBIGUOUS || error == GIT_ENOTFOUND) ?
+			GIT_EINVALIDSPEC : error;
 
 	if (n == 0) {
 		*out = temp_commit;
@@ -436,8 +460,9 @@ static int handle_linear_syntax(git_object **out, git_object *obj, int n)
 	git_object *temp_commit = NULL;
 	int error;
 
-	if (git_object_peel(&temp_commit, obj, GIT_OBJ_COMMIT) < 0)
-		return -1;
+	if ((error = git_object_peel(&temp_commit, obj, GIT_OBJ_COMMIT)) < 0)
+		return (error == GIT_EAMBIGUOUS || error == GIT_ENOTFOUND) ?
+			GIT_EINVALIDSPEC : error;
 
 	error = git_commit_nth_gen_ancestor((git_commit **)out, (git_commit*)temp_commit, n);
 
@@ -454,8 +479,8 @@ static int handle_colon_syntax(
 	int error = -1;
 	git_tree_entry *entry = NULL;
 
-	if (git_object_peel(&tree, obj, GIT_OBJ_TREE) < 0)
-		return -1;
+	if ((error = git_object_peel(&tree, obj, GIT_OBJ_TREE)) < 0)
+		return error == GIT_ENOTFOUND ? GIT_EINVALIDSPEC : error;
 
 	if (*path == '\0') {
 		*out = tree;
@@ -483,11 +508,11 @@ static int walk_and_search(git_object **out, git_revwalk *walk, regex_t *regex)
 	int error;
 	git_oid oid;
 	git_object *obj;
-	
+
 	while (!(error = git_revwalk_next(&oid, walk))) {
 
-		if ((error = git_object_lookup(&obj, git_revwalk_repository(walk), &oid, GIT_OBJ_COMMIT) < 0) &&
-			(error != GIT_ENOTFOUND))
+		error = git_object_lookup(&obj, git_revwalk_repository(walk), &oid, GIT_OBJ_COMMIT);
+		if ((error < 0) && (error != GIT_ENOTFOUND))
 			return -1;
 
 		if (!regexec(regex, git_commit_message((git_commit*)obj), 0, NULL, 0)) {
@@ -508,25 +533,25 @@ static int handle_grep_syntax(git_object **out, git_repository *repo, const git_
 {
 	regex_t preg;
 	git_revwalk *walk = NULL;
-	int error = -1;
+	int error;
 
-	if (build_regex(&preg, pattern) < 0)
-		return -1;
-		
-	if (git_revwalk_new(&walk, repo) < 0)
+	if ((error = build_regex(&preg, pattern)) < 0)
+		return error;
+
+	if ((error = git_revwalk_new(&walk, repo)) < 0)
 		goto cleanup;
 
 	git_revwalk_sorting(walk, GIT_SORT_TIME);
 
 	if (spec_oid == NULL) {
 		// TODO: @carlosmn: The glob should be refs/* but this makes git_revwalk_next() fails
-		if (git_revwalk_push_glob(walk, GIT_REFS_HEADS_DIR "*") < 0)
+		if ((error = git_revwalk_push_glob(walk, GIT_REFS_HEADS_DIR "*")) < 0)
 			goto cleanup;
-	} else if (git_revwalk_push(walk, spec_oid) < 0)
+	} else if ((error = git_revwalk_push(walk, spec_oid)) < 0)
 			goto cleanup;
 
 	error = walk_and_search(out, walk, &preg);
-		
+
 cleanup:
 	regfree(&preg);
 	git_revwalk_free(walk);
@@ -547,7 +572,7 @@ static int handle_caret_curly_syntax(git_object **out, git_object *obj, const ch
 	expected_type = parse_obj_type(curly_braces_content);
 
 	if (expected_type == GIT_OBJ_BAD)
-		return -1;
+		return GIT_EINVALIDSPEC;
 
 	return git_object_peel(out, obj, expected_type);
 }
@@ -561,13 +586,13 @@ static int extract_curly_braces_content(git_buf *buf, const char *spec, size_t *
 	(*pos)++;
 
 	if (spec[*pos] == '\0' || spec[*pos] != '{')
-		return revspec_error(spec);
+		return GIT_EINVALIDSPEC;
 
 	(*pos)++;
 
 	while (spec[*pos] != '}') {
 		if (spec[*pos] == '\0')
-			return revspec_error(spec);
+			return GIT_EINVALIDSPEC;
 
 		git_buf_putc(buf, spec[(*pos)++]);
 	}
@@ -610,8 +635,8 @@ static int extract_how_many(int *n, const char *spec, size_t *pos)
 		} while (spec[(*pos)] == kind && kind == '~');
 
 		if (git__isdigit(spec[*pos])) {
-			if ((git__strtol32(&parsed, spec + *pos, &end_ptr, 10) < 0) < 0)
-				return revspec_error(spec);
+			if (git__strtol32(&parsed, spec + *pos, &end_ptr, 10) < 0)
+				return GIT_EINVALIDSPEC;
 
 			accumulated += (parsed - 1);
 			*pos = end_ptr - spec;
@@ -632,7 +657,7 @@ static int object_from_reference(git_object **object, git_reference *reference)
 	if (git_reference_resolve(&resolved, reference) < 0)
 		return -1;
 
-	error = git_object_lookup(object, reference->owner, git_reference_oid(resolved), GIT_OBJ_ANY);
+	error = git_object_lookup(object, reference->db->repo, git_reference_target(resolved), GIT_OBJ_ANY);
 	git_reference_free(resolved);
 
 	return error;
@@ -656,7 +681,7 @@ static int ensure_base_rev_loaded(git_object **object, git_reference **reference
 	}
 
 	if (!allow_empty_identifier && identifier_len == 0)
-		return revspec_error(spec);
+		return GIT_EINVALIDSPEC;
 
 	if (git_buf_put(&identifier, spec, identifier_len) < 0)
 		return -1;
@@ -667,12 +692,12 @@ static int ensure_base_rev_loaded(git_object **object, git_reference **reference
 	return error;
 }
 
-static int ensure_base_rev_is_not_known_yet(git_object *object, const char *spec)
+static int ensure_base_rev_is_not_known_yet(git_object *object)
 {
 	if (object == NULL)
 		return 0;
 
-	return revspec_error(spec);
+	return GIT_EINVALIDSPEC;
 }
 
 static bool any_left_hand_identifier(git_object *object, git_reference *reference, size_t identifier_len)
@@ -689,12 +714,12 @@ static bool any_left_hand_identifier(git_object *object, git_reference *referenc
 	return false;
 }
 
-static int ensure_left_hand_identifier_is_not_known_yet(git_object *object, git_reference *reference, const char *spec)
+static int ensure_left_hand_identifier_is_not_known_yet(git_object *object, git_reference *reference)
 {
-	if (!ensure_base_rev_is_not_known_yet(object, spec) && reference == NULL)
+	if (!ensure_base_rev_is_not_known_yet(object) && reference == NULL)
 		return 0;
 
-	return revspec_error(spec);
+	return GIT_EINVALIDSPEC;
 }
 
 int git_revparse_single(git_object **out, git_repository *repo, const char *spec)
@@ -801,7 +826,7 @@ int git_revparse_single(git_object **out, git_repository *repo, const char *spec
 				if ((error = extract_curly_braces_content(&buf, spec, &pos)) < 0)
 					goto cleanup;
 
-				if ((error = ensure_base_rev_is_not_known_yet(base_rev, spec)) < 0)
+				if ((error = ensure_base_rev_is_not_known_yet(base_rev)) < 0)
 					goto cleanup;
 
 				if ((error = handle_at_syntax(&temp_object, &reference, spec, identifier_len, repo, git_buf_cstr(&buf))) < 0)
@@ -816,7 +841,7 @@ int git_revparse_single(git_object **out, git_repository *repo, const char *spec
 		}
 
 		default:
-			if ((error = ensure_left_hand_identifier_is_not_known_yet(base_rev, reference, spec)) < 0)
+			if ((error = ensure_left_hand_identifier_is_not_known_yet(base_rev, reference)) < 0)
 				goto cleanup;
 
 			pos++;
@@ -831,9 +856,57 @@ int git_revparse_single(git_object **out, git_repository *repo, const char *spec
 	error = 0;
 
 cleanup:
-	if (error)
+	if (error) {
+		if (error == GIT_EINVALIDSPEC)
+			giterr_set(GITERR_INVALID,
+				"Failed to parse revision specifier - Invalid pattern '%s'", spec);
+
 		git_object_free(base_rev);
+	}
 	git_reference_free(reference);
 	git_buf_free(&buf);
 	return error;
 }
+
+
+int git_revparse(
+	git_revspec *revspec,
+	git_repository *repo,
+	const char *spec)
+{
+	const char *dotdot;
+	int error = 0;
+
+	assert(revspec && repo && spec);
+
+	memset(revspec, 0x0, sizeof(*revspec));
+
+	if ((dotdot = strstr(spec, "..")) != NULL) {
+		char *lstr;
+		const char *rstr;
+		revspec->flags = GIT_REVPARSE_RANGE;
+
+		lstr = git__substrdup(spec, dotdot - spec);
+		rstr = dotdot + 2;
+		if (dotdot[2] == '.') {
+			revspec->flags |= GIT_REVPARSE_MERGE_BASE;
+			rstr++;
+		}
+
+		if ((error = git_revparse_single(&revspec->from, repo, lstr)) < 0) {
+			return error;
+		}
+
+		if ((error = git_revparse_single(&revspec->to, repo, rstr)) < 0) {
+			return error;
+		}
+
+		git__free((void*)lstr);
+	} else {
+		revspec->flags = GIT_REVPARSE_SINGLE;
+		error = git_revparse_single(&revspec->from, repo, spec);
+	}
+
+	return error;
+}
+