has-guarded-handlers 1.5.0 → 1.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d854e0cfdde0b22903dbdf262be0270d1667eff
+  data.tar.gz: a76bbebebf714923e14fa877eb3d7386d73c2ff7
+SHA512:
+  metadata.gz: 8ded65f328d1a8bbfcf0b0b8c3a9bcc45b0906989513f724ffbc8fed534732a60ea0431e06f3e4d5b50c01dac226b24a8e7b8d7bbbeb5f6d3536b3c291a2e2b7
+  data.tar.gz: 2427d889bf1d2032bbfebd1de4f7dfa8e4c28493434d488d7d39004f5d855ffef9c3648dc4ef79e97695ea3f7b9c41ece0cdd9cff7a8b3bffb7d357befafd9b8

data/.travis.yml

@@ -1,9 +1,14 @@
 language: ruby
 rvm:
-  - 1.9.2
   - 1.9.3
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-19mode # currently in active development, may or may not work for your project
-  # - ruby-head
+  - 2.0.0
+  - 2.1.0
+  - jruby-19mode
+  - rbx-2.1.1
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: rbx-2.1.1
+    - rvm: ruby-head
 notifications:
   irc: "irc.freenode.org#adhearsion"

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # [develop](https://github.com/adhearsion/has-guarded-handlers)
 
+# [1.6.0](https://github.com/adhearsion/has-guarded-handlers/compare/v1.5.0...v1.6.0) - [2014-01-16](https://rubygems.org/gems/has-guarded-handlers/versions/1.6.0)
+  * Feature: Add a broadcast mode to handler triggering, which ignores what happens in handlers (return value and exceptions) and unconditionally continues the handler chain.
+
 # [1.5.0](https://github.com/adhearsion/has-guarded-handlers/compare/v1.4.2...v1.5.0) - [2012-12-08](https://rubygems.org/gems/has-guarded-handlers/versions/1.5.0)
   * Bugfix: Correct API preservation from previous release
 

data/has-guarded-handlers.gemspec

@@ -20,7 +20,6 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'bundler', ["~> 1.0"]
   s.add_development_dependency 'rspec', [">= 2.5.0"]
-  s.add_development_dependency 'mocha', [">= 0"]
   s.add_development_dependency 'ci_reporter', [">= 1.6.3"]
   s.add_development_dependency 'yard', [">= 0.7.0"]
   s.add_development_dependency 'rake', [">= 0"]

data/lib/has_guarded_handlers.rb

@@ -77,8 +77,12 @@ module HasGuardedHandlers
   # Trigger a handler classification with an event object
   #
   # @param [Symbol, nil] type a classification to separate handlers/events into channels
-  # @param [Object] the event object to yield to the handler block
-  def trigger_handler(type, event)
+  # @param [Object] event the event object to yield to the handler block
+  # @param [Hash] options
+  # @option options [true, false] :broadcast Enables broadcast mode, where the return value or raising of handlers does not halt the handler chain. Defaults to false.
+  # @option options [Proc] :exception_callback Allows handling exceptions when broadcast mode is available via a callback.
+  def trigger_handler(type, event, options = {})
+    broadcast = options[:broadcast] || false
     return unless handler = handlers_of_type(type)
     called = false
     catch :halt do
@@ -88,8 +92,16 @@ module HasGuardedHandlers
           if guarded?(guards, event)
             called = false
           else
-            call_handler handler, guards, event
-            true
+            begin
+              call_handler handler, guards, event
+            rescue => e
+              if broadcast
+                options[:exception_callback].call(e) if options[:exception_callback]
+              else
+                raise
+              end
+            end
+            true unless broadcast
           end
         end
         delete_handler_if(type) { |_, h, _| h.equal? handler } if tmp && val

data/lib/has_guarded_handlers/version.rb

@@ -1,3 +1,3 @@
 module HasGuardedHandlers
-  VERSION = "1.5.0"
+  VERSION = "1.6.0"
 end

data/spec/has_guarded_handlers_spec.rb

@@ -7,29 +7,29 @@ describe HasGuardedHandlers do
     end
   end
 
-  let(:event) { mock 'Event' }
-  let(:response) { mock 'Response' }
+  let(:event) { double 'Event' }
+  let(:response) { double 'Response' }
 
   it 'can register a handler' do
