polyphony 1.1.1 → 1.2

data/lib/polyphony/extensions/io.rb

@@ -80,7 +80,6 @@ class ::IO
     # @!visibility private
     alias_method :orig_popen, :popen
 
-
     # @!visibility private
     def popen(cmd, mode = 'r')
       return orig_popen(cmd, mode) unless block_given?
@@ -163,7 +162,6 @@ class ::IO
   # @!visibility private
   alias_method :orig_getbyte, :getbyte
 
-
   # @!visibility private
   def getbyte
     char = getc
@@ -173,7 +171,6 @@ class ::IO
   # @!visibility private
   alias_method :orig_getc, :getc
 
-
   # @!visibility private
   def getc
     return @read_buffer.slice!(0) if @read_buffer && !@read_buffer.empty?
@@ -186,12 +183,12 @@ class ::IO
   end
 
   # @!visibility private
-  def ungetc(c)
-    c = c.chr if c.is_a?(Integer)
+  def ungetc(chr)
+    chr = chr.chr if chr.is_a?(Integer)
     if @read_buffer
-      @read_buffer.prepend(c)
+      @read_buffer.prepend(chr)
     else
-      @read_buffer = +c
+      @read_buffer = +chr
     end
   end
   alias_method :ungetbyte, :ungetc
@@ -199,14 +196,10 @@ class ::IO
   # @!visibility private
   alias_method :orig_read, :read
 
-
   # @!visibility private
-  def read(len = nil, buf = nil, buf_pos = 0)
+  def read(len = nil, buf = nil, buffer_pos: 0)
     return '' if len == 0
-
-    if buf
-      return Polyphony.backend_read(self, buf, len, true, buf_pos)
-    end
+    return Polyphony.backend_read(self, buf, len, true, buffer_pos) if buf
 
     @read_buffer ||= +''
     result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
@@ -221,7 +214,7 @@ class ::IO
   alias_method :orig_readpartial, :read
 
   # @!visibility private
-  def readpartial(len, str = +'', buffer_pos = 0, raise_on_eof = true)
+  def readpartial(len, str = +'', buffer_pos: 0, raise_on_eof: true)
     result = Polyphony.backend_read(self, str, len, false, buffer_pos)
     raise EOFError if !result && raise_on_eof
 
@@ -262,7 +255,7 @@ class ::IO
       idx = @read_buffer.index(sep)
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
-      result = readpartial(8192, @read_buffer, -1)
+      result = readpartial(8192, @read_buffer, buffer_pos: -1)
       return nil unless result
     end
   rescue EOFError
@@ -287,7 +280,7 @@ class ::IO
         yield line
       end
 
-      result = readpartial(8192, @read_buffer, -1)
+      result = readpartial(8192, @read_buffer, buffer_pos: -1)
       return self if !result
     end
   rescue EOFError
@@ -306,7 +299,7 @@ class ::IO
   # @!visibility private
   LINEFEED = "\n"
   # @!visibility private
-  LINEFEED_RE = /\n$/.freeze
+  LINEFEED_RE = /\n$/
 
   # @!visibility private
   alias_method :orig_puts, :puts
@@ -351,97 +344,97 @@ class ::IO
 
   # @!visibility private
   def write_nonblock(string, _options = {})
-  write(string)
-end
-
-# @!visibility private
-alias_method :orig_read_nonblock, :read_nonblock
+    write(string)
+  end
 
-# @!visibility private
-def read_nonblock(maxlen, buf = nil, _options = nil)
-  buf ? readpartial(maxlen, buf) : readpartial(maxlen)
-end
+  # @!visibility private
+  alias_method :orig_read_nonblock, :read_nonblock
 
-# Reads up to `maxlen` bytes at a time in an infinite loop. Read data
-# will be passed to the given block.
-#
-# @param maxlen [Integer] maximum bytes to receive
-# @yield [String] read data
-# @return [IO] self
-def read_loop(maxlen = 8192, &block)
-  Polyphony.backend_read_loop(self, maxlen, &block)
-end
+  # @!visibility private
+  def read_nonblock(maxlen, buf = nil, _options = nil)
+    buf ? readpartial(maxlen, buf) : readpartial(maxlen)
+  end
 
