empipelines 0.2.2 → 0.2.3

data/README.md

@@ -4,10 +4,8 @@
 * Make wiring easier
 * Example apps
 * Control flow for AmqpEventSource
-* Transaction ID on each message
 * Evented I/O for IOEventSource
 * Consolidate logger and monitoring
 * Default monitoring implementation
 * Performance testing
-* Make all events composable (e.g. new_on_event = old_on_event o new_handler)
 * Detect insonsistency when handler didnt consume or pass message ahead

data/empipelines.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |s|
   s.rubygems_version = '1.3.5'
   ## Leave these as is they will be modified for you by the rake gemspec task.
   s.name              = 'empipelines'
-  s.version           = '0.2.2'
-  s.date              = '2011-12-23'
+  s.version           = '0.2.3'
+  s.date              = '2012-01-02'
   s.rubyforge_project = 'empipelines'
 
   s.summary           = "Simple Event Handling Pipeline Architecture for EventMachine"
@@ -45,10 +45,9 @@ Gem::Specification.new do |s|
     lib/empipelines/aggregated_event_source.rb
     lib/empipelines/amqp_event_source.rb
     lib/empipelines/batch_event_source.rb
-    lib/empipelines/event_handlers.rb
     lib/empipelines/event_pipeline.rb
+    lib/empipelines/event_source.rb
     lib/empipelines/io_event_source.rb
-    lib/empipelines/list_event_source.rb
     lib/empipelines/message.rb
     lib/empipelines/periodic_event_source.rb
     lib/empipelines/pipeline.rb
@@ -57,9 +56,9 @@ Gem::Specification.new do |s|
     unit/empipelines/batch_event_source_spec.rb
     unit/empipelines/empty_io_event_source.dat
     unit/empipelines/event_pipeline_spec.rb
+    unit/empipelines/event_source_spec.rb
     unit/empipelines/io_event_source.dat
     unit/empipelines/io_event_source_spec.rb
-    unit/empipelines/list_event_source_spec.rb
     unit/empipelines/message_spec.rb
     unit/empipelines/periodic_event_source_spec.rb
     unit/empipelines/pipeline_spec.rb

data/lib/empipelines/aggregated_event_source.rb

@@ -1,8 +1,7 @@
-require 'empipelines/event_handlers'
+require 'empipelines/event_source'
 
 module EmPipelines
-  class AggregatedEventSource
-    include EventHandlers
+  class AggregatedEventSource <  EventSource
     
     def initialize(em, *event_sources)
       @em, @sources = em, event_sources.flatten
@@ -15,7 +14,7 @@ module EmPipelines
         
         s.on_finished do |*ignored|
           finished += 1
-          finished_handler.call(self) if finished == @sources.size
+          finished! if finished == @sources.size
         end
         @em.next_tick { s.start! }
       end      

data/lib/empipelines/amqp_event_source.rb

@@ -1,26 +1,26 @@
+require 'empipelines/event_source'
+require 'empipelines/message'
+
 require 'json'
 
 module EmPipelines
   #this must have a on_finished!
-  class AmqpEventSource
+  class AmqpEventSource < EventSource
+
     def initialize(em, queue, event_name)
       @em, @queue, @event_name = em, queue, event_name
     end
 
-    def on_event(&handler)
-      @handler = handler
-    end
-
     def start!
       @queue.subscribe do |header, json_payload|
-        message = Message.new ({
-                                 :header     => header,
-                                 :origin     => @queue.name,
-                                 :payload    => JSON.parse(json_payload),
-                                 :event      => @event_name,
-                                 :started_at => Time.now.to_i
-                                })
-        @handler.call(message)
+        message = Message.new({
+                                :header     => header,
+                                :origin     => @queue.name,
+                                :payload    => JSON.parse(json_payload),
+                                :event      => @event_name,
+                                :started_at => Time.now.to_i
+                              })
+        event!(message)
       end
     end
   end

data/lib/empipelines/batch_event_source.rb

@@ -1,8 +1,8 @@
-require 'empipelines/event_handlers'
+require 'empipelines/message'
+require 'empipelines/event_source'
 
 module EmPipelines
-  class BatchEventSource
-    include EventHandlers
+  class BatchEventSource < EventSource
     
     def initialize(em, list_name, events)
       @num_finalised = 0
