standard-procedure-plumbing 0.2.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71e621c375dc0a17f928884eee2718fc7ed89a2f113374e90a5e6532914d71ea
-  data.tar.gz: 6632624c924bdee49e9dc4b273da36792916c434d12b867d874bcd1ddb880b8b
+  metadata.gz: 6074870313ece34eb4b9565602db4de70bb5b7e14e8a9051d85bb46b6fc64bf5
+  data.tar.gz: a81292b0ad9e87dfcce61d531e891c1b4ed25ccda3331ceb731c082c6e9c7c16
 SHA512:
-  metadata.gz: aa02b3cc5688ebeed1ec98f22142077d9c26e952bc34772d9395d6d120f2a5103efc67a5cc0e3f7508c937f6392a294f3d6088d8adca9d7415cf81cb2e7f28e6
-  data.tar.gz: d2a164087e839fc3cd48d9b0c22cee9765541a388e4ffc48f5f614faa4690b69d7aa17a6bfc6d77d03ce2ed91e2af49cb8a02fa98e094117194414d7dbd49470
+  metadata.gz: 45827e921f7bc272e0688a6477d405a81e8c9ea64405078782fbf5aa45658066bf7f9c5503692f4f6eadfdbb08d21221eb4e0b0731654e4808e0f7ec1111f9bb
+  data.tar.gz: 1ba319545accf7051393845b1883d5eb69aeacba182c86f26ca6e95e7761711e922904d2ec5427872e8dcd6ccdf5fba25737fe5c20a887cc06ba23ab2184c81a

data/.vscode/tasks.json

@@ -0,0 +1,11 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "rspec",
+      "type": "shell",
+      "command": "rspec",
+      "problemMatcher": []
+    }
+  ]
+}

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [0.2.2] - 2024-08-25
+
+ - Added Plumbing::RubberDuck
+
+## [0.2.1] - 2024-08-25
+
+ - Split the Pipe implementation between the Pipe and EventDispatcher
+ - Use different EventDispatchers to handle fibers or inline pipes
+ - Renamed Chain to Pipeline
+
 ## [0.2.0] - 2024-08-14
 
  - Added optional Dry::Validation support

data/README.md

@@ -1,5 +1,64 @@
 # Plumbing
 