-# Receives data from the io in an infinite loop, passing the data to the given
-# receiver using the given method. If a block is given, the result of the
-# method call to the receiver is passed to the block.
-#
-# This method can be used to feed data into parser objects. The following
-# example shows how to feed data from a io directly into a MessagePack
-# unpacker:
-#
-#   unpacker = MessagePack::Unpacker.new
-#   io.feed_loop(unpacker, :feed_each) { |msg| handle_msg(msg) }
-#
-# @param receiver [any] receiver object
-# @param method [Symbol] method to call
-# @return [IO] self
-def feed_loop(receiver, method = :call, &block)
-  Polyphony.backend_feed_loop(self, receiver, method, &block)
-end
+  # Reads up to `maxlen` bytes at a time in an infinite loop. Read data
+  # will be passed to the given block.
+  #
+  # @param maxlen [Integer] maximum bytes to receive
+  # @yield [String] read data
+  # @return [IO] self
+  def read_loop(maxlen = 8192, &block)
+    Polyphony.backend_read_loop(self, maxlen, &block)
+  end
 
-# Waits for the IO to become readable, with an optional timeout.
-#
-# @param timeout [Integer, nil] optional timeout in seconds.
-# @return [IO] self
-def wait_readable(timeout = nil)
-  return self if @read_buffer && @read_buffer.size > 0
+  # Receives data from the io in an infinite loop, passing the data to the given
+  # receiver using the given method. If a block is given, the result of the
+  # method call to the receiver is passed to the block.
+  #
+  # This method can be used to feed data into parser objects. The following
+  # example shows how to feed data from a io directly into a MessagePack
+  # unpacker:
+  #
+  #   unpacker = MessagePack::Unpacker.new
+  #   io.feed_loop(unpacker, :feed_each) { |msg| handle_msg(msg) }
+  #
+  # @param receiver [any] receiver object
+  # @param method [Symbol] method to call
+  # @return [IO] self
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_feed_loop(self, receiver, method, &block)
+  end
 
-  if timeout
-    move_on_after(timeout) do
+  # Waits for the IO to become readable, with an optional timeout.
+  #
+  # @param timeout [Integer, nil] optional timeout in seconds.
+  # @return [IO] self
+  def wait_readable(timeout = nil)
+    return self if @read_buffer && !@read_buffer.empty?
+
+    if timeout
+      move_on_after(timeout) do
+        Polyphony.backend_wait_io(self, false)
+        self
+      end
+    else
       Polyphony.backend_wait_io(self, false)
       self
     end
-  else
-    Polyphony.backend_wait_io(self, false)
-    self
   end
-end
 
-# Waits for the IO to become writeable, with an optional timeout.
-#
-# @param timeout [Integer, nil] optional timeout in seconds.
-# @return [IO] self
-def wait_writable(timeout = nil)
-  if timeout
-    move_on_after(timeout) do
+  # Waits for the IO to become writeable, with an optional timeout.
+  #
+  # @param timeout [Integer, nil] optional timeout in seconds.
+  # @return [IO] self
+  def wait_writable(timeout = nil)
+    if timeout
+      move_on_after(timeout) do
+        Polyphony.backend_wait_io(self, true)
+        self
+      end
+    else
       Polyphony.backend_wait_io(self, true)
       self
     end
-  else
-    Polyphony.backend_wait_io(self, true)
-    self
   end
-end
-
-# Splices data from the given IO. If maxlen is negative, splices repeatedly
-# using absolute value of maxlen until EOF is encountered.
-#
-# @param src [IO, Polpyhony::Pipe] source to splice from
-# @param maxlen [Integer] maximum bytes to splice
-# @return [Integer] bytes spliced
-def splice_from(src, maxlen)
-  Polyphony.backend_splice(src, self, maxlen)
-end
 
-if RUBY_PLATFORM =~ /linux/
-  # Tees data from the given IO.
+  # Splices data from the given IO. If maxlen is negative, splices repeatedly
+  # using absolute value of maxlen until EOF is encountered.
   #