@@ -24,11 +24,11 @@ module EmPipelines
                                 :origin => @list_name
                               })
 
-        message.on_rejected_broken(message_finished)
+        message.on_broken(message_finished)
         message.on_rejected(message_finished)
         message.on_consumed(message_finished)
 
-        event_handler.call(message)
+        event!(message)
       end
     end
 
@@ -37,11 +37,7 @@ module EmPipelines
       #TODO: can we make this not be based on size?
       #it makes it harder to have streams as event sources (i.e. ranges).
       #this class should only rely on Enumerable methods.
-      finished = (@num_finalised == @events.size)
-
-      if finished and finished_handler
-        @em.next_tick { finished_handler.call(self) }
-      end
+      finished! if (@num_finalised == @events.size)
     end
   end
 end

data/lib/empipelines/event_source.rb

@@ -0,0 +1,67 @@
+module EmPipelines
+  class EventSource
+    def on_event(handler=nil, &block)
+      add_handlers!(event_handler, (handler || block))
+    end
+
+    def on_finished(handler=nil, &block)
+      add_handlers!(finished_handler, (handler || block))
+    end
+
+    protected
+    def event_handler
+      @event_handler ||= []
+      @event_handler
+    end
+
+    def finished_handler
+      @finished_handler ||= []
+      @finished_handler
+    end
+
+    def finished!
+      finished_handler.each{ |h| h.call(self) }
+    end
+
+    def event!(msg)
+      if event_handler.size == 1 then
+        event_handler.first.call(msg)
+      else
+        copies = a_copy_per_handler(msg)
+        event_handler.each do |h|
+          h.call(copies.pop)
+        end
+      end
+    end
+
+    private
+    def a_copy_per_handler(msg)
+        msg_copies = event_handler.map { |x| msg.copy }
+
+        verify_copies = lambda do |m|
+          if msg_copies.all?(&:processed?) then
+            if msg_copies.any? { |m| m.state == :broken } then
+              msg.broken!
+            elsif msg_copies.any? { |m| m.state == :rejected } then
+              msg.rejected!
+            else
+              msg.consumed!
+            end
+          end
+        end
+
+        msg_copies.each do |copy|
+          copy.on_consumed(verify_copies)
+          copy.on_rejected(verify_copies)
+          copy.on_broken(verify_copies)
+        end
+
+        msg_copies.clone
+    end
+
+    def add_handlers!(handler_list, new_handlers)
+      to_add = new_handlers.is_a?(Enumerable) ? new_handlers : [new_handlers]
+      to_add.each { |h| handler_list << h  }
+    end
+  end
+end

data/lib/empipelines/io_event_source.rb

@@ -1,8 +1,7 @@
-require 'empipelines/event_handlers'
+require 'empipelines/event_source'
 
 module EmPipelines
-  class IOEventSource
-    include EventHandlers
+  class IOEventSource < EventSource
 
     def initialize(em, file_path)
       raise "File #{file_path} does not exist!" unless File.exists?(file_path)
@@ -15,7 +14,7 @@ module EmPipelines
 
       wrapped_handler = BatchEventSource.new(@em, @file_path, events)
       wrapped_handler.on_event(event_handler)
-      wrapped_handler.on_finished { |*ignored| finished_handler.call(self) }
+      wrapped_handler.on_finished { |*ignored| finished! }
       wrapped_handler.start!
     end
   end

data/lib/empipelines/message.rb

@@ -1,8 +1,12 @@
 module EmPipelines
   class Message
-    attr_reader :state
-    
-    def initialize(base_hash={})
+    attr_reader :state, :co_id
+
+    @@count = 0
+
+    def initialize(base_hash={}, origin=nil)
+      @origin = origin
+      create_correlation_id!
       backing_hash!(base_hash)
       created!
     end
@@ -28,15 +32,15 @@ module EmPipelines
     end
 
     def on_consumed(callback=nil, &callback_block)
-      @consumed_callback = block_given? ? callback_block : callback
+      @consumed_callback = (callback || callback_block)
     end
 
     def on_rejected(callback=nil, &callback_block)
-      @rejected_callback = block_given? ? callback_block : callback
+      @rejected_callback = (callback || callback_block)
     end
