polyphony 0.82 → 0.83

data/ext/polyphony/zlib_conf.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+libs = $libs
+if %w'z libz zlib1 zlib zdll zlibwapi'.find {|z| have_library(z, 'deflateReset')} and
+    have_header('zlib.h') then
+  have_zlib = true
+else
+  $libs = libs
+  unless File.directory?(zsrc = "#{$srcdir}/zlib")
+    dirs = Dir.open($srcdir) {|z| z.grep(/\Azlib-\d+[.\d]*\z/) {|x|"#{$srcdir}/#{x}"}}
+    dirs.delete_if {|x| !File.directory?(x)}
+    zsrc = dirs.max_by {|x| x.scan(/\d+/).map(&:to_i)}
+  end
+  if zsrc
+    addconf = [
+      "ZSRC = $(srcdir)/#{File.basename(zsrc)}\n",
+      "all:\n",
+    ]
+    $INCFLAGS << " -I$(ZSRC)"
+    if $mswin or $mingw
+      dll = "zlib1.dll"
+      $extso << dll
+      $cleanfiles << "$(topdir)/#{dll}" << "$(ZIMPLIB)"
+      zmk = "\t$(MAKE) -f $(ZMKFILE) TOP=$(ZSRC)"
+      zopts = []
+      if $nmake
+        zmkfile = "$(ZSRC)/win32/Makefile.msc"
+        m = "#{zsrc}/win32/Makefile.msc"
+        # zopts << "USE_ASM=1"
+        zopts << "ARCH=#{RbConfig::CONFIG['target_cpu']}"
+      else
+        zmkfile = "$(ZSRC)/win32/Makefile.gcc"
+        m = "#{zsrc}/win32/Makefile.gcc"
+        zmk += " PREFIX="
+        zmk << CONFIG['CC'][/(.*-)gcc([^\/]*)\z/, 1]
+        zmk << " CC=$(CC)" if $2
+      end
+      m = File.read(m)
+      zimplib = m[/^IMPLIB[ \t]*=[ \t]*(\S+)/, 1]
+      ($LOCAL_LIBS << " ./" << zimplib).strip!
+      unless $nmake or /^TOP[ \t]/ =~ m
+        m.gsub!(/win32\/zlib\.def/, '$(TOP)/\&')
+        m.gsub!(/^(\t.*[ \t])(\S+\.rc)/, '\1-I$(<D) $<')
+        m = "TOP = .\n""VPATH=$(TOP)\n" + m
+        zmkfile = File.basename(zmkfile)
+        File.rename(zmkfile, zmkfile+".orig") if File.exist?(zmkfile)
+        File.write(zmkfile, m)
+      end
+      addconf.push(
+        "ZMKFILE = #{zmkfile}\n",
+        "ZIMPLIB = #{zimplib}\n",
+        "ZOPTS = #{zopts.join(' ')}\n",
+        "$(TARGET_SO): $(ZIMPLIB)\n",
+        "$(ZIMPLIB):\n",
+        "#{zmk} $(ZOPTS) $@\n",
+        "install-so static: $(topdir)/#{dll}",
+        "$(topdir)/#{dll}: $(ZIMPLIB)\n",
+        "\t$(Q) $(COPY) #{dll} $(@D)\n",
+        "clean: clean-zsrc\n",
+        "clean-zsrc:\n",
+        "#{zmk} clean\n",
+      )
+    end
+    Logging.message "using zlib in #{zsrc}\n"
+    $defs << "-DHAVE_ZLIB_H"
+    have_zlib = true
+  end
+end
+
+if have_zlib
+  defines = []
+
+  Logging::message 'checking for kind of operating system... '
+  os_code = with_config('os-code') ||
+    case RUBY_PLATFORM.split('-',2)[1]
+    when 'amigaos' then
+      os_code = 'AMIGA'
+    when /mswin|mingw|bccwin/ then
+      # NOTE: cygwin should be regarded as Unix.
+      os_code = 'WIN32'
+    else
+      os_code = 'UNIX'
+    end
+  os_code = 'OS_' + os_code.upcase
+
+  OS_NAMES = {
+    'OS_MSDOS'   => 'MS-DOS',
+    'OS_AMIGA'   => 'Amiga',
+    'OS_VMS'     => 'VMS',
+    'OS_UNIX'    => 'Unix',
+    'OS_ATARI'   => 'Atari',
+    'OS_MACOS'   => 'MacOS',
+    'OS_TOPS20'  => 'TOPS20',
+    'OS_WIN32'   => 'Win32',
+    'OS_VMCMS'   => 'VM/CMS',
+    'OS_ZSYSTEM' => 'Z-System',
+    'OS_CPM'     => 'CP/M',
+    'OS_QDOS'    => 'QDOS',
+    'OS_RISCOS'  => 'RISCOS',
+    'OS_UNKNOWN' => 'Unknown',
+  }
+  unless OS_NAMES.key? os_code then
+    raise "invalid OS_CODE `#{os_code}'"
+  end
+  Logging::message "#{OS_NAMES[os_code]}\n"
+  defines << "OS_CODE=#{os_code}"
+
+  $defs.concat(defines.collect{|d|' -D'+d})
+
+  if zsrc
+    $defs << "-DHAVE_CRC32_COMBINE"
+    $defs << "-DHAVE_ADLER32_COMBINE"
+    $defs << "-DHAVE_TYPE_Z_CRC_T"
+  else
+    have_func('crc32_combine', 'zlib.h')
+    have_func('adler32_combine', 'zlib.h')
+    have_type('z_crc_t', 'zlib.h')
+  end
+end

