polyphony 0.36 → 0.38

data/lib/polyphony/adapters/fs.rb

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
-export  :stat,
-        :read
-
 require 'fileutils'
 
-ThreadPool = import('./core/thread_pool')
+require_relative './core/thread_pool'
 
 ::File.singleton_class.instance_eval do
   alias_method :orig_stat, :stat

data/lib/polyphony/adapters/process.rb

@@ -1,29 +1,33 @@
 # frozen_string_literal: true
 
-export :watch
-
-def watch(cmd = nil, &block)
-  terminated = nil
-  pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
-  watcher = Gyro::Child.new(pid)
-  watcher.await
-  terminated = true
-ensure
-  kill_process(pid) unless terminated || pid.nil?
-end
-
-def kill_process(pid)
-  cancel_after(5) do
-    kill_and_await('TERM', pid)
+module Polyphony
+  module Process
+    class << self
+      def watch(cmd = nil, &block)
+        terminated = nil
+        pid = cmd ? Kernel.spawn(cmd) : Polyphony.fork(&block)
+        watcher = Gyro::Child.new(pid)
+        watcher.await
+        terminated = true
+      ensure
+        kill_process(pid) unless terminated || pid.nil?
+      end
+      
+      def kill_process(pid)
+        cancel_after(5) do
+          kill_and_await('TERM', pid)
+        end
+      rescue Polyphony::Cancel
+        kill_and_await(-9, pid)
+      end
+      
+      def kill_and_await(sig, pid)
+        ::Process.kill(sig, pid)
+        Gyro::Child.new(pid).await
+      rescue SystemCallError
+        # ignore
+        puts 'SystemCallError in kill_and_await'
+      end
+    end
   end
-rescue Polyphony::Cancel
-  kill_and_await(-9, pid)
-end
-
-def kill_and_await(sig, pid)
-  Process.kill(sig, pid)
-  Gyro::Child.new(pid).await
-rescue SystemCallError
-  # ignore
-  puts 'SystemCallError in kill_and_await'
 end

data/lib/polyphony/adapters/trace.rb

@@ -1,133 +1,138 @@
 # frozen_string_literal: true
 
-export :new, :analyze, :STOCK_EVENTS
-
-require 'polyphony'
+require_relative '../../polyphony'
 
 STOCK_EVENTS = %i[line call return c_call c_return b_call b_return].freeze
 
