curb 0.7.8 → 0.7.9

data/README

@@ -156,3 +156,9 @@ documentation with:
     requests.each do|url|
       puts responses[url]
     end
+
+### Easy Callbacks
+
+on_success:  is called when the response code is 20x
+on_failure: is called when the response code is not success, including redirects e.g. 30x
+on_complete: is called in all cases.

data/ext/curb.h

@@ -20,11 +20,11 @@
 #include "curb_macros.h"
 
 // These should be managed from the Rake 'release' task.
-#define CURB_VERSION   "0.7.8"
-#define CURB_VER_NUM   708
+#define CURB_VERSION   "0.7.9"
+#define CURB_VER_NUM   790
 #define CURB_VER_MAJ   0
 #define CURB_VER_MIN   7
-#define CURB_VER_MIC   8
+#define CURB_VER_MIC   9
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_easy.c

@@ -137,7 +137,7 @@ static int proc_debug_handler(CURL *curl,
 
 /* ================== MARK/FREE FUNC ==================*/
 void curl_easy_mark(ruby_curl_easy *rbce) {
-  rb_gc_mark(rbce->opts);
+  if (!NIL_P(rbce->opts)) { rb_gc_mark(rbce->opts); }
   if (!NIL_P(rbce->multi)) { rb_gc_mark(rbce->multi); }
 }
 
@@ -181,6 +181,8 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->connect_timeout = 0;
   rbce->dns_cache_timeout = 60;
   rbce->ftp_response_timeout = 0;
+  rbce->low_speed_limit = 0;
+  rbce->low_speed_time = 0;
   rbce->ssl_version = -1;
   rbce->use_ssl = -1;
   rbce->ftp_filemethod = -1;
@@ -197,6 +199,7 @@ static void ruby_curl_easy_zero(ruby_curl_easy *rbce) {
   rbce->verbose = 0;
   rbce->multipart_form_post = 0;
   rbce->enable_cookies = 0;
+  rbce->ignore_content_length = 0;
 }
 
 /*
@@ -225,14 +228,15 @@ static VALUE ruby_curl_easy_new(int argc, VALUE *argv, VALUE klass) {
     rb_raise(eCurlErrFailedInit, "Failed to initialize easy handle");
   }
 
+  new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
+
   rbce->multi = Qnil;
+  rbce->opts  = Qnil;
 
   ruby_curl_easy_zero(rbce);
 
   rb_easy_set("url", url);
 
-  new_curl = Data_Wrap_Struct(klass, curl_easy_mark, curl_easy_free, rbce);
-
   /* set the new_curl pointer to the curl handle */
   ecode = curl_easy_setopt(rbce->curl, CURLOPT_PRIVATE, (void*)new_curl);
   if (ecode != CURLE_OK) {
@@ -331,6 +335,12 @@ static VALUE ruby_curl_easy_reset(VALUE self) {
     raise_curl_easy_error_exception(ecode);
   }
 
+  /* Free everything up */
+  if (rbce->curl_headers) {
+    curl_slist_free_all(rbce->curl_headers);
+    rbce->curl_headers = NULL;
+  }
+
   return opts_dup;
 }
 
@@ -826,7 +836,7 @@ static VALUE ruby_curl_easy_put_data_set(VALUE self, VALUE data) {
         rb_hash_aset(headers, rb_str_new2("Expect"), rb_str_new2(""));
       }
       size = rb_funcall(stat, rb_intern("size"), 0);
-      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2INT(size));
+      curl_easy_setopt(curl, CURLOPT_INFILESIZE, FIX2LONG(size));
     }
     else if( rb_hash_aref(headers, rb_str_new2("Transfer-Encoding")) == Qnil ) {
       rb_hash_aset(headers, rb_str_new2("Transfer-Encoding"), rb_str_new2("chunked"));
@@ -1002,7 +1012,8 @@ static VALUE ruby_curl_easy_http_auth_types_set(int argc, VALUE *argv, VALUE sel
 
   rb_scan_args(argc, argv, "*", &args_ary);
   Data_Get_Struct(self, ruby_curl_easy, rbce);
-  len = RARRAY_LEN(args_ary);
+
+  len = (int)RARRAY_LEN(args_ary);
 
   if (len == 1 && (TYPE(rb_ary_entry(args_ary,0)) == T_FIXNUM || rb_ary_entry(args_ary,0) == Qnil)) {
     if (rb_ary_entry(args_ary,0) == Qnil) { 
@@ -1188,6 +1199,51 @@ static VALUE ruby_curl_easy_ftp_response_timeout_get(VALUE self, VALUE ftp_respo
   CURB_IMMED_GETTER(ruby_curl_easy, ftp_response_timeout, 0);
 }
 
+/*
+ * call-seq:
+ *   easy.low_speed_limit = fixnum or nil        => fixnum or nil
+ *
+ * Set the transfer speed (in bytes per second) that the transfer should be
+ * below during +low_speed_time+ seconds for the library to consider it too
+ * slow and abort.
+ */
+static VALUE ruby_curl_easy_low_speed_limit_set(VALUE self, VALUE low_speed_limit) {
+  CURB_IMMED_SETTER(ruby_curl_easy, low_speed_limit, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.low_speed_limit                        => fixnum or nil
+ *
+ * Obtain the minimum transfer speed over +low_speed+time+ below which the
+ * transfer will be aborted.
+ */
+static VALUE ruby_curl_easy_low_speed_limit_get(VALUE self, VALUE low_speed_limit) {
+  CURB_IMMED_GETTER(ruby_curl_easy, low_speed_limit, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.low_speed_time = fixnum or nil        => fixnum or nil
+ *
+ * Set the time (in seconds) that the transfer should be below the
+ * +low_speed_limit+ for the library to consider it too slow and abort.
+ */
+static VALUE ruby_curl_easy_low_speed_time_set(VALUE self, VALUE low_speed_time) {
+  CURB_IMMED_SETTER(ruby_curl_easy, low_speed_time, 0);
+}
+
+/*
+ * call-seq:
+ *   easy.low_speed_time                        => fixnum or nil
+ *
+ * Obtain the time that the transfer should be below +low_speed_limit+ for
+ * the library to abort it.
+ */
+static VALUE ruby_curl_easy_low_speed_time_get(VALUE self, VALUE low_speed_time) {
+  CURB_IMMED_GETTER(ruby_curl_easy, low_speed_time, 0);
+}
+
 /*
  * call-seq:
  *   easy.username = string                           => string
@@ -1425,8 +1481,8 @@ static VALUE ruby_curl_easy_header_in_body_set(VALUE self, VALUE header_in_body)
  * call-seq:
  *   easy.header_in_body?                             => boolean
  *
- * Determine whether this Curl instance will verify the SSL peer
- * certificate.
+ * Determine whether this Curl instance will return HTTP headers
+ * combined with body data.
  */
 static VALUE ruby_curl_easy_header_in_body_q(VALUE self) {
   CURB_BOOLEAN_GETTER(ruby_curl_easy, header_in_body);
@@ -1592,6 +1648,31 @@ static VALUE ruby_curl_easy_enable_cookies_q(VALUE self) {
   CURB_BOOLEAN_GETTER(ruby_curl_easy, enable_cookies);
 }
 
+/*
+ * call-seq:
+ *   easy.ignore_content_length = boolean
+ *
+ * Configure whether this Curl::Easy instance should ignore the content
+ * length header.
+ */
+static VALUE ruby_curl_easy_ignore_content_length_set(VALUE self, VALUE ignore_content_length)
+{
+  CURB_BOOLEAN_SETTER(ruby_curl_easy, ignore_content_length);
+}
+
+/*
+ * call-seq:
+ *   easy.ignore_content_length?                             => boolean
+ *
+ * Determine whether this Curl::Easy instance ignores the content
+ * length header.
+ */
+static VALUE ruby_curl_easy_ignore_content_length_q(VALUE self) {
+  CURB_BOOLEAN_GETTER(ruby_curl_easy, ignore_content_length);
+}
+
+
+
 /* ================= EVENT PROCS ================== */
 
 /*
@@ -1895,6 +1976,9 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce ) {
   curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, rbce->connect_timeout);
   curl_easy_setopt(curl, CURLOPT_DNS_CACHE_TIMEOUT, rbce->dns_cache_timeout);
 
+  curl_easy_setopt(curl, CURLOPT_IGNORE_CONTENT_LENGTH, rbce->ignore_content_length);
+
+
 #if LIBCURL_VERSION_NUM >= 0x070a08
   curl_easy_setopt(curl, CURLOPT_FTP_RESPONSE_TIMEOUT, rbce->ftp_response_timeout);
 #else
@@ -1903,6 +1987,9 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce ) {
   }
 #endif
 
+  curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, rbce->low_speed_limit);
+  curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, rbce->low_speed_time);
+
   // Set up localport / proxy port
   // FIXME these won't get returned to default if they're unset Ruby
   if (rbce->proxy_port > 0) {
@@ -2054,10 +2141,10 @@ VALUE ruby_curl_easy_setup( ruby_curl_easy *rbce ) {
 VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
 
   CURL *curl = rbce->curl;
-  struct curl_slist *headers = rbce->curl_headers;
-  // Free everything up
-  if (headers) {
-    curl_slist_free_all(headers);
+
+  /* Free everything up */
+  if (rbce->curl_headers) {
+    curl_slist_free_all(rbce->curl_headers);
     rbce->curl_headers = NULL;
   }
 
@@ -2067,7 +2154,7 @@ VALUE ruby_curl_easy_cleanup( VALUE self, ruby_curl_easy *rbce ) {
     rbce->curl_ftp_commands = NULL;
   }
 
-  // clean up a PUT request's curl options.
+  /* clean up a PUT request's curl options. */
   if (!rb_easy_nil("upload")) {
     rb_easy_del("upload"); // set the upload object to Qnil to let the GC clean up
     curl_easy_setopt(curl, CURLOPT_UPLOAD, 0);
@@ -2132,7 +2219,7 @@ static VALUE ruby_curl_easy_perform_get(VALUE self) {
 /*
  * Common implementation of easy.http(verb) and easy.http_delete
  */
-static VALUE ruby_curl_easy_perform_verb_str(VALUE self, char *verb) {
+static VALUE ruby_curl_easy_perform_verb_str(VALUE self, const char *verb) {
   ruby_curl_easy *rbce;
   CURL *curl;
   VALUE retval;
@@ -3042,9 +3129,9 @@ static VALUE ruby_curl_easy_escape(VALUE self, VALUE svalue) {
   if( rb_type(str) != T_STRING ) { str = rb_funcall(str,rb_intern("to_s"),0); }
 
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
-  result = (char*)curl_easy_escape(rbce->curl, StringValuePtr(str), RSTRING_LEN(str));
+  result = (char*)curl_easy_escape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str));
 #else
-  result = (char*)curl_escape(StringValuePtr(str), RSTRING_LEN(str));
+  result = (char*)curl_escape(StringValuePtr(str), (int)RSTRING_LEN(str));
 #endif
 
   rresult = rb_str_new2(result);
@@ -3070,7 +3157,7 @@ static VALUE ruby_curl_easy_unescape(VALUE self, VALUE str) {
   Data_Get_Struct(self, ruby_curl_easy, rbce);
 
 #if (LIBCURL_VERSION_NUM >= 0x070f04)
-  result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), RSTRING_LEN(str), &rlen);
+  result = (char*)curl_easy_unescape(rbce->curl, StringValuePtr(str), (int)RSTRING_LEN(str), &rlen);
 #else
   result = (char*)curl_unescape(StringValuePtr(str), RSTRING_LEN(str));
   rlen = strlen(result);
@@ -3274,6 +3361,10 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "dns_cache_timeout", ruby_curl_easy_dns_cache_timeout_get, 0);
   rb_define_method(cCurlEasy, "ftp_response_timeout=", ruby_curl_easy_ftp_response_timeout_set, 1);
   rb_define_method(cCurlEasy, "ftp_response_timeout", ruby_curl_easy_ftp_response_timeout_get, 0);
+  rb_define_method(cCurlEasy, "low_speed_limit=", ruby_curl_easy_low_speed_limit_set, 1);
+  rb_define_method(cCurlEasy, "low_speed_limit", ruby_curl_easy_low_speed_limit_get, 0);
+  rb_define_method(cCurlEasy, "low_speed_time=", ruby_curl_easy_low_speed_time_set, 1);
+  rb_define_method(cCurlEasy, "low_speed_time", ruby_curl_easy_low_speed_time_get, 0);
   rb_define_method(cCurlEasy, "ssl_version=", ruby_curl_easy_ssl_version_set, 1);
   rb_define_method(cCurlEasy, "ssl_version", ruby_curl_easy_ssl_version_get, 0);
   rb_define_method(cCurlEasy, "use_ssl=", ruby_curl_easy_use_ssl_set, 1);
@@ -3309,6 +3400,8 @@ void init_curb_easy() {
   rb_define_method(cCurlEasy, "multipart_form_post?", ruby_curl_easy_multipart_form_post_q, 0);
   rb_define_method(cCurlEasy, "enable_cookies=", ruby_curl_easy_enable_cookies_set, 1);
   rb_define_method(cCurlEasy, "enable_cookies?", ruby_curl_easy_enable_cookies_q, 0);
+  rb_define_method(cCurlEasy, "ignore_content_length=", ruby_curl_easy_ignore_content_length_set, 1);
+  rb_define_method(cCurlEasy, "ignore_content_length?", ruby_curl_easy_ignore_content_length_q, 0);
 
   rb_define_method(cCurlEasy, "on_body", ruby_curl_easy_on_body_set, -1);
   rb_define_method(cCurlEasy, "on_header", ruby_curl_easy_on_header_set, -1);

data/ext/curb_easy.h

@@ -51,6 +51,8 @@ typedef struct {
   unsigned long connect_timeout;
   long dns_cache_timeout;
   unsigned long ftp_response_timeout;
+  long low_speed_limit;
+  long low_speed_time;
   long ssl_version;
   long use_ssl;
   long ftp_filemethod;
@@ -67,6 +69,7 @@ typedef struct {
   char verbose;
   char multipart_form_post;
   char enable_cookies;
+  char ignore_content_length;
   struct curl_slist *curl_headers;
   struct curl_slist *curl_ftp_commands;
 

data/ext/curb_multi.c

@@ -456,7 +456,7 @@ VALUE ruby_curl_multi_perform(int argc, VALUE *argv, VALUE self) {
       }
 
       tv.tv_sec  = 0; /* never wait longer than 1 second */
-      tv.tv_usec = timeout_milliseconds * 1000;
+      tv.tv_usec = (int)(timeout_milliseconds * 1000); /* XXX: int is the right type for OSX, what about linux? */
 
       if (timeout_milliseconds == 0) { /* no delay */
         rb_curl_multi_run( self, rbcm->handle, &(rbcm->running) );

data/ext/curb_postfield.c

@@ -109,7 +109,7 @@ void append_to_form(VALUE self,
     } else {
       // is a content field
       if (rbcpf->content_proc != Qnil) {
-        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, self);
+        rbcpf->buffer_str = rb_funcall(rbcpf->content_proc, idCall, 1, self);
         
         if (rbcpf->content_type == Qnil) {
           result = curl_formadd(first, last, CURLFORM_PTRNAME, StringValuePtr(rbcpf->name), 
@@ -209,7 +209,7 @@ void curl_postfield_free(ruby_curl_postfield *rbcpf) {
  */
 static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass) {
   ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
-  
+ 
   // wierdness - we actually require two args, unless a block is provided, but
   // we have to work that out below.
   rb_scan_args(argc, argv, "12&", &rbcpf->name, &rbcpf->content, &rbcpf->content_type, &rbcpf->content_proc);
@@ -443,7 +443,7 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
       rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string %s:%d, make sure your field name responds_to :to_s", __FILE__, __LINE__);
     }
 
-    char *tmpchrs = curl_escape(StringValuePtr(name), RSTRING_LEN(name));
+    char *tmpchrs = curl_escape(StringValuePtr(name), (int)RSTRING_LEN(name));
     
     if (!tmpchrs) {
       rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name `%s'", tmpchrs);
@@ -472,7 +472,7 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
         }
       }
       //fprintf(stderr, "encoding content: %ld - %s\n", RSTRING_LEN(tmpcontent), RSTRING_PTR(tmpcontent) );
-      tmpchrs = curl_escape(RSTRING_PTR(tmpcontent), RSTRING_LEN(tmpcontent));
+      tmpchrs = curl_escape(RSTRING_PTR(tmpcontent), (int)RSTRING_LEN(tmpcontent));
       if (!tmpchrs) {
         rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
       } else {

data/ext/curb_upload.c

@@ -56,7 +56,7 @@ VALUE ruby_curl_upload_stream_get(VALUE self) {
 VALUE ruby_curl_upload_offset_set(VALUE self, VALUE offset) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);
-  rbcu->offset = FIX2INT(offset);
+  rbcu->offset = FIX2LONG(offset);
   return offset;
 }
 /*

data/ext/extconf.rb

@@ -1,5 +1,4 @@
 require 'mkmf'
-puts $CFLAGS.inspect
 
 dir_config('curl')
 

data/lib/curb.rb

@@ -26,16 +26,24 @@ module Curl
       def download(url, filename = url.split(/\?/).first.split(/\//).last, &blk)
         curl = Curl::Easy.new(url, &blk)
         
-        File.open(filename, "wb") do |output|
-          old_on_body = curl.on_body do |data| 
+        output = if filename.is_a? IO
+          filename.binmode if filename.respond_to?(:binmode)
+          filename
+        else
+          File.open(filename, 'wb')
+        end
+        
+        begin
+          old_on_body = curl.on_body do |data|
             result = old_on_body ?  old_on_body.call(data) : data.length
             output << data if result == data.length
             result
           end
-          
           curl.perform
-        end        
-
+        ensure
+          output.close rescue IOError
+        end
+        
         return curl
       end
     end
@@ -200,6 +208,7 @@ module Curl
       # when using the :post or :put method, urls should be a hash, including the individual post fields per post
       #
       def download(urls,easy_options={},multi_options={},download_paths=nil,&blk)
+        errors = []
         procs = []
         files = []
         urls_with_config = []
@@ -218,10 +227,11 @@ module Curl
             download_path = File.basename(url)
           end
 
-          lambda do|dp|
+          file = lambda do|dp|
             file = File.open(dp,"wb")
             procs << (lambda {|data| file.write data; data.size })
             files << file
+            file
           end.call(download_path)
 
           if urlcfg.is_a?(Hash)
@@ -229,17 +239,27 @@ module Curl
           else
             urls_with_config << {:url => url, :on_body => procs.last, :method => :get}.merge(easy_options)
           end
-          url_to_download_paths[url] = download_path # store for later
+          url_to_download_paths[url] = {:path => download_path, :file => file} # store for later
         end
 
         if blk
-          Curl::Multi.http(urls_with_config, multi_options) {|c,code,method| blk.call(c,url_to_download_paths[c.url]) }
+          # when injecting the block, ensure file is closed before yielding
+          Curl::Multi.http(urls_with_config, multi_options) do |c,code,method|
+            info = url_to_download_paths[c.url]
+            begin
+              file = info[:file]
+              files.reject!{|f| f == file }
+              file.close
+            rescue => e
+              errors << e
+            end
+            blk.call(c,info[:path])
+          end
         else
           Curl::Multi.http(urls_with_config, multi_options)
         end
 
       ensure
-        errors = []
         files.each {|f|
           begin
             f.close

data/tests/helper.rb

@@ -178,5 +178,6 @@ module TestServerMethods
       at_exit{exit_code.call}
 
     end
+  rescue Errno::EADDRINUSE
   end
 end

data/tests/tc_curl_download.rb

@@ -7,7 +7,7 @@ class TestCurbCurlDownload < Test::Unit::TestCase
     server_setup
   end
   
-  def test_download_url_to_file
+  def test_download_url_to_file_via_string
     dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
     dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
 
@@ -18,6 +18,49 @@ class TestCurbCurlDownload < Test::Unit::TestCase
     File.unlink(dl_path) if File.exist?(dl_path)
   end
 
+  def test_download_url_to_file_via_file_io
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+    dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
+    io = File.open(dl_path, 'wb')
+
+    curb = Curl::Easy.download(dl_url, io)
+    assert io.closed?
+    assert File.exist?(dl_path)
+    assert_equal File.read(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c')), File.read(dl_path)
+  ensure
+    File.unlink(dl_path) if File.exist?(dl_path)
+  end
+
+  def test_download_url_to_file_via_io
+    dl_url = "http://127.0.0.1:9129/ext/curb_easy.c"
+    dl_path = File.join(Dir::tmpdir, "dl_url_test.file")
+    reader, writer = IO.pipe
+
+    # Write to local file
+    fork do
+      begin
+        writer.close
+        File.open(dl_path, 'wb') { |file| file << reader.read }
+      ensure
+        reader.close rescue IOError # if the stream has already been closed
+      end
+    end
+
+    # Download remote source
+    begin
+      reader.close
+      curb = Curl::Easy.download(dl_url, writer)
+      Process.wait
+    ensure
+      writer.close rescue IOError # if the stream has already been closed, which occurs in Easy::download
+    end
+
+    assert File.exist?(dl_path)
+    assert_equal File.read(File.join(File.dirname(__FILE__), '..','ext','curb_easy.c')), File.read(dl_path)
+  ensure
+    File.unlink(dl_path) if File.exist?(dl_path)
+  end
+
   def test_download_bad_url_gives_404
     dl_url = "http://127.0.0.1:9129/this_file_does_not_exist.html"
     dl_path = File.join(Dir::tmpdir, "dl_url_test.file")

data/tests/tc_curl_easy.rb

@@ -354,6 +354,30 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert_equal 30, c.dns_cache_timeout
   end
   
+  def test_low_speed_limit_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.low_speed_limit
+    
+    c.low_speed_limit = 3
+    assert_equal 3, c.low_speed_limit
+    
+    c.low_speed_limit = nil
+    assert_nil c.low_speed_limit
+  end
+  
+  def test_low_speed_time_01
+    c = Curl::Easy.new($TEST_URL)
+    
+    assert_nil c.low_speed_time
+    
+    c.low_speed_time = 3
+    assert_equal 3, c.low_speed_time
+    
+    c.low_speed_time = nil
+    assert_nil c.low_speed_time
+  end
+  
   def test_on_body
     blk = lambda { |i| i.length }
     
@@ -476,6 +500,13 @@ class TestCurbCurlEasy < Test::Unit::TestCase
     assert c.multipart_form_post?
   end
 
+  def test_ignore_content_length
+    c = Curl::Easy.new
+    assert !c.ignore_content_length?
+    assert c.ignore_content_length = true
+    assert c.ignore_content_length?
+  end
+
   def test_enable_cookies
     c = Curl::Easy.new
     assert !c.enable_cookies?
@@ -664,24 +695,26 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   def test_cert
     curl = Curl::Easy.new(TestServlet.url)
     curl.cert= File.join(File.dirname(__FILE__),"cert.pem")
-    assert /cert.pem$/,curl.cert
+    assert_match /cert.pem$/,curl.cert
   end
 
   def test_cert_with_password
     curl = Curl::Easy.new(TestServlet.url)
     curl.cert= File.join(File.dirname(__FILE__),"cert.pem:password")
-    assert /cert.pem$/,curl.cert
+    assert_match /cert.pem$/,curl.cert
   end
 
   def test_cert_type
     curl = Curl::Easy.new(TestServlet.url)
     curl.certtype= "DER"
-    assert "DER", curl.certtype
+    assert_equal "DER", curl.certtype
   end
 
   def test_default_certtype
     curl = Curl::Easy.new(TestServlet.url)
-    assert "PEM", curl.certtype
+    assert_nil curl.certtype
+    curl.certtype = "PEM"
+    assert_equal "PEM", curl.certtype
   end
 
   # Generate a CA cert with instructions at
@@ -689,13 +722,13 @@ class TestCurbCurlEasy < Test::Unit::TestCase
   def test_ca_cert
     curl = Curl::Easy.new(TestServlet.url)
     curl.cacert= File.join(File.dirname(__FILE__),"cacert.pem")
-    assert /cacert.pem$/, curl.cacert
+    assert_match /cacert.pem$/, curl.cacert
   end
 
   def test_user_agent
     curl = Curl::Easy.new(TestServlet.url)
     curl.useragent= "Curb-Easy/Ruby"
-    assert /ScrubDog$/,curl.useragent
+    assert_equal "Curb-Easy/Ruby",curl.useragent
   end
 
   def test_username_password

data/tests/tc_curl_multi.rb

@@ -315,15 +315,20 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     downloads = []
     file_info = {}
     FileUtils.mkdir("tmp/")
+
+    # for each file store the size by file name
     Dir[File.dirname(__FILE__) + "/../ext/*.c"].each do|path|
       urls << (root_uri + File.basename(path))
       downloads << "tmp/" + File.basename(path)
-      file_info[File.basename(path)] = {:size => File.size(path)}
+      file_info[File.basename(path)] = {:size => File.size(path), :path => path}
     end
+
+    # start downloads
     Curl::Multi.download(urls,{},{},downloads) do|curl,download_path|
       assert_equal 200, curl.response_code
       assert File.exist?(download_path)
-      assert file_info[File.basename(download_path)][:size], File.size(download_path)
+      store = file_info[File.basename(download_path)]
+      assert_equal file_info[File.basename(download_path)][:size], File.size(download_path), "incomplete download: #{download_path}"
     end
   ensure
     FileUtils.rm_rf("tmp/")

data/tests/timeout.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'helper'))
+
+# Run server with: ruby -rubygems timeout_server.rb -p 9128
+
+# Note that curl requires all timeouts to be integers -
+# curl_easy_setopt does not have a provision for floating-point values
+
+class TestCurbTimeouts < Test::Unit::TestCase
+  def test_no_timeout_by_default
+    curl = Curl::Easy.new(wait_url(2))
+    start = Time.now
+    assert_equal true, curl.http_get
+    elapsed = Time.now - start
+    assert elapsed > 2
+  end
+  
+  def test_overall_timeout_on_dead_transfer
+    curl = Curl::Easy.new(wait_url(2))
+    curl.timeout = 1
+    assert_raise(Curl::Err::TimeoutError) do
+      curl.http_get
+    end
+  end
+  
+  def test_clearing_timeout
+    curl = Curl::Easy.new(wait_url(2))
+    curl.timeout = 1
+    curl.timeout = nil
+    start = Time.now
+    assert_equal true, curl.http_get
+    elapsed = Time.now - start
+    assert elapsed > 2
+  end
+  
+  def test_overall_timeout_on_slow_transfer
+    curl = Curl::Easy.new(serve_url(100, 2, 3))
+    curl.timeout = 1
+    # transfer is aborted despite data being exchanged
+    assert_raise(Curl::Err::TimeoutError) do
+      curl.http_get
+    end
+  end
+  
+  def test_low_speed_time_on_slow_transfer
+    curl = Curl::Easy.new(serve_url(100, 1, 3))
+    curl.low_speed_time = 2
+    # use default low_speed_limit of 1
+    assert true, curl.http_get
+  end
+  
+  def test_low_speed_time_on_very_slow_transfer
+    # send data slower than required
+    curl = Curl::Easy.new(serve_url(10, 2, 3))
+    curl.low_speed_time = 1
+    # XXX for some reason this test fails if low speed limit is not specified
+    curl.low_speed_limit = 1
+    # use default low_speed_limit of 1
+    assert_raise(Curl::Err::TimeoutError) do
+      curl.http_get
+    end
+  end
+  
+  def test_low_speed_limit_on_slow_transfer
+    curl = Curl::Easy.new(serve_url(10, 1, 3))
+    curl.low_speed_time = 2
+    curl.low_speed_limit = 1000
+    assert_raise(Curl::Err::TimeoutError) do
+      curl.http_get
+    end
+  end
+  
+  def test_clearing_low_speed_time
+    curl = Curl::Easy.new(serve_url(100, 2, 3))
+    curl.low_speed_time = 1
+    curl.low_speed_time = nil
+    assert_equal true, curl.http_get
+  end
+  
+  def test_clearing_low_speed_limit
+    curl = Curl::Easy.new(serve_url(10, 1, 3))
+    curl.low_speed_time = 2
+    curl.low_speed_limit = 1000
+    curl.low_speed_limit = nil
+    assert_equal true, curl.http_get
+  end
+  
+  private
+  
+  def wait_url(time)
+    "#{server_base}/wait/#{time}"
+  end
+  
+  def serve_url(chunk_size, time, count)
+    "#{server_base}/serve/#{chunk_size}/every/#{time}/for/#{count}"
+  end
+  
+  def server_base
+    'http://127.0.0.1:9128'
+  end
+end

data/tests/timeout_server.rb

@@ -0,0 +1,33 @@
+# This Sinatra application must be run with mongrel
+# or possibly with unicorn for the serve action to work properly.
+# See http://efreedom.com/Question/1-3669674/Streaming-Data-Sinatra-Rack-Application
+
+require 'sinatra'
+
+get '/wait/:time' do |time|
+  time = time.to_i
+  sleep(time)
+  "Slept #{time} at #{Time.now}"
+end
+
+# http://efreedom.com/Question/1-3027435/Way-Flush-Html-Wire-Sinatra
+class Streamer
+  def initialize(time, chunks)
+    @time = time
+    @chunks = chunks
+  end
+  
+  def each
+    @chunks.each do |chunk|
+      sleep(@time)
+      yield chunk
+    end
+  end
+end
+
+get '/serve/:chunk_size/every/:time/for/:count' do |chunk_size, time, count|
+  chunk_size, time, count = chunk_size.to_i, time.to_i, count.to_i
+  chunk = 'x' * chunk_size
+  chunks = [chunk] * count
+  Streamer.new(time, chunks)
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: curb
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: false
   segments: 
   - 0
   - 7
-  - 8
-  version: 0.7.8
+  - 9
+  version: 0.7.9
 platform: ruby
 authors: 
 - Ross Bamford
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-17 00:00:00 -04:00
+date: 2010-12-22 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -66,6 +66,8 @@ files:
 - tests/tc_curl_easy.rb
 - tests/tc_curl_multi.rb
 - tests/tc_curl_postfield.rb
+- tests/timeout.rb
+- tests/timeout_server.rb
 - tests/unittests.rb
 has_rdoc: true
 homepage: http://curb.rubyforge.org/
@@ -120,4 +122,6 @@ test_files:
 - tests/tc_curl_easy.rb
 - tests/tc_curl_multi.rb
 - tests/tc_curl_postfield.rb
+- tests/timeout.rb
+- tests/timeout_server.rb
 - tests/unittests.rb