ntl-actor 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4bb4e6d1c16a91e05baee4e50e7dfd15f3b1fe9b
+  data.tar.gz: 8bba64e0b7e2cf6bb1333db1a543891d3f39a1f6
+SHA512:
+  metadata.gz: 8515e2123e74493072741078194d021e7ccaa1be0dba3ab7773ef2428aeabc1a05d68b252dbb43a13271b5590b63ebd0aa95521e3c28368ca817df470eaa4ef5
+  data.tar.gz: 6ecccc370a61eb473b0db1ddf7304075b0c0bcb35ca807637bcb8c2d8ffad3deaaaa7d82ff45b9a55f3fa82a40e78c4ad7146fe4c2e8583264d7b0982ad8fc65

data/lib/actor.rb

@@ -0,0 +1,20 @@
+require 'ostruct'
+require 'securerandom'
+require 'set'
+
+require 'actor/queue'
+require 'actor/queue/assertions'
+require 'actor/queue/reader'
+
+require 'actor/statistics'
+require 'actor/statistics/copy'
+require 'actor/statistics/timer'
+
+require 'actor/messaging/address'
+require 'actor/messaging/reader'
+require 'actor/messaging/reader/substitute'
+require 'actor/messaging/writer'
+require 'actor/messaging/writer/substitute'
+require 'actor/messaging/system_message'
+
+require 'actor/actor'

data/lib/actor/actor.rb

@@ -0,0 +1,146 @@
+module Actor
+  def self.included cls
+    cls.class_exec do
+      extend Destructure
+      extend Spawn
+      extend Start
+
+      prepend UpdateStatistics
+    end
+  end
+
+  attr_accessor :actor_address
+  attr_accessor :actor_state
+  attr_writer :reader
+
+  def action
+  end
+
+  def actor_statistics
+    @actor_statistics ||= Statistics.new
+  end
+
+  def handle _
+  end
+
+  def handle_system_message message
+    case message
+    when Messaging::SystemMessage::Pause then
+      self.actor_state = State::Paused
+
+    when Messaging::SystemMessage::Resume then
+      self.actor_state = State::Running
+
+    when Messaging::SystemMessage::Stop then
+      self.actor_state = State::Stopped
+      raise StopIteration
+
+    when Messaging::SystemMessage::RecordStatus then
+      status = message.status
+
+      Statistics::Copy.(status, actor_statistics)
+
+      status.state = actor_state
+
+      Messaging::Writer.write status, message.reply_address
+    end
+  end
+
+  def reader
+    @reader ||= Reader::Substitute.new
+  end
+
+  def run_loop
+    loop do
+      while message = reader.read(wait: actor_state == State::Paused)
+        handle message
+
+        if message.is_a? Messaging::SystemMessage
+          handle_system_message message
+        end
+      end
+
+      action if actor_state == State::Running
+
+      Thread.pass
+    end
+  end
+
+  module Destructure
+    def destructure actor, address, thread, include: nil
+      return address if include.nil?
+
+      result = [address]
+
+      include.each do |variable_name|
+        value = binding.local_variable_get variable_name
+
+        result << value
+      end
+
+      return *result
+    end
+  end
+
+  module Spawn
+    def spawn *positional_arguments, include: nil, **keyword_arguments, &block
+      address = Messaging::Address.get
+
+      method = if respond_to? :build then :build else :new end
+
+      if keyword_arguments.empty?
+        instance = __send__ method, *positional_arguments, &block
+      else
+        instance = __send__ method, *positional_arguments, **keyword_arguments, &block
+      end
+
+      reader = Messaging::Reader.build address
+
+      instance.actor_address = address
+      instance.actor_state = State::Paused
+      instance.reader = reader
+
+      thread = ::Thread.new do
+        instance.run_loop
+      end
+
+      destructure instance, address, thread, include: include
+    end
+  end
+
+  module Start
+    def start *positional_arguments, include: nil, **keyword_arguments, &block
+      address, instance, thread = spawn(
+        *positional_arguments,
+        include: %i(actor thread),
+        **keyword_arguments,
+        &block
+      )
+
+      Messaging::Writer.write(
+        Messaging::SystemMessage::Resume.new,
+        address
+      )
+
+      destructure instance, address, thread, include: include
+    end
+  end
+
+  module State
+    Paused = :paused
+    Running = :running
+    Stopped = :stopped
+  end
+
+  module UpdateStatistics
+    def action
+      actor_statistics.executing_action
+
+      result = super
+
+      actor_statistics.action_executed
+
+      result
+    end
+  end
+end

