event_bus 1.0.0 → 1.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f2564b2f02ca631c0946ce255404047cdca69c1
+  data.tar.gz: 513f9d5702367b1d8848aab1fa957a94c6696112
+SHA512:
+  metadata.gz: 743af19ba1318b886d7915ac7a9f04a463a5fdde5c517b619d9104f0b4c082c3389c8e4413521c00cbd8b20b7a18577ceccb770d99aa50ace5347d16ff06cff8
+  data.tar.gz: dc8bb15ce2f0e581332de4dac97d159d4f202633958ab7aefcb1711b3da3ad3ad915a3d389d23441f87634a5e15ba57c2f1f52bad963a1e45f2ee4a79070a256

data/Gemfile

@@ -1,9 +1,2 @@
 source 'https://rubygems.org'
 gemspec
-
-group :test do
-  gem 'rspec', '~> 2.12'
-  gem 'rake', '~> 10.0.1'
-  gem 'simplecov', :require => false
-end
-

data/README.md

@@ -20,6 +20,9 @@ Climate](https://codeclimate.com/github/kevinrutherford/event_bus.png)](https://
 * Subscribe to events using names or regex patterns.
 * Works with Rails.
 * Works without Rails.
+* Completely synchronous (use the
+  [event_bg_bus](https://rubygems.org/gems/event_bg_bus) gem for async operation
+  using Sidekiq).
 
 ## Installation
 
@@ -123,7 +126,7 @@ See the specs for more detailed usage scenarios.
 
 ## Compatibility
 
-Tested with Ruby 1.9.x, JRuby, Rubinius.
+Tested with Ruby 2.1, 2.0, 1.9.x, JRuby.
 See the [build status](https://travis-ci.org/kevinrutherford/event_bus)
 for details.
 

data/lib/event_bus.rb

@@ -68,6 +68,22 @@ class EventBus
 
     alias :listen_for :subscribe
 
+    #
+    # Register a global error handler
+    #
+    # The supplied block will be called once for each error that is raised by
+    # any listener, for any event.
+    #
+    # The block will be provided with two parameters, the listener that errored,
+    # and the payload of the event.
+    #
+    # @param blk the block to be called when any unhandled error occurs in a listener
+    # @return [EventBus] the EventBus, ready to be called again
+    def on_error(&blk)
+      registrations.on_error &blk
+      self
+    end
+
     #
     # Delete all current listener registrations
     #
@@ -78,6 +94,25 @@ class EventBus
       self
     end
 
+    #
+    # Adds a subscriber that only listens for the duration of the block. Mostly
+    # useful for testing event dispatching.
+    #
+    # @param pattern [String, Regexp] listen for any events whose name matches this pattern
+    # @param listener the object to be notified when a matching event occurs
+    # @param method_name [Symbol] the method to be called on +listener+ when a matching event occurs
+    # @return [EventBus] the EventBus, ready to be called again.
+    def with_temporary_subscriber(pattern, listener = nil, method_name = nil)
+      subscribe(pattern, listener, method_name)
+      temporary_subscriber = registrations.last_subscriber
+
+      yield
+
+      self
+    ensure
+      registrations.remove_subscriber(temporary_subscriber)
+    end
+
     private
 
     def subscribe_pattern(pattern, listener, method_name, &blk)

data/lib/event_bus/registrations.rb

@@ -7,41 +7,72 @@ class EventBus
   class Registrations
     include Singleton
 
-    def initialize
-      clear
-    end
-
     def announce(event_name, payload)
       full_payload = {event_name: event_name}.merge(payload)
-      @listeners.each do |listener|
-        listener.respond(event_name, full_payload)
+      listeners.each do |listener|
+        pass_event_to listener, event_name, full_payload
       end
     end
 
     def clear
-      @listeners = []
+      listeners.clear
     end
 
     def add_method(pattern, listener, method_name)
-      @listeners << Registration.new(pattern, listener, method_name)
+      listeners << Registration.new(pattern, listener, method_name)
     end
 
     def add_block(pattern, &blk)
-      @listeners << BlockRegistration.new(pattern, blk)
+      listeners << BlockRegistration.new(pattern, blk)
+    end
+
+    def on_error(&blk)
+      @error_handler = blk
+    end
+
+    def remove_subscriber(subscriber)
+      listeners.delete subscriber
+    end
+
+    def last_subscriber
+      listeners.last
     end
 
     private
+    def listeners
+      @listeners ||= []
+    end
+
+    def error_handler
+      @error_handler
+    end
+
+    def pass_event_to(listener, event_name, payload)
+      begin
+        listener.respond(event_name, payload)
+      rescue => error
+        error_handler.call(listener.receiver, payload.merge(error: error)) if error_handler
+      end
+    end
 
     Registration = Struct.new(:pattern, :listener, :method_name) do
       def respond(event_name, payload)
         listener.send(method_name, payload) if pattern === event_name
       end
+
+      def receiver
+        listener
+      end
     end
 
     BlockRegistration = Struct.new(:pattern, :block) do
       def respond(event_name, payload)
         block.call(payload) if pattern === event_name
       end
+
+      def receiver
+        block
+      end
     end
 
   end

data/spec/lib/event_bus_spec.rb

@@ -1,159 +1,208 @@
 require 'spec_helper'
 
 describe EventBus do
-  let(:listener) { double(:listener) }
-  let(:event_name) { 'aa123bb' }
-  let(:receiving_method) { :receiving_method_name }
+  let(:listener) { double(:listener, handler: true) }
 
   before do
     EventBus.clear
   end
 
-  describe 'publishing' do
+  describe "a temporary subscriber" do
+    context "receives events during the subscription block" do
+      When { EventBus.with_temporary_subscriber(/test/, listener, :handler) { EventBus.publish 'test'} }
+      Then { listener.should have_received(:handler).with(event_name: 'test') }
+    end
 
-    it 'accepts a string for the event name' do
-      EventBus.subscribe(/#{event_name}/, listener, receiving_method)
-      listener.should_receive(receiving_method).with(event_name: event_name)
-      EventBus.publish(event_name)
+    context "does not receive events after the subscription block" do
+      Given { EventBus.with_temporary_subscriber(/test/, listener, :handler) {  } }
+      When { EventBus.publish 'test' }
+      Then { listener.should_not have_received(:handler).with(event_name: 'test') }
     end
 
-    it 'accepts a symbol for the event name' do
-      event_sym = :abc_123
-      EventBus.subscribe(/#{event_sym}/, listener, receiving_method)
-      listener.should_receive(receiving_method).with(event_name: event_sym)
-      EventBus.publish(event_sym)
+
+  end
+
+  describe 'publishing' do
+
+    context 'accepts a string for the event name' do
+      Given { EventBus.subscribe(/aa123bb/, listener, :handler) }
+      When { EventBus.publish('aa123bb') }
+      Then { listener.should have_received(:handler).with(event_name: 'aa123bb') }
     end
 
-    it 'rejects any other type as the event name' do
-      expect { EventBus.publish(123) }.to raise_error(ArgumentError)
+    context 'accepts a symbol for the event name' do
+      Given { EventBus.subscribe(/aa123bb/, listener, :handler) }
+      When { EventBus.publish(:aa123bb) }
+      Then { listener.should have_received(:handler).with(event_name: :aa123bb) }
     end
 
-    it 'returns itself, to facilitate cascades' do
-      EventBus.publish(event_name, {}).should == EventBus
+    context 'rejects any other type as the event name' do
+      When(:result) { EventBus.publish(123) }
+      Then { result.should have_failed(ArgumentError) }
     end
 
-    it 'adds the event name to the payload' do
-      EventBus.subscribe(event_name, listener, receiving_method)
-      listener.should_receive(receiving_method).with(event_name: event_name, a: 56)
-      EventBus.publish(event_name, a: 56)
+    context 'adds the event name to the payload' do
+      Given { EventBus.subscribe('aa123bb', listener, :handler) }
+      When { EventBus.publish('aa123bb', a: 56) }
+      Then { listener.should have_received(:handler).with(event_name: 'aa123bb', a: 56) }
     end
 
-    it 'allows the payload to be omitted' do
-      EventBus.subscribe(event_name, listener, receiving_method)
-      listener.should_receive(receiving_method).with(event_name: event_name)
-      EventBus.publish(event_name)
+    context 'allows the payload to be omitted' do
+      Given { EventBus.subscribe('aa123bb', listener, :handler) }
+      When { EventBus.publish('aa123bb') }
+      Then { listener.should have_received(:handler).with(event_name: 'aa123bb') }
     end
 
   end
 
-  describe 'subscribing' do
+  describe 'publishing with errors' do
+    Given(:error) { RuntimeError.new }
+    Given(:erroring_listener) { double(:erroring_listener) }
+    Given(:error_handler) { double(:error_handler, handle_error: true) }
+    Given { erroring_listener.stub(:handler) { raise error } }
+
+    context 'sends the event to the second listener when the first errors' do
+      Given { EventBus.subscribe('aa123bb', erroring_listener, :handler) }
+      Given { EventBus.subscribe('aa123bb', listener, :handler) }
+      When { EventBus.publish('aa123bb') }
+      Then { listener.should have_received(:handler).with(event_name: 'aa123bb') }
+    end
+
+    context 'with an error handler' do
+      Given { EventBus.on_error do |listener, payload|
+        error_handler.handle_error(listener, payload)
+      end }
+
+      context 'when the listener is an object' do
+        Given { EventBus.subscribe('aa123bb', erroring_listener, :handler) }
+        When { EventBus.publish('aa123bb') }
+        Then { error_handler.should have_received(:handle_error).with(erroring_listener, event_name: 'aa123bb', error: error ) }
+      end
+
+      context 'when the listener is a block' do
+        Given { EventBus.subscribe('aa123bb') {|info| raise error } }
+        When { EventBus.publish('aa123bb') }
+        Then { error_handler.should have_received(:handle_error).with(instance_of(Proc), event_name: 'aa123bb', error: error) }
+      end
 
-    it 'returns itself, to facilitate cascades' do
-      EventBus.subscribe(event_name, listener, receiving_method).should == EventBus
     end
 
+  end
+
+  describe 'subscribing' do
+
     context 'with a regex pattern' do
-      it 'sends the event to a matching listener' do
-        EventBus.subscribe(/123b/, listener, receiving_method)
-        listener.should_receive(receiving_method).with(a: 1, b: 2, event_name: event_name)
-        EventBus.publish(event_name, a: 1, b: 2)
+      context 'sends the event to a matching listener' do
+        Given { EventBus.subscribe(/123b/, listener, :handler) }
+        When { EventBus.publish('aa123bb', a: 1, b: 2) }
+        Then { listener.should have_received(:handler).with(a: 1, b: 2, event_name: 'aa123bb') }
       end
 
-      it 'does not send the event to non-matching listeners' do
-        EventBus.subscribe(/123a/, listener, receiving_method)
-        listener.should_not_receive(receiving_method)
-        EventBus.publish(event_name, a: 1, b: 2, event_name: event_name)
+      context 'does not send the event to non-matching listeners' do
+        Given { EventBus.subscribe(/123a/, listener, :handler) }
+        When { EventBus.publish('aa123bb', a: 1, b: 2, event_name: 'aa123bb') }
+        Then { listener.should_not have_received(:handler) }
       end
     end
 
     context 'with a string pattern' do
-      it 'sends the event to a matching listener' do
-        EventBus.subscribe(event_name, listener, receiving_method)
-        listener.should_receive(receiving_method).with(a: 1, b: 2, event_name: event_name)
-        EventBus.publish(event_name, a: 1, b: 2)
+      context 'sends the event to a matching listener' do
+        Given { EventBus.subscribe('aa123bb', listener, :handler) }
+        When { EventBus.publish('aa123bb', a: 1, b: 2) }
+        Then { listener.should have_received(:handler).with(a: 1, b: 2, event_name: 'aa123bb') }
       end
 
-      it 'does not send the event to non-matching listeners' do
-        EventBus.subscribe('blah', listener, receiving_method)
-        listener.should_not_receive(receiving_method)
-        EventBus.publish(event_name, a: 1, b: 2, event_name: event_name)
+      context 'does not send the event to non-matching listeners' do
+        Given { EventBus.subscribe('blah', listener, :handler) }
+        When { EventBus.publish('aa123bb', a: 1, b: 2, event_name: 'aa123bb') }
+        Then { listener.should_not have_received(:handler) }
       end
     end
 
     context 'with a symbol pattern' do
-      it 'sends the event to a matching listener' do
-        event_name = :abc_123
-        EventBus.subscribe(event_name, listener, receiving_method)
-        listener.should_receive(receiving_method).with(a: 1, b: 2, event_name: event_name)
-        EventBus.publish(event_name, a: 1, b: 2)
+      context 'sends the event to a matching listener' do
+        Given { EventBus.subscribe(:aa123bb, listener, :handler) }
+        When { EventBus.publish(:aa123bb, a: 1, b: 2) }
+        Then { listener.should have_received(:handler).with(a: 1, b: 2, event_name: :aa123bb) }
       end
 
-      it 'does not send the event to non-matching listeners' do
-        EventBus.subscribe(:blah, listener, receiving_method)
-        listener.should_not_receive(receiving_method)
-        EventBus.publish(event_name, a: 1, b: 2, event_name: event_name)
+      context 'does not send the event to non-matching listeners' do
+        Given { EventBus.subscribe(:blah, listener, :handler) }
+        When { EventBus.publish('aa123bb', a: 1, b: 2, event_name: 'aa123bb') }
+        Then { listener.should_not have_received(:handler) }
       end
     end
 
-    context 'with a listener method' do
-      it 'will not accept a block too' do
-        expect { EventBus.subscribe('blah', listener, receiving_method) {|info| }}.to raise_error(ArgumentError)
+    context 'subscribing a block' do
+      Given(:spy) { double(:spy, block_called: nil) }
+      Given {
+        EventBus.subscribe('aa123bb') {|info| spy.block_called(info) }
+      }
+
+      context 'calls the block when the event matches' do
+        When { EventBus.publish('aa123bb', a: 1, b: 2) }
+        Then { spy.should have_received(:block_called).with(a: 1, b: 2, event_name: 'aa123bb') }
       end
 
-      it 'expects a method name' do
-        expect { EventBus.subscribe('blah', listener) }.to raise_error(ArgumentError)
+      context 'does not call the block when the event does not match' do
+        When { EventBus.publish('blah') }
+        Then { spy.should_not have_received(:block_called) }
       end
     end
 
-    context 'with a block' do
-      it 'requires a block when no listener method is supplied' do
-        expect { EventBus.subscribe('blah') }.to raise_error(ArgumentError)
+    context 'with a listener object' do
+      Given { EventBus.subscribe(listener) }
+
+      context 'calls a listener method whose name matches the event name' do
+        When { EventBus.publish('handler', a: 2, b: 3) }
+        Then { listener.should have_received(:handler).with(a: 2, b: 3, event_name: 'handler') }
       end
 
-      it 'calls the block when the event matches' do
-        block_called = false
-        EventBus.subscribe(event_name) do |info|
-          block_called = true
-          info.should == {a: 1, b: 2, event_name: event_name}
-        end
-        EventBus.publish(event_name, a: 1, b: 2)
-        block_called.should be_true
+      context 'calls a listener method with symbol whose name matches the event name' do
+        When { EventBus.publish(:handler, a: 2, b: 3) }
+        Then { listener.should have_received(:handler).with(a: 2, b: 3, event_name: :handler) }
       end
 
-      it 'does not call the block when the event does not match' do
-        block_called = false
-        EventBus.subscribe('blah') {|_| block_called = true }
-        EventBus.publish(event_name)
-        block_called.should be_false
+      context 'calls no method when there is no name match' do
+        When { EventBus.publish('b_method') }
+        Then { listener.should_not have_received(:handler) }
       end
+
     end
 
-    context 'with a listener object' do
+    context 'when called incorrectly' do
 
-      it 'calls a listener method whose name matches the event name' do
-        listener.should_receive(:a_method).with(a: 2, b: 3, event_name: 'a_method')
-        EventBus.subscribe(listener)
-        EventBus.publish('a_method', a: 2, b: 3)
-      end
+      context 'when specifying the event name' do
 
-      it 'calls a listener method with symbol whose name matches the event name' do
-        listener.should_receive(:a_method).with(a: 2, b: 3, event_name: :a_method)
-        EventBus.subscribe(listener)
-        EventBus.publish(:a_method, a: 2, b: 3)
-      end
+        context 'must provide a method or a block' do
+          When(:subscribe) { EventBus.subscribe('blah', listener) }
+          Then { subscribe.should have_failed(ArgumentError) }
+        end
 
-      it 'calls no method when there is no name match' do
-        listener.should_not_receive(:a_method)
-        EventBus.subscribe(listener)
-        EventBus.publish('b_method')
-      end
+        context 'cannot provide a method AND a block' do
+          When(:subscribe) { EventBus.subscribe('blah', listener, :handler) {|info| }}
+          Then { subscribe.should have_failed(ArgumentError) }
+        end
+
+        context 'must provide a block when no method is supplied' do
+          When(:subscribe) { EventBus.subscribe('blah') }
+          Then { subscribe.should have_failed(ArgumentError) }
+        end
 
-      it 'will not accept other arguments' do
-        expect { EventBus.subscribe(listener, double) }.to raise_error(ArgumentError)
       end
 
-      it 'will not accept a block' do
-        expect { EventBus.subscribe(listener) {|info| }}.to raise_error(ArgumentError)
+      context 'when specifying a listener object' do
+
+        context 'when a method is also provided' do
+          When(:subscribe) { EventBus.subscribe(listener, double) }
+          Then { subscribe.should have_failed(ArgumentError) }
+        end
+
+        context 'when a block is also provided' do
+          When(:subscribe) { EventBus.subscribe(listener) {|info| } }
+          Then { subscribe.should have_failed(ArgumentError) }
+        end
+
       end
 
     end
@@ -161,15 +210,35 @@ describe EventBus do
   end
 
   describe '.clear' do
-    it 'removes all previous registrants' do
-      EventBus.subscribe(event_name, listener, receiving_method)
-      EventBus.clear
-      listener.should_not_receive(receiving_method)
-      EventBus.publish(event_name, {})
+    context 'removes all previous registrants' do
+      Given { EventBus.subscribe('aa123bb', listener, :handler) }
+      Given { EventBus.clear }
+      When { EventBus.publish('aa123bb', {}) }
+      Then { listener.should_not have_received(:handler) }
+    end
+
+  end
+
+  context 'EventBus methods cascade' do
+
+    context 'clear' do
+      When(:result) { EventBus.clear }
+      Then { result.should == EventBus }
+    end
+
+    context 'publish' do
+      When(:result) { EventBus.publish('aa123bb', {}) }
+      Then { result.should == EventBus }
+    end
+
+    context 'subscribe' do
+      When(:result) { EventBus.subscribe('aa123bb', listener, :handler) }
+      Then { result.should == EventBus }
     end
 
-    it 'returns itself, to facilitate cascades' do
-      EventBus.clear.should == EventBus
+    context 'with_temporary_subscriber' do
+      When(:result) { EventBus.with_temporary_subscriber('aa123bb', listener, :handler) { } }
+      Then { result.should == EventBus }
     end
   end
 

data/spec/spec_helper.rb

@@ -1,9 +1,6 @@
 require 'rubygems'
 require 'bundler/setup'
-require 'simplecov'
-
-SimpleCov.start
+require 'rspec-spies'
+require 'rspec-given'
 
 require 'event_bus'
-
-

metadata

@@ -1,62 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: event_bus
 version: !ruby/object:Gem::Version
-  version: 1.0.0
-  prerelease: 
+  version: 1.1.1
 platform: ruby
 authors:
 - Kevin Rutherford
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-19 00:00:00.000000000 Z
+date: 2014-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 10.0.1
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
         version: '2.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - '='
       - !ruby/object:Gem::Version
         version: '2.12'
 - !ruby/object:Gem::Dependency
-  name: simplecov
+  name: rspec-given
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-spies
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: event_bus provides support for application-wide events, without coupling
@@ -66,10 +73,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .rspec
-- .yardopts
+- ".rspec"
+- ".yardopts"
 - Gemfile
-- Gemfile.lock
 - README.md
 - Rakefile
 - lib/event_bus.rb
@@ -78,29 +84,27 @@ files:
 - spec/spec_helper.rb
 homepage: http://github.com/kevinrutherford/event_bus
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A simple pubsub event bus for Ruby applications
 test_files:
 - spec/lib/event_bus_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 

data/Gemfile.lock

@@ -1,32 +0,0 @@
-PATH
-  remote: .
-  specs:
-    event_bus (0.1.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    diff-lcs (1.2.3)
-    multi_json (1.7.2)
-    rake (10.0.4)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.1)
-    simplecov (0.7.1)
-      multi_json (~> 1.0)
-      simplecov-html (~> 0.7.1)
-    simplecov-html (0.7.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  event_bus!
-  rake (~> 10.0.1)
-  rspec (~> 2.12)
-  simplecov