standard-procedure-plumbing 0.4.2 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77cd887e8bdfc09198bcf94c65b6d52014383b6691625f41e7301b52ae223adf
-  data.tar.gz: 4196496eff4bbc7b277592b22855dca3c29d87115130ca08a57796cb14436aae
+  metadata.gz: b9f1970e25364d95a6ec7ad423514cb7b58060eeb756b1a0522f54f8b2cb2b4a
+  data.tar.gz: 0e6eaa9583b24265285528f37e23d97109839fadbd7c48486fe621e22b5321a3
 SHA512:
-  metadata.gz: 8e8614ed73bb33446e89294b7c94da3f39786a3c82704ac1c5187d5310edb5756db00bdfd38128743496b4af2bd1fdbde3027850a83406efdf76d5bd5fb3cf74
-  data.tar.gz: f5b1d8f95e6a275817348a95b3761d0dcb991d2e504b87dbcf2a35f1b4a4ac0f96bc0a90a70f59113644034291dd9af83f30adcfb30965bc4c35ec3dc5996502
+  metadata.gz: 4672d2ce39d68ac74325c2c23e87e66e66eb97735d69681c115b0190203d178966283a432566164d4a5624202ec0fb2935af83ff338876b550ff542fc7ff5bdc
+  data.tar.gz: 52dfe371b1f12fab3040e3270c496403b06ee6d9331380e630dee481ef90653e939de544f77e177ed9f45378aa08a090e3f48275b66e1dcdd3442c4c9a824f15

data/lib/plumbing/actor/async.rb

@@ -26,7 +26,7 @@ module Plumbing
         nil
       end
 
-      def within_actor? = true
+      def in_context? = true
 
       def stop = nil
 

data/lib/plumbing/actor/inline.rb

@@ -18,7 +18,7 @@ module Plumbing
         nil
       end
 
-      def within_actor? = true
+      def in_context? = true
 
       def stop = nil
 

data/lib/plumbing/actor/kernel.rb

@@ -1,3 +1,5 @@
+require "timeout"
+
 module Plumbing
   module Actor
     ::Kernel.class_eval do
@@ -5,6 +7,15 @@ module Plumbing
         result = block.call
         result.respond_to?(:value) ? result.send(:value) : result
       end
+
+      def wait_for timeout = nil, &block
+        Timeout.timeout(timeout || Plumbing.config.timeout) do
+          loop do
+            break if block.call
+            sleep 0.1
+          end
+        end
+      end
     end
   end
 end

data/lib/plumbing/actor/rails.rb

@@ -5,8 +5,8 @@ module Plumbing
     class Rails < Threaded
       protected
 
-      def future(&)
-        Concurrent::Promises.future do
+      def in_context(&)
+        super do
           Rails.application.executor.wrap(&)
         end
       end

data/lib/plumbing/actor/threaded.rb

@@ -1,5 +1,6 @@
 require "concurrent/array"
 require "concurrent/mvar"
+require "concurrent/scheduled_task"
 require "concurrent/immutable_struct"
 require "concurrent/promises"
 require_relative "transporter"
@@ -17,11 +18,10 @@ module Plumbing
 
       # Send the message to the target and wrap the result
       def send_message(message_name, *args, **params, &block)
-        Message.new(@target, message_name, Plumbing::Actor.transporter.marshal(*args, **params), block, Concurrent::MVar.new).tap do |message|
-          @mutex.synchronize do
-            @queue << message
-            send_messages if @queue.any?
-          end
+        puts "->#{@target.class}##{message_name}(#{args.inspect}, #{params.inspect})\n#{Thread.current.name}" if Plumbing.config.debug
+        Message.new(@target, message_name, Plumbing::Actor.transporter.marshal(*args), Plumbing::Actor.transporter.marshal(params).first, block, Concurrent::MVar.new).tap do |message|
+          @queue << message
+          send_messages
         end
       end
 
@@ -30,34 +30,41 @@ module Plumbing
         nil
       end
 
-      def within_actor? = @mutex.owned?
+      def in_context? = @mutex.owned?
 
-      def stop
-        within_actor? ? @queue.clear : @mutex.synchronize { @queue.clear }
-      end
+      def stop = @queue.clear
 
       protected
 
-      def future(&) = Concurrent::Promises.future(&)
+      def in_actor_thread &block
+        Concurrent::ScheduledTask.execute(0.1) do
+          @mutex.synchronize(&block)
+        end
+      end
 
       private
 
       def send_messages