+## Plumbing::Pipeline - transform data through a pipeline
+
+Define a sequence of operations that proceed in order, passing their output from one operation as the input to another.
+
+Use `perform` to define a step that takes some input and returns a different output.  
+Use `execute` to define a step that takes some input and returns that same input.  
+Use `embed` to define a step that uses another `Plumbing::Chain` class to generate the output.  
+
+If you have [dry-validation](https://dry-rb.org/gems/dry-validation/1.10/) installed, you can validate your input using a `Dry::Validation::Contract`.  
+
+If you don't want to use dry-validation, you can instead define a `pre_condition` (although there's nothing to stop you defining a contract as well as pre_conditions - with the contract being verified first).  
+
+You can also verify that the output generated is as expected by defining a `post_condition`.  
+
+### Usage:
+
+```ruby
+require "plumbing"
+class BuildSequence < Plumbing::Pipeline 
+  pre_condition :must_be_an_array do |input| 
+    # you could replace this with a `validate` definition (using a Dry::Validation::Contract) if you prefer
+    input.is_a? Array 
+  end
+
+  post_condition :must_have_three_elements do |output|
+    # this is a stupid post-condition but 🤷🏾‍♂️, this is just an example
+    output.length == 3
+  end
+
+  perform :add_first
+  perform :add_second
+  perform :add_third
+
+  private 
+
+  def add_first input 
+    input << "first"
+  end
+
+  def add_second input 
+    input << "second" 
+  end
+
+  def add_third input 
+    input << "third"
+  end
+end
+
+BuildSequence.new.call []
+# => ["first", "second", "third"]
+
+BuildSequence.new.call 1
+# => Plumbing::PreconditionError("must_be_an_array")
+
+BuildSequence.new.call ["extra element"]
+# => Plumbing::PostconditionError("must_have_three_elements")
+```
+
+
 ## Plumbing::Pipe - a composable observer
 
 [Observers](https://ruby-doc.org/3.3.0/stdlibs/observer/Observable.html) in Ruby are a pattern where objects (observers) register their interest in another object (the observable).  This pattern is common throughout programming languages (event listeners in Javascript, the dependency protocol in [Smalltalk](https://en.wikipedia.org/wiki/Smalltalk)).
@@ -28,7 +87,9 @@ require "plumbing"
 
 @source = Plumbing::Pipe.start
 
-@filter = Plumbing::Filter.start source: @source, accepts: %w[important urgent]
+@filter = Plumbing::Filter.start source: @source do |event|
+  %w[important urgent].include? event.type 
+end
 
 @observer = @filter.add_observer do |event|
   puts event.type
@@ -83,9 +144,9 @@ require "plumbing"
 @first_source = Plumbing::Pipe.start
 @second_source = Plumbing::Pipe.start
 
-@join = Plumbing::Junction.start @first_source, @second_source
+@junction = Plumbing::Junction.start @first_source, @second_source
 
-@observer = @join.add_observer do |event|
+@observer = @junction.add_observer do |event|
   puts event.type
 end
 
@@ -95,62 +156,60 @@ end
 # => "two"
 ```
 
-## Plumbing::Chain - a chain of operations that occur in sequence
-
-Define a sequence of operations that proceed in order, passing their output from one operation as the input to another.
+Dispatching events asynchronously (using Fibers)
+```ruby
+require "plumbing"
+require "plumbing/event_dispatcher/fiber"
+require "async"
 
-Use `perform` to define a step that takes some input and returns a different output.  
-Use `execute` to define a step that takes some input and returns that same input.  
-Use `embed` to define a step that uses another `Plumbing::Chain` class to generate the output.  
+# `limit` controls how many fibers can dispatch events concurrently - the default is 4
+@first_source = Plumbing::Pipe.start dispatcher: Plumbing::EventDispatcher::Fiber.new limit: 8
+@second_source = Plumbing::Pipe.start dispatcher: Plumbing::EventDispatcher::Fiber.new limit: 2
 
-If you have [dry-validation](https://dry-rb.org/gems/dry-validation/1.10/) installed, you can validate your input using a `Dry::Validation::Contract`.  
+@junction = Plumbing::Junction.start @first_source, @second_source, dispatcher: Plumbing::EventDispatcher::Fiber.new
 
-If you don't want to use dry-validation, you can instead define a `pre_condition` - there's nothing to stop you defining a contract as well as pre_conditions (with the contract being verified first).  
+@filter = Plumbing::Filter.start source: @junction, dispatcher: Plumbing::EventDispatcher::Fibernew do |event|
+  %w[one-one two-two].include? event.type 
+end
 
-You can also verify that the output generated is as expected by defining a `post_condition`.  
+Sync do 
+  @first_source.notify "one-one"
+  @first_source.notify "one-two"
+  @second_source.notify "two-one"
+  @second_source.notify "two-two"
+end
+```
 
-### Usage:
 
-```ruby
-require "plumbing"
-class BuildSequence < Plumbing::Chain 
-  pre_condition :must_be_an_array do |input| 
-    # you could replace this with a `validate` definition (using a Dry::Validation::Contract) if you prefer
-    input.is_a? Array 
-  end
+## Plumbing::RubberDuck - duck types and type-casts
 
-  post_condition :must_have_three_elements do |output|
-    # yes, this is a stupid post-condition but 🤷🏾‍♂️
-    output.length == 3
-  end
+Define an [interface or protocol](https://en.wikipedia.org/wiki/Interface_(object-oriented_programming) specifying which messages you expect to be able to send.  Then cast an object into that type, which first tests that the object can respond to those messages and limits you to sending those messages and no others.  
 
-  perform :add_first
-  perform :add_second
-  perform :add_third
 
-  private 
+### Usage 
 
-  def add_first input 
-    input << "first"
-  end
+Define your interface (Person in this example), then cast your objects (instances of PersonData and CarData).  
 
-  def add_second input 
-    input << "second" 
-  end
+```ruby
+require "plumbing"
 
-  def add_third input 
-    input << "third"
-  end
-end
+Person = Plumbing::RubberDuck.define :first_name, :last_name, :email 
 
-BuildSequence.new.call []
-# => ["first", "second", "third"]
+PersonData = Struct.new(:first_name, :last_name, :email, :favourite_food)
+CarData = Struct.new(:make, :model, :colour)
 
-BuildSequence.new.call 1
-# => Plumbing::PreconditionError("must_be_an_array")
+@porsche_911 = CarData.new "Porsche", "911", "black"
+@person = @porsche_911.as Person
+# => Raises a TypeError 
 
-BuildSequence.new.call ["extra element"]
-# => Plumbing::PostconditionError("must_have_three_elements")
+@alice = PersonData.new "Alice", "Aardvark", "alice@example.com", "Ice cream"
+@person = @alice.as Person
+@person.first_name
+# => "Alice"
+@person.email 
+# => "alice@example.com"
+@person.favourite_food
+# => NoMethodError - even though :favourite_food is a field in PersonData, it is not included in the definition of Person so cannot be accessed through the RubberDuck type
 ```
 
 ## Installation
@@ -167,7 +226,6 @@ Then:
 require 'plumbing'
 ```
 
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/checksums/standard-procedure-plumbing-0.2.0.gem.sha512

@@ -0,0 +1 @@
+f8972f9d59a7a040262dd738514a53e38300604b524f67a16bfc465d69335838fd6861a429c164764f72a4172d54462c8816eeb43d4bafe8099c97eb9fe7b156

data/checksums/standard-procedure-plumbing-0.2.1.gem.sha512

@@ -0,0 +1 @@
+92f63ff4b002a27778854ba86d2bb4b60e4ce7eae93592d3c3e3f90aa03045d961b6dfea86901a7290485d4953df548c521ae49efd7d53547939208515aa392e

data/checksums/standard-procedure-plumbing-0.2.2.gem.sha512

@@ -0,0 +1 @@
+2309f738a6739650f259c456af69796e59c1de214579a8a274d56b7ccc8176e9e59cb0e63d744bd5a6ed40e93f4c57a368c3de2bc525163e90da9467a58c6387

data/lib/plumbing/error.rb

@@ -10,10 +10,4 @@ module Plumbing
 
   # Error raised because an invalid [Event] object was pushed into the pipe
   class InvalidEvent < Error; end
-
-  # Error raised because an invalid observer was registered
-  class InvalidObserver < Error; end
-
-  # Error raised because a BlockedPipe was used instead of an actual implementation of a Pipe
-  class PipeIsBlocked < Plumbing::Error; end
 end

data/lib/plumbing/event_dispatcher/fiber.rb

@@ -0,0 +1,61 @@
+require "async/task"
+require "async/semaphore"
+
+module Plumbing
+  class EventDispatcher
+    class Fiber < EventDispatcher
+      def initialize limit: 4
+        super()
+        @semaphore = Async::Semaphore.new(limit)
+        @queue = Set.new
+        @paused = false
+      end
+
+      def dispatch event
+        @queue << event
+        dispatch_events unless @paused
+      end
+
+      def pause
+        @paused = true
+      end
+
+      def resume
+        @paused = false
+        dispatch_events
+      end
+
+      def queue_size
+        @queue.size
+      end
+
+      def shutdown
+        super
+        @queue.clear
+      end
+
+      private
+
+      def dispatch_events
+        @semaphore.async do |task|
+          events = @queue.dup
+          @queue.clear
+          events.each do |event|
+            dispatch_event event, task
+          end
+        end
+      end
+
+      def dispatch_event event, task
+        @observers.each do |observer|
+          task.async do
+            observer.call event
+          rescue => ex
+            puts ex
+            ex
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plumbing/event_dispatcher.rb

@@ -0,0 +1,34 @@
+module Plumbing
+  class EventDispatcher
+    def initialize observers: []
+      @observers = observers.as(Collection)
+    end
+
+    def add_observer observer = nil, &block
+      observer ||= block.to_proc
+      @observers << observer.as(Callable).target
+      observer
+    end
+
+    def remove_observer observer
+      @observers.delete observer
+    end
+
+    def is_observer? observer
+      @observers.include? observer
+    end
+
+    def dispatch event
+      @observers.each do |observer|
+        observer.call event
+      rescue => ex
+        puts ex
+        ex
+      end
+    end
+
+    def shutdown
+      @observers = []
+    end
+  end
+end

data/lib/plumbing/filter.rb

@@ -1,19 +1,13 @@
 module Plumbing
   # A pipe that filters events from a source pipe
   class Filter < Pipe
-    class InvalidFilter < Error; end
-
     # Chain this pipe to the source pipe
     # @param source [Plumbing::Pipe]
-    # @param accepts [Array[String]] event types that this filter will allow through (or pass [] to allow all)
-    # @param rejects [Array[String]] event types that this filter will not allow through
-    def initialize source:, accepts: [], rejects: []
-      super()
-      raise InvalidFilter.new "source must be a Plumbing::Pipe descendant" unless source.is_a? Plumbing::Pipe
-      raise InvalidFilter.new "accepts and rejects must be arrays" unless accepts.is_a?(Array) && rejects.is_a?(Array)
-      @accepted_event_types = accepts
-      @rejected_event_types = rejects
-      source.add_observer do |event|
+    # @param &accepts [Block] a block that returns a boolean value - true to accept the event, false to reject it
+    def initialize source:, dispatcher: nil, &accepts
+      super(dispatcher: dispatcher)
+      @accepts = accepts.as(Callable)
+      source.as(Observable).add_observer do |event|
         filter_and_republish event
       end
     end
@@ -21,8 +15,7 @@ module Plumbing
     private
 
     def filter_and_republish event
-      return nil if @accepted_event_types.any? && !@accepted_event_types.include?(event.type)
-      return nil if @rejected_event_types.include? event.type
+      return nil unless @accepts.call event
       dispatch event
     end
   end

data/lib/plumbing/junction.rb

@@ -0,0 +1,20 @@
+module Plumbing
+  # A pipe that filters events from a source pipe
+  class Junction < Pipe
+    # Chain multiple sources to this pipe
+    # @param [Array<Plumbing::Pipe>]
+    def initialize *sources, dispatcher: nil
+      super(dispatcher: dispatcher)
+      @sources = sources.collect { |source| add(source) }
+    end
+
+    private
+
+    def add source
+      source.as(Observable).add_observer do |event|
+        dispatch event
+      end
+      source
+    end
+  end
+end

data/lib/plumbing/pipe.rb

@@ -1,9 +1,11 @@
 module Plumbing
   # A basic pipe
   class Pipe
+    require_relative "event_dispatcher"
+
     # Subclasses should call `super()` to ensure the pipe is initialised corrected
-    def initialize
-      @observers = []
+    def initialize dispatcher: nil
+      @dispatcher = dispatcher.nil? ? EventDispatcher.new : dispatcher.as(DispatchesEvents)
     end
 
     # Push an event into the pipe
@@ -27,38 +29,36 @@ module Plumbing
     # @param &block [Block] (optional)
     # @return an object representing this observer (dependent upon the implementation of the pipe itself)
     # Either a `callable` or a `block` must be supplied.  If the latter, it is converted to a [Proc]
-    def add_observer observer = nil, &block
-      observer ||= block.to_proc
-      raise Plumbing::InvalidObserver.new "observer_does_not_respond_to_call" unless observer.respond_to? :call
-      @observers << observer
+    def add_observer(observer = nil, &)
+      @dispatcher.add_observer(observer, &)
     end
 
     # Remove an observer from this pipe
     # @param observer
     # This removes the given observer from this pipe.  The observer should have previously been returned by #add_observer and is implementation-specific
     def remove_observer observer
-      @observers.delete observer
+      @dispatcher.remove_observer observer
     end
 
     # Test whether the given observer is observing this pipe
     # @param observer
     # @return [boolean]
     def is_observer? observer
-      @observers.include? observer
+      @dispatcher.is_observer? observer
     end
 
     # Close this pipe and perform any cleanup.
     # Subclasses should override this to perform their own shutdown routines and call `super` to ensure everything is tidied up
     def shutdown
       # clean up and release any observers, just in case
-      @observers = []
+      @dispatcher.shutdown
     end
 
     # Start this pipe
     # Subclasses may override this method to add any implementation specific details.
     # By default any supplied parameters are called to the subclass' `initialize` method
-    def self.start(**params)
-      new(**params)
+    def self.start(*, **, &)
+      new(*, **, &)
     end
 
     protected
@@ -68,12 +68,7 @@ module Plumbing
     # 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.collect do |observer|
-        observer.call event
-      rescue => ex
-        puts ex
-        ex
-      end
+      @dispatcher.dispatch event
     end
   end
 end

data/lib/plumbing/{chain → pipeline}/contracts.rb

@@ -1,5 +1,5 @@
 module Plumbing
-  class Chain
+  class Pipeline
     module Contracts
       def pre_condition name, &validator
         pre_conditions[name.to_sym] = validator
@@ -25,19 +25,19 @@ module Plumbing
 
       def validate_contract_for input
         return true if @validation_contract.nil?
-        result = const_get(@validation_contract).new.call(input)
+        result = const_get(@validation_contract).new.as(Callable).call(input)
         raise PreConditionError, result.errors.to_h.to_yaml unless result.success?
         input
       end
 
       def validate_preconditions_for input
-        failed_preconditions = pre_conditions.select { |name, validator| !validator.call(input) }
+        failed_preconditions = pre_conditions.select { |name, validator| !validator.as(Callable).call(input) }
         raise PreConditionError, failed_preconditions.keys.join(", ") if failed_preconditions.any?
         input
       end
 
       def validate_postconditions_for output
-        failed_postconditions = post_conditions.select { |name, validator| !validator.call(output) }
+        failed_postconditions = post_conditions.select { |name, validator| !validator.as(Callable).call(output) }
         raise PostConditionError, failed_postconditions.keys.join(", ") if failed_postconditions.any?
         output
       end

data/lib/plumbing/{chain → pipeline}/operations.rb

@@ -1,14 +1,8 @@
 module Plumbing
-  class Chain
+  class Pipeline
     module Operations
-      def perform method, &implementation
-        implementation ||= ->(input, instance) { instance.send(method, input) }
-        operations << implementation
-      end
-
-      def embed method, class_name
-        implementation = ->(input, instance) { const_get(class_name).new.call(input) }
-        operations << implementation
+      def perform method, using: nil, &implementation
+        using.nil? ? perform_internal(method, &implementation) : perform_external(method, using)
       end
 
       def execute method
@@ -24,7 +18,7 @@ module Plumbing
         validate_preconditions_for input
         result = input
         operations.each do |operation|
-          result = operation.call(result, instance)
+          result = operation.as(Callable).call(result, instance)
         end
         validate_postconditions_for result
         result
@@ -35,6 +29,17 @@ module Plumbing
       def operations
         @operations ||= []
       end
+
+      def perform_internal method, &implementation
+        implementation ||= ->(input, instance) { instance.send(method, input) }
+        operations << implementation
+      end
+
+      def perform_external method, class_or_class_name
+        external_class = class_or_class_name.is_a?(String) ? const_get(class_or_class_name) : class_or_class_name
+        implementation = ->(input, instance) { external_class.new.as(Callable).call(input) }
+        operations << implementation
+      end
     end
   end
 end

data/lib/plumbing/pipeline.rb

@@ -0,0 +1,14 @@
+require_relative "pipeline/contracts"
+require_relative "pipeline/operations"
+
+module Plumbing
+  # A chain of operations that are executed in sequence
+  class Pipeline
+    extend Plumbing::Pipeline::Contracts
+    extend Plumbing::Pipeline::Operations
+
+    def call input
+      self.class._call input, self
+    end
+  end
+end

data/lib/plumbing/rubber_duck/object.rb

@@ -0,0 +1,9 @@
+module Plumbing
+  class RubberDuck
+    ::Object.class_eval do
+      def as duck_type
+        duck_type.proxy_for self
+      end
+    end
+  end
+end

data/lib/plumbing/rubber_duck/proxy.rb

@@ -0,0 +1,16 @@
+module Plumbing
+  class RubberDuck
+    class Proxy
+      attr_reader :target
+
+      def initialize target, duck_type
+        @target = target
+        @duck_type = duck_type
+      end
+
+      def as duck_type
+        (duck_type == @duck_type) ? self : duck_type.proxy_for(target)
+      end
+    end
+  end
+end

data/lib/plumbing/rubber_duck.rb

@@ -0,0 +1,50 @@
+module Plumbing
+  # A type-checker for duck-types
+  class RubberDuck
+    require_relative "rubber_duck/object"
+    require_relative "rubber_duck/proxy"
+
+    def initialize *methods
+      @methods = methods.map(&:to_sym)
+      @proxy_classes = {}
+    end
+
+    def verify object
+      missing_methods = @methods.reject { |method| object.respond_to? method }
+      raise TypeError, "Expected object to respond to #{missing_methods.join(", ")}" unless missing_methods.empty?
+      object
+    end
+
+    def proxy_for object
+      is_a_proxy?(object) || build_proxy_for(object)
+    end
+
+    def self.define *methods
+      new(*methods)
+    end
+
+    private
+
+    def is_a_proxy? object
+      @proxy_classes.value?(object.class) ? object : nil
+    end
+
+    def build_proxy_for object
+      proxy_class_for(object).new(verify(object), self)
+    end
+
+    def proxy_class_for object
+      @proxy_classes[object.class] ||= define_proxy_class_for(object.class)
+    end
+
+    def define_proxy_class_for klass
+      Class.new(Plumbing::RubberDuck::Proxy).tap do |proxy_class|
+        @methods.each do |method|
+          proxy_class.define_method method do |*args, &block|
+            @target.send method, *args, &block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/plumbing/types.rb

@@ -0,0 +1,6 @@
+module Plumbing
+  Callable = RubberDuck.define :call
+  Observable = RubberDuck.define :add_observer, :remove_observer, :is_observer?
+  DispatchesEvents = RubberDuck.define :add_observer, :remove_observer, :is_observer?, :shutdown, :dispatch
+  Collection = RubberDuck.define :each, :<<, :delete, :include?
+end

data/lib/plumbing/version.rb

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

data/lib/plumbing.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "plumbing/version"
-
-require_relative "plumbing/error"
-require_relative "plumbing/event"
-require_relative "plumbing/pipe"
-require_relative "plumbing/filter"
-require_relative "plumbing/chain"
-
 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.2.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Rahoul Baruah
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-14 00:00:00.000000000 Z
+date: 2024-08-25 00:00:00.000000000 Z
 dependencies: []
 description: A composable event pipeline and sequential pipelines of operations
 email:
@@ -21,6 +21,7 @@ files:
 - ".rubocop.yml"
 - ".solargraph.yml"
 - ".standard.yml"
+- ".vscode/tasks.json"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE
@@ -28,15 +29,24 @@ files:
 - Rakefile
 - checksums/standard-procedure-plumbing-0.1.1.gem.sha512
 - checksums/standard-procedure-plumbing-0.1.2.gem.sha512
+- checksums/standard-procedure-plumbing-0.2.0.gem.sha512
+- checksums/standard-procedure-plumbing-0.2.1.gem.sha512
+- checksums/standard-procedure-plumbing-0.2.2.gem.sha512
 - lib/plumbing.rb
-- lib/plumbing/chain.rb
-- lib/plumbing/chain/contracts.rb
-- lib/plumbing/chain/operations.rb
 - lib/plumbing/error.rb
 - lib/plumbing/event.rb
-- lib/plumbing/fiber/pipe.rb
+- lib/plumbing/event_dispatcher.rb
+- lib/plumbing/event_dispatcher/fiber.rb
 - lib/plumbing/filter.rb
+- lib/plumbing/junction.rb
 - lib/plumbing/pipe.rb
+- lib/plumbing/pipeline.rb
+- lib/plumbing/pipeline/contracts.rb
+- lib/plumbing/pipeline/operations.rb
+- lib/plumbing/rubber_duck.rb
+- lib/plumbing/rubber_duck/object.rb
+- lib/plumbing/rubber_duck/proxy.rb
+- lib/plumbing/types.rb
 - lib/plumbing/version.rb
 - sig/plumbing.rbs
 homepage: https://github.com/standard-procedure/plumbing
@@ -61,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
 summary: Plumbing - various pipelines for your ruby application

data/lib/plumbing/chain.rb

@@ -1,14 +0,0 @@
-require_relative "chain/contracts"
-require_relative "chain/operations"
-
-module Plumbing
-  # A chain of operations that are executed in sequence
-  class Chain
-    extend Plumbing::Chain::Contracts
-    extend Plumbing::Chain::Operations
-
-    def call input
-      self.class._call input, self
-    end
-  end
-end

data/lib/plumbing/fiber/pipe.rb

@@ -1,36 +0,0 @@
-require "async/task"
-require "async/semaphore"
-
-module Plumbing
-  module Fiber
-    # An implementation of a pipe that uses Fibers
-    class Pipe < Plumbing::Pipe
-      attr_reader :active
-
-      def initialize limit: 4
-        super()
-        @limit = 4
-        @semaphore = Async::Semaphore.new(@limit)
-      end
-
-      def << event
-        raise Plumbing::InvalidEvent.new "event is not a Plumbing::Event" unless event.is_a? Plumbing::Event
-        @semaphore.async do |task|
-          dispatch event, task
-        end
-      end
-
-      protected
-
-      def dispatch event, task
-        @observers.collect do |observer|
-          task.async do
-            observer.call event
-          rescue => ex
-            puts "Error: #{ex}"
-          end
-        end
-      end
-    end
-  end
-end