standard-procedure-plumbing 0.3.3 → 0.4.1

data/spec/plumbing/actor_spec.rb

@@ -0,0 +1,310 @@
+require "spec_helper"
+
+require_relative "../../lib/plumbing/actor/async"
+require_relative "../../lib/plumbing/actor/threaded"
+require_relative "../../lib/plumbing/actor/rails"
+
+RSpec.describe Plumbing::Actor do
+  # standard:disable Lint/ConstantDefinitionInBlock
+  class Counter
+    include Plumbing::Actor
+    async :name, :count, :slow_query, "slowly_increment", "raises_error"
+    attr_reader :name, :count
+
+    def initialize name, initial_value: 0
+      @name = name
+      @count = initial_value
+    end
+
+    protected
+
+    def slowly_increment
+      sleep 0.2
+      @count += 1
+    end
+
+    def slow_query
+      sleep 0.2
+      @count
+    end
+
+    def raises_error = raise "I'm an error"
+  end
+
+  class StepCounter < Counter
+    async :step_value
+    attr_reader :step_value
+
+    def initialize name, initial_value: 0, step_value: 5
+      super(name, initial_value: initial_value)
+      @step_value = step_value
+    end
+
+    protected
+
+    def slowly_increment
+      sleep 0.2
+      @count += @step_value
+    end
+
+    def failing_query
+      raise "I'm a failure"
+    end
+  end
+
+  class WhoAmI
+    include Plumbing::Actor
+    async :me_as_actor, :me_as_self
+
+    private
+
+    def me_as_actor = as_actor
+
+    def me_as_self = self
+
+    def prepare = @calling_thread = Thread.current
+
+    def check = @calling_thread == Thread.current
+  end
+
+  class Actor
+    include Plumbing::Actor
+    async :get_object_id, :get_object
+
+    private def get_object_id(record) = record.object_id
+    private def get_object(record) = record
+  end
+
+  class SafetyCheck
+    include Plumbing::Actor
+    async :called_from_actor_thread?
+
+    def initialize tester
+      @tester = tester
+      @called_from_actor_thread = false
+      configure_safety_check
+    end
+
+    private
+
+    def called_from_actor_thread? = @called_from_actor_thread
+
+    def configure_safety_check
+      @tester.on_safety_check do
+        safely do
+          @called_from_actor_thread = proxy.within_actor?
+        end
+      end
+    end
+  end
+
+  class Tester
+    include Plumbing::Actor
+    async :on_safety_check, :do_safety_check
+
+    def initialize
+      @on_safety_check = nil
+    end
+
+    private
+
+    def on_safety_check(&block) = @on_safety_check = block
+
+    def do_safety_check = @on_safety_check&.call
+  end
+  # standard:enable Lint/ConstantDefinitionInBlock
+
+  it "knows which async messages are understood" do
+    expect(Counter.async_messages).to eq [:name, :count, :slow_query, :slowly_increment, :raises_error]
+  end
+
+  it "reuses existing proxy classes" do
+    @counter = Counter.start "inline counter", initial_value: 100
+    @proxy_class = @counter.class
+
+    @counter = Counter.start "another inline counter", initial_value: 200
+    expect(@counter.class).to eq @proxy_class
+  end
+
+  it "includes async messages from the superclass" do
+    expect(StepCounter.async_messages).to eq [:name, :count, :slow_query, :slowly_increment, :raises_error, :step_value]
+
+    @step_counter = StepCounter.start "step counter", initial_value: 100, step_value: 10
+
+    expect(@step_counter.count.value).to eq 100
+    expect(@step_counter.step_value.value).to eq 10
+    @step_counter.slowly_increment
+    expect(@step_counter.count.value).to eq 110
+  end
+
+  it "can access its own proxy" do
+    @actor = WhoAmI.start
+
+    expect(await { @actor.me_as_self }).to_not eq @actor
+    expect(await { @actor.me_as_actor }).to eq @actor
+  end
+
+  context "inline" do
+    around :example do |example|
+      Plumbing.configure mode: :inline, &example
+    end
+
+    it "returns the result from a message immediately" do
+      @counter = Counter.start "inline counter", initial_value: 100
+      @time = Time.now
+
+      expect(@counter.name.value).to eq "inline counter"
+      expect(@counter.count.value).to eq 100
+      expect(Time.now - @time).to be < 0.1
+
+      expect(@counter.slow_query.value).to eq 100
+      expect(Time.now - @time).to be > 0.1
+    end
+
+    it "sends all commands immediately" do
+      @counter = Counter.start "inline counter", initial_value: 100
+      @time = Time.now
+
+      @counter.slowly_increment
+
+      expect(@counter.count.value).to eq 101
+      expect(Time.now - @time).to be > 0.1
+    end
+
+    it "can safely access its own data" do
+      @tester = Tester.start
+      @safety_check = SafetyCheck.start @tester
+
+      @tester.do_safety_check
+
+      expect(true).to become_equal_to { @safety_check.called_from_actor_thread?.value }
+    end
+  end
+
+  [:threaded, :async].each do |mode|
+    context mode.to_s do
+      around :example do |example|
+        Sync do
+          Plumbing.configure mode: mode, &example
+        end
+      end
+
+      it "performs queries in the background and waits for the response" do
+        @counter = Counter.start "async counter", initial_value: 100
+        @time = Time.now
+
+        expect(@counter.name.value).to eq "async counter"
+        expect(@counter.count.value).to eq 100
+        expect(Time.now - @time).to be < 0.1
+
+        expect(@counter.slow_query.value).to eq 100
+        expect(Time.now - @time).to be > 0.1
+      ensure
+        @counter.stop
+      end
+
+      it "performs queries ignoring the response and returning immediately" do
+        @counter = Counter.start "threaded counter", initial_value: 100
+        @time = Time.now
+
+        @counter.slow_query
+
+        expect(Time.now - @time).to be < 0.1
+      ensure
+        @counter.stop
+      end
+
+      it "performs commands in the background and returning immediately" do
+        @counter = Counter.start "threaded counter", initial_value: 100
+        @time = Time.now
+
+        @counter.slowly_increment
+        expect(Time.now - @time).to be < 0.1
+
+        # wait for the background task to complete
+        expect(101).to become_equal_to { @counter.count.value }
+        expect(Time.now - @time).to be > 0.1
+      ensure
+        @counter.stop
+      end
+
+      it "re-raises exceptions when checking the result" do
+        @counter = Counter.start "failure"
+
+        expect { @counter.raises_error.value }.to raise_error "I'm an error"
+      ensure
+        @counter.stop
+      end
+
+      it "does not raise exceptions if ignoring the result" do
+        @counter = Counter.start "failure"
+
+        expect { @counter.raises_error }.not_to raise_error
+      ensure
+        @counter.stop
+      end
+    end
+  end
+
+  context "threaded" do
+    around :example do |example|
+      Plumbing.configure mode: :threaded, &example
+    end
+
+    before do
+      GlobalID.app = "rspec"
+      GlobalID::Locator.use :rspec do |gid, options|
+        Record.new gid.model_id
+      end
+    end
+
+    # standard:disable Lint/ConstantDefinitionInBlock
+    class Record
+      include GlobalID::Identification
+      attr_reader :id
+      def initialize id
+        @id = id
+      end
+
+      def == other
+        other.id == @id
+      end
+    end
+    # standard:enable Lint/ConstantDefinitionInBlock
+
+    it "packs and unpacks arguments when sending them across threads" do
+      @actor = Actor.start
+      @record = Record.new "999"
+
+      @object_id = @actor.get_object_id(@record).value
+
+      expect(@object_id).to_not eq @record.object_id
+    ensure
+      @actor.stop
+    end
+
+    it "packs and unpacks results when sending them across threads" do
+      @actor = Actor.start
+      @record = Record.new "999"
+
+      @object = @actor.get_object(@record).value
+
+      expect(@object.id).to eq @record.id
+      expect(@object.object_id).to_not eq @record.object_id
+    ensure
+      @actor.stop
+    end
+
+    it "can safely access its own data" do
+      @tester = Tester.start
+      @safety_check = SafetyCheck.start @tester
+
+      @tester.do_safety_check
+
+      expect(true).to become_equal_to { @safety_check.called_from_actor_thread?.value }
+    ensure
+      @tester.stop
+      @safety_check.stop
+    end
+  end
+end