-    
-    def on_rejected_broken(callback=nil, &callback_block)
-      @rejected_broken_callback = block_given? ? callback_block : callback
+
+    def on_broken(callback=nil, &callback_block)
+      @broken_callback = (callback || callback_block)
     end
 
     def consumed!
@@ -50,11 +54,15 @@ module EmPipelines
       @state = :rejected
       invoke(@rejected_callback)
     end
-    
+
     def broken!
       check_if_mutation_allowed
-      @state = :rejected_broken
-      invoke(@rejected_broken_callback)
+      @state = :broken
+      invoke(@broken_callback)
+    end
+
+    def processed?
+      @state != :created
     end
 
     def as_hash
@@ -64,20 +72,33 @@ module EmPipelines
     def payload
       as_hash[:payload]
     end
-    
+
+    def copy
+      forked = Message.new(as_hash, self)
+      forked.on_broken(@broken_callback)
+      forked.on_rejected(@rejected_callback)
+      forked.on_consumed(@consumed_callback)
+      forked
+    end
+
     def to_s
-      "#{self.class.name} state:#{@state} backing_hash:#{as_hash}"
+      "#{self.class.name} co_id:#{co_id} state:#{@state} backing_hash:#{as_hash}"
     end
 
     private
+    def create_correlation_id!
+      @@count += 1
+      suffix = @origin.nil? ? "@#{Process.pid}" : @origin.co_id
+      @co_id = "#{@@count}@#{suffix}"
+    end
 
     def backing_hash!(other)
       @backing_hash = symbolised(other)
     end
-    
+
     def symbolised(raw_hash)
       raw_hash.reduce({}) do |acc, (key, value)|
-        acc[key.to_s.to_sym] = value.is_a?(Hash) ? symbolised(value) : value        
+        acc[key.to_s.to_sym] = value.is_a?(Hash) ? symbolised(value) : value
         acc
       end
     end
@@ -85,11 +106,11 @@ module EmPipelines
     def created!
       @state = :created
     end
-    
+
     def check_if_mutation_allowed
-      raise "Cannot mutate #{self}" unless @state == :created
+      raise "Cannot mutate #{self}" if processed?
     end
-    
+
     def invoke(callback)
       callback.call(self) if callback
     end

data/lib/empipelines/periodic_event_source.rb

@@ -1,5 +1,5 @@
 module EmPipelines
-  class PeriodicEventSource
+  class PeriodicEventSource < EventSource
     #on finish!!!!
     def initialize(em, name, interval_in_secs, &event_sourcing_code)
       @em                  = em
@@ -16,14 +16,10 @@ module EmPipelines
       end
     end
 
-    def on_event(&handler)
-      @handler = handler
-    end
-
     def tick!      
       event = @event_sourcing_code.call
       
-      @handler.call(Message.new(:payload => event, :origin => @name)) if event
+      event!(Message.new(:payload => event, :origin => @name)) if event
     end
   end
 end

data/lib/empipelines.rb

@@ -1,14 +1,13 @@
 module EmPipelines
-  VERSION = '0.2.2'
+  VERSION = '0.2.3'
 end
 
 require 'empipelines/message'
 
-require 'empipelines/event_handlers'
+require 'empipelines/event_source'
 require 'empipelines/amqp_event_source'
 require 'empipelines/batch_event_source'
 require 'empipelines/io_event_source'
-require 'empipelines/list_event_source'
 require 'empipelines/periodic_event_source'
 require 'empipelines/aggregated_event_source'
 

data/unit/empipelines/aggregated_event_source_spec.rb

@@ -1,17 +1,15 @@
 require 'empipelines/aggregated_event_source'
 
 module EmPipelines
-  class EventSourceStub
-    include EventHandlers
-
-    def event!(contents)
+  class EventSourceStub < EventSource
+    def event_now!(contents)
       raise 'not started' unless @started
-      event_handler.call(contents) if event_handler
+      event!(contents)
     end
 
-    def finish!
+    def finish_now!
       raise 'not started' unless @started
-      finished_handler.call([:this, :should, :not, :be, :used])
+      finished!
     end
 
     def start!
@@ -40,11 +38,11 @@ module EmPipelines
 
       aggregated.start!
 