-def new(*events)
-  start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-  events = STOCK_EVENTS if events.empty?
-  ::TracePoint.new(*events) { |tp| yield trace_record(tp, start_stamp) }
-end
-
-def trace_record(trp, start_stamp)
-  stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_stamp
-
-  { stamp: stamp, event: trp.event, location: "#{trp.path}:#{trp.lineno}",
-    self: trp.self, binding: trp.binding, fiber: tp_fiber(trp),
-    lineno: trp.lineno, method_id: trp.method_id,
-    path: trp.path, parameters: tp_params(trp),
-    return_value: tp_return_value(trp), schedule_value: tp_schedule_value(trp),
-    exception: tp_raised_exception(trp) }
-end
-
-def tp_fiber(trp)
-  trp.is_a?(FiberTracePoint) ? trp.fiber : Fiber.current
-end
-
-PARAMS_EVENTS = %i[call c_call b_call].freeze
-
-def tp_params(trp)
-  PARAMS_EVENTS.include?(trp.event) ? trp.parameters : nil
-end
-
-RETURN_VALUE_EVENTS = %i[return c_return b_return].freeze
-
-def tp_return_value(trp)
-  RETURN_VALUE_EVENTS.include?(trp.event) ? trp.return_value : nil
-end
-
-SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
-
-def tp_schedule_value(trp)
-  SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
-end
-
-def tp_raised_exception(trp)
-  trp.event == :raise && trp.raised_exception
-end
-
-def analyze(records)
-  by_fiber = Hash.new { |h, f| h[f] = [] }
-  records.each_with_object(by_fiber) { |r, h| h[r[:fiber]] << r }
-  { by_fiber: by_fiber }
-end
-
-# Implements fake TracePoint instances for fiber-related events
-class FiberTracePoint
-  attr_reader :event, :fiber, :value
-
-  def initialize(tpoint)
-    @tp = tpoint
-    @event = tpoint.return_value[0]
-    @fiber = tpoint.return_value[1]
-    @value = tpoint.return_value[2]
-  end
-
-  def lineno
-    @tp.lineno
-  end
-
-  def method_id
-    @tp.method_id
-  end
-
-  def path
-    @tp.path
-  end
-
-  def self
-    @tp.self
-  end
-
-  def binding
-    @tp.binding
-  end
-end
-
-class << ::TracePoint
-  POLYPHONY_FILE_REGEXP = /^#{::Exception::POLYPHONY_DIR}/.freeze
-
-  alias_method :orig_new, :new
-  def new(*args, &block)
-    events_mask, fiber_events_mask = event_masks(args)
-
-    orig_new(*events_mask) do |tp|
-      handle_tp_event(tp, fiber_events_mask, &block)
-    end
-  end
-
-  def handle_tp_event(tpoint, fiber_events_mask)
-    # next unless !$watched_fiber || Fiber.current == $watched_fiber
-
-    if tpoint.method_id == :__fiber_trace__
-      return if tpoint.event != :c_return
-      return unless fiber_events_mask.include?(tpoint.return_value[0])
-
-      tpoint = FiberTracePoint.new(tpoint)
-    elsif tpoint.path =~ POLYPHONY_FILE_REGEXP
-      return
-    end
-
-    yield tpoint
-  end
-
-  ALL_FIBER_EVENTS = %i[
-    fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
-    fiber_ev_loop_enter fiber_ev_loop_leave
-  ].freeze
-
-  def event_masks(events)
-    events.each_with_object([[], []]) do |e, masks|
-      case e
-      when /fiber_/
-        masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
-        masks[0] << :c_return unless masks[0].include?(:c_return)
-      else
-        masks[0] << e
+module Polyphony
+  module Trace
+    class << self
+      def new(*events)
+        start_stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+        events = STOCK_EVENTS if events.empty?
+        ::TracePoint.new(*events) { |tp| yield trace_record(tp, start_stamp) }
+      end
+      
+      def trace_record(trp, start_stamp)
+        stamp = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - start_stamp
+      
+        { stamp: stamp, event: trp.event, location: "#{trp.path}:#{trp.lineno}",
+          self: trp.self, binding: trp.binding, fiber: tp_fiber(trp),
+          lineno: trp.lineno, method_id: trp.method_id,
+          path: trp.path, parameters: tp_params(trp),
+          return_value: tp_return_value(trp), schedule_value: tp_schedule_value(trp),
+          exception: tp_raised_exception(trp) }
+      end
+      
+      def tp_fiber(trp)
+        trp.is_a?(FiberTracePoint) ? trp.fiber : Fiber.current
+      end
+      
+      PARAMS_EVENTS = %i[call c_call b_call].freeze
+      
+      def tp_params(trp)
+        PARAMS_EVENTS.include?(trp.event) ? trp.parameters : nil
+      end
+      
+      RETURN_VALUE_EVENTS = %i[return c_return b_return].freeze
+      
+      def tp_return_value(trp)
+        RETURN_VALUE_EVENTS.include?(trp.event) ? trp.return_value : nil
+      end
+      
+      SCHEDULE_VALUE_EVENTS = %i[fiber_schedule fiber_run].freeze
+      
+      def tp_schedule_value(trp)
+        SCHEDULE_VALUE_EVENTS.include?(trp.event) ? trp.value : nil
+      end
+      
+      def tp_raised_exception(trp)
+        trp.event == :raise && trp.raised_exception
+      end
+      
+      def analyze(records)
+        by_fiber = Hash.new { |h, f| h[f] = [] }
+        records.each_with_object(by_fiber) { |r, h| h[r[:fiber]] << r }
+        { by_fiber: by_fiber }
+      end
+      
+      # Implements fake TracePoint instances for fiber-related events
+      class FiberTracePoint
+        attr_reader :event, :fiber, :value
+      
+        def initialize(tpoint)
+          @tp = tpoint
+          @event = tpoint.return_value[0]
+          @fiber = tpoint.return_value[1]
+          @value = tpoint.return_value[2]
+        end
+      
+        def lineno
+          @tp.lineno
+        end
+      
+        def method_id
+          @tp.method_id
+        end
+      
+        def path
+          @tp.path
+        end
+      
+        def self
+          @tp.self
+        end
+      
+        def binding
+          @tp.binding
+        end
+      end
+      
+      class << ::TracePoint
+        POLYPHONY_FILE_REGEXP = /^#{::Exception::POLYPHONY_DIR}/.freeze
+      
+        alias_method :orig_new, :new
+        def new(*args, &block)
+          events_mask, fiber_events_mask = event_masks(args)
+      
+          orig_new(*events_mask) do |tp|
+            handle_tp_event(tp, fiber_events_mask, &block)
+          end
+        end
+      
+        def handle_tp_event(tpoint, fiber_events_mask)
+          # next unless !$watched_fiber || Fiber.current == $watched_fiber
+      
+          if tpoint.method_id == :__fiber_trace__
+            return if tpoint.event != :c_return
+            return unless fiber_events_mask.include?(tpoint.return_value[0])
+      
+            tpoint = FiberTracePoint.new(tpoint)
+          elsif tpoint.path =~ POLYPHONY_FILE_REGEXP
+            return
+          end
+      
+          yield tpoint
+        end
+      
+        ALL_FIBER_EVENTS = %i[
+          fiber_create fiber_terminate fiber_schedule fiber_switchpoint fiber_run
+          fiber_ev_loop_enter fiber_ev_loop_leave
+        ].freeze
+      
+        def event_masks(events)
+          events.each_with_object([[], []]) do |e, masks|
+            case e
+            when /fiber_/
+              masks[1] += e == :fiber_all ? ALL_FIBER_EVENTS : [e]
+              masks[0] << :c_return unless masks[0].include?(:c_return)
+            else
+              masks[0] << e
+            end
+          end
+        end
       end
     end
   end
 end
