rugged 0.17.0.b7 → 0.18.0.b1

data/ext/rugged/rugged_remote.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
+ * Copyright (c) 2013 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
@@ -33,45 +33,83 @@ static void rb_git_remote__free(git_remote *remote)
 	git_remote_free(remote);
 }
 
-static VALUE rb_git_remote__new(int argc, VALUE *argv, VALUE klass)
+VALUE rugged_remote_new(VALUE klass, VALUE owner, git_remote *remote)
+{
+	VALUE rb_remote = Data_Wrap_Struct(klass, NULL, &rb_git_remote__free, remote);
+	rugged_set_owner(rb_remote, owner);
+	return rb_remote;
+}
+
+/*
+ *  	call-seq:
+ *   		Remote.new(repository, url) -> remote
+ *
+ *   	Return a new remote from +url+ in +repository+ , the remote is not persisted:
+ *	- +url+: a valid remote url
+ *
+ *	Returns a new <tt>Rugged::Remote</tt> object
+ *
+ *		Rugged::Remote.new(@repo, 'git://github.com/libgit2/libgit2.git') #=> #<Rugged::Remote:0x00000001fbfa80>
+ */
+static VALUE rb_git_remote_new(VALUE klass, VALUE rb_repo, VALUE rb_url)
 {
-	VALUE rb_remote, rb_repo, rb_url, rb_name;
 	git_remote *remote;
 	git_repository *repo;
 	const char *url;
 	int error;
 
-	rb_scan_args(argc, argv, "21", &rb_repo, &rb_url, &rb_name);
-
 	Check_Type(rb_url, T_STRING);
-
-	if (!rb_obj_is_instance_of(rb_repo, rb_cRuggedRepo))
-		rb_raise(rb_eTypeError, "Expecting a Rugged Repository");
+	rugged_check_repo(rb_repo);
 
 	Data_Get_Struct(rb_repo, git_repository, repo);
 
 	url = StringValueCStr(rb_url);
 
 	if (git_remote_valid_url(url)) {
-		if (!NIL_P(rb_name))
-			Check_Type(rb_name, T_STRING);
-
-		error = git_remote_new(
-			&remote,
-			repo,
-			NIL_P(rb_name) ? NULL : StringValueCStr(rb_name),
-			StringValueCStr(rb_url),
-			NULL
-		);
+		error = git_remote_create_inmemory(
+				&remote,
+				repo,
+				NULL,
+				url);
 	} else {
-		error = git_remote_load(&remote, repo, url);
+		rb_raise(rb_eArgError, "Invalid URL format");
 	}
 
 	rugged_exception_check(error);
 
-	rb_remote = Data_Wrap_Struct(klass, NULL, &rb_git_remote__free, remote);
-	rugged_set_owner(rb_remote, rb_repo);
-	return rb_remote;
+	return rugged_remote_new(klass, rb_repo, remote);
+}
+
+/*
+ *  	call-seq:
+ *   		Remote.lookup(repository, name) -> new_remote or nil
+ *
+ *   	Return an existing remote with +name+ in +repository+:
+ *	- +name+: a valid remote name
+ *
+ *	Returns a new <tt>Rugged::Remote</tt> object or +nil+ if the
+ *	remote doesn't exist
+ *
+ *		Rugged::Remote.lookup(@repo, 'origin') #=> #<Rugged::Remote:0x00000001fbfa80>
+ */
+static VALUE rb_git_remote_lookup(VALUE klass, VALUE rb_repo, VALUE rb_name)
+{
+	git_remote *remote;
+	git_repository *repo;
+	int error;
+
+	Check_Type(rb_name, T_STRING);
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
+
+	error = git_remote_load(&remote, repo, StringValueCStr(rb_name));
+
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+
+	rugged_exception_check(error);
+
+	return rugged_remote_new(klass, rb_repo, remote);
 }
 
 static VALUE rb_git_remote_disconnect(VALUE self)
@@ -95,9 +133,9 @@ static VALUE rb_git_remote_connect(VALUE self, VALUE rb_direction)
 	id_direction = SYM2ID(rb_direction);
 
 	if (id_direction == rb_intern("fetch"))
-		direction = GIT_DIR_FETCH;
+		direction = GIT_DIRECTION_FETCH;
 	else if (id_direction == rb_intern("push"))
-		direction = GIT_DIR_PUSH;
+		direction = GIT_DIRECTION_PUSH;
 	else
 		rb_raise(rb_eTypeError,
 			"Invalid remote direction. Expected `:fetch` or `:push`");
