Merge branch 'master' into mongo_driver

.travis.yml

@@ -1,8 +1,7 @@
 rvm:
   - 1.9.2
   - 1.9.3
-  - ruby-head
   - 1.8.7
   - ree
 env:
-  - SLEEP_FACTOR=5
+  - SLEEP_FACTOR=8

lib/eventwire.rb

@@ -2,28 +2,35 @@
 require 'eventwire/publisher'
 require 'eventwire/subscriber'
 require 'eventwire/drivers'
+require 'eventwire/middleware'
 
 module Eventwire
 
   class << self
 
+    def reset!
+      @driver = nil
+      @middleware = nil
+      @logger = nil
+    end
+
     def driver
-      @driver ||= Drivers::InProcess.new
+      @driver ||= decorate(Drivers::InProcess.new)
     end
 
     def driver=(driver)
       klass = Drivers.const_get(driver.to_sym) if driver.respond_to?(:to_sym)
-      @driver = klass ? klass.new : driver
+      @driver = decorate(klass ? klass.new : driver)
+    end
+
+    def logger
+      @logger ||= Logger.new(nil)
     end
 
     def logger=(logger)
       @logger = logger
     end
 
-    def logger
-      @logger ||= Logger.new(nil)
-    end
-
     def start_worker
       driver.start
     end
@@ -35,30 +42,40 @@ def stop_worker
     def on_error(&block)
       @error_handler = block
     end
+
+    def error_handler
+      @error_handler ||= lambda {|ex|}
+    end
 
     def publish(event_name, event_data = nil)
       driver.publish event_name, event_data
       logger.info "Event published `#{event_name}` with data `#{event_data.inspect}`"
     end
-
+    
     def subscribe(event_name, handler_id, &handler)
-      driver.subscribe event_name, handler_id do |data|
-        begin
-          logger.info "Starting to process `#{event_name}` with handler `#{handler_id}` and data `#{data.inspect}`"
-          handler.call build_event(data) 
-        rescue Exception => ex
-          logger.error "\nAn error occurred: `#{ex.message}`\n#{ex.backtrace.join("\n")}\n"
-          @error_handler.call(ex) if @error_handler
-        ensure
-          logger.info "End processing `task_completed`"
-        end
+      Eventwire.driver.subscribe event_name, handler_id, &handler
+    end
+
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def method_missing(meth, *args, &blk)
+        @app.send(meth, *args, &blk)
       end
     end
 
-    private
-
-    def build_event(data)
-      data && Struct.new(*data.keys.map(&:to_sym)).new(*data.values)
+    def middleware
+      @middleware ||= [ Eventwire::Middleware::ErrorHandler, 
+                        Eventwire::Middleware::Logger, 
+                        Eventwire::Middleware::DataObjects ]
+    end
+
+    def decorate(driver)
+      middleware.inject(driver) do |driver, klass|
+        klass.new(driver)
+      end
     end
 
   end

lib/eventwire/middleware.rb

@@ -0,0 +1,9 @@
+module Eventwire
+  module Middleware
+    autoload :Base, 'eventwire/middleware/base'
+
+    autoload :Logger,       'eventwire/middleware/logger'
+    autoload :ErrorHandler, 'eventwire/middleware/error_handler'
+    autoload :DataObjects,  'eventwire/middleware/data_objects'
+  end
+end

lib/eventwire/middleware/base.rb

@@ -0,0 +1,13 @@
+module Eventwire
+  module Middleware
+    class Base
+      def initialize(app)
+        @app = app
+      end
+
+      def method_missing(meth, *args, &blk)
+        @app.send(meth, *args, &blk)
+      end
+    end
+  end
+end

lib/eventwire/middleware/data_objects.rb

@@ -0,0 +1,17 @@
+module Eventwire
+  module Middleware
+    class DataObjects < Base
+      def subscribe(event_name, handler_id, &handler)
+        @app.subscribe event_name, handler_id do |data|
+          handler.call build_event(data)
+        end
+      end
+
+      private
+
+      def build_event(data)
+        data && Struct.new(*data.keys.map(&:to_sym)).new(*data.values)
+      end
+    end
+  end
+end

lib/eventwire/middleware/error_handler.rb

@@ -0,0 +1,16 @@
+module Eventwire
+  module Middleware
+    class ErrorHandler < Base
+      def subscribe(event_name, handler_id, &handler)
+        @app.subscribe event_name, handler_id do |data|
+          begin
+            handler.call(data)
+          rescue Exception => ex
+            Eventwire.logger.error "\nAn error occurred: `#{ex.message}`\n#{ex.backtrace.join("\n")}\n"
+            Eventwire.error_handler.call(ex)
+          end
+        end
+      end
+    end
+  end
+end

lib/eventwire/middleware/logger.rb

@@ -0,0 +1,18 @@
+module Eventwire
+  module Middleware
+    class Logger < Base  
+
+      def subscribe(event_name, handler_id, &handler)
+        @app.subscribe event_name, handler_id do |data|
+          begin
+            Eventwire.logger.info "Starting to process `#{event_name}` with handler `#{handler_id}` and data `#{data.inspect}`"
+            handler.call data
+          ensure
+            Eventwire.logger.info "End processing `#{event_name}`"
+          end
+        end
+      end
+
+    end
+  end
+end

lib/eventwire/subscriber/data.rb

@@ -0,0 +1,19 @@
+module Eventwire
+  module Subscriber
+    class Data
+      def initialize(handler, event_name, handler_id)
+        @handler = handler
+      end
+
+      def call(data)
+        @handler.call(build_event(data))
+      end
+
+      private
+
+      def build_event(data)
+        data && Struct.new(*data.keys.map(&:to_sym)).new(*data.values)
+      end
+    end
+  end
+end