data/lib/polyphony/extensions/io.rb

@@ -73,6 +73,14 @@ class ::IO
 
       Open3.popen2(cmd) { |_i, o, _t| yield o }
     end
+
+    def splice(src, dest, maxlen)
+      Polyphony.backend_splice(src, dest, maxlen)
+    end
+
+    def splice_to_eof(src, dest, chunk_size = 8192)
+      Polyphony.backend_splice_to_eof(src, dest, chunk_size)
+    end
   end
 end
 
@@ -257,11 +265,11 @@ class ::IO
     end
   end
 
-  def splice(src, maxlen)
+  def splice_from(src, maxlen)
     Polyphony.backend_splice(src, self, maxlen)
   end
 
-  def splice_to_eof(src, chunksize = 8192)
+  def splice_to_eof_from(src, chunksize = 8192)
     Polyphony.backend_splice_to_eof(src, self, chunksize)
   end
 end

data/lib/polyphony/extensions/pipe.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+# Pipe instance methods
+class Polyphony::Pipe
+  def __read_method__
+    :backend_read
+  end
+
+  def getbyte
+    char = getc
+    char ? char.getbyte(0) : nil
+  end
+
+  def getc
+    return @read_buffer.slice!(0) if @read_buffer && !@read_buffer.empty?
+
+    @read_buffer ||= +''
+    Polyphony.backend_read(self, @read_buffer, 8192, false, -1)
+    return @read_buffer.slice!(0) if !@read_buffer.empty?
+
+    nil
+  end
+
+  def read(len = nil, buf = nil, buf_pos = 0)
+    if buf
+      return Polyphony.backend_read(self, buf, len, true, buf_pos)
+    end
+
+    @read_buffer ||= +''
+    result = Polyphony.backend_read(self, @read_buffer, len, true, -1)
+    return nil unless result
+
+    already_read = @read_buffer
+    @read_buffer = +''
+    already_read
+  end
+
+  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
+
+    result
+  end
+
+  def write(str, *args)
+    Polyphony.backend_write(self, str, *args)
+  end
+
+  def <<(str)
+    Polyphony.backend_write(self, str)
+    self
+  end
+
+  def gets(sep = $/, _limit = nil, _chomp: nil)
+    if sep.is_a?(Integer)
+      sep = $/
+      _limit = sep
+    end
+    sep_size = sep.bytesize
+
+    @read_buffer ||= +''
+
+    while true
+      idx = @read_buffer.index(sep)
+      return @read_buffer.slice!(0, idx + sep_size) if idx
+
+      result = readpartial(8192, @read_buffer, -1)
+      return nil unless result
+    end
+  rescue EOFError
+    return nil
+  end
+
+  # def print(*args)
+  # end
+
+  # def printf(format, *args)
+  # end
+
+  # def putc(obj)
+  # end
+
+  LINEFEED = "\n"
+  LINEFEED_RE = /\n$/.freeze
+
+  def puts(*args)
+    if args.empty?
+      write LINEFEED
+      return
+    end
+
+    idx = 0
+    while idx < args.size
+      arg = args[idx]
+      args[idx] = arg = arg.to_s unless arg.is_a?(String)
+      if arg =~ LINEFEED_RE
+        idx += 1
+      else
+        args.insert(idx + 1, LINEFEED)
+        idx += 2
+      end
+    end
+
+    write(*args)
+    nil
+  end
+
+  # def readbyte
+  # end
+
+  # def readchar
+  # end
+
+  # def readline(sep = $/, limit = nil, chomp: nil)
+  # end
+
+  # def readlines(sep = $/, limit = nil, chomp: nil)
+  # end
+
+  def write_nonblock(string, _options = {})
+    write(string)
+  end
+
+  def read_nonblock(maxlen, buf = nil, _options = nil)
+    buf ? readpartial(maxlen, buf) : readpartial(maxlen)
+  end
+
+  def read_loop(maxlen = 8192, &block)
+    Polyphony.backend_read_loop(self, maxlen, &block)
+  end
+
+  def feed_loop(receiver, method = :call, &block)
+    Polyphony.backend_feed_loop(self, receiver, method, &block)
+  end
+
+  def wait_readable(timeout = nil)
+    if timeout
+      move_on_after(timeout) do
+        Polyphony.backend_wait_io(self, false)
+        self
+      end
+    else
+      Polyphony.backend_wait_io(self, false)
+      self
+    end
+  end
+
+  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
+  end
+
+  def splice_from(src, maxlen)
+    Polyphony.backend_splice(src, self, maxlen)
+  end
+
+  def splice_to_eof_from(src, chunksize = 8192)
+    Polyphony.backend_splice_to_eof(src, self, chunksize)
+  end
+end

