taf2-curb 0.4.5.0 → 0.4.6.0

data/doc.rb

@@ -34,7 +34,7 @@ begin
     end
   end
  
-  system("rdoc --title='Curb - libcurl bindings for ruby' --main=README #{pp_srcdir}/*.c README LICENSE ext/curb.rb")
+  system("rdoc --title='Curb - libcurl bindings for ruby' --main=README #{pp_srcdir}/*.c README LICENSE lib/curb.rb")
 ensure
   rm_rf(tmpdir)
 end

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.4.5.0"
-#define CURB_VER_NUM   450
+#define CURB_VERSION   "0.4.6.0"
+#define CURB_VER_NUM   460
 #define CURB_VER_MAJ   0
 #define CURB_VER_MIN   4
-#define CURB_VER_MIC   5
+#define CURB_VER_MIC   6
 #define CURB_VER_PATCH 0
 
 

data/ext/curb_multi.c

@@ -93,6 +93,51 @@ static VALUE ruby_curl_multi_new(VALUE klass) {
   return new_curlm;
 }
 
+// Hash#foreach callback for ruby_curl_multi_requests
+static int ruby_curl_multi_requests_callback(VALUE key, VALUE value, VALUE result_array) {
+  rb_ary_push(result_array, value);
+  
+  return ST_CONTINUE;
+}
+
+/*
+ * call-seq:
+ *   multi.requests                                   => [#<Curl::Easy...>, ...]
+ * 
+ * Returns an array containing all the active requests on this Curl::Multi object.
+ */
+static VALUE ruby_curl_multi_requests(VALUE self) {
+  ruby_curl_multi *rbcm;
+  
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  
+  VALUE result_array = rb_ary_new();
+  
+  // iterate over the requests hash, and stuff references into the array.
+  rb_hash_foreach( rbcm->requests, ruby_curl_multi_requests_callback, result_array );
+  
+  return result_array;
+}
+
+/*
+ * call-seq:
+ *   multi.idle?                                      => true or false
+ * 
+ * Returns whether or not this Curl::Multi handle is processing any requests.  E.g. this returns
+ * true when multi.requests.length == 0.
+ */
+static VALUE ruby_curl_multi_idle(VALUE self) {
+  ruby_curl_multi *rbcm;
+  
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  
+  if ( FIX2INT( rb_funcall(rbcm->requests, rb_intern("length"), 0) ) == 0 ) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
 /*
  * call-seq:
  * multi = Curl::Multi.new
@@ -185,7 +230,7 @@ static VALUE ruby_curl_multi_add(VALUE self, VALUE easy) {
  * # sometime later
  * multi.remove(easy)
  *
- * Remove an easy handle from a multi stack
+ * Remove an easy handle from a multi stack.
  *
  * Will raise an exception if the easy handle is not found
  */
@@ -226,6 +271,30 @@ static void rb_curl_multi_remove(ruby_curl_multi *rbcm, VALUE easy) {
   }
 }
 