-    response.expects(:call).twice.with(event)
+    response.should_receive(:call).twice.with(event)
     subject.register_handler(:event) { |e| response.call e }
     subject.trigger_handler(:event, event).should be_true
     subject.trigger_handler(:event, event).should be_true
   end
 
   it 'can register a handler for all events, regardless of category' do
-    response.expects(:call).twice.with(event)
+    response.should_receive(:call).twice.with(event)
     subject.register_handler { |e| response.call e }
     subject.trigger_handler :event, event
     subject.trigger_handler :bah, event
   end
 
   it 'can register a one-shot (tmp) handler' do
-    response.expects(:call).times(3).with(event)
-    event.expects(:foo).times(3).returns :bar
+    response.should_receive(:call).exactly(3).times.with(event)
+    event.should_receive(:foo).exactly(3).times.and_return :bar
 
-    nomatch_event = mock 'Event(nomatch)'
-    nomatch_event.expects(:foo).twice.returns :baz
+    nomatch_event = double 'Event(nomatch)'
+    nomatch_event.should_receive(:foo).twice.and_return :baz
 
     subject.register_handler(:event, :foo => :bar) do |e|
       response.call e
@@ -43,7 +43,7 @@ describe HasGuardedHandlers do
   end
 
   it 'can unregister a handler after registration' do
-    response.expects(:call).once.with(event)
+    response.should_receive(:call).once.with(event)
     subject.register_handler(:event) { |e| response.call e }
     id = subject.register_handler(:event) { |e| response.call :foo }
     subject.unregister_handler :event, id
@@ -58,8 +58,8 @@ describe HasGuardedHandlers do
   end
 
   it 'allows for breaking out of handlers' do
-    response.expects(:handle).once
-    response.expects(:fail).never
+    response.should_receive(:handle).once
+    response.should_receive(:fail).never
     subject.register_handler :event do |_|
       response.handle
       throw :halt
@@ -70,7 +70,7 @@ describe HasGuardedHandlers do
 
   context 'when multiple handlers are registered' do
     it "stops at the first matching handler regardless of return value" do
-      response.expects(:handle).once
+      response.should_receive(:handle).once
       subject.register_handler :event do |_|
         response.handle
         false
@@ -80,12 +80,67 @@ describe HasGuardedHandlers do
       end
       subject.trigger_handler(:event, event).should be_true
     end
+
+    context "and an early one raises" do
+      it "raises that exception, and does not execute later handlers" do
+        response.should_receive(:handle).never
+        subject.register_handler :event do |_|
+          raise "Oops"
+        end
+        subject.register_handler :event do |_|
+          response.handle
+        end
+        expect { subject.trigger_handler(:event, event) }.to raise_error(StandardError, "Oops")
+      end
+    end
+
+    context "when broadcast mode is enabled on trigger" do
+      it "continues regardless of return value" do
+        response.should_receive(:handle).twice
+        subject.register_handler :event do |_|
+          response.handle
+        end
+        subject.register_handler :event do |_|
+          response.handle
+        end
+        subject.trigger_handler(:event, event, broadcast: true).should be_true
+      end
+
+      context "and an early one raises" do
+        it "swallows that exception, and executes later handlers" do
+          response.should_receive(:handle).once
+          subject.register_handler :event do |_|
+            raise "Oops"
+          end
+          subject.register_handler :event do |_|
+            response.handle
+          end
+          subject.trigger_handler(:event, event, broadcast: true)
+        end
+
+        it "can invoke a callback on an exception" do
+          exception_callback = double 'Exception Callback'
+          exception_callback.should_receive(:call).once.with do |e|
+            e.should be_a(RuntimeError)
+            e.message.should == "Oops"
+          end.ordered
+          response.should_receive(:handle).once.ordered
+          subject.register_handler :event do |_|
+            raise "Oops"
+          end
+          subject.register_handler :event do |_|
+            response.handle
+          end
+          subject.trigger_handler(:event, event, broadcast: true, exception_callback: exception_callback)
+        end
+      end
+    end
   end
 
   it 'allows for passing to the next handler of the same type' do
-    response.expects(:handle1).once
-    response.expects(:handle2).once
-    response.expects(:fail).never
+    response.should_receive(:handle1).once
+    response.should_receive(:handle2).once
+    response.should_receive(:fail).never
     subject.register_handler :event do |_|
       response.handle1
       throw :pass
