curb 0.9.10 → 1.0.1

data/ext/curb_easy.c

@@ -268,6 +268,8 @@ void curl_easy_free(ruby_curl_easy *rbce) {
 static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->opts = rb_hash_new();
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   rbce->curl_headers = NULL;
   rbce->curl_proxy_headers = NULL;
   rbce->curl_ftp_commands = NULL;
@@ -327,9 +329,9 @@ static VALUE ruby_curl_easy_allocate(VALUE klass) {
 
 /*
  * call-seq:
- *   Curl::Easy.new                                   => #<Curl::Easy...>
- *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
- *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
+ *   Curl::Easy.new                                   => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil)                        => #<Curl::Easy...>
+ *   Curl::Easy.new(url = nil) { |self| ... }         => #<Curl::Easy...>
  *
  * Initialize a new Curl::Easy instance, optionally supplying the URL.
  * The block form allows further configuration to be supplied before
@@ -355,8 +357,9 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
 
   ruby_curl_easy_zero(rbce);
 
-  rb_easy_set("url", url);
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
 
+  rb_easy_set("url", url);
 
   /* set the pointer to the curl handle */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
@@ -373,8 +376,8 @@ static VALUE ruby_curl_easy_initialize(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.clone                                       => #&lt;easy clone&gt;
- *   easy.dup                                         => #&lt;easy clone&gt;
+ *   easy.clone                                       => <easy clone>
+ *   easy.dup                                         => <easy clone>
  *
  * Clone this Curl::Easy instance, creating a new instance.
  * This method duplicates the underlying CURL* handle.
@@ -392,6 +395,8 @@ static VALUE ruby_curl_easy_clone(VALUE self) {
   newrbce->curl_ftp_commands = NULL;
   newrbce->curl_resolve = NULL;
 
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+
   return Data_Wrap_Struct(cCurlEasy, curl_easy_mark, curl_easy_free, newrbce);
 }
 
@@ -461,7 +466,9 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
   curl_easy_reset(rbce->curl);
   ruby_curl_easy_zero(rbce);
 
-  /* rest clobbers the private setting, so reset it to self */
+  curl_easy_setopt(rbce->curl, CURLOPT_ERRORBUFFER, &rbce->err_buf);
+
+  /* reset clobbers the private setting, so reset it to self */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)self);
   if (ecode != CURLE_OK) {
     raise_curl_easy_error_exception(ecode);
@@ -950,7 +957,7 @@ static VALUE ruby_curl_easy_ftp_commands_set(VALUE self, VALUE ftp_commands) {
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.ftp_commands                                => array or nil
  */
 static VALUE ruby_curl_easy_ftp_commands_get(VALUE self) {
@@ -969,7 +976,7 @@ static VALUE ruby_curl_easy_resolve_set(VALUE self, VALUE resolve) {
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.resolve                                => array or nil
  */
 static VALUE ruby_curl_easy_resolve_get(VALUE self) {
@@ -1539,6 +1546,7 @@ static VALUE ruby_curl_easy_password_get(VALUE self, VALUE password) {
  *   Curl::CURL_SSLVERSION_TLSv1_0
  *   Curl::CURL_SSLVERSION_TLSv1_1
  *   Curl::CURL_SSLVERSION_TLSv1_2
+ *   Curl::CURL_SSLVERSION_TLSv1_3
  */
 static VALUE ruby_curl_easy_ssl_version_set(VALUE self, VALUE ssl_version) {
   CURB_IMMED_SETTER(ruby_curl_easy, ssl_version, -1);
@@ -1587,7 +1595,7 @@ static VALUE ruby_curl_easy_ftp_filemethod_set(VALUE self, VALUE ftp_filemethod)
 }
 
 /*
- * call-seq
+ * call-seq:
  *   easy.ftp_filemethod                              => fixnum
  *
  * Get the configuration for how libcurl will reach files on the server.
@@ -1959,7 +1967,7 @@ static VALUE ruby_curl_easy_resolve_mode_set(VALUE self, VALUE resolve_mode) {
 
 /*
  * call-seq:
- *   easy.on_body { |body_data| ... }                 => &lt;old handler&gt;
+ *   easy.on_body { |body_data| ... }                 => <old handler>
  *
  * Assign or remove the +on_body+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1978,7 +1986,7 @@ static VALUE ruby_curl_easy_on_body_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_success { |easy| ... }                   => &lt;old handler&gt;
+ *   easy.on_success { |easy| ... }                   => <old handler>
  *
  * Assign or remove the +on_success+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -1993,7 +2001,7 @@ static VALUE ruby_curl_easy_on_success_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_failure {|easy,code| ... }               => &lt;old handler&gt;
+ *   easy.on_failure {|easy,code| ... }               => <old handler>
  *
  * Assign or remove the +on_failure+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2008,7 +2016,7 @@ static VALUE ruby_curl_easy_on_failure_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *  easy.on_missing {|easy,code| ... }                => &lt;old handler;&gt;
+ *  easy.on_missing {|easy,code| ... }                => <old handler;>
  *
  *  Assign or remove the on_missing handler for this Curl::Easy instance.
  *  To remove a previously-supplied handler, call this method with no attached
@@ -2023,7 +2031,7 @@ static VALUE ruby_curl_easy_on_missing_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *  easy.on_redirect {|easy,code| ... }                => &lt;old handler;&gt;
+ *  easy.on_redirect {|easy,code| ... }                => <old handler;>
  *
  *  Assign or remove the on_redirect handler for this Curl::Easy instance.
  *  To remove a previously-supplied handler, call this method with no attached
@@ -2038,7 +2046,7 @@ static VALUE ruby_curl_easy_on_redirect_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_complete {|easy| ... }                   => &lt;old handler&gt;
+ *   easy.on_complete {|easy| ... }                   => <old handler>
  *
  * Assign or remove the +on_complete+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2052,7 +2060,7 @@ static VALUE ruby_curl_easy_on_complete_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_header { |header_data| ... }             => &lt;old handler&gt;
+ *   easy.on_header { |header_data| ... }             => <old handler>
  *
  * Assign or remove the +on_header+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2068,7 +2076,7 @@ static VALUE ruby_curl_easy_on_header_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => &lt;old handler&gt;
+ *   easy.on_progress { |dl_total, dl_now, ul_total, ul_now| ... } => <old handler>
  *
  * Assign or remove the +on_progress+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2089,7 +2097,7 @@ static VALUE ruby_curl_easy_on_progress_set(int argc, VALUE *argv, VALUE self) {
 
 /*
  * call-seq:
- *   easy.on_debug { |type, data| ... }               => &lt;old handler&gt;
+ *   easy.on_debug { |type, data| ... }               => <old handler>
  *
  * Assign or remove the +on_debug+ handler for this Curl::Easy instance.
  * To remove a previously-supplied handler, call this method with no
@@ -2128,11 +2136,14 @@ static VALUE cb_each_http_header(VALUE header, VALUE wrap) {
 
     name = rb_obj_as_string(rb_ary_entry(header, 0));
     value = rb_obj_as_string(rb_ary_entry(header, 1));
-
-    // This is a bit inefficient, but we don't want to be modifying
-    // the actual values in the original hash.
-    header_str = rb_str_plus(name, rb_str_new2(": "));
-    header_str = rb_str_plus(header_str, value);
+    if (rb_str_strlen(value) == 0) { // removing the header e.g. Accept: with nothing trailing should remove it see: https://curl.se/libcurl/c/CURLOPT_HTTPHEADER.html
+      header_str = rb_str_plus(name, rb_str_new2(":"));
+    } else {
+      // This is a bit inefficient, but we don't want to be modifying
+      // the actual values in the original hash.
+      header_str = rb_str_plus(name, rb_str_new2(": "));
+      header_str = rb_str_plus(header_str, value);
+    }
   } else {
     header_str = rb_obj_as_string(header);
   }
@@ -2607,6 +2618,8 @@ static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, verb);
 
   retval = rb_funcall(self, rb_intern("perform"), 0);
@@ -2672,6 +2685,8 @@ static VALUE ruby_curl_easy_perform_post(int argc, VALUE *argv, VALUE self) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
 
   if (rbce->multipart_form_post) {
@@ -2743,6 +2758,8 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
   curl = rbce->curl;
 
+  memset(rbce->err_buf, 0, sizeof(rbce->err_buf));
+
   curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, NULL);
   ruby_curl_easy_put_data_set(self, data);
 
@@ -2761,6 +2778,10 @@ static VALUE ruby_curl_easy_perform_put(VALUE self, VALUE data) {
  * your own body handler, this string will be empty.
  */
 static VALUE ruby_curl_easy_body_str_get(VALUE self) {
+  /*
+     TODO: can we force_encoding on the return here if we see charset=utf-8 in the content-type header?
+     Content-Type: application/json; charset=utf-8
+  */
   CURB_OBJECT_HGETTER(ruby_curl_easy, body_data);
 }
 
@@ -2955,7 +2976,7 @@ static VALUE ruby_curl_easy_connect_time_get(VALUE self) {
  * Retrieve the time, in seconds, it took from the start until the SSL/SSH
  * connect/handshake to the remote host was completed. This time is most often
  * very near to the pre transfer time, except for cases such as HTTP
- * pippelining where the pretransfer time can be delayed due to waits in line
+ * pipelining where the pretransfer time can be delayed due to waits in line
  * for the pipeline and more.
  */
 #if defined(HAVE_CURLINFO_APPCONNECT_TIME)
@@ -3448,6 +3469,21 @@ static VALUE ruby_curl_easy_last_result(VALUE self) {
   return LONG2NUM(rbce->last_result);
 }
 
+/*
+ * call-seq:
+ *   easy.last_error                                     => "Error details" or nil
+ */
+static VALUE ruby_curl_easy_last_error(VALUE self) {
+  ruby_curl_easy *rbce;
+  Data_Get_Struct(self, ruby_curl_easy, rbce);
+
+  if (rbce->err_buf[0]) {    // curl returns NULL or empty string if none
+    return rb_str_new2(rbce->err_buf);
+  } else {
+    return Qnil;
+  }
+}
+
 /*
  * call-seq:
  *   easy.setopt Fixnum, value  => value
@@ -3546,6 +3582,9 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
   case CURLOPT_TCP_NODELAY: {
     curl_easy_setopt(rbce->curl, CURLOPT_TCP_NODELAY, NUM2LONG(val));
     } break;
+  case CURLOPT_RANGE: {
+    curl_easy_setopt(rbce->curl, CURLOPT_RANGE, StringValueCStr(val));
+    } break;
   case CURLOPT_RESUME_FROM: {
     curl_easy_setopt(rbce->curl, CURLOPT_RESUME_FROM, NUM2LONG(val));
     } break;
@@ -3596,7 +3635,7 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
 #endif
 #if HAVE_CURLOPT_HAPROXYPROTOCOL
   case CURLOPT_HAPROXYPROTOCOL:
-    curl_easy_setopt(rbce->curl, HAVE_CURLOPT_HAPROXYPROTOCOL, NUM2LONG(val));
+    curl_easy_setopt(rbce->curl, CURLOPT_HAPROXYPROTOCOL, NUM2LONG(val));
     break;
 #endif
   case CURLOPT_STDERR:
@@ -3606,6 +3645,15 @@ static VALUE ruby_curl_easy_set_opt(VALUE self, VALUE opt, VALUE val) {
     GetOpenFile(val, open_f_ptr);
     curl_easy_setopt(rbce->curl, CURLOPT_STDERR, rb_io_stdio_file(open_f_ptr));
     break;
+  case CURLOPT_PROTOCOLS:
+  case CURLOPT_REDIR_PROTOCOLS:
+    curl_easy_setopt(rbce->curl, option, NUM2LONG(val));
+    break;
+#if HAVE_CURLOPT_SSL_SESSIONID_CACHE
+  case CURLOPT_SSL_SESSIONID_CACHE:
+    curl_easy_setopt(rbce->curl, CURLOPT_SSL_SESSIONID_CACHE, NUM2LONG(val));
+    break;
+#endif
   default:
     rb_raise(rb_eTypeError, "Curb unsupported option");
   }
@@ -3913,6 +3961,7 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "multi", ruby_curl_easy_multi_get, 0);
   rb_define_method(cCurlEasy, "multi=", ruby_curl_easy_multi_set, 1);
   rb_define_method(cCurlEasy, "last_result", ruby_curl_easy_last_result, 0);
+  rb_define_method(cCurlEasy, "last_error", ruby_curl_easy_last_error, 0);
 
   rb_define_method(cCurlEasy, "setopt", ruby_curl_easy_set_opt, 2);
   rb_define_method(cCurlEasy, "getinfo", ruby_curl_easy_get_opt, 1);

data/ext/curb_easy.h

@@ -36,6 +36,9 @@ typedef struct {
   /* The handler */
   CURL *curl;
 
+  /* Buffer for error details from CURLOPT_ERRORBUFFER */
+  char err_buf[CURL_ERROR_SIZE];
+
   VALUE opts; /* rather then allocate everything we might need to store, allocate a Hash and only store objects we actually use... */
   VALUE multi; /* keep a multi handle alive for each easy handle not being used by a multi handle.  This improves easy performance when not within a multi context */
 

data/ext/curb_multi.c

@@ -64,7 +64,7 @@ static void ruby_curl_multi_init(ruby_curl_multi *rbcm) {
 
 /*
  * call-seq:
- *   Curl::Multi.new                                   => #<Curl::Easy...>
+ *   Curl::Multi.new                                   => #<Curl::Easy...>
  *
  * Create a new Curl::Multi instance
  */
@@ -132,7 +132,7 @@ VALUE ruby_curl_multi_get_autoclose(VALUE klass) {
 
 /*
  * call-seq:
- *   multi.requests                                   => [#&lt;Curl::Easy...&gt;, ...]
+ *   multi.requests                                   => [#<Curl::Easy...>, ...]
  * 
  * Returns an array containing all the active requests on this Curl::Multi object.
  */
@@ -300,10 +300,14 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     rbce->callback_active = 1;
     val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
     rbce->callback_active = 0;
-    //rb_funcall( rb_easy_get("complete_proc"), idCall, 1, easy );
   }
 
+#ifdef HAVE_CURLINFO_RESPONSE_CODE
   curl_easy_getinfo(rbce->curl, CURLINFO_RESPONSE_CODE, &response_code);
+#else
+  // old libcurl
+  curl_easy_getinfo(rbce->curl, CURLINFO_HTTP_CODE, &response_code);
+#endif
 
   if (result != 0) {
     if (!rb_easy_nil("failure_proc")) {
@@ -313,8 +317,7 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
       rbce->callback_active = 0;
       //rb_funcall( rb_easy_get("failure_proc"), idCall, 2, easy, rb_curl_easy_error(result) );
     }
-  }
-  else if (!rb_easy_nil("success_proc") &&
+  } else if (!rb_easy_nil("success_proc") &&
           ((response_code >= 200 && response_code < 300) || response_code == 0)) {
     /* NOTE: we allow response_code == 0, in the case of non http requests e.g. reading from disk */
     callargs = rb_ary_new3(2, rb_easy_get("success_proc"), easy);
@@ -322,22 +325,19 @@ static void rb_curl_mutli_handle_complete(VALUE self, CURL *easy_handle, int res
     val = rb_rescue(call_status_handler1, callargs, callback_exception, Qnil);
     rbce->callback_active = 0;
     //rb_funcall( rb_easy_get("success_proc"), idCall, 1, easy );
-  }
-  else if (!rb_easy_nil("redirect_proc") &&
+  } else if (!rb_easy_nil("redirect_proc") &&
           (response_code >= 300 && response_code < 400)) {
     rbce->callback_active = 1;
     callargs = rb_ary_new3(3, rb_easy_get("redirect_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 0;
     val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
-  }
-  else if (!rb_easy_nil("missing_proc") &&
+  } else if (!rb_easy_nil("missing_proc") &&
           (response_code >= 400 && response_code < 500)) {
     rbce->callback_active = 1;
     callargs = rb_ary_new3(3, rb_easy_get("missing_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 0;
     val = rb_rescue(call_status_handler2, callargs, callback_exception, Qnil);
-  }
-  else if (!rb_easy_nil("failure_proc") &&
+  } else if (!rb_easy_nil("failure_proc") &&
           (response_code >= 500 && response_code <= 999)) {
     callargs = rb_ary_new3(3, rb_easy_get("failure_proc"), easy, rb_curl_easy_error(result));
     rbce->callback_active = 1;

data/ext/curb_postfield.c

@@ -195,9 +195,9 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
 
 /*
  * call-seq:
- *   Curl::PostField.content(name, content) => #<Curl::PostField...>
- *   Curl::PostField.content(name, content, content_type = nil) => #<Curl::PostField...>
- *   Curl::PostField.content(name, content_type = nil) { |field| ... } => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content) => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content, content_type = nil) => #<Curl::PostField...>
+ *   Curl::PostField.content(name, content_type = nil) { |field| ... } => #<Curl::PostField...>
  * 
  * Create a new Curl::PostField, supplying the field name, content,
  * and, optionally, Content-type (curl will attempt to determine this if
@@ -241,9 +241,9 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
 
 /*
  * call-seq:
- *   Curl::PostField.file(name, local_file_name) => #&lt;Curl::PostField...&gt;
- *   Curl::PostField.file(name, local_file_name, remote_file_name = local_file_name) => #&lt;Curl::PostField...&gt;
- *   Curl::PostField.file(name, remote_file_name) { |field| ... } => #&lt;Curl::PostField...&gt;
+ *   Curl::PostField.file(name, local_file_name) => #<Curl::PostField...>
+ *   Curl::PostField.file(name, local_file_name, remote_file_name = local_file_name) => #<Curl::PostField...>
+ *   Curl::PostField.file(name, remote_file_name) { |field| ... } => #<Curl::PostField...>
  * 
  * Create a new Curl::PostField for a file upload field, supplying the local filename
  * to read from, and optionally the remote filename (defaults to the local name).
@@ -399,7 +399,7 @@ static VALUE ruby_curl_postfield_remote_file_get(VALUE self) {
 
 /*
  * call-seq:
- *   field.set_content_proc { |field| ... }           => &lt;old proc&gt;
+ *   field.set_content_proc { |field| ... }           => <old proc>
  * 
  * Set a content proc for this field. This proc will be called during the
  * perform to supply the content for this field, overriding any setting

data/ext/extconf.rb

@@ -18,6 +18,8 @@ elsif !have_library('curl') or !have_header('curl/curl.h')
   fail <<-EOM
   Can't find libcurl or curl/curl.h
 
+  Make sure development libs (ie libcurl4-openssl-dev) are installed on the system.
+
   Try passing --with-curl-dir or --with-curl-lib and --with-curl-include
   options to extconf.
   EOM
@@ -341,6 +343,9 @@ have_constant :CURL_SSLVERSION_TLSv1_0
 have_constant :CURL_SSLVERSION_TLSv1_1
 have_constant :CURL_SSLVERSION_TLSv1_2
 
+# Added in 7.52.0
+have_constant :CURL_SSLVERSION_TLSv1_3
+
 have_constant "curlopt_ssl_verifypeer"
 have_constant "curlopt_cainfo"
 have_constant "curlopt_issuercert"
@@ -400,6 +405,37 @@ have_constant "curlopt_path_as_is"
 # added in 7.43.0
 have_constant "curlopt_pipewait"
 
+# protocol constants
+have_constant "curlproto_all"
+have_constant "curlproto_dict"
+have_constant "curlproto_file"
+have_constant "curlproto_ftp"
+have_constant "curlproto_ftps"
+have_constant "curlproto_gopher"
+have_constant "curlproto_http"
+have_constant "curlproto_https"
+have_constant "curlproto_imap"
+have_constant "curlproto_imaps"
+have_constant "curlproto_ldap"
+have_constant "curlproto_ldaps"
+have_constant "curlproto_pop3"
+have_constant "curlproto_pop3s"
+have_constant "curlproto_rtmp"
+have_constant "curlproto_rtmpe"
+have_constant "curlproto_rtmps"
+have_constant "curlproto_rtmpt"
+have_constant "curlproto_rtmpte"
+have_constant "curlproto_rtmpts"
+have_constant "curlproto_rtsp"
+have_constant "curlproto_scp"
+have_constant "curlproto_sftp"
+have_constant "curlproto_smb"
+have_constant "curlproto_smbs"
+have_constant "curlproto_smtp"
+have_constant "curlproto_smtps"
+have_constant "curlproto_telnet"
+have_constant "curlproto_tftp"
+
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end

data/lib/curl/easy.rb

@@ -21,7 +21,7 @@ module Curl
     #
     def status
       # Matches the last HTTP Status - following the HTTP protocol specification 'Status-Line = HTTP-Version SP Status-Code SP (Opt:)Reason-Phrase CRLF'
-      statuses = self.header_str.scan(/HTTP\/\d(\.\d)?\s(\d+\s.*)\r\n/).map{ |match| match[1] }
+      statuses = self.header_str.to_s.scan(/HTTP\/\d(\.\d)?\s(\d+\s.*)\r\n/).map {|match| match[1] }
       statuses.last.strip if statuses.length > 0
     end
 
@@ -75,8 +75,9 @@ module Curl
       end
 
       if self.last_result != 0 && self.on_failure.nil?
-        error = Curl::Easy.error(self.last_result)
-        raise error.first.new(self.head)
+        (err_class, err_summary) = Curl::Easy.error(self.last_result)
+        err_detail = self.last_error
+        raise err_class.new([err_summary, err_detail].compact.join(": "))
       end
 
       ret
@@ -320,7 +321,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.perform(url) { |easy| ... }           => #<Curl::Easy...>
+      #   Curl::Easy.perform(url) { |easy| ... }           => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls the general +perform+ method, before returning
@@ -338,7 +339,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_get(url) { |easy| ... }          => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_get(url) { |easy| ... }          => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_get+, before returning the new instance.
@@ -355,7 +356,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_head(url) { |easy| ... }         => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_head(url) { |easy| ... }         => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_head+, before returning the new instance.
@@ -409,7 +410,7 @@ module Curl
 
       #
       # call-seq:
-      #   Curl::Easy.http_delete(url) { |easy| ... }       => #&lt;Curl::Easy...&gt;
+      #   Curl::Easy.http_delete(url) { |easy| ... }       => #<Curl::Easy...>
       #
       # Convenience method that creates a new Curl::Easy instance with
       # the specified URL and calls +http_delete+, before returning the new instance.

data/lib/curl/multi.rb

@@ -144,7 +144,7 @@ module Curl
 
         max_connects.times do
           conf = urls_with_config.pop
-          add_free_handle.call conf, nil
+          add_free_handle.call(conf, nil) if conf
           break if urls_with_config.empty?
         end
 
@@ -153,7 +153,7 @@ module Curl
           if urls_with_config.size > 0 && free_handles.size > 0
             easy = free_handles.pop
             conf = urls_with_config.pop
-            add_free_handle.call conf, easy
+            add_free_handle.call(conf, easy) if conf
           end
         end
 

data/lib/curl.rb

@@ -9,12 +9,20 @@ require 'cgi'
 module Curl
 
   def self.http(verb, url, post_body=nil, put_data=nil, &block)
-    handle = Thread.current[:curb_curl] ||= Curl::Easy.new
-    handle.reset
+    if Thread.current[:curb_curl_yielding]
+      handle = Curl::Easy.new # we can't reuse this
+    else
+      handle = Thread.current[:curb_curl] ||= Curl::Easy.new
+      handle.reset
+    end
     handle.url = url
     handle.post_body = post_body if post_body
     handle.put_data = put_data if put_data
-    yield handle if block_given?
+    if block_given?
+      Thread.current[:curb_curl_yielding] = true
+      yield handle
+      Thread.current[:curb_curl_yielding] = false
+    end
     handle.http(verb)
     handle
   end

data/tests/helper.rb

@@ -143,7 +143,6 @@ module TestServerMethods
   def server_setup(port=9129,servlet=TestServlet)
     @__port = port
     if (@server ||= nil).nil? and !File.exist?(locked_file)
-
       File.open(locked_file,'w') {|f| f << 'locked' }
       if TEST_SINGLE_THREADED
         rd, wr = IO.pipe

data/tests/tc_curl_easy.rb

@@ -10,6 +10,14 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     Curl.reset
   end
 
+  def test_nested_easy_methods
+    easy = Curl.get(TestServlet.url) {|http|
+      res = Curl.get(TestServlet.url + '/not_here')
+      assert_equal 404, res.response_code
+    }
+    assert_equal 200, easy.response_code
+  end
+
   def test_curlopt_stderr_with_file
     # does not work with Tempfile directly
     path = Tempfile.new('curb_test_curlopt_stderr').path
@@ -21,7 +29,7 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     end
     output = File.read(path)
 
-    assert_match('HTTP/1.1 200 OK ', output)
+    assert_match(/HTTP\/1\.1\ 200\ OK(?:\ )?/, output)
     assert_match('Host: 127.0.0.1:9129', output)
   end