polyphony 0.25 → 0.26

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c47fca95a744d36163d87e80cd0e56a23ae9a613d1df4970475db7a7b8840ba3
-  data.tar.gz: eebe2e1f3dd6fd3efe80cd60444c881978d7d0ff34d8c381fdd4324e77ef14a6
+  metadata.gz: d97b4ef9db1f6463947a3d5e0e300ee0155bd576ee878a4866557a2cc97cf785
+  data.tar.gz: 8fa0f7e075ce3c7bd9cf28270d06b0fbfe399657571aeaa23773400cb6535f58
 SHA512:
-  metadata.gz: a266b7d3ef74d98a3a43bf4f821e3894295bae084a4ca7f067c3e63b1600ea6c6191e9fe39caa72166c0dba759bca5dc0cb47312de76e45b7028ce3c231f5166
-  data.tar.gz: d3cb27c65c01fa8984d88ba047fbfb30d08660a5afcfe3636af6302e47d3b45b5ba3908419eb8a867ed7ed96aa83d3ec03eadf7dd03542de04095fe7cf64c5f5
+  metadata.gz: ac3eb507f068f54f70f5e1a79d964c39943f7ac7cfa945da02847f59ec53fc23739b2633428258d0caaf91bfdacc25cfcb6fa73175f8d43c7ed38fdd81f0a360
+  data.tar.gz: 75402a0ca525da7aa02fbe933c4f76328d9272ecb9dd7e404003b85a92e327882ca50d63eed49140593628cf0989d1a8cf7aac6abab5ad766124b1e5e7d00348

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+0.26 2020-01-12
+---------------
+
+* Optimize `IO#read_watcher`, `IO#write_watcher`
+* Implement `Fiber#raise`
+* Fix `Kernel#gets` with `ARGV`
+* Return `[pid, exit_status]` from `Gyro::Child#await`
+
 0.25 2020-01-10
 ---------------
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.25)
+    polyphony (0.26)
       modulation (~> 1.0)
 
 GEM
@@ -57,4 +57,4 @@ DEPENDENCIES
   simplecov (= 0.17.1)
 
 BUNDLED WITH
-   2.1.3
+   2.1.4

data/TODO.md

@@ -1,27 +1,26 @@
-## 0.25 Merge Coprocess functionality into Fiber
+## 0.26 Real IO#gets and IO#read
 
-- Merge `Coprocess` functionality into `Fiber`
-  - Get rid of the duality Coprocess - Fiber
-  - exception handling
-  - interrupting (`MoveOn`/`Cancel`)
-  - message passing (`receive`/`send`)
-  - Clear separation between scheduling code and event handling code
-  - Check performance difference using `http_server.rb`. We should expect a
-    modest increase in throughput, as well as significantly less memory usage.
-- Handle calls to `#sleep` without duration (should just `#suspend`)
-
-## 0.26 Move Other interface code into separate gem
-
-- Pull out redis/postgres code, put into new `polyphony-contrib` gem
+- More tests
+- Implement some basic stuff missing:
+  - override `IO#eof?` since it too reads into buffer
+  - real `IO#gets` (with buffering)
+  - `IO#read` (read to EOF)
+  - `IO.foreach`
+  - `Process.waitpid`
 
 ## 0.27 Working Sinatra application
 
+- Pull out redis/postgres code, put into new `polyphony-xxx` gems
 - app with database access (postgresql)
 - benchmarks!
 
-## 0.28 Support for multi-threading
+## 0.28 Sidekick
+
+Plan of action:
 
-- Separate event loop for each thread
+- fork sidekiq, make adjustments to Polyphony code
+- test performance
+- proceed from there
 
 ## 0.29 Testing && Docs
 

data/ext/gyro/child.c