-        future do
-          @mutex.synchronize do
-            message = @queue.shift
-            message&.call
-          end
+        in_context? ? dispatch_messages : in_actor_thread { dispatch_messages }
+      end
+
+      def dispatch_messages
+        while (message = @queue.shift)
+          message.call
         end
       end
 
-      class Message < Concurrent::ImmutableStruct.new(:target, :message_name, :packed_args, :unsafe_block, :result)
+      class Message < Concurrent::ImmutableStruct.new(:target, :message_name, :packed_args, :packed_params, :unsafe_block, :result)
         def call
           args = Plumbing::Actor.transporter.unmarshal(*packed_args)
-          value = target.send message_name, *args, &unsafe_block
+          params = Plumbing::Actor.transporter.unmarshal(packed_params)
+          puts "=> #{target.class}##{message_name}(#{args.first.inspect}, #{params.first.inspect}, &#{!unsafe_block.nil?})\n#{Thread.current.name}" if Plumbing.config.debug
+          value = target.send message_name, *args, **params.first, &unsafe_block
 
           result.put Plumbing::Actor.transporter.marshal(value)
         rescue => ex
+          puts ex
+          puts ex.backtrace
           result.put ex
         end
 

data/lib/plumbing/actor.rb

@@ -8,7 +8,7 @@ module Plumbing
       nil
     end
 
-    def within_actor? = proxy.within_actor?
+    def in_context? = proxy.in_context?
 
     def stop = proxy.stop
 

data/lib/plumbing/config.rb

@@ -1,6 +1,6 @@
 # Pipes, pipelines, actors and rubber ducks
 module Plumbing
-  Config = Data.define :mode, :actor_proxy_classes, :timeout do
+  Config = Data.define :mode, :actor_proxy_classes, :timeout, :debug do
     def actor_proxy_class_for target_class
       actor_proxy_classes[target_class]
     end
@@ -45,7 +45,7 @@ module Plumbing
   private_class_method :set_configuration_and_yield
 
   def self.configs
-    @configs ||= [Config.new(mode: :inline, timeout: 30, actor_proxy_classes: {})]
+    @configs ||= [Config.new(mode: :inline, timeout: 30, actor_proxy_classes: {}, debug: false)]
   end
   private_class_method :configs
 end

data/{spec → lib/plumbing/spec}/become_equal_to_matcher.rb

@@ -9,15 +9,12 @@ require "rspec/expectations"
 #
 RSpec::Matchers.define :become_equal_to do
   match do |expected|
-    max = Plumbing.config.timeout * 10
-    counter = 0
-    matched = false
-    while (counter < max) && (matched == false)
-      sleep 0.1
-      counter += 1
-      matched = true if (@result = block_arg.call) == expected
+    wait_for do
+      block_arg.call == expected
     end
-    matched
+    true
+  rescue Timeout::Error
+    false
   end
 
   failure_message do |expected|

data/lib/plumbing/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Plumbing
-  VERSION = "0.4.2"
+  VERSION = "0.4.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standard-procedure-plumbing
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.4
 platform: ruby
 authors:
 - Rahoul Baruah
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-17 00:00:00.000000000 Z
+date: 2024-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: globalid
@@ -55,25 +55,9 @@ files:
 - lib/plumbing/rubber_duck/module.rb
 - lib/plumbing/rubber_duck/object.rb
 - lib/plumbing/rubber_duck/proxy.rb
+- lib/plumbing/spec/become_equal_to_matcher.rb
 - lib/plumbing/types.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/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_spec.rb
-- spec/spec_helper.rb
 homepage: https://github.com/standard-procedure/plumbing
 licenses: []
 metadata:

data/spec/examples/actor_spec.rb

