Remote revamp

ext/rugged/rugged.c

@@ -299,6 +299,25 @@ void rugged_exception_raise(void)
 	rb_exc_raise(err_obj);
 }
 
+VALUE rugged__block_yield_splat(VALUE args) {
+	VALUE block = rb_ary_shift(args);
+	int n = RARRAY_LENINT(args);
+
+	if (n == 0) {
+		return rb_funcall(block, rb_intern("call"), 0);
+	} else {
+		int i;
+		VALUE *argv;
+		argv = ALLOCA_N(VALUE, n);
+
+		for (i=0; i < n; i++) {
+			argv[i] = rb_ary_entry(args, i);
+		}
+
+		return rb_funcall2(block, rb_intern("call"), n, argv);
+	}
+}
+
 /*
  *  call-seq:
  *    Rugged.__cache_usage__ -> [current, max]

ext/rugged/rugged.h

@@ -93,6 +93,8 @@ VALUE rb_git_delta_file_fromC(const git_diff_file *file);
 void rugged_parse_diff_options(git_diff_options *opts, VALUE rb_options);
 void rugged_parse_merge_options(git_merge_options *opts, VALUE rb_options);
 
+void rugged_cred_extract(git_cred **cred, int allowed_types, VALUE rb_credential);
+
 VALUE rugged_otype_new(git_otype t);
 git_otype rugged_otype_get(VALUE rb_type);
 
@@ -131,11 +133,29 @@ static inline int rugged_parse_bool(VALUE boolean)
 
 extern VALUE rb_cRuggedRepo;
 
-struct rugged_cb_payload {
+VALUE rugged__block_yield_splat(VALUE args);
+
+struct rugged_cb_payload
+{
     VALUE rb_data;
     int exception;
 };
 
+struct rugged_remote_cb_payload
+{
+	VALUE progress;
+	VALUE completion;
+	VALUE transfer_progress;
+	VALUE update_tips;
+	VALUE credentials;
+	int exception;
+};
+
+void rugged_remote_init_callbacks_and_payload_from_options(
+	VALUE rb_options,
+	git_remote_callbacks *callbacks,
+	struct rugged_remote_cb_payload *payload);
+
 static inline void rugged_check_repo(VALUE rb_repo)
 {
 	if (!rb_obj_is_kind_of(rb_repo, rb_cRuggedRepo))

ext/rugged/rugged_cred.c

@@ -26,15 +26,100 @@
 
 extern VALUE rb_mRugged;
 VALUE rb_mRuggedCred;
-VALUE rb_cRuggedCredPlaintext;
+VALUE rb_cRuggedCredUserPassword;
 VALUE rb_cRuggedCredSshKey;
+VALUE rb_cRuggedCredSshKeyFromAgent;
 VALUE rb_cRuggedCredDefault;
 
+static void rugged_cred_extract_userpass(git_cred **cred, VALUE rb_credential)
+{
+	VALUE rb_username = rb_iv_get(rb_credential, "@username");
+	VALUE rb_password = rb_iv_get(rb_credential, "@password");
+
+	Check_Type(rb_username, T_STRING);
+	Check_Type(rb_password, T_STRING);
+
+	rugged_exception_check(
+		git_cred_userpass_plaintext_new(cred,
+			StringValueCStr(rb_username),
+			StringValueCStr(rb_password)
+		)
+	);
+}
+
+static void rugged_cred_extract_ssh_key(git_cred **cred, VALUE rb_credential)
+{
+	VALUE rb_username   = rb_iv_get(rb_credential, "@username");
+	VALUE rb_publickey  = rb_iv_get(rb_credential, "@publickey");
+	VALUE rb_privatekey = rb_iv_get(rb_credential, "@privatekey");
+	VALUE rb_passphrase = rb_iv_get(rb_credential, "@passphrase");
+
+	Check_Type(rb_username, T_STRING);
+	Check_Type(rb_privatekey, T_STRING);
+
+	if (!NIL_P(rb_publickey))
+		Check_Type(rb_publickey, T_STRING);
+	if (!NIL_P(rb_passphrase))
+		Check_Type(rb_passphrase, T_STRING);
+
+	rugged_exception_check(
+		git_cred_ssh_key_new(cred,
+			StringValueCStr(rb_username),
+			NIL_P(rb_publickey) ? NULL : StringValueCStr(rb_publickey),
+			StringValueCStr(rb_privatekey),
+			NIL_P(rb_passphrase) ? NULL : StringValueCStr(rb_passphrase)
+		)
+	);
+}
+
+static void rugged_credential_extract_ssh_key_from_agent(git_cred **cred, VALUE rb_credential)
+{
+	VALUE rb_username = rb_iv_get(rb_credential, "@username");
+
+	Check_Type(rb_username, T_STRING);
+
+	rugged_exception_check(
+		git_cred_ssh_key_from_agent(cred, StringValueCStr(rb_username))
+	);
+}
+
+static void rugged_cred_extract_default(git_cred **cred, VALUE rb_credential)
+{
+	rugged_exception_check(git_cred_default_new(cred));
+}
+
+void rugged_cred_extract(git_cred **cred, int allowed_types, VALUE rb_credential)
+{
+	if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredUserPassword)) {
+		if (!(allowed_types & GIT_CREDTYPE_USERPASS_PLAINTEXT))
+			rb_raise(rb_eArgError, "Invalid credential type");
+
+		rugged_cred_extract_userpass(cred, rb_credential);
+	} else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredSshKey)) {
+		if (!(allowed_types & GIT_CREDTYPE_SSH_KEY))
+			rb_raise(rb_eArgError, "Invalid credential type");
+
+		rugged_cred_extract_ssh_key(cred, rb_credential);
+	} else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredSshKeyFromAgent)) {
+		if (!(allowed_types & GIT_CREDTYPE_SSH_KEY))
+			rb_raise(rb_eArgError, "Invalid credential type");
+
+		rugged_credential_extract_ssh_key_from_agent(cred, rb_credential);
+	} else if (rb_obj_is_kind_of(rb_credential, rb_cRuggedCredDefault)) {
+		if (!(allowed_types & GIT_CREDTYPE_DEFAULT))
+			rb_raise(rb_eArgError, "Invalid credential type");
+
+		rugged_cred_extract_default(cred, rb_credential);
+	}
+}
+
+
 void Init_rugged_cred(void)
 {
-	rb_mRuggedCred          = rb_define_module_under(rb_mRugged, "Credentials");
+	rb_mRuggedCred                = rb_define_module_under(rb_mRugged, "Credentials");
 
-	rb_cRuggedCredPlaintext = rb_define_class_under(rb_mRuggedCred, "Plaintext", rb_cObject);
-	rb_cRuggedCredSshKey    = rb_define_class_under(rb_mRuggedCred, "SshKey", rb_cObject);
-	rb_cRuggedCredDefault   = rb_define_class_under(rb_mRuggedCred, "Default", rb_cObject);
+	rb_cRuggedCredUserPassword    = rb_define_class_under(rb_mRuggedCred, "UserPassword", rb_cObject);
+	rb_cRuggedCredSshKey          = rb_define_class_under(rb_mRuggedCred, "SshKey", rb_cObject);
+	rb_cRuggedCredSshKeyFromAgent = rb_define_class_under(rb_mRuggedCred, "SshKeyFromAgent", rb_cObject);
+	rb_cRuggedCredDefault         = rb_define_class_under(rb_mRuggedCred, "Default", rb_cObject);
 }