curb 0.6.5.0 → 0.8.4

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,11 +209,11 @@ 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);
-  
+
   // special handling if theres a block, second arg is actually content_type
   if (rbcpf->content_proc != Qnil) {
     if (rbcpf->content != Qnil) {
@@ -235,7 +235,7 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
   rbcpf->local_file = Qnil;
   rbcpf->remote_file = Qnil;
   rbcpf->buffer_str = Qnil;
-  
+ 
   return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
 }
 
@@ -253,11 +253,11 @@ static VALUE ruby_curl_postfield_new_content(int argc, VALUE *argv, VALUE klass)
  * data.
  */
 static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
-  // TODO needs to handle content-type too 
+  // TODO needs to handle content-type too
   ruby_curl_postfield *rbcpf = ALLOC(ruby_curl_postfield);
-  
+
   rb_scan_args(argc, argv, "21&", &rbcpf->name, &rbcpf->local_file, &rbcpf->remote_file, &rbcpf->content_proc);
-  
+
   // special handling if theres a block, second arg is actually remote name.
   if (rbcpf->content_proc != Qnil) {
     if (rbcpf->local_file != Qnil) {
@@ -267,7 +267,7 @@ static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
         // (correct block call form)
         rbcpf->remote_file = rbcpf->local_file;
       }
-      
+ 
       // Shouldn't get a local file, so can ignore it.
       rbcpf->local_file = Qnil;
     }
@@ -275,13 +275,13 @@ static VALUE ruby_curl_postfield_new_file(int argc, VALUE *argv, VALUE klass) {
     if (rbcpf->remote_file == Qnil) {
       rbcpf->remote_file = rbcpf->local_file;
     }
-  }    
-      
+  }
+ 
   /* assoc objects */
   rbcpf->content = Qnil;
   rbcpf->content_type = Qnil;
   rbcpf->buffer_str = Qnil;
-  
+ 
   return Data_Wrap_Struct(cCurlPostField, curl_postfield_mark, curl_postfield_free, rbcpf);
 }
 
