rugged 0.22.0b5 → 0.22.1b1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 096ce237a96fe39032ff6e26839007148fb90ea8
-  data.tar.gz: 4a8b6154d4ef9c9be73f6c473d8edcd7eede1747
+  metadata.gz: a920e7f6ad886a0730f1b80b91990956469eb3c8
+  data.tar.gz: bc69152690eeea81ab3f2e0749a967de27b3107c
 SHA512:
-  metadata.gz: 340fe46665f934cb4925d9ac63153107e322f06335753c753f09314515658ae8fd50d127084afc22904d9ee6730e9f933b27a9e8043fc8fc7df484ac722cc553
-  data.tar.gz: ce7e75586a31232cda3b5a61c7742ba9a1d5f82b6f9fad14d6da8d346f73e44505195ee8a5d50a444ec04218f25701665133fe0a31b67ec378e5ca877dc2cdbe
+  metadata.gz: f26e34ae5df319b467d5348039255f0d4e1c8d885b6d11ec65511664b1e2a1d468369305dd383ab8084bc8566f12ab95caa2cade4698f9742d0d69ffff338323
+  data.tar.gz: e38f35f6abf4d6f08797c966c7e3a40508b771ed3f29c72e1dac56f4787c981ff9848a25142ff057924a2a53d139f22f33fa84f0b0e4a546951697e0c6917330

data/README.md

@@ -27,7 +27,7 @@ If you want to build Rugged with HTTPS and SSH support, check out the list of op
 If you're using bundler and want to bundle `libgit2` with Rugged, you can use the `:submodules` option:
 
 ```ruby
-gem 'rugged', git: 'git://github.com/libgit2/rugged.git', branch: 'development', submodules: true
+gem 'rugged', git: 'git://github.com/libgit2/rugged.git', submodules: true
 ```
 
 To load Rugged, you'll usually want to add something like this:
