standard-procedure-plumbing 0.4.4 → 0.4.6

data/lib/plumbing/{filter.rb → pipe/filter.rb}

@@ -1,7 +1,7 @@
 require_relative "custom_filter"
 module Plumbing
   # A pipe that filters events from a source pipe
-  class Filter < CustomFilter
+  class Pipe::Filter < Pipe::CustomFilter
     # Chain this pipe to the source pipe
     # @param source [Plumbing::Observable] the source from which to receive and filter events
     # @param &accepts [Block] a block that returns a boolean value - true to accept the event, false to reject it
@@ -14,9 +14,10 @@ module Plumbing
 
     protected
 
-    def received(event)
-      return nil unless @accepts.call event
-      dispatch event
+    def received(event_name, data)
+      safely do
+        notify event_name, **data if @accepts.call(event_name, data)
+      end
     end
   end
 end

data/lib/plumbing/{junction.rb → pipe/junction.rb}

@@ -1,6 +1,6 @@
 module Plumbing
   # A pipe that filters events from a source pipe
-  class Junction < Pipe
+  class Pipe::Junction < Pipe
     # Chain multiple sources to this pipe
     # @param sources [Array<Plumbing::Observable>] the sources which will be joined and relayed
     def initialize *sources
@@ -11,9 +11,9 @@ module Plumbing
     private
 
     def add source
-      source.as(Observable).add_observer do |event|
+      source.as(Observable).add_observer do |event_name, **data|
         safely do
-          dispatch event
+          notify event_name, **data
         end
       end
     end

data/lib/plumbing/pipe.rb

@@ -3,21 +3,19 @@ module Plumbing
   class Pipe
     include Plumbing::Actor
 
-    async :notify, :<<, :remove_observer, :add_observer, :is_observer?, :shutdown
+    async :notify, :remove_observer, :add_observer, :is_observer?, :shutdown
 
-    # Push an event into the pipe
-    # @param event [Plumbing::Event] the event to push into the pipe
-    def << event
-      raise Plumbing::InvalidEvent.new event unless event.is_a? Plumbing::Event
-      dispatch event
-    end
-
-    # A shortcut to creating and then pushing an event
-    # @param event_type [String] representing the type of event this is
+    # Notify observers about an event
+    # @param event_name [String] representing the type of event this is
     # @param data [Hash] representing the event-specific data to be passed to the observers
-    def notify event_type, data = nil
-      Event.new(type: event_type, data: data).tap do |event|
-        self << event
+    def notify event_name, **data
+      Plumbing.config.logger.debug { "-> #{self.class}#notify #{event_name}" }
+      observers.each do |observer|
+        Plumbing.config.logger.debug { "===> #{self.class}#dispatch #{event_name}(#{data}) to #{observer}" }
+        observer.call event_name, data
+      rescue => ex
+        Plumbing.config.logger.error { "!!!! #{self.class}#dispatch #{event_name} => #{ex}" }
+        ex
       end
     end
 
@@ -52,23 +50,14 @@ module Plumbing
       stop
     end
 
-    protected
-
-    # Dispatch an event to all observers
-    # @param event [Plumbing::Event]
-    # Enumerates all observers and `calls` them with this event
-    # Discards any errors raised by the observer so that all observers will be successfully notified
-    def dispatch event
-      observers.each do |observer|
-        observer.call event
-      rescue => ex
-        puts ex
-        ex
-      end
-    end
+    private
 
     def observers
       @observers ||= []
     end
+
+    require_relative "pipe/filter"
+    require_relative "pipe/junction"
+
   end
 end

data/lib/plumbing/spec/become_matchers.rb