-      source1.event! expected[0]
-      source2.event! expected[1]
-      source2.event! expected[2]
-      source3.event! expected[3]
-      source1.event! expected[4]
+      source1.event_now! expected[0]
+      source2.event_now! expected[1]
+      source2.event_now! expected[2]
+      source3.event_now! expected[3]
+      source1.event_now! expected[4]
 
       received.should ==(expected)
     end
@@ -61,9 +59,9 @@ module EmPipelines
       end
 
       aggregated.start!
-      sources[2].finish!
-      sources[1].finish!
-      sources[0].finish!
+      sources[2].finish_now!
+      sources[1].finish_now!
+      sources[0].finish_now!
 
       has_finished.first.should be_true
     end
@@ -78,8 +76,8 @@ module EmPipelines
       end
 
       aggregated.start!
-      sources[2].finish!
-      sources[0].finish!
+      sources[2].finish_now!
+      sources[0].finish_now!
     end
   end
 end

data/unit/empipelines/batch_event_source_spec.rb

@@ -1,7 +1,7 @@
 require 'empipelines/batch_event_source'
 
 module EmPipelines
-  ShouldNotBeCalled = lambda { raise 'should not be called' }
+  ShouldNotBeCalled = lambda { |*x| raise 'should not be called' }
   describe BatchEventSource do
 
     let (:em) do
@@ -56,7 +56,7 @@ module EmPipelines
         has_finished << true
       end
 
-      source.on_event(&ShouldNotBeCalled)
+      source.on_event(ShouldNotBeCalled)
 
       source.start!
 
@@ -67,8 +67,6 @@ module EmPipelines
       events = [1,2,3,4,5,6,7,8,9,10]
       source = BatchEventSource.new(em, list_name, events)
 
-      source.on_event(&ShouldNotBeCalled)
-
       count = 0
       source.on_event do |e|
         e.consumed! if (count=+1) > 1

data/unit/empipelines/event_source_spec.rb

@@ -0,0 +1,115 @@
+require 'empipelines/event_source'
+
+module EmPipelines
+  class StubEventSource < EventSource
+    def event_now!(message)
+      event!(message)
+    end
+
+    def finish_now!
+      finished!
+    end
+  end
+
+  describe EventSource do
+    context 'calling event handlers' do
+      it 'calls the handler when an message is to be processed' do
+        message = stub('message')
+        received = []
+
+        source = StubEventSource.new
+        source.on_event { |a| received << a }
+        source.event_now!(message)
+        received.should==([message])
+      end
+
+      it 'calls the finished handler when all events were processed' do
+        message = stub('message')
+        received = []
+
+        source = StubEventSource.new
+        source.on_finished { |a| received << a }
+        source.finish_now!
+        received.should==([source])
+      end
+
+      it 'does not do anything if no handlers' do
+        StubEventSource.new.event_now!({})
+        StubEventSource.new.finish_now!
+      end
+    end
+
+    context 'multiple event handlers' do
+      let(:message1) { Message.new({:a => 1}) }
+      let(:message2) { Message.new({:b => 2}) }
+
+      def mark_as(state)
+        lambda {|m| m.send "#{state}!".to_sym }
+      end
+
+      def should_be_marked_as(desired, message)
+        undesired = [:broken, :consumed, :rejected] - [desired]
+        undesired.each { |u| message.should_not_receive("#{u}!".to_sym) }
+        message.should_receive("#{desired}!".to_sym)
+        message.should_receive(:copy).at_least(:once).and_return { Message.new({}) }
+      end
+
+      it 'supports multiple handlers for a single event'do
+        received = []
+        finished = []
+
+        source = StubEventSource.new
+        source.on_event([lambda {|m| received << [1, m.payload]}, lambda {|m| received << [2, m.payload]}])
+        source.on_event {|m| received << [3, m.payload]}
+
+        source.on_finished {|s| finished << [10, s]}
+        source.on_finished([lambda {|s| finished << [20, s]}, lambda {|s| finished << [30, s]}])
+
+        source.event_now!(message1)
+        source.event_now!(message2)
+        source.finish_now!
+
+        received.should ==([
+                            [1, message1.payload],
+                            [2, message1.payload],
+                            [3, message1.payload],
+                            [1, message2.payload],
+                            [2, message2.payload],
+                            [3, message2.payload]
+                           ])
+
+        finished.should ==([[10, source], [20, source], [30, source]])
+      end
+
+      it 'marks the message as consumed if all handlers consume' do
+        message = mock('message')
+        should_be_marked_as(:consumed, message)
+
+        source = StubEventSource.new
+        source.on_event([mark_as(:consumed), mark_as(:consumed), mark_as(:consumed)])
+        source.event_now!(message)
+      end
+
+      it 'marks the message as rejects if at least one handler rejects and all others consumed' do
+        message = mock('message')
+        should_be_marked_as(:rejected, message)
+
+        source = StubEventSource.new
+        source.on_event([mark_as(:consumed), mark_as(:consumed), mark_as(:rejected), mark_as(:consumed)])
+        source.event_now!(message)
+      end
+
+      it 'marks message as broken if at least one handler marks as broken, regardless of others' do
+        message = mock('message')
+        should_be_marked_as(:broken, message)
+
+        source = StubEventSource.new
+        source.on_event([mark_as(:consumed), mark_as(:consumed), mark_as(:rejected), mark_as(:consumed), mark_as(:broken)])
+        source.event_now!(message)
+      end
+    end
+
+    context 'flow control' do
+    end
+  end
+end