data/lib/actor/controls.rb

@@ -0,0 +1,10 @@
+require 'actor/controls/actor'
+require 'actor/controls/statistics'
+require 'actor/controls/statistics/elapsed_time'
+require 'actor/controls/statistics/elapsed_time/average'
+require 'actor/controls/statistics/elapsed_time/maximum'
+require 'actor/controls/statistics/elapsed_time/minimum'
+require 'actor/controls/statistics/elapsed_time/standard_deviation'
+require 'actor/controls/statistics/timer'
+require 'actor/controls/time'
+require 'actor/controls/time/clock'

data/lib/actor/controls/actor.rb

@@ -0,0 +1,13 @@
+module Actor
+  module Controls
+    module Actor
+      def self.example
+        Example.new
+      end
+
+      class Example
+        include ::Actor
+      end
+    end
+  end
+end

data/lib/actor/controls/statistics.rb

@@ -0,0 +1,21 @@
+module Actor
+  module Controls
+    module Statistics
+      def self.example executions=nil
+        executions ||= 1
+
+        statistics = ::Actor::Statistics.new
+
+        executions.times do
+          timer = Controls::Statistics::Timer.example
+          statistics.timer = timer
+
+          statistics.executing_action
+          statistics.action_executed
+        end
+
+        statistics
+      end
+    end
+  end
+end

data/lib/actor/controls/statistics/elapsed_time.rb

@@ -0,0 +1,15 @@
+module Actor
+  module Controls
+    module Statistics
+      module ElapsedTime
+        def self.configure_timer receiver, elapsed_times
+          timer = Timer.example elapsed_times
+
+          receiver.timer = timer
+
+          elapsed_times.count
+        end
+      end
+    end
+  end
+end

data/lib/actor/controls/statistics/elapsed_time/average.rb

@@ -0,0 +1,21 @@
+module Actor
+  module Controls
+    module Statistics
+      module ElapsedTime
+        module Average
+          def self.configure_timer receiver
+            ElapsedTime.configure_timer receiver, elapsed_times
+          end
+
+          def self.elapsed_times
+            [1, 2, 6]
+          end
+
+          def self.value
+            3
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actor/controls/statistics/elapsed_time/maximum.rb

@@ -0,0 +1,21 @@
+module Actor
+  module Controls
+    module Statistics
+      module ElapsedTime
+        module Maximum
+          def self.configure_timer receiver
+            ElapsedTime.configure_timer receiver, elapsed_times
+          end
+
+          def self.elapsed_times
+            [1, 11, 111]
+          end
+
+          def self.value
+            111
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actor/controls/statistics/elapsed_time/minimum.rb

@@ -0,0 +1,21 @@
+module Actor
+  module Controls
+    module Statistics
+      module ElapsedTime
+        module Minimum
+          def self.configure_timer receiver
+            ElapsedTime.configure_timer receiver, elapsed_times
+          end
+
+          def self.elapsed_times
+            [111, 11, 1]
+          end
+
+          def self.value
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actor/controls/statistics/elapsed_time/standard_deviation.rb

