empipelines 0.1

data/Gemfile

@@ -0,0 +1,15 @@
+source :gemcutter
+
+gem 'rake'
+gem 'json'
+gem 'eventmachine'
+gem 'em-http-request'
+gem 'amqp'
+
+group :cucumber do
+  gem 'activesupport'
+  gem 'sinatra'
+  gem 'cucumber'
+  gem 'rspec'
+  gem 'bunny'
+end

data/Gemfile.lock

@@ -0,0 +1,69 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activesupport (3.1.3)
+      multi_json (~> 1.0)
+    addressable (2.2.6)
+    amq-client (0.8.7)
+      amq-protocol (>= 0.8.4)
+      eventmachine
+    amq-protocol (0.8.4)
+    amqp (0.8.4)
+      amq-client (~> 0.8.7)
+      amq-protocol (~> 0.8.4)
+      eventmachine
+    builder (3.0.0)
+    bunny (0.7.8)
+    cucumber (1.1.4)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.7.1)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.6)
+    diff-lcs (1.1.3)
+    em-http-request (1.0.0)
+      addressable (>= 2.2.3)
+      em-socksify
+      eventmachine (>= 1.0.0.beta.3)
+      http_parser.rb (>= 0.5.2)
+    em-socksify (0.1.0)
+      eventmachine
+    eventmachine (1.0.0.beta.4)
+    gherkin (2.7.1)
+      json (>= 1.4.6)
+    http_parser.rb (0.5.3)
+    json (1.6.3)
+    multi_json (1.0.4)
+    rack (1.3.5)
+    rack-protection (1.1.4)
+      rack
+    rake (0.9.2.2)
+    rspec (2.7.0)
+      rspec-core (~> 2.7.0)
+      rspec-expectations (~> 2.7.0)
+      rspec-mocks (~> 2.7.0)
+    rspec-core (2.7.1)
+    rspec-expectations (2.7.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.7.0)
+    sinatra (1.3.1)
+      rack (~> 1.3, >= 1.3.4)
+      rack-protection (~> 1.1, >= 1.1.2)
+      tilt (~> 1.3, >= 1.3.3)
+    term-ansicolor (1.0.7)
+    tilt (1.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  amqp
+  bunny
+  cucumber
+  em-http-request
+  eventmachine
+  json
+  rake
+  rspec
+  sinatra

data/README.md

@@ -0,0 +1 @@
+# EM Pipelines

data/Rakefile

@@ -0,0 +1,168 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'cucumber/rake/task'
+require 'rubygems'
+require 'rake'
+require 'date'
+
+#############################################################################
+#
+# Helper functions
+#
+#############################################################################
+
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+def date
+  Date.today.to_s
+end
+
+def rubyforge_project
+  name
+end
+
+def gemspec_file
+  "#{name}.gemspec"
+end
+
+def gemspec
+  @gemspec ||= eval(IO.read(gemspec_file))
+end
+
+def gem_file
+  gemspec.file_name
+end
+
+def replace_header(head, header_name)
+  head.sub!(/(\.#{header_name}\s*= ').*'/) { "#{$1}#{send(header_name)}'"}
+end
+
+#############################################################################
+#
+# Standard tasks
+#
+#############################################################################
+task :default => :pre_checkin
+
+Cucumber::Rake::Task.new(:non_wip_features) do |t|
+  t.cucumber_opts = "--format pretty --tag ~@wip"
+end
+
+Cucumber::Rake::Task.new(:all_features) do |t|
+  t.cucumber_opts = "--format pretty"
+end
+
+desc "Runs specs"
+task :specs do
+  all = FileList['spec/**/*_spec.rb']
+  sh "rspec --color  #{all}"
+end
+
+desc "Resets localhost's rabbitmq"
+task :reset_rabbitmq do
+  sh 'rabbitmqctl stop_app'
+  sh 'rabbitmqctl reset'
+  sh 'rabbitmqctl start_app'
+end
+
+desc "Run cucumber tests for finished features"
+task :features do
+
+end
+
+desc "Run cucumber tests for all features, including work in progress"
+task :all_features do
+  
+end
+
+task :ci => [:specs, :features, :build]
+
+desc "MUST BE RUN (AND PASS!) BEFORE CHECKING IN CODE!"
+task :pre_checkin => [:reset_rabbitmq, :ci]
+
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+
+
+#############################################################################
+#
+# Packaging tasks
+#
+#############################################################################
+
+task :release => :ci do
+  Dir.chdir File.dirname(__FILE__)
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
+  if `git fetch --tags && git tag`.split(/\n/).include?(gem_file)
+    raise "Version #{gem_file} already deployed"
+  end
+  sh <<-END
+    git commit -a --allow-empty -m 'Release #{gem_file}'
+    git tag -a #{gem_file} -m 'Version #{gem_file}'
+    git push origin master
+    git push origin --tags
+  END
+end
+
+desc "Build #{gem_file} into the pkg directory"
+task :build => :gemspec do
+  sh "mkdir -p pkg"
+  sh "gem build #{gemspec_file}"
+  sh "mv #{gem_file} pkg"
+end
+
+desc "Generate #{gemspec_file}"
+task :gemspec => :validate do
+  # read spec file and split out manifest section
+  spec = File.read(gemspec_file)
+  head, manifest, tail = spec.split("  # = MANIFEST =\n")
+
+  # replace name version and date
+  replace_header(head, :name)
+  replace_header(head, :version)
+  replace_header(head, :date)
+  #comment this out if your rubyforge_project has a different name
+  replace_header(head, :rubyforge_project)
+
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").
+    sort.
+    reject { |file| file =~ /^\./ }.
+    reject { |file| file =~ /^(rdoc|pkg)/ }.
+    map { |file| "    #{file}" }.
+    join("\n")
+
+  # piece file back together and write
+  manifest = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = [head, manifest, tail].join("  # = MANIFEST =\n")
+  File.open(gemspec_file, 'w') { |io| io.write(spec) }
+  puts "Updated #{gemspec_file}"
+end
+
+desc "Validate #{gemspec_file}"
+task :validate do
+  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  unless libfiles.empty?
+    puts "Directory `lib` should only contain a `#{name}.rb` file and `#{name}` dir."
+    exit!
+  end
+  unless Dir['VERSION*'].empty?
+    puts "A `VERSION` file at root level violates Gem best practices."
+    exit!
+  end
+end

data/empipelines.gemspec

@@ -0,0 +1,61 @@
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  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.1'
+  s.date              = '2011-12-19'
+  s.rubyforge_project = 'empipelines'
+
+  s.summary           = "Simple Event Handling Pipeline Architecture for EventMachine"
+  s.description       = "Simple Event Handling Pipeline Architecture for EventMachine"
+
+  s.authors           = ["Tobias Schmidt", "Phil Calcado"]
+  s.email             = 'pcalcado+empipelines@gmail.com'
+  s.homepage          = 'http://github.com/pcalcado/empipelines'
+
+  s.require_paths = %w[lib]
+  #s.executables = ["empipelines"]
+  #s.default_executable = 'empipelines'
+
+  ## Specify any RDoc options here.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md]
+
+  ## List your runtime dependencies here.
+  #s.add_dependency('DEPNAME', [">= 1.1.0", "< 2.0.0"])
+  #s.add_development_dependency('bacon', [">= 1.1.0])
+  #s.add_development_dependency('rspec', [">= 1.3.0"])
+
+  ## DO NOT REMOVE THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    Gemfile.lock
+    README.md
+    Rakefile
+    empipelines.gemspec
+    lib/empipelines.rb
+    lib/empipelines/amqp_event_source.rb
+    lib/empipelines/batch_event_source.rb
+    lib/empipelines/event_pipeline.rb
+    lib/empipelines/list_event_source.rb
+    lib/empipelines/message.rb
+    lib/empipelines/periodic_event_source.rb
+    lib/empipelines/pipeline.rb
+    spec/empipelines/amqp_event_source_spec.rb
+    spec/empipelines/batch_event_source_spec.rb
+    spec/empipelines/event_pipeline_spec.rb
+    spec/empipelines/list_event_source_spec.rb
+    spec/empipelines/message_spec.rb
+    spec/empipelines/periodic_event_source_spec.rb
+    spec/empipelines/pipeline_spec.rb
+    spec/spec_helper.rb
+    spec/stage_helper.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list.
+  s.test_files = s.files.select { |path| path =~ /^spec\/*_spec\.rb/ }
+end

data/lib/empipelines/amqp_event_source.rb

@@ -0,0 +1,25 @@
+require 'json'
+
+module Pipelines
+  class AmqpEventSource
+    def initialize(queue, event_name)
+      @queue, @event_name = queue, event_name
+    end
+
+    def on_event(&handler)
+      @handler = handler
+    end
+
+    def start!
+      @queue.subscribe do |header, json_payload|
+        message = Message.new ({
+                                :header     => header,
+                                :payload    => JSON.parse(json_payload),
+                                :event      => @event_name,
+                                :started_at => Time.now.to_i
+                                })
+        @handler.call(message)
+      end
+    end
+  end
+end

data/lib/empipelines/batch_event_source.rb

@@ -0,0 +1,44 @@
+module Pipelines
+  class BatchEventSource
+    def initialize(em, events)
+      @em, @events = em, events
+    end
+
+    def on_event(&handler)
+      @handler = handler
+    end
+
+    def on_batch_finished(&batch_finished_handler)
+      @batch_finished_handler = batch_finished_handler
+    end
+
+    def start!
+      @finalised = []
+      check_if_finished
+
+      message_finished = lambda do |m|
+        @finalised << m
+        check_if_finished
+      end
+
+      @events.each do |e|
+        message = Message.new({:payload => e})
+
+        message.on_rejected_broken(message_finished)
+        message.on_rejected(message_finished)
+        message.on_consumed(message_finished)
+
+        @handler.call(message)
+      end
+    end
+
+    private
+    def check_if_finished
+      finished = (@finalised.size == @events.size)
+
+      if finished and @batch_finished_handler
+        @em.next_tick { @batch_finished_handler.call(@finalised) }
+      end
+    end
+  end
+end

data/lib/empipelines/event_pipeline.rb

@@ -0,0 +1,15 @@
+module Pipelines
+  class EventPipeline
+    def initialize(source, pipeline, monitoring)
+      @source, @pipeline, @monitoring = source, pipeline, monitoring
+
+      @source.on_event do |event_data|
+        @pipeline.notify(event_data)
+      end
+    end
+
+    def start!
+      @source.start!
+    end
+  end
+end

data/lib/empipelines/list_event_source.rb

@@ -0,0 +1,17 @@
+module Pipelines
+  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/lib/empipelines/message.rb

@@ -0,0 +1,90 @@
+module Pipelines
+  class Message
+    def initialize(base_hash={})
+      hash!(base_hash)
+      created!
+    end
+
+    def [](key)
+      hash[key]
+    end
+
+    def []=(key, value)
+      check_if_mutation_allowed
+      hash[key] = value
+    end
+
+    def delete(key)
+      check_if_mutation_allowed
+      hash.delete key
+    end
+
+    def merge(other_hash)
+      check_if_mutation_allowed
+      Message.new(hash.merge(other_hash))
+    end
+
+    def on_consumed(callback=nil, &callback_block)
+      @consumed_callback = block_given? ? callback_block : callback
+    end
+
+    def on_rejected(callback=nil, &callback_block)
+      @rejected_callback = block_given? ? callback_block : callback
+    end
+    
+    def on_rejected_broken(callback=nil, &callback_block)
+      @rejected_broken_callback = block_given? ? callback_block : callback
+    end
+
+    def consumed!
+      check_if_mutation_allowed
+      @state = :consumed
+      invoke(@consumed_callback)
+    end
+
+    def rejected!
+      check_if_mutation_allowed
+      @state = :rejected
+      invoke(@rejected_callback)
+    end
+    
+    def broken!
+      check_if_mutation_allowed
+      @state = :rejected_broken
+      invoke(@rejected_broken_callback)
+    end
+
+    def hash
+      @backing_hash
+    end
+    
+    def to_s
+      "#{self.class.name} state:#{@state} hash:#{hash}"
+    end
+
+    private
+
+    def 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
+      end
+    end
+
+    def created!
+      @state = :created
+    end
+    
+    def check_if_mutation_allowed
+      raise "Cannot mutate #{self}" unless @state == :created
+    end
+    
+    def invoke(callback)
+      callback.call(self) if callback
+    end
+  end
+end

data/lib/empipelines/periodic_event_source.rb

@@ -0,0 +1,24 @@
+module Pipelines
+  class PeriodicEventSource
+    def initialize(em, interval_in_secs, &event_sourcing_code)
+      @em, @interval_in_secs, @event_sourcing_code = em, interval_in_secs, event_sourcing_code
+    end
+
+    def start!
+      event_sourcing_code = @event_sourcing_code
+
+      @em.add_periodic_timer(@interval_in_secs) do
+        tick!
+      end
+    end
+
+    def on_event(&handler)
+      @handler = handler
+    end
+
+    def tick!      
+      event = @event_sourcing_code.call
+      @handler.call(event) if event
+    end
+  end
+end

data/lib/empipelines/pipeline.rb

@@ -0,0 +1,50 @@
+module Pipelines
+  class Pipeline
+    class TerminatorStage
+      def self.notify(ignored, also_ignored = {})
+        #noop
+      end
+    end
+    
+    def initialize(spawner, context, monitoring, logger)
+      @spawner = spawner
+      @logger = logger
+      @context = context
+      @monitoring = monitoring
+    end
+    
+    def for(event_definition)
+      stages = event_definition.map(&instantiate_with_dependencies)
+
+      monitoring = @monitoring
+      logger = @logger
+      
+      first_stage_process = stages.reverse.reduce(TerminatorStage) do |current_head, next_stage|
+        @spawner.spawn do |input|
+          begin
+            logger.debug "#{next_stage.class}#notify with #{input}}"
+            next_stage.call(input) do |output|
+              current_head.notify(output)
+            end
+          rescue => exception
+            monitoring.inform_exception!(exception, next_stage)
+          end
+        end        
+      end
+      
+      @logger.info "Pipeline for event_definition is: #{stages.map(&:class).join('->')}"    
+      first_stage_process
+    end
+    
+    private
+    def instantiate_with_dependencies
+      lambda do |stage_class|
+        stage_instance = stage_class.new
+        @context.each do |name, value|
+          stage_instance.define_singleton_method(name) { value }
+        end
+        stage_instance
+      end
+    end
+  end
+end

data/lib/empipelines.rb

@@ -0,0 +1,3 @@
+module empipelines
+  VERSION = '0.1'
+end

data/spec/empipelines/amqp_event_source_spec.rb

@@ -0,0 +1,36 @@
+require 'empipelines/amqp_event_source'
+
+module Pipelines
+  class StubQueue
+    def subscribe(&code)
+      @code = code
+    end
+
+    def publish(header, payload)
+      @code.call(header,  payload)
+    end
+  end
+  
+  describe AmqpEventSource do
+    it "adds payload, time and event type to message and sends to listener" do
+      json_payload = '{"key":"value"}'
+      queue = StubQueue.new
+      event_type = "NuclearWar"
+      header = stub('header')
+
+      received_messages = []
+      
+      amqp_source = AmqpEventSource.new(queue, event_type)
+      amqp_source.on_event { |e| received_messages << e }
+      amqp_source.start!
+
+      queue.publish(header, json_payload)
+
+      received_messages.size.should eql(1)
+      received_messages.first[:header].should ==(header)
+      received_messages.first[:payload].should ==({:key => "value"})
+      received_messages.first[:event].should ==(event_type)
+      received_messages.first[:started_at].should_not be_nil
+    end
+  end
+end

data/spec/empipelines/batch_event_source_spec.rb

@@ -0,0 +1,78 @@
+require 'empipelines/batch_event_source'
+
+module Pipelines
+  describe BatchEventSource do
+
+    let (:em) do
+      em = mock('eventmachine')
+      em.stub(:next_tick).and_yield
+      em
+    end
+
+    it "sends each element on the list as a payload to the listener" do
+      events = [1,2,3,4,5,6,7,8,9,10]
+      source = BatchEventSource.new(em, events)
+
+      received = []
+      source.on_event do |e|
+        received << e
+      end
+
+      source.start!
+
+      received.map{ |i| i[:payload] }.should ==(events)
+    end
+
+    it "calls the batch finished callback when all items were processed" do
+      events = [1,2,3,4,5,6,7,8,9,10]
+      source = BatchEventSource.new(em, events)
+
+      has_finished = []
+
+      source.on_batch_finished do |messages|
+        has_finished << messages
+      end
+
+      source.on_event do |e|
+        e.consumed!
+      end
+
+      source.start!
+
+      has_finished.first.map{ |i| i[:payload] }.should ==(events)
+    end
+
+    it "finishes straight away if there are no events to process" do
+      source = BatchEventSource.new(em, [])
+
+      has_finished = []
+      source.on_batch_finished do |messages|
+        has_finished << true
+      end
+
+      source.on_event do |e|
+        raise 'should not be called!'
+      end
+
+      source.start!
+
+      has_finished.first.should be_true
+    end
+
+    it "does not call the batch finished callback if not all of the  items were processed" do
+      events = [1,2,3,4,5,6,7,8,9,10]
+      source = BatchEventSource.new(em, events)
+
+      source.on_batch_finished do |messages|
+        raise "should not be called"
+      end
+
+      count = 0
+      source.on_event do |e|
+        e.consumed! if (count=+1) > 1
+      end
+
+      source.start!
+    end
+  end
+end

data/spec/empipelines/event_pipeline_spec.rb

@@ -0,0 +1,31 @@
+require 'empipelines/event_pipeline'
+
+module Pipelines
+  class StubSource
+    def initialize(event_data)
+      @event_data = event_data
+    end
+    
+    def start!
+      @handler.call(@event_data)
+    end
+
+    def on_event(&event_handler)
+      @handler = event_handler
+    end    
+  end
+  
+  describe EventPipeline do
+    it "binds a source to a pipeline" do
+      monitoring = stub(:increment => nil)
+      event = stub('event')
+      pipeline = stub('processing pipeline')
+      source = StubSource.new(event)
+
+      pipeline.should_receive(:notify).with(event)
+      
+      event_pipeline = EventPipeline.new(source, pipeline, monitoring)
+      event_pipeline.start!
+    end
+  end
+end

data/spec/empipelines/list_event_source_spec.rb

@@ -0,0 +1,17 @@
+require 'empipelines/list_event_source'
+
+module Pipelines
+  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

data/spec/empipelines/message_spec.rb

@@ -0,0 +1,138 @@
+require 'empipelines/message'
+
+module Pipelines
+  describe Message 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)
+
+        message[:a].should ==(original_hash[:a])
+        message[:b].should ==(original_hash[:b])
+        message[:doesntexist].should ==(original_hash[:doesntexist])
+      end
+
+      it "symbolises keys of all maps in the message" do
+        message = Message.new({
+                                :a => 1,
+                                "b" => 2,
+                                3 => 3 ,
+                                "d" => {
+                                  "d1" => {"e" => 5},
+                                  "d2" => nil}
+                              })
+        message[:a].should ==(1)
+        message[:b].should ==(2)
+        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
+        original_hash = {:a => 1, :b => 2, :c => 0}
+
+        message = Message.new(original_hash)
+
+        message[:a] = 666
+        message.delete :b
+        message[:z] = 999
+
+        message[:a].should ==(666)
+        message[:b].should be_nil
+        message[:c].should ==(original_hash[:c])
+        message[:z].should ==(999)      
+      end
+
+      it "can be merged with a map, symbolising keys" do
+        original = Message.new({'a' => 1})
+        merged = original.merge({'b' => 2})
+
+        original[:b].should be_nil
+        
+        merged[:a].should ==(original[:a])
+        merged[:b].should_not be_nil
+      end
+    end
+
+    context "message status" do
+
+      let (:handler_that_should_never_be_called) { lambda { raise "This shouldnt happen"  } }
+
+      it "doesnt do anything if no state callback specified" do
+        Message.new.consumed!
+        Message.new.rejected!
+        Message.new.broken!        
+      end
+
+      it "is possible to reject a message if broken"do
+        called = []
+        
+        message = Message.new        
+        message.on_rejected_broken  do |msg|
+          called << msg
+        end
+        
+        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
+        called = []
+        
+        message = Message.new        
+        message.on_rejected  do |msg|
+          called << msg
+        end
+        
+        message.on_rejected_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
+        called = []
+        
+        message = Message.new        
+        message.on_consumed do |msg|
+          called << msg
+        end
+        
+        message.on_rejected_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
+        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!
+
+        lambda{ read.call(consumed) }.should_not raise_error
+        lambda{ mutate.call(consumed) }.should raise_error
+        lambda{ read.call(rejected) }.should_not raise_error
+        lambda{ mutate.call(rejected) }.should raise_error
+        lambda{ read.call(broken) }.should_not raise_error
+        lambda{ mutate.call(broken) }.should raise_error
+      end
+    end
+  end
+end

data/spec/empipelines/periodic_event_source_spec.rb

@@ -0,0 +1,28 @@
+require 'empipelines/periodic_event_source'
+
+module Pipelines
+  describe PeriodicEventSource do
+    it 'schedules itself with eventmachine' do
+      em = stub('eventmachine')
+      em.should_receive(:add_periodic_timer).with(5)
+      PeriodicEventSource.new(em, 5){ "something cool!" }.start!
+    end
+    
+    it 'sends the result of the periodic action to the handler' do
+      expected_message = { :something => "goes here" }
+      received_messages = []
+
+      source = PeriodicEventSource.new(stub('eventmachine'), 666){ expected_message }
+      source.on_event { |msg| received_messages << msg}      
+      source.tick!
+
+      received_messages.should eql([expected_message])      
+    end
+    
+    it 'doesnt o anything if no event was generated' do      
+      source = PeriodicEventSource.new(stub('eventmachine'), 666){ nil }
+      source.on_event { |m| raise "should not be called" }      
+      source.tick!
+    end
+  end  
+end

data/spec/empipelines/pipeline_spec.rb

@@ -0,0 +1,106 @@
+require "empipelines/pipeline"
+
+module Pipelines
+  class AddOne
+    def call(input, &next_stage)
+      next_stage.call({:data => (input[:data] + 1)})
+    end
+  end
+
+  class SquareIt
+    def call(input, &next_stage)
+      next_stage.call({:data => (input[:data] * input[:data])})
+    end
+  end
+
+  class BrokenStage
+    def call(ignore, &ignored_too)
+      raise "Boo!"
+    end
+  end
+
+  class DeadEnd
+    def call(input, &also_ignore)
+      #noop
+    end
+  end
+
+  class NeedsAnApple
+    def call(input, &next_stage)
+      next_stage.call(input.merge({:apple => apple}))
+    end
+  end
+
+  class NeedsAnOrange
+    def call(input, &next_stage)
+      next_stage.call(input.merge({:orange => orange}))
+    end
+  end
+  
+  class GlobalHolder
+    @@value = nil
+    def GlobalHolder.held
+      @@value
+    end
+
+    def initialize
+      @@value = nil
+    end
+    
+    def call(input, &next_step)
+      @@value = input
+      next_step.call(self.class)
+    end
+  end
+
+  class StubSpawner
+    
+    class StubProcess
+      def initialize(block)
+        @block = block
+      end
+      
+      def notify(input)
+        @block.call(input)
+      end
+    end
+    
+    def spawn(&block)
+      StubProcess.new(block)
+    end
+  end
+
+  describe Pipeline do
+    let(:logger) {stub(:info => true, :debug => true)}
+    it "chains the actions using processes" do
+      event_chain = [AddOne, SquareIt, GlobalHolder]
+      pipelines = Pipeline.new(StubSpawner.new, {}, stub('monitoring'), logger)
+      pipeline = pipelines.for(event_chain)
+      pipeline.notify({:data =>1})
+      GlobalHolder.held.should eql({:data => 4})
+    end
+
+    it "does not send to the next if last returned nil" do
+      event_chain = [AddOne, SquareIt, DeadEnd, GlobalHolder]
+      pipelines = Pipeline.new(StubSpawner.new, {}, stub('monitoring'), logger)
+      pipeline = pipelines.for(event_chain)
+      pipeline.notify({:data => 1})
+      GlobalHolder.held.should be_nil
+    end
+
+    it "makes all objects in the context object available to stages" do
+      event_chain = [NeedsAnApple, NeedsAnOrange, GlobalHolder]
+      pipelines = Pipeline.new(StubSpawner.new, {:apple => :some_apple, :orange => :some_orange}, stub('monitoring'), logger)
+      pipeline = pipelines.for(event_chain)
+      pipeline.notify({})
+      GlobalHolder.held.should eql({:apple => :some_apple, :orange => :some_orange})
+    end
+
+    it "sends exception to the proper handler" do
+      monitoring = mock()
+      monitoring.should_receive(:inform_exception!)
+      pipeline = Pipeline.new(StubSpawner.new, {}, monitoring, logger)
+      pipeline.for([BrokenStage]).notify({})
+    end
+  end
+end

data/spec/stage_helper.rb

@@ -0,0 +1,54 @@
+def request(path = path)
+  responses = []
+  described_class.request(path) { |response| responses << response }
+  responses
+end
+
+def process(message = message, stage_class = described_class)
+  messages = []
+  stage_instance = stage_class.new
+
+  #TODO: should this be here? Is there an easy way?
+  context.each {|k,v| stage_instance.define_singleton_method(k) {v} }
+
+  stage_instance.call(message) { |message| messages << message }
+  messages
+end
+
+RSpec::Matchers.define :return_response do |expected|
+  match do |responses|
+    responses.include?(expected)
+  end
+end
+
+RSpec::Matchers.define :return_any_response do |expected|
+  match do |responses|
+    responses.any?
+  end
+end
+
+RSpec::Matchers.define :send_messages_including do |expected|
+  match do |messages|
+    messages.any? do |message|
+      expected.all? do |key, value|
+        message[key] == value
+      end
+    end
+  end
+end
+
+RSpec::Matchers.define :send_some_message do |expected|
+  match do |messages|
+    messages.any?
+  end
+end
+
+RSpec::Matchers.define :send_no_message do |expected|
+  match do |messages|
+    messages.empty?
+  end
+end
+
+RSpec::Matchers.define :send_message do |expected|
+  match { |messages| messages.include?(expected) }
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: empipelines
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Tobias Schmidt
+- Phil Calcado
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-19 00:00:00.000000000Z
+dependencies: []
+description: Simple Event Handling Pipeline Architecture for EventMachine
+email: pcalcado+empipelines@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- empipelines.gemspec
+- lib/empipelines.rb
+- lib/empipelines/amqp_event_source.rb
+- lib/empipelines/batch_event_source.rb
+- lib/empipelines/event_pipeline.rb
+- lib/empipelines/list_event_source.rb
+- lib/empipelines/message.rb
+- lib/empipelines/periodic_event_source.rb
+- lib/empipelines/pipeline.rb
+- spec/empipelines/amqp_event_source_spec.rb
+- spec/empipelines/batch_event_source_spec.rb
+- spec/empipelines/event_pipeline_spec.rb
+- spec/empipelines/list_event_source_spec.rb
+- spec/empipelines/message_spec.rb
+- spec/empipelines/periodic_event_source_spec.rb
+- spec/empipelines/pipeline_spec.rb
+- spec/spec_helper.rb
+- spec/stage_helper.rb
+homepage: http://github.com/pcalcado/empipelines
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -303490141068781308
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: empipelines
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 2
+summary: Simple Event Handling Pipeline Architecture for EventMachine
+test_files: []