@@ -89,7 +89,11 @@ void Gyro_Child_callback(struct ev_loop *ev_loop, struct ev_child *ev_child, int
 
   if (child->fiber != Qnil) {
     VALUE fiber = child->fiber;
-    VALUE resume_value = INT2NUM(child->pid);
+    int exit_status = ev_child->rstatus >> 8; // weird, why should we do this?
+
+    VALUE resume_value = rb_ary_new_from_args(
+      2, INT2NUM(ev_child->rpid), INT2NUM(exit_status)
+    );
     child->fiber = Qnil;
     Gyro_schedule_fiber(fiber, resume_value);
   }

data/ext/gyro/gyro.c

@@ -31,13 +31,11 @@ ID ID_clear;
 ID ID_each;
 ID ID_inspect;
 ID ID_raise;
-ID ID_read_watcher;
 ID ID_running;
 ID ID_scheduled;
 ID ID_scheduled_next;
 ID ID_scheduled_value;
 ID ID_transfer;
-ID ID_write_watcher;
 ID ID_R;
 ID ID_W;
 ID ID_RW;
@@ -75,13 +73,11 @@ void Init_Gyro() {
   ID_each             = rb_intern("each");
   ID_inspect          = rb_intern("inspect");
   ID_raise            = rb_intern("raise");
-  ID_read_watcher     = rb_intern("read_watcher");
   ID_running          = rb_intern("@running");
   ID_scheduled        = rb_intern("scheduled");
   ID_scheduled_next   = rb_intern("scheduled_next");
   ID_scheduled_value  = rb_intern("scheduled_value");
   ID_transfer         = rb_intern("transfer");
-  ID_write_watcher    = rb_intern("write_watcher");
   ID_R                = rb_intern("r");
   ID_W                = rb_intern("w");
   ID_RW               = rb_intern("rw");

data/ext/gyro/gyro.h

@@ -44,10 +44,8 @@ extern ID ID_clear;
 extern ID ID_each;
 extern ID ID_inspect;
 extern ID ID_raise;
-extern ID ID_read_watcher;
 extern ID ID_scheduled_value;
 extern ID ID_transfer;
-extern ID ID_write_watcher;
 extern ID ID_R;
 extern ID ID_W;
 extern ID ID_RW;

data/ext/gyro/gyro_ext.c

@@ -1,5 +1,4 @@
 #include "gyro.h"
-#include "../libev/ev.c"
 
 void Init_Gyro();
 void Init_Gyro_Async();

data/ext/gyro/io.c

@@ -32,6 +32,11 @@ static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io);
 static VALUE IO_write(int argc, VALUE *argv, VALUE io);
 static VALUE IO_write_chevron(VALUE io, VALUE str);
 
+ID ID_read_watcher;
+ID ID_write_watcher;
+VALUE SYM_r;
+VALUE SYM_w;
+
 void Init_Gyro_IO() {
   cGyro_IO = rb_define_class_under(mGyro, "IO", rb_cData);
   rb_define_alloc_func(cGyro_IO, Gyro_IO_allocate);
@@ -48,6 +53,11 @@ void Init_Gyro_IO() {
   rb_define_method(cIO, "<<", IO_write_chevron, 1);
   rb_define_method(cIO, "read_watcher", IO_read_watcher, 0);
   rb_define_method(cIO, "write_watcher", IO_write_watcher, 0);
+
+  ID_read_watcher = rb_intern("@read_watcher");
+  ID_write_watcher = rb_intern("@write_watcher");
+  SYM_r = ID2SYM(rb_intern("r"));
+  SYM_w = ID2SYM(rb_intern("w"));
 }
 
 static const rb_data_type_t Gyro_IO_type = {
@@ -286,11 +296,28 @@ static VALUE IO_read(int argc, VALUE *argv, VALUE io) {
   return str;
 }
 
+#define READ_DATA_PENDING_COUNT(fptr) ((fptr)->rbuf.len)
+#define MEMMOVE(p1,p2,type,n) memmove((p1), (p2), sizeof(type)*(size_t)(n))
+
+static long
+read_buffered_data(char *ptr, long len, rb_io_t *fptr)
+{
+    int n;
+
+    n = READ_DATA_PENDING_COUNT(fptr);
+    if (n <= 0) return 0;
+    if (n > len) n = (int)len;
+    MEMMOVE(ptr, fptr->rbuf.ptr+fptr->rbuf.off, char, n);
+    fptr->rbuf.off += n;
+    fptr->rbuf.len -= n;
+    return n;
+}
+
 static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io) {
   VALUE underlying_io = rb_iv_get(io, "@io");
   if (!NIL_P(underlying_io)) io = underlying_io;
 
-  long len = argc == 1 ? NUM2LONG(argv[0]) : 8192;
+  long len = argc >= 1 ? NUM2LONG(argv[0]) : 8192;
 
   rb_io_t *fptr;
   long n;
@@ -312,21 +339,24 @@ static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io) {
   if (len == 0)
   	return str;
 
-  while (1) {
-    n = read(fptr->fd, RSTRING_PTR(str), len);
-    if (n < 0) {
-      int e = errno;
-      if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (read_watcher == Qnil)
-          read_watcher = IO_read_watcher(io);
-        Gyro_IO_await(read_watcher);
+  n = read_buffered_data(RSTRING_PTR(str), len, fptr);
+  if (n <= 0) {
+    while (1) {
+      n = read(fptr->fd, RSTRING_PTR(str), len);
+      if (n < 0) {
+        int e = errno;
+        if (e == EWOULDBLOCK || e == EAGAIN) {
+          if (read_watcher == Qnil)
+            read_watcher = IO_read_watcher(io);
+          Gyro_IO_await(read_watcher);
+        }
+        else
+          rb_syserr_fail(e, strerror(e));
+          // rb_syserr_fail_path(e, fptr->pathv);
       }
       else
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
+        break;
     }
-    else
-      break;
   }
 
   io_set_read_length(str, n, shrinkable);
@@ -406,19 +436,21 @@ static VALUE IO_write_chevron(VALUE io, VALUE str) {
 }
 
 VALUE IO_read_watcher(VALUE self) {
-  VALUE watcher = rb_iv_get(self, "@read_watcher");
+  VALUE watcher = rb_ivar_get(self, ID_read_watcher);
   if (watcher == Qnil) {
-    watcher = rb_funcall(cGyro_IO, rb_intern("new"), 2, self, ID2SYM(rb_intern("r")));
-    rb_iv_set(self, "@read_watcher", watcher);
+    VALUE args[] = {self, SYM_r};
+    watcher = rb_class_new_instance(2, args, cGyro_IO);
+    rb_ivar_set(self, ID_read_watcher, watcher);
   }
   return watcher;
 }
 
 VALUE IO_write_watcher(VALUE self) {
-  VALUE watcher = rb_iv_get(self, "@write_watcher");
+  VALUE watcher = rb_ivar_get(self, ID_write_watcher);
   if (watcher == Qnil) {
-    watcher = rb_funcall(cGyro_IO, rb_intern("new"), 2, self, ID2SYM(rb_intern("w")));
-    rb_iv_set(self, "@write_watcher", watcher);
+    VALUE args[] = {self, SYM_w};
+    watcher = rb_class_new_instance(2, args, cGyro_IO);
+    rb_ivar_set(self, ID_write_watcher, watcher);
   }
   return watcher;
 }

data/ext/gyro/libev.c

@@ -0,0 +1,2 @@
+#include "libev.h"
+#include "../libev/ev.c"

data/lib/polyphony.rb

@@ -65,7 +65,6 @@ module Polyphony
     end
 
     def reset!
-      # Fiber.root.scheduled_value = nil
       Gyro.reset!
       Fiber.reset!
     end

data/lib/polyphony/extensions/core.rb

@@ -58,8 +58,6 @@ module ::Kernel
 
   alias_method :orig_backtick, :`
   def `(cmd)
-    # $stdout.orig_puts '*' * 60
-    # $stdout.orig_puts caller.join("\n")
     Open3.popen3(cmd) do |i, o, e, _t|
       i.close
       while (l = e.readpartial(8192))
@@ -70,25 +68,29 @@ module ::Kernel
   end
 
   ARGV_GETS_LOOP = proc do |calling_fiber|
-    ARGV.each do |fn|
+    while (fn = ARGV.shift)
       File.open(fn, 'r') do |f|
         while (line = f.gets)
           calling_fiber = calling_fiber.transfer(line)
         end
       end
     end
+    nil
   rescue Exception => e
     calling_fiber.transfer(e)
   end
 
   alias_method :orig_gets, :gets
   def gets(*_args)
-    return $stdin.gets if ARGV.empty?
+    if !ARGV.empty? || @gets_fiber
+      @gets_fiber ||= Fiber.new(&ARGV_GETS_LOOP)
+      result = @gets_fiber.alive? && @gets_fiber.safe_transfer(Fiber.current)
+      return result if result
 
-    @gets_fiber ||= Fiber.new(&ARGV_GETS_LOOP)
-    return @gets_fiber.safe_transfer(Fiber.current) if @gets_fiber.alive?
+      @gets_fiber = nil
+    end
 
-    nil
+    $stdin.gets
   end
 
   alias_method :orig_system, :system
@@ -100,8 +102,6 @@ module ::Kernel
       end
     end
     true
-  rescue SystemCallError
-    nil
   end
 end
 

data/lib/polyphony/extensions/fiber.rb

@@ -8,7 +8,7 @@ Exceptions = import '../core/exceptions'
 module FiberControl
   def await
     if @running == false
-      return @result.is_a?(Exception) ? (raise @result) : @result
+      return @result.is_a?(Exception) ? (Kernel.raise @result) : @result
     end
 
     @waiting_fiber = Fiber.current
@@ -32,6 +32,21 @@ module FiberControl
     schedule Exceptions::Cancel.new
     snooze
   end
+
+  def raise(*args)
+    error = error_from_raise_args(args)
+    schedule error
+    snooze
+  end
+
+  def error_from_raise_args(args)
+    case (arg = args.shift)
+    when String then RuntimeError.new(arg)
+    when Class  then arg.new(args.shift)
+    when Exception then arg
+    else RuntimeError.new
+    end
+  end
 end
 
 # Messaging functionality
@@ -109,7 +124,7 @@ class ::Fiber
   end
 
   def run(first_value)
-    raise first_value if first_value.is_a?(Exception)
+    Kernel.raise first_value if first_value.is_a?(Exception)
 
     @running = true
     self.class.map[self] = true
@@ -156,11 +171,11 @@ class ::Fiber
   end
 
   def caller
-    @caller ||= []
+    spin_caller = @caller || []
     if @calling_fiber
-      @caller + @calling_fiber.caller
+      spin_caller + @calling_fiber.caller
     else
-      @caller
+      spin_caller
     end
   end
 end

data/lib/polyphony/extensions/io.rb

@@ -163,13 +163,26 @@ class ::IO
 
   alias_method :orig_write_nonblock, :write_nonblock
   def write_nonblock(string, _options = {})
-    # STDOUT << '>'
     write(string, 0)
   end
 
   alias_method :orig_read_nonblock, :read_nonblock
   def read_nonblock(maxlen, buf = nil, _options = nil)
-    # STDOUT << '<'
     buf ? readpartial(maxlen, buf) : readpartial(maxlen)
   end
+
+  alias_method :orig_read, :read
+  def read(length = nil, outbuf = nil)
+    if length
+      return outbuf ? readpartial(length) : readpartial(length, outbuf)
+    end
+
+    until eof?
+      result = outbuf ? readpartial(8192, outbuf) : readpartial(8192)
+      break unless result
+
+      outbuf = result
+    end
+    outbuf
+  end
 end

data/lib/polyphony/extensions/openssl.rb

@@ -23,8 +23,8 @@ class ::OpenSSL::SSL::SSLSocket
     write_watcher = nil
     loop do
       case (result = read_nonblock(maxlen, buf, exception: false))
-      when :wait_readable then (read_watcher ||= Gyro::IO.new(io, :r)).await
-      when :wait_writable then (write_watcher ||= Gyro::IO.new(io, :w)).await
+      when :wait_readable then (read_watcher ||= io.read_watcher).await
+      when :wait_writable then (write_watcher ||= io.write_watcher).await
       else result
       end
     end
@@ -61,8 +61,8 @@ class ::OpenSSL::SSL::SSLSocket
     write_watcher = nil
     loop do
       case (result = write_nonblock(buf, exception: false))
-      when :wait_readable then (read_watcher ||= Gyro::IO.new(io, :r)).await
-      when :wait_writable then (write_watcher ||= Gyro::IO.new(io, :w)).await
+      when :wait_readable then (read_watcher ||= io.read_watcher).await
+      when :wait_writable then (write_watcher ||= io.write_watcher).await
       else result
       end
     end

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.25'
+  VERSION = '0.26'
 end

data/polyphony.gemspec

@@ -8,9 +8,10 @@ Gem::Specification.new do |s|
   s.author      = 'Sharon Rosner'
   s.email       = 'ciconia@gmail.com'
   s.files       = `git ls-files`.split
-  s.homepage    = 'http://github.com/digital-fabric/polyphony'
+  s.homepage    = 'https://dfab.gitbook.io/polyphony/'
   s.metadata    = {
-    "source_code_uri" => "https://github.com/digital-fabric/polyphony"
+    "source_code_uri" => "https://github.com/digital-fabric/polyphony",
+    "documentation_uri" => "https://dfab.gitbook.io/polyphony/"
   }
   s.rdoc_options = ["--title", "polyphony", "--main", "README.md"]
   s.extra_rdoc_files = ["README.md"]

data/test/coverage.rb

@@ -3,13 +3,11 @@
 require 'coverage'
 require 'simplecov'
 
-class << SimpleCov::LinesClassifier
-  alias_method :orig_whitespace_line?, :whitespace_line?
-  def whitespace_line?(line)
-    line.strip =~ /^(begin|end|ensure|else|\})|(\s*rescue\s.+)$/ || orig_whitespace_line?(line)
-  end
-end
-
+# Since we load code using Modulation, and the stock coverage gem does not
+# calculate coverage for code loaded using `Kernel#eval` et al, we need to use
+# the TracePoint API in order to trace execution. Here we monkey-patch the two
+# main Coverage class methods, start and result to use TracePoint. Otherwise we
+# let SimpleCov do its business.
 module Coverage
   EXCLUDE = %w{coverage eg helper run
   }.map { |n| File.expand_path("test/#{n}.rb") }
@@ -42,4 +40,15 @@ module Coverage
   end
 end
 
+class << SimpleCov::LinesClassifier
+  alias_method :orig_whitespace_line?, :whitespace_line?
+  def whitespace_line?(line)
+    # apparently TracePoint tracing does not cover lines including only keywords
+    # such as begin end etc, so here we mark those lines as whitespace, so they
+    # won't count towards the coverage score.
+    line.strip =~ /^(begin|end|ensure|else|\})|(\s*rescue\s.+)$/ ||
+                  orig_whitespace_line?(line)
+  end
+end
+
 SimpleCov.start

data/test/test_ext.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class ExceptionTest < MiniTest::Test
+  def test_sanitize
+    prev_disable = Exception.__disable_sanitized_backtrace__
+    Exception.__disable_sanitized_backtrace__ = false
+
+    begin
+      lineno = __LINE__ + 1
+      spin { raise 'foo' }
+      suspend
+    rescue => e
+    end
+
+    assert_kind_of Exception, e
+    backtrace = e.backtrace
+    location = "#{__FILE__}:#{lineno}"
+    assert_match /#{location}/, backtrace[0]
+    polyphony_re = /^#{Exception::POLYPHONY_DIR}/
+    assert_equal [], backtrace.select { |l| l =~ polyphony_re }
+
+    Exception.__disable_sanitized_backtrace__ = true
+    begin
+      lineno = __LINE__ + 1
+      spin { raise 'foo' }
+      suspend
+    rescue => e
+    end
+
+    assert_kind_of Exception, e
+    backtrace = e.backtrace
+    location = "#{__FILE__}:#{lineno}"
+    assert_match /#{location}/, backtrace[0]
+    assert_match /lib\/polyphony\/extensions\/fiber.rb/, backtrace[1]
+    assert_match /lib\/polyphony\/extensions\/fiber.rb/, backtrace[2]
+  ensure
+    Exception.__disable_sanitized_backtrace__ = prev_disable
+  end
+
+end
+
+class ProcessTest < MiniTest::Test
+  def test_detach
+    pid = Polyphony.fork { sleep 0.05; exit! 42 }
+    buffer = []
+    spin { 3.times { |i| buffer << i; snooze } }
+    w = Process.detach(pid)
+
+    assert_kind_of Fiber, w
+    result = w.await
+
+    assert_equal [0, 1, 2], buffer
+    assert_equal [pid, 42], result
+  end
+end
+
+class KernelTest < MiniTest::Test
+  def test_backticks
+    buffer = []
+    spin { 3.times { |i| buffer << i; snooze } }
+    data = `sleep 0.01; echo hello`
+
+    assert_equal [0, 1, 2], buffer
+    assert_equal "hello\n", data
+  end
+
+  def test_backticks_stderr
+    prev_stderr = $stderr
+    $stderr = err_io = StringIO.new
+
+    data = `>&2 echo "error"`
+    $stderr.rewind
+    $stderr = prev_stderr
+    
+    assert_nil data
+    assert_equal "error\n", err_io.read
+  ensure
+    $stderr = prev_stderr
+  end
+
+  def test_gets
+    prev_stdin = $stdin
+    i, o = IO.pipe
+    $stdin = i
+
+    spin { o << "hello\n" }
+    s = gets
+
+    assert_equal "hello\n", s
+  ensure
+    $stdin = prev_stdin
+  end
+
+  def test_gets_from_argv
+    prev_stdin = $stdin
+
+    ARGV << __FILE__
+    ARGV << __FILE__
+
+    contents = IO.read(__FILE__).lines
+    count = contents.size
+
+    buffer = []
+
+    (count * 2).times { buffer << gets }
+    assert_equal contents * 2, buffer
+
+    i, o = IO.pipe
+    $stdin = i
+
+    spin { o << "hello\n" }
+    s = gets
+
+    assert_equal "hello\n", s
+  ensure
+    $stdin = prev_stdin
+  end
+
+  def test_gets_from_bad_argv
+    prev_stdin = $stdin
+
+    ARGV << 'foobar'
+
+    begin
+      gets
+    rescue => e
+    end
+
+    assert_kind_of Errno::ENOENT, e
+  ensure
+    $stdin = prev_stdin
+  end
+
+  def test_system
+    prev_stdout = $stdout
+    $stdout = out_io = StringIO.new
+
+    buffer = []
+    spin { 3.times { |i| buffer << i; snooze } }
+    system('sleep 0.01; echo hello')
+    out_io.rewind
+    $stdout = prev_stdout
+
+    assert_equal [0, 1, 2], buffer
+    assert_equal "hello\n", out_io.read
+  ensure
+    $stdout = prev_stdout
+  end
+end
+
+class TimeoutTest < MiniTest::Test
+  def test_that_timeout_yields_to_other_fibers
+    buffer = []
+    spin { 3.times { |i| buffer << i; snooze } }
+    assert_raises(Timeout::Error) { Timeout.timeout(0.05) { sleep 1 } }
+    assert_equal [0, 1, 2], buffer
+  end
+
+  class MyTimeout < Exception
+  end
+
+  def test_that_timeout_method_accepts_custom_error_class_and_message
+    buffer = []
+    spin { 3.times { |i| buffer << i; snooze } }
+    begin
+      Timeout.timeout(0.05, MyTimeout, 'foo') { sleep 1 }
+    rescue Exception => e
+    end
+
+    assert_kind_of MyTimeout, e
+    assert_equal 'foo', e.message
+  end
+end

data/test/test_fiber.rb

@@ -3,7 +3,7 @@
 require_relative 'helper'
 
 class FiberTest < MiniTest::Test
-  def test_that_new_spun_fiber_starts_in_suspended_state
+  def test_spin_initial_state
     result = nil
     f = Fiber.spin { result = 42 }
     assert_nil result
@@ -13,7 +13,7 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
-  def test_that_await_blocks_until_fiber_is_done
+  def test_await
     result = nil
     f = Fiber.spin do
       snooze
@@ -25,14 +25,14 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
-  def test_that_await_returns_the_fibers_return_value
+  def test_await_return_value
     f = Fiber.spin { %i[foo bar] }
     assert_equal %i[foo bar], f.await
   ensure
     f&.stop
   end
 
-  def test_that_await_raises_error_raised_by_fiber
+  def test_await_with_error
     result = nil
     f = Fiber.spin { raise 'foo' }
     begin
@@ -46,7 +46,123 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
-  def test_that_running_fiber_can_be_cancelled
+  def test_raise
+    result = []
+    error = nil
+    f = Fiber.spin do
+      result << 1
+      2.times { snooze }
+      result << 2
+    end
+    defer { f.raise }
+    assert_equal 0, result.size
+    begin
+      f.await
+    rescue Exception => e
+      error = e
+    end
+    assert_equal 1, result.size
+    assert_equal 1, result[0]
+    assert_kind_of RuntimeError, error
+  ensure
+    f&.stop
+  end
+
+  class MyError < RuntimeError
+  end
+
+  def test_raise_with_error_class
+    result = []
+    error = nil
+    f = Fiber.spin do
+      result << 1
+      2.times { snooze }
+      result << 2
+    end
+    defer { f.raise MyError }
+    assert_equal 0, result.size
+    begin
+      f.await
+    rescue Exception => e
+      error = e
+    end
+    assert_equal 1, result.size
+    assert_equal 1, result[0]
+    assert_kind_of MyError, error
+  ensure
+    f&.stop
+  end
+
+  def test_raise_with_error_class_and_message
+    result = []
+    error = nil
+    f = Fiber.spin do
+      result << 1
+      2.times { snooze }
+      result << 2
+    end
+    defer { f.raise(MyError, 'foo') }
+    assert_equal 0, result.size
+    begin
+      f.await
+    rescue Exception => e
+      error = e
+    end
+    assert_equal 1, result.size
+    assert_equal 1, result[0]
+    assert_kind_of MyError, error
+    assert_equal 'foo', error.message
+  ensure
+    f&.stop
+  end
+
+  def test_raise_with_message
+    result = []
+    error = nil
+    f = Fiber.spin do
+      result << 1
+      2.times { snooze }
+      result << 2
+    end
+    defer { f.raise 'foo' }
+    assert_equal 0, result.size
+    begin
+      f.await
+    rescue Exception => e
+      error = e
+    end
+    assert_equal 1, result.size
+    assert_equal 1, result[0]
+    assert_kind_of RuntimeError, error
+    assert_equal 'foo', error.message
+  ensure
+    f&.stop
+  end
+
+  def test_raise_with_exception
+    result = []
+    error = nil
+    f = Fiber.spin do
+      result << 1
+      2.times { snooze }
+      result << 2
+    end
+    defer { f.raise MyError.new('bar') }
+    assert_equal 0, result.size
+    begin
+      f.await
+    rescue Exception => e
+      error = e
+    end
+    assert_equal 1, result.size
+    assert_equal 1, result[0]
+    assert_kind_of MyError, error
+    assert_equal 'bar', error.message
+  ensure
+    f&.stop
+  end
+
+  def test_cancel
     result = []
     error = nil
     f = Fiber.spin do
@@ -68,7 +184,7 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
-  def test_that_running_fiber_can_be_interrupted
+  def test_interrupt
     # that is, stopped without exception
     result = []
     f = Fiber.spin do
@@ -77,7 +193,7 @@ class FiberTest < MiniTest::Test
       result << 2
       3
     end
-    defer { f.stop(42) }
+    defer { f.interrupt(42) }
 
     await_result = f.await
     assert_equal 1, result.size
@@ -86,56 +202,38 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
-  def test_that_fiber_can_be_awaited
-    result = nil
-    f2 = nil
-    f1 = spin do
-      f2 = Fiber.spin do
-        snooze
-        42
-      end
-      result = f2.await
+  def test_stop
+    # that is, stopped without exception
+    result = []
+    f = Fiber.spin do
+      result << 1
+      2.times { snooze }
+      result << 2
+      3
     end
-    suspend
-    assert_equal 42, result
-  ensure
-    f1&.stop
-    f2&.stop
-  end
+    defer { f.stop(42) }
 
-  def test_that_fiber_can_be_stopped
-    result = nil
-    f = spin do
-      snooze
-      result = 42
-    end
-    defer { f.interrupt }
-    suspend
-    assert_nil result
+    await_result = f.await
+    assert_equal 1, result.size
+    assert_equal 42, await_result
   ensure
     f&.stop
   end
 
-  def test_that_fiber_can_be_cancelled
-    result = nil
-    f = spin do
-      snooze
-      result = 42
-    rescue Polyphony::Cancel => e
-      result = e
+  def test_interrupt_before_start
+    result = []
+    f = Fiber.spin do
+      result << 1
     end
-    defer { f.cancel! }
-
-    suspend
+    f.interrupt(42)
+    snooze
 
-    assert_kind_of Polyphony::Cancel, result
-    assert_kind_of Polyphony::Cancel, f.result
     assert_equal :dead, f.state
-  ensure
-    f&.stop
+    assert_equal [], result
+    assert_equal 42, f.result
   end
 
-  def test_that_inner_fiber_can_be_interrupted
+  def test_interrupt_nested_fiber
     result = nil
     f2 = nil
     f1 = spin do
@@ -175,7 +273,7 @@ class FiberTest < MiniTest::Test
     f&.stop
   end
 
-  def test_fiber_exception_propagation
+  def test_exception_bubbling
     # error is propagated to calling fiber
     raised_error = nil
     spin do
@@ -192,17 +290,7 @@ class FiberTest < MiniTest::Test
     assert_equal 'foo', raised_error.message
   end
 
-  def test_that_fiber_can_be_interrupted_before_first_scheduling
-    buffer = []
-    f = spin { buffer << 1 }
-    f.stop
-
-    snooze
-    assert !f.running?
-    assert_equal [], buffer
-  end
-
-  def test_exception_propagation_for_orphan_fiber
+  def test_exception_bubling_for_orphan_fiber
     raised_error = nil
     spin do
       spin do
@@ -288,38 +376,6 @@ class FiberTest < MiniTest::Test
     assert_equal [42], values
     assert !f.running?
   end
-
-  def test_interrupt
-    f = spin do
-      sleep 1
-      :foo
-    end
-
-    snooze
-    assert f.alive?
-
-    f.interrupt :bar
-    assert !f.running?
-
-    assert_equal :bar, f.result
-  end
-
-  def test_cancel
-    error = nil
-    f = spin do
-      sleep 1
-      :foo
-    end
-
-    snooze
-    f.cancel!
-  rescue Polyphony::Cancel => e
-    # cancel error should bubble up
-    error = e
-  ensure
-    assert error
-    assert_equal :dead, f.state
-  end
 end
 
 class MailboxTest < MiniTest::Test
@@ -379,4 +435,29 @@ class MailboxTest < MiniTest::Test
     snooze
     assert_equal 1, Fiber.count
   end
+
+  def test_inspect
+    expected = format('#<Fiber:%s (root) (running)>', Fiber.current.object_id)
+    assert_equal expected, Fiber.current.inspect
+
+    spin_line_no = __LINE__ + 1
+    f = spin { :foo }
+
+    expected = format(
+      '#<Fiber:%s %s:%d:in `test_inspect\' (scheduled)>',
+      f.object_id,
+      __FILE__,
+      spin_line_no
+    )
+    assert_equal expected, f.inspect
+
+    f.await
+    expected = format(
+      '#<Fiber:%s %s:%d:in `test_inspect\' (dead)>',
+      f.object_id,
+      __FILE__,
+      spin_line_no
+    )
+    assert_equal expected, f.inspect
+  end
 end

data/test/test_global_api.rb

@@ -294,4 +294,20 @@ class MoveOnAfterTest < MiniTest::Test
     f.stop
     assert (4..5).include?(buffer.size)
   end
+
+  def test_sleep
+    t0 = Time.now
+    sleep 0.05
+    elapsed = Time.now - t0
+    puts "* elapsed: #{elapsed.inspect}"
+    assert (0.045..0.8).include? elapsed
+
+    f = spin { sleep }
+    snooze
+    assert f.running?
+    snooze
+    assert f.running?
+    f.stop
+    assert !f.running?
+  end
 end

data/test/test_supervisor.rb

@@ -56,14 +56,14 @@ class SupervisorTest < MiniTest::Test
     foo_f = bar_f = baz_f = nil
     result, f = Polyphony::Supervisor.new.select { |s|
       foo_f = s.spin { sleep 0.01; buffer << :foo; :foo }
-      bar_f = s.spin { sleep 0.02; buffer << :bar; :bar }
-      baz_f = s.spin { sleep 0.03; buffer << :baz; :baz }
+      bar_f = s.spin { sleep 0.03; buffer << :bar; :bar }
+      baz_f = s.spin { sleep 0.05; buffer << :baz; :baz }
     }
 
     assert_equal :foo, result
     assert_equal foo_f, f
 
-    sleep 0.03
+    sleep 0.05
     assert !bar_f.running?
     assert !baz_f.running?
     assert_equal [:foo], buffer

data/test/test_timer.rb

@@ -45,6 +45,6 @@ class TimerTest < MiniTest::Test
     }
     suspend
     deltas = times.each_with_object([]) { |t, a| a << t - last; last = t }
-    assert_equal 0, deltas.filter { |d| (d - 0.01).abs >= 0.005 }.size
+    assert_equal 0, deltas.filter { |d| (d - 0.01).abs >= 0.006 }.size
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polyphony
 version: !ruby/object:Gem::Version
-  version: '0.25'
+  version: '0.26'
 platform: ruby
 authors:
 - Sharon Rosner
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-10 00:00:00.000000000 Z
+date: 2020-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: modulation
@@ -254,6 +254,7 @@ files:
 - ext/gyro/gyro.h
 - ext/gyro/gyro_ext.c
 - ext/gyro/io.c
+- ext/gyro/libev.c
 - ext/gyro/libev.h
 - ext/gyro/signal.c
 - ext/gyro/socket.c
@@ -303,6 +304,7 @@ files:
 - test/run.rb
 - test/test_async.rb
 - test/test_cancel_scope.rb
+- test/test_ext.rb
 - test/test_fiber.rb
 - test/test_global_api.rb
 - test/test_gyro.rb
@@ -312,11 +314,12 @@ files:
 - test/test_signal.rb
 - test/test_supervisor.rb
 - test/test_timer.rb
-homepage: http://github.com/digital-fabric/polyphony
+homepage: https://dfab.gitbook.io/polyphony/
 licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/digital-fabric/polyphony
+  documentation_uri: https://dfab.gitbook.io/polyphony/
 post_install_message: 
 rdoc_options:
 - "--title"
@@ -336,7 +339,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: 'Polyphony: Fiber-based Concurrency for Ruby'