@@ -147,9 +185,15 @@ static VALUE rb_git_remote_ls(VALUE self)
 static VALUE rb_git_remote_name(VALUE self)
 {
 	git_remote *remote;
+	const char * name;
 	Data_Get_Struct(self, git_remote, remote);
 
-	return rugged_str_new2(git_remote_name(remote), NULL);
+	name = git_remote_name(remote);
+
+	if (name)
+		return rugged_str_new2(name, NULL);
+	else
+		return Qnil;
 }
 
 static VALUE rb_git_remote_url(VALUE self)
@@ -172,12 +216,10 @@ static VALUE rb_git_remote_download(VALUE self)
 {
 	int error;
 	git_remote *remote;
-	git_off_t bytes = 0;
-	git_indexer_stats stats;
 
 	Data_Get_Struct(self, git_remote, remote);
 
-	error = git_remote_download(remote, &bytes, &stats);
+	error = git_remote_download(remote, NULL, NULL);
 	rugged_exception_check(error);
 
 	return Qnil;
@@ -226,7 +268,8 @@ void Init_rugged_remote()
 {
 	rb_cRuggedRemote = rb_define_class_under(rb_mRugged, "Remote", rb_cObject);
 
-	rb_define_singleton_method(rb_cRuggedRemote, "new", rb_git_remote__new, -1);
+	rb_define_singleton_method(rb_cRuggedRemote, "new", rb_git_remote_new, 2);
+	rb_define_singleton_method(rb_cRuggedRemote, "lookup", rb_git_remote_lookup, 2);
 	rb_define_singleton_method(rb_cRuggedRemote, "each", rb_git_remote_each, 1);
 
 	rb_define_method(rb_cRuggedRemote, "connect", rb_git_remote_connect, 1);

data/ext/rugged/rugged_repo.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2011 GitHub, Inc
+ * Copyright (c) 2013 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
@@ -25,9 +25,11 @@
 #include "rugged.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;
 
 VALUE rb_cRuggedRepo;
 VALUE rb_cRuggedOdbObject;
@@ -114,9 +116,8 @@ VALUE rugged_raw_read(git_repository *repo, const git_oid *oid)
 	rugged_exception_check(error);
 
 	error = git_odb_read(&obj, odb, oid);
-	rugged_exception_check(error);
-
 	git_odb_free(odb);
+	rugged_exception_check(error);
 
 	return Data_Wrap_Struct(rb_cRuggedOdbObject, NULL, rb_git__odbobj_free, obj);
 }
@@ -142,9 +143,67 @@ static VALUE rugged_repo_new(VALUE klass, git_repository *repo)
 	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 set_repository_options(git_repository *repo, VALUE rb_options)
+{
+	int error = 0;
+
+	if (NIL_P(rb_options))
+		return;
+
+	Check_Type(rb_options, T_HASH);
+
+	/* Check for `:alternates` */
+	load_alternates(repo, rb_hash_aref(rb_options, CSTR2SYM("alternates")));
+}
+
+static VALUE rb_git_repo_open_bare(int argc, VALUE *argv, VALUE klass)
+{
+	git_repository *repo;
+	int error = 0;
+	VALUE rb_path, rb_alternates;
+
+	rb_scan_args(argc, argv, "11", &rb_path, &rb_alternates);
+	Check_Type(rb_path, T_STRING);
+
+	error = git_repository_open_bare(&repo, StringValueCStr(rb_path));
+	rugged_exception_check(error);
+
+	load_alternates(repo, rb_alternates);
+
+	return rugged_repo_new(klass, repo);
+}
+
 /*
  *	call-seq:
- *		Rugged::Repository.new(path) -> repository
+ *		Rugged::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
@@ -156,44 +215,58 @@ static VALUE rugged_repo_new(VALUE klass, git_repository *repo)
  *	instead.
  *
  *		Rugged::Repository.new('~/test/.git') #=> #<Rugged::Repository:0x108849488>
+ *
+ *	+options+ is an optional hash with the following keys:
+ *
+ *	- +:alternates+: +Array+ with a list of alternate object folders, e.g.
+ *
+ *		Rugged::Repository.new(path, :alternates => ['./other/repo/.git/objects'])
  */
-static VALUE rb_git_repo_new(VALUE klass, VALUE rb_path)
+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, "11", &rb_path, &rb_options);
 	Check_Type(rb_path, T_STRING);
 
 	error = git_repository_open(&repo, StringValueCStr(rb_path));
 	rugged_exception_check(error);