+// Hash#foreach callback for ruby_curl_multi_cancel
+static int ruby_curl_multi_cancel_callback(VALUE key, VALUE value, ruby_curl_multi *rbcm) {
+  rb_curl_multi_remove(rbcm, value);
+  
+  return ST_CONTINUE;
+}
+
+/*
+ * call-seq:
+ *   multi.cancel!
+ * 
+ * Cancels all requests currently being made on this Curl::Multi handle.  
+ */
+static VALUE ruby_curl_multi_cancel(VALUE self) {
+  ruby_curl_multi *rbcm;
+
+  Data_Get_Struct(self, ruby_curl_multi, rbcm);
+  
+  rb_hash_foreach( rbcm->requests, ruby_curl_multi_cancel_callback, (VALUE)rbcm );
+  
+  // for chaining
+  return self;
+}
+
 static void rb_curl_multi_read_info(VALUE self, CURLM *multi_handle) {
   int msgs_left, result;
   CURLMsg *msg;
@@ -379,11 +448,16 @@ void init_curb_multi() {
 
   /* Class methods */
   rb_define_singleton_method(cCurlMulti, "new", ruby_curl_multi_new, 0);
-
+  
+  /* "Attributes" */
+  rb_define_method(cCurlMulti, "requests", ruby_curl_multi_requests, 0);
+  rb_define_method(cCurlMulti, "idle?", ruby_curl_multi_idle, 0);
+  
   /* Instnace methods */
   rb_define_method(cCurlMulti, "max_connects=", ruby_curl_multi_max_connects, 1);
   rb_define_method(cCurlMulti, "pipeline=", ruby_curl_multi_pipeline, 1);
   rb_define_method(cCurlMulti, "add", ruby_curl_multi_add, 1);
   rb_define_method(cCurlMulti, "remove", ruby_curl_multi_remove, 1);
+  rb_define_method(cCurlMulti, "cancel!", ruby_curl_multi_cancel, 0);
   rb_define_method(cCurlMulti, "perform", ruby_curl_multi_perform, 0);
 }

data/ext/curb_upload.c

@@ -6,6 +6,10 @@
 extern VALUE mCurl;
 VALUE cCurlUpload;
 
+#ifdef RDOC_NEVER_DEFINED
+  mCurl = rb_define_module("Curl");
+#endif
+
 static void curl_upload_mark(ruby_curl_upload *rbcu) {
   if (rbcu->stream) rb_gc_mark(rbcu->stream);
 }
@@ -13,6 +17,10 @@ static void curl_upload_free(ruby_curl_upload *rbcu) {
   free(rbcu);
 }
 
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_new(VALUE klass) {
   VALUE upload;
   ruby_curl_upload *rbcu = ALLOC(ruby_curl_upload);
@@ -22,23 +30,39 @@ VALUE ruby_curl_upload_new(VALUE klass) {
   return upload;
 }
 
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_stream_set(VALUE self, VALUE stream) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);
   rbcu->stream = stream;
   return stream;
 }
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_stream_get(VALUE self) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);
   return rbcu->stream;
 }
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 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);
   return offset;
 }
+/*
+ * call-seq:
+ *   internal class for sending large file uploads
+ */
 VALUE ruby_curl_upload_offset_get(VALUE self) {
   ruby_curl_upload *rbcu;
   Data_Get_Struct(self, ruby_curl_upload, rbcu);

data/tests/tc_curl_multi.rb

@@ -100,6 +100,50 @@ class TestCurbCurlMulti < Test::Unit::TestCase
     m = nil
 
   end
+  
+  def test_idle_check
+    m = Curl::Multi.new
+    e = Curl::Easy.new($TEST_URL)
+    
+    assert(m.idle?, 'A new Curl::Multi handle should be idle')
+    
+    m.add(e)
+    
+    assert((not m.idle?), 'A Curl::Multi handle with a request should not be idle')
+    
+    m.perform
+    
+    assert(m.idle?, 'A Curl::Multi handle should be idle after performing its requests')
+  end
+  
+  def test_requests
+    m = Curl::Multi.new
+    
+    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests')
+    
+    10.times do
+      m.add(Curl::Easy.new($TEST_URL))
+    end
+    
+    assert_equal(10, m.requests.length, 'multi.requests should contain all the active requests')
+    
+    m.perform
+    
+    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests after a perform')
+  end
+  
+  def test_cancel
+    m = Curl::Multi.new
+    m.cancel! # shouldn't raise anything
+    
+    10.times do
+      m.add(Curl::Easy.new($TEST_URL))
+    end
+    
+    m.cancel!
+    
+    assert_equal([], m.requests, 'A new Curl::Multi handle should have no requests after being canceled')
+  end
 
   def test_with_success
     c1 = Curl::Easy.new($TEST_URL)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: taf2-curb
 version: !ruby/object:Gem::Version 
-  version: 0.4.5.0
+  version: 0.4.6.0
 platform: ruby
 authors: 
 - Ross Bamford
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-18 00:00:00 -07:00
+date: 2009-07-19 00:00:00 -07:00
 default_executable: 
 dependencies: []