-  # @param src [IO, Polpyhony::Pipe] source to tee from
-  # @param maxlen [Integer] maximum bytes to tee
-  # @return [Integer] bytes teed
-  def tee_from(src, maxlen)
-    Polyphony.backend_tee(src, self, maxlen)
+  # @param src [IO, Polpyhony::Pipe] source to splice from
+  # @param maxlen [Integer] maximum bytes to splice
+  # @return [Integer] bytes spliced
+  def splice_from(src, maxlen)
+    Polyphony.backend_splice(src, self, maxlen)
+  end
+
+  if RUBY_PLATFORM =~ /linux/
+    # Tees data from the given IO.
+    #
+    # @param src [IO, Polpyhony::Pipe] source to tee from
+    # @param maxlen [Integer] maximum bytes to tee
+    # @return [Integer] bytes teed
+    def tee_from(src, maxlen)
+      Polyphony.backend_tee(src, self, maxlen)
+    end
   end
-end
 end

data/lib/polyphony/extensions/kernel.rb

@@ -2,6 +2,27 @@
 
 require 'open3'
 
+module Polyphony
+  # Intercepts calls to #trap
+  module TrapInterceptor
+    def trap(sig, command = nil, &block)
+      return super(sig, command) if command.is_a? String
+
+      block = command if !block && command.respond_to?(:call)
+
+      # The signal trap can be invoked at any time, including while the system
+      # backend is blocking while polling for events. In order to deal with this
+      # correctly, we run the signal handler code in an out-of-band, priority
+      # scheduled fiber, that will pass any uncaught exception (including
+      # SystemExit and Interrupt) to the main thread's main fiber. See also
+      # `Fiber#schedule_priority_oob_fiber`.
+      super(sig) do
+        Fiber.schedule_priority_oob_fiber(&block)
+      end
+    end
+  end
+end
+
 # Kernel extensions (methods available to all objects / call sites)
 module ::Kernel
   # @!visibility private
@@ -59,7 +80,7 @@ module ::Kernel
     strs = args.inject([]) do |m, a|
       m << a.inspect << "\n"
     end
-    STDOUT.write(*strs)
+    $stdout.write(*strs)
     args.size == 1 ? args.first : args
   end
 
@@ -72,6 +93,9 @@ module ::Kernel
   end
 
   class << self
+    # @!visibility private
+    alias_method :orig_trap, :trap
+
     # @!visibility private
     alias_method :orig_system, :system
 
@@ -92,23 +116,29 @@ module ::Kernel
   # @!visibility private
   alias_method :orig_trap, :trap
 
-  # @!visibility private
-  def trap(sig, command = nil, &block)
-    return orig_trap(sig, command) if command.is_a? String
-
-    block = command if !block && command.respond_to?(:call)
-
-    # The signal trap can be invoked at any time, including while the system
-    # backend is blocking while polling for events. In order to deal with this
-    # correctly, we run the signal handler code in an out-of-band, priority
-    # scheduled fiber, that will pass any uncaught exception (including
-    # SystemExit and Interrupt) to the main thread's main fiber. See also
-    # `Fiber#schedule_priority_oob_fiber`.
-    orig_trap(sig) do
-      Fiber.schedule_priority_oob_fiber(&block)
-    end
+  prepend Polyphony::TrapInterceptor
+
+  class << self
+    prepend Polyphony::TrapInterceptor
   end
 
+  # # @!visibility private
+  # def trap(sig, command = nil, &block)
+  #   return orig_trap(sig, command) if command.is_a? String
+
+  #   block = command if !block && command.respond_to?(:call)
+
+  #   # The signal trap can be invoked at any time, including while the system
+  #   # backend is blocking while polling for events. In order to deal with this
+  #   # correctly, we run the signal handler code in an out-of-band, priority
+  #   # scheduled fiber, that will pass any uncaught exception (including
+  #   # SystemExit and Interrupt) to the main thread's main fiber. See also
+  #   # `Fiber#schedule_priority_oob_fiber`.
+  #   orig_trap(sig) do
+  #     Fiber.schedule_priority_oob_fiber(&block)
+  #   end
+  # end
+
   private
 
   # @!visibility private
@@ -116,3 +146,9 @@ module ::Kernel
     src.read_loop { |data| dest << data }
   end
 end
+
+module ::Process
+  class << self
+    prepend Polyphony::TrapInterceptor
+  end
+end

data/lib/polyphony/extensions/object.rb

@@ -84,7 +84,7 @@ class ::Object
   def spin_loop(tag = nil, rate: nil, interval: nil, &block)
     if rate || interval
       Fiber.current.spin(tag, caller) do
-        throttled_loop(rate: rate, interval: interval, &block)
+        throttled_loop(rate:, interval:, &block)
       end
     else
       spin_loop_without_throttling(tag, caller, block)
