standard-procedure-plumbing 0.3.2 → 0.4.0

data/spec/plumbing/actor_spec.rb

@@ -0,0 +1,208 @@
+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
+  # 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 commands and queries 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.await).to eq 100
+    expect(@step_counter.step_value.await).to eq 10
+    @step_counter.slowly_increment
+    expect(@step_counter.count.await).to eq 110
+  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.await).to eq "inline counter"
+      expect(@counter.count.await).to eq 100
+      expect(Time.now - @time).to be < 0.1
+
+      expect(@counter.slow_query.await).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.await).to eq 101
+      expect(Time.now - @time).to be > 0.1
+    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.await).to eq "async counter"
+        expect(@counter.count.await).to eq 100
+        expect(Time.now - @time).to be < 0.1
+
+        expect(@counter.slow_query.await).to eq 100
+        expect(Time.now - @time).to be > 0.1
+      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
+      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.await }
+        expect(Time.now - @time).to be > 0.1
+      end
+
+      it "re-raises exceptions when checking the result" do
+        @counter = Counter.start "failure"
+
+        expect { @counter.raises_error.await }.to raise_error "I'm an error"
+      end
+
+      it "does not raise exceptions if ignoring the result" do
+        @counter = Counter.start "failure"
+
+        expect { @counter.raises_error }.not_to raise_error
+      end
+    end
+  end
+
+  context "threaded" do
+    around :example do |example|
+      Plumbing.configure mode: :threaded, &example
+    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
+
+    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
+    # 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).await
+
+      expect(@object_id).to_not eq @record.object_id
+    end
+
+    it "packs and unpacks results when sending them across threads" do
+      @actor = Actor.start
+      @record = Record.new "999"
+
+      @object = @actor.get_object(@record).await
+
+      expect(@object.id).to eq @record.id
+      expect(@object.object_id).to_not eq @record.object_id
+    end
+  end
+end

data/spec/plumbing/pipe_spec.rb

@@ -20,4 +20,12 @@ RSpec.describe Plumbing::Pipe do
 
     it_behaves_like "a pipe"
   end
+
+  context "threaded" do
+    around :example do |example|
+      Plumbing.configure mode: :threaded, &example
+    end
+
+    it_behaves_like "a pipe"
+  end
 end

data/spec/plumbing/rubber_duck_spec.rb

@@ -5,72 +5,70 @@ RSpec.describe Plumbing::RubberDuck do
   class Duck
     def quack = "Quack"
 
-    def swim place
-      "Swim in #{place}"
-    end
+    def swim(place) = "Swim in #{place}"
 
-    def fly &block
-      "Fly #{block.call}"
-    end
+    def fly(&block) = "Fly #{block.call}"
   end
   # standard:enable Lint/ConstantDefinitionInBlock
 
-  it "verifies that an object matches the RubberDuck type" do
-    @duck_type = described_class.define :quack, :swim, :fly
-    @duck = Duck.new
+  context "defining rubber ducks" do
+    it "verifies that an object matches the RubberDuck type" do
+      @duck_type = described_class.define :quack, :swim, :fly
+      @duck = Duck.new
 
-    expect(@duck_type.verify(@duck)).to eq @duck
-  end
+      expect(@duck_type.verify(@duck)).to eq @duck
+    end
 
-  it "casts the object to a duck type" do
-    @duck_type = described_class.define :quack, :swim, :fly
-    @duck = Duck.new
+    it "casts the object to a duck type" do
+      @duck_type = described_class.define :quack, :swim, :fly
+      @duck = Duck.new
 
-    @proxy = @duck.as @duck_type
+      @proxy = @duck.as @duck_type
 
-    expect(@proxy).to be_kind_of Plumbing::RubberDuck::Proxy
-    expect(@proxy).to respond_to :quack
-    expect(@proxy.quack).to eq "Quack"
-    expect(@proxy).to respond_to :swim
-    expect(@proxy.swim("the river")).to eq "Swim in the river"
-    expect(@proxy).to respond_to :fly
-    expect(@proxy.fly { "ducky fly" }).to eq "Fly ducky fly"
-  end
+      expect(@proxy).to be_kind_of Plumbing::RubberDuck::Proxy
+      expect(@proxy).to respond_to :quack
+      expect(@proxy.quack).to eq "Quack"
+      expect(@proxy).to respond_to :swim
+      expect(@proxy.swim("the river")).to eq "Swim in the river"
+      expect(@proxy).to respond_to :fly
+      expect(@proxy.fly { "ducky fly" }).to eq "Fly ducky fly"
+    end
 
-  it "does not forward methods that are not part of the duck type" do
-    @duck_type = described_class.define :swim, :fly
-    @duck = Duck.new
+    it "does not forward methods that are not part of the duck type" do
+      @duck_type = described_class.define :swim, :fly
+      @duck = Duck.new
 
-    @proxy = @duck.as @duck_type
+      @proxy = @duck.as @duck_type
 
