rugged 0.19.0 → 0.21.0

data/ext/rugged/rugged_remote.c

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  *
- * Copyright (c) 2013 GitHub, Inc
+ * 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
@@ -26,198 +26,165 @@
 
 extern VALUE rb_mRugged;
 extern VALUE rb_cRuggedRepo;
+extern VALUE rb_eRuggedError;
 VALUE rb_cRuggedRemote;
 
-static void rb_git_remote__free(git_remote *remote)
-{
-	git_remote_free(remote);
-}
+#define RUGGED_REMOTE_CALLBACKS_INIT {1, progress_cb, NULL, credentials_cb, transfer_progress_cb, update_tips_cb, NULL}
 
-VALUE rugged_remote_new(VALUE klass, VALUE owner, git_remote *remote)
+static int progress_cb(const char *str, int len, void *data)
 {
-	VALUE rb_remote;
+	struct rugged_remote_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(2);
 
-	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->progress))
+		return 0;
 
-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");
+	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;
 }
 
-/*
- *  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 transfer_progress_cb(const git_transfer_progress *stats, void *data)
 {
-	git_remote *remote;
-	git_repository *repo;
-	int error;
-
-	rugged_check_repo(rb_repo);
-	rugged_validate_remote_url(rb_url);
+	struct rugged_remote_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(5);
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	if (NIL_P(payload->transfer_progress))
+		return 0;
 
-	error = git_remote_create_inmemory(
-			&remote,
-			repo,
-			NULL,
-			StringValueCStr(rb_url));
+	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));
 
-	rugged_exception_check(error);
+	rb_protect(rugged__block_yield_splat, args, &payload->exception);
 
-	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 update_tips_cb(const char *refname, const git_oid *src, const git_oid *dest, void *data)
 {
-	git_remote *remote;
-	git_repository *repo;
-	int error;
-
-	Check_Type(rb_name, T_STRING);
-	rugged_validate_remote_url(rb_url);
-	rugged_check_repo(rb_repo);
+	struct rugged_remote_cb_payload *payload = data;
+	VALUE args = rb_ary_new2(4);
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	if (NIL_P(payload->update_tips))
+		return 0;
 
-	error = git_remote_create(
-			&remote,
-			repo,
-			StringValueCStr(rb_name),
-			StringValueCStr(rb_url));
+	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));
 
-	rugged_exception_check(error);
+	rb_protect(rugged__block_yield_splat, args, &payload->exception);
 
-	return rugged_remote_new(klass, rb_repo, remote);
+	return payload->exception ? GIT_ERROR : GIT_OK;
 }
 
-/*
- *  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, rb_options, name) \
+	do {							\
+		ret = rb_hash_aref(rb_options, CSTR2SYM(name)); \
+								\
+		if (!NIL_P(ret) && !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)
+{
+	git_remote_callbacks prefilled = RUGGED_REMOTE_CALLBACKS_INIT;
 
-	if (rb_block_given_p()) {
-		rb_protect(rb_yield, self, &exception);
-		git_remote_disconnect(remote);
+	prefilled.payload = payload;
+	memcpy(callbacks, &prefilled, sizeof(git_remote_callbacks));
 
-		if (exception)
-			rb_jump_tag(exception);
-	}
+	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");
+}
 
-	return Qnil;
+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(git_remote_head *head)
+static VALUE rugged_rhead_new(const git_remote_head *head)
 {
 	VALUE rb_head = rb_hash_new();
 
@@ -230,48 +197,78 @@ 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.
  */
-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;
+	const git_remote_head **heads;
+
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+
+	VALUE rb_options;
+
+	int error;
+	size_t heads_len, i;
+
 	Data_Get_Struct(self, git_remote, remote);
 
+	rb_scan_args(argc, argv, ":", &rb_options);
+
 	if (!rb_block_given_p())
-		return rb_funcall(self, rb_intern("to_enum"), 1, CSTR2SYM("ls"));
+		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);
+
+	if ((error = git_remote_set_callbacks(remote, &callbacks)) ||
+	    (error = git_remote_connect(remote, GIT_DIRECTION_FETCH)) ||
+	    (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);
+
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
 
-	if (exception)
-		rb_jump_tag(exception);
 	rugged_exception_check(error);
 
 	return Qnil;
@@ -281,7 +278,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 +298,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)
@@ -316,6 +315,7 @@ static VALUE rb_git_remote_url(VALUE self)
  *
  *  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)
@@ -337,6 +337,7 @@ static VALUE rb_git_remote_set_url(VALUE self, VALUE rb_url)
  *
  *  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,6 +357,7 @@ 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)