@@ -424,55 +424,67 @@ static VALUE ruby_curl_postfield_to_str(VALUE self) {
   // FIXME This is using the deprecated curl_escape func
   ruby_curl_postfield *rbcpf;
   VALUE result = Qnil;
+  VALUE name = Qnil;
+  char *tmpchrs;
   
   Data_Get_Struct(self, ruby_curl_postfield, rbcpf);
 
-  if ((rbcpf->local_file == Qnil) && (rbcpf->remote_file == Qnil)) {
     if (rbcpf->name != Qnil) {
+      name = rbcpf->name;
+      if (rb_type(name) == T_STRING) {
+        name = rbcpf->name;
+      } else if (rb_respond_to(name,rb_intern("to_s"))) {
+        name = rb_funcall(name, rb_intern("to_s"), 0);
+      }
+      else {
+        name = Qnil; // we can't handle this object
+      }
+    }
+    if (name == Qnil) {
+      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(RSTRING_PTR(rbcpf->name), RSTRING_LEN(rbcpf->name));
+    tmpchrs = curl_escape(StringValuePtr(name), (int)RSTRING_LEN(name));
+    
+    if (!tmpchrs) {
+      rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name `%s'", tmpchrs);
+    } else {
+      VALUE tmpcontent = Qnil;
+      VALUE escd_name = rb_str_new2(tmpchrs);
+      curl_free(tmpchrs);
       
+      if (rbcpf->content_proc != Qnil) {
+        tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
+      } else if (rbcpf->content != Qnil) {
+        tmpcontent = rbcpf->content;
+      } else if (rbcpf->local_file != Qnil) {
+        tmpcontent = rbcpf->local_file;
+      } else if (rbcpf->remote_file != Qnil) {
+        tmpcontent = rbcpf->remote_file;
+      } else {
+        tmpcontent = rb_str_new2("");
+      }
+      if (TYPE(tmpcontent) != T_STRING) {
+        if (rb_respond_to(tmpcontent, rb_intern("to_s"))) {
+          tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
+        }
+        else {
+          rb_raise(rb_eRuntimeError, "postfield(%s) is not a string and does not respond_to to_s", RSTRING_PTR(escd_name) );
+        }
+      }
+      //fprintf(stderr, "encoding content: %ld - %s\n", RSTRING_LEN(tmpcontent), RSTRING_PTR(tmpcontent) );
+      tmpchrs = curl_escape(RSTRING_PTR(tmpcontent), (int)RSTRING_LEN(tmpcontent));
       if (!tmpchrs) {
-        rb_raise(eCurlErrInvalidPostField, "Failed to url-encode name `%s'", tmpchrs);
+        rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
       } else {
-        VALUE tmpcontent = Qnil;
-        VALUE escd_name = rb_str_new2(tmpchrs);
+        VALUE escd_content = rb_str_new2(tmpchrs);
         curl_free(tmpchrs);
         
-        if (rbcpf->content_proc != Qnil) {
-          tmpcontent = rb_funcall(rbcpf->content_proc, idCall, 1, self);
-        } else if (rbcpf->content != Qnil) {
-          tmpcontent = rbcpf->content;
-        } else {
-          tmpcontent = rb_str_new2("");
-        }
-        if (TYPE(tmpcontent) != T_STRING) {
-          if (rb_respond_to(tmpcontent, rb_intern("to_s"))) {
-            tmpcontent = rb_funcall(tmpcontent, rb_intern("to_s"), 0);
-          }
-          else {
-            rb_raise(rb_eRuntimeError, "postfield(%s) is not a string and does not respond_to to_s", RSTRING_PTR(escd_name) );
-          }
-        }
-        //fprintf(stderr, "encoding content: %ld - %s\n", RSTRING_LEN(tmpcontent), RSTRING_PTR(tmpcontent) );
-        tmpchrs = curl_escape(RSTRING_PTR(tmpcontent), RSTRING_LEN(tmpcontent));
-        if (!tmpchrs) {
-          rb_raise(eCurlErrInvalidPostField, "Failed to url-encode content `%s'", tmpchrs);
-        } else {
-          VALUE escd_content = rb_str_new2(tmpchrs);
-          curl_free(tmpchrs);
-          
-          result = escd_name;
-          rb_str_cat(result, "=", 1);
-          rb_str_concat(result, escd_content); 
-        }            
+        result = escd_name;
+        rb_str_cat(result, "=", 1);
+        rb_str_concat(result, escd_content); 
       }
-    } else {
-      rb_raise(eCurlErrInvalidPostField, "Cannot convert unnamed field to string %s:%d", __FILE__, __LINE__);
-    }      
-  } else {
-    rb_raise(eCurlErrInvalidPostField, "Cannot convert non-content field to string %s:%d", __FILE__, __LINE__);
-  }  
+    }
   
   return result;
 }

data/ext/curb_upload.c