@@ -200,8 +200,11 @@ class ::Object
   # @param duration [Number, nil] duration
   # @return [any]
   def sleep(duration = nil)
-    duration ?
-    Polyphony.backend_sleep(duration) : Polyphony.backend_wait_event(true)
+    if duration
+      Polyphony.backend_sleep(duration)
+    else
+      Polyphony.backend_wait_event(true)
+    end
   end
 
   # Starts a throttled loop with the given rate. If `count:` is given, the
@@ -220,9 +223,7 @@ class ::Object
     if opts[:count]
       opts[:count].times { |_i| throttler.(&block) }
     else
-      while true
-        throttler.(&block)
-      end
+      throttler.(&block) while true
     end
   rescue LocalJumpError, StopIteration
     # break called or StopIteration raised

data/lib/polyphony/extensions/openssl.rb

@@ -39,7 +39,7 @@ class ::OpenSSL::SSL::SSLSocket
 
   # @!visibility private
   def fill_rbuff
-    data = self.sysread(BLOCK_SIZE)
+    data = sysread(BLOCK_SIZE)
     if data
       @rbuffer << data
     else
@@ -103,15 +103,13 @@ class ::OpenSSL::SSL::SSLSocket
   # @param buf [String, nil] buffer to read into
   # @param buf_pos [Number] buffer position to read into
   # @return [String] buffer used for reading
-  def read(maxlen = nil, buf = nil, buf_pos = 0)
-    return readpartial(maxlen, buf, buf_pos) if buf
+  def read(maxlen = nil, buf = nil, buffer_pos: 0)
+    return readpartial(maxlen, buf, buffer_pos:) if buf
 
     buf = +''
     return readpartial(maxlen, buf) if maxlen
 
-    while true
-      readpartial(4096, buf, -1)
-    end
+    readpartial(4096, buf, buffer_pos: -1) while true
   rescue EOFError
     buf
   end
@@ -132,7 +130,7 @@ class ::OpenSSL::SSL::SSLSocket
   # @param buf_pos [Number] buffer position to read into
   # @param raise_on_eof [bool] whether to raise an exception on `EOF`
   # @return [String, nil] buffer used for reading or nil on `EOF`
-  def readpartial(maxlen, buf = +'', buf_pos = 0, raise_on_eof = true)
+  def readpartial(maxlen, buf = +'', buffer_pos: 0, raise_on_eof: true)
     if buf_pos != 0
       if (result = sysread(maxlen, +''))
         if buf_pos == -1
@@ -265,7 +263,7 @@ class ::OpenSSL::SSL::SSLServer
   # @param ignore_errors [boolean] whether to ignore IO and SSL errors
   # @yield [OpenSSL::SSL::SSLSocket] accepted socket
   # @return [OpenSSL::SSL::SSLServer] self
-  def accept_loop(ignore_errors = true)
+  def accept_loop(ignore_errors: true)
     loop do
       yield accept
     rescue OpenSSL::SSL::SSLError, SystemCallError => e

data/lib/polyphony/extensions/pipe.rb

@@ -43,10 +43,8 @@ class Polyphony::Pipe
   # @param buf [String, nil] buffer to read into
   # @param buf_pos [Integer] buffer position to read into
   # @return [String] read data
-  def read(len = nil, buf = nil, buf_pos = 0)
-    if buf
-      return Polyphony.backend_read(self, buf, len, true, buf_pos)
-    end
+  def read(len = nil, buf = nil, buffer_pos: 0)
+    return Polyphony.backend_read(self, buf, len, true, buffer_pos) if buf
 
     @read_buffer ||= +''
     result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
@@ -64,8 +62,8 @@ class Polyphony::Pipe
   # @param buf_pos [Integer] buffer position to read into
   # @param raise_on_eof [boolean] whether to raise an error if EOF is detected
   # @return [String] read data
-  def readpartial(len, buf = +'', buf_pos = 0, raise_on_eof = true)
-    result = Polyphony.backend_read(self, buf, len, false, buf_pos)
+  def readpartial(len, buf = +'', buffer_pos: 0, raise_on_eof: true)
+    result = Polyphony.backend_read(self, buf, len, false, buffer_pos)
     raise EOFError if !result && raise_on_eof
 
     result