-    expect(@proxy).to_not respond_to :quack
-  end
+      expect(@proxy).to_not respond_to :quack
+    end
 
-  it "does not wrap rubber ducks in a proxy" do
-    @duck_type = described_class.define :swim, :fly
-    @duck = Duck.new
+    it "does not wrap rubber ducks in a proxy" do
+      @duck_type = described_class.define :swim, :fly
+      @duck = Duck.new
 
-    @proxy = @duck.as @duck_type
+      @proxy = @duck.as @duck_type
 
-    expect(@proxy.as(@duck_type)).to eq @proxy
-  end
+      expect(@proxy.as(@duck_type)).to eq @proxy
+    end
 
-  it "allows rubber ducks to be expanded and cast to other types" do
-    @quackers = described_class.define :quack
-    @swimming_bird = described_class.define :swim, :fly
-    @duck = Duck.new
+    it "allows rubber ducks to be expanded and cast to other types" do
+      @quackers = described_class.define :quack
+      @swimming_bird = described_class.define :swim, :fly
+      @duck = Duck.new
 
-    @swimmer = @duck.as @swimming_bird
-    @quacker = @swimmer.as @quackers
+      @swimmer = @duck.as @swimming_bird
+      @quacker = @swimmer.as @quackers
 
-    expect(@swimmer).to respond_to :swim
-    expect(@quacker).to respond_to :quack
-  end
+      expect(@swimmer).to respond_to :swim
+      expect(@quacker).to respond_to :quack
+    end
 
-  it "raises a TypeError if the class responds to the given methods" do
-    cow_type = described_class.define :moo, :chew
-    duck = Duck.new
+    it "raises a TypeError if the object does not respond to the given methods" do
+      @cow_type = described_class.define :moo, :chew
+      @duck = Duck.new
 
-    expect { cow_type.verify(duck) }.to raise_error(TypeError)
+      expect { @cow_type.verify(@duck) }.to raise_error(TypeError)
+    end
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: standard-procedure-plumbing
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Rahoul Baruah
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-13 00:00:00.000000000 Z
-dependencies: []
+date: 2024-09-15 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
@@ -31,27 +52,25 @@ files:
 - lib/plumbing/pipeline/contracts.rb
 - lib/plumbing/pipeline/operations.rb
 - lib/plumbing/rubber_duck.rb
+- lib/plumbing/rubber_duck/module.rb
 - 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/version.rb
 - spec/become_equal_to_matcher.rb
+- spec/examples/actor_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
@@ -76,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.5.12
 signing_key:
 specification_version: 4
 summary: Plumbing - various pipelines for your ruby application

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.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

data/spec/examples/valve_spec.rb

@@ -1,88 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "Valve examples" do
-  # standard:disable Lint/ConstantDefinitionInBlock
-  class Employee
-    include Plumbing::Valve
-    query :name, :job_title, :greet_slowly
-    command :promote
-
-    def initialize(name)
-      @name = name
-      @job_title = "Sales assistant"
-    end
-
-    attr_reader :name, :job_title
-
-    def promote
-      sleep 0.5
-      @job_title = "Sales manager"
-    end
-
-    def greet_slowly
-      sleep 0.2
-      "H E L L O"
-    end
-  end
-  # standard:enable Lint/ConstantDefinitionInBlock
-
-  context "inline" do
-    it "queries an object" do
-      Plumbing.configure mode: :inline do
-        @person = Employee.start "Alice"
-
-        expect(@person.name).to eq "Alice"
-        expect(@person.job_title).to eq "Sales assistant"
-
-        @time = Time.now
-        expect(@person.greet_slowly).to eq "H E L L O"
-        expect(Time.now - @time).to be > 0.1
-
-        @time = Time.now
-        expect(@person.greet_slowly(ignore_result: true)).to be_nil
-        expect(Time.now - @time).to be > 0.1
-      end
-    end
-
-    it "commands an object" do
-      Plumbing.configure mode: :inline do
-        @person = Employee.start "Alice"
-
-        @person.promote
-
-        expect(@person.job_title).to eq "Sales manager"
-      end
-    end
-  end
-
-  context "async" do
-    around :example do |example|
-      Plumbing.configure mode: :async do
-        Kernel::Async(&example)
-      end
-    end
-
-    it "queries an object" do
-      @person = Employee.start "Alice"
-
-      expect(@person.name).to eq "Alice"
-      expect(@person.job_title).to eq "Sales assistant"
-
-      @time = Time.now
-      expect(@person.greet_slowly).to eq "H E L L O"
-      expect(Time.now - @time).to be > 0.1
-
-      @time = Time.now
-      expect(@person.greet_slowly(ignore_result: true)).to be_nil
-      expect(Time.now - @time).to be < 0.1
-    end
-
-    it "commands an object" do
-      @person = Employee.start "Alice"
-
-      @person.promote
-
-      expect(@person.job_title).to eq "Sales manager"
-    end
-  end
-end