polyphony 0.19 → 0.20

data/polyphony.gemspec

@@ -14,20 +14,24 @@ Gem::Specification.new do |s|
   }
   s.rdoc_options = ["--title", "polyphony", "--main", "README.md"]
   s.extra_rdoc_files = ["README.md"]
-  s.extensions = ["ext/ev/extconf.rb"]
+  s.extensions = ["ext/gyro/extconf.rb"]
   s.require_paths = ["lib"]
 
+  s.executables   = ['poly']
+
   s.add_runtime_dependency      'modulation',     '~>0.25'
   
   s.add_runtime_dependency      'http_parser.rb', '0.6.0'
   s.add_runtime_dependency      'http-2',         '0.10.0'
+  s.add_runtime_dependency      'rack'
   
-  s.add_development_dependency  'hiredis',        '0.6.3'
-  s.add_development_dependency  'httparty',       '0.17.0'
-  s.add_development_dependency  'localhost',      '1.1.4'
-  s.add_development_dependency  'minitest',       '5.11.3'
-  s.add_development_dependency  'pg',             '1.1.3'
-  s.add_development_dependency  'rake-compiler',  '1.0.5'
-  s.add_development_dependency  'redis',          '4.1.0'
-  s.add_development_dependency  'websocket',      '1.2.8'
+  s.add_development_dependency  'hiredis',            '0.6.3'
+  s.add_development_dependency  'httparty',           '0.17.0'
+  s.add_development_dependency  'localhost',          '1.1.4'
+  s.add_development_dependency  'minitest',           '5.11.3'
+  s.add_development_dependency  'minitest-reporters', '1.4.2'
+  s.add_development_dependency  'pg',                 '1.1.3'
+  s.add_development_dependency  'rake-compiler',      '1.0.5'
+  s.add_development_dependency  'redis',              '4.1.0'
+  s.add_development_dependency  'websocket',          '1.2.8'
 end

data/test/eg.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kernel
+  RE_CONST  = /^[A-Z]/.freeze
+  RE_ATTR   = /^@(.+)$/.freeze
+
+  def eg(hash)
+    Module.new.tap do |m|
+      s = m.singleton_class
+      hash.each do |k, v|
+        case k
+        when RE_CONST
+          m.const_set(k, v)
+        when RE_ATTR
+          m.instance_variable_set(k, v)
+        else
+          block = if v.respond_to?(:to_proc)
+                    proc { |*args| instance_exec(*args, &v) }
+                  else
+                    proc { v }
+                  end
+          s.define_method(k, &block)
+        end
+      end
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+require 'polyphony'
+require 'fileutils'
+
+require_relative './eg'
+
+::Exception.__disable_sanitized_backtrace__ = true
+
+Minitest::Reporters.use! [
+  Minitest::Reporters::SpecReporter.new
+]
+
+class MiniTest::Test
+  def teardown
+    # wait for reactor loop to finish running
+    suspend
+    Polyphony.reset!
+  end
+end

data/test/run.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Dir.glob("#{__dir__}/test_*.rb").each do |path|
+  require(path)
+end

data/test/test_async.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class AsyncTest < MiniTest::Test
+  def test_that_async_watcher_receives_signal_across_threads
+    count = 0
+    a = Gyro::Async.new do
+      count += 1
+      a.stop
+    end
+    Thread.new do
+      sync_sleep 0.001
+      a.signal!
+    end
+    suspend
+    assert_equal(1, count)
+  end
+
+  def test_that_async_watcher_coalesces_signals
+    count = 0
+    a = Gyro::Async.new do
+      count += 1
+      Gyro::Timer.new(0.01, 0).start { a.stop }
+    end
+    Thread.new do
+      sync_sleep 0.001
+      3.times { a.signal! }
+    end
+    suspend
+    assert_equal(1, count)
+  end
+end

data/test/test_coprocess.rb

@@ -1,13 +1,11 @@
-require 'minitest/autorun'
-require 'bundler/setup'
-require 'polyphony'
+# frozen_string_literal: true
 
-class CoprocessTest < MiniTest::Test
-  def setup
-    EV.rerun
-  end
+require_relative 'helper'
+
+STDOUT.sync = true
 
-  def test_that_main_fiber_has_associated_coprocess
+class CoprocessTest < MiniTest::Test
+  def test_that_root_fiber_has_associated_coprocess
     assert_equal(Fiber.current, Polyphony::Coprocess.current.fiber)
     assert_equal(Polyphony::Coprocess.current, Fiber.current.coprocess)
   end
@@ -18,24 +16,35 @@ class CoprocessTest < MiniTest::Test
     assert_nil(result)
     coproc.await
     assert_equal(42, result)
+  ensure
+    coproc&.stop
   end
 
   def test_that_new_coprocess_runs_on_different_fiber
     coproc = Polyphony::Coprocess.new { Fiber.current }
     fiber = coproc.await
     assert(fiber != Fiber.current)