@@ -106,7 +104,7 @@ class Polyphony::Pipe
       idx = @read_buffer.index(sep)
       return @read_buffer.slice!(0, idx + sep_size) if idx
 
-      result = readpartial(8192, @read_buffer, -1)
+      result = readpartial(8192, @read_buffer, buffer_pos: -1)
       return nil unless result
     end
   rescue EOFError

data/lib/polyphony/extensions/socket.rb

@@ -26,9 +26,8 @@ end
 
 # Socket extensions # TODO: rewrite in C
 class ::Socket < ::BasicSocket
-
   # Accepts an incoming connection.
-
+  #
   # @return [TCPSocket] new connection
   def accept
     Polyphony.backend_accept(self, TCPSocket)
@@ -73,12 +72,9 @@ class ::Socket < ::BasicSocket
   # @param buf [String, nil] buffer to read into
   # @param buf_pos [Number] buffer position to read into
   # @return [String] buffer used for reading
-  def read(len = nil, buf = nil, buf_pos = 0)
+  def read(len = nil, buf = nil, buffer_pos: 0)
     return '' if len == 0
-
-    if buf
-      return Polyphony.backend_read(self, buf, len, true, buf_pos)
-    end
+    return Polyphony.backend_read(self, buf, len, true, buffer_pos) if buf
 
     @read_buffer ||= +''
     result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
@@ -167,8 +163,8 @@ class ::Socket < ::BasicSocket
   # @param buf_pos [Number] buffer position to read into
   # @param raise_on_eof [bool] whether to raise an exception on `EOF`
   # @return [String, nil] buffer used for reading or nil on `EOF`
-  def readpartial(maxlen, buf = +'', buf_pos = 0, raise_on_eof = true)
-    result = Polyphony.backend_recv(self, buf, maxlen, buf_pos)
+  def readpartial(maxlen, buf = +'', buffer_pos: 0, raise_on_eof: true)
+    result = Polyphony.backend_recv(self, buf, maxlen, buffer_pos)
     raise EOFError if !result && raise_on_eof
 
     result
@@ -210,8 +206,8 @@ class ::Socket < ::BasicSocket
   end
 
   class << self
-  # @!visibility private
-  alias_method :orig_getaddrinfo, :getaddrinfo
+    # @!visibility private
+    alias_method :orig_getaddrinfo, :getaddrinfo
 
     # Resolves the given addr using a worker thread from the default thread
     # pool.
@@ -337,12 +333,9 @@ class ::TCPSocket < ::IPSocket
   # @param buf [String, nil] buffer to read into
   # @param buf_pos [Number] buffer position to read into
   # @return [String] buffer used for reading
-  def read(len = nil, buf = nil, buf_pos = 0)
+  def read(len = nil, buf = nil, buffer_pos: 0)
     return '' if len == 0
-
-    if buf
-      return Polyphony.backend_read(self, buf, len, true, buf_pos)
-    end
+    return Polyphony.backend_read(self, buf, len, true, buffer_pos) if buf
 
     @read_buffer ||= +''
     result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
@@ -413,9 +406,10 @@ class ::TCPSocket < ::IPSocket
   # @param buf_pos [Number] buffer position to read into
   # @param raise_on_eof [bool] whether to raise an exception on `EOF`
   # @return [String, nil] buffer used for reading or nil on `EOF`
-  def readpartial(maxlen, buf = +'', buf_pos = 0, raise_on_eof = true)
-    result = Polyphony.backend_recv(self, buf, maxlen, buf_pos)
+  def readpartial(maxlen, buf = +'', buffer_pos: 0, raise_on_eof: true)
+    result = Polyphony.backend_recv(self, buf, maxlen, buffer_pos)
     raise EOFError if !result && raise_on_eof
+
     result
   end
 
@@ -430,7 +424,7 @@ class ::TCPSocket < ::IPSocket
   # @param exception [bool] whether to raise an exception if not ready for reading
   # @return [String, :wait_readable] read buffer
   def read_nonblock(maxlen, buf = nil, exception: true)
-    @io.read_nonblock(maxlen, buf, exception: exception)
+    @io.read_nonblock(maxlen, buf, exception:)
   end
 
   # Performs a non-blocking to the socket. If the socket is not ready for
@@ -442,13 +436,12 @@ class ::TCPSocket < ::IPSocket
   # @param exception [bool] whether to raise an exception if not ready for reading
   # @return [Integer, :wait_readable] number of bytes written
   def write_nonblock(buf, exception: true)