@@ -0,0 +1,38 @@
+# See https://rosettacode.org/wiki/Standard_deviation
+module Actor
+  module Controls
+    module Statistics
+      module ElapsedTime
+        module StandardDeviation
+          def self.configure_timer receiver
+            ElapsedTime.configure_timer receiver, elapsed_times
+          end
+
+          def self.elapsed_times
+            [2, 4, 4, 4, 5, 5, 7, 9]
+          end
+
+          def self.average
+            5
+          end
+
+          def self.maximum
+            7
+          end
+
+          def self.minimum
+            3
+          end
+
+          def self.percent
+            40.0
+          end
+
+          def self.value
+            2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actor/controls/statistics/timer.rb

@@ -0,0 +1,19 @@
+module Actor
+  module Controls
+    module Statistics
+      module Timer
+        def self.example elapsed_times=nil
+          elapsed_times ||= [Controls::Time::ElapsedTime.example]
+
+          steps = elapsed_times.flat_map do |elapsed_time|
+            [elapsed_time, 0]
+          end
+
+          timer = ::Actor::Statistics::Timer.new
+          timer.clock = Time::Clock.build steps
+          timer
+        end
+      end
+    end
+  end
+end

data/lib/actor/controls/time.rb

@@ -0,0 +1,24 @@
+module Actor
+  module Controls
+    module Time
+      def self.example offset=nil
+        offset ||= 0
+        offset = ElapsedTime.example offset
+
+        reference + offset
+      end
+
+      def self.reference
+        ::Time.new 2000, 1, 1, 11, 11, 11, -3600
+      end
+
+      module ElapsedTime
+        def self.example scalar=nil
+          scalar ||= 1
+
+          Rational(scalar, 1000)
+        end
+      end
+    end
+  end
+end

data/lib/actor/controls/time/clock.rb

@@ -0,0 +1,31 @@
+module Actor
+  module Controls
+    module Time
+      class Clock
+        attr_reader :step_function
+        attr_accessor :time
+
+        def initialize time, step_function
+          @time = time
+          @step_function = step_function
+        end
+
+        def self.build steps
+          time = Time.reference
+
+          step_function = steps.cycle
+
+          new time, step_function
+        end
+
+        def now
+          now = time
+
+          self.time += step_function.next
+
+          now
+        end
+      end
+    end
+  end
+end

data/lib/actor/messaging/address.rb

