rdavila-rugged 0.24.0b13

data/ext/rugged/rugged_repo.c

@@ -0,0 +1,2669 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2014 GitHub, Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "rugged.h"
+#include <git2/sys/repository.h>
+#include <git2/sys/odb_backend.h>
+#include <git2/sys/refdb_backend.h>
+#include <git2/refs.h>
+
+extern VALUE rb_mRugged;
+extern VALUE rb_eRuggedError;
+extern VALUE rb_cRuggedIndex;
+extern VALUE rb_cRuggedConfig;
+extern VALUE rb_cRuggedBackend;
+extern VALUE rb_cRuggedRemote;
+extern VALUE rb_cRuggedCommit;
+extern VALUE rb_cRuggedTag;
+extern VALUE rb_cRuggedTree;
+extern VALUE rb_cRuggedReference;
+extern VALUE rb_cRuggedBackend;
+
+extern VALUE rb_cRuggedCredPlaintext;
+extern VALUE rb_cRuggedCredSshKey;
+extern VALUE rb_cRuggedCredDefault;
+
+VALUE rb_cRuggedRepo;
+VALUE rb_cRuggedOdbObject;
+
+static ID id_call;
+
+/*
+ *  call-seq:
+ *    odb_obj.oid -> hex_oid
+ *
+ *  Return the Object ID (a 40 character SHA1 hash) for this raw
+ *  object.
+ *
+ *    odb_obj.oid #=> "d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f"
+ */
+static VALUE rb_git_odbobj_oid(VALUE self)
+{
+	git_odb_object *obj;
+	Data_Get_Struct(self, git_odb_object, obj);
+	return rugged_create_oid(git_odb_object_id(obj));
+}
+
+/*
+ *  call-seq:
+ *    odb_obj.data -> buffer
+ *
+ *  Return an ASCII buffer with the raw bytes that form the Git object.
+ *
+ *    odb_obj.data #=> "tree 87ebee8367f9cc5ac04858b3bd5610ca74f04df9\n"
+ *                 #=> "parent 68d041ee999cb07c6496fbdd4f384095de6ca9e1\n"
+ *                 #=> "author Vicent Martí <tanoku@gmail.com> 1326863045 -0800\n"
+ *                 #=> ...
+ */
+static VALUE rb_git_odbobj_data(VALUE self)
+{
+	git_odb_object *obj;
+	Data_Get_Struct(self, git_odb_object, obj);
+	return rb_str_new(git_odb_object_data(obj), git_odb_object_size(obj));
+}
+
+/*
+ *  call-seq:
+ *    odb_obj.size -> size
+ *
+ *  Return the size in bytes of the Git object after decompression. This is
+ *  also the size of the +obj.data+ buffer.
+ *
+ *    odb_obj.size #=> 231
+ */
+static VALUE rb_git_odbobj_size(VALUE self)
+{
+	git_odb_object *obj;
+	Data_Get_Struct(self, git_odb_object, obj);
+	return INT2FIX(git_odb_object_size(obj));
+}
+
+/*
+ *  call-seq:
+ *    odb_obj.type -> Symbol
+ *
+ *  Return a Ruby symbol representing the basic Git type of this object.
+ *  Possible values are +:tree+, +:blob+, +:commit+ and +:tag+.
+ *
+ *    odb_obj.type #=> :tag
+ */
+static VALUE rb_git_odbobj_type(VALUE self)
+{
+	git_odb_object *obj;
+	Data_Get_Struct(self, git_odb_object, obj);
+	return rugged_otype_new(git_odb_object_type(obj));
+}
+
+void rb_git__odbobj_free(void *obj)
+{
+	git_odb_object_free((git_odb_object *)obj);
+}
+
+VALUE rugged_raw_read(git_repository *repo, const git_oid *oid)
+{
+	git_odb *odb;
+	git_odb_object *obj;
+
+	int error;
+
+	error = git_repository_odb(&odb, repo);
+	rugged_exception_check(error);
+
+	error = git_odb_read(&obj, odb, oid);
+	git_odb_free(odb);
+	rugged_exception_check(error);
+
+	return Data_Wrap_Struct(rb_cRuggedOdbObject, NULL, rb_git__odbobj_free, obj);
+}
+
+void rb_git_repo__free(git_repository *repo)
+{
+	git_repository_free(repo);
+}
+
+VALUE rugged_repo_new(VALUE klass, git_repository *repo)
+{
+	VALUE rb_repo = Data_Wrap_Struct(klass, NULL, &rb_git_repo__free, repo);
+
+#ifdef HAVE_RUBY_ENCODING_H
+	/* TODO: set this properly */
+	rb_iv_set(rb_repo, "@encoding",
+		rb_enc_from_encoding(rb_filesystem_encoding()));
+#endif
+
+	rb_iv_set(rb_repo, "@config", Qnil);
+	rb_iv_set(rb_repo, "@index", Qnil);
+
+	return rb_repo;
+}
+
+static void load_alternates(git_repository *repo, VALUE rb_alternates)
+{
+	git_odb *odb = NULL;
+	int i, error;
+
+	if (NIL_P(rb_alternates))
+		return;
+
+	Check_Type(rb_alternates, T_ARRAY);
+
+	if (RARRAY_LEN(rb_alternates) == 0)
+		return;
+
+	for (i = 0; i < RARRAY_LEN(rb_alternates); ++i)
+		Check_Type(rb_ary_entry(rb_alternates, i), T_STRING);
+
+	error = git_repository_odb(&odb, repo);
+	rugged_exception_check(error);
+
+	for (i = 0; !error && i < RARRAY_LEN(rb_alternates); ++i) {
+		VALUE alt = rb_ary_entry(rb_alternates, i);
+		error = git_odb_add_disk_alternate(odb, StringValueCStr(alt));
+	}
+
+	git_odb_free(odb);
+	rugged_exception_check(error);
+}
+
+static void rugged_repo_new_with_backend(git_repository **repo, VALUE rb_path, VALUE rb_backend)
+{
+	char *path;
+
+	git_odb *odb = NULL;
+	git_odb_backend *odb_backend = NULL;
+	git_refdb *refdb = NULL;
+	git_refdb_backend *refdb_backend = NULL;
+	git_reference *head = NULL;
+	rugged_backend *backend;
+
+	int error = 0;
+
+	Check_Type(rb_path, T_STRING);
+	path = StringValueCStr(rb_path);
+
+	if (rb_obj_is_kind_of(rb_backend, rb_cRuggedBackend) == Qfalse) {
+		rb_raise(rb_eRuggedError, "Backend must be an instance of Rugged::Backend");
+	}
+
+	Data_Get_Struct(rb_backend, rugged_backend, backend);
+
+	error = git_odb_new(&odb);
+	if (error) goto cleanup;
+
+	error = backend->odb_backend(&odb_backend, backend, path);
+	if (error) goto cleanup;
+
+	error = git_odb_add_backend(odb, odb_backend, 1);
+	if (error) {
+		assert(odb_backend->free);
+		odb_backend->free(odb_backend);
+		goto cleanup;
+	}
+
+	error = git_repository_wrap_odb(repo, odb);
+	if (error) goto cleanup;
+
+	error = git_refdb_new(&refdb, *repo);
+	if (error) goto cleanup;
+
+	error = backend->refdb_backend(&refdb_backend, backend, path);
+	if (error) {
+		assert(refdb_backend->free);
+		refdb_backend->free(refdb_backend);
+		goto cleanup;
+	}
+
+	error = git_refdb_set_backend(refdb, refdb_backend);
+	if (error) goto cleanup;
+
+	git_repository_set_refdb(*repo, refdb);
+
+	error = git_reference_lookup(&head, *repo, "HEAD");
+
+	if (error == GIT_ENOTFOUND) {
+		giterr_clear();
+		error = git_reference_symbolic_create(&head, *repo, "HEAD", "refs/heads/master", 0, NULL);
+	}
+
+	if (!error) {
+		git_reference_free(head);
+		return;
+	}
+
+cleanup:
+	git_repository_free(*repo);
+	git_odb_free(odb);
+	git_refdb_free(refdb);
+
+	rugged_exception_check(error);
+}
+
+/*
+ *  call-seq:
+ *    Repository.bare(path[, alternates]) -> repository OR
+ *    Repository.bare(path[, options]) -> repository
+ *
+ *  Open a bare Git repository at +path+ and return a +Repository+
+ *  object representing it.
+ *
+ *  This is faster than Rugged::Repository.new, as it won't attempt to perform
+ *  any +.git+ directory discovery, won't try to load the config options to
+ *  determine whether the repository is bare and won't try to load the workdir.
+ *
+ *  Optionally, you can pass a list of alternate object folders or an options Hash.
+ *
+ *    Rugged::Repository.bare(path, ['./other/repo/.git/objects'])
+ *    Rugged::Repository.bare(path, opts)
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :backend ::
+ *    A Rugged::Backend instance
+ *  :alternates ::
+ *    A list of alternate object folders.
+ *    Rugged::Repository.bare(path, :alternates => ['./other/repo/.git/objects'])
+ */
+static VALUE rb_git_repo_open_bare(int argc, VALUE *argv, VALUE klass)
+{
+	git_repository *repo = NULL;
+	int error = 0;
+	VALUE rb_path, rb_options, rb_alternates = 0;
+
+	rb_scan_args(argc, argv, "11", &rb_path, &rb_options);
+
+	if (!NIL_P(rb_options) && TYPE(rb_options) == T_ARRAY)
+		rb_alternates = rb_options;
+
+	if (!NIL_P(rb_options) && TYPE(rb_options) == T_HASH) {
+		/* Check for `:backend` */
+		VALUE rb_backend = rb_hash_aref(rb_options, CSTR2SYM("backend"));
+
+		if (!NIL_P(rb_backend)) {
+			rugged_repo_new_with_backend(&repo, rb_path, rb_backend);
+		}
+
+		/* Check for `:alternates` */
+		rb_alternates = rb_hash_aref(rb_options, CSTR2SYM("alternates"));
+	}
+
+	if (!repo) {
+		Check_Type(rb_path, T_STRING);
+
+		error = git_repository_open_bare(&repo, StringValueCStr(rb_path));
+		rugged_exception_check(error);
+	}
+
+	if (rb_alternates) {
+		load_alternates(repo, rb_alternates);
+	}
+
+	return rugged_repo_new(klass, repo);
+}
+
+/*
+ *  call-seq:
+ *    Repository.new(path, options = {}) -> repository
+ *
+ *  Open a Git repository in the given +path+ and return a +Repository+ object
+ *  representing it. An exception will be thrown if +path+ doesn't point to a
+ *  valid repository. If you need to create a repository from scratch, use
+ *  Rugged::Repository.init_at instead.
+ *
+ *  The +path+ must point to either the actual folder (+.git+) of a Git repository,
+ *  or to the directorly that contains the +.git+ folder.
+ *
+ *  See also Rugged::Repository.discover and Rugged::Repository.bare.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :alternates ::
+ *    A list of alternate object folders.
+ *
+ *  Examples:
+ *
+ *    Rugged::Repository.new('test/.git') #=> #<Rugged::Repository:0x108849488>
+ *    Rugged::Repository.new(path, :alternates => ['./other/repo/.git/objects'])
+ */
+static VALUE rb_git_repo_new(int argc, VALUE *argv, VALUE klass)
+{
+	git_repository *repo;
+	int error = 0;
+	VALUE rb_path, rb_options;
+
+	rb_scan_args(argc, argv, "10:", &rb_path, &rb_options);
+	Check_Type(rb_path, T_STRING);
+
+	error = git_repository_open(&repo, StringValueCStr(rb_path));
+	rugged_exception_check(error);
+
+	if (!NIL_P(rb_options)) {
+		/* Check for `:alternates` */
+		load_alternates(repo, rb_hash_aref(rb_options, CSTR2SYM("alternates")));
+	}
+
+	return rugged_repo_new(klass, repo);
+}
+
+/*
+ *  call-seq:
+ *    Repository.init_at(path, is_bare = false, opts = {}) -> repository
+ *
+ *  Initialize a Git repository in +path+. This implies creating all the
+ *  necessary files on the FS, or re-initializing an already existing
+ *  repository if the files have already been created.
+ *
+ *  The +is_bare+ (optional, defaults to false) attribute specifies whether
+ *  the Repository should be created on disk as bare or not.
+ *  Bare repositories have no working directory and are created in the root
+ *  of +path+. Non-bare repositories are created in a +.git+ folder and
+ *  use +path+ as working directory.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :backend ::
+ *    A Rugged::Backend instance
+ *
+ *
+ *    Rugged::Repository.init_at('repository', :bare) #=> #<Rugged::Repository:0x108849488>
+ */
+static VALUE rb_git_repo_init_at(int argc, VALUE *argv, VALUE klass)
+{
+	git_repository *repo = NULL;
+	VALUE rb_path, rb_is_bare, rb_options;
+	int error;
+
+	rb_scan_args(argc, argv, "11:", &rb_path, &rb_is_bare, &rb_options);
+	Check_Type(rb_path, T_STRING);
+
+	if (!NIL_P(rb_options)) {
+		/* Check for `:backend` */
+		VALUE rb_backend = rb_hash_aref(rb_options, CSTR2SYM("backend"));
+
+		if (rb_backend && !NIL_P(rb_backend)) {
+			rugged_repo_new_with_backend(&repo, rb_path, rb_backend);
+		}
+	}
+
+	if(!repo) {
+		error =	git_repository_init(&repo, StringValueCStr(rb_path), RTEST(rb_is_bare));
+		rugged_exception_check(error);
+	}
+
+	return rugged_repo_new(klass, repo);
+}
+
+static void parse_clone_options(git_clone_options *ret, VALUE rb_options, struct rugged_remote_cb_payload *remote_payload)
+{
+	VALUE val;
+
+	if (NIL_P(rb_options))
+		return;
+
+	val = rb_hash_aref(rb_options, CSTR2SYM("bare"));
+	if (RTEST(val))
+		ret->bare = 1;
+
+	val = rb_hash_aref(rb_options, CSTR2SYM("checkout_branch"));
+	if (!NIL_P(val)) {
+		Check_Type(val, T_STRING);
+		ret->checkout_branch = StringValueCStr(val);
+	}
+
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &ret->fetch_opts.callbacks, remote_payload);
+}
+
+/*
+ *  call-seq:
+ *    Repository.clone_at(url, local_path[, options]) -> repository
+ *
+ *  Clone a repository from +url+ to +local_path+.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :bare ::
+ *    If +true+, the clone will be created as a bare repository.
+ *    Defaults to +false+.
+ *
+ *  :checkout_branch ::
+ *    The name of a branch to checkout. Defaults to the remote's +HEAD+.
+ *
+ *  :remote ::
+ *    The name to give to the "origin" remote. Defaults to <tt>"origin"</tt>.
+ *
+ *  :ignore_cert_errors ::
+ *    If set to +true+, errors while validating the remote's host certificate will be ignored.
+ *
+ *  :credentials ::
+ *    The credentials to use for the clone operation. Can be either an instance of one
+ *    of the Rugged::Credentials types, or a proc returning one of the former.
+ *    The proc will be called with the +url+, the +username+ from the url (if applicable) and
+ *    a list of applicable credential types.
+ *
+ *  :progress ::
+ *    A callback that will be executed with the textual progress received from the remote.
+ *    This is the text send over the progress side-band (ie. the "counting objects" output).
+ *
+ *  :transfer_progress ::
+ *    A callback that will be executed to report clone progress information. It will be passed
+ *    the amount of +total_objects+, +indexed_objects+, +received_objects+, +local_objects+,
+ *    +total_deltas+, +indexed_deltas+, and +received_bytes+.
+ *
+ *  :update_tips ::
+ *    A callback that will be executed each time a reference was updated locally. It will be
+ *    passed the +refname+, +old_oid+ and +new_oid+.
+ *
+ *  Example:
+ *
+ *    Repository.clone_at("https://github.com/libgit2/rugged.git", "./some/dir", {
+ *      transfer_progress: lambda { |total_objects, indexed_objects, received_objects, local_objects, total_deltas, indexed_deltas, received_bytes|
+ *        # ...
+ *      }
+ *    })
+ */
+static VALUE rb_git_repo_clone_at(int argc, VALUE *argv, VALUE klass)
+{
+	VALUE url, local_path, rb_options_hash;
+	git_clone_options options = GIT_CLONE_OPTIONS_INIT;
+	struct rugged_remote_cb_payload remote_payload = { Qnil, Qnil, Qnil, Qnil, 0 };
+	git_repository *repo;
+	int error;
+
+	rb_scan_args(argc, argv, "21", &url, &local_path, &rb_options_hash);
+	Check_Type(url, T_STRING);
+	Check_Type(local_path, T_STRING);
+
+	parse_clone_options(&options, rb_options_hash, &remote_payload);
+
+	error = git_clone(&repo, StringValueCStr(url), StringValueCStr(local_path), &options);
+
+	if (RTEST(remote_payload.exception))
+		rb_jump_tag(remote_payload.exception);
+	rugged_exception_check(error);
+
+	return rugged_repo_new(klass, repo);
+}
+
+#define RB_GIT_REPO_OWNED_GET(_klass, _object) \
+	VALUE rb_data = rb_iv_get(self, "@" #_object); \
+	if (NIL_P(rb_data)) { \
+		git_repository *repo; \
+		git_##_object *data; \
+		int error; \
+		Data_Get_Struct(self, git_repository, repo); \
+		error = git_repository_##_object(&data, repo); \
+		rugged_exception_check(error); \
+		rb_data = rugged_##_object##_new(_klass, self, data); \
+		rb_iv_set(self, "@" #_object, rb_data); \
+	} \
+	return rb_data; \
+
+#define RB_GIT_REPO_OWNED_SET(_klass, _object) \
+	VALUE rb_old_data; \
+	git_repository *repo; \
+	git_##_object *data; \
+	if (!rb_obj_is_kind_of(rb_data, _klass))\
+		rb_raise(rb_eTypeError, \
+			"The given object is not a Rugged::" #_object); \
+	if (!NIL_P(rugged_owner(rb_data))) \
+		rb_raise(rb_eRuntimeError, \
+			"The given object is already owned by another repository"); \
+	Data_Get_Struct(self, git_repository, repo); \
+	Data_Get_Struct(rb_data, git_##_object, data); \
+	git_repository_set_##_object(repo, data); \
+	rb_old_data = rb_iv_get(self, "@" #_object); \
+	if (!NIL_P(rb_old_data)) rugged_set_owner(rb_old_data, Qnil); \
+	rugged_set_owner(rb_data, self); \
+	rb_iv_set(self, "@" #_object, rb_data); \
+	return Qnil; \
+
+
+/*
+ *  call-seq:
+ *    repo.index = idx
+ *
+ *  Set the index for this +Repository+. +idx+ must be a instance of
+ *  Rugged::Index. This index will be used internally by all
+ *  operations that use the Git index on +repo+.
+ *
+ *  Note that it's not necessary to set the +index+ for any repository;
+ *  by default repositories are loaded with the index file that can be
+ *  located on the +.git+ folder in the filesystem.
+ */
+static VALUE rb_git_repo_set_index(VALUE self, VALUE rb_data)
+{
+	RB_GIT_REPO_OWNED_SET(rb_cRuggedIndex, index);
+}
+
+/*
+ *  call-seq:
+ *    repo.index -> idx
+ *
+ *  Return the default index for this repository.
+ */
+static VALUE rb_git_repo_get_index(VALUE self)
+{
+	RB_GIT_REPO_OWNED_GET(rb_cRuggedIndex, index);
+}
+
+/*
+ *  call-seq:
+ *    repo.config = cfg
+ *
+ *  Set the configuration file for this +Repository+. +cfg+ must be a instance of
+ *  Rugged::Config. This config file will be used internally by all
+ *  operations that need to lookup configuration settings on +repo+.
+ *
+ *  Note that it's not necessary to set the +config+ for any repository;
+ *  by default repositories are loaded with their relevant config files
+ *  on the filesystem, and the corresponding global and system files if
+ *  they can be found.
+ */
+static VALUE rb_git_repo_set_config(VALUE self, VALUE rb_data)
+{
+	RB_GIT_REPO_OWNED_SET(rb_cRuggedConfig, config);
+}
+
+/*
+ *  call-seq:
+ *    repo.config -> cfg
+ *
+ *  Return a Rugged::Config object representing this repository's config.
+ */
+static VALUE rb_git_repo_get_config(VALUE self)
+{
+	RB_GIT_REPO_OWNED_GET(rb_cRuggedConfig, config);
+}
+
+/*
+ *  call-seq:
+ *    repo.ident = ident
+ *
+ *  Set the identity to be used for writing reflogs.
+ *
+ *  +ident+ can be either +nil+ or a Hash containing +name+ and/or +email+ entries.
+ */
+static VALUE rb_git_repo_set_ident(VALUE self, VALUE rb_ident) {
+	VALUE rb_val;
+
+	git_repository *repo;
+	const char *name = NULL, *email = NULL;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	if (!NIL_P(rb_ident)) {
+		Check_Type(rb_ident, T_HASH);
+
+		if (!NIL_P(rb_val = rb_hash_aref(rb_ident, CSTR2SYM("name")))) {
+			Check_Type(rb_val, T_STRING);
+			name = StringValueCStr(rb_val);
+		}
+
+		if (!NIL_P(rb_val = rb_hash_aref(rb_ident, CSTR2SYM("email")))) {
+			Check_Type(rb_val, T_STRING);
+			email = StringValueCStr(rb_val);
+		}
+	}
+
+	rugged_exception_check(
+		git_repository_set_ident(repo, name, email)
+	);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.ident -> ident
+ *
+ *  Return a Hash containing the identity that is used to write reflogs.
+ *
+ *  +ident+ is a Hash containing +name+ and/or +email+ entries, or `nil`.
+ */
+static VALUE rb_git_repo_get_ident(VALUE self)
+{
+	VALUE rb_ident = rb_hash_new();
+
+	git_repository *repo;
+	const char *name = NULL, *email = NULL;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	rugged_exception_check(
+		git_repository_ident(&name, &email, repo)
+	);
+
+	if (name) {
+		rb_hash_aset(rb_ident, CSTR2SYM("name"), rb_str_new_utf8(name));
+	}
+
+	if (email) {
+		rb_hash_aset(rb_ident, CSTR2SYM("email"), rb_str_new_utf8(email));
+	}
+
+	return rb_ident;
+}
+
+/*
+ *  call-seq:
+ *    repo.merge_base(oid1, oid2, ...)
+ *    repo.merge_base(ref1, ref2, ...)
+ *    repo.merge_base(commit1, commit2, ...)
+ *
+ *  Find a merge base, given two or more commits or oids.
+ *  Returns nil if a merge base is not found.
+ */
+static VALUE rb_git_repo_merge_base(VALUE self, VALUE rb_args)
+{
+	int error = GIT_OK, i;
+	git_repository *repo;
+	git_oid base, *input_array = xmalloc(sizeof(git_oid) * RARRAY_LEN(rb_args));
+	int len = (int)RARRAY_LEN(rb_args);
+
+	if (len < 2)
+		rb_raise(rb_eArgError, "wrong number of arguments (%d for 2+)", len);
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	for (i = 0; !error && i < len; ++i) {
+		error = rugged_oid_get(&input_array[i], repo, rb_ary_entry(rb_args, i));
+	}
+
+	if (error) {
+		xfree(input_array);
+		rugged_exception_check(error);
+	}
+
+	error = git_merge_base_many(&base, repo, len, input_array);
+	xfree(input_array);
+
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&base);
+}
+
+/*
+ *  call-seq:
+ *    repo.merge_bases(oid1, oid2, ...) -> Array
+ *    repo.merge_bases(ref1, ref2, ...) -> Array
+ *    repo.merge_bases(commit1, commit2, ...) -> Array
+ *
+ *  Find all merge bases, given two or more commits or oids.
+ *  Returns an empty array if no merge bases are found.
+ */
+static VALUE rb_git_repo_merge_bases(VALUE self, VALUE rb_args)
+{
+	int error = GIT_OK;
+	size_t i, len = (size_t)RARRAY_LEN(rb_args);
+	git_repository *repo;
+	git_oidarray bases = {NULL, 0};
+	git_oid *input_array;
+
+	VALUE rb_bases;
+
+	if (len < 2)
+		rb_raise(rb_eArgError, "wrong number of arguments (%ld for 2+)", RARRAY_LEN(rb_args));
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	input_array = xmalloc(sizeof(git_oid) * len);
+
+	for (i = 0; !error && i < len; ++i) {
+		error = rugged_oid_get(&input_array[i], repo, rb_ary_entry(rb_args, i));
+	}
+
+	if (error) {
+		xfree(input_array);
+		rugged_exception_check(error);
+	}
+
+	error = git_merge_bases_many(&bases, repo, len, input_array);
+	xfree(input_array);
+
+	if (error != GIT_ENOTFOUND)
+		rugged_exception_check(error);
+
+	rb_bases = rb_ary_new2(bases.count);
+
+	for (i = 0; i < bases.count; ++i) {
+		rb_ary_push(rb_bases, rugged_create_oid(&bases.ids[i]));
+	}
+
+	git_oidarray_free(&bases);
+
+	return rb_bases;
+}
+
+/*
+ *  call-seq:
+ *    repo.merge_analysis(their_commit) -> Array
+ *
+ *  Analyzes the given commit and determines the opportunities for merging
+ *  it into the repository's HEAD. Returns an Array containing a combination
+ *  of the following symbols:
+ *
+ *  :normal ::
+ *    A "normal" merge is possible, both HEAD and the given commit have
+ *    diverged from their common ancestor. The divergent commits must be
+ *    merged.
+ *
+ *  :up_to_date ::
+ *    The given commit is reachable from HEAD, meaning HEAD is up-to-date
+ *    and no merge needs to be performed.
+ *
+ *  :fastforward ::
+ *    The given commit is a fast-forward from HEAD and no merge needs to be
+ *    performed. HEAD can simply be set to the given commit.
+ *
+ *  :unborn ::
+ *    The HEAD of the current repository is "unborn" and does not point to
+ *    a valid commit. No merge can be performed, but the caller may wish
+ *    to simply set HEAD to the given commit.
+ */
+static VALUE rb_git_repo_merge_analysis(int argc, VALUE *argv, VALUE self)
+{
+	int error;
+	git_repository *repo;
+	git_commit *their_commit;
+	git_annotated_commit *annotated_commit;
+	git_merge_analysis_t analysis;
+	git_merge_preference_t preference;
+	VALUE rb_their_commit, result;
+
+	rb_scan_args(argc, argv, "10", &rb_their_commit);
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	if (TYPE(rb_their_commit) == T_STRING) {
+		rb_their_commit = rugged_object_rev_parse(self, rb_their_commit, 1);
+	}
+
+	if (!rb_obj_is_kind_of(rb_their_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+
+	Data_Get_Struct(rb_their_commit, git_commit, their_commit);
+
+	error = git_annotated_commit_lookup(&annotated_commit, repo, git_commit_id(their_commit));
+	rugged_exception_check(error);
+
+	error = git_merge_analysis(&analysis, &preference, repo,
+				   /* hack as we currently only do one commit */
+				   (const git_annotated_commit **) &annotated_commit, 1);
+	git_annotated_commit_free(annotated_commit);
+	rugged_exception_check(error);
+
+	result = rb_ary_new();
+	if (analysis & GIT_MERGE_ANALYSIS_NORMAL)
+		rb_ary_push(result, CSTR2SYM("normal"));
+	if (analysis & GIT_MERGE_ANALYSIS_UP_TO_DATE)
+		rb_ary_push(result, CSTR2SYM("up_to_date"));
+	if (analysis & GIT_MERGE_ANALYSIS_FASTFORWARD)
+		rb_ary_push(result, CSTR2SYM("fastforward"));
+	if (analysis & GIT_MERGE_ANALYSIS_UNBORN)
+		rb_ary_push(result, CSTR2SYM("unborn"));
+
+	return result;
+}
+
+/*
+ *  call-seq:
+ *    repo.revert_commit(revert_commit, our_commit, options = {}) -> index
+ *    
+ *	Reverts the given commit against the given "our" commit, producing an
+ *	index that reflects the result of the revert.
+ */
+static VALUE rb_git_repo_revert_commit(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_revert_commit, rb_our_commit, rb_options;
+	git_commit *revert_commit, *our_commit;
+	git_index *index;
+	git_repository *repo;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
+	unsigned int mainline = 0;
+	int error;
+
+	rb_scan_args(argc, argv, "20:", &rb_revert_commit, &rb_our_commit, &rb_options);
+
+	if (TYPE(rb_revert_commit) == T_STRING)
+		rb_revert_commit = rugged_object_rev_parse(self, rb_revert_commit, 1);
+
+	if (TYPE(rb_our_commit) == T_STRING)
+		rb_our_commit = rugged_object_rev_parse(self, rb_our_commit, 1);
+
+	if (!rb_obj_is_kind_of(rb_revert_commit, rb_cRuggedCommit) ||
+		!rb_obj_is_kind_of(rb_our_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+
+	if (!NIL_P(rb_options)) {
+		VALUE rb_mainline;
+
+		Check_Type(rb_options, T_HASH);
+		rugged_parse_merge_options(&opts, rb_options);
+
+		rb_mainline = rb_hash_aref(rb_options, CSTR2SYM("mainline"));
+		if (!NIL_P(rb_mainline)) {
+			Check_Type(rb_mainline, T_FIXNUM);
+			mainline = FIX2UINT(rb_mainline);
+		}
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+	Data_Get_Struct(rb_revert_commit, git_commit, revert_commit);
+	Data_Get_Struct(rb_our_commit, git_commit, our_commit);
+
+	error = git_revert_commit(&index, repo, revert_commit, our_commit, mainline, &opts);
+	if (error == GIT_EMERGECONFLICT)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	return rugged_index_new(rb_cRuggedIndex, self, index);
+}
+
+/*
+ *  call-seq:
+ *    repo.merge_commits(our_commit, their_commit, options = {}) -> index
+ *
+ *  Merges the two given commits, returning a Rugged::Index that reflects
+ *  the result of the merge.
+ *
+ *  +our_commit+ and +their_commit+ can either be Rugged::Commit objects,
+ *  or OIDs resolving to the former.
+ */
+static VALUE rb_git_repo_merge_commits(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_our_commit, rb_their_commit, rb_options;
+	git_commit *our_commit, *their_commit;
+	git_index *index;
+	git_repository *repo;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
+	int error;
+
+	rb_scan_args(argc, argv, "20:", &rb_our_commit, &rb_their_commit, &rb_options);
+
+	if (TYPE(rb_our_commit) == T_STRING) {
+		rb_our_commit = rugged_object_rev_parse(self, rb_our_commit, 1);
+	}
+
+	if (!rb_obj_is_kind_of(rb_our_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+
+	if (TYPE(rb_their_commit) == T_STRING) {
+		rb_their_commit = rugged_object_rev_parse(self, rb_their_commit, 1);
+	}
+
+	if (!rb_obj_is_kind_of(rb_their_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+
+	if (!NIL_P(rb_options)) {
+		Check_Type(rb_options, T_HASH);
+		rugged_parse_merge_options(&opts, rb_options);
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+	Data_Get_Struct(rb_our_commit, git_commit, our_commit);
+	Data_Get_Struct(rb_their_commit, git_commit, their_commit);
+
+	error = git_merge_commits(&index, repo, our_commit, their_commit, &opts);
+	if (error == GIT_EMERGECONFLICT)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	return rugged_index_new(rb_cRuggedIndex, self, index);
+}
+
+/*
+ *  call-seq:
+ *    repo.include?(oid) -> true or false
+ *    repo.exists?(oid) -> true or false
+ *
+ *  Return whether an object with the given SHA1 OID (represented as
+ *  a hex string of at least 7 characters) exists in the repository.
+ *
+ *    repo.include?("d8786bfc97485e8d7b19b21fb88c8ef1f199fc3f") #=> true
+ *    repo.include?("d8786bfc") #=> true
+ */
+static VALUE rb_git_repo_exists(VALUE self, VALUE hex)
+{
+	git_repository *repo;
+	git_odb *odb;
+	git_oid oid;
+	int error;
+
+	Data_Get_Struct(self, git_repository, repo);
+	Check_Type(hex, T_STRING);
+
+	error = git_oid_fromstrn(&oid, RSTRING_PTR(hex), RSTRING_LEN(hex));
+	rugged_exception_check(error);
+
+	error = git_repository_odb(&odb, repo);
+	rugged_exception_check(error);
+
+	error = git_odb_exists_prefix(NULL, odb, &oid, RSTRING_LEN(hex));
+	git_odb_free(odb);
+
+	if (error == 0 || error == GIT_EAMBIGUOUS)
+		return Qtrue;
+
+	return Qfalse;
+}
+
+/*
+ *  call-seq:
+ *    repo.read(oid) -> str
+ *
+ *  Read and return the raw data of the object identified by the given +oid+.
+ */
+static VALUE rb_git_repo_read(VALUE self, VALUE hex)
+{
+	git_repository *repo;
+	git_oid oid;
+	int error;
+
+	Data_Get_Struct(self, git_repository, repo);
+	Check_Type(hex, T_STRING);
+
+	error = git_oid_fromstr(&oid, StringValueCStr(hex));
+	rugged_exception_check(error);
+
+	return rugged_raw_read(repo, &oid);
+}
+
+/*
+ *  call-seq:
+ *    repo.read_header(oid) -> hash
+ *
+ *  Read and return the header information in +repo+'s ODB
+ *  for the object identified by the given +oid+.
+ *
+ *  Returns a Hash object with the following key/value pairs:
+ *
+ *  :type ::
+ *    A Symbol denoting the object's type. Possible values are:
+ *    +:tree+, +:blob+, +:commit+ or +:tag+.
+ *  :len ::
+ *    A Number representing the object's length, in bytes.
+ */
+static VALUE rb_git_repo_read_header(VALUE self, VALUE hex)
+{
+	git_repository *repo;
+	git_oid oid;
+	git_odb *odb;
+	git_otype type;
+	size_t len;
+	VALUE rb_hash;
+	int error;
+
+	Data_Get_Struct(self, git_repository, repo);
+	Check_Type(hex, T_STRING);
+
+	error = git_oid_fromstr(&oid, StringValueCStr(hex));
+	rugged_exception_check(error);
+
+	error = git_repository_odb(&odb, repo);
+	rugged_exception_check(error);
+
+	error = git_odb_read_header(&len, &type, odb, &oid);
+	git_odb_free(odb);
+	rugged_exception_check(error);
+
+	rb_hash = rb_hash_new();
+	rb_hash_aset(rb_hash, CSTR2SYM("type"), CSTR2SYM(git_object_type2string(type)));
+	rb_hash_aset(rb_hash, CSTR2SYM("len"), INT2FIX(len));
+
+	return rb_hash;
+}
+
+/**
+ *  call-seq:
+ *    repo.expand_oids([oid..], object_type = :any) -> hash
+ *
+ *  Expand a list of short oids to their full value, assuming they exist
+ *  in the repository. If `object_type` is passed, OIDs are expected to be
+ *  of the given type.
+ *
+ *  Returns a hash of `{ short_oid => full_oid }` for the short OIDs which
+ *  exist in the repository and match the expected object type. Missing OIDs
+ *  will not appear in the resulting hash.
+ */
+static VALUE rb_git_repo_expand_oids(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_result, rb_oids, rb_expected_type;
+
+	git_otype expected_type = GIT_OBJ_ANY;
+
+	git_repository *repo;
+	git_oid oid;
+	git_odb *odb;
+	int i, error;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	rb_scan_args(argc, argv, "11", &rb_oids, &rb_expected_type);
+
+	Check_Type(rb_oids, T_ARRAY);
+	expected_type = rugged_otype_get(rb_expected_type);
+
+	error = git_repository_odb(&odb, repo);
+	rugged_exception_check(error);
+
+	rb_result = rb_hash_new();
+
+	for (i = 0; i < RARRAY_LEN(rb_oids); ++i) {
+		VALUE hex_oid = rb_ary_entry(rb_oids, i);
+		git_oid found_oid;
+
+		if (TYPE(hex_oid) != T_STRING) {
+			git_odb_free(odb);
+			rb_raise(rb_eTypeError, "Expected a SHA1 OID");
+		}
+
+		error = git_oid_fromstrn(&oid, RSTRING_PTR(hex_oid), RSTRING_LEN(hex_oid));
+		if (error < 0) {
+			git_odb_free(odb);
+			rugged_exception_check(error);
+		}
+
+		error = git_odb_exists_prefix(&found_oid, odb, &oid, RSTRING_LEN(hex_oid));
+
+		if (!error) {
+			if (expected_type != GIT_OBJ_ANY) {
+				size_t found_size;
+				git_otype found_type;
+
+				if (git_odb_read_header(&found_size, &found_type, odb, &found_oid) < 0)
+					continue;
+
+				if (found_type != expected_type)
+					continue;
+			}
+
+			rb_hash_aset(rb_result, hex_oid, rugged_create_oid(&found_oid));
+		}
+	}
+
+	git_odb_free(odb);
+	return rb_result;
+}
+
+/*
+ *  call-seq:
+ *    repo.descendant_of?(commit, ancestor) -> true or false
+ *
+ *  +commit+ and +ancestor+ must be String commit OIDs or instances of Rugged::Commit.
+ *
+ *  Returns true if +commit+ is a descendant of +ancestor+, or false if not.
+ */
+static VALUE rb_git_repo_descendant_of(VALUE self, VALUE rb_commit, VALUE rb_ancestor)
+{
+	int result;
+	int error;
+	git_repository *repo;
+	git_oid commit, ancestor;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	error = rugged_oid_get(&commit, repo, rb_commit);
+	rugged_exception_check(error);
+
+	error = rugged_oid_get(&ancestor, repo, rb_ancestor);
+	rugged_exception_check(error);
+
+	result = git_graph_descendant_of(repo, &commit, &ancestor);
+	rugged_exception_check(result);
+
+	return result ? Qtrue : Qfalse;
+}
+
+/*
+ *  call-seq:
+ *    Repository.hash_data(str, type) -> oid
+ *
+ *  Hash the contents of +str+ as raw bytes (ignoring any encoding
+ *  information) and adding the relevant header corresponding to +type+,
+ *  and return a hex string representing the result from the hash.
+ *
+ *    Repository.hash_data('hello world', :commit) #=> "de5ba987198bcf2518885f0fc1350e5172cded78"
+ *
+ *    Repository.hash_data('hello_world', :tag) #=> "9d09060c850defbc7711d08b57def0d14e742f4e"
+ */
+static VALUE rb_git_repo_hash(VALUE self, VALUE rb_buffer, VALUE rb_type)
+{
+	int error;
+	git_oid oid;
+
+	Check_Type(rb_buffer, T_STRING);
+
+	error = git_odb_hash(&oid,
+		RSTRING_PTR(rb_buffer),
+		RSTRING_LEN(rb_buffer),
+		rugged_otype_get(rb_type)
+	);
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&oid);
+}
+
+/*
+ *  call-seq:
+ *    Repository.hash_file(path, type) -> oid
+ *
+ *  Hash the contents of the file pointed at by +path+, assuming
+ *  that it'd be stored in the ODB with the given +type+, and return
+ *  a hex string representing the SHA1 OID resulting from the hash.
+ *
+ *    Repository.hash_file('foo.txt', :commit) #=> "de5ba987198bcf2518885f0fc1350e5172cded78"
+ *
+ *    Repository.hash_file('foo.txt', :tag) #=> "9d09060c850defbc7711d08b57def0d14e742f4e"
+ */
+static VALUE rb_git_repo_hashfile(VALUE self, VALUE rb_path, VALUE rb_type)
+{
+	int error;
+	git_oid oid;
+
+	Check_Type(rb_path, T_STRING);
+
+	error = git_odb_hashfile(&oid,
+		StringValueCStr(rb_path),
+		rugged_otype_get(rb_type)
+	);
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&oid);
+}
+
+/*
+ *  call-seq:
+ *    repo.write(buffer, type) -> oid
+ *
+ *  Write the data contained in the +buffer+ string as a raw object of the
+ *  given +type+ into the repository's object database.
+ *
+ *  +type+ can be either +:tag+, +:commit+, +:tree+ or +:blob+.
+ *
+ *  Returns the newly created object's oid.
+ */
+static VALUE rb_git_repo_write(VALUE self, VALUE rb_buffer, VALUE rub_type)
+{
+	git_repository *repo;
+	git_odb_stream *stream;
+
+	git_odb *odb;
+	git_oid oid;
+	int error;
+
+	git_otype type;
+
+	Data_Get_Struct(self, git_repository, repo);
+	Check_Type(rb_buffer, T_STRING);
+
+	error = git_repository_odb(&odb, repo);
+	rugged_exception_check(error);
+
+	type = rugged_otype_get(rub_type);
+
+	error = git_odb_open_wstream(&stream, odb, RSTRING_LEN(rb_buffer), type);
+	git_odb_free(odb);
+	rugged_exception_check(error);
+
+	error = git_odb_stream_write(stream, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
+	if (!error)
+		error = git_odb_stream_finalize_write(&oid, stream);
+
+	git_odb_stream_free(stream);
+	rugged_exception_check(error);
+
+	return rugged_create_oid(&oid);
+}
+
+#define RB_GIT_REPO_GETTER(method) \
+	git_repository *repo; \
+	int error; \
+	Data_Get_Struct(self, git_repository, repo); \
+	error = git_repository_##method(repo); \
+	rugged_exception_check(error); \
+	return error ? Qtrue : Qfalse; \
+
+/*
+ *  call-seq:
+ *    repo.bare? -> true or false
+ *
+ *  Return whether a repository is bare or not. A bare repository has no
+ *  working directory.
+ */
+static VALUE rb_git_repo_is_bare(VALUE self)
+{
+	RB_GIT_REPO_GETTER(is_bare);
+}
+
+/*
+ *  call-seq:
+ *    repo.shallow? -> true or false
+ *
+ *  Return whether a repository is a shallow clone or not. A shallow clone has
+ *  a truncated history and can not be cloned or fetched from, nor can be
+ *  pushed from nor into it.
+ */
+static VALUE rb_git_repo_is_shallow(VALUE self)
+{
+	RB_GIT_REPO_GETTER(is_shallow);
+}
+
+/*
+ *  call-seq:
+ *    repo.empty? -> true or false
+ *
+ *  Return whether a repository is empty or not. An empty repository has just
+ *  been initialized and has no commits yet.
+ */
+static VALUE rb_git_repo_is_empty(VALUE self)
+{
+	RB_GIT_REPO_GETTER(is_empty);
+}
+
+/*
+ *  call-seq:
+ *    repo.head_detached? -> true or false
+ *
+ *  Return whether the +HEAD+ of a repository is detached or not.
+ */
+static VALUE rb_git_repo_head_detached(VALUE self)
+{
+	RB_GIT_REPO_GETTER(head_detached);
+}
+
+/*
+ *  call-seq:
+ *    repo.head_unborn? -> true or false
+ *
+ *  Return whether the current branch is unborn (+HEAD+ points to a
+ *  non-existent branch).
+ */
+static VALUE rb_git_repo_head_unborn(VALUE self)
+{
+	RB_GIT_REPO_GETTER(head_unborn);
+}
+
+/*
+ *  call-seq:
+ *    repo.head = str
+ *
+ *  Make the repository's +HEAD+ point to the specified reference.
+ */
+static VALUE rb_git_repo_set_head(VALUE self, VALUE rb_head)
+{
+	git_repository *repo;
+	int error;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	Check_Type(rb_head, T_STRING);
+	error = git_repository_set_head(repo, StringValueCStr(rb_head));
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.head -> ref
+ *
+ *  Retrieve and resolve the reference pointed at by the repository's +HEAD+.
+ *
+ *  Returns +nil+ if +HEAD+ is missing.
+ */
+static VALUE rb_git_repo_get_head(VALUE self)
+{
+	git_repository *repo;
+	git_reference *head;
+	int error;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	error = git_repository_head(&head, repo);
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+	else
+		rugged_exception_check(error);
+
+	return rugged_ref_new(rb_cRuggedReference, self, head);
+}
+
+/*
+ *  call-seq:
+ *    repo.path -> path
+ *
+ *  Return the full, normalized path to this repository. For non-bare repositories,
+ *  this is the path of the actual +.git+ folder, not the working directory.
+ *
+ *    repo.path #=> "/home/foo/workthing/.git"
+ */
+static VALUE rb_git_repo_path(VALUE self)
+{
+	git_repository *repo;
+	const char *path;
+
+	Data_Get_Struct(self, git_repository, repo);
+	path = git_repository_path(repo);
+
+	return path ? rb_str_new_utf8(path) : Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.workdir -> path or nil
+ *
+ *  Return the working directory for this repository, or +nil+ if
+ *  the repository is bare.
+ *
+ *    repo1.bare? #=> false
+ *    repo1.workdir #=> "/home/foo/workthing/"
+ *
+ *    repo2.bare? #=> true
+ *    repo2.workdir #=> nil
+ */
+static VALUE rb_git_repo_workdir(VALUE self)
+{
+	git_repository *repo;
+	const char *workdir;
+
+	Data_Get_Struct(self, git_repository, repo);
+	workdir = git_repository_workdir(repo);
+
+	return workdir ? rb_str_new_utf8(workdir) : Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.workdir = path
+ *
+ *  Sets the working directory of +repo+ to +path+. All internal
+ *  operations on +repo+ that affect the working directory will
+ *  instead use +path+.
+ *
+ *  The +workdir+ can be set on bare repositories to temporarily
+ *  turn them into normal repositories.
+ *
+ *    repo.bare? #=> true
+ *    repo.workdir = "/tmp/workdir"
+ *    repo.bare? #=> false
+ *    repo.checkout
+ */
+static VALUE rb_git_repo_set_workdir(VALUE self, VALUE rb_workdir)
+{
+	git_repository *repo;
+
+	Data_Get_Struct(self, git_repository, repo);
+	Check_Type(rb_workdir, T_STRING);
+
+	rugged_exception_check(
+		git_repository_set_workdir(repo, StringValueCStr(rb_workdir), 0)
+	);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    Repository.discover(path = nil, across_fs = true) -> repository
+ *
+ *  Traverse +path+ upwards until a Git working directory with a +.git+
+ *  folder has been found, open it and return it as a +Repository+
+ *  object.
+ *
+ *  If +path+ is +nil+, the current working directory will be used as
+ *  a starting point.
+ *
+ *  If +across_fs+ is +true+, the traversal won't stop when reaching
+ *  a different device than the one that contained +path+ (only applies
+ *  to UNIX-based OSses).
+ */
+static VALUE rb_git_repo_discover(int argc, VALUE *argv, VALUE klass)
+{
+	git_repository *repo;
+	VALUE rb_path, rb_across_fs;
+	git_buf repository_path = { NULL };
+	int error, across_fs = 0;
+
+	rb_scan_args(argc, argv, "02", &rb_path, &rb_across_fs);
+
+	if (NIL_P(rb_path)) {
+		VALUE rb_dir = rb_const_get(rb_cObject, rb_intern("Dir"));
+		rb_path = rb_funcall(rb_dir, rb_intern("pwd"), 0);
+	}
+
+	if (!NIL_P(rb_across_fs)) {
+		across_fs = rugged_parse_bool(rb_across_fs);
+	}
+
+	Check_Type(rb_path, T_STRING);
+
+	error = git_repository_discover(
+		&repository_path,
+		StringValueCStr(rb_path),
+		across_fs,
+		NULL
+	);
+
+	rugged_exception_check(error);
+
+	error = git_repository_open(&repo, repository_path.ptr);
+	git_buf_free(&repository_path);
+
+	rugged_exception_check(error);
+
+	return rugged_repo_new(klass, repo);
+}
+
+static VALUE flags_to_rb(unsigned int flags)
+{
+	VALUE rb_flags = rb_ary_new();
+
+	if (flags & GIT_STATUS_INDEX_NEW)
+		rb_ary_push(rb_flags, CSTR2SYM("index_new"));
+
+	if (flags & GIT_STATUS_INDEX_MODIFIED)
+		rb_ary_push(rb_flags, CSTR2SYM("index_modified"));
+
+	if (flags & GIT_STATUS_INDEX_DELETED)
+		rb_ary_push(rb_flags, CSTR2SYM("index_deleted"));
+
+	if (flags & GIT_STATUS_WT_NEW)
+		rb_ary_push(rb_flags, CSTR2SYM("worktree_new"));
+
+	if (flags & GIT_STATUS_WT_MODIFIED)
+		rb_ary_push(rb_flags, CSTR2SYM("worktree_modified"));
+
+	if (flags & GIT_STATUS_WT_DELETED)
+		rb_ary_push(rb_flags, CSTR2SYM("worktree_deleted"));
+
+	if (flags & GIT_STATUS_IGNORED)
+		rb_ary_push(rb_flags, CSTR2SYM("ignored"));
+
+	return rb_flags;
+}
+
+static int rugged__status_cb(const char *path, unsigned int flags, void *payload)
+{
+	rb_funcall((VALUE)payload, rb_intern("call"), 2,
+		rb_str_new_utf8(path), flags_to_rb(flags)
+	);
+
+	return GIT_OK;
+}
+
+/*
+ *  call-seq:
+ *    repo.status { |file, status_data| block }
+ *    repo.status(path) -> status_data
+ *
+ *  Returns the status for one or more files in the working directory
+ *  of the repository. This is equivalent to the +git status+ command.
+ *
+ *  The returned +status_data+ is always an array containing one or more
+ *  status flags as Ruby symbols. Possible flags are:
+ *
+ *  - +:index_new+: the file is new in the index
+ *  - +:index_modified+: the file has been modified in the index
+ *  - +:index_deleted+: the file has been deleted from the index
+ *  - +:worktree_new+: the file is new in the working directory
+ *  - +:worktree_modified+: the file has been modified in the working directory
+ *  - +:worktree_deleted+: the file has been deleted from the working directory
+ *
+ *  If a +block+ is given, status information will be gathered for every
+ *  single file on the working dir. The +block+ will be called with the
+ *  status data for each file.
+ *
+ *    repo.status { |file, status_data| puts "#{file} has status: #{status_data.inspect}" }
+ *
+ *  results in, for example:
+ *
+ *    src/diff.c has status: [:index_new, :worktree_new]
+ *    README has status: [:worktree_modified]
+ *
+ *  If a +path+ is given instead, the function will return the +status_data+ for
+ *  the file pointed to by path, or raise an exception if the path doesn't exist.
+ *
+ *  +path+ must be relative to the repository's working directory.
+ *
+ *    repo.status('src/diff.c') #=> [:index_new, :worktree_new]
+ */
+static VALUE rb_git_repo_status(int argc, VALUE *argv, VALUE self)
+{
+	int error;
+	VALUE rb_path;
+	git_repository *repo;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	if (rb_scan_args(argc, argv, "01", &rb_path) == 1) {
+		unsigned int flags;
+		Check_Type(rb_path, T_STRING);
+		error = git_status_file(&flags, repo, StringValueCStr(rb_path));
+		rugged_exception_check(error);
+
+		return flags_to_rb(flags);
+	}
+
+	if (!rb_block_given_p())
+		rb_raise(rb_eRuntimeError,
+			"A block was expected for iterating through "
+			"the repository contents.");
+
+	error = git_status_foreach(
+		repo,
+		&rugged__status_cb,
+		(void *)rb_block_proc()
+	);
+
+	rugged_exception_check(error);
+	return Qnil;
+}
+
+static int rugged__each_id_cb(const git_oid *id, void *payload)
+{
+	int *exception = (int *)payload;
+	rb_protect(rb_yield, rugged_create_oid(id), exception);
+	return *exception ? GIT_ERROR : GIT_OK;
+}
+
+/*
+ *  call-seq:
+ *    repo.each_id { |id| block }
+ *    repo.each_id -> Iterator
+ *
+ *  Call the given +block+ once with every object ID found in +repo+
+ *  and all its alternates. Object IDs are passed as 40-character
+ *  strings.
+ */
+static VALUE rb_git_repo_each_id(VALUE self)
+{
+	git_repository *repo;
+	git_odb *odb;
+	int error, exception = 0;
+
+	if (!rb_block_given_p())
+		return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("each_id"));
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	error = git_repository_odb(&odb, repo);
+	rugged_exception_check(error);
+
+	error = git_odb_foreach(odb, &rugged__each_id_cb, &exception);
+	git_odb_free(odb);
+
+	if (exception)
+		rb_jump_tag(exception);
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+static int parse_reset_type(VALUE rb_reset_type)
+{
+	ID id_reset_type;
+
+	Check_Type(rb_reset_type, T_SYMBOL);
+	id_reset_type = SYM2ID(rb_reset_type);
+
+	if (id_reset_type == rb_intern("soft")) {
+		return GIT_RESET_SOFT;
+	} else if (id_reset_type == rb_intern("mixed")) {
+		return GIT_RESET_MIXED;
+	} else if (id_reset_type == rb_intern("hard")) {
+		return GIT_RESET_HARD;
+	} else {
+		rb_raise(rb_eArgError,
+			"Invalid reset type. Expected `:soft`, `:mixed` or `:hard`");
+	}
+}
+
+/*
+ *  call-seq:
+ *    repo.reset(target, reset_type) -> nil
+ *
+ *  Sets the current head to the specified commit oid and optionally
+ *  resets the index and working tree to match.
+ *  - +target+: Rugged::Commit, Rugged::Tag or rev that resolves to a commit or tag object
+ *  - +reset_type+: +:soft+, +:mixed+ or +:hard+
+ *
+ *  [:soft]
+ *    the head will be moved to the commit.
+ *  [:mixed]
+ *    will trigger a +:soft+ reset, plus the index will be replaced
+ *    with the content of the commit tree.
+ *  [:hard]
+ *    will trigger a +:mixed+ reset and the working directory will be
+ *    replaced with the content of the index. (Untracked and ignored files
+ *    will be left alone)
+ *
+ *  Examples:
+ *
+ *    repo.reset('origin/master', :hard) #=> nil
+ */
+static VALUE rb_git_repo_reset(VALUE self, VALUE rb_target, VALUE rb_reset_type)
+{
+	git_repository *repo;
+	int reset_type;
+	git_object *target = NULL;
+	int error;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	reset_type = parse_reset_type(rb_reset_type);
+	target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY);
+
+	error = git_reset(repo, target, reset_type, NULL);
+
+	git_object_free(target);
+
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.reset_path(pathspecs, target=nil) -> nil
+ *
+ *  Updates entries in the index from the +target+ commit tree, matching
+ *  the given +pathspecs+.
+ *
+ *  Passing a nil +target+ will result in removing
+ *  entries in the index matching the provided pathspecs.
+ *
+ *  - +pathspecs+: list of pathspecs to operate on (+String+ or +Array+ of +String+ objects)
+ *  - +target+(optional): Rugged::Commit, Rugged::Tag or rev that resolves to a commit or tag object.
+ *
+ *  Examples:
+ *    reset_path(File.join('subdir','file.txt'), '441034f860c1d5d90e4188d11ae0d325176869a8') #=> nil
+ */
+static VALUE rb_git_repo_reset_path(int argc, VALUE *argv, VALUE self)
+{
+	git_repository *repo;
+	git_object *target = NULL;
+	git_strarray pathspecs;
+	VALUE rb_target, rb_paths;
+	int error = 0;
+
+	pathspecs.strings = NULL;
+	pathspecs.count = 0;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	rb_scan_args(argc, argv, "11", &rb_paths, &rb_target);
+
+	rugged_rb_ary_to_strarray(rb_paths, &pathspecs);
+
+	if (!NIL_P(rb_target))
+		target = rugged_object_get(repo, rb_target, GIT_OBJ_ANY);
+
+	error = git_reset_default(repo, target, &pathspecs);
+
+	xfree(pathspecs.strings);
+	git_object_free(target);
+
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.close -> nil
+ *
+ *  Frees all the resources used by this repository immediately. The repository can
+ *  still be used after this call. Resources will be opened as necessary.
+ *
+ *  It is not required to call this method explicitly. Repositories are closed
+ *  automatically before garbage collection
+ */
+static VALUE rb_git_repo_close(VALUE self)
+{
+	git_repository *repo;
+	Data_Get_Struct(self, git_repository, repo);
+
+	git_repository__cleanup(repo);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.namespace = new_namespace
+ *
+ *  Sets the active namespace for the repository.
+ *  If set to nil, no namespace will be active.
+ */
+static VALUE rb_git_repo_set_namespace(VALUE self, VALUE rb_namespace)
+{
+	git_repository *repo;
+	int error;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	if (!NIL_P(rb_namespace)) {
+		Check_Type(rb_namespace, T_STRING);
+		error = git_repository_set_namespace(repo, StringValueCStr(rb_namespace));
+	} else {
+		error = git_repository_set_namespace(repo, NULL);
+	}
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.namespace -> str
+ *
+ *  Returns the active namespace for the repository.
+ */
+static VALUE rb_git_repo_get_namespace(VALUE self)
+{
+	git_repository *repo;
+	const char *namespace;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	namespace = git_repository_get_namespace(repo);
+	return namespace ? rb_str_new_utf8(namespace) : Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.ahead_behind(local, upstream) -> Array
+ *
+ *  Returns a 2 element Array containing the number of commits
+ *  that the upstream object is ahead and behind the local object.
+ *
+ *  +local+ and +upstream+ can either be strings containing SHA1 OIDs or
+ *  Rugged::Object instances.
+ */
+static VALUE rb_git_repo_ahead_behind(VALUE self, VALUE rb_local, VALUE rb_upstream) {
+	git_repository *repo;
+	int error;
+	git_oid local, upstream;
+	size_t ahead, behind;
+	VALUE rb_result;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	error = rugged_oid_get(&local, repo, rb_local);
+	rugged_exception_check(error);
+
+	error = rugged_oid_get(&upstream, repo, rb_upstream);
+	rugged_exception_check(error);
+
+	error = git_graph_ahead_behind(&ahead, &behind, repo, &local, &upstream);
+	rugged_exception_check(error);
+
+	rb_result = rb_ary_new2(2);
+	rb_ary_push(rb_result, INT2FIX((int) ahead));
+	rb_ary_push(rb_result, INT2FIX((int) behind));
+	return rb_result;
+}
+
+/*
+ *  call-seq:
+ *    repo.default_signature -> signature or nil
+ *
+ *  Returns a +Hash+ with the default user +signature+ or +nil+.
+ *
+ *  Looks up the +user.name+ and +user.email+ from the configuration and
+ *  uses the current time as the timestamp, and creates a new signature
+ *  based on that information.  It will return +nil+ if either the
+ *  +user.name+ or +user.email+ are not set.
+ *
+ *  Returns a +Hash+:
+ *  - +:name+: the +user.name+ config value
+ *  - +:email+: the +user.email+ config value
+ *  - +:time+: the current time as a +Time+ instance
+ */
+static VALUE rb_git_repo_default_signature(VALUE self) {
+	int error;
+	git_repository *repo;
+	git_signature *signature;
+	VALUE rb_signature;
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	error = git_signature_default(&signature, repo);
+
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	rb_signature = rugged_signature_new(signature, NULL);
+	git_signature_free(signature);
+	return rb_signature;
+}
+
+void rugged__checkout_progress_cb(
+	const char *path,
+	size_t completed_steps,
+	size_t total_steps,
+	void *data
+) {
+	struct rugged_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(4);
+	rb_ary_push(args, payload->rb_data);
+	rb_ary_push(args, path == NULL ? Qnil : rb_str_new2(path));
+	rb_ary_push(args, INT2FIX(completed_steps));
+	rb_ary_push(args, INT2FIX(total_steps));
+
+	rb_protect(rugged__block_yield_splat, args, &payload->exception);
+}
+
+static int rugged__checkout_notify_cb(
+	git_checkout_notify_t why,
+	const char *path,
+	const git_diff_file *baseline,
+	const git_diff_file *target,
+	const git_diff_file *workdir,
+	void *data
+) {
+	struct rugged_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(5);
+	rb_ary_push(args, payload->rb_data);
+
+	switch (why) {
+		case GIT_CHECKOUT_NOTIFY_CONFLICT:
+			rb_ary_push(args, CSTR2SYM("conflict"));
+		break;
+
+		case GIT_CHECKOUT_NOTIFY_DIRTY:
+			rb_ary_push(args, CSTR2SYM("dirty"));
+		break;
+
+		case GIT_CHECKOUT_NOTIFY_UPDATED:
+			rb_ary_push(args, CSTR2SYM("updated"));
+		break;
+
+		case GIT_CHECKOUT_NOTIFY_UNTRACKED:
+			rb_ary_push(args, CSTR2SYM("untracked"));
+		break;
+
+		case GIT_CHECKOUT_NOTIFY_IGNORED:
+			rb_ary_push(args, CSTR2SYM("ignored"));
+		break;
+
+		default:
+			rb_ary_push(args, CSTR2SYM("unknown"));
+	}
+
+	rb_ary_push(args, rb_git_delta_file_fromC(baseline));
+	rb_ary_push(args, rb_git_delta_file_fromC(target));
+	rb_ary_push(args, rb_git_delta_file_fromC(workdir));
+
+	rb_protect(rugged__block_yield_splat, args, &payload->exception);
+
+	return payload->exception ? GIT_ERROR : GIT_OK;
+}
+
+/**
+ * The caller has to free the returned git_checkout_options paths strings array.
+ */
+static void rugged_parse_checkout_options(git_checkout_options *opts, VALUE rb_options)
+{
+	VALUE rb_value;
+
+	if (NIL_P(rb_options))
+		return;
+
+	Check_Type(rb_options, T_HASH);
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("progress"));
+	if (!NIL_P(rb_value)) {
+		struct rugged_cb_payload *payload = malloc(sizeof(struct rugged_cb_payload));
+		payload->rb_data = rb_value;
+		payload->exception = 0;
+
+		opts->progress_payload = payload;
+		opts->progress_cb = &rugged__checkout_progress_cb;
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("notify"));
+	if (!NIL_P(rb_value)) {
+		struct rugged_cb_payload *payload = malloc(sizeof(struct rugged_cb_payload));
+		payload->rb_data = rb_value;
+		payload->exception = 0;
+
+		opts->notify_payload = payload;
+		opts->notify_cb = &rugged__checkout_notify_cb;
+	}
+
+	if (!NIL_P(rb_value = rb_hash_aref(rb_options, CSTR2SYM("strategy")))) {
+		int i;
+
+		rb_value = rb_ary_to_ary(rb_value);
+		for (i = 0; i < RARRAY_LEN(rb_value); ++i) {
+			VALUE rb_strategy = rb_ary_entry(rb_value, i);
+
+			if (rb_strategy == CSTR2SYM("safe")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_SAFE;
+			} else if (rb_strategy == CSTR2SYM("force")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_FORCE;
+			} else if (rb_strategy == CSTR2SYM("recreate_missing")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_RECREATE_MISSING;
+			} else if (rb_strategy == CSTR2SYM("allow_conflicts")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_ALLOW_CONFLICTS;
+			} else if (rb_strategy == CSTR2SYM("remove_untracked")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_REMOVE_UNTRACKED;
+			} else if (rb_strategy == CSTR2SYM("remove_ignored")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_REMOVE_IGNORED;
+			} else if (rb_strategy == CSTR2SYM("update_only")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_UPDATE_ONLY;
+			} else if (rb_strategy == CSTR2SYM("dont_update_index")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_DONT_UPDATE_INDEX;
+			} else if (rb_strategy == CSTR2SYM("no_refresh")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_NO_REFRESH;
+			} else if (rb_strategy == CSTR2SYM("disable_pathspec_match")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_DISABLE_PATHSPEC_MATCH;
+			} else if (rb_strategy == CSTR2SYM("skip_locked_directories")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_SKIP_LOCKED_DIRECTORIES;
+			} else if (rb_strategy == CSTR2SYM("skip_unmerged")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_SKIP_UNMERGED;
+			} else if (rb_strategy == CSTR2SYM("use_ours")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_USE_OURS;
+			} else if (rb_strategy == CSTR2SYM("use_theirs")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_USE_THEIRS;
+			} else if (rb_strategy == CSTR2SYM("update_submodules")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_UPDATE_SUBMODULES;
+			} else if (rb_strategy == CSTR2SYM("update_submodules_if_changed")) {
+				opts->checkout_strategy |= GIT_CHECKOUT_UPDATE_SUBMODULES_IF_CHANGED;
+			} else if (rb_strategy != CSTR2SYM("none")) {
+				rb_raise(rb_eArgError, "Unknown checkout strategy");
+			}
+		}
+	}
+
+	if (!NIL_P(rb_value = rb_hash_aref(rb_options, CSTR2SYM("notify_flags")))) {
+		int i;
+
+		rb_value = rb_ary_to_ary(rb_value);
+		for (i = 0; i < RARRAY_LEN(rb_value); ++i) {
+			VALUE rb_notify_flag = rb_ary_entry(rb_value, i);
+
+			if (rb_notify_flag == CSTR2SYM("conflict")) {
+				opts->notify_flags |= GIT_CHECKOUT_NOTIFY_CONFLICT;
+			} else if (rb_notify_flag == CSTR2SYM("dirty")) {
+				opts->notify_flags |= GIT_CHECKOUT_NOTIFY_DIRTY;
+			} else if (rb_notify_flag == CSTR2SYM("updated")) {
+				opts->notify_flags |= GIT_CHECKOUT_NOTIFY_UPDATED;
+			} else if (rb_notify_flag == CSTR2SYM("untracked")) {
+				opts->notify_flags |= GIT_CHECKOUT_NOTIFY_UNTRACKED;
+			} else if (rb_notify_flag == CSTR2SYM("ignored")) {
+				opts->notify_flags |= GIT_CHECKOUT_NOTIFY_IGNORED;
+			} else if (rb_notify_flag == CSTR2SYM("all")) {
+				opts->notify_flags |= GIT_CHECKOUT_NOTIFY_ALL;
+			} else if (rb_notify_flag != CSTR2SYM("none")) {
+				rb_raise(rb_eArgError, "Unknown checkout notify flag");
+			}
+		}
+	}
+
+	opts->disable_filters = RTEST(rb_hash_aref(rb_options, CSTR2SYM("disable_filters")));
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("dir_mode"));
+	if (!NIL_P(rb_value)) {
+		opts->dir_mode = FIX2UINT(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("file_mode"));
+	if (!NIL_P(rb_value)) {
+		opts->file_mode = FIX2UINT(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("file_open_flags"));
+	if (!NIL_P(rb_value)) {
+		opts->file_mode = FIX2INT(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("target_directory"));
+	if (!NIL_P(rb_value)) {
+		opts->target_directory = StringValueCStr(rb_value);
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("baseline"));
+	if (!NIL_P(rb_value)) {
+		if (rb_obj_is_kind_of(rb_value, rb_cRuggedTree)) {
+			Data_Get_Struct(rb_value, git_tree, opts->baseline);
+		} else {
+			rb_raise(rb_eTypeError, "Expected a Rugged::Tree.");
+		}
+	}
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("paths"));
+	rugged_rb_ary_to_strarray(rb_value, &opts->paths);
+}
+
+/**
+ *  call-seq:
+ *    repo.checkout_tree(treeish[, options])
+ *
+ *  Updates files in the index and working tree to match the content of the
+ *  tree pointed at by the +treeish+.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :progress ::
+ *    A callback that will be executed for checkout progress notifications.
+ *    Up to 3 parameters are passed on each execution:
+ *
+ *    - The path to the last updated file (or +nil+ on the very first invocation).
+ *    - The number of completed checkout steps.
+ *    - The number of total checkout steps to be performed.
+ *
+ *  :notify ::
+ *    A callback that will be executed for each checkout notification types specified
+ *    with +:notify_flags+. Up to 5 parameters are passed on each execution:
+ *
+ *    - An array containing the +:notify_flags+ that caused the callback execution.
+ *    - The path of the current file.
+ *    - A hash describing the baseline blob (or +nil+ if it does not exist).
+ *    - A hash describing the target blob (or +nil+ if it does not exist).
+ *    - A hash describing the workdir blob (or +nil+ if it does not exist).
+ *
+ *  :strategy ::
+ *    A single symbol or an array of symbols representing the strategies to use when
+ *    performing the checkout. Possible values are:
+ *
+ *    :none ::
+ *      Perform a dry run (default).
+ *
+ *    :safe ::
+ *      Allow safe updates that cannot overwrite uncommitted data.
+ *
+ *    :recreate_missing ::
+ *      Allow checkout to recreate missing files.
+ *
+ *    :force ::
+ *      Allow all updates to force working directory to look like index.
+ *
+ *    :allow_conflicts ::
+ *      Allow checkout to make safe updates even if conflicts are found.
+ *
+ *    :remove_untracked ::
+ *      Remove untracked files not in index (that are not ignored).
+ *
+ *    :remove_ignored ::
+ *      Remove ignored files not in index.
+ *
+ *    :update_only ::
+ *      Only update existing files, don't create new ones.
+ *
+ *    :dont_update_index ::
+ *      Normally checkout updates index entries as it goes; this stops that.
+ *
+ *    :no_refresh ::
+ *      Don't refresh index/config/etc before doing checkout.
+ *
+ *    :disable_pathspec_match ::
+ *      Treat pathspec as simple list of exact match file paths.
+ *
+ *    :skip_locked_directories ::
+ *      Ignore directories in use, they will be left empty.
+ *
+ *    :skip_unmerged ::
+ *      Allow checkout to skip unmerged files (NOT IMPLEMENTED).
+ *
+ *    :use_ours ::
+ *      For unmerged files, checkout stage 2 from index (NOT IMPLEMENTED).
+ *
+ *    :use_theirs ::
+ *      For unmerged files, checkout stage 3 from index (NOT IMPLEMENTED).
+ *
+ *    :update_submodules ::
+ *      Recursively checkout submodules with same options (NOT IMPLEMENTED).
+ *
+ *    :update_submodules_if_changed ::
+ *      Recursively checkout submodules if HEAD moved in super repo (NOT IMPLEMENTED).
+ *
+ *  :disable_filters ::
+ *    If +true+, filters like CRLF line conversion will be disabled.
+ *
+ *  :dir_mode ::
+ *    Mode for newly created directories. Default: +0755+.
+ *
+ *  :file_mode ::
+ *    Mode for newly created files. Default: +0755+ or +0644+.
+ *
+ *  :file_open_flags ::
+ *    Mode for opening files. Default: <code>IO::CREAT | IO::TRUNC | IO::WRONLY</code>.
+ *
+ *  :notify_flags ::
+ *    A single symbol or an array of symbols representing the cases in which the +:notify+
+ *    callback should be invoked. Possible values are:
+ *
+ *    :none ::
+ *      Do not invoke the +:notify+ callback (default).
+ *
+ *    :conflict ::
+ *      Invoke the callback for conflicting paths.
+ *
+ *    :dirty ::
+ *      Invoke the callback for "dirty" files, i.e. those that do not need an update but
+ *      no longer match the baseline.
+ *
+ *    :updated ::
+ *      Invoke the callback for any file that was changed.
+ *
+ *    :untracked ::
+ *      Invoke the callback for untracked files.
+ *
+ *    :ignored ::
+ *      Invoke the callback for ignored files.
+ *
+ *    :all ::
+ *      Invoke the callback for all these cases.
+ *
+ *  :paths ::
+ *    A glob string or an array of glob strings specifying which paths should be taken
+ *    into account for the checkout operation. +nil+ will match all files.
+ *    Default: +nil+.
+ *
+ *  :baseline ::
+ *    A Rugged::Tree that represents the current, expected contents of the workdir.
+ *    Default: +HEAD+.
+ *
+ *  :target_directory ::
+ *    A path to an alternative workdir directory in which the checkout should be performed.
+ */
+static VALUE rb_git_checkout_tree(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_treeish, rb_options;
+	git_repository *repo;
+	git_object *treeish;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
+	struct rugged_cb_payload *payload;
+	int error, exception = 0;
+
+	rb_scan_args(argc, argv, "10:", &rb_treeish, &rb_options);
+
+	if (TYPE(rb_treeish) == T_STRING) {
+		rb_treeish = rugged_object_rev_parse(self, rb_treeish, 1);
+	}
+
+	if (!rb_obj_is_kind_of(rb_treeish, rb_cRuggedCommit) &&
+			!rb_obj_is_kind_of(rb_treeish, rb_cRuggedTag) &&
+			!rb_obj_is_kind_of(rb_treeish, rb_cRuggedTree)) {
+		rb_raise(rb_eTypeError, "Expected Rugged::Commit, Rugged::Tag or Rugged::Tree");
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+	Data_Get_Struct(rb_treeish, git_object, treeish);
+
+	rugged_parse_checkout_options(&opts, rb_options);
+
+	error = git_checkout_tree(repo, treeish, &opts);
+	xfree(opts.paths.strings);
+
+	if ((payload = opts.notify_payload) != NULL) {
+		exception = payload->exception;
+		xfree(opts.notify_payload);
+	}
+
+	if ((payload = opts.progress_payload) != NULL) {
+		exception = payload->exception;
+		xfree(opts.progress_payload);
+	}
+
+	if (exception)
+		rb_jump_tag(exception);
+
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/**
+ *  call-seq: repo.checkout_index(index[,options]) -> nil
+ *
+ *  Updates files in the index and the working tree to match the content of the
+ *  commit pointed at by +index+.
+ *
+ *  See Repository#checkout_tree for a list of supported +options+.
+ */
+static VALUE rb_git_checkout_index(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_index, rb_options;
+	git_repository *repo;
+	git_index *index;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
+	struct rugged_cb_payload *payload;
+	int error, exception = 0;
+
+	rb_scan_args(argc, argv, "10:", &rb_index, &rb_options);
+
+	if (!rb_obj_is_kind_of(rb_index, rb_cRuggedIndex))
+		rb_raise(rb_eTypeError, "Expected Rugged::Index");
+
+	Data_Get_Struct(self, git_repository, repo);
+	Data_Get_Struct(rb_index, git_index, index);
+
+	rugged_parse_checkout_options(&opts, rb_options);
+
+	error = git_checkout_index(repo, index, &opts);
+	xfree(opts.paths.strings);
+
+	if ((payload = opts.notify_payload) != NULL) {
+		exception = payload->exception;
+		xfree(opts.notify_payload);
+	}
+
+	if ((payload = opts.progress_payload) != NULL) {
+		exception = payload->exception;
+		xfree(opts.progress_payload);
+	}
+
+	if (exception)
+		rb_jump_tag(exception);
+
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/**
+ *  call-seq: repo.checkout_head([options]) -> nil
+ *
+ *  Updates files in the index and the working tree to match the content of the
+ *  commit pointed at by +HEAD+.
+ *
+ *  See Repository#checkout_tree for a list of supported +options+.
+ */
+static VALUE rb_git_checkout_head(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_options;
+	git_repository *repo;
+	git_checkout_options opts = GIT_CHECKOUT_OPTIONS_INIT;
+	struct rugged_cb_payload *payload;
+	int error, exception = 0;
+
+	rb_scan_args(argc, argv, "00:", &rb_options);
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	rugged_parse_checkout_options(&opts, rb_options);
+
+	error = git_checkout_head(repo, &opts);
+	xfree(opts.paths.strings);
+
+	if ((payload = opts.notify_payload) != NULL) {
+		exception = payload->exception;
+		xfree(opts.notify_payload);
+	}
+
+	if ((payload = opts.progress_payload) != NULL) {
+		exception = payload->exception;
+		xfree(opts.progress_payload);
+	}
+
+	if (exception)
+		rb_jump_tag(exception);
+
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.path_ignored?(path) -> true or false
+ *
+ *  Return whether a path is ignored or not.
+ */
+static VALUE rb_git_repo_is_path_ignored(VALUE self, VALUE rb_path) {
+	git_repository *repo;
+	const char *path;
+	int error;
+	int ignored;
+
+	Data_Get_Struct(self, git_repository, repo);
+	path = StringValueCStr(rb_path);
+	error = git_ignore_path_is_ignored(&ignored, repo, path);
+	rugged_exception_check(error);
+	return ignored ? Qtrue : Qfalse;
+}
+
+static void rugged_parse_cherrypick_options(git_cherrypick_options *opts, VALUE rb_options)
+{
+	VALUE rb_value;
+
+	if (NIL_P(rb_options))
+		return;
+
+	Check_Type(rb_options, T_HASH);
+
+	rb_value = rb_hash_aref(rb_options, CSTR2SYM("mainline"));
+	if (!NIL_P(rb_value)) {
+		opts->mainline = FIX2UINT(rb_value);
+	}
+}
+
+static VALUE rugged_create_attr(const char *attr)
+{
+	switch (git_attr_value(attr)) {
+	case GIT_ATTR_TRUE_T:
+		return Qtrue;
+
+	case GIT_ATTR_FALSE_T:
+		return Qfalse;
+
+	case GIT_ATTR_VALUE_T:
+		return rb_str_new2(attr);
+
+	case GIT_ATTR_UNSPECIFIED_T:
+	default:
+		return Qnil;
+	}
+}
+
+static int foreach_attr_hash(const char *name, const char *value, void *payload)
+{
+	VALUE rb_hash = (VALUE)payload;
+	rb_hash_aset(rb_hash, rb_str_new2(name), rugged_create_attr(value));
+	return 0;
+}
+
+static VALUE rb_git_repo_attributes(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_path, rb_names, rb_options;
+
+	git_repository *repo;
+	int error, options = 0;
+
+	rb_scan_args(argc, argv, "12", &rb_path, &rb_names, &rb_options);
+
+	Data_Get_Struct(self, git_repository, repo);
+	Check_Type(rb_path, T_STRING);
+
+	if (!NIL_P(rb_options)) {
+		Check_Type(rb_options, T_FIXNUM);
+		options = FIX2INT(rb_options);
+	}
+
+	switch (TYPE(rb_names)) {
+	case T_ARRAY:
+	{
+		VALUE rb_result;
+		const char **values;
+		const char **names;
+		long i, num_attr = RARRAY_LEN(rb_names);
+
+		if (num_attr > 32)
+			rb_raise(rb_eRuntimeError, "Too many attributes requested");
+
+		values = alloca(num_attr * sizeof(const char *));
+		names = alloca(num_attr * sizeof(const char *));
+
+		for (i = 0; i < num_attr; ++i) {
+			VALUE attr = rb_ary_entry(rb_names, i);
+			Check_Type(attr, T_STRING);
+			names[i] = StringValueCStr(attr);
+		}
+
+		error = git_attr_get_many(
+			values, repo, options,
+			StringValueCStr(rb_path),
+			(size_t)num_attr, names);
+
+		rugged_exception_check(error);
+
+		rb_result = rb_hash_new();
+		for (i = 0; i < num_attr; ++i) {
+			VALUE attr = rb_ary_entry(rb_names, i);
+			rb_hash_aset(rb_result, attr, rugged_create_attr(values[i]));
+		}
+		return rb_result;
+	}
+
+	case T_STRING:
+	{
+		const char *value;
+
+		error = git_attr_get(
+			&value, repo, options,
+			StringValueCStr(rb_path),
+			StringValueCStr(rb_names));
+
+		rugged_exception_check(error);
+
+		return rugged_create_attr(value);
+	}
+
+	case T_NIL:
+	{
+		VALUE rb_result = rb_hash_new();
+
+		error = git_attr_foreach(
+			repo, options,
+			StringValueCStr(rb_path),
+			&foreach_attr_hash,
+			(void *)rb_result);
+
+		rugged_exception_check(error);
+		return rb_result;
+	}
+
+	default:
+		rb_raise(rb_eTypeError,
+			"Invalid attribute name (expected String or Array)");
+	}
+}
+
+/*
+ *  call-seq:
+ *    repo.cherrypick(commit[, options]) -> nil
+ *
+ *  Cherry-pick the given commit and update the index and working
+ *  directory accordingly.
+ *
+ *  `commit` can be either a string containing a commit id or a
+ *  `Rugged::Commit` object.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :mainline ::
+ *    When cherry-picking a merge, you need to specify the parent number
+ *    (starting from 1) which should be considered the mainline.
+ */
+static VALUE rb_git_repo_cherrypick(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_options, rb_commit;
+
+	git_repository *repo;
+	git_commit *commit;
+	git_cherrypick_options opts = GIT_CHERRYPICK_OPTIONS_INIT;
+
+	int error;
+
+	rb_scan_args(argc, argv, "10:", &rb_commit, &rb_options);
+
+	if (TYPE(rb_commit) == T_STRING) {
+		rb_commit = rugged_object_rev_parse(self, rb_commit, 1);
+	}
+
+	if (!rb_obj_is_kind_of(rb_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+	Data_Get_Struct(rb_commit, git_commit, commit);
+
+	rugged_parse_cherrypick_options(&opts, rb_options);
+
+	error = git_cherrypick(repo, commit, &opts);
+	rugged_exception_check(error);
+
+	return Qnil;
+}
+
+/*
+ *  call-seq:
+ *    repo.cherrypick_commit(commit, our_commit, [mainline, options]) -> nil
+ *
+ *  Cherry-pick the given commit on the given base in-memory and
+ *  return an index with the result.
+ *
+ *  `commit` can be either a string containing a commit id or a
+ *  `Rugged::Commit` object.
+ *
+ *  `our_commit` is the base commit, can be either a string containing
+ *  a commit id or a `Rugged::Commit` object.
+ *
+ *  `mainline` when cherry-picking a merge, this is the parent number
+ *   (starting from 1) which should be considered the mainline.
+ */
+static VALUE rb_git_repo_cherrypick_commit(int argc, VALUE *argv, VALUE self)
+{
+	VALUE rb_options, rb_commit, rb_our_commit, rb_mainline;
+
+	git_repository *repo;
+	git_commit *commit, *our_commit;
+	git_merge_options opts = GIT_MERGE_OPTIONS_INIT;
+	git_index *index;
+	int error, mainline;
+
+	rb_scan_args(argc, argv, "21:", &rb_commit, &rb_our_commit, &rb_mainline, &rb_options);
+
+	if (TYPE(rb_commit) == T_STRING) {
+		rb_commit = rugged_object_rev_parse(self, rb_commit, 1);
+	}
+	if (TYPE(rb_our_commit) == T_STRING) {
+		rb_our_commit = rugged_object_rev_parse(self, rb_our_commit, 1);
+	}
+
+	if (!rb_obj_is_kind_of(rb_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+	if (!rb_obj_is_kind_of(rb_our_commit, rb_cRuggedCommit)) {
+		rb_raise(rb_eArgError, "Expected a Rugged::Commit.");
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+	Data_Get_Struct(rb_commit, git_commit, commit);
+	Data_Get_Struct(rb_our_commit, git_commit, our_commit);
+
+	rugged_parse_merge_options(&opts, rb_options);
+
+	mainline = NIL_P(rb_mainline) ? 0 : FIX2UINT(rb_mainline);
+	error = git_cherrypick_commit(&index, repo, commit, our_commit, mainline, &opts);
+	rugged_exception_check(error);
+
+	return rugged_index_new(rb_cRuggedIndex, self, index);
+}
+
+void Init_rugged_repo(void)
+{
+	id_call = rb_intern("call");
+
+	rb_cRuggedRepo = rb_define_class_under(rb_mRugged, "Repository", rb_cObject);
+
+	rb_define_singleton_method(rb_cRuggedRepo, "new", rb_git_repo_new, -1);
+	rb_define_singleton_method(rb_cRuggedRepo, "bare", rb_git_repo_open_bare, -1);
+	rb_define_singleton_method(rb_cRuggedRepo, "hash_data", rb_git_repo_hash,  2);
+	rb_define_singleton_method(rb_cRuggedRepo, "hash_file", rb_git_repo_hashfile,  2);
+	rb_define_singleton_method(rb_cRuggedRepo, "init_at", rb_git_repo_init_at, -1);
+	rb_define_singleton_method(rb_cRuggedRepo, "discover", rb_git_repo_discover, -1);
+	rb_define_singleton_method(rb_cRuggedRepo, "clone_at", rb_git_repo_clone_at, -1);
+
+	rb_define_method(rb_cRuggedRepo, "close", rb_git_repo_close, 0);
+
+	rb_define_method(rb_cRuggedRepo, "exists?", rb_git_repo_exists, 1);
+	rb_define_method(rb_cRuggedRepo, "include?", rb_git_repo_exists, 1);
+	rb_define_method(rb_cRuggedRepo, "expand_oids", rb_git_repo_expand_oids, -1);
+	rb_define_method(rb_cRuggedRepo, "descendant_of?", rb_git_repo_descendant_of, 2);
+
+	rb_define_method(rb_cRuggedRepo, "read",   rb_git_repo_read,   1);
+	rb_define_method(rb_cRuggedRepo, "read_header",   rb_git_repo_read_header,   1);
+	rb_define_method(rb_cRuggedRepo, "write",  rb_git_repo_write,  2);
+	rb_define_method(rb_cRuggedRepo, "each_id",  rb_git_repo_each_id,  0);
+
+	rb_define_method(rb_cRuggedRepo, "path",  rb_git_repo_path, 0);
+	rb_define_method(rb_cRuggedRepo, "workdir",  rb_git_repo_workdir, 0);
+	rb_define_method(rb_cRuggedRepo, "workdir=",  rb_git_repo_set_workdir, 1);
+	rb_define_method(rb_cRuggedRepo, "status",  rb_git_repo_status,  -1);
+
+	rb_define_method(rb_cRuggedRepo, "index",  rb_git_repo_get_index,  0);
+	rb_define_method(rb_cRuggedRepo, "index=",  rb_git_repo_set_index,  1);
+	rb_define_method(rb_cRuggedRepo, "config",  rb_git_repo_get_config,  0);
+	rb_define_method(rb_cRuggedRepo, "config=",  rb_git_repo_set_config,  1);
+
+	rb_define_method(rb_cRuggedRepo, "ident", rb_git_repo_get_ident, 0);
+	rb_define_method(rb_cRuggedRepo, "ident=", rb_git_repo_set_ident, 1);
+
+	rb_define_method(rb_cRuggedRepo, "bare?",  rb_git_repo_is_bare,  0);
+	rb_define_method(rb_cRuggedRepo, "shallow?",  rb_git_repo_is_shallow,  0);
+	rb_define_method(rb_cRuggedRepo, "empty?",  rb_git_repo_is_empty,  0);
+
+	rb_define_method(rb_cRuggedRepo, "head_detached?",  rb_git_repo_head_detached,  0);
+	rb_define_method(rb_cRuggedRepo, "head_unborn?",  rb_git_repo_head_unborn,  0);
+	rb_define_method(rb_cRuggedRepo, "head=", rb_git_repo_set_head, 1);
+	rb_define_method(rb_cRuggedRepo, "head", rb_git_repo_get_head, 0);
+
+	rb_define_method(rb_cRuggedRepo, "merge_base", rb_git_repo_merge_base, -2);
+	rb_define_method(rb_cRuggedRepo, "merge_bases", rb_git_repo_merge_bases, -2);
+
+	rb_define_method(rb_cRuggedRepo, "merge_analysis", rb_git_repo_merge_analysis, -1);
+	rb_define_method(rb_cRuggedRepo, "merge_commits", rb_git_repo_merge_commits, -1);
+
+	rb_define_method(rb_cRuggedRepo, "revert_commit", rb_git_repo_revert_commit, -1);
+
+	rb_define_method(rb_cRuggedRepo, "path_ignored?", rb_git_repo_is_path_ignored, 1);
+
+	rb_define_method(rb_cRuggedRepo, "reset", rb_git_repo_reset, 2);
+	rb_define_method(rb_cRuggedRepo, "reset_path", rb_git_repo_reset_path, -1);
+
+	rb_define_method(rb_cRuggedRepo, "namespace=", rb_git_repo_set_namespace, 1);
+	rb_define_method(rb_cRuggedRepo, "namespace", rb_git_repo_get_namespace, 0);
+
+	rb_define_method(rb_cRuggedRepo, "ahead_behind", rb_git_repo_ahead_behind, 2);
+
+	rb_define_method(rb_cRuggedRepo, "default_signature", rb_git_repo_default_signature, 0);
+
+	rb_define_method(rb_cRuggedRepo, "checkout_tree", rb_git_checkout_tree, -1);
+	rb_define_method(rb_cRuggedRepo, "checkout_index", rb_git_checkout_index, -1);
+	rb_define_method(rb_cRuggedRepo, "checkout_head", rb_git_checkout_head, -1);
+
+	rb_define_method(rb_cRuggedRepo, "cherrypick", rb_git_repo_cherrypick, -1);
+	rb_define_method(rb_cRuggedRepo, "cherrypick_commit", rb_git_repo_cherrypick_commit, -1);
+	rb_define_method(rb_cRuggedRepo, "fetch_attributes", rb_git_repo_attributes, -1);
+
+	rb_cRuggedOdbObject = rb_define_class_under(rb_mRugged, "OdbObject", rb_cObject);
+	rb_define_method(rb_cRuggedOdbObject, "data",  rb_git_odbobj_data,  0);
+	rb_define_method(rb_cRuggedOdbObject, "len",  rb_git_odbobj_size,  0);
+	rb_define_method(rb_cRuggedOdbObject, "type",  rb_git_odbobj_type,  0);
+	rb_define_method(rb_cRuggedOdbObject, "oid",  rb_git_odbobj_oid,  0);
+}