data/unit/empipelines/io_event_source_spec.rb

@@ -1,4 +1,5 @@
 require 'empipelines/io_event_source'
+require 'empipelines/batch_event_source'
 
 module EmPipelines
   describe IOEventSource do    

data/unit/empipelines/message_spec.rb

@@ -2,8 +2,8 @@ require 'empipelines/message'
 
 module EmPipelines
   describe Message do
-    context "mostly behaves like a hashmap" do
-      it "stores values under symbolised keys" do
+    context 'mostly behaves like a hashmap' do
+      it 'stores values under symbolised keys' do
         original_hash = {:a => 1, :b => 2}
 
         message = Message.new(original_hash)
@@ -13,23 +13,23 @@ module EmPipelines
         message[:doesntexist].should ==(original_hash[:doesntexist])
       end
 
-      it "symbolises keys of all maps in the message" do
+      it 'symbolises keys of all maps in the message' do
         message = Message.new({
                                 :a => 1,
-                                "b" => 2,
+                                'b' => 2,
                                 3 => 3 ,
-                                "d" => {
-                                  "d1" => {"e" => 5},
-                                  "d2" => nil}
+                                'd' => {
+                                  'd1' => {'e' => 5},
+                                  'd2' => nil}
                               })
         message[:a].should ==(1)
         message[:b].should ==(2)
-        message["3".to_sym].should ==(3)
+        message['3'.to_sym].should ==(3)
         message[:d][:d1][:e].should ==(5)
         message[:d][:d2].should be_nil
       end
-      
-      it "allows for values to be CRUD" do
+
+      it 'allows for values to be CRUD' do
         original_hash = {:a => 1, :b => 2, :c => 0}
 
         message = Message.new(original_hash)
@@ -41,10 +41,10 @@ module EmPipelines
         message[:a].should ==(666)
         message[:b].should be_nil
         message[:c].should ==(original_hash[:c])
-        message[:z].should ==(999)      
+        message[:z].should ==(999)
       end
 
-      it "can be merged with a map, symbolising keys" do
+      it 'can be merged with a map, symbolising keys' do
         original = Message.new({'a' => 1})
         original.merge!({'b' => 2})
 
@@ -53,74 +53,94 @@ module EmPipelines
       end
     end
 
-    context "message status" do
+    context 'message status handlers' do
 
-      let (:handler_that_should_never_be_called) { lambda { raise "This shouldnt happen"  } }
+      let (:handler_that_should_never_be_called) { lambda { raise 'This shouldnt happen'  } }
 
-      it "doesnt do anything if no state callback specified" do
+      it 'doesnt do anything if no state callback specified' do
         Message.new.consumed!
         Message.new.rejected!
-        Message.new.broken!        
+        Message.new.broken!
+      end
+
+      it 'is possible to override a handler' do
+        origin = Message.new
+        origin.on_broken(handler_that_should_never_be_called)
+        origin.on_rejected(handler_that_should_never_be_called)
+        origin.on_consumed(handler_that_should_never_be_called)
+
+        consume = origin.copy
+        consume.on_consumed {}
+
+        reject  = origin.copy
+        reject.on_rejected {}
+
+        broken  = origin.copy
+        broken.on_broken {}
+
+        consume.consumed!
+        broken.broken!
+        reject.rejected!
       end
 