@@ -1,86 +0,0 @@
-require "spec_helper"
-require "plumbing/actor/async"
-require "plumbing/actor/threaded"
-
-RSpec.shared_examples "an example actor" do |runs_in_background|
-  # standard:disable Lint/ConstantDefinitionInBlock
-  class Employee
-    include Plumbing::Actor
-    async :name, :job_title, :greet_slowly, :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
-
-  it "queries an object" do
-    @person = Employee.start "Alice"
-
-    expect(await { @person.name }).to eq "Alice"
-    expect(await { @person.job_title }).to eq "Sales assistant"
-
-    @time = Time.now
-    # `greet_slowly` is a query so will block until a response is received
-    expect(await { @person.greet_slowly }).to eq "H E L L O"
-    expect(Time.now - @time).to be > 0.1
-
-    @time = Time.now
-    # we're not awaiting the result, so this should run in the background (unless we're using inline mode)
-    @person.greet_slowly
-
-    expect(Time.now - @time).to be < 0.1 if runs_in_background
-    expect(Time.now - @time).to be > 0.1 if !runs_in_background
-  ensure
-    @person.stop
-  end
-
-  it "commands an object" do
-    @person = Employee.start "Alice"
-    @person.promote
-    expect(@person.job_title.value).to eq "Sales manager"
-  ensure
-    @person.stop
-  end
-end
-
-RSpec.describe "Actor example: " do
-  context "inline mode" do
-    around :example do |example|
-      Plumbing.configure mode: :inline, &example
-    end
-
-    it_behaves_like "an example actor", false
-  end
-
-  context "async mode" do
-    around :example do |example|
-      Plumbing.configure mode: :async do
-        Kernel::Async(&example)
-      end
-    end
-
-    it_behaves_like "an example actor", true
-  end
-
-  context "threaded mode" do
-    around :example do |example|
-      Plumbing.configure mode: :threaded, &example
-    end
-
-    it_behaves_like "an example actor", true
-  end
-end

data/spec/examples/await_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-require "plumbing/actor/async"
-require "plumbing/actor/threaded"
-
-RSpec.describe "await" do
-  # standard:disable Lint/ConstantDefinitionInBlock
-  class Person
-    include Plumbing::Actor
-    async :name
-    def initialize name
-      @name = name
-    end
-    attr_reader :name
-  end
-  # standard:enable Lint/ConstantDefinitionInBlock
-
-  [:inline, :async, :threaded].each do |mode|
-    context "#{mode} mode" do
-      around :example do |example|
-        Sync do
-          Plumbing.configure mode: mode, &example
-        end
-      end
-
-      it "awaits a result from the actor directly" do
-        @person = Person.start "Alice"
-
-        expect(@person.name.value).to eq "Alice"
-      end
-
-      it "uses a block to await the result from the actor" do
-        @person = Person.start "Alice"
-
-        expect(await { @person.name }).to eq "Alice"
-      end
-
-      it "uses a block to immediately access non-actor objects" do
-        @person = "Bob"
-        expect(await { @person }).to eq "Bob"
-      end
-    end
-  end
-end

data/spec/examples/pipe_spec.rb

@@ -1,145 +0,0 @@
-require "spec_helper"
-require "async"
-require "plumbing/actor/async"
-require "plumbing/actor/threaded"
-
-RSpec.describe "Pipe examples" do
-  it "observes events" do
-    @source = Plumbing::Pipe.start
-
-    @result = []
-    @source.add_observer do |event|
-      @result << event.type
-    end
-
-    @source.notify "something_happened", message: "But what was it?"
-    expect(@result).to eq ["something_happened"]
-  end
-
-  it "filters events" do
-    @source = Plumbing::Pipe.start
-
-    @filter = Plumbing::Filter.start source: @source do |event|
-      %w[important urgent].include? event.type
-    end
-
-    @result = []
-    @filter.add_observer do |event|
-      @result << event.type
-    end
-
-    @source.notify "important", message: "ALERT! ALERT!"
-    expect(@result).to eq ["important"]
-
-    @source.notify "unimportant", message: "Nothing to see here"
-    expect(@result).to eq ["important"]
-  end
-
-  it "allows for custom filters" do
-    # standard:disable Lint/ConstantDefinitionInBlock
-    class EveryThirdEvent < Plumbing::CustomFilter
-      def initialize source:
-        super
-        @events = []
-      end
-
-      def received event
-        safely do
-          @events << event
-          if @events.count >= 3
-            @events.clear
-            self << event
-          end
-        end
-      end
-    end
-    # standard:enable Lint/ConstantDefinitionInBlock
-
-    @source = Plumbing::Pipe.start
-    @filter = EveryThirdEvent.start(source: @source)
-
-    @result = []
-    @filter.add_observer do |event|
-      @result << event.type
-    end
-
-    1.upto 10 do |i|
-      @source.notify i.to_s
-    end
-
-    expect(@result).to eq ["3", "6", "9"]
-  end
-
-  it "joins multiple source pipes" do
-    @first_source = Plumbing::Pipe.start
-    @second_source = Plumbing::Pipe.start
-
-    @junction = Plumbing::Junction.start @first_source, @second_source
-
-    @result = []
-    @junction.add_observer do |event|
-      @result << event.type
-    end
-
-    @first_source.notify "one"
-    expect(@result).to eq ["one"]
-    @second_source.notify "two"
-    expect(@result).to eq ["one", "two"]
-  end
-
-  it "dispatches events asynchronously using async" do
-    Plumbing.configure mode: :async do
-      Sync do
-        @first_source = Plumbing::Pipe.start
-        @second_source = Plumbing::Pipe.start
-        @junction = Plumbing::Junction.start @first_source, @second_source
-        @filter = Plumbing::Filter.start source: @junction do |event|
-          %w[one-one two-two].include? event.type
-        end
-        @result = []
-        @filter.add_observer do |event|
-          @result << event.type
-        end
-
-        @first_source.notify "one-one"
-        @first_source.notify "one-two"
-        @second_source.notify "two-one"
-        @second_source.notify "two-two"
-
-        expect(["one-one", "two-two"]).to become_equal_to { @result }
-      end
-    end
-  end
-
-  it "dispatches events asynchronously using threads" do
-    Plumbing.configure mode: :threaded do
-      @result = []
-
-      @first_source = Plumbing::Pipe.start
-      @second_source = Plumbing::Pipe.start
-      @junction = Plumbing::Junction.start @first_source, @second_source
-
-      @filter = Plumbing::Filter.start source: @junction do |event|
-        %w[one-one two-two].include? event.type
-      end
-      await do
-        @filter.add_observer do |event|
-          puts "observing #{event.type}"
-          @result << event.type
-        end
-      end
-
-      @first_source.notify "one-one"
-      @first_source.notify "one-two"
-      @second_source.notify "two-one"
-      @second_source.notify "two-two"
-
-      expect(["one-one", "two-two"]).to become_equal_to { @result.sort }
-    ensure
-      @first_source.shutdown
-      @second_source.shutdown
-      @junction.shutdown
-      @filter.shutdown
-    end
-  end
-end