@@ -0,0 +1,121 @@
+require "rspec/expectations"
+
+# Custom matcher that repeatedly evaluates the block until it matches the expected value or the timeout has elapsed
+#
+# This allows asynchronous operations to be tested in a synchronous manner with a timeout
+#
+# Example:
+#     expect{ subject.greeting }.to become "Hello Alice"
+#
+RSpec::Matchers.define :become do |expected|
+  match do |block|
+    wait_for do
+      (@result = block.call) == expected
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+
+  def supports_block_expectations? = true
+
+  failure_message do |expected|
+    "expected #{expected} but, after timeout, the result was #{@result}"
+  end
+end
+
+# Custom matcher that repeatedly evaluates the block until it becomes true or the timeout has elapsed
+#
+# This allows asynchronous operations to be tested in a synchronous manner with a timeout
+#
+# Example:
+#     expect { @object.valid? }.to become_true
+#
+RSpec::Matchers.define :become_true do
+  match do |block|
+    wait_for do
+      block.call == true
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+
+  def supports_block_expectations? = true
+
+  failure_message do |expected|
+    "expected true but timeout expired"
+  end
+end
+
+# Custom matcher that repeatedly evaluates the block until it becomes truthy or the timeout has elapsed
+#
+# This allows asynchronous operations to be tested in a synchronous manner with a timeout
+#
+# Example:
+#     expect { @object.message }.to become_truthy
+#
+RSpec::Matchers.define :become_truthy do
+  match do |block|
+    wait_for do
+      block.call
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+
+  def supports_block_expectations? = true
+
+  failure_message do |expected|
+    "expected truthy value but timeout expired"
+  end
+end
+
+# Custom matcher that repeatedly evaluates the block until it becomes false or the timeout has elapsed
+#
+# This allows asynchronous operations to be tested in a synchronous manner with a timeout
+#
+# Example:
+#     expect { @object.in_progress? }.to become_false
+#
+RSpec::Matchers.define :become_false do
+  match do |block|
+    wait_for do
+      block.call == false
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+
+  def supports_block_expectations? = true
+
+  failure_message do |expected|
+    "expected false but timeout expired"
+  end
+end
+
+# Custom matcher that repeatedly evaluates the block until it becomes falsey or the timeout has elapsed
+#
+# This allows asynchronous operations to be tested in a synchronous manner with a timeout
+#
+# Example:
+#     expect { @object.background_task }.to become_falsey
+#
+RSpec::Matchers.define :become_falsey do
+  match do |block|
+    wait_for do
+      !block.call
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+
+  def supports_block_expectations? = true
+
+  failure_message do |expected|
+    "expected falsey but timeout expired"
+  end
+end

data/lib/plumbing/spec/modes.rb

@@ -0,0 +1,14 @@
+module Plumbing
+  module Spec
+    def self.modes(inline: true, async: true, threaded: true, &)
+      Plumbing.configure(mode: :inline, &) if inline
+      Sync { Plumbing.configure(mode: :async, &) } if async
+      Plumbing.configure(mode: thread_mode, &) if threaded
+    end
+
+    def self.thread_mode
+      defined?(::Rails) ? :threaded_rails : :threaded
+    end
+    private_class_method :thread_mode
+  end
+end

data/lib/plumbing/version.rb

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

data/lib/plumbing.rb

@@ -6,10 +6,7 @@ module Plumbing
   require_relative "plumbing/rubber_duck"
   require_relative "plumbing/types"
   require_relative "plumbing/error"
-  require_relative "plumbing/event"
   require_relative "plumbing/pipe"
-  require_relative "plumbing/filter"
-  require_relative "plumbing/junction"
   require_relative "plumbing/pipeline"
   require_relative "plumbing/version"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standard-procedure-plumbing
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.4.6
 platform: ruby
 authors:
 - Rahoul Baruah
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-09-18 00:00:00.000000000 Z
+date: 2024-09-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: globalid
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- LICENSE
 - README.md
 - Rakefile
 - lib/plumbing.rb
@@ -42,12 +43,11 @@ files:
 - lib/plumbing/actor/threaded.rb
 - lib/plumbing/actor/transporter.rb
 - lib/plumbing/config.rb
-- lib/plumbing/custom_filter.rb
 - lib/plumbing/error.rb
-- lib/plumbing/event.rb
-- lib/plumbing/filter.rb
-- lib/plumbing/junction.rb
 - lib/plumbing/pipe.rb
+- lib/plumbing/pipe/custom_filter.rb
+- lib/plumbing/pipe/filter.rb
+- lib/plumbing/pipe/junction.rb
 - lib/plumbing/pipeline.rb
 - lib/plumbing/pipeline/contracts.rb
 - lib/plumbing/pipeline/operations.rb
@@ -55,7 +55,8 @@ 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/spec/become_matchers.rb
+- lib/plumbing/spec/modes.rb
 - lib/plumbing/types.rb
 - lib/plumbing/version.rb
 homepage: https://github.com/standard-procedure/plumbing

data/lib/plumbing/event.rb

@@ -1,4 +0,0 @@
-module Plumbing
-  # An immutable data structure representing an Event
-  Event = Data.define :type, :data
-end

data/lib/plumbing/spec/become_equal_to_matcher.rb

@@ -1,23 +0,0 @@
-require "rspec/expectations"
-
-# Custom matcher that repeatedly evaluates the block until it matches the expected value or 5 seconds have elapsed
-#
-# This allows asynchronous operations to be tested in a synchronous manner with a timeout
-#
-# Example:
-#     expect("Hello").to become_equal_to { subject.greeting }
-#
-RSpec::Matchers.define :become_equal_to do
-  match do |expected|
-    wait_for do
-      block_arg.call == expected
-    end
-    true
-  rescue Timeout::Error
-    false
-  end
-
-  failure_message do |expected|
-    "expected block to return #{expected} but was #{@result} after timeout expired"
-  end
-end