-      it "is possible to reject a message if broken"do
+      it 'is possible to reject a message if broken'do
         called = []
-        
-        message = Message.new        
-        message.on_rejected_broken  do |msg|
+
+        message = Message.new
+        message.on_broken  do |msg|
           called << msg
         end
-        
-        message.on_rejected(handler_that_should_never_be_called) 
+
+        message.on_rejected(handler_that_should_never_be_called)
         message.on_consumed(handler_that_should_never_be_called)
 
         message.broken!
-        
+
         called.should==([message])
       end
-      
-      it "is possible to reject a message if consumer cant handle it" do
+
+      it 'is possible to reject a message if consumer cant handle it' do
         called = []
-        
-        message = Message.new        
+
+        message = Message.new
         message.on_rejected  do |msg|
           called << msg
         end
-        
-        message.on_rejected_broken(handler_that_should_never_be_called)
+
+        message.on_broken(handler_that_should_never_be_called)
         message.on_consumed(handler_that_should_never_be_called)
 
         message.rejected!
-        
+
         called.should==([message])
       end
 
-      it "is possible to mark a message as consumed" do
+      it 'is possible to mark a message as consumed' do
         called = []
-        
-        message = Message.new        
+
+        message = Message.new
         message.on_consumed do |msg|
           called << msg
         end
-        
-        message.on_rejected_broken(handler_that_should_never_be_called)
+
+        message.on_broken(handler_that_should_never_be_called)
         message.on_rejected(handler_that_should_never_be_called)
 
         message.consumed!
-        
+
         called.should==([message])
       end
-      
-      it "is not possible to change a message after marking as consumed or rejected" do
+
+      it 'is not possible to change a message after marking as consumed or rejected' do
         read = lambda { |m| m[:some_key] }
         mutate = lambda { |m| m[:some_key] = :some_value }
-        
+
         consumed = Message.new
         consumed.consumed!
-        
+
         rejected = Message.new
         rejected.rejected!
-        
+
         broken = Message.new
         broken.broken!
 
@@ -132,5 +152,104 @@ module EmPipelines
         lambda{ mutate.call(broken) }.should raise_error
       end
     end