+	set_repository_options(repo, rb_options);
 
 	return rugged_repo_new(klass, repo);
 }
 
 /*
  *	call-seq:
- *		Rugged::Repository.init_at(path, is_bare) -> repository
+ *		init_at(path, is_bare = false) -> 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+ 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 +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.
  *
- *		Rugged::Repository.init_at('~/repository') #=> #<Rugged::Repository:0x108849488>
+ *		Rugged::Repository.init_at('~/repository', :bare) #=> #<Rugged::Repository:0x108849488>
  */
-static VALUE rb_git_repo_init_at(VALUE klass, VALUE path, VALUE rb_is_bare)
+static VALUE rb_git_repo_init_at(int argc, VALUE *argv, VALUE klass)
 {
 	git_repository *repo;
-	int error, is_bare;
+	VALUE rb_path, rb_is_bare;
+	int error, is_bare = 0;
+
+	rb_scan_args(argc, argv, "11", &rb_path, &rb_is_bare);
+	Check_Type(rb_path, T_STRING);
 
-	is_bare = rugged_parse_bool(rb_is_bare);
-	Check_Type(path, T_STRING);
+	if (!NIL_P(rb_is_bare))
+		is_bare = rb_is_bare ? 1 : 0;
 
-	error = git_repository_init(&repo, StringValueCStr(path), is_bare);
+	error = git_repository_init(&repo, StringValueCStr(rb_path), is_bare);
 	rugged_exception_check(error);
 
 	return rugged_repo_new(klass, repo);
@@ -278,6 +351,33 @@ static VALUE rb_git_repo_get_config(VALUE self)
 	RB_GIT_REPO_OWNED_GET(rb_cRuggedConfig, config);
 }
 