+  ensure
+    coproc&.stop
   end
 
   def test_that_await_blocks_until_coprocess_is_done
     result = nil
-    coproc = Polyphony::Coprocess.new { sleep 0.001; result = 42 }
+    coproc = Polyphony::Coprocess.new do
+      snooze
+      result = 42
+    end
     coproc.await
     assert_equal(42, result)
+  ensure
+    coproc&.stop
   end
 
   def test_that_await_returns_the_coprocess_return_value
-    coproc = Polyphony::Coprocess.new { [:foo, :bar] }
-    assert_equal([:foo, :bar], coproc.await)
+    coproc = Polyphony::Coprocess.new { %i[foo bar] }
+    assert_equal(%i[foo bar], coproc.await)
+  ensure
+    coproc&.stop
   end
 
   def test_that_await_raises_error_raised_by_coprocess
@@ -43,162 +52,315 @@ class CoprocessTest < MiniTest::Test
     coproc = Polyphony::Coprocess.new { raise 'foo' }
     begin
       result = coproc.await
-    rescue => e
+    rescue Exception => e
       result = { error: e }
     end
     assert_kind_of(Hash, result)
     assert_kind_of(RuntimeError, result[:error])
+  ensure
+    coproc&.stop
   end
 
   def test_that_running_coprocess_can_be_cancelled
     result = []
-    coproc = Polyphony::Coprocess.new {
+    error = nil
+    coproc = Polyphony::Coprocess.new do
       result << 1
-      sleep 0.002
+      2.times { snooze }
       result << 2
-    }
-    EV::Timer.new(0.001, 0).start { coproc.cancel! }
+    end.run
+    defer { coproc.cancel! }
+    assert_equal(0, result.size)
     begin
       coproc.await
-    rescue Exception => e
-      result << e
+    rescue Polyphony::Cancel => e
+      error = e
     end
-    assert_equal(2, result.size)
+    assert_equal(1, result.size)
     assert_equal(1, result[0])
-    assert_kind_of(Polyphony::Cancel, result[1])
+    assert_kind_of(Polyphony::Cancel, error)
+  ensure
+    coproc&.stop
   end
 
   def test_that_running_coprocess_can_be_interrupted
     # that is, stopped without exception
     result = []
-    coproc = Polyphony::Coprocess.new {
+    coproc = Polyphony::Coprocess.new do
       result << 1
-      sleep 0.002
+      2.times { snooze }
       result << 2
       3
-    }
-    EV::Timer.new(0.001, 0).start { coproc.stop(42) }
+    end.run
+    defer { coproc.stop(42) }
 
     await_result = coproc.await
     assert_equal(1, result.size)
     assert_equal(42, await_result)
+  ensure
+    coproc&.stop
   end
 
   def test_that_coprocess_can_be_awaited
     result = nil
-    spin do
-      coprocess = Polyphony::Coprocess.new { sleep(0.001); 42 }
-      result = coprocess.await
+    cp2 = nil
+    cp1 = spin do
+      cp2 = Polyphony::Coprocess.new do
+        snooze
+        42
+      end
+      result = cp2.await
     end
     suspend
     assert_equal(42, result)
+  ensure
+    cp1&.stop
+    cp2&.stop
   end
 
   def test_that_coprocess_can_be_stopped
     result = nil
-    coprocess = spin do
-      sleep(0.001)
+    coproc = spin do
+      snooze
       result = 42
     end
-    EV.next_tick { coprocess.interrupt }
+    defer { coproc.interrupt }
     suspend
     assert_nil(result)
+  ensure
+    coproc&.stop
   end
 
   def test_that_coprocess_can_be_cancelled
     result = nil
-    coprocess = spin do
-      sleep(0.001)
+    coproc = spin do
+      snooze
       result = 42
     rescue Polyphony::Cancel => e
       result = e
     end
-    EV.next_tick { coprocess.cancel! }
+    defer { coproc.cancel! }
 
     suspend
 
     assert_kind_of(Polyphony::Cancel, result)
-    assert_kind_of(Polyphony::Cancel, coprocess.result)
-    assert_nil(coprocess.running?)
+    assert_kind_of(Polyphony::Cancel, coproc.result)
+    assert_nil(coproc.alive?)
+  ensure
+    coproc&.stop
   end
 
   def test_that_inner_coprocess_can_be_interrupted
     result = nil
-    coprocess2 = nil
-    coprocess = spin do
-      coprocess2 = spin do
-        sleep(0.001)
+    cp2 = nil
+    cp1 = spin do
+      cp2 = spin do
+        snooze
         result = 42
       end
-      coprocess2.await
+      cp2.await
       result && result += 1
     end
-    EV.next_tick { coprocess.interrupt }
+    defer { cp1.interrupt }
     suspend
     assert_nil(result)
-    assert_nil(coprocess.running?)
-    assert_nil(coprocess2.running?)
+    assert_nil(cp1.alive?)
+    assert_nil(cp2.alive?)
+  ensure
+    cp1&.stop
+    cp2&.stop
   end
 
   def test_that_inner_coprocess_can_interrupt_outer_coprocess