@@ -11,7 +11,7 @@ VALUE cCurlUpload;
 #endif
 
 static void curl_upload_mark(ruby_curl_upload *rbcu) {
-  if (rbcu->stream) rb_gc_mark(rbcu->stream);
+  if (rbcu->stream && !NIL_P(rbcu->stream)) rb_gc_mark(rbcu->stream);
 }
 static void curl_upload_free(ruby_curl_upload *rbcu) {
   free(rbcu);
@@ -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')
 
@@ -36,16 +35,17 @@ end
 #  puts "Selected arch: #{archs.first}"
 #end
 
-def define(s)
-  $defs.push( format("-D HAVE_%s", s.to_s.upcase) )
+def define(s, v=1)
+  $defs.push( format("-D HAVE_%s=%d", s.to_s.upcase, v) )
 end
 
 def have_constant(name)
+  sname = name.is_a?(Symbol) ? name.to_s : name.upcase
   checking_for name do
     src = %{
       #include <curl/curl.h>
       int main() {
-        int test = (int)#{name.upcase};
+        int test = (int)#{sname};
         return 0;
       }
     }
@@ -53,6 +53,7 @@ def have_constant(name)
       define name
       true
     else
+      #define name, 0
       false
     end
   end
@@ -100,6 +101,13 @@ have_constant "curle_login_denied"
 # older than 7.16.3
 have_constant "curlmopt_maxconnects"
 
+have_constant "curlopt_seekfunction"
+have_constant "curlopt_seekdata"
+have_constant "curlopt_sockoptfunction"
+have_constant "curlopt_sockoptdata"
+have_constant "curlopt_opensocketfunction"
+have_constant "curlopt_opensocketdata"
+
 # additional consts
 have_constant "curle_conv_failed"
 have_constant "curle_conv_reqd"
@@ -111,13 +119,22 @@ have_constant "curle_again"
 have_constant "curle_ssl_crl_badfile"
 have_constant "curle_ssl_issuer_error"
 
+# added in 7.18.2
+have_constant "curlinfo_redirect_url"
+
 # username/password added in 7.19.1
 have_constant "curlopt_username"
 have_constant "curlopt_password"
+have_constant "curlinfo_primary_ip"
 
 # ie quirk added in 7.19.3
 have_constant "curlauth_digest_ie"
 
+# added in 7.15.1
+have_constant "curlftpmethod_multicwd"
+have_constant "curlftpmethod_nocwd"
+have_constant "curlftpmethod_singlecwd"
+
 # centos 4.5 build of libcurl
 have_constant "curlm_bad_socket"
 have_constant "curlm_unknown_option"
@@ -125,6 +142,215 @@ have_func("curl_multi_timeout")
 have_func("curl_multi_fdset")
 have_func("curl_multi_perform")
 
+# constants
+have_constant "curlopt_interleavefunction"
+have_constant "curlopt_interleavedata"
+have_constant "curlopt_chunk_bgn_function"
+have_constant "curlopt_chunk_end_function"
+have_constant "curlopt_chunk_data"
+have_constant "curlopt_fnmatch_function"
+have_constant "curlopt_fnmatch_data"
+have_constant "curlopt_errorbuffer"
+have_constant "curlopt_stderr"
+have_constant "curlopt_failonerror"
+have_constant "curlopt_url"
+have_constant "curlopt_protocols"
+have_constant "curlopt_redir_protocols"
+have_constant "curlopt_proxy"
+have_constant "curlopt_proxyport"
+have_constant "curlopt_proxytype"
+have_constant "curlopt_noproxy"
+have_constant "curlopt_httpproxytunnel"
+have_constant "curlopt_socks5_gssapi_service"
+have_constant "curlopt_socks5_gssapi_nec"
+have_constant "curlopt_interface"
+have_constant "curlopt_localport"
+have_constant "curlopt_dns_cache_timeout"
+have_constant "curlopt_dns_use_global_cache"
+have_constant "curlopt_buffersize"
+have_constant "curlopt_port"
+have_constant "curlopt_tcp_nodelay"
+have_constant "curlopt_address_scope"
+have_constant "curlopt_netrc"
+have_constant "curl_netrc_optional"
+have_constant "curl_netrc_ignored"
+have_constant "curl_netrc_required"
+have_constant "curlopt_netrc_file"
+have_constant "curlopt_userpwd"
+have_constant "curlopt_proxyuserpwd"
+have_constant "curlopt_username"
+have_constant "curlopt_password"
+have_constant "curlopt_password"
+have_constant "curlopt_password"
+have_constant "curlopt_httpauth"
+have_constant "curlauth_digest_ie"
+have_constant "curlauth_only"
+have_constant "curlopt_tlsauth_type"
+have_constant "curlopt_tlsauth_srp"
+have_constant "curlopt_tlsauth_username"
+have_constant "curlopt_tlsauth_password"
+have_constant "curlopt_proxyauth"
+have_constant "curlopt_autoreferer"
+have_constant "curlopt_encoding"
+have_constant "curlopt_followlocation"
+have_constant "curlopt_unrestricted_auth"
+have_constant "curlopt_maxredirs"
+have_constant "curlopt_postredir"
+have_constant "curlopt_put"
+have_constant "curlopt_post"
+have_constant "curlopt_postfields"
+have_constant "curlopt_postfieldsize"
+have_constant "curlopt_postfieldsize_large"
+have_constant "curlopt_copypostfields"
+have_constant "curlopt_httppost"
+have_constant "curlopt_referer"
+have_constant "curlopt_useragent"
+have_constant "curlopt_httpheader"
+have_constant "curlopt_http200aliases"
+have_constant "curlopt_cookie"
+have_constant "curlopt_cookiefile"
+have_constant "curlopt_cookiejar"
+have_constant "curlopt_cookiesession"
+have_constant "curlopt_cookielist"
+have_constant "curlopt_httpget"
+have_constant "curlopt_http_version"
+have_constant "curl_http_version_none"
+have_constant "curl_http_version_1_0"
+have_constant "curl_http_version_1_1"
+have_constant "curlopt_ignore_content_length"
+have_constant "curlopt_http_content_decoding"
+have_constant "curlopt_http_transfer_decoding"
+have_constant "curlopt_mail_from"
+have_constant "curlopt_mail_rcpt"
+have_constant "curlopt_tftp_blksize"
+have_constant "curlopt_ftpport"
+have_constant "curlopt_quote"
+have_constant "curlopt_postquote"
+have_constant "curlopt_prequote"
+have_constant "curlopt_dirlistonly"
+have_constant "curlopt_append"
+have_constant "curlopt_ftp_use_eprt"
+have_constant "curlopt_ftp_use_epsv"
+have_constant "curlopt_ftp_use_pret"
+have_constant "curlopt_ftp_create_missing_dirs"
+have_constant "curlopt_ftp_response_timeout"
+have_constant "curlopt_ftp_alternative_to_user"
+have_constant "curlopt_ftp_skip_pasv_ip"
+have_constant "curlopt_ftpsslauth"
+have_constant "curlftpauth_default"
+have_constant "curlftpauth_ssl"
+have_constant "curlftpauth_tls"
+have_constant "curlopt_ftp_ssl_ccc"
+have_constant "curlftpssl_ccc_none"
+have_constant "curlftpssl_ccc_passive"
+have_constant "curlftpssl_ccc_active"
+have_constant "curlopt_ftp_account"
+have_constant "curlopt_ftp_filemethod"
+have_constant "curlftpmethod_multicwd"
+have_constant "curlftpmethod_nocwd"
+have_constant "curlftpmethod_singlecwd"
+have_constant "curlopt_rtsp_request"
+have_constant "curl_rtspreq_options"
+have_constant "curl_rtspreq_describe"
+have_constant "curl_rtspreq_announce"
+have_constant "curl_rtspreq_setup"
+have_constant "curl_rtspreq_play"
+have_constant "curl_rtspreq_pause"
+have_constant "curl_rtspreq_teardown"
+have_constant "curl_rtspreq_get_parameter"
+have_constant "curl_rtspreq_set_parameter"
+have_constant "curl_rtspreq_record"
+have_constant "curl_rtspreq_receive"
+have_constant "curlopt_rtsp_session_id"
+have_constant "curlopt_rtsp_stream_uri"
+have_constant "curlopt_rtsp_transport"
+have_constant "curlopt_rtsp_header"
+have_constant "curlopt_rtsp_client_cseq"
+have_constant "curlopt_rtsp_server_cseq"
+have_constant "curlopt_transfertext"
+have_constant "curlopt_proxy_transfer_mode"
+have_constant "curlopt_crlf"
+have_constant "curlopt_range"
+have_constant "curlopt_resume_from"
+have_constant "curlopt_resume_from_large"
+have_constant "curlopt_customrequest"
+have_constant "curlopt_filetime"
+have_constant "curlopt_nobody"
+have_constant "curlopt_infilesize"
+have_constant "curlopt_infilesize_large"
+have_constant "curlopt_upload"
+have_constant "curlopt_maxfilesize"
+have_constant "curlopt_maxfilesize_large"
+have_constant "curlopt_timecondition"
+have_constant "curlopt_timevalue"
+have_constant "curlopt_timeout"
+have_constant "curlopt_timeout_ms"
+have_constant "curlopt_low_speed_limit"
+have_constant "curlopt_low_speed_time"
+have_constant "curlopt_max_send_speed_large"
+have_constant "curlopt_max_recv_speed_large"
+have_constant "curlopt_maxconnects"
+have_constant "curlopt_closepolicy"
+have_constant "curlopt_fresh_connect"
+have_constant "curlopt_forbid_reuse"
+have_constant "curlopt_connecttimeout"
+have_constant "curlopt_connecttimeout_ms"
+have_constant "curlopt_ipresolve"
+have_constant "curl_ipresolve_whatever"
+have_constant "curl_ipresolve_v4"
+have_constant "curl_ipresolve_v6"
+have_constant "curlopt_connect_only"
+have_constant "curlopt_use_ssl"
+have_constant "curlusessl_none"
+have_constant "curlusessl_try"
+have_constant "curlusessl_control"
+have_constant "curlusessl_all"
+have_constant "curlopt_resolve"
+have_constant "curlopt_sslcert"
+have_constant "curlopt_sslcerttype"
+have_constant "curlopt_sslkey"
+have_constant "curlopt_sslkeytype"
+have_constant "curlopt_keypasswd"
+have_constant "curlopt_sslengine"
+have_constant "curlopt_sslengine_default"
+have_constant "curlopt_sslversion"
+have_constant "curl_sslversion_default"
+have_constant :CURL_SSLVERSION_TLSv1
+have_constant :CURL_SSLVERSION_SSLv2
+have_constant :CURL_SSLVERSION_SSLv3
+have_constant "curlopt_ssl_verifypeer"
+have_constant "curlopt_cainfo"
+have_constant "curlopt_issuercert"
+have_constant "curlopt_capath"
+have_constant "curlopt_crlfile"
+have_constant "curlopt_ssl_verifyhost"
+have_constant "curlopt_certinfo"
+have_constant "curlopt_random_file"
+have_constant "curlopt_egdsocket"
+have_constant "curlopt_ssl_cipher_list"
+have_constant "curlopt_ssl_sessionid_cache"
+have_constant "curlopt_krblevel"
+have_constant "curlopt_ssh_auth_types"
+have_constant "curlopt_ssh_host_public_key_md5"
+have_constant "curlopt_ssh_public_keyfile"
+have_constant "curlopt_ssh_private_keyfile"
+have_constant "curlopt_ssh_knownhosts"
+have_constant "curlopt_ssh_keyfunction"
+have_constant "curlkhstat_fine_add_to_file"
+have_constant "curlkhstat_fine"
+have_constant "curlkhstat_reject"
+have_constant "curlkhstat_defer"
+have_constant "curlopt_ssh_keydata"
+have_constant "curlopt_private"
+have_constant "curlopt_share"
+have_constant "curlopt_new_file_perms"
+have_constant "curlopt_new_directory_perms"
+have_constant "curlopt_telnetoptions"
+# was obsoleted in August 2007 for 7.17.0, reused in April 2011 for 7.21.5
+have_constant "curle_not_built_in"
+
+have_constant "curle_obsolete" # removed in 7.24 ?
+
 if try_compile('int main() { return 0; }','-Wall')
   $CFLAGS << ' -Wall'
 end
@@ -167,5 +393,7 @@ test_for("curl_easy_escape", "CURL_EASY_ESCAPE", %{
   }
 })
 