@@ -99,8 +154,8 @@ describe HasGuardedHandlers do
 
   context 'when there is nothing to pass to' do
     it 'correctly indicates that a handler was called' do
-      response.expects(:handle1).once
-      response.expects(:fail).never
+      response.should_receive(:handle1).once
+      response.should_receive(:fail).never
       subject.register_handler :event do |_|
         response.handle1
         throw :pass
@@ -112,10 +167,9 @@ describe HasGuardedHandlers do
 
   describe 'when registering handlers with the same priority' do
     it 'preserves the order of specification of the handlers' do
-      sequence = sequence 'handler_priority'
-      response.expects(:handle1).once.in_sequence sequence
-      response.expects(:handle2).once.in_sequence sequence
-      response.expects(:handle3).once.in_sequence sequence
+      response.should_receive(:handle1).once.ordered
+      response.should_receive(:handle2).once.ordered
+      response.should_receive(:handle3).once.ordered
       subject.register_handler :event do |_|
         response.handle1
         throw :pass
@@ -134,10 +188,9 @@ describe HasGuardedHandlers do
 
   describe 'when registering handlers with a specified priority' do
     it 'executes handlers in that order' do
-      sequence = sequence 'handler_priority'
-      response.expects(:handle1).once.in_sequence sequence
-      response.expects(:handle2).once.in_sequence sequence
-      response.expects(:handle3).once.in_sequence sequence
+      response.should_receive(:handle1).once.ordered
+      response.should_receive(:handle2).once.ordered
+      response.should_receive(:handle3).once.ordered
       subject.register_handler_with_priority :event, -10 do |_|
         response.handle3
         throw :pass
@@ -155,7 +208,7 @@ describe HasGuardedHandlers do
   end
 
   it 'can clear handlers' do
-    response.expects(:call).once
+    response.should_receive(:call).once
 
     subject.register_handler(:event) { |_| response.call }
     subject.trigger_handler :event, event
@@ -171,7 +224,7 @@ describe HasGuardedHandlers do
     end
 
     it 'can be a class' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, GuardedObject) { |_| response.call }
 
       subject.trigger_handler :event, GuardedObject.new
@@ -179,7 +232,7 @@ describe HasGuardedHandlers do
     end
 
     it 'can be a module' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, GuardMixin) { |_| response.call }
 
       subject.trigger_handler :event, GuardedObject.new
@@ -187,54 +240,54 @@ describe HasGuardedHandlers do
     end
 
     it 'can be a symbol' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, :chat?) { |_| response.call }
 
-      event.expects(:chat?).returns true
+      event.should_receive(:chat?).and_return true
       subject.trigger_handler :event, event
 
-      event.expects(:chat?).returns false
+      event.should_receive(:chat?).and_return false
       subject.trigger_handler :event, event
     end
 
     it 'can be a hash with string match' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, :body => 'exit') { |_| response.call }
 
-      event.expects(:body).returns 'exit'
+      event.should_receive(:body).and_return 'exit'
       subject.trigger_handler :event, event
 
-      event.expects(:body).returns 'not-exit'
+      event.should_receive(:body).and_return 'not-exit'
       subject.trigger_handler :event, event
     end
 
     it 'can be a hash with a value' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, :number => 0) { |_| response.call }
 
-      event.expects(:number).returns 0
+      event.should_receive(:number).and_return 0
       subject.trigger_handler :event, event
 
-      event.expects(:number).returns 1
+      event.should_receive(:number).and_return 1
       subject.trigger_handler :event, event
     end
 
     it 'can be a hash with a regexp' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, :body => /exit/) { |_| response.call }
 
-      event.expects(:body).returns 'more than just exit, but exit still'
+      event.should_receive(:body).and_return 'more than just exit, but exit still'
       subject.trigger_handler :event, event
 
-      event.expects(:body).returns 'keyword not found'
+      event.should_receive(:body).and_return 'keyword not found'
       subject.trigger_handler :event, event
 
-      event.expects(:body).returns nil
+      event.should_receive(:body).and_return nil
       subject.trigger_handler :event, event
     end
 
     it 'can be a hash with arguments' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, [:[], :foo] => :bar) { |_| response.call }
 
       subject.trigger_handler :event, {:foo => :bar}
