rugged 0.19.0 → 0.28.0

data/ext/rugged/rugged_remote.c

@@ -1,223 +1,246 @@
 /*
- * The MIT License
- *
- * 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
- * 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.
+ * Copyright (C) the Rugged contributors.  All rights reserved.
+ *
+ * This file is part of Rugged, distributed under the MIT license.
+ * For full terms see the included LICENSE file.
  */
 
 #include "rugged.h"
 
 extern VALUE rb_mRugged;
 extern VALUE rb_cRuggedRepo;
+extern VALUE rb_eRuggedError;
 VALUE rb_cRuggedRemote;
 
-static void rb_git_remote__free(git_remote *remote)
+static int progress_cb(const char *str, int len, void *data)
 {
-	git_remote_free(remote);
+	struct rugged_remote_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(2);
+
+	if (NIL_P(payload->progress))
+		return 0;
+
+	rb_ary_push(args, payload->progress);
+	rb_ary_push(args, rb_str_new(str, len));
+
+	rb_protect(rugged__block_yield_splat, args, &payload->exception);
+
+	return payload->exception ? GIT_ERROR : GIT_OK;
 }
 
-VALUE rugged_remote_new(VALUE klass, VALUE owner, git_remote *remote)
+static int transfer_progress_cb(const git_transfer_progress *stats, void *data)
 {
-	VALUE rb_remote;
+	struct rugged_remote_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(5);
 
-	rb_remote = Data_Wrap_Struct(klass, NULL, &rb_git_remote__free, remote);
-	rugged_set_owner(rb_remote, owner);
-	return rb_remote;
+	if (NIL_P(payload->transfer_progress))
+		return 0;
+
+	rb_ary_push(args, payload->transfer_progress);
+	rb_ary_push(args, UINT2NUM(stats->total_objects));
+	rb_ary_push(args, UINT2NUM(stats->indexed_objects));
+	rb_ary_push(args, UINT2NUM(stats->received_objects));
+	rb_ary_push(args, UINT2NUM(stats->local_objects));
+	rb_ary_push(args, UINT2NUM(stats->total_deltas));
+	rb_ary_push(args, UINT2NUM(stats->indexed_deltas));
+	rb_ary_push(args, INT2FIX(stats->received_bytes));
+
+	rb_protect(rugged__block_yield_splat, args, &payload->exception);
+
+	return payload->exception ? GIT_ERROR : GIT_OK;
 }
 
-static inline void rugged_validate_remote_url(VALUE rb_url)
-{
-	Check_Type(rb_url, T_STRING);
-	if (!git_remote_valid_url(StringValueCStr(rb_url)))
-		rb_raise(rb_eArgError, "Invalid URL format");
+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;
 }
 
-/*
- *  call-seq:
- *    Remote.new(repository, url) -> remote
- *
- *  Return a new remote with +url+ in +repository+ , the remote is not persisted:
- *  - +url+: a valid remote url
- *
- *  Returns a new Rugged::Remote 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)
+static int update_tips_cb(const char *refname, const git_oid *src, const git_oid *dest, void *data)
 {
-	git_remote *remote;
-	git_repository *repo;
-	int error;
+	struct rugged_remote_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(4);
 
-	rugged_check_repo(rb_repo);
-	rugged_validate_remote_url(rb_url);
+	if (NIL_P(payload->update_tips))
+		return 0;
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	rb_ary_push(args, payload->update_tips);
+	rb_ary_push(args, rb_str_new_utf8(refname));
+	rb_ary_push(args, git_oid_iszero(src) ? Qnil : rugged_create_oid(src));
+	rb_ary_push(args, git_oid_iszero(dest) ? Qnil : rugged_create_oid(dest));
 
-	error = git_remote_create_inmemory(
-			&remote,
-			repo,
-			NULL,
-			StringValueCStr(rb_url));
+	rb_protect(rugged__block_yield_splat, args, &payload->exception);
 
-	rugged_exception_check(error);
-
-	return rugged_remote_new(klass, rb_repo, remote);
+	return payload->exception ? GIT_ERROR : GIT_OK;
 }
 
-/*
- *  call-seq:
- *     Remote.add(repository, name, url) -> remote
- *
- *  Add a new remote with +name+ and +url+ to +repository+
- *  - +url+: a valid remote url
- *  - +name+: a valid remote name
- *
- *  Returns a new Rugged::Remote object
- *
- *    Rugged::Remote.add(@repo, 'origin', 'git://github.com/libgit2/rugged.git') #=> #<Rugged::Remote:0x00000001fbfa80>
- */
-static VALUE rb_git_remote_add(VALUE klass, VALUE rb_repo,VALUE rb_name, VALUE rb_url)
+static int certificate_check_cb(git_cert *cert, int valid, const char *host, void *data)
 {
-	git_remote *remote;
-	git_repository *repo;
-	int error;
+	struct rugged_remote_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(3);
+	VALUE ret;
 
-	Check_Type(rb_name, T_STRING);
-	rugged_validate_remote_url(rb_url);
-	rugged_check_repo(rb_repo);
+	if (NIL_P(payload->certificate_check))
+		return valid ? 0 : GIT_ECERTIFICATE;
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	rb_ary_push(args, payload->certificate_check);
+	rb_ary_push(args, valid ? Qtrue : Qfalse);
+	rb_ary_push(args, rb_str_new_utf8(host));
 
-	error = git_remote_create(
-			&remote,
-			repo,
-			StringValueCStr(rb_name),
-			StringValueCStr(rb_url));
+	ret = rb_protect(rugged__block_yield_splat, args, &payload->exception);
 
-	rugged_exception_check(error);
+	if (payload->exception)
+		return GIT_ERROR;
 
-	return rugged_remote_new(klass, rb_repo, remote);
+	return rugged_parse_bool(ret) ? GIT_OK : GIT_ECERTIFICATE;
 }
 