data/lib/polyphony/extensions.rb

@@ -3,6 +3,7 @@
 require_relative './extensions/exception'
 require_relative './extensions/fiber'
 require_relative './extensions/io'
+require_relative './extensions/pipe'
 require_relative './extensions/object'
 require_relative './extensions/kernel'
 require_relative './extensions/process'

data/lib/polyphony/version.rb

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

data/lib/polyphony.rb

@@ -18,6 +18,10 @@ require_relative './polyphony/adapters/process'
 # Polyphony API
 module Polyphony
   class << self
+    def pipe
+      Pipe.new
+    end
+
     def fork(&block)
       Kernel.fork do
         # A race condition can arise if a TERM or INT signal is received before

data/test/helper.rb

@@ -37,6 +37,10 @@ module ::Kernel
       format("%p\n", args.size == 1 ? args.first : args)
     end
   end
+
+  def monotonic_clock
+    ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+  end
 end
 
 class MiniTest::Test

data/test/test_backend.rb

@@ -17,7 +17,7 @@ class BackendTest < MiniTest::Test
 
   def test_sleep
     count = 0
-    t0 = Time.now
+    t0 = monotonic_clock
     spin {
       @backend.sleep 0.01
       count += 1
@@ -26,7 +26,7 @@ class BackendTest < MiniTest::Test
       @backend.sleep 0.01
       count += 1
     }.await
-    assert_in_range 0.02..0.06, Time.now - t0 if IS_LINUX
+    assert_in_range 0.02..0.06, monotonic_clock - t0 if IS_LINUX
     assert_equal 3, count
   end
 
@@ -309,51 +309,6 @@ class BackendTest < MiniTest::Test
     assert_equal [1], buffer
   end
 
-  def test_splice
-    i1, o1 = IO.pipe
-    i2, o2 = IO.pipe
-    len = nil
-
-    spin {
-      len = o2.splice(i1, 1000)
-      o2.close
-    }
-
-    o1.write('foobar')
-    result = i2.read
-
-    assert_equal 'foobar', result
-    assert_equal 6, len
-  end
-
-  def test_splice_to_eof
-    i1, o1 = IO.pipe
-    i2, o2 = IO.pipe
-    len = nil
-
-    f = spin {
-      len = o2.splice_to_eof(i1, 1000)
-      o2.close
-    }
-
-    o1.write('foo')
-    result = i2.readpartial(1000)
-    assert_equal 'foo', result
-
-    o1.write('bar')
-    result = i2.readpartial(1000)
-    assert_equal 'bar', result
-    o1.close
-    f.await
-    assert_equal 6, len
-  ensure
-    if f.alive?
-      f.interrupt
-      f.await
-    end
-  end
-
-
   def test_splice_chunks
     body = 'abcd' * 4
     chunk_size = 12
@@ -512,7 +467,7 @@ class BackendChainTest < MiniTest::Test
     i, o = IO.pipe
     backend = Thread.current.backend
     while true