-    @io.write_nonblock(buf, exception: exception)
+    @io.write_nonblock(buf, exception:)
   end
 end
 
 # TCPServer extensions
 class ::TCPServer < ::TCPSocket
-
   # Initializes the TCP server socket.
   #
   # @param hostname [String, nil] hostname to connect to
@@ -546,12 +539,9 @@ class ::UNIXSocket < ::BasicSocket
   # @param buf [String, nil] buffer to read into
   # @param buf_pos [Number] buffer position to read into
   # @return [String] buffer used for reading
-  def read(len = nil, buf = nil, buf_pos = 0)
+  def read(len = nil, buf = nil, buffer_pos: 0)
     return '' if len == 0
-
-    if buf
-      return Polyphony.backend_read(self, buf, len, true, buf_pos)
-    end
+    return Polyphony.backend_read(self, buf, len, true, buffer_pos) if buf
 
     @read_buffer ||= +''
     result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
@@ -648,9 +638,10 @@ class ::UNIXSocket < ::BasicSocket
   # @param buf_pos [Number] buffer position to read into
   # @param raise_on_eof [bool] whether to raise an exception on `EOF`
   # @return [String, nil] buffer used for reading or nil on `EOF`
-  def readpartial(maxlen, buf = +'', buf_pos = 0, raise_on_eof = true)
-    result = Polyphony.backend_recv(self, buf, maxlen, buf_pos)
+  def readpartial(maxlen, buf = +'', buffer_pos: 0, raise_on_eof: true)
+    result = Polyphony.backend_recv(self, buf, maxlen, buffer_pos)
     raise EOFError if !result && raise_on_eof
+
     result
   end
 
@@ -665,7 +656,7 @@ class ::UNIXSocket < ::BasicSocket
   # @param exception [bool] whether to raise an exception if not ready for reading
   # @return [String, :wait_readable] read buffer
   def read_nonblock(maxlen, buf = nil, exception: true)
-    @io.read_nonblock(maxlen, buf, exception: exception)
+    @io.read_nonblock(maxlen, buf, exception:)
   end
 
   # Performs a non-blocking to the socket. If the socket is not ready for
@@ -677,7 +668,7 @@ class ::UNIXSocket < ::BasicSocket
   # @param exception [bool] whether to raise an exception if not ready for reading
   # @return [Integer, :wait_readable] number of bytes written
   def write_nonblock(buf, exception: true)
-    @io.write_nonblock(buf, exception: exception)
+    @io.write_nonblock(buf, exception:)
   end
 end
 
@@ -724,13 +715,13 @@ class ::UDPSocket < ::IPSocket
   # @return [Integer] bytes sent
   def send(msg, flags, *addr)
     sockaddr =  case addr.size
-    when 2
-      Socket.sockaddr_in(addr[1], addr[0])
-    when 1
-      addr[0]
-    else
-      nil
-    end
+                when 2
+                  Socket.sockaddr_in(addr[1], addr[0])
+                when 1
+                  addr[0]
+                else
+                  nil
+                end
 
     Polyphony.backend_sendmsg(self, msg, flags, sockaddr, nil)
   end

data/lib/polyphony/extensions/thread.rb

@@ -81,7 +81,6 @@ class ::Thread
     return self if @terminated
 
     raise Polyphony::Terminate
-    self
   end
 
   # @!visibility private
@@ -160,9 +159,8 @@ class ::Thread
   #
   # @param result [any] thread's return value
   def finalize(result)
-    unless Fiber.current.children.empty?
-      Fiber.current.shutdown_all_children
-    end
+    Fiber.current.shutdown_all_children if !Fiber.current.children.empty?
+
     @finalization_mutex.synchronize do
       @terminated = true
       @result = result

data/lib/polyphony/extensions/timeout.rb

@@ -4,7 +4,6 @@ require 'timeout'
 
 # Timeout extensions
 module ::Timeout
-
   # Sets a timeout for the given block. This method provides an equivalent API
   # to the stock Timeout API provided by Ruby. In case of a timeout, the block
   # will be interrupted and an exception will be raised according to the given

data/lib/polyphony/version.rb

@@ -2,5 +2,5 @@
 
 module Polyphony
   # @!visibility private
-  VERSION = '1.1.1'
+  VERSION = '1.2'
 end