+

data/lib/polyphony/core/channel.rb

@@ -1,46 +1,46 @@
 # frozen_string_literal: true
 
-export_default :Channel
+require_relative './exceptions'
 
-Exceptions = import('./exceptions')
-
-# Implements a unidirectional communication channel along the lines of Go
-# (buffered) channels.
-class Channel
-  def initialize
-    @payload_queue = []
-    @waiting_queue = []
-  end
+module Polyphony
+  # Implements a unidirectional communication channel along the lines of Go
+  # (buffered) channels.
+  class Channel
+    def initialize
+      @payload_queue = []
+      @waiting_queue = []
+    end
 
-  def close
-    stop = Exceptions::MoveOn.new
-    @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
-  end
+    def close
+      stop = Polyphony::MoveOn.new
+      @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
+    end
 
-  def <<(value)
-    if @waiting_queue.empty?
-      @payload_queue << value
-    else
-      @waiting_queue.shift&.schedule(value)
+    def <<(value)
+      if @waiting_queue.empty?
+        @payload_queue << value
+      else
+        @waiting_queue.shift&.schedule(value)
+      end
+      snooze
     end
-    snooze
-  end
 
-  def receive
-    Gyro.ref
-    if @payload_queue.empty?
-      @waiting_queue << Fiber.current
-      suspend
-    else
-      receive_from_queue
+    def receive
+      Gyro.ref
+      if @payload_queue.empty?
+        @waiting_queue << Fiber.current
+        suspend
+      else
+        receive_from_queue
+      end
+    ensure
+      Gyro.unref
     end
-  ensure
-    Gyro.unref
-  end
 
-  def receive_from_queue
-    payload = @payload_queue.shift
-    snooze
-    payload
+    def receive_from_queue
+      payload = @payload_queue.shift
+      snooze
+      payload
+    end
   end
-end
+end

data/lib/polyphony/core/exceptions.rb

@@ -1,36 +1,36 @@
 # frozen_string_literal: true
 
-export :BaseException, :MoveOn, :Cancel, :Terminate, :Restart
-
-# Common exception class for interrupting fibers. These exceptions allow
-# control of fibers. BaseException exceptions can encapsulate a value and thus
-# provide a way to interrupt long-running blocking operations while still
-# passing a value back to the call site. BaseException exceptions can also
-# references a cancel scope in order to allow correct bubbling of exceptions
-# through nested cancel scopes.
-class BaseException < ::Exception
-  attr_reader :value
-
-  def initialize(value = nil)
-    @caller_backtrace = caller
-    @value = value
-  end
-
-  def backtrace
-    sanitize(@caller_backtrace)
+module Polyphony
+  # Common exception class for interrupting fibers. These exceptions allow
+  # control of fibers. BaseException exceptions can encapsulate a value and thus
+  # provide a way to interrupt long-running blocking operations while still
+  # passing a value back to the call site. BaseException exceptions can also
+  # references a cancel scope in order to allow correct bubbling of exceptions
+  # through nested cancel scopes.
+  class BaseException < ::Exception
+    attr_reader :value
+
+    def initialize(value = nil)
+      @caller_backtrace = caller
+      @value = value
+    end
+
+    def backtrace
+      sanitize(@caller_backtrace)
+    end
   end
-end
 
-# MoveOn is used to interrupt a long-running blocking operation, while
-# continuing the rest of the computation.
-class MoveOn < BaseException; end
+  # MoveOn is used to interrupt a long-running blocking operation, while
+  # continuing the rest of the computation.
+  class MoveOn < BaseException; end
 
-# Cancel is used to interrupt a long-running blocking operation, bubbling the
-# exception up through cancel scopes and supervisors.
-class Cancel < BaseException; end
+  # Cancel is used to interrupt a long-running blocking operation, bubbling the
+  # exception up through cancel scopes and supervisors.
+  class Cancel < BaseException; end
 
-# Terminate is used to interrupt a fiber once its parent fiber has terminated.
-class Terminate < BaseException; end
+  # Terminate is used to interrupt a fiber once its parent fiber has terminated.
+  class Terminate < BaseException; end
 
-# Restart is used to restart a fiber
-class Restart < BaseException; end
+  # Restart is used to restart a fiber
+  class Restart < BaseException; end
+end