-      len = o.splice(from, 8192)
+      len = o.splice_from(from, 8192)
       break if len == 0
 
       backend.chain(

data/test/test_global_api.rb

@@ -103,38 +103,38 @@ end
 
 class MoveOnAfterTest < MiniTest::Test
   def test_move_on_after
-    t0 = Time.now
+    t0 = monotonic_clock
     v = move_on_after(0.01) do
       sleep 1
       :foo
     end
-    t1 = Time.now
+    t1 = monotonic_clock
 
     assert t1 - t0 < 0.1
     assert_nil v
   end
 
   def test_move_on_after_with_value
-    t0 = Time.now
+    t0 = monotonic_clock
     v = move_on_after(0.01, with_value: :bar) do
       sleep 1
       :foo
     end
-    t1 = Time.now
+    t1 = monotonic_clock
 
     assert t1 - t0 < 0.1
     assert_equal :bar, v
   end
 
   def test_move_on_after_with_reset
-    t0 = Time.now
+    t0 = monotonic_clock
     v = move_on_after(0.01, with_value: :moved_on) do |timeout|
       sleep 0.007
       timeout.reset
       sleep 0.007
       nil
     end
-    t1 = Time.now
+    t1 = monotonic_clock
 
     assert_nil v
     assert_in_range 0.014..0.02, t1 - t0 if IS_LINUX
@@ -143,23 +143,23 @@ class MoveOnAfterTest < MiniTest::Test
   def test_nested_move_on_after
     skip unless IS_LINUX
 
-    t0 = Time.now
+    t0 = monotonic_clock
     o = move_on_after(0.01, with_value: 1) do
       move_on_after(0.02, with_value: 2) do
         sleep 1
       end
     end
-    t1 = Time.now
+    t1 = monotonic_clock
     assert_equal 1, o
     assert_in_range 0.008..0.015, t1 - t0 if IS_LINUX
 
-    t0 = Time.now
+    t0 = monotonic_clock
     o = move_on_after(0.05, with_value: 1) do
       move_on_after(0.01, with_value: 2) do
         sleep 1
       end
     end
-    t1 = Time.now
+    t1 = monotonic_clock
     assert_equal 2, o
     assert_in_range 0.008..0.013, t1 - t0 if IS_LINUX
   end
@@ -167,7 +167,7 @@ end
 
 class CancelAfterTest < MiniTest::Test
   def test_cancel_after
-    t0 = Time.now
+    t0 = monotonic_clock
 
     assert_raises Polyphony::Cancel do
       cancel_after(0.01) do
@@ -175,12 +175,12 @@ class CancelAfterTest < MiniTest::Test
         :foo
       end
     end
-    t1 = Time.now
+    t1 = monotonic_clock
     assert t1 - t0 < 0.1
   end
 
   def test_cancel_after_with_reset
-    t0 = Time.now
+    t0 = monotonic_clock
     cancel_after(0.01) do |f|
       assert_kind_of Fiber, f
       assert_equal Fiber.current, f.parent
@@ -188,7 +188,7 @@ class CancelAfterTest < MiniTest::Test
       f.reset
       sleep 0.007
     end
-    t1 = Time.now
+    t1 = monotonic_clock
     assert_in_range 0.014..0.024, t1 - t0 if IS_LINUX
   end
 
@@ -270,7 +270,7 @@ class SpinLoopTest < MiniTest::Test
   def test_spin_loop_with_rate
     buffer = []
     counter = 0
-    t0 = Time.now
+    t0 = monotonic_clock
     f = spin_loop(rate: 100) { buffer << (counter += 1) }
     sleep 0.02
     f.stop
@@ -280,7 +280,7 @@ class SpinLoopTest < MiniTest::Test
   def test_spin_loop_with_interval
     buffer = []
     counter = 0
-    t0 = Time.now
+    t0 = monotonic_clock
     f = spin_loop(interval: 0.01) { buffer << (counter += 1) }
     sleep 0.02
     f.stop
@@ -361,7 +361,7 @@ class ThrottledLoopTest < MiniTest::Test
   def test_throttled_loop
     buffer = []
     counter = 0
-    t0 = Time.now
+    t0 = monotonic_clock
     f = spin do
       throttled_loop(10) { buffer << (counter += 1) }
     end
@@ -372,12 +372,12 @@ class ThrottledLoopTest < MiniTest::Test
   def test_throttled_loop_with_count
     buffer = []
     counter = 0
-    t0 = Time.now
+    t0 = monotonic_clock
     f = spin do
       throttled_loop(50, count: 5) { buffer << (counter += 1) }
     end
     f.await
-    t1 = Time.now
+    t1 = monotonic_clock
     assert_in_range 0.075..0.15, t1 - t0 if IS_LINUX
     assert_equal [1, 2, 3, 4, 5], buffer
   end
@@ -395,7 +395,7 @@ class GlobalAPIEtcTest < MiniTest::Test
 
   def test_every
     buffer = []
-    t0 = Time.now
+    t0 = monotonic_clock
     f = spin do
       every(0.01) { buffer << 1 }
     end
@@ -406,7 +406,7 @@ class GlobalAPIEtcTest < MiniTest::Test
 
   def test_every_with_slow_op
     buffer = []
-    t0 = Time.now
+    t0 = monotonic_clock
     f = spin do
       every(0.01) { sleep 0.05; buffer << 1 }
     end
@@ -416,9 +416,9 @@ class GlobalAPIEtcTest < MiniTest::Test
   end
 
   def test_sleep
-    t0 = Time.now
+    t0 = monotonic_clock
     sleep 0.1
-    elapsed = Time.now - t0
+    elapsed = monotonic_clock - t0
     assert_in_range 0.05..0.15, elapsed if IS_LINUX
 
     f = spin { sleep }