@@ -267,11 +267,11 @@ You can also write trees with the `TreeBuilder`:
 
 ```ruby
 oid = repo.write("This is a blob.", :blob)
-builder = Rugged::Tree::Builder.new
+builder = Rugged::Tree::Builder.new(repo)
 builder << { :type => :blob, :name => "README.md", :oid => oid, :filemode => 0100644 }
 
 options = {}
-options[:tree] = builder.write(repo)
+options[:tree] = builder.write
 
 options[:author] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
 options[:committer] = { :email => "testuser@github.com", :name => 'Test Author', :time => Time.now }
@@ -569,6 +569,22 @@ Rugged.raw_to_hex("\277\336Y\315\320\337\254\035\211(\024\366j\225d\032\275\212\
 
 ---
 
+### Alternative backends
+
+You can store bare repositories in alternative backends instead of storing on disk. (see
+`redbadger/rugged-redis` for an example of how a rugged backend works).
+
+```ruby
+a_backend = Rugged::InMemory::Backend.new(opt1: 'setting', opt2: 'setting')
+
+repo = Rugged::Repository.init_at('repo_name', :bare, backend: a_backend)
+
+# or
+
+repo = Rugged::Repository.bare('repo_name', backend: a_backend)
+```
+---
+
 ## Contributing
 
 Fork libgit2/rugged on GitHub, make it awesomer (preferably in a branch named

data/ext/rugged/extconf.rb

@@ -19,15 +19,34 @@ if !(MAKE = find_executable('gmake') || find_executable('make'))
   abort "ERROR: GNU make is required to build Rugged."
 end
 
+CWD = File.expand_path(File.dirname(__FILE__))
+LIBGIT2_DIR = File.join(CWD, '..', '..', 'vendor', 'libgit2')
+
 if arg_config("--use-system-libraries", !!ENV['RUGGED_USE_SYSTEM_LIBRARIES'])
   puts "Building Rugged using system libraries.\n"
 
   dir_config('git2').any? or pkg_config('libgit2')
 
-  try_compile(<<-SRC) or abort "libgit2 version is not compatible"
+  major = minor = nil
+
+  File.readlines(File.join(LIBGIT2_DIR, "include", "git2", "version.h")).each do |line|
+    if !major && (matches = line.match(/^#define LIBGIT2_VER_MAJOR ([0-9]+)$/))
+      major = matches[1]
+      next
+    end
+
+    if !minor && (matches = line.match(/^#define LIBGIT2_VER_MINOR ([0-9]+)$/))
+      minor = matches[1]
+      next
+    end
+
+    break if major && minor
+  end
+
+  try_compile(<<-SRC) or abort "libgit2 version is not compatible, expected ~> #{major}.#{minor}.0"
 #include <git2/version.h>
 
-#if LIBGIT2_SOVERSION != 21
+#if LIBGIT2_VER_MAJOR != #{major} || LIBGIT2_VER_MINOR != #{minor}
 #error libgit2 version is not compatible
 #endif
   SRC
@@ -40,9 +59,6 @@ else
     abort "ERROR: pkg-config is required to build Rugged."
   end
 
-  CWD = File.expand_path(File.dirname(__FILE__))
-  LIBGIT2_DIR = File.join(CWD, '..', '..', 'vendor', 'libgit2')
-
   Dir.chdir(LIBGIT2_DIR) do
     Dir.mkdir("build") if !Dir.exists?("build")
 

data/ext/rugged/rugged.c

@@ -456,6 +456,7 @@ void Init_rugged(void)
 	Init_rugged_diff_line();
 	Init_rugged_blame();
 	Init_rugged_cred();
+	Init_rugged_backend();
 
 	/*
 	 * Sort the repository contents in no particular ordering;

data/ext/rugged/rugged.h

@@ -74,6 +74,7 @@ void Init_rugged_diff_hunk(void);
 void Init_rugged_diff_line(void);
 void Init_rugged_blame(void);
 void Init_rugged_cred(void);
+void Init_rugged_backend(void);
 
 VALUE rb_git_object_init(git_otype type, int argc, VALUE *argv, VALUE self);
 
@@ -153,6 +154,7 @@ struct rugged_remote_cb_payload
 	VALUE transfer_progress;
 	VALUE update_tips;
 	VALUE credentials;
+	VALUE result;
 	int exception;
 };
 
@@ -174,4 +176,10 @@ static inline VALUE rugged_create_oid(const git_oid *oid)
 	return rb_str_new(out, 40);
 }
 
+
+typedef struct _rugged_backend {
+  int (* odb_backend)(git_odb_backend **backend_out, struct _rugged_backend *backend, const char* path);
+  int (* refdb_backend)(git_refdb_backend **backend_out, struct _rugged_backend *backend, const char* path);
+} rugged_backend;
+
 #endif

data/ext/rugged/rugged_backend.c

@@ -0,0 +1,34 @@
+/*
+ * 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"
+
+extern VALUE rb_mRugged;
+
+VALUE rb_cRuggedBackend;
+
+void Init_rugged_backend(void)
+{
+	rb_cRuggedBackend = rb_define_class_under(rb_mRugged, "Backend", rb_cObject);
+}

data/ext/rugged/rugged_branch_collection.c

@@ -235,6 +235,7 @@ static VALUE each_branch(int argc, VALUE *argv, VALUE self, int branch_names_onl
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
 	error = git_branch_iterator_new(&iter, repo, filter);
+	rugged_exception_check(error);
 
 	if (branch_names_only) {
 		git_reference *branch;

data/ext/rugged/rugged_remote.c

@@ -29,7 +29,7 @@ extern VALUE rb_cRuggedRepo;
 extern VALUE rb_eRuggedError;
 VALUE rb_cRuggedRemote;
 
-#define RUGGED_REMOTE_CALLBACKS_INIT {1, progress_cb, NULL, credentials_cb, NULL, transfer_progress_cb, update_tips_cb, NULL}
+#define RUGGED_REMOTE_CALLBACKS_INIT {1, progress_cb, NULL, credentials_cb, NULL, transfer_progress_cb, update_tips_cb, NULL, NULL, push_update_reference_cb, NULL}
 
 static int progress_cb(const char *str, int len, void *data)
 {
@@ -69,6 +69,15 @@ static int transfer_progress_cb(const git_transfer_progress *stats, void *data)
 	return payload->exception ? GIT_ERROR : GIT_OK;
 }
 
+static int push_update_reference_cb(const char *refname, const char *status, void *data) {
+	struct rugged_remote_cb_payload *payload = data;
+
+	if (status != NULL)
+		rb_hash_aset(payload->result, rb_str_new_utf8(refname), rb_str_new_utf8(status));
+
+	return GIT_OK;
+}
+
 static int update_tips_cb(const char *refname, const git_oid *src, const git_oid *dest, void *data)
 {
 	struct rugged_remote_cb_payload *payload = data;
@@ -164,10 +173,12 @@ void rugged_remote_init_callbacks_and_payload_from_options(
 	prefilled.payload = payload;
 	memcpy(callbacks, &prefilled, sizeof(git_remote_callbacks));
 
-	CALLABLE_OR_RAISE(payload->update_tips, rb_options, "update_tips");
-	CALLABLE_OR_RAISE(payload->progress, rb_options, "progress");
-	CALLABLE_OR_RAISE(payload->transfer_progress, rb_options, "transfer_progress");
-	CALLABLE_OR_RAISE(payload->credentials, rb_options, "credentials");
+	if (!NIL_P(rb_options)) {
+		CALLABLE_OR_RAISE(payload->update_tips, rb_options, "update_tips");
+		CALLABLE_OR_RAISE(payload->progress, rb_options, "progress");
+		CALLABLE_OR_RAISE(payload->transfer_progress, rb_options, "transfer_progress");
+		CALLABLE_OR_RAISE(payload->credentials, rb_options, "credentials");
+	}
 }
 
 static void rb_git_remote__free(git_remote *remote)
@@ -237,7 +248,7 @@ static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
 	const git_remote_head **heads;
 
-	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 
 	VALUE rb_options;
 
@@ -251,8 +262,7 @@ static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 	if (!rb_block_given_p())
 		return rb_funcall(self, rb_intern("to_enum"), 2, CSTR2SYM("ls"), rb_options);
 
-	if (!NIL_P(rb_options))
-		rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
 
 	if ((error = git_remote_set_callbacks(remote, &callbacks)) ||
 	    (error = git_remote_connect(remote, GIT_DIRECTION_FETCH)) ||
@@ -527,7 +537,7 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
 {
 	git_remote *remote;
 	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
-	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 	VALUE rb_direction, rb_options;
 	ID id_direction;
 	int error, direction;
@@ -544,8 +554,7 @@ static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
 	else
 		rb_raise(rb_eTypeError, "Invalid direction. Expected :fetch or :push");
 
-	if (!NIL_P(rb_options))
-		rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
 
 	if ((error = git_remote_set_callbacks(remote, &callbacks)) < 0)
 		goto cleanup;
@@ -618,7 +627,7 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 	git_signature *signature = NULL;
 	git_strarray refspecs;
 	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
-	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 
 	char *log_message = NULL;
 	int error;
@@ -633,6 +642,8 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 	rugged_check_repo(rb_repo);
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+
 	if (!NIL_P(rb_options)) {
 		VALUE rb_val = rb_hash_aref(rb_options, CSTR2SYM("signature"));
 		if (!NIL_P(rb_val))
@@ -641,8 +652,6 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 		rb_val = rb_hash_aref(rb_options, CSTR2SYM("message"));
 		if (!NIL_P(rb_val))
 			log_message = StringValueCStr(rb_val);
-
-		rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
 	}
 
 	if ((error = git_remote_set_callbacks(remote, &callbacks)))
@@ -674,15 +683,6 @@ static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 	return rb_result;
 }
 
-static int push_status_cb(const char *ref, const char *msg, void *payload)
-{
-	VALUE rb_result_hash = (VALUE)payload;
-	if (msg != NULL)
-		rb_hash_aset(rb_result_hash, rb_str_new_utf8(ref), rb_str_new_utf8(msg));
-
-	return GIT_OK;
-}
-
 /*
  *  call-seq:
  *    remote.push(refspecs = nil, options = {}) -> hash
@@ -721,36 +721,30 @@ static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 {
 	VALUE rb_refspecs, rb_options, rb_val;
 	VALUE rb_repo = rugged_owner(self);
-	VALUE rb_exception = Qnil, rb_result = rb_hash_new();
 
 	git_repository *repo;
-	git_remote *remote, *tmp_remote = NULL;
+	git_remote *remote;
 	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
-	git_push *push = NULL;
 	git_signature *signature = NULL;
+	git_strarray refspecs;
+	git_push_options opts = GIT_PUSH_OPTIONS_INIT;
 
-	int error = 0, i = 0;
+	int error = 0;
 	char *log_message = NULL;
 
-	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, 0 };
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, rb_hash_new(), 0 };
 
 	rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
 
-	if (!NIL_P(rb_refspecs)) {
-		Check_Type(rb_refspecs, T_ARRAY);
-		for (i = 0; i < RARRAY_LEN(rb_refspecs); ++i) {
-			VALUE rb_refspec = rb_ary_entry(rb_refspecs, i);
-			Check_Type(rb_refspec, T_STRING);
-		}
-	}
+	rugged_rb_ary_to_strarray(rb_refspecs, &refspecs);
 
 	rugged_check_repo(rb_repo);
 	Data_Get_Struct(rb_repo, git_repository, repo);
 	Data_Get_Struct(self, git_remote, remote);
 
-	if (!NIL_P(rb_options)) {
-		rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
 
+	if (!NIL_P(rb_options)) {
 		rb_val = rb_hash_aref(rb_options, CSTR2SYM("message"));
 		if (!NIL_P(rb_val))
 			log_message = StringValueCStr(rb_val);
@@ -760,64 +754,21 @@ static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 			signature = rugged_signature_get(rb_val, repo);
 	}
 
-	// Create a temporary remote that we use for pushing
-	if ((error = git_remote_dup(&tmp_remote, remote)) ||
-	    (error = git_remote_set_callbacks(tmp_remote, &callbacks)))
+	if ((error = git_remote_set_callbacks(remote, &callbacks)))
 	    goto cleanup;
 
-	if (!NIL_P(rb_refspecs)) {
-		git_remote_clear_refspecs(tmp_remote);
-
-		for (i = 0; !error && i < RARRAY_LEN(rb_refspecs); ++i) {
-			VALUE rb_refspec = rb_ary_entry(rb_refspecs, i);
-
-			if ((error = git_remote_add_push(tmp_remote, StringValueCStr(rb_refspec))))
-				goto cleanup;
-		}
-	}
-
-	if ((error = git_push_new(&push, tmp_remote)))
-		goto cleanup;
-
-	// TODO: Get rid of this once git_remote_push lands in libgit2.
-	{
-		git_strarray push_refspecs;
-		size_t i;
-
-		if ((error = git_remote_get_push_refspecs(&push_refspecs, tmp_remote)))
-			goto cleanup;
-
-		if (push_refspecs.count == 0) {
-			rb_exception = rb_exc_new2(rb_eRuggedError, "no pushspecs are configured for the given remote");
-			goto cleanup;
-		}
-
-		for (i = 0; !error && i < push_refspecs.count; ++i) {
-			error = git_push_add_refspec(push, push_refspecs.strings[i]);
-		}
-
-		git_strarray_free(&push_refspecs);
-		if (error) goto cleanup;
-	}
-
-	if ((error = git_push_finish(push)))
-		goto cleanup;
-
-	if ((error = git_push_status_foreach(push, &push_status_cb, (void *)rb_result)) ||
-	    (error = git_push_update_tips(push, signature, log_message)))
-	    goto cleanup;
+	error = git_remote_push(remote, &refspecs, &opts, signature, log_message);
 
 cleanup:
-	git_push_free(push);
-	git_remote_free(tmp_remote);
+	xfree(refspecs.strings);
 	git_signature_free(signature);
 
-	if (!NIL_P(rb_exception))
-		rb_exc_raise(rb_exception);
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
 
 	rugged_exception_check(error);
 
-	return rb_result;
+	return payload.result;
 }
 
 void Init_rugged_remote(void)

data/ext/rugged/rugged_remote_collection.c

@@ -251,7 +251,8 @@ static VALUE rb_git_remote_collection_rename(VALUE self, VALUE rb_name_or_remote
 {
 	VALUE rb_repo = rugged_owner(self);
 	git_repository *repo;
-	int i, error, exception;
+	size_t i;
+	int error, exception;
 	git_strarray problems;
 
 	if (!rb_block_given_p())

data/ext/rugged/rugged_repo.c

@@ -24,6 +24,9 @@
 
 #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;
@@ -35,6 +38,7 @@ 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;
@@ -182,9 +186,78 @@ static void load_alternates(git_repository *repo, VALUE rb_alternates)
 	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) 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) 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, NULL);
+	}
+
+	if (!error) {
+		git_reference_free(head);
+		return;
+	}
+
+cleanup:
+	git_repository_free(*repo);
+	git_odb_free(odb);
+	git_refdb_free(refdb);
+
+	if (odb_backend != NULL) odb_backend->free(odb_backend);
+	if (refdb_backend != NULL) refdb_backend->free(refdb_backend);
+
+	rugged_exception_check(error);
+}
+
 /*
  *  call-seq:
- *    Repository.bare(path[, alternates]) -> repository
+ *    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.
@@ -193,23 +266,52 @@ static void load_alternates(git_repository *repo, VALUE rb_alternates)
  *  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.
+ *  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;
+	git_repository *repo = NULL;
 	int error = 0;
-	VALUE rb_path, rb_alternates;
+	VALUE rb_path, rb_options, rb_alternates = 0;
 
-	rb_scan_args(argc, argv, "11", &rb_path, &rb_alternates);
-	Check_Type(rb_path, T_STRING);
+	rb_scan_args(argc, argv, "11", &rb_path, &rb_options);
 
-	error = git_repository_open_bare(&repo, StringValueCStr(rb_path));
-	rugged_exception_check(error);
+	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);
+		}
 
-	load_alternates(repo, rb_alternates);
+		/* 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);
 }
@@ -235,7 +337,7 @@ static VALUE rb_git_repo_open_bare(int argc, VALUE *argv, VALUE klass)
  *
  *  Examples:
  *
- *    Rugged::Repository.new('~/test/.git') #=> #<Rugged::Repository:0x108849488>
+ *    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)
@@ -260,7 +362,7 @@ static VALUE rb_git_repo_new(int argc, VALUE *argv, VALUE klass)
 
 /*
  *  call-seq:
- *    Repository.init_at(path, is_bare = false) -> repository
+ *    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
@@ -272,19 +374,36 @@ static VALUE rb_git_repo_new(int argc, VALUE *argv, VALUE klass)
  *  of +path+. Non-bare repositories are created in a +.git+ folder and
  *  use +path+ as working directory.
  *
- *    Rugged::Repository.init_at('~/repository', :bare) #=> #<Rugged::Repository:0x108849488>
+ *  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;
-	VALUE rb_path, rb_is_bare;
+	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_scan_args(argc, argv, "11:", &rb_path, &rb_is_bare, &rb_options);
 	Check_Type(rb_path, T_STRING);
 
-	rugged_exception_check(
-		git_repository_init(&repo, StringValueCStr(rb_path), RTEST(rb_is_bare))
-	);
+	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);
 }
@@ -526,19 +645,21 @@ static VALUE rb_git_repo_merge_base(VALUE self, VALUE rb_args)
  */
 static VALUE rb_git_repo_merge_bases(VALUE self, VALUE rb_args)
 {
-	int error = GIT_OK, i;
+	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 = xmalloc(sizeof(git_oid) * RARRAY_LEN(rb_args));
-	int len = (int)RARRAY_LEN(rb_args);
+	git_oid *input_array;
 
 	VALUE rb_bases;
 
 	if (len < 2)
-		rb_raise(rb_eArgError, "wrong number of arguments (%d for 2+)", len);
+		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));
 	}
@@ -585,7 +706,7 @@ static VALUE rb_git_repo_merge_bases(VALUE self, VALUE rb_args)
  *  :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
@@ -1116,8 +1237,12 @@ static VALUE rb_git_repo_get_head(VALUE self)
 static VALUE rb_git_repo_path(VALUE self)
 {
 	git_repository *repo;
+	const char *path;
+
 	Data_Get_Struct(self, git_repository, repo);
-	return rb_str_new_utf8(git_repository_path(repo));
+	path = git_repository_path(repo);
+
+	return path ? rb_str_new_utf8(path) : Qnil;
 }
 
 /*