kgio 1.3.1 → 2.0.0pre1

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v1.3.1.GIT
+DEF_VER=v2.0.0pre1.GIT
 
 LF='
 '

data/GNUmakefile

@@ -139,7 +139,7 @@ release: verify package $(release_notes) $(release_changes)
 	# make tgz release on RubyForge
 	rubyforge add_release -f -n $(release_notes) -a $(release_changes) \
 	  $(rfproject) $(rfpackage) $(VERSION) $(pkgtgz)
-	# push gem to Gemcutter
+	# push gem to RubyGems.org
 	gem push $(pkggem)
 	# in case of gem downloads from RubyForge releases page
 	-rubyforge add_file \

data/HACKING

@@ -31,7 +31,7 @@ characters wide) and NOT the indentation style of Matz Ruby.
 
 Contributions are welcome in the form of patches, pull requests, code
 review, testing, documentation, user support or any other feedback.  The
-{Unicornmailing list}[mailto:mongrel-unicorn@rubyforge.org] is the
+{kgio mailing list}[mailto:kgio@librelist.com] is the
 central coordination point for all user and developer feedback and bug
 reports.
 

data/ISSUES

@@ -1,18 +1,16 @@
 = Issues
 
-The Unicorn {mailing list}[mailto:mongrel-unicorn@rubyforge.org] is the best
+The kgio {mailing list}[mailto:kgio@librelist.com] is the best
 place to report bugs, submit patches and/or obtain support after you
 have searched the mailing list archives and
 {documentation}[http://unicorn.bogomips.org/kgio].
 
-* No subscription is needed to post to the mailing list,
-  let us know that we need to Cc: replies to you if you're unsubscribed.
 * Do not {top post}[http://catb.org/jargon/html/T/top-post.html] in replies
 * Quote only the relevant portions of the message you're replying to
-* Do not send HTML mail
+* Do not send any HTML mail at all
 
 If your issue is of a sensitive nature or you're just shy in public,
-then feel free to email us privately at mailto:unicorn@bogomips.org
+then feel free to email us privately at mailto:kgio@bogomips.org
 instead and your issue will be handled discreetly.
 
 If you don't get a response within a few days, we may have forgotten
@@ -26,11 +24,11 @@ guidelines for patch submission.
 
 == Mailing List Info
 
-* subscribe: http://rubyforge.org/mailman/listinfo/mongrel-unicorn
-* post: mailto:mongrel-unicorn@rubyforge.org
-* private: mailto:unicorn@bogomips.org
+* subscribe: send a message to the mailing list
+* post: mailto:kgio@librelist.com
+* private: mailto:kgio@bogomips.org
 
-== Mailing List Archives
+== Mailing List Archives (coming soon)
 
-* nntp://news.gmane.org/gmane.comp.lang.ruby.unicorn.general
-* http://rubyforge.org/pipermail/mongrel-unicorn
+* http://unicorn.bogomips.org/kgio/archives/
+* nntp://news.gmane.org/gmane.comp.lang.ruby.kgio.general

data/README

@@ -8,16 +8,16 @@ applications.
 == Features
 
 * Can avoid expensive exceptions on common EAGAIN/EINPROGRESS errors,
-  returning Kgio::WaitReadable or Kgio::WaitWritable instead.
+  returning :wait_readable or :wait_writable instead.
   These exceptions got more expensive to hit under Ruby 1.9.2
   (but should be fixed in Ruby 1.9.3 to 1.9.1 performance levels)
 
 * Returns the unwritten portion of the string on partial writes,
   making it ideal for buffering unwritten data.
 
-* May be assigned Kgio.wait_writable= and Kgio.wait_readable=
-  methods to allow socket/pipe objects to make custom callbacks
-  (such as adding the file descriptor to a poll set and yielding
+* May call any method defined to be "kgio_wait_writable" or
+  "kgio_wait_readable" methods to allow socket/pipe objects to make custom
+  callbacks (such as adding the file descriptor to a poll set and yielding
   the current Fiber).
 
 * Uses
@@ -38,7 +38,7 @@ and run setup.rb after unpacking it:
 
 http://rubyforge.org/frs/?group_id=8977
 
-You may also install it via RubyGems on Gemcutter:
+You may also install it via RubyGems.org:
 
   gem install kgio
 
@@ -61,8 +61,7 @@ from git.
 
 All feedback (bug reports, user/development dicussion, patches, pull
 requests) go to the mailing list/newsgroup.  See the ISSUES document for
-information on the
-{Unicorn mailing list}[mailto:mongrel-unicorn@rubyforge.org].
+information on the {kgio mailing list}[mailto:kgio@librelist.com]
 
 For the latest on kgio releases, you may check our NEWS page (and
 subscribe to our Atom feed).

data/ext/kgio/connect.c

@@ -46,7 +46,7 @@ my_connect(VALUE klass, int io_wait, int domain, void *addr, socklen_t addrlen)
 
 			if (io_wait) {
 				errno = EAGAIN;
-				kgio_wait_writable(io, fd);
+				(void)kgio_call_wait_writable(io);
 			}
 			return io;
 		}
@@ -81,7 +81,7 @@ static VALUE tcp_connect(VALUE klass, VALUE ip, VALUE port, int io_wait)
  * Creates a new Kgio::TCPSocket object and initiates a
  * non-blocking connection.
  *
- * This may block and call any method assigned to Kgio.wait_writable.
+ * This may block and call any method defined to kgio_wait_writable.
  *
  * Unlike the TCPSocket.new in Ruby, this does NOT perform DNS
  * lookups (which is subject to a different set of timeouts and
@@ -100,7 +100,7 @@ static VALUE kgio_tcp_connect(VALUE klass, VALUE ip, VALUE port)
  * Creates a new Kgio::TCPSocket object and initiates a
  * non-blocking connection.  The caller should select/poll
  * on the socket for writability before attempting to write
- * or optimistically attempt a write and handle Kgio::WaitWritable
+ * or optimistically attempt a write and handle :wait_writable
  * or Errno::EAGAIN.
  *
  * Unlike the TCPSocket.new in Ruby, this does NOT perform DNS
@@ -138,7 +138,7 @@ static VALUE unix_connect(VALUE klass, VALUE path, int io_wait)
  * Creates a new Kgio::UNIXSocket object and initiates a
  * non-blocking connection.
  *
- * This may block and call any method assigned to Kgio.wait_writable.
+ * This may block and call any method defined to kgio_wait_writable.
  */
 static VALUE kgio_unix_connect(VALUE klass, VALUE path)
 {
@@ -153,7 +153,7 @@ static VALUE kgio_unix_connect(VALUE klass, VALUE path)
  * Creates a new Kgio::UNIXSocket object and initiates a
  * non-blocking connection.  The caller should select/poll
  * on the socket for writability before attempting to write
- * or optimistically attempt a write and handle Kgio::WaitWritable
+ * or optimistically attempt a write and handle :wait_writable
  * or Errno::EAGAIN.
  */
 static VALUE kgio_unix_start(VALUE klass, VALUE path)
@@ -197,7 +197,7 @@ static VALUE stream_connect(VALUE klass, VALUE addr, int io_wait)
  * Creates a generic Kgio::Socket object and initiates a
  * non-blocking connection.
  *
- * This may block and call any method assigned to Kgio.wait_writable.
+ * This may block and call any method assigned to kgio_wait_writable.
  */
 static VALUE kgio_connect(VALUE klass, VALUE addr)
 {
@@ -215,7 +215,7 @@ static VALUE kgio_connect(VALUE klass, VALUE addr)
  * Creates a generic Kgio::Socket object and initiates a
  * non-blocking connection.  The caller should select/poll
  * on the socket for writability before attempting to write
- * or optimistically attempt a write and handle Kgio::WaitWritable
+ * or optimistically attempt a write and handle :wait_writable
  * or Errno::EAGAIN.
  */
 static VALUE kgio_start(VALUE klass, VALUE addr)

data/ext/kgio/kgio.h

@@ -34,7 +34,7 @@ void init_kgio_read_write(void);
 void init_kgio_accept(void);
 void init_kgio_connect(void);
 
-void kgio_wait_writable(VALUE io, int fd);
-void kgio_wait_readable(VALUE io, int fd);
+VALUE kgio_call_wait_writable(VALUE io);
+VALUE kgio_call_wait_readable(VALUE io);
 
 #endif /* KGIO_H */

data/ext/kgio/read_write.c

@@ -1,5 +1,5 @@
 #include "kgio.h"
-static VALUE mKgio_WaitReadable, mKgio_WaitWritable;
+static VALUE sym_wait_readable, sym_wait_writable;
 static VALUE eErrno_EPIPE, eErrno_ECONNRESET;
 
 /*
@@ -26,7 +26,7 @@ static void raise_empty_bt(VALUE err, const char *msg)
 
 static void my_eof_error(void)
 {
-	raise_empty_bt(rb_eEOFError, "");
+	raise_empty_bt(rb_eEOFError, "end of file reached");
 }
 
 static void wr_sys_fail(const char *msg)
@@ -67,14 +67,14 @@ static int read_check(struct io_args *a, long n, const char *msg, int io_wait)
 		rb_str_set_len(a->buf, 0);
 		if (errno == EAGAIN) {
 			if (io_wait) {
-				kgio_wait_readable(a->io, a->fd);
+				(void)kgio_call_wait_readable(a->io);
 
 				/* buf may be modified in other thread/fiber */
 				rb_str_resize(a->buf, a->len);
 				a->ptr = RSTRING_PTR(a->buf);
 				return -1;
 			} else {
-				a->buf = mKgio_WaitReadable;
+				a->buf = sym_wait_readable;
 				return 0;
 			}
 		}
@@ -112,8 +112,8 @@ retry:
  * Reads at most maxlen bytes from the stream socket.  Returns with a
  * newly allocated buffer, or may reuse an existing buffer if supplied.
  *
- * Calls the method assigned to Kgio.wait_readable, or blocks in a
- * thread-safe manner for writability.
+ * Calls whatever is is defined to be the kgio_wait_readable method
+ * for the class.
  *
  * Returns nil on EOF.
  *
@@ -127,7 +127,9 @@ static VALUE kgio_read(int argc, VALUE *argv, VALUE io)
 
 /*
  * Same as Kgio::PipeMethods#kgio_read, except EOFError is raised
- * on EOF without a backtrace
+ * on EOF without a backtrace.  This method is intended as a
+ * drop-in replacement for places where IO#readpartial is used, and
+ * may be aliased as such.
  */
 static VALUE kgio_read_bang(int argc, VALUE *argv, VALUE io)
 {
@@ -148,7 +150,7 @@ static VALUE kgio_read_bang(int argc, VALUE *argv, VALUE io)
  *
  * Returns nil on EOF.
  *
- * Returns Kgio::WaitReadable if EAGAIN is encountered.
+ * Returns :wait_readable if EAGAIN is encountered.
  */
 static VALUE kgio_tryread(int argc, VALUE *argv, VALUE io)
 {
@@ -230,7 +232,7 @@ done:
 			long written = RSTRING_LEN(a->buf) - a->len;
 
 			if (io_wait) {
-				kgio_wait_writable(a->io, a->fd);
+				(void)kgio_call_wait_writable(a->io);
 
 				/* buf may be modified in other thread/fiber */
 				a->len = RSTRING_LEN(a->buf) - written;
@@ -241,7 +243,7 @@ done:
 			} else if (written > 0) {
 				a->buf = rb_str_new(a->ptr, a->len);
 			} else {
-				a->buf = mKgio_WaitWritable;
+				a->buf = sym_wait_writable;
 			}
 			return 0;
 		}
@@ -276,9 +278,8 @@ retry:
  *
  * Returns nil when the write completes.
  *
- * Calls the method Kgio.wait_writable if it is set.  Otherwise this
- * blocks in a thread-safe manner until all data is written or a
- * fatal error occurs.
+ * Calls whatever is is defined to be the kgio_wait_writable method
+ * for the class.
  */
 static VALUE kgio_write(VALUE io, VALUE str)
 {
@@ -288,14 +289,14 @@ static VALUE kgio_write(VALUE io, VALUE str)
 /*
  * call-seq:
  *
- *	io.kgio_trywrite(str)	-> nil or Kgio::WaitWritable
+ *	io.kgio_trywrite(str)	-> nil or :wait_writable
  *
  * Returns nil if the write was completed in full.
  *
  * Returns a String containing the unwritten portion if EAGAIN
  * was encountered, but some portion was successfully written.
  *
- * Returns Kgio::WaitWritable if EAGAIN is encountered and nothing
+ * Returns :wait_writable if EAGAIN is encountered and nothing
  * was written.
  */
 static VALUE kgio_trywrite(VALUE io, VALUE str)
@@ -350,9 +351,10 @@ void init_kgio_read_write(void)
 {
 	VALUE mPipeMethods, mSocketMethods;
 	VALUE mKgio = rb_define_module("Kgio");
+	VALUE mWaiters = rb_const_get(mKgio, rb_intern("DefaultWaiters"));
 
-	mKgio_WaitReadable = rb_const_get(mKgio, rb_intern("WaitReadable"));
-	mKgio_WaitWritable = rb_const_get(mKgio, rb_intern("WaitWritable"));
+	sym_wait_readable = ID2SYM(rb_intern("wait_readable"));
+	sym_wait_writable = ID2SYM(rb_intern("wait_writable"));
 
 	/*
 	 * Document-module: Kgio::PipeMethods
@@ -391,4 +393,6 @@ void init_kgio_read_write(void)
 
 	eErrno_EPIPE = rb_const_get(rb_mErrno, rb_intern("EPIPE"));
 	eErrno_ECONNRESET = rb_const_get(rb_mErrno, rb_intern("ECONNRESET"));
+	rb_include_module(mPipeMethods, mWaiters);
+	rb_include_module(mSocketMethods, mWaiters);
 }

data/ext/kgio/wait.c

@@ -1,117 +1,81 @@
 #include "kgio.h"
 
-static ID io_wait_rd, io_wait_wr;
+static ID id_wait_rd, id_wait_wr;
 
-void kgio_wait_readable(VALUE io, int fd)
-{
-	if (io_wait_rd) {
-		(void)rb_funcall(io, io_wait_rd, 0, 0);
-	} else {
-		if (!rb_io_wait_readable(fd))
-			rb_sys_fail("wait readable");
-	}
-}
+/*
+ * avoiding rb_thread_select() or similar since rb_io_wait_*able can be
+ * made to use poll() later on.  It's highly unlikely Ruby will move to
+ * use an edge-triggered event notification, so assigning EAGAIN is
+ * probably safe...
+ */
 
-void kgio_wait_writable(VALUE io, int fd)
-{
-	if (io_wait_wr) {
-		(void)rb_funcall(io, io_wait_wr, 0, 0);
-	} else {
-		if (!rb_io_wait_writable(fd))
-			rb_sys_fail("wait writable");
-	}
-}
 
 /*
- * call-seq:
+ * Blocks the running Thread indefinitely until +self+ IO object is writable.
+ * This method is automatically called by default whenever kgio_read needs
+ * to block on input.
  *
- *	Kgio.wait_readable = :method_name
- *	Kgio.wait_readable = nil
- *
- * Sets a method for kgio_read to call when a read would block.
- * This is useful for non-blocking frameworks that use Fibers,
- * as the method referred to this may cause the current Fiber
- * to yield execution.
- *
- * A special value of nil will cause Ruby to wait using the
- * rb_io_wait_readable() function.
+ * Users of alternative threading/fiber libraries are
+ * encouraged to override this method in their subclasses or modules to
+ * work with their threading/blocking methods.
  */
-static VALUE set_wait_rd(VALUE mod, VALUE sym)
+static VALUE kgio_wait_readable(VALUE self)
 {
-	switch (TYPE(sym)) {
-	case T_SYMBOL:
-		io_wait_rd = SYM2ID(sym);
-		return sym;
-	case T_NIL:
-		io_wait_rd = 0;
-		return sym;
-	}
-	rb_raise(rb_eTypeError, "must be a symbol or nil");
-	return sym;
+	errno = EAGAIN;
+	if (!rb_io_wait_readable(my_fileno(self)))
+		rb_sys_fail("kgio_wait_readable");
+
+	return self;
 }
 
 /*
- * call-seq:
- *
- *	Kgio.wait_writable = :method_name
- *	Kgio.wait_writable = nil
- *
- * Sets a method for kgio_write to call when a read would block.
- * This is useful for non-blocking frameworks that use Fibers,
- * as the method referred to this may cause the current Fiber
- * to yield execution.
- *
- * A special value of nil will cause Ruby to wait using the
- * rb_io_wait_writable() function.
+ * blocks the running Thread indefinitely until +self+ IO object is writable
+ * This method is automatically called whenever kgio_write needs to
+ * block on output.
+ * Users of alternative threading/fiber libraries are
+ * encouraged to override this method in their subclasses or modules to
+ * work with their threading/blocking methods.
  */
-static VALUE set_wait_wr(VALUE mod, VALUE sym)
+static VALUE kgio_wait_writable(VALUE self)
 {
-	switch (TYPE(sym)) {
-	case T_SYMBOL:
-		io_wait_wr = SYM2ID(sym);
-		return sym;
-	case T_NIL:
-		io_wait_wr = 0;
-		return sym;
-	}
-	rb_raise(rb_eTypeError, "must be a symbol or nil");
-	return sym;
+	errno = EAGAIN;
+	if (!rb_io_wait_writable(my_fileno(self)))
+		rb_sys_fail("kgio_wait_writable");
+
+	return self;
 }
 
-/*
- * call-seq:
- *
- *	Kgio.wait_writable	-> Symbol or nil
- *
- * Returns the symbolic method name of the method assigned to
- * call when EAGAIN is occurs on a Kgio::PipeMethods#kgio_write
- * or Kgio::SocketMethods#kgio_write call
- */
-static VALUE wait_wr(VALUE mod)
+VALUE kgio_call_wait_writable(VALUE io)
 {
-	return io_wait_wr ? ID2SYM(io_wait_wr) : Qnil;
+	return rb_funcall(io, id_wait_wr, 0, 0);
 }
 
-/*
- * call-seq:
- *
- *	Kgio.wait_readable	-> Symbol or nil
- *
- * Returns the symbolic method name of the method assigned to
- * call when EAGAIN is occurs on a Kgio::PipeMethods#kgio_read
- * or Kgio::SocketMethods#kgio_read call.
- */
-static VALUE wait_rd(VALUE mod)
+VALUE kgio_call_wait_readable(VALUE io)
 {
-	return io_wait_rd ? ID2SYM(io_wait_rd) : Qnil;
+	return rb_funcall(io, id_wait_rd, 0, 0);
 }
 
 void init_kgio_wait(void)
 {
 	VALUE mKgio = rb_define_module("Kgio");
 
-	rb_define_singleton_method(mKgio, "wait_readable=", set_wait_rd, 1);
-	rb_define_singleton_method(mKgio, "wait_writable=", set_wait_wr, 1);
-	rb_define_singleton_method(mKgio, "wait_readable", wait_rd, 0);
-	rb_define_singleton_method(mKgio, "wait_writable", wait_wr, 0);
+	/*
+	 * Document-module: Kgio::DefaultWaiters
+	 *
+	 * This module contains default kgio_wait_readable and
+	 * kgio_wait_writable methods that block indefinitely (in a
+	 * thread-safe manner) until an IO object is read or writable.
+	 * This module is included in the Kgio::PipeMethods and
+	 * Kgio::SocketMethods modules used by all bundled IO-derived
+	 * objects.
+	 */
+	VALUE mWaiters = rb_define_module_under(mKgio, "DefaultWaiters");
+
+	id_wait_rd = rb_intern("kgio_wait_readable");
+	id_wait_wr = rb_intern("kgio_wait_writable");
+
+	rb_define_method(mWaiters, "kgio_wait_readable",
+	                 kgio_wait_readable, 0);
+	rb_define_method(mWaiters, "kgio_wait_writable",
+	                 kgio_wait_writable, 0);
 }

data/kgio.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |s|
   s.authors = ["kgio hackers"]
   s.date = Time.now.utc.strftime('%Y-%m-%d')
   s.description = description
-  s.email = %q{mongrel-unicorn@rubyforge.org}
+  s.email = %q{kgio@bogomips.org}
 
   s.extra_rdoc_files = File.readlines('.document').map! do |x|
     x.chomp!

data/lib/kgio.rb

@@ -8,11 +8,11 @@ module Kgio
   LOCALHOST = '127.0.0.1'
 
   # Kgio::PipeMethods#kgio_tryread and Kgio::SocketMethods#kgio_tryread will
-  # return this constant when waiting for a read is required.
+  # return :wait_readable when waiting for a read is required.
   WaitReadable = :wait_readable
 
-  # PipeMethods#kgio_trywrite and SocketMethods#kgio_trywrite will
-  # return this constant when waiting for a read is required.
+  # PipeMethods#kgio_trywrite and SocketMethods#kgio_trywrite will return
+  # :wait_writable when waiting for a read is required.
   WaitWritable = :wait_writable
 end
 

data/test/lib_read_write.rb

@@ -13,9 +13,6 @@ module LibReadWriteTest
       @rd.close unless @rd.closed?
       @wr.close unless @wr.closed?
     end
-    assert_nothing_raised do
-      Kgio.wait_readable = Kgio.wait_writable = nil
-    end
   end
 
   def test_read_zero
@@ -97,9 +94,9 @@ module LibReadWriteTest
         case rv
         when String
           wr = rv
-        when Kgio::WaitReadable
+        when :wait_readable
           assert false, "should never get here line=#{__LINE__}"
-        when Kgio::WaitWritable
+        when :wait_writable
           IO.select(nil, [ @wr ])
         else
           wr = false
@@ -122,7 +119,7 @@ module LibReadWriteTest
   end
 
   def test_tryread_empty
-    assert_equal Kgio::WaitReadable, @rd.kgio_tryread(1)
+    assert_equal :wait_readable, @rd.kgio_tryread(1)
   end
 
   def test_read_too_much
@@ -159,10 +156,10 @@ module LibReadWriteTest
 
   def test_trywrite_return_wait_writable
     tmp = []
-    tmp << @wr.kgio_trywrite("HI") until tmp[-1] == Kgio::WaitWritable
-    assert Kgio::WaitWritable === tmp[-1]
-    assert(!(Kgio::WaitReadable === tmp[-1]))
-    assert_equal Kgio::WaitWritable, tmp.pop
+    tmp << @wr.kgio_trywrite("HI") until tmp[-1] == :wait_writable
+    assert :wait_writable === tmp[-1]
+    assert(!(:wait_readable === tmp[-1]))
+    assert_equal :wait_writable, tmp.pop
     assert tmp.size > 0
     penultimate = tmp.pop
     assert(penultimate == "I" || penultimate == nil)
@@ -173,7 +170,7 @@ module LibReadWriteTest
   def test_tryread_extra_buf_eagain_clears_buffer
     tmp = "hello world"
     rv = @rd.kgio_tryread(2, tmp)
-    assert_equal Kgio::WaitReadable, rv
+    assert_equal :wait_readable, rv
     assert_equal "", tmp
   end
 
@@ -205,11 +202,10 @@ module LibReadWriteTest
 
   def test_monster_write_wait_writable
     @wr.instance_variable_set :@nr, 0
-    def @wr.wait_writable
+    def @wr.kgio_wait_writable
       @nr += 1
       IO.select(nil, [self])
     end
-    Kgio.wait_writable = :wait_writable
     buf = "." * 1024 * 1024 * 10
     thr = Thread.new { @wr.kgio_write(buf) }
     readed = @rd.read(buf.size)
@@ -220,7 +216,6 @@ module LibReadWriteTest
   end
 
   def test_wait_readable_ruby_default
-    assert_nothing_raised { Kgio.wait_readable = nil }
     elapsed = 0
     foo = nil
     t0 = Time.now
@@ -243,7 +238,6 @@ module LibReadWriteTest
     rescue Errno::EAGAIN
       break
     end while true
-    assert_nothing_raised { Kgio.wait_writable = nil }
     elapsed = 0
     foo = nil
     t0 = Time.now
@@ -261,10 +255,9 @@ module LibReadWriteTest
   end
 
   def test_wait_readable_method
-    def @rd.moo
+    def @rd.kgio_wait_readable
       defined?(@z) ? raise(RuntimeError, "Hello") : @z = "HI"
     end
-    assert_nothing_raised { Kgio.wait_readable = :moo }
     foo = nil
     begin
       foo = @rd.kgio_read(5)
@@ -277,29 +270,26 @@ module LibReadWriteTest
   end
 
   def test_tryread_wait_readable_method
-    def @rd.moo
+    def @rd.kgio_wait_readable
       raise "Hello"
     end
-    assert_nothing_raised { Kgio.wait_readable = :moo }
-    assert_equal Kgio::WaitReadable, @rd.kgio_tryread(5)
+    assert_equal :wait_readable, @rd.kgio_tryread(5)
   end
 
   def test_trywrite_wait_readable_method
-    def @wr.moo
+    def @wr.kgio_wait_writable
       raise "Hello"
     end
-    assert_nothing_raised { Kgio.wait_writable = :moo }
     tmp = []
     buf = "." * 1024
     10000.times { tmp << @wr.kgio_trywrite(buf) }
-    assert_equal Kgio::WaitWritable, tmp.pop
+    assert_equal :wait_writable, tmp.pop
   end
 
   def test_wait_writable_method
-    def @wr.moo
+    def @wr.kgio_wait_writable
       defined?(@z) ? raise(RuntimeError, "Hello") : @z = "HI"
     end
-    assert_nothing_raised { Kgio.wait_writable = :moo }
     n = []
     begin
       loop { n << @wr.kgio_write("HIHIHIHIHIHI") }

data/test/test_connect_fd_leak.rb

@@ -5,10 +5,6 @@ require 'kgio'
 
 class TestConnectFDLeak < Test::Unit::TestCase
 
-  def teardown
-    Kgio.wait_readable = Kgio.wait_writable = nil
-  end
-
   def test_unix_socket
     nr = 0
     path = "/non/existent/path"

data/test/test_default_wait.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+require 'io/nonblock'
+$-w = true
+require 'kgio'
+
+class TestDefaultWait < Test::Unit::TestCase
+
+  def test_socket_pair
+    a, b = Kgio::UNIXSocket.pair
+    assert_equal a, a.kgio_wait_writable
+    a.syswrite('.')
+    assert_equal b, b.kgio_wait_readable
+  end
+
+  def test_pipe
+    a, b = Kgio::Pipe.new
+    assert_equal b, b.kgio_wait_writable
+    b.syswrite('.')
+    assert_equal a, a.kgio_wait_readable
+  end
+end

data/test/test_pipe_popen.rb

@@ -6,7 +6,7 @@ require 'kgio'
 class TestPipePopen < Test::Unit::TestCase
   def test_popen
     io = Kgio::Pipe.popen("sleep 1 && echo HI")
-    assert_equal Kgio::WaitReadable, io.kgio_tryread(2)
+    assert_equal :wait_readable, io.kgio_tryread(2)
     sleep 1.5
     assert_equal "HI\n", io.kgio_read(3)
     assert_nil io.kgio_read(5)

data/test/test_tcp_connect.rb

@@ -5,7 +5,7 @@ require 'kgio'
 
 class SubSocket < Kgio::Socket
   attr_accessor :foo
-  def wait_writable
+  def kgio_wait_writable
     @foo = "waited"
   end
 end
@@ -23,7 +23,6 @@ class TestKgioTcpConnect < Test::Unit::TestCase
     @srv.close unless @srv.closed?
     Kgio.accept_cloexec = true
     Kgio.accept_nonblock = false
-    Kgio.wait_readable = Kgio.wait_writable = nil
   end
 
   def test_new
@@ -56,7 +55,6 @@ class TestKgioTcpConnect < Test::Unit::TestCase
   end
 
   def test_socket_start
-    Kgio::wait_writable = :wait_writable
     sock = SubSocket.start(@addr)
     assert_nil sock.foo
     ready = IO.select(nil, [ sock ])
@@ -65,7 +63,6 @@ class TestKgioTcpConnect < Test::Unit::TestCase
   end
 
   def test_wait_writable_set
-    Kgio::wait_writable = :wait_writable
     sock = SubSocket.new(@addr)
     assert_equal "waited", sock.foo
     assert_equal nil, sock.kgio_write("HELLO")

data/test/test_unix_connect.rb

@@ -6,7 +6,7 @@ require 'tempfile'
 
 class SubSocket < Kgio::Socket
   attr_accessor :foo
-  def wait_writable
+  def kgio_wait_writable
     @foo = "waited"
   end
 end
@@ -57,7 +57,6 @@ class TestKgioUnixConnect < Test::Unit::TestCase
   end
 
   def test_socket_start
-    Kgio::wait_writable = :wait_writable
     sock = SubSocket.start(@addr)
     assert_nil sock.foo
     ready = IO.select(nil, [ sock ])
@@ -66,7 +65,6 @@ class TestKgioUnixConnect < Test::Unit::TestCase
   end
 
   def test_wait_writable_set
-    Kgio::wait_writable = :wait_writable
     sock = SubSocket.new(@addr)
     assert_kind_of Kgio::Socket, sock
     assert_instance_of SubSocket, sock

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: kgio
 version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: false
+  hash: -766259887
+  prerelease: true
   segments: 
-  - 1
-  - 3
-  - 1
-  version: 1.3.1
+  - 2
+  - 0
+  - 0pre1
+  version: 2.0.0pre1
 platform: ruby
 authors: 
 - kgio hackers
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-08 00:00:00 +00:00
+date: 2010-11-18 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -24,7 +24,7 @@ description: |-
   exceptions on EAGAIN and EINPROGRESS.  It is intended for use with the
   Unicorn and Rainbows! Rack servers, but may be used by other
   applications.
-email: mongrel-unicorn@rubyforge.org
+email: kgio@bogomips.org
 executables: []
 
 extensions: 
@@ -78,6 +78,7 @@ files:
 - test/lib_server_accept.rb
 - test/test_accept_class.rb
 - test/test_connect_fd_leak.rb
+- test/test_default_wait.rb
 - test/test_pipe_popen.rb
 - test/test_pipe_read_write.rb
 - test/test_socketpair_read_write.rb
@@ -112,12 +113,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: rainbows
@@ -126,6 +129,7 @@ signing_key:
 specification_version: 3
 summary: kinder, gentler I/O for Ruby
 test_files: 
+- test/test_default_wait.rb
 - test/test_unix_connect.rb
 - test/test_pipe_read_write.rb
 - test/test_unix_server.rb