+/*
+ *	call-seq:
+ *		repo.merge_base(oid1, oid2)
+ *		repo.merge_base(ref1, ref2)
+ *		repo.merge_base(commit1, commit2)
+ *
+ *	Find a merge base, given two commits or oids.
+ *	Returns nil if a merge base is not found.
+ */
+static VALUE rb_git_repo_merge_base(VALUE self, VALUE obj1, VALUE obj2)
+{
+	int error;
+	git_oid oid1, oid2, base;
+	git_repository *repo;
+
+	Data_Get_Struct(self, git_repository, repo);
+	rugged_oid_get(&oid1, repo, obj1);
+	rugged_oid_get(&oid2, repo, obj2);
+
+	error = git_merge_base(&base, repo, &oid1, &oid2);
+	if (error == GIT_ENOTFOUND)
+		return Qnil;
+
+	rugged_exception_check(error);
+	return rugged_create_oid(&base);
+}
+
 /*
  *	call-seq:
  *		repo.include?(oid) -> true or false
@@ -326,6 +426,36 @@ static VALUE rb_git_repo_read(VALUE self, VALUE hex)
 	return rugged_raw_read(repo, &oid);
 }
 
+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:
  *		Repository.hash(buffer, type) -> oid
@@ -395,6 +525,7 @@ static VALUE rb_git_repo_write(VALUE self, VALUE rb_buffer, VALUE rub_type)
 	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);
@@ -402,14 +533,14 @@ static VALUE rb_git_repo_write(VALUE self, VALUE rb_buffer, VALUE rub_type)
 	type = rugged_otype_get(rub_type);
 
 	error = git_odb_open_wstream(&stream, odb, RSTRING_LEN(rb_buffer), type);
-	rugged_exception_check(error);
-
 	git_odb_free(odb);
+	rugged_exception_check(error);
 
 	error = stream->write(stream, RSTRING_PTR(rb_buffer), RSTRING_LEN(rb_buffer));
 	rugged_exception_check(error);
 
 	error = stream->finalize_write(&oid, stream);
+	stream->free(stream);
 	rugged_exception_check(error);
 
 	return rugged_create_oid(&oid);
@@ -688,26 +819,273 @@ static VALUE rb_git_repo_status(int argc, VALUE *argv, VALUE self)
 	return Qnil;
 }
 
+static int rugged__each_id_cb(const git_oid *id, void *payload)
+{
+	rb_yield(rugged_create_oid(id));
+	return 0;
+}
+
+/*
+ *	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;
+
+	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, NULL);
+	git_odb_free(odb);
+
+	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);
+
+	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.
+ *
+ *	- +pahtspecs+: 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;
+	VALUE rb_path_array;
+	int i, 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);
+
+	rb_path_array = rb_ary_to_ary(rb_paths);
+
+	for (i = 0; i < RARRAY_LEN(rb_path_array); ++i)
+		Check_Type(rb_ary_entry(rb_path_array, i), T_STRING);
+
+	pathspecs.count = RARRAY_LEN(rb_path_array);
+	pathspecs.strings = xmalloc(pathspecs.count * sizeof(char *));
+
+	for (i = 0; i < RARRAY_LEN(rb_path_array); ++i) {
+		VALUE fpath = rb_ary_entry(rb_path_array, i);
+		pathspecs.strings[i] = StringValueCStr(fpath);
+	}
+
+	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;
+}
+
+
+static int rugged__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, rugged_str_new2(ref, rb_utf8_encoding()),
+			rugged_str_new2(msg, NULL));
+	return GIT_OK;
+}
+
+/*
+ *	call-seq:
+ *		repo.push("origin", ["refs/heads/master", ":refs/heads/to_be_deleted"])
+ *
+ *  Pushes the given refspecs to the given remote. Returns a hash that contains key-value pairs that
+ *  reflect pushed refs and error messages, if applicable.
+ */
+static VALUE rb_git_repo_push(VALUE self, VALUE rb_remote, VALUE rb_refspecs)
+{
+	VALUE rb_refspec, rb_exception = Qnil, rb_result = rb_hash_new();
+	git_repository *repo;
+	git_remote *remote = NULL;
+	git_push *push = NULL;
+
+	int error = 0, i = 0;
+
+	Check_Type(rb_refspecs, T_ARRAY);
+	for (i = 0; i < RARRAY_LEN(rb_refspecs); ++i) {
+		rb_refspec = rb_ary_entry(rb_refspecs, i);
+		Check_Type(rb_refspec, T_STRING);
+	}
+
+	Data_Get_Struct(self, git_repository, repo);
+
+	if (rb_obj_is_kind_of(rb_remote, rb_cRuggedRemote)) {
+		Data_Get_Struct(rb_remote, git_remote, remote);
+	} else if (TYPE(rb_remote) == T_STRING) {
+		error = git_remote_load(&remote, repo, StringValueCStr(rb_remote));
+		if (error) goto cleanup;
+	} else {
+		rb_raise(rb_eTypeError, "Expecting a String or Rugged::Remote instance");
+	}
+
+	error = git_push_new(&push, remote);
+	if (error) goto cleanup;
+
+	for (i = 0; !error && i < RARRAY_LEN(rb_refspecs); ++i) {
+		rb_refspec = rb_ary_entry(rb_refspecs, i);
+		error = git_push_add_refspec(push, StringValueCStr(rb_refspec));
+	}
+	if (error) goto cleanup;
+
+	error = git_push_finish(push);
+
+	if (error) {
+		if (error == GIT_ENONFASTFORWARD) {
+			rb_exception = rb_exc_new2(rb_eRuggedError, "non-fast-forward update rejected");
+		} else if (error == -1) {
+			rb_exception = rb_exc_new2(rb_eRuggedError, "could not push to repo (check for non-bare repo)");
+		}
+
+		goto cleanup;
+	}
+
+	if (!git_push_unpack_ok(push)) {
+		rb_exception = rb_exc_new2(rb_eRuggedError, "the remote side did not unpack successfully");
+		goto cleanup;
+	}
+
+	error = git_push_status_foreach(push, &rugged__push_status_cb, (void *)rb_result);
+	if (error) goto cleanup;
+
+	error = git_push_update_tips(push);
+
+cleanup:
+	git_push_free(push);
+
+	// We can only free the remote if we have loaded it ourselves.
+	if (!rb_obj_is_kind_of(rb_remote, rb_cRuggedRemote)) {
+		git_remote_free(remote);
+	}
+
+	if (!NIL_P(rb_exception))
+		rb_exc_raise(rb_exception);
+
+	rugged_exception_check(error);
+
+	return rb_result;
+}
+
 void Init_rugged_repo()
 {
 	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, "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",   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, 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_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, "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, "push", rb_git_repo_push, 2);
+
 	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);
@@ -719,6 +1097,10 @@ void Init_rugged_repo()
 	rb_define_method(rb_cRuggedRepo, "head_detached?",  rb_git_repo_head_detached,  0);
 	rb_define_method(rb_cRuggedRepo, "head_orphan?",  rb_git_repo_head_orphan,  0);
 
+	rb_define_method(rb_cRuggedRepo, "merge_base", rb_git_repo_merge_base, 2);
+	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_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);