data/spec/plumbing/custom_filter_spec.rb

@@ -15,7 +15,7 @@ RSpec.describe Plumbing::CustomFilter do
     # standard:enable Lint/ConstantDefinitionInBlock
 
     @pipe = Plumbing::Pipe.start
-    @filter = ReversingFilter.new(source: @pipe)
+    @filter = ReversingFilter.start(source: @pipe)
     @result = []
     @filter.add_observer do |event|
       @result << event.type

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: standard-procedure-plumbing
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.1
 platform: ruby
 authors:
 - Rahoul Baruah
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-14 00:00:00.000000000 Z
-dependencies: []
+date: 2024-09-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: globalid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A composable event pipeline and sequential pipelines of operations
 email:
 - rahoulb@echodek.co
@@ -20,6 +34,13 @@ files:
 - README.md
 - Rakefile
 - lib/plumbing.rb
+- lib/plumbing/actor.rb
+- lib/plumbing/actor/async.rb
+- lib/plumbing/actor/inline.rb
+- lib/plumbing/actor/kernel.rb
+- lib/plumbing/actor/rails.rb
+- lib/plumbing/actor/threaded.rb
+- lib/plumbing/actor/transporter.rb
 - lib/plumbing/config.rb
 - lib/plumbing/custom_filter.rb
 - lib/plumbing/error.rb
@@ -35,26 +56,22 @@ files:
 - lib/plumbing/rubber_duck/object.rb
 - lib/plumbing/rubber_duck/proxy.rb
 - lib/plumbing/types.rb
-- lib/plumbing/valve.rb
-- lib/plumbing/valve/async.rb
-- lib/plumbing/valve/inline.rb
-- lib/plumbing/valve/message.rb
-- lib/plumbing/valve/rails.rb
-- lib/plumbing/valve/threaded.rb
 - lib/plumbing/version.rb
 - spec/become_equal_to_matcher.rb
+- spec/examples/actor_spec.rb
+- spec/examples/await_spec.rb
 - spec/examples/pipe_spec.rb
 - spec/examples/pipeline_spec.rb
 - spec/examples/rubber_duck_spec.rb
-- spec/examples/valve_spec.rb
 - spec/plumbing/a_pipe.rb
+- spec/plumbing/actor/transporter_spec.rb
+- spec/plumbing/actor_spec.rb
 - spec/plumbing/custom_filter_spec.rb
 - spec/plumbing/filter_spec.rb
 - spec/plumbing/junction_spec.rb
 - spec/plumbing/pipe_spec.rb
 - spec/plumbing/pipeline_spec.rb
 - spec/plumbing/rubber_duck_spec.rb
-- spec/plumbing/valve_spec.rb
 - spec/plumbing_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/standard-procedure/plumbing

data/lib/plumbing/valve/async.rb

@@ -1,43 +0,0 @@
-require "async"
-require "async/semaphore"
-require "timeout"
-
-module Plumbing
-  module Valve
-    class Async
-      attr_reader :target
-
-      def initialize target
-        @target = target
-        @queue = []
-        @semaphore = ::Async::Semaphore.new(1)
-      end
-
-      # Ask the target to answer the given message
-      def ask(message, *args, **params, &block)
-        task = @semaphore.async do
-          @target.send message, *args, **params, &block
-        end
-        Timeout.timeout(timeout) do
-          task.wait
-        end
-      end
-
-      # Tell the target to execute the given message
-      def tell(message, *args, **params, &block)
-        @semaphore.async do |task|
-          @target.send message, *args, **params, &block
-        rescue
-          nil
-        end
-        nil
-      end
-
-      private
-
-      def timeout
-        Plumbing.config.timeout
-      end
-    end
-  end
-end

data/lib/plumbing/valve/inline.rb

@@ -1,20 +0,0 @@
-module Plumbing
-  module Valve
-    class Inline
-      def initialize target
-        @target = target
-      end
-
-      # Ask the target to answer the given message
-      def ask(message, ...)
-        @target.send(message, ...)
-      end
-
-      # Tell the target to execute the given message
-      def tell(message, ...)
-        @target.send(message, ...)
-        nil
-      end
-    end
-  end
-end

data/lib/plumbing/valve/message.rb

@@ -1,5 +0,0 @@
-module Plumbing
-  module Valve
-    Message = Struct.new :message, :args, :params, :block, :result, :status
-  end
-end

data/lib/plumbing/valve/threaded.rb

@@ -1,67 +0,0 @@
-require "concurrent/array"
-require "concurrent/mvar"
-require "concurrent/immutable_struct"
-require "concurrent/promises"
-
-module Plumbing
-  module Valve
-    class Threaded
-      attr_reader :target
-
-      def initialize target
-        @target = target
-        @queue = Concurrent::Array.new
-      end
-
-      # Ask the target to answer the given message
-      def ask(message, *, **, &)
-        add_message_to_queue(message, *, **, &).value
-      end
-
-      # Tell the target to execute the given message
-      def tell(message, *, **, &)
-        add_message_to_queue(message, *, **, &)
-        nil
-      rescue
-        nil
-      end
-
-      protected
-
-      def future(&)
-        Concurrent::Promises.future(&)
-      end
-
-      private
-
-      def send_messages
-        future do
-          while (message = @queue.shift)
-            message.call
-          end
-        end
-      end
-
-      def add_message_to_queue message_name, *args, **params, &block
-        Message.new(@target, message_name, args, params, block, Concurrent::MVar.new).tap do |message|
-          @queue << message
-          send_messages if @queue.size == 1
-        end
-      end
-
-      class Message < Concurrent::ImmutableStruct.new(:target, :name, :args, :params, :block, :result)
-        def value
-          result.take(Plumbing.config.timeout).tap do |value|
-            raise value if value.is_a? Exception
-          end
-        end
-
-        def call
-          result.put target.send(name, *args, **params, &block)
-        rescue => ex
-          result.put ex
-        end
-      end
-    end
-  end
-end

data/lib/plumbing/valve.rb

@@ -1,71 +0,0 @@
-require_relative "valve/inline"
-
-module Plumbing
-  module Valve
-    def self.included base
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # Create a new valve instance and build a proxy for it using the current mode
-      # @return [Plumbing::Valve::Base] the proxy for the valve instance
-      def start(*, **, &)
-        build_proxy_for(new(*, **, &))
-      end
-
-      # Define the queries that this valve can answer
-      # @param names [Array<Symbol>] the names of the queries
-      def query(*names) = queries.concat(names.map(&:to_sym))
-
-      # List the queries that this valve can answer
-      def queries = @queries ||= []
-
-      # Define the commands that this valve can execute
-      # @param names [Array<Symbol>] the names of the commands
-      def command(*names) = commands.concat(names.map(&:to_sym))
-
-      # List the commands that this valve can execute
-      def commands = @commands ||= []
-
-      def inherited subclass
-        subclass.commands.concat commands
-        subclass.queries.concat queries
-      end
-
-      private
-
-      def build_proxy_for(target)
-        proxy_class_for(target.class).new(target)
-      end
-
-      def proxy_class_for target_class
-        Plumbing.config.valve_proxy_class_for(target_class) || register_valve_proxy_class_for(target_class)
-      end
-
-      def proxy_base_class = const_get "Plumbing::Valve::#{Plumbing.config.mode.to_s.capitalize}"
-
-      def register_valve_proxy_class_for target_class
-        Plumbing.config.register_valve_proxy_class_for(target_class, build_proxy_class)
-      end
-
-      def build_proxy_class
-        Class.new(proxy_base_class).tap do |proxy_class|
-          queries.each do |query|
-            proxy_class.define_method query do |*args, ignore_result: false, **params, &block|
-              ignore_result ? tell(query, *args, **params, &block) : ask(query, *args, **params, &block)
-            end
-          end
-
-          commands.each do |command|
-            proxy_class.define_method command do |*args, **params, &block|
-              tell(command, *args, **params, &block)
-              nil
-            rescue
-              nil
-            end
-          end
-        end
-      end
-    end
-  end
-end