-    result, coprocess2 = nil
-    
-    coprocess = spin do
-      coprocess2 = spin do
-        EV.next_tick { coprocess.interrupt }
-        sleep(0.001)
+    result, cp2 = nil
+
+    cp1 = spin do
+      cp2 = spin do
+        defer { cp1.interrupt }
+        snooze
+        snooze
         result = 42
       end
-      coprocess2.await
+      cp2.await
       result && result += 1
     end
-    
+
     suspend
-    
+
     assert_nil(result)
-    assert_nil(coprocess.running?)
-    assert_nil(coprocess2.running?)
+    assert_nil(cp1.alive?)
+    assert_nil(cp2.alive?)
+  ensure
+    cp1&.stop
+    cp2&.stop
+  end
+
+  def test_alive?
+    counter = 0
+    coproc = spin do
+      3.times do
+        snooze
+        counter += 1
+      end
+    end
+
+    assert(coproc.alive?)
+    snooze
+    assert(coproc.alive?)
+    snooze while counter < 3
+    assert(!coproc.alive?)
+  ensure
+    coproc&.stop
+  end
+
+  def test_coprocess_exception_propagation
+    # error is propagated to calling coprocess
+    raised_error = nil
+    spin do
+      spin do
+        raise 'foo'
+      end
+      snooze # allow nested coprocess to run before finishing
+    end
+    suspend
+  rescue Exception => e
+    raised_error = e
+  ensure
+    assert(raised_error)
+    assert_equal('foo', raised_error.message)
   end
 end
 
-class MailboxTest < MiniTest::Test
-  def setup
-    EV.rerun
+def test_exception_propagation_for_orphan_fiber
+  raised_error = nil
+  spin do
+    spin do
+      snooze
+      raise 'bar'
+    end
   end
+  suspend
+rescue Exception => e
+  raised_error = e
+ensure
+  assert(raised_error)
+  assert_equal('bar', raised_error.message)
+end
 
+class MailboxTest < MiniTest::Test
   def test_that_coprocess_can_receive_messages
     msgs = []
-    coprocess = spin {
-      loop {
-        msgs << receive
-      }
-    }
+    coproc = spin { loop { msgs << receive } }
 
-    EV.snooze # allow coproc to start
-    
-    3.times { |i| coprocess << i; EV.snooze }
+    snooze # allow coproc to start
+
+    3.times do |i|
+      coproc << i
+      snooze
+    end
 
     assert_equal([0, 1, 2], msgs)
   ensure
-    coprocess.stop
+    coproc&.stop
   end
 
-  def test_that_multiple_messages_sent_at_once_arrive
+  def test_that_multiple_messages_sent_at_once_arrive_in_order
     msgs = []
-    coprocess = spin {
-      loop { 
-        msgs << receive
-      }
-    }
+    coproc = spin { loop { msgs << receive } }
+
+    snooze # allow coproc to start
 
-    EV.snooze # allow coproc to start
-    
-    3.times { |i| coprocess << i }
+    3.times { |i| coproc << i }
 
-    EV.snooze
+    snooze
 
     assert_equal([0, 1, 2], msgs)
   ensure
-    coprocess.stop
+    coproc&.stop
+  end
+
+  def test_when_done
+    flag = nil
+    values = []
+    coproc = spin do
+      snooze until flag
+    end
+    coproc.when_done { values << 42 }
+
+    snooze
+    assert values.empty?
+    snooze
+    flag = true
+    assert values.empty?
+    assert coproc.alive?
+
+    snooze
+    assert_equal [42], values
+    assert !coproc.alive?
+  end
+
+  def test_resume
+    values = []
+    coproc = spin do
+      values << 1
+      x = suspend
+      values << x
+      suspend
+      values << 3
+    end
+    snooze
+    assert_equal [1], values
+
+    coproc.resume 2
+    assert_equal [1, 2], values
+
+    coproc.resume
+    assert_equal [1, 2, 3], values
+
+    assert !coproc.alive?
+  end
+
+  def test_interrupt
+    coproc = spin do
+      sleep 1
+      :foo
+    end
+
+    snooze
+    assert coproc.alive?
+
+    coproc.interrupt :bar
+    assert !coproc.alive?
+
+    assert_equal :bar, coproc.result
+  end
+
+  def test_cancel
+    error = nil
+    coproc = spin do
+      sleep 1
+      :foo
+    end
+
+    snooze
+    coproc.cancel!
+  rescue Polyphony::Cancel => e
+    # cancel error should bubble up
+    error = e
+  ensure
+    assert error
+    assert !coproc.alive?
+  end
+
+  def test_current
+    assert_equal Fiber.root.coprocess, Polyphony::Coprocess.current
+
+    value = nil
+    coproc = spin do
+      value = :ok if Polyphony::Coprocess.current == coproc
+    end
+
+    snooze
+    assert_equal :ok, value
   end
 end