data/spec/examples/pipeline_spec.rb

@@ -1,89 +0,0 @@
-require "spec_helper"
-require "dry/validation"
-
-RSpec.describe "Pipeline examples" do
-  it "builds a simple pipeline of operations adding to an array with pre-conditions and post-conditions" do
-    # standard:disable Lint/ConstantDefinitionInBlock
-    class BuildArray < Plumbing::Pipeline
-      perform :add_first
-      perform :add_second
-      perform :add_third
-
-      pre_condition :must_be_an_array do |input|
-        input.is_a? Array
-      end
-
-      post_condition :must_have_three_elements do |output|
-        output.length == 3
-      end
-
-      private
-
-      def add_first(input) = input << "first"
-
-      def add_second(input) = input << "second"
-
-      def add_third(input) = input << "third"
-    end
-    # standard:enable Lint/ConstantDefinitionInBlock
-
-    expect(BuildArray.new.call([])).to eq ["first", "second", "third"]
-    expect { BuildArray.new.call(1) }.to raise_error(Plumbing::PreConditionError)
-    expect { BuildArray.new.call(["extra element"]) }.to raise_error(Plumbing::PostConditionError)
-  end
-
-  it "builds a simple pipeline of operations using an external class to implement one of the steps" do
-    # standard:disable Lint/ConstantDefinitionInBlock
-    class ExternalStep < Plumbing::Pipeline
-      perform :add_item_to_array
-
-      private
-
-      def add_item_to_array(input) = input << "external"
-    end
-
-    class BuildSequenceWithExternalStep < Plumbing::Pipeline
-      perform :add_first
-      perform :add_second, using: "ExternalStep"
-      perform :add_third
-
-      private
-
-      def add_first(input) = input << "first"
-
-      def add_third(input) = input << "third"
-    end
-    # standard:enable Lint/ConstantDefinitionInBlock
-
-    expect(BuildSequenceWithExternalStep.new.call([])).to eq ["first", "external", "third"]
-  end
-
-  it "uses a dry-validation contract to test the input parameters" do
-    # standard:disable Lint/ConstantDefinitionInBlock
-    class SayHello < Plumbing::Pipeline
-      validate_with "SayHello::Input"
-      perform :say_hello
-
-      private
-
-      def say_hello input
-        "Hello #{input[:name]} - I will now send a load of annoying marketing messages to #{input[:email]}"
-      end
-
-      class Input < Dry::Validation::Contract
-        params do
-          required(:name).filled(:string)
-          required(:email).filled(:string)
-        end
-        rule :email do
-          key.failure("must be a valid email") unless /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z\d\-]+)*\.[a-z]+\z/i.match? value
-        end
-      end
-    end
-    # standard:enable Lint/ConstantDefinitionInBlock
-
-    SayHello.new.call(name: "Alice", email: "alice@example.com")
-
-    expect { SayHello.new.call(some: "other data") }.to raise_error(Plumbing::PreConditionError)
-  end
-end