@@ -0,0 +1,40 @@
+module Actor
+  module Messaging
+    class Address
+      attr_reader :id
+      attr_reader :queue
+
+      def initialize id, queue
+        @id = id
+        @queue = queue
+      end
+
+      def self.get
+        id = SecureRandom.uuid
+        queue = Queue.new
+
+        new id, queue
+      end
+
+      def reader_count
+        queue.reader_count
+      end
+
+      def inspect
+        %{#<#{self.class.name} id=#{id.inspect}, queue=#{queue_tail}..#{queue_head}, readers=#{reader_count}>}
+      end
+
+      def queue_head
+        queue.head
+      end
+
+      def queue_tail
+        queue.tail
+      end
+
+      def queue_size
+        queue.size
+      end
+    end
+  end
+end

data/lib/actor/messaging/reader.rb

@@ -0,0 +1,31 @@
+module Actor
+  module Messaging
+    class Reader
+      attr_reader :queue_reader
+
+      def initialize queue_reader
+        @queue_reader = queue_reader
+      end
+
+      def self.build address
+        queue = address.queue
+
+        queue_reader = Queue::Reader.build queue
+
+        new queue_reader
+      end
+
+      def read wait: nil
+        queue_reader.read wait: wait
+      end
+
+      def stop
+        queue_reader.stop
+      end
+
+      def stopped?
+        queue_reader.stopped?
+      end
+    end
+  end
+end

data/lib/actor/messaging/reader/substitute.rb

@@ -0,0 +1,40 @@
+module Actor
+  module Messaging
+    class Reader
+      class Substitute
+        attr_accessor :stopped
+
+        def read wait: nil
+          message = messages.shift
+
+          return message if message
+
+          if wait
+            raise Wait, "Next message has not yet been written"
+          end
+        end
+
+        def stop
+          self.stopped = true
+        end
+
+        def stopped?
+          stopped
+        end
+
+        def add_message message
+          messages << message
+        end
+
+        def messages
+          @messages ||= []
+        end
+
+        Wait = Class.new StandardError
+
+        # Eventide compatibility
+        singleton_class.send :alias_method, :build, :new
+      end
+    end
+  end
+end

data/lib/actor/messaging/system_message.rb

@@ -0,0 +1,25 @@
+module Actor
+  module Messaging
+    module SystemMessage
+      Pause = Class.new { include SystemMessage }
+      Resume = Class.new { include SystemMessage }
+      Stop = Class.new { include SystemMessage }
+
+      class RecordStatus
+        include SystemMessage
+
+        attr_reader :reply_address
+        attr_reader :status
+
+        def initialize reply_address
+          @reply_address = reply_address
+          @status = Status.new
+        end
+      end
+
+      class Status < OpenStruct
+        include SystemMessage
+      end
+    end
+  end
+end

data/lib/actor/messaging/writer.rb

@@ -0,0 +1,26 @@
+module Actor
+  module Messaging
+    class Writer
+      attr_reader :queue
+
+      def initialize queue
+        @queue = queue
+      end
+
+      def self.build address
+        queue = address.queue
+
+        new queue
+      end
+
+      def self.write message, address
+        instance = build address
+        instance.write message
+      end
+
+      def write message
+        queue.write message
+      end
+    end
+  end
+end

data/lib/actor/messaging/writer/substitute.rb

@@ -0,0 +1,26 @@
+module Actor
+  module Messaging
+    class Writer
+      class Substitute
+        def write message
+          messages << message
+        end
+
+        def messages
+          @messages ||= []
+        end
+
+        module Assertions
+          def written? &block
+            block ||= proc { true }
+
+            messages.any? &block
+          end
+        end
+
+        # Eventide compatibility
+        singleton_class.send :alias_method, :build, :new
+      end
+    end
+  end
+end

data/lib/actor/queue.rb

@@ -0,0 +1,116 @@
+module Actor
+  class Queue
+    attr_reader :blocked_threads
+    attr_reader :reader_positions
+    attr_reader :list
+    attr_reader :mutex
+    attr_accessor :tail
+
+    def initialize
+      @blocked_threads = Set.new
+      @reader_positions = Hash.new 0
+      @list = []
+      @mutex = Mutex.new
+      @tail = 0
+    end
+
+    def head
+      tail + size
+    end
+
+    def read position, wait: nil
+      mutex.synchronize do
+        relative_position = position - tail
+
+        until list.count > relative_position
+          return nil unless wait
+
+          blocked_threads << Thread.current
+          mutex.sleep
+          blocked_threads.delete Thread.current
+        end
+
+        object = list[relative_position]
+
+        up position.next
+        down position
+
+        object
+      end
+    end
+
+    def reader_started position=nil
+      mutex.synchronize do
+        position ||= tail
+
+        up position
+
+        position
+      end
+    end
+
+    def readers?
+      reader_positions.any?
+    end
+
+    def reader_count
+      return 0 unless readers?
+
+      reader_positions.values.reduce &:+
+    end
+
+    def reader_stopped position
+      mutex.synchronize do
+        down position
+      end
+    end
+
+    def size
+      list.size
+    end
+
+    def write object
+      # Owning the mutex is not necessary here; the worst that can happen is
+      # that occasionally we write a object when there aren't any readers.
+      return unless readers?
+
+      mutex.synchronize do
+        list << object
+      end
+
+      blocked_threads.each &:wakeup
+    end
+
+    # These command methods are highly unsafe to call without owning the mutex;
+    # therefore, they are marked as private.
+    private
+
+    def down position
+      ref_count = reader_positions[position] - 1
+
+      if ref_count.zero?
+        reader_positions.delete position
+      else
+        reader_positions[position] = ref_count
+      end
+
+      if ref_count.zero?
+        if readers? and position == tail
+          new_tail = reader_positions.keys.min
+
+          expired_objects = new_tail - tail
+
+          list.slice! 0, expired_objects
+
+          self.tail = new_tail
+        end
+      end
+
+      ref_count
+    end
+
+    def up position
+      reader_positions[position] += 1
+    end
+  end
+end

data/lib/actor/queue/assertions.rb

@@ -0,0 +1,13 @@
+module Actor
+  class Queue
+    module Assertions
+      def contains? object
+        if list.find object then true else false end
+      end
+
+      def empty?
+        size.zero?
+      end
+    end
+  end
+end

data/lib/actor/queue/reader.rb

@@ -0,0 +1,57 @@
+module Actor
+  class Queue
+    class Reader
+      attr_reader :queue
+      attr_accessor :position
+      attr_accessor :stopped
+
+      def initialize queue, position
+        @queue = queue
+        @position = position
+      end
+
+      def self.build queue
+        position = queue.reader_started
+
+        new queue, position
+      end
+
+      def self.start queue, &block
+        instance = build queue
+
+        begin
+          block.(instance)
+          return instance
+        ensure
+          instance.stop
+        end
+      end
+
+      def read wait: nil
+        if stopped?
+          raise Stopped, "Reader has stopped"
+        end
+
+        object = queue.read position, wait: wait
+
+        return nil if object.nil?
+
+        self.position = position.next
+
+        object
+      end
+
+      def stop
+        self.stopped = true
+
+        queue.reader_stopped position
+      end
+
+      def stopped?
+        stopped
+      end
+
+      Stopped = Class.new StandardError
+    end
+  end
+end

data/lib/actor/statistics.rb

@@ -0,0 +1,75 @@
+module Actor
+  class Statistics
+    attr_accessor :elapsed_time
+    attr_accessor :executions
+    attr_accessor :last_execution_time
+    attr_accessor :maximum_elapsed_time
+    attr_accessor :minimum_elapsed_time
+    attr_accessor :start_time
+    attr_accessor :sum_elapsed_time_squared
+    attr_writer :timer
+
+    def initialize
+      @executions = 0
+      @elapsed_time = 0
+      @sum_elapsed_time_squared = 0
+    end
+
+    def self.build actor
+      instance = new
+      actor.add_observer instance
+      instance
+    end
+
+    def executing_action
+      now = timer.reset
+
+      self.start_time ||= now
+    end
+
+    def action_executed
+      start_time, stop_time = timer.stop
+
+      elapsed_time = stop_time - start_time
+
+      self.elapsed_time += elapsed_time
+      self.executions += 1
+      self.last_execution_time = stop_time
+      self.maximum_elapsed_time = [elapsed_time, maximum_elapsed_time].compact.max
+      self.minimum_elapsed_time = [elapsed_time, minimum_elapsed_time].compact.min
+      self.sum_elapsed_time_squared += elapsed_time ** 2
+    end
+
+    def average_elapsed_time
+      return nil if executions.zero?
+
+      Rational elapsed_time, executions
+    end
+
+    def standard_deviation
+      return nil if executions.zero?
+
+      average_elapsed_time = self.average_elapsed_time
+
+      deviation = Math.sqrt(
+        [
+          0,
+          Rational(sum_elapsed_time_squared, executions) - average_elapsed_time ** 2
+        ].max
+      )
+
+      min = average_elapsed_time - deviation
+      max = average_elapsed_time + deviation
+
+      unless average_elapsed_time.zero?
+        percent = Rational(deviation * 100, average_elapsed_time)
+      end
+
+      return deviation, min, max, percent
+    end
+
+    def timer
+      @timer ||= Timer.new
+    end
+  end
+end

data/lib/actor/statistics/copy.rb

@@ -0,0 +1,19 @@
+module Actor
+  class Statistics
+    module Copy
+      def self.call target, statistics
+        target.average_elapsed_time = statistics.average_elapsed_time
+        target.elapsed_time = statistics.elapsed_time
+        target.executions = statistics.executions
+        target.last_execution_time = statistics.last_execution_time
+        target.minimum_elapsed_time = statistics.minimum_elapsed_time
+        target.maximum_elapsed_time = statistics.maximum_elapsed_time
+        target.start_time = statistics.start_time
+
+        deviation, _, _, percent = statistics.standard_deviation
+        target.standard_deviation_amount = deviation
+        target.standard_deviation_percent = percent
+      end
+    end
+  end
+end

data/lib/actor/statistics/timer.rb

@@ -0,0 +1,26 @@
+module Actor
+  class Statistics
+    class Timer
+      attr_writer :clock
+      attr_accessor :start_time
+      attr_accessor :stop_time
+
+      def clock
+        @clock ||= Time
+      end
+
+      def reset
+        self.stop_time = nil
+        self.start_time = clock.now
+
+        start_time
+      end
+
+      def stop
+        self.stop_time = stop_time = clock.now
+
+        return start_time, stop_time
+      end
+    end
+  end
+end

data/lib/actor/test_fixtures.rb

@@ -0,0 +1,4 @@
+require 'test_bench'
+
+require 'actor/test_fixtures/parallel_iteration'
+require 'actor/test_fixtures/sample_actor_status'

data/lib/actor/test_fixtures/parallel_iteration.rb

@@ -0,0 +1,143 @@
+module Actor
+  module TestFixtures
+    class ParallelIteration
+      include TestBench::Fixture
+
+      attr_writer :iteration_count
+      attr_reader :iteration_proc
+      attr_writer :setup_proc
+      attr_writer :setup_thread_proc
+      attr_writer :teardown_proc
+      attr_accessor :test_proc
+      attr_reader :prose
+      attr_writer :thread_count
+
+      def initialize iteration_proc, prose
+        @iteration_proc = iteration_proc
+        @prose = prose
+      end
+
+      def self.build prose, each_iteration:, test: nil, setup: nil, setup_thread: nil, teardown: nil, iterations: nil, threads: nil
+        instance = new each_iteration, prose
+        instance.iteration_count = iterations
+        instance.setup_proc = setup
+        instance.setup_thread_proc = setup_thread
+        instance.teardown_proc = teardown
+        instance.test_proc = test
+        instance.thread_count = threads
+        instance
+      end
+
+      def self.call *arguments
+        instance = build *arguments
+        instance.()
+      end
+
+      def call
+        instance_exec &setup_proc
+
+        threads = thread_count.times.map do |index|
+          thread = Thread.new do
+            Thread.stop
+
+            instance_exec &setup_thread_proc
+
+            iteration_count.times do
+              instance_exec &iteration_proc
+            end
+
+            prose = "#{self.prose} (Thread: #{index + 1}/#{thread_count})"
+
+            if test_proc
+              test prose do
+                instance_exec &test_proc
+              end
+            else
+              context prose
+            end
+          end
+          thread.abort_on_exception = true
+          thread
+        end
+
+        Thread.pass until threads.all? &:stop?
+
+        context "Started #{thread_count} threads; each will iterate #{iteration_count} times"
+
+        t0 = Time.now
+
+        threads.each &:wakeup
+        threads.each &:join
+
+        t1 = Time.now
+
+        elapsed_time = t1 - t0
+
+        total_iterations = thread_count * iteration_count
+
+        iterations_per_second = Rational total_iterations, elapsed_time
+
+        context "Finished %i iterations across %i threads in %.2fs; %.2f iterations per second" %
+          [total_iterations, thread_count, elapsed_time, iterations_per_second]
+
+        return iteration_count, thread_count
+
+      ensure
+        instance_exec &teardown_proc
+      end
+
+      def iteration_count
+        @iteration_count ||= Defaults.iteration_count
+      end
+
+      def print_debug receiver
+        str = receiver.inspect
+        str << "\n"
+
+        $stdout.write str
+      end
+
+      def setup_proc
+        @setup_proc ||= proc {}
+      end
+
+      def setup_thread_proc
+        @setup_thread_proc ||= proc {}
+      end
+
+      def teardown_proc
+        @teardown_proc ||= proc {}
+      end
+
+      def thread
+        Thread.current
+      end
+
+      def thread_count
+        @thread_count ||= Defaults.thread_count
+      end
+
+      module Defaults
+        def self.iteration_count
+          if ENV['STRESS_TEST'] == 'high'
+            10_000
+          elsif ENV['STRESS_TEST'] == 'low'
+            2_500
+          else
+            100
+          end
+        end
+
+        def self.thread_count
+          if ENV['STRESS_TEST'] == 'high'
+            100
+          elsif ENV['STRESS_TEST'] == 'low'
+            25
+          else
+            2
+          end
+        end
+      end
+    end
+  end
+end

data/lib/actor/test_fixtures/sample_actor_status.rb

@@ -0,0 +1,45 @@
+module Actor
+  module TestFixtures
+    class SampleActorStatus
+      include TestBench::Fixture
+
+      attr_reader :reader
+      attr_reader :reply_address
+      attr_reader :writer
+
+      def initialize writer, reply_address, reader
+        @reader = reader
+        @reply_address = reply_address
+        @writer = writer
+      end
+
+      def self.call prose, address:, test:
+        reply_address = Messaging::Address.get
+        reader = Messaging::Reader.build reply_address
+
+        writer = Messaging::Writer.build address
+
+        instance = new writer, reply_address, reader
+        instance.(prose, &test)
+      end
+
+      def call test_prose, &block
+        writer.write record_status_message
+
+        status_0 = reader.read wait: true
+
+        writer.write record_status_message
+
+        status_1 = reader.read wait: true
+
+        test test_prose do
+          block.(status_1, status_0)
+        end
+      end
+
+      def record_status_message
+        Messaging::SystemMessage::RecordStatus.new reply_address
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: ntl-actor
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nathan Ladd
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-28 00:00:00.000000000 Z
+dependencies: []
+description: Implementation of actor pattern for ruby designed for simplicity and
+  frugality
+email: nathanladd+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/actor.rb
+- lib/actor/actor.rb
+- lib/actor/controls.rb
+- lib/actor/controls/actor.rb
+- lib/actor/controls/statistics.rb
+- lib/actor/controls/statistics/elapsed_time.rb
+- lib/actor/controls/statistics/elapsed_time/average.rb
+- lib/actor/controls/statistics/elapsed_time/maximum.rb
+- lib/actor/controls/statistics/elapsed_time/minimum.rb
+- lib/actor/controls/statistics/elapsed_time/standard_deviation.rb
+- lib/actor/controls/statistics/timer.rb
+- lib/actor/controls/time.rb
+- lib/actor/controls/time/clock.rb
+- lib/actor/messaging/address.rb
+- lib/actor/messaging/reader.rb
+- lib/actor/messaging/reader/substitute.rb
+- lib/actor/messaging/system_message.rb
+- lib/actor/messaging/writer.rb
+- lib/actor/messaging/writer/substitute.rb
+- lib/actor/queue.rb
+- lib/actor/queue/assertions.rb
+- lib/actor/queue/reader.rb
+- lib/actor/statistics.rb
+- lib/actor/statistics/copy.rb
+- lib/actor/statistics/timer.rb
+- lib/actor/test_fixtures.rb
+- lib/actor/test_fixtures/parallel_iteration.rb
+- lib/actor/test_fixtures/sample_actor_status.rb
+homepage: https://github.com/ntl/actor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Implementation of actor pattern for ruby
+test_files: []