+have_func('rb_thread_blocking_region')
+
 create_header('curb_config.h')
 create_makefile('curb_core')

data/lib/curb.rb

@@ -1,186 +1 @@
-require 'curb_core'
-
-module Curl
-
-  class Easy
-    class << self
-    
-      # call-seq:
-      #   Curl::Easy.download(url, filename = url.split(/\?/).first.split(/\//).last) { |curl| ... }
-      #   
-      # Stream the specified url (via perform) and save the data directly to the
-      # supplied filename (defaults to the last component of the URL path, which will 
-      # usually be the filename most simple urls).
-      # 
-      # If a block is supplied, it will be passed the curl instance prior to the
-      # perform call.
-      # 
-      # *Note* that the semantics of the on_body handler are subtly changed when using
-      # download, to account for the automatic routing of data to the specified file: The 
-      # data string is passed to the handler *before* it is written
-      # to the file, allowing the handler to perform mutative operations where 
-      # necessary. As usual, the transfer will be aborted if the on_body handler
-      # returns a size that differs from the data chunk size - in this case, the 
-      # offending chunk will *not* be written to the file, the file will be closed,
-      # and a Curl::Err::AbortedByCallbackError will be raised.
-      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| 
-            result = old_on_body ?  old_on_body.call(data) : data.length
-            output << data if result == data.length
-            result
-          end
-          
-          curl.perform
-        end        
-
-        return curl
-      end
-    end
-
-    # Allow the incoming cert string to be file:password
-    # but be careful to not use a colon from a windows file path
-    # as the split point. Mimic what curl's main does
-    alias_method :native_cert=, :cert=
-    def cert=(cert_file)
-      pos = cert_file.rindex(':')
-      if pos && pos > 1
-        self.native_cert= cert_file[0..pos-1]
-        self.certpassword= cert_file[pos+1..-1]
-      else
-        self.native_cert= cert_file
-      end
-      self.cert
-    end
-  end
-
-  class Multi
-    class << self
-      # call-seq:
-      #   Curl::Multi.get('url1','url2','url3','url4','url5', :follow_location => true) do|easy|
-      #     easy
-      #   end
-      # 
-      # Blocking call to fetch multiple url's in parallel.
-      def get(urls, easy_options={}, multi_options={}, &blk)
-        url_confs = []
-        urls.each do|url|
-          url_confs << {:url => url, :method => :get}.merge(easy_options)
-        end
-        self.http(url_confs, multi_options) {|c,code,method| blk.call(c) }
-      end
-
-      # call-seq:
-      #
-      #   Curl::Multi.post([{:url => 'url1', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}},
-      #                     {:url => 'url2', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}},
-      #                     {:url => 'url3', :post_fields => {'field1' => 'value1', 'field2' => 'value2'}}],
-      #                    { :follow_location => true, :multipart_form_post => true },
-      #                    {:pipeline => true }) do|easy|
-      #     easy_handle_on_request_complete
-      #   end
-      # 
-      # Blocking call to POST multiple form's in parallel.
-      # 
-      # urls_with_config: is a hash of url's pointing to the postfields to send 
-      # easy_options: are a set of common options to set on all easy handles
-      # multi_options: options to set on the Curl::Multi handle
-      #
-      def post(urls_with_config, easy_options={}, multi_options={}, &blk)
-        url_confs = []
-        urls_with_config.each do|uconf|
-          url_confs << uconf.merge(:method => :post).merge(easy_options)
-        end
-        self.http(url_confs, multi_options) {|c,code,method| blk.call(c) }
-      end
-
-      # call-seq:
-      #
-      #   Curl::Multi.put([{:url => 'url1', :put_data => "some message"},
-      #                    {:url => 'url2', :put_data => IO.read('filepath')},
-      #                    {:url => 'url3', :put_data => "maybe another string or socket?"],
-      #                    {:follow_location => true},
-      #                    {:pipeline => true }) do|easy|
-      #     easy_handle_on_request_complete
-      #   end
-      # 
-      # Blocking call to POST multiple form's in parallel.
-      # 
-      # urls_with_config: is a hash of url's pointing to the postfields to send 
-      # easy_options: are a set of common options to set on all easy handles
-      # multi_options: options to set on the Curl::Multi handle
-      #
-      def put(urls_with_config, easy_options={}, multi_options={}, &blk)
-        url_confs = []
-        urls_with_config.each do|uconf|
-          url_confs << uconf.merge(:method => :put).merge(easy_options)
-        end
-        self.http(url_confs, multi_options) {|c,code,method| blk.call(c) }
-      end
-
-
-      # call-seq:
-      #
-      # Curl::Multi.http( [
-      #   { :url => 'url1', :method => :post,
-      #     :post_fields => {'field1' => 'value1', 'field2' => 'value2'} },
-      #   { :url => 'url2', :method => :get,
-      #     :follow_location => true, :max_redirects => 3 },
-      #   { :url => 'url3', :method => :put, :put_data => File.open('file.txt','rb') },
-      #   { :url => 'url4', :method => :head }
-      # ], {:pipeline => true})
-      #
-      # Blocking call to issue multiple HTTP requests with varying verb's.
-      #
-      # urls_with_config: is a hash of url's pointing to the easy handle options as well as the special option :method, that can by one of [:get, :post, :put, :delete, :head], when no verb is provided e.g. :method => nil -> GET is used
-      # multi_options: options for the multi handle 
-      # blk: a callback, that yeilds when a handle is completed
-      #
-      def http(urls_with_config, multi_options={}, &blk)
-        m = Curl::Multi.new
-        # configure the multi handle
-        multi_options.each { |k,v| m.send("#{k}=", v) }
-
-        urls_with_config.each do|conf|
-          c = conf.dup # avoid being destructive to input
-          url     = c.delete(:url)
-          method  = c.delete(:method)
-          headers = c.delete(:headers)
-
-          easy    = Curl::Easy.new(url)
-
-          case method
-          when :post
-            fields = c.delete(:post_fields)
-            # set the post post using the url fields
-            easy.post_body = fields.map{|f,k| "#{easy.escape(f)}=#{easy.escape(k)}"}.join('&')
-          when :put
-            easy.put_data = c.delete(:put_data)
-          when :head
-            easy.head = true
-          when :delete
-            easy.delete = true
-          when :get
-          else
-            # XXX: nil is treated like a GET
-          end
-
-          # headers is a special key
-          headers.each {|k,v| easy.headers[k] = v } if headers
- 
-          #
-          # use the remaining options as specific configuration to the easy handle
-          # bad options should raise an undefined method error
-          #
-          c.each { |k,v| easy.send("#{k}=",v) }
-
-          easy.on_complete {|curl,code| blk.call(curl,code,method) } if blk
-          m.add(easy)
-        end
-        m.perform
-      end
-    end
-  end
-end
+require 'curl'