lib/eventwire/subscriber/errors.rb

@@ -0,0 +1,18 @@
+module Eventwire
+  module Subscriber
+    class Errors
+      def initialize(handler, event_name, handler_id)
+        @handler = handler
+      end
+
+      def call(data)
+        begin
+          @handler.call(data)
+        rescue Exception => ex
+          Eventwire.logger.error "\nAn error occurred: `#{ex.message}`\n#{ex.backtrace.join("\n")}\n"
+          Eventwire.error_handler.call(ex)
+        end
+      end
+    end
+  end
+end

lib/eventwire/subscriber/log.rb

@@ -0,0 +1,20 @@
+module Eventwire
+  module Subscriber
+    class Log
+      def initialize(handler, event_name, handler_id)
+        @handler = handler
+        @event_name = event_name
+        @handler_id = handler_id
+      end
+
+      def call(data)
+        begin
+          Eventwire.logger.info "Starting to process `#{@event_name}` with handler `#{@handler_id}` and data `#{data.inspect}`"
+          @handler.call(data)
+        ensure
+          Eventwire.logger.info "End processing `#{@event_name}`"
+        end
+      end
+    end
+  end
+end

spec/unit/drivers/amqp_spec.rb → spec/integration/drivers/amqp_spec.rb

@@ -1,4 +1,4 @@
-require 'unit/drivers/drivers_helper'
+require 'integration/drivers/drivers_helper'
 
 describe Eventwire::Drivers::AMQP do
   it_should_behave_like 'a driver with single-process support'

spec/unit/drivers/bunny_spec.rb → spec/integration/drivers/bunny_spec.rb

@@ -1,4 +1,4 @@
-require 'unit/drivers/drivers_helper'
+require 'integration/drivers/drivers_helper'
 
 describe Eventwire::Drivers::Bunny do
   it_should_behave_like 'a driver with single-process support'

spec/unit/drivers/in_process_spec.rb → spec/integration/drivers/in_process_spec.rb

@@ -1,4 +1,4 @@
-require 'unit/drivers/drivers_helper'
+require 'integration/drivers/drivers_helper'
 
 describe Eventwire::Drivers::InProcess do
   it_should_behave_like 'a driver with single-process support'

spec/unit/drivers/redis_spec.rb → spec/integration/drivers/redis_spec.rb

@@ -1,4 +1,4 @@
-require 'unit/drivers/drivers_helper'
+require 'integration/drivers/drivers_helper'
 
 describe Eventwire::Drivers::Redis do
   it_should_behave_like 'a driver with single-process support'

spec/unit/drivers/zero_spec.rb → spec/integration/drivers/zero_spec.rb

@@ -1,4 +1,4 @@
-require 'unit/drivers/drivers_helper'
+require 'integration/drivers/drivers_helper'
 
 unless ENV['TRAVIS']
 

spec/spec_helper.rb

@@ -37,7 +37,7 @@ def sleep(time)
   config.include Helpers
 
   config.after do
-    Eventwire.driver = nil
+    Eventwire.reset!
   end
 end
 

spec/unit/configuration_spec.rb

@@ -2,19 +2,55 @@
 
 describe 'Eventwire configuration' do
   describe 'driver' do
+    before do
+      Eventwire.middleware.clear
+    end
+
     it 'is InProcess by default' do
       Eventwire.driver.should be_an_instance_of(Eventwire::Drivers::InProcess)
     end
 
     it 'can be changed to other driver given an instance of it' do
-      driver = Eventwire::Drivers::Redis.new
+      driver = Object.new
+
       Eventwire.driver = driver
+
       Eventwire.driver.should == driver
     end
 
     it 'can be changed to other driver given its name' do
-      Eventwire.driver = :Redis
-      Eventwire.driver.should be_an_instance_of(Eventwire::Drivers::Redis)
+      Eventwire::Drivers::AwesomeDriver = Class.new
+
+      Eventwire.driver = :AwesomeDriver
+
+      Eventwire.driver.should be_an_instance_of(Eventwire::Drivers::AwesomeDriver)
+    end
+
+    context 'driver decoration' do
+
+      it 'decorates the driver with one middleware' do
+        middleware = Struct.new(:app)
+        driver = Object.new
+
+        Eventwire.middleware.replace [middleware]
+        Eventwire.driver = driver
+
+        Eventwire.driver.should be_an_instance_of(middleware)
+        Eventwire.driver.app.should be(driver)
+      end
+
+      it 'decorates the driver with more than one middlewares' do
+        middleware1 = Struct.new(:app)
+        middleware2 = Struct.new(:app)
+        driver = Object.new
+
+        Eventwire.middleware.replace [middleware1, middleware2]
+        Eventwire.driver = driver
+
+        Eventwire.driver.should be_an_instance_of(middleware2)
+        Eventwire.driver.app.should be_an_instance_of(middleware1)
+        Eventwire.driver.app.app.should be(driver)
+      end
     end
-  end
+  end  
 end

spec/unit/middleware/data_objects_spec.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Eventwire::Middleware::DataObjects do
+  let(:app) { mock }
+  subject { Eventwire::Middleware::DataObjects.new(app) }
+
+  describe 'subscribe' do
+    it 'should call app’s subscribe' do
+      app.should_receive(:subscribe).with(:event_name, :handler_id)
+
+      subject.subscribe(:event_name, :handler_id)
+    end
+
+    it 'should make the handler build an event object' do
+      app.stub :subscribe do |_, _, handler|
+        handler.call(:task_name => 'Cleaning')
+        handler.call('task_name' => 'Cleaning')
+      end
+
+      subject.subscribe :event_name, :handler_id do |data|
+        data.task_name.should == 'Cleaning'
+      end
+    end
+  end
+end