@@ -397,7 +399,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,7 +410,7 @@ 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)
 {
@@ -438,7 +440,7 @@ static VALUE rb_git_remote_add_refspec(VALUE self, VALUE rb_refspec, git_directi
  *  call-seq:
  *    remote.add_fetch(refspec) -> nil
  *
- *  Add a fetch refspec to the remote
+ *  Add a fetch refspec to the remote.
  */
 static VALUE rb_git_remote_add_fetch(VALUE self, VALUE rb_refspec)
 {
@@ -449,7 +451,7 @@ static VALUE rb_git_remote_add_fetch(VALUE self, VALUE rb_refspec)
  *  call-seq:
  *    remote.add_push(refspec) -> nil
  *
- *  Add a push refspec to the remote
+ *  Add a push refspec to the remote.
  */
 static VALUE rb_git_remote_add_push(VALUE self, VALUE rb_refspec)
 {
@@ -475,251 +477,346 @@ static VALUE rb_git_remote_clear_refspecs(VALUE self)
 
 /*
  *  call-seq:
- *    remote.connected? -> true or false
+ *    remote.save -> true
  *
- *  Returns if the remote is connected
+ *  Saves the remote data (url, fetchspecs, ...) to the config.
  *
- *    remote.connected? #=> false
- *    remote.connect(:fetch)
- *    remote.connected? #=> true
+ *  Anonymous, in-memory remotes created through
+ *  +ReferenceCollection#create_anonymous+ can not be saved.
+ *  Doing so will result in an exception being raised.
  */
-static VALUE rb_git_remote_connected(VALUE self)
+static VALUE rb_git_remote_save(VALUE self)
 {
 	git_remote *remote;
+
 	Data_Get_Struct(self, git_remote, remote);
 
-	return git_remote_connected(remote) ? Qtrue : Qfalse;
+	rugged_exception_check(
+		git_remote_save(remote)
+	);
+	return Qtrue;
 }
 
 /*
  *  call-seq:
- *    remote.download() -> nil
+ *    remote.rename!(new_name) -> array or nil
  *
- *  Download the packfile from a connected remote
+ *  Renames a remote.
+ *
+ *  All remote-tracking branches and configuration settings
+ *  for the remote are updated.
  *
- *  Negotiate what objects should be downloaded and download the
- *  packfile with those objects.
+ *  Returns +nil+ if everything was updated or array of fetch refspecs
+ *  that haven't been automatically updated and need potential manual
+ *  tweaking.
  *
- *    remote.connect(:fetch) do |r|
- *      r.download
- *    end
+ *  Anonymous, in-memory remotes created through
+ *  +ReferenceCollection#create_anonymous+ can not be given a name through
+ *  this method.
+ *
+ *    remote = Rugged::Remote.lookup(@repo, 'origin')
+ *    remote.rename!('upstream') #=> nil
  */
-static VALUE rb_git_remote_download(VALUE self)
+static VALUE rb_git_remote_rename(VALUE self, VALUE rb_new_name)
 {
-	int error;
 	git_remote *remote;
+	git_strarray problems = {0};
+	VALUE rb_result;
 
+	Check_Type(rb_new_name, T_STRING);
 	Data_Get_Struct(self, git_remote, remote);
+	
+	rugged_exception_check(
+		git_remote_rename(&problems, remote, StringValueCStr(rb_new_name))
+	);
 
-	error = git_remote_download(remote, NULL, NULL);
-	rugged_exception_check(error);
-
-	return Qnil;
-}
-
-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));
-
-	rb_protect(rb_yield_splat, rb_args, exception);
-
-	return *exception ? GIT_ERROR : GIT_OK;
+	rb_result = problems.count == 0 ? Qnil : rugged_strarray_to_rb_ary(&problems);
+	git_strarray_free(&problems);
+	return rb_result;
 }
 
 /*
  *  call-seq:
- *    remote.update_tips! -> nil
- *    remote.update_tips! { |reference, source, destination| block }
+ *    remote.fetch(refspecs = nil, options = {}) -> hash
  *
- *  Update the tips to a new state from a connected remote. The target
- *  objects must be downloaded before the tips are updated.
+ *  Downloads new data from the remote for the given +refspecs+ and updates tips.
  *
- *      r.update_tips! do |ref, src, dst|
- *        puts "#{ref}: #{src}..#{dst}"
- *      end
+ *  You can optionally pass in an alternative list of +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:
+ *
+ *  :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.
+ *
+ *  :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+.
+ *
+ *  :message ::
+ *    The message to insert into the reflogs. Defaults to "fetch".
+ *
+ *  :signature ::
+ *    The signature to be used for updating the reflogs.
+ *
+ *  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_remote *remote, *tmp_remote = NULL;
+	git_repository *repo;
+	git_signature *signature = NULL;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, Qnil, 0 };
+
+	char *log_message = NULL;
+	int error, i;
+
+	VALUE rb_options, rb_refspecs, rb_result = Qnil, rb_repo = rugged_owner(self);
+
+	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);
+		}
+	}
 
 	Data_Get_Struct(self, git_remote, remote);
+	rugged_check_repo(rb_repo);
+	Data_Get_Struct(rb_repo, git_repository, repo);
 
-	if (rb_block_given_p()) {
-		int exception = 0, error;
-		git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	if (!NIL_P(rb_options)) {
+		VALUE rb_val = rb_hash_aref(rb_options, CSTR2SYM("signature"));
+		if (!NIL_P(rb_val))
+			signature = rugged_signature_get(rb_val, repo);
 
-		callbacks.payload = &exception;
-		callbacks.update_tips = &cb_remote__update_tips;
-		rugged_exception_check(
-			git_remote_set_callbacks(remote, &callbacks)
-		);
+		rb_val = rb_hash_aref(rb_options, CSTR2SYM("message"));
+		if (!NIL_P(rb_val))
+			log_message = StringValueCStr(rb_val);
 
-		error = git_remote_update_tips(remote);
+		rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+	}
 
-		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);
+	if ((error = git_remote_dup(&tmp_remote, remote)) ||
+		(error = git_remote_set_callbacks(tmp_remote, &callbacks)))
+		goto cleanup;
 
-		if (exception)
-			rb_jump_tag(exception);
+	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);
 
-		rugged_exception_check(error);
-	} else {
-		rugged_exception_check(
-			git_remote_update_tips(remote)
-		);
+			if ((error = git_remote_add_fetch(tmp_remote, StringValueCStr(rb_refspec))))
+				goto cleanup;
+		}
 	}
 
-	return Qnil;
+	if ((error = git_remote_fetch(tmp_remote, signature, log_message)) == GIT_OK) {
+		const git_transfer_progress *stats = git_remote_stats(tmp_remote);
+
+		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));
+	}
+
+	cleanup:
+
+	git_signature_free(signature);
+	git_remote_free(tmp_remote);
+
+	if (payload.exception)
+		rb_jump_tag(payload.exception);
+
+	rugged_exception_check(error);
+
+	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.names(repository) -> array
+ *    remote.push(refspecs = nil, options = {}) -> hash
+ *
+ *  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.
+ *
+ *  You can optionally pass in an alternative list of +refspecs+ to use instead of the push
+ *  refspecs already configured for +remote+.
+ *
+ *  The following options can be passed in the +options+ Hash:
+ *
+ *  :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.
+ *
+ *  :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+.
  *
- *  Returns the names of all remotes in +repository+
+ *  :message ::
+ *    A single line log message to be appended to the reflog of each local remote-tracking
+ *    branch that gets updated. Defaults to: "fetch".
  *
- *    Rugged::Remote.names(@repo) #=> ['origin', 'upstream']
+ *  :signature ::
+ *    The signature to be used for populating the reflog entries.
+ *
+ *  Example:
+ *
+ *    remote = Rugged::Remote.lookup(@repo, 'origin')
+ *    remote.push(["refs/heads/master", ":refs/heads/to_be_deleted"])
  */
-
-static VALUE rb_git_remote_names(VALUE klass, VALUE rb_repo)
+static VALUE rb_git_remote_push(int argc, VALUE *argv, VALUE self)
 {
-	git_repository *repo;
-	git_strarray remotes;
-	VALUE rb_remote_names;
-	int error;
-
-	rugged_check_repo(rb_repo);
+	VALUE rb_refspecs, rb_options, rb_val;
+	VALUE rb_repo = rugged_owner(self);
+	VALUE rb_exception = Qnil, rb_result = rb_hash_new();
 
-	Data_Get_Struct(rb_repo, git_repository, repo);
+	git_repository *repo;
+	git_remote *remote, *tmp_remote = NULL;
+	git_remote_callbacks callbacks = GIT_REMOTE_CALLBACKS_INIT;
+	git_push *push = NULL;
+	git_signature *signature = NULL;
 
-	error = git_remote_list(&remotes, repo);
-	rugged_exception_check(error);
+	int error = 0, i = 0;
+	char *log_message = NULL;
 
-	rb_remote_names = rugged_strarray_to_rb_ary(&remotes);
-	git_strarray_free(&remotes);
-	return rb_remote_names;
-}
+	struct rugged_remote_cb_payload payload = { Qnil, Qnil, Qnil, Qnil, 0 };
 
-/* :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;
+	rb_scan_args(argc, argv, "01:", &rb_refspecs, &rb_options);
 
-	if (!rb_block_given_p())
-		return rb_funcall(klass, rb_intern("to_enum"), 2, CSTR2SYM("each"), rb_repo);
+	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_check_repo(rb_repo);
 	Data_Get_Struct(rb_repo, git_repository, repo);
+	Data_Get_Struct(self, git_remote, remote);
 
-	error = git_remote_list(&remotes, repo);
-	rugged_exception_check(error);
+	if (!NIL_P(rb_options)) {
+		rugged_remote_init_callbacks_and_payload_from_options(rb_options, &callbacks, &payload);
+
+		rb_val = rb_hash_aref(rb_options, CSTR2SYM("message"));
+		if (!NIL_P(rb_val))
+			log_message = StringValueCStr(rb_val);
+
+		rb_val = rb_hash_aref(rb_options, CSTR2SYM("signature"));
+		if (!NIL_P(rb_val))
+			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)))
+	    goto cleanup;
 
-	for (i = 0; !exception && !error && i < remotes.count; ++i) {
-		git_remote *remote;
-		error = git_remote_load(&remote, repo, remotes.strings[i]);
+	if (!NIL_P(rb_refspecs)) {
+		git_remote_clear_refspecs(tmp_remote);
 
-		if (!error) {
-			rb_protect(
-				rb_yield, rugged_remote_new(klass, rb_repo, remote),
-				&exception);
+		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;
 		}
 	}
 
-	git_strarray_free(&remotes);
+	if ((error = git_push_new(&push, tmp_remote)))
+		goto cleanup;
 
-	if (exception)
-		rb_jump_tag(exception);
+	// TODO: Get rid of this once git_remote_push lands in libgit2.
+	{
+		git_strarray push_refspecs;
+		size_t i;
 
-	rugged_exception_check(error);
-	return Qnil;
-}
+		if ((error = git_remote_get_push_refspecs(&push_refspecs, tmp_remote)))
+			goto cleanup;
 
-/*
- *  call-seq:
- *    remote.save -> true
- *
- *  Saves the remote data ( url, fetchspecs, ...) to the config
- *
- *  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;
+		if (push_refspecs.count == 0) {
+			rb_exception = rb_exc_new2(rb_eRuggedError, "no pushspecs are configured for the given remote");
+			goto cleanup;
+		}
 
-	Data_Get_Struct(self, git_remote, remote);
+		for (i = 0; !error && i < push_refspecs.count; ++i) {
+			error = git_push_add_refspec(push, push_refspecs.strings[i]);
+		}
 
-	rugged_exception_check(
-		git_remote_save(remote)
-	);
-	return Qtrue;
-}
+		git_strarray_free(&push_refspecs);
+		if (error) goto cleanup;
+	}
 
-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;
-}
+	if ((error = git_push_finish(push)))
+		goto cleanup;
 
-/*
- *  call-seq:
- *    remote.rename!(new_name) -> array or nil
- *
- *  Renames a remote
- *
- *  All remote-tracking branches and configuration settings
- *  for the remote are updated.
- *
- *  Returns +nil+ if everything was updated or array of fetch refspecs
- *  that haven't been automatically updated and need potential manual
- *  tweaking.
- *
- *  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
- *
-*/
-static VALUE rb_git_remote_rename(VALUE self, VALUE rb_new_name)
-{
-	git_remote *remote;
-	int error = 0;
-	VALUE rb_refspec_ary = rb_ary_new();
+	if (!git_push_unpack_ok(push)) {
+		rb_exception = rb_exc_new2(rb_eRuggedError, "the remote side did not unpack successfully");
+		goto cleanup;
+	}
 
-	Check_Type(rb_new_name, T_STRING);
-	Data_Get_Struct(self, git_remote, remote);
-	error = git_remote_rename(
-			remote,
-			StringValueCStr(rb_new_name),
-			cb_remote__rename_problem, (void *)rb_refspec_ary);
+	if ((error = git_push_status_foreach(push, &push_status_cb, (void *)rb_result)) ||
+	    (error = git_push_update_tips(push, signature, log_message)))
+	    goto cleanup;
+
+cleanup:
+	git_push_free(push);
+	git_remote_free(tmp_remote);
+	git_signature_free(signature);
+
+	if (!NIL_P(rb_exception))
+		rb_exc_raise(rb_exception);
 
 	rugged_exception_check(error);
 
-	return RARRAY_LEN(rb_refspec_ary) == 0 ? Qnil : rb_refspec_ary;
+	return rb_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);
@@ -729,10 +826,9 @@ void Init_rugged_remote(void)
 	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, "ls", rb_git_remote_ls, -1);
+	rb_define_method(rb_cRuggedRemote, "fetch", rb_git_remote_fetch, -1);
+	rb_define_method(rb_cRuggedRemote, "push", rb_git_remote_push, -1);
 	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);