-/*
- *  call-seq:
- *    Remote.lookup(repository, name) -> remote or nil
- *
- *  Return an existing remote with +name+ in +repository+:
- *  - +name+: a valid remote name
- *
- *  Returns a new Rugged::Remote 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)
+struct extract_cred_args
 {
-	git_remote *remote;
-	git_repository *repo;
-	int error;
+	VALUE rb_callback;
+	git_cred **cred;
+	const char *url;
+	const char *username_from_url;
+	unsigned int allowed_types;
+};
 
-	Check_Type(rb_name, T_STRING);
-	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
+static VALUE allowed_types_to_rb_ary(int allowed_types) {
+	VALUE rb_allowed_types = rb_ary_new();
 
-	error = git_remote_load(&remote, repo, StringValueCStr(rb_name));
+	if (allowed_types & GIT_CREDTYPE_USERPASS_PLAINTEXT)
+		rb_ary_push(rb_allowed_types, CSTR2SYM("plaintext"));
 
-	if (error == GIT_ENOTFOUND)
-		return Qnil;
+	if (allowed_types & GIT_CREDTYPE_SSH_KEY)
+		rb_ary_push(rb_allowed_types, CSTR2SYM("ssh_key"));
 
-	rugged_exception_check(error);
+	if (allowed_types & GIT_CREDTYPE_DEFAULT)
+		rb_ary_push(rb_allowed_types, CSTR2SYM("default"));
 
-	return rugged_remote_new(klass, rb_repo, remote);
+	return rb_allowed_types;
 }
 
-/*
- *  call-seq:
- *    remote.disconnect() -> nil
- *
- *  Disconnect from the remote, closes the connection to the remote
- */
-static VALUE rb_git_remote_disconnect(VALUE self)
-{
-	git_remote *remote;
-	Data_Get_Struct(self, git_remote, remote);
+static VALUE extract_cred(VALUE data) {
+	struct extract_cred_args *args = (struct extract_cred_args*)data;
+	VALUE rb_url, rb_username_from_url, rb_cred;
+
+	rb_url = args->url ? rb_str_new2(args->url) : Qnil;
+	rb_username_from_url = args->username_from_url ? rb_str_new2(args->username_from_url) : Qnil;
+
+	rb_cred = rb_funcall(args->rb_callback, rb_intern("call"), 3,
+		rb_url, rb_username_from_url, allowed_types_to_rb_ary(args->allowed_types));
+
+	rugged_cred_extract(args->cred, args->allowed_types, rb_cred);
 
-	git_remote_disconnect(remote);
 	return Qnil;
 }
 
-/*
- *  call-seq:
- *    remote.connect(direction) -> nil
- *    remote.connect(direction) { |connected_remote| block }
- *
- *  Open a connection to a remote:
- *  - +direction+: +:fetch+ or +:pull+
- *
- *  If a block is given it will be passed the connected remote as argument
- *  and the remote will be disconnected when the block terminates.
- *
- *  The transport is selected based on the URL.
- *
- *    remote.connect(:fetch) #=> nil
- *
- *    remote.connect(:fetch) do |r|
- *      r.connected?  #=> true
- *    end
- *
- */
-static VALUE rb_git_remote_connect(VALUE self, VALUE rb_direction)
+static int credentials_cb(
+	git_cred **cred,
+	const char *url,
+	const char *username_from_url,
+	unsigned int allowed_types,
+	void *data)
 {
-	int error, direction = 0, exception = 0;
-	git_remote *remote;
-	ID id_direction;
+	struct rugged_remote_cb_payload *payload = data;
+	struct extract_cred_args args = {
+		payload->credentials, cred, url, username_from_url, allowed_types
+	};
 
-	Data_Get_Struct(self, git_remote, remote);
+	if (NIL_P(payload->credentials))
+		return GIT_PASSTHROUGH;
 
-	Check_Type(rb_direction, T_SYMBOL);
-	id_direction = SYM2ID(rb_direction);
+	rb_protect(extract_cred, (VALUE)&args, &payload->exception);
 
-	if (id_direction == rb_intern("fetch"))
-		direction = GIT_DIRECTION_FETCH;
-	else if (id_direction == rb_intern("push"))
-		direction = GIT_DIRECTION_PUSH;
-	else
-		rb_raise(rb_eTypeError,
-			"Invalid remote direction. Expected `:fetch` or `:push`");
+	return payload->exception ? GIT_ERROR : GIT_OK;
+}
 
-	error = git_remote_connect(remote, direction);
-	rugged_exception_check(error);
+#define CALLABLE_OR_RAISE(ret, name) \
+	do { \
+		if (!rb_respond_to(ret, rb_intern("call"))) \
+			rb_raise(rb_eArgError, "Expected a Proc or an object that responds to #call (:" name " )."); \
+	} while (0);
+
+void rugged_remote_init_callbacks_and_payload_from_options(
+	VALUE rb_options,
+	git_remote_callbacks *callbacks,
+	struct rugged_remote_cb_payload *payload)
+{
+	callbacks->payload = payload;
+	callbacks->push_update_reference = push_update_reference_cb;
+
+	if (!NIL_P(rb_options)) {
+		payload->progress = rb_hash_aref(rb_options, CSTR2SYM("progress"));
+		if (!NIL_P(payload->progress)) {
+			CALLABLE_OR_RAISE(payload->progress, "progress");
+			callbacks->sideband_progress = progress_cb;
+		}
+
+		payload->credentials = rb_hash_aref(rb_options, CSTR2SYM("credentials"));
+		if (!NIL_P(payload->credentials)) {
+			CALLABLE_OR_RAISE(payload->credentials, "credentials");
+			callbacks->credentials = credentials_cb;
+		}
+
+		payload->certificate_check = rb_hash_aref(rb_options, CSTR2SYM("certificate_check"));
+		if (!NIL_P(payload->certificate_check)) {
+			CALLABLE_OR_RAISE(payload->certificate_check, "certificate_check");
+			callbacks->certificate_check = certificate_check_cb;
+		}
 
-	if (rb_block_given_p()) {
-		rb_protect(rb_yield, self, &exception);
-		git_remote_disconnect(remote);
+		payload->transfer_progress = rb_hash_aref(rb_options, CSTR2SYM("transfer_progress"));
+		if (!NIL_P(payload->transfer_progress)) {
+			CALLABLE_OR_RAISE(payload->transfer_progress, "transfer_progress");
+			callbacks->transfer_progress = transfer_progress_cb;
+		}
 
-		if (exception)
-			rb_jump_tag(exception);
+		payload->update_tips = rb_hash_aref(rb_options, CSTR2SYM("update_tips"));
+		if (!NIL_P(payload->update_tips)) {
+			CALLABLE_OR_RAISE(payload->update_tips, "update_tips");
+			callbacks->update_tips = update_tips_cb;
+		}
 	}
+}
 
-	return Qnil;
+static void init_custom_headers(VALUE rb_options, git_strarray *custom_headers)
+{
+	if (!NIL_P(rb_options))
+	{
+		VALUE rb_headers = rb_hash_aref(rb_options, CSTR2SYM("headers"));
+		rugged_rb_ary_to_strarray(rb_headers, custom_headers);
+	}
 }
 
-static VALUE rugged_rhead_new(git_remote_head *head)
+static int parse_prune_type(VALUE rb_prune_type)
+{
+	if (rb_prune_type == Qtrue) {
+		return GIT_FETCH_PRUNE;
+	} else if (rb_prune_type == Qfalse) {
+		return GIT_FETCH_NO_PRUNE;
+	} else if (rb_prune_type == Qnil) {
+		return GIT_FETCH_PRUNE_UNSPECIFIED;
+	} else {
+		rb_raise(rb_eTypeError, "wrong argument type for :prune (expected true, false or nil)");
+	}
+}
+
+static void rb_git_remote__free(git_remote *remote)
+{
+	git_remote_free(remote);
+}
+
+VALUE rugged_remote_new(VALUE owner, git_remote *remote)
+{
+	VALUE rb_remote;
+
+	rb_remote = Data_Wrap_Struct(rb_cRuggedRemote, NULL, &rb_git_remote__free, remote);
+	rugged_set_owner(rb_remote, owner);
+	return rb_remote;
+}
+
+static VALUE rugged_rhead_new(const git_remote_head *head)
 {
 	VALUE rb_head = rb_hash_new();
 
@@ -230,48 +253,79 @@ static VALUE rugged_rhead_new(git_remote_head *head)
 	return rb_head;
 }
 
-static int cb_remote__ls(git_remote_head *head, void *payload)
-{
-	int *exception = (int *)payload;
-	rb_protect(rb_yield, rugged_rhead_new(head), exception);
-	return *exception ? GIT_ERROR : GIT_OK;
-}
-
 /*
  *  call-seq:
- *    remote.ls() -> an_enumerator
- *    remote.ls() { |remote_head_hash| block }
+ *    remote.ls(options = {}) -> an_enumerator
+ *    remote.ls(options = {}) { |remote_head_hash| block }
+ *
+ *  Connects +remote+ to list all references available along with their
+ *  associated commit ids.
+ *
+ *  The given block is called once for each remote head with a Hash containing the
+ *  following keys:
+ *
+ *  :local? ::
+ *    +true+ if the remote head is available locally, +false+ otherwise.
  *
- *  List references available in a connected +remote+ repository along
- *  with the associated commit IDs.
+ *  :oid ::
+ *    The id of the object the remote head is currently pointing to.
  *
- *  Call the given block once for each remote head in the +remote+ as a
- *  +Hash+.
- *  If no block is given an Enumerator is returned.
+ *  :loid ::
+ *    The id of the object the local copy of the remote head is currently
+ *    pointing to. Set to +nil+ if there is no local copy of the remote head.
  *
- *    remote.connect(:fetch) do |r|
- *      r.ls.to_a #=> [{:local?=>false, :oid=>"b3ee97a91b02e91c35394950bda6ea622044baad", :loid=> nil, :name=>"refs/heads/development"}]
- *    end
+ *  :name ::
+ *    The fully qualified reference name of the remote head.
  *
- *  remote head hash includes:
- *  [:oid] oid of the remote head
- *  [:name] name of the remote head
+ *  If no block is given, an enumerator will be returned.
  *
+ *  The following options can be passed in the +options+ Hash:
  *
+ *  :credentials ::
+ *    The credentials to use for the ls 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.
+ *
+ *  :headers ::
+ *    Extra HTTP headers to include with the request (only applies to http:// or https:// remotes)
  */
-static VALUE rb_git_remote_ls(VALUE self)
+static VALUE rb_git_remote_ls(int argc, VALUE *argv, VALUE self)
 {
-	int error, exception = 0;
 	git_remote *remote;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	git_strarray custom_headers = {0};
+	const git_remote_head **heads;
+
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+
+	VALUE rb_options;
+
+	int error;
+	size_t heads_len, i;
+
+	RETURN_ENUMERATOR(self, argc, argv);
 	Data_Get_Struct(self, git_remote, remote);
+	rb_scan_args(argc, argv, ":", &rb_options);
+
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+	init_custom_headers(rb_options, &custom_headers);
 
-	if (!rb_block_given_p())
-		return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("ls"));
+	if ((error = git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, NULL, &custom_headers)) ||
+	    (error = git_remote_ls(&heads, &heads_len, remote)))
+		goto cleanup;
 
-	error = git_remote_ls(remote, &cb_remote__ls, &exception);
+	for (i = 0; i < heads_len && !payload.exception; i++)
+		rb_protect(rb_yield, rugged_rhead_new(heads[i]), &payload.exception);
+
+	cleanup:
+
+	git_remote_disconnect(remote);
+	xfree(custom_headers.strings);
+
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
 
-	if (exception)
-		rb_jump_tag(exception);
 	rugged_exception_check(error);
 
 	return Qnil;
@@ -281,7 +335,8 @@ static VALUE rb_git_remote_ls(VALUE self)
  *  call-seq:
  *    remote.name() -> string
  *
- *	Returns the remote's name
+ *	Returns the remote's name.
+ *
  *	  remote.name #=> "origin"
  */
 static VALUE rb_git_remote_name(VALUE self)
@@ -300,6 +355,7 @@ static VALUE rb_git_remote_name(VALUE self)
  *    remote.url() -> string
  *
  *  Returns the remote's url
+ *
  *    remote.url #=> "git://github.com/libgit2/rugged.git"
  */
 static VALUE rb_git_remote_url(VALUE self)
@@ -310,33 +366,13 @@ static VALUE rb_git_remote_url(VALUE self)
 	return rb_str_new_utf8(git_remote_url(remote));
 }
 
-/*
- *  call-seq:
- *    remote.url = url -> url
- *
- *  Sets the remote's url without persisting it in the config.
- *  Existing connections will not be updated.
- *    remote.url = 'git://github.com/libgit2/rugged.git' #=> "git://github.com/libgit2/rugged.git"
- */
-static VALUE rb_git_remote_set_url(VALUE self, VALUE rb_url)
-{
-	git_remote *remote;
-
-	rugged_validate_remote_url(rb_url);
-	Data_Get_Struct(self, git_remote, remote);
-
-	rugged_exception_check(
-		git_remote_set_url(remote, StringValueCStr(rb_url))
-	);
-	return rb_url;
-}
-
 /*
  *  call-seq:
  *    remote.push_url() -> string or nil
  *
  *  Returns the remote's url for pushing or nil if no special url for
  *  pushing is set.
+ *
  *    remote.push_url #=> "git://github.com/libgit2/rugged.git"
  */
 static VALUE rb_git_remote_push_url(VALUE self)
@@ -356,17 +392,23 @@ static VALUE rb_git_remote_push_url(VALUE self)
  *
  *  Sets the remote's url for pushing without persisting it in the config.
  *  Existing connections will not be updated.
+ *
  *    remote.push_url = 'git@github.com/libgit2/rugged.git' #=> "git@github.com/libgit2/rugged.git"
  */
 static VALUE rb_git_remote_set_push_url(VALUE self, VALUE rb_url)
 {
+	VALUE rb_repo = rugged_owner(self);
 	git_remote *remote;
+	git_repository *repo;
+
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
 
-	rugged_validate_remote_url(rb_url);
+	Check_Type(rb_url, T_STRING);
 	Data_Get_Struct(self, git_remote, remote);
 
 	rugged_exception_check(
-		git_remote_set_pushurl(remote, StringValueCStr(rb_url))
+		git_remote_set_pushurl(repo, git_remote_name(remote), StringValueCStr(rb_url))
 	);
 
 	return rb_url;
@@ -397,7 +439,7 @@ static VALUE rb_git_remote_refspecs(VALUE self, git_direction direction)
  *  call-seq:
  *  remote.fetch_refspecs -> array
  *
- *  Get the remote's list of fetch refspecs as +array+
+ *  Get the remote's list of fetch refspecs as +array+.
  */
 static VALUE rb_git_remote_fetch_refspecs(VALUE self)
 {
@@ -408,332 +450,267 @@ static VALUE rb_git_remote_fetch_refspecs(VALUE self)
  *  call-seq:
  *  remote.push_refspecs -> array
  *
- *  Get the remote's list of push refspecs as +array+
+ *  Get the remote's list of push refspecs as +array+.
  */
 static VALUE rb_git_remote_push_refspecs(VALUE self)
 {
 	return rb_git_remote_refspecs(self, GIT_DIRECTION_PUSH);
 }
 
-static VALUE rb_git_remote_add_refspec(VALUE self, VALUE rb_refspec, git_direction direction)
-{
-	git_remote *remote;
-	int error = 0;
-
-	Data_Get_Struct(self, git_remote, remote);
-
-	Check_Type(rb_refspec, T_STRING);
-
-	if (direction == GIT_DIRECTION_FETCH)
-		error = git_remote_add_fetch(remote, StringValueCStr(rb_refspec));
-	else
-		error = git_remote_add_push(remote, StringValueCStr(rb_refspec));
-
-	rugged_exception_check(error);
-
-	return Qnil;
-}
-
 /*
  *  call-seq:
- *    remote.add_fetch(refspec) -> nil
+ *    remote.check_connection(direction, options = {}) -> boolean
  *
- *  Add a fetch refspec to the remote
- */
-static VALUE rb_git_remote_add_fetch(VALUE self, VALUE rb_refspec)
-{
-	return rb_git_remote_add_refspec(self, rb_refspec, GIT_DIRECTION_FETCH);
-}
-
-/*
- *  call-seq:
- *    remote.add_push(refspec) -> nil
+ *  Try to connect to the +remote+. Useful to simulate
+ *  <tt>git fetch --dry-run</tt> and <tt>git push --dry-run</tt>.
  *
- *  Add a push refspec to the remote
- */
-static VALUE rb_git_remote_add_push(VALUE self, VALUE rb_refspec)
-{
-	return rb_git_remote_add_refspec(self, rb_refspec, GIT_DIRECTION_PUSH);
-}
-
-/*
- *  call-seq:
- *    remote.clear_refspecs -> nil
+ *  Returns +true+ if connection is successful, +false+ otherwise.
  *
- *  Remove all configured fetch and push refspecs from the remote.
- */
-static VALUE rb_git_remote_clear_refspecs(VALUE self)
-{
-	git_remote *remote;
-
-	Data_Get_Struct(self, git_remote, remote);
-
-	git_remote_clear_refspecs(remote);
-
-	return Qnil;
-}
-
-/*
- *  call-seq:
- *    remote.connected? -> true or false
+ *  +direction+ must be either +:fetch+ or +:push+.
  *
- *  Returns if the remote is connected
+ *  The following options can be passed in the +options+ Hash:
  *
- *    remote.connected? #=> false
- *    remote.connect(:fetch)
- *    remote.connected? #=> true
- */
-static VALUE rb_git_remote_connected(VALUE self)
-{
-	git_remote *remote;
-	Data_Get_Struct(self, git_remote, remote);
-
-	return git_remote_connected(remote) ? Qtrue : Qfalse;
-}
-
-/*
- *  call-seq:
- *    remote.download() -> nil
+ *  +credentials+ ::
+ *    The credentials to use for the connection. 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.
  *
- *  Download the packfile from a connected remote
+ *  :headers ::
+ *    Extra HTTP headers to include with the request (only applies to http:// or https:// remotes)
  *
- *  Negotiate what objects should be downloaded and download the
- *  packfile with those objects.
+ *  Example:
  *
- *    remote.connect(:fetch) do |r|
- *      r.download
- *    end
+ *    remote = repo.remotes["origin"]
+ *    success = remote.check_connection(:fetch)
+ *    raise Error("Unable to pull without credentials") unless success
  */
-static VALUE rb_git_remote_download(VALUE self)
+static VALUE rb_git_remote_check_connection(int argc, VALUE *argv, VALUE self)
 {
-	int error;
 	git_remote *remote;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	git_strarray custom_headers = {0};
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+	VALUE rb_direction, rb_options;
+	ID id_direction;
+	int error, direction;
 
 	Data_Get_Struct(self, git_remote, remote);
+	rb_scan_args(argc, argv, "01:", &rb_direction, &rb_options);
 
-	error = git_remote_download(remote, NULL, NULL);
-	rugged_exception_check(error);
+	Check_Type(rb_direction, T_SYMBOL);
+	id_direction = SYM2ID(rb_direction);
+	if (id_direction == rb_intern("fetch"))
+		direction = GIT_DIRECTION_FETCH;
+	else if (id_direction == rb_intern("push"))
+		direction = GIT_DIRECTION_PUSH;
+	else
+		rb_raise(rb_eTypeError, "Invalid direction. Expected :fetch or :push");
 
-	return Qnil;
-}
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+	init_custom_headers(rb_options, &custom_headers);
 
-static int cb_remote__update_tips(const char *refname, const git_oid *src, const git_oid *dest, void *payload)
-{
-	VALUE rb_args = rb_ary_new2(3);
-	int *exception = (int *)payload;
-	rb_ary_push(rb_args, rb_str_new_utf8(refname));
-	rb_ary_push(rb_args, git_oid_iszero(src) ? Qnil : rugged_create_oid(src));
-	rb_ary_push(rb_args, git_oid_iszero(dest) ? Qnil : rugged_create_oid(dest));
+	error = git_remote_connect(remote, direction, &callbacks, NULL, &custom_headers);
+	git_remote_disconnect(remote);
+
+	xfree(custom_headers.strings);
 
-	rb_protect(rb_yield_splat, rb_args, exception);
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
 
-	return *exception ? GIT_ERROR : GIT_OK;
+	return error ? Qfalse : Qtrue;
 }
 
 /*
  *  call-seq:
- *    remote.update_tips! -> nil
- *    remote.update_tips! { |reference, source, destination| block }
+ *    remote.fetch(refspecs = nil, options = {}) -> hash
+ *
+ *  Downloads new data from the remote for the given +refspecs+ and updates tips.
+ *
+ *  You can optionally pass in a single or multiple alternative +refspecs+ to use instead of the fetch
+ *  refspecs already configured for +remote+.
+ *
+ *  Returns a hash containing statistics for the fetch operation.
+ *
+ *  The following options can be passed in the +options+ Hash:
  *
- *  Update the tips to a new state from a connected remote. The target
- *  objects must be downloaded before the tips are updated.
+ *  :credentials ::
+ *    The credentials to use for the fetch 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.
  *
- *      r.update_tips! do |ref, src, dst|
- *        puts "#{ref}: #{src}..#{dst}"
- *      end
+ *  :headers ::
+ *    Extra HTTP headers to include with the request (only applies to http:// or https:// remotes)
+ *
+ *  :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 is updated locally. It will be
+ *    passed the +refname+, +old_oid+ and +new_oid+.
+ *
+ *  :certificate_check ::
+ *    A callback that will be executed each time we validate a certificate using https. It
+ *    will be passed the +valid+, +host_name+ and the callback should return a true/false to
+ *    indicate if the certificate has been validated.
+ *
+ *  :message ::
+ *    The message to insert into the reflogs. Defaults to "fetch".
+ *
+ *  :prune ::
+ *    Specifies the prune mode for the fetch. +true+ remove any remote-tracking references that
+ *    no longer exist, +false+ do not prune, +nil+ use configured settings Defaults to "nil".
+ *
+ *  Example:
+ *
+ *    remote = Rugged::Remote.lookup(@repo, 'origin')
+ *    remote.fetch({
+ *      transfer_progress: lambda { |total_objects, indexed_objects, received_objects, local_objects, total_deltas, indexed_deltas, received_bytes|
+ *        # ...
+ *      }
+ *    })
  */
-static VALUE rb_git_remote_update_tips(VALUE self)
+static VALUE rb_git_remote_fetch(int argc, VALUE *argv, VALUE self)
 {
 	git_remote *remote;
+	git_strarray refspecs;
+	git_fetch_options opts = GIT_FETCH_OPTIONS_INIT;
+	const git_transfer_progress *stats;
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
 
-	Data_Get_Struct(self, git_remote, remote);
+	char *log_message = NULL;
+	int error;
 
-	if (rb_block_given_p()) {
-		int exception = 0, error;
-		git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	VALUE rb_options, rb_refspecs, rb_result = Qnil;
 
-		callbacks.payload = &exception;
-		callbacks.update_tips = &cb_remote__update_tips;
-		rugged_exception_check(
-			git_remote_set_callbacks(remote, &callbacks)
-		);
+	rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
 
-		error = git_remote_update_tips(remote);
+	rugged_rb_ary_to_strarray(rb_refspecs, &refspecs);
 
-		callbacks.update_tips = NULL;
-		// Don't overwrite the first error we've seen
-		if (!error) error = git_remote_set_callbacks(remote, &callbacks);
-		else git_remote_set_callbacks(remote, &callbacks);
+	Data_Get_Struct(self, git_remote, remote);
 
-		if (exception)
-			rb_jump_tag(exception);
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
+	init_custom_headers(rb_options, &opts.custom_headers);
 
-		rugged_exception_check(error);
-	} else {
-		rugged_exception_check(
-			git_remote_update_tips(remote)
-		);
-	}
+	if (!NIL_P(rb_options)) {
+		VALUE rb_prune_type;
+		VALUE rb_val = rb_hash_aref(rb_options, CSTR2SYM("message"));
 
-	return Qnil;
-}
+		if (!NIL_P(rb_val))
+			log_message = StringValueCStr(rb_val);
 
-/*
- *  call-seq:
- *    Remote.names(repository) -> array
- *
- *  Returns the names of all remotes in +repository+
- *
- *    Rugged::Remote.names(@repo) #=> ['origin', 'upstream']
- */
+		rb_prune_type = rb_hash_aref(rb_options, CSTR2SYM("prune"));
+		opts.prune = parse_prune_type(rb_prune_type);
+	}
 
-static VALUE rb_git_remote_names(VALUE klass, VALUE rb_repo)
-{
-	git_repository *repo;
-	git_strarray remotes;
-	VALUE rb_remote_names;
-	int error;
+	error = git_remote_fetch(remote, &refspecs, &opts, log_message);
 
-	rugged_check_repo(rb_repo);
+	xfree(refspecs.strings);
+	xfree(opts.custom_headers.strings);
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
 
-	error = git_remote_list(&remotes, repo);
 	rugged_exception_check(error);
 
-	rb_remote_names = rugged_strarray_to_rb_ary(&remotes);
-	git_strarray_free(&remotes);
-	return rb_remote_names;
-}
+	stats = git_remote_stats(remote);
 
-/* :nodoc: */
-static VALUE rb_git_remote_each(VALUE klass, VALUE rb_repo)
-{
-	git_repository *repo;
-	git_strarray remotes;
-	size_t i;
-	int error = 0;
-	int exception = 0;
-
-	if (!rb_block_given_p())
-		return rb_funcall(klass, rb_intern("to_enum"), 2, CSTR2SYM("each"), rb_repo);
-
-	rugged_check_repo(rb_repo);
-	Data_Get_Struct(rb_repo, git_repository, repo);
-
-	error = git_remote_list(&remotes, repo);
-	rugged_exception_check(error);
+	rb_result = rb_hash_new();
+	rb_hash_aset(rb_result, CSTR2SYM("total_objects"),    UINT2NUM(stats->total_objects));
+	rb_hash_aset(rb_result, CSTR2SYM("indexed_objects"),  UINT2NUM(stats->indexed_objects));
+	rb_hash_aset(rb_result, CSTR2SYM("received_objects"), UINT2NUM(stats->received_objects));
+	rb_hash_aset(rb_result, CSTR2SYM("local_objects"),    UINT2NUM(stats->local_objects));
+	rb_hash_aset(rb_result, CSTR2SYM("total_deltas"),     UINT2NUM(stats->total_deltas));
+	rb_hash_aset(rb_result, CSTR2SYM("indexed_deltas"),   UINT2NUM(stats->indexed_deltas));
+	rb_hash_aset(rb_result, CSTR2SYM("received_bytes"),   INT2FIX(stats->received_bytes));
 
-	for (i = 0; !exception && !error && i < remotes.count; ++i) {
-		git_remote *remote;
-		error = git_remote_load(&remote, repo, remotes.strings[i]);
-
-		if (!error) {
-			rb_protect(
-				rb_yield, rugged_remote_new(klass, rb_repo, remote),
-				&exception);
-		}
-	}
-
-	git_strarray_free(&remotes);
-
-	if (exception)
-		rb_jump_tag(exception);
-
-	rugged_exception_check(error);
-	return Qnil;
+	return rb_result;
 }
 
 /*
  *  call-seq:
- *    remote.save -> true
+ *    remote.push(refspecs = nil, options = {}) -> hash
  *
- *  Saves the remote data ( url, fetchspecs, ...) to the config
+ *  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.
  *
- *  One can't save a in-memory remote created with Remote.new.
- *  Doing so will result in an exception being raised.
-*/
-static VALUE rb_git_remote_save(VALUE self)
-{
-	git_remote *remote;
-
-	Data_Get_Struct(self, git_remote, remote);
-
-	rugged_exception_check(
-		git_remote_save(remote)
-	);
-	return Qtrue;
-}
-
-static int cb_remote__rename_problem(const char* refspec_name, void *payload)
-{
-	rb_ary_push((VALUE) payload, rb_str_new_utf8(refspec_name));
-	return 0;
-}
-
-/*
- *  call-seq:
- *    remote.rename!(new_name) -> array or nil
+ *  You can optionally pass in an alternative list of +refspecs+ to use instead of the push
+ *  refspecs already configured for +remote+.
  *
- *  Renames a remote
+ *  The following options can be passed in the +options+ Hash:
  *
- *  All remote-tracking branches and configuration settings
- *  for the remote are updated.
+ *  :credentials ::
+ *    The credentials to use for the push 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.
  *
- *  Returns +nil+ if everything was updated or array of fetch refspecs
- *  that haven't been automatically updated and need potential manual
- *  tweaking.
+ *  :update_tips ::
+ *    A callback that will be executed each time a reference is updated remotely. It will be
+ *    passed the +refname+, +old_oid+ and +new_oid+.
  *
- *  A temporary in-memory remote, created with Remote.new
- *  cannot be given a name with this method.
- *    remote = Rugged::Remote.lookup(@repo, 'origin')
- *    remote.rename!('upstream') #=> nil
+ *  :headers ::
+ *    Extra HTTP headers to include with the push (only applies to http:// or https:// remotes)
+ *
+ *  Example:
  *
-*/
-static VALUE rb_git_remote_rename(VALUE self, VALUE rb_new_name)
+ *    remote = Rugged::Remote.lookup(@repo, 'origin')
+ *    remote.push(["refs/heads/master", ":refs/heads/to_be_deleted"])
+ */
+static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 {
+	VALUE rb_refspecs, rb_options;
+
 	git_remote *remote;
+	git_strarray refspecs;
+	git_push_options opts = GIT_PUSH_OPTIONS_INIT;
+
 	int error = 0;
-	VALUE rb_refspec_ary = rb_ary_new();
 
-	Check_Type(rb_new_name, T_STRING);
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, Qnil, rb_hash_new(), 0 };
+
+	rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
+
+	rugged_rb_ary_to_strarray(rb_refspecs, &refspecs);
+
 	Data_Get_Struct(self, git_remote, remote);
-	error = git_remote_rename(
-			remote,
-			StringValueCStr(rb_new_name),
-			cb_remote__rename_problem, (void *)rb_refspec_ary);
+
+	rugged_remote_init_callbacks_and_payload_from_options(rb_options, &opts.callbacks, &payload);
+	init_custom_headers(rb_options, &opts.custom_headers);
+
+	error = git_remote_push(remote, &refspecs, &opts);
+
+	xfree(refspecs.strings);
+	xfree(opts.custom_headers.strings);
+
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
 
 	rugged_exception_check(error);
 
-	return RARRAY_LEN(rb_refspec_ary) == 0 ? Qnil : rb_refspec_ary;
+	return payload.result;
 }
 
 void Init_rugged_remote(void)
 {
 	rb_cRuggedRemote = rb_define_class_under(rb_mRugged, "Remote", rb_cObject);
 
-	rb_define_singleton_method(rb_cRuggedRemote, "new", rb_git_remote_new, 2);
-	rb_define_singleton_method(rb_cRuggedRemote, "add", rb_git_remote_add, 3);
-	rb_define_singleton_method(rb_cRuggedRemote, "lookup", rb_git_remote_lookup, 2);
-	rb_define_singleton_method(rb_cRuggedRemote, "names", rb_git_remote_names, 1);
-	rb_define_singleton_method(rb_cRuggedRemote, "each", rb_git_remote_each, 1);
-
-	rb_define_method(rb_cRuggedRemote, "connect", rb_git_remote_connect, 1);
-	rb_define_method(rb_cRuggedRemote, "disconnect", rb_git_remote_disconnect, 0);
 	rb_define_method(rb_cRuggedRemote, "name", rb_git_remote_name, 0);
 	rb_define_method(rb_cRuggedRemote, "url", rb_git_remote_url, 0);
-	rb_define_method(rb_cRuggedRemote, "url=", rb_git_remote_set_url, 1);
 	rb_define_method(rb_cRuggedRemote, "push_url", rb_git_remote_push_url, 0);
 	rb_define_method(rb_cRuggedRemote, "push_url=", rb_git_remote_set_push_url, 1);
 	rb_define_method(rb_cRuggedRemote, "fetch_refspecs", rb_git_remote_fetch_refspecs, 0);
 	rb_define_method(rb_cRuggedRemote, "push_refspecs", rb_git_remote_push_refspecs, 0);
-	rb_define_method(rb_cRuggedRemote, "add_fetch", rb_git_remote_add_fetch, 1);
-	rb_define_method(rb_cRuggedRemote, "add_push", rb_git_remote_add_push, 1);
-	rb_define_method(rb_cRuggedRemote, "connected?", rb_git_remote_connected, 0);
-	rb_define_method(rb_cRuggedRemote, "ls", rb_git_remote_ls, 0);
-	rb_define_method(rb_cRuggedRemote, "download", rb_git_remote_download, 0);
-	rb_define_method(rb_cRuggedRemote, "update_tips!", rb_git_remote_update_tips, 0);
-	rb_define_method(rb_cRuggedRemote, "clear_refspecs", rb_git_remote_clear_refspecs, 0);
-	rb_define_method(rb_cRuggedRemote, "save", rb_git_remote_save, 0);
-	rb_define_method(rb_cRuggedRemote, "rename!", rb_git_remote_rename, 1);
+	rb_define_method(rb_cRuggedRemote, "ls", rb_git_remote_ls, -1);
+	rb_define_method(rb_cRuggedRemote, "check_connection", rb_git_remote_check_connection, -1);
+	rb_define_method(rb_cRuggedRemote, "fetch", rb_git_remote_fetch, -1);
+	rb_define_method(rb_cRuggedRemote, "push", rb_git_remote_push, -1);
 }