+
+    context 'cloning messages' do
+      it 'copys a message with equal initial state' do
+        origin = Message.new({:a => 1})
+        copy = origin.copy
+
+        origin.as_hash.should ==(copy.as_hash)
+      end
+
+      it 'copys a message with equal handlers' do
+        origin = Message.new({:a => 1})
+
+        consumed = []
+        rejected = []
+        broken   = []
+
+        origin.on_consumed { |m| consumed << m}
+        origin.on_rejected { |m| rejected << m}
+        origin.on_broken   { |m| broken   << m}
+
+        copy1 = origin.copy
+        copy2 = origin.copy
+
+        origin.consumed!
+        copy1.broken!
+        copy2.rejected!
+
+        consumed.should ==([origin])
+        rejected.should ==([copy2])
+        broken.should   ==([copy1])
+      end
+
+      it 'makes the messages contents independent' do
+        origin = Message.new({:a => 1})
+        copy = origin.copy
+        origin[:b] = 2
+        copy[:c] = 3
+
+        origin[:c].should be_nil
+        copy[:c].should_not be_nil
+
+        origin[:b].should_not be_nil
+        copy[:b].should be_nil
+      end
+
+      it 'makes the messages state independent' do
+        origin = Message.new({:a => 1})
+        copy = origin.copy
+
+        origin.broken!
+        copy.consumed!
+
+        origin.state.should ==(:broken)
+        copy.state.should ==(:consumed)
+      end
+    end
+
+    context 'generating a correlation id' do
+      it 'creates a different CoId for each sequential message' do
+        m1, m2, m3 = Message.new, Message.new, Message.new
+
+        m1.co_id.should_not ==(m2.co_id)
+        m1.co_id.should_not ==(m3.co_id)
+        m2.co_id.should_not ==(m1.co_id)
+        m2.co_id.should_not ==(m3.co_id)
+        m3.co_id.should_not ==(m2.co_id)
+        m3.co_id.should_not ==(m1.co_id)
+      end
+
+      it 'includes the process id on CoId so that multiple instances have different ids' do
+        Message.new.co_id.should match(/#{Process.pid}/)
+      end
+
+      it 'does not change CoId with state chages' do
+        m = Message.new
+        old_id = m.co_id
+
+        m.merge!({:some => :thing})
+        merged_id = m.co_id
+
+        m.consumed!
+        consumed_id = m.co_id
+
+        [merged_id, consumed_id].should ==([old_id, old_id])
+      end
+
+      it 'a copied message has a different, yet related, CoId from its origin' do
+        origin = Message.new
+        copied = origin.copy
+        grandcopied = copied.copy
+
+        origin.co_id.should_not ==(copied.co_id)
+        origin.co_id.should_not ==(grandcopied.co_id)
+        copied.co_id.should_not ==(grandcopied.co_id)
+
+        copied.co_id.should match(/#{origin.co_id}/)
+        grandcopied.co_id.should match(/#{copied.co_id}/)
+      end
+    end
   end
 end

data/unit/empipelines/pipeline_spec.rb

@@ -1,3 +1,4 @@
+require 'empipelines/message'
 require 'empipelines/pipeline'
 
 def msg(some_map)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: empipelines
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-23 00:00:00.000000000Z
+date: 2012-01-02 00:00:00.000000000Z
 dependencies: []
 description: Simple Event Handling Pipeline Architecture for EventMachine
 email: pcalcado+empipelines@gmail.com
@@ -33,10 +33,9 @@ files:
 - lib/empipelines/aggregated_event_source.rb
 - lib/empipelines/amqp_event_source.rb
 - lib/empipelines/batch_event_source.rb
-- lib/empipelines/event_handlers.rb
 - lib/empipelines/event_pipeline.rb
+- lib/empipelines/event_source.rb
 - lib/empipelines/io_event_source.rb
-- lib/empipelines/list_event_source.rb
 - lib/empipelines/message.rb
 - lib/empipelines/periodic_event_source.rb
 - lib/empipelines/pipeline.rb
@@ -45,9 +44,9 @@ files:
 - unit/empipelines/batch_event_source_spec.rb
 - unit/empipelines/empty_io_event_source.dat
 - unit/empipelines/event_pipeline_spec.rb
+- unit/empipelines/event_source_spec.rb
 - unit/empipelines/io_event_source.dat
 - unit/empipelines/io_event_source_spec.rb
-- unit/empipelines/list_event_source_spec.rb
 - unit/empipelines/message_spec.rb
 - unit/empipelines/periodic_event_source_spec.rb
 - unit/empipelines/pipeline_spec.rb
@@ -68,7 +67,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -530546752871247334
+      hash: 2169333879126328078
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/empipelines/event_handlers.rb

@@ -1,20 +0,0 @@
-module EmPipelines
-  module EventHandlers
-    def on_event(event_handler=nil, &block)
-      @event_handler = block_given? ? block : event_handler
-    end
-
-    def on_finished(batch_finished_handler=nil, &block)
-      @finished_handler = block_given? ? block : batch_finished_handler
-    end
-
-    protected
-    def finished_handler
-      @finished_handler
-    end
-
-    def event_handler
-      @event_handler
-    end
-  end
-end    

data/lib/empipelines/list_event_source.rb

@@ -1,17 +0,0 @@
-module EmPipelines
-  class ListEventSource
-    def initialize(events)
-      @events = events
-    end
-
-    def start!
-      @events.each do |e|
-        @handler.call({:payload => e})
-      end
-    end
-
-    def on_event(&handler)
-      @handler = handler
-    end
-  end
-end

data/unit/empipelines/list_event_source_spec.rb

@@ -1,17 +0,0 @@
-require 'empipelines/list_event_source'
-
-module EmPipelines
-  describe ListEventSource do
-    it 'sends each element of the list to the handler' do
-      items = [1, 2, 3, 4, 5, 6]
-      expected_messages = items.map { |i| {:payload => i} }
-      received_messages = []
-
-      source = ListEventSource.new(items)
-      source.on_event { |msg| received_messages << msg}      
-      source.start!
-
-      received_messages.should eql(expected_messages)    
-    end
-  end  
-end