@@ -243,60 +296,60 @@ describe HasGuardedHandlers do
     end
 
     it 'can be a hash with an array' do
-      response.expects(:call).twice
+      response.should_receive(:call).twice
       subject.register_handler(:event, :type => [:result, :error]) { |_| response.call }
 
-      event = mock 'Event'
-      event.expects(:type).at_least_once.returns :result
+      event = double 'Event'
+      event.should_receive(:type).at_least(1).and_return :result
       subject.trigger_handler :event, event
 
-      event = mock 'Event'
-      event.expects(:type).at_least_once.returns :error
+      event = double 'Event'
+      event.should_receive(:type).at_least(1).and_return :error
       subject.trigger_handler :event, event
 
-      event = mock 'Event'
-      event.expects(:type).at_least_once.returns :get
+      event = double 'Event'
+      event.should_receive(:type).at_least(1).and_return :get
       subject.trigger_handler :event, event
     end
 
     it 'chained are treated like andand (short circuited)' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, :type => :get, :body => 'test') { |_| response.call }
 
-      event = mock 'Event'
-      event.expects(:type).at_least_once.returns :get
-      event.expects(:body).returns 'test'
+      event = double 'Event'
+      event.should_receive(:type).at_least(1).and_return :get
+      event.should_receive(:body).and_return 'test'
       subject.trigger_handler :event, event
 
-      event = mock 'Event'
-      event.expects(:type).at_least_once.returns :set
-      event.expects(:body).never
+      event = double 'Event'
+      event.should_receive(:type).at_least(1).and_return :set
+      event.should_receive(:body).never
       subject.trigger_handler :event, event
     end
 
     it 'within an Array are treated as oror (short circuited)' do
-      response.expects(:call).twice
+      response.should_receive(:call).twice
       subject.register_handler(:event, [{:type => :get}, {:body => 'test'}]) { |_| response.call }
 
-      event = mock 'Event'
-      event.expects(:type).at_least_once.returns :set
-      event.expects(:body).returns 'test'
+      event = double 'Event'
+      event.should_receive(:type).at_least(1).and_return :set
+      event.should_receive(:body).and_return 'test'
       subject.trigger_handler :event, event
 
-      event = mock 'Event'
-      event.stubs(:type).at_least_once.returns :get
-      event.expects(:body).never
+      event = double 'Event'
+      event.should_receive(:type).at_least(1).and_return :get
+      event.should_receive(:body).never
       subject.trigger_handler :event, event
     end
 
     it 'can be a lambda' do
-      response.expects(:call).once
+      response.should_receive(:call).once
       subject.register_handler(:event, lambda { |e| e.number % 3 == 0 }) { |_| response.call }
 
-      event.expects(:number).at_least_once.returns 3
+      event.should_receive(:number).once.and_return 3
       subject.trigger_handler :event, event
 
-      event.expects(:number).at_least_once.returns 2
+      event.should_receive(:number).once.and_return 2
       subject.trigger_handler :event, event
     end
 

data/spec/spec_helper.rb

@@ -4,7 +4,6 @@ require 'has_guarded_handlers'
 Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
 
 RSpec.configure do |config|
-  config.mock_with :mocha
   config.filter_run :focus => true
   config.run_all_when_everything_filtered = true
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: has-guarded-handlers
 version: !ruby/object:Gem::Version
-  version: 1.5.0
-  prerelease: 
+  version: 1.6.0
 platform: ruby
 authors:
 - Ben Langfeld
@@ -10,118 +9,90 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-08 00:00:00.000000000 Z
+date: 2014-01-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.5.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.5.0
-- !ruby/object:Gem::Dependency
-  name: mocha
-  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'
 - !ruby/object:Gem::Dependency
   name: ci_reporter
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 1.6.3
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: rake
   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'
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   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: Allow an object's API to provide flexible handler registration, storage
@@ -132,9 +103,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - CHANGELOG.md
 - Gemfile
 - Guardfile
@@ -148,33 +119,26 @@ files:
 - spec/spec_helper.rb
 homepage: http://github.com/adhearsion/has-guarded-handlers
 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'
-      segments:
-      - 0
-      hash: -3810858558252593489
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3810858558252593489
 requirements: []
 rubyforge_project: has-guarded-handlers
-rubygems_version: 1.8.24
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A library for associating a set of event handlers, complete with guards,
   with a Ruby object
 test_files: