has-guarded-handlers 1.6.0 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d854e0cfdde0b22903dbdf262be0270d1667eff
-  data.tar.gz: a76bbebebf714923e14fa877eb3d7386d73c2ff7
+  metadata.gz: 8f951b34654f8fa653a3b1cda2ef2c54b6e62ad9
+  data.tar.gz: 8b78f49afa001bcc62a169ae9a372ac2574ac82c
 SHA512:
-  metadata.gz: 8ded65f328d1a8bbfcf0b0b8c3a9bcc45b0906989513f724ffbc8fed534732a60ea0431e06f3e4d5b50c01dac226b24a8e7b8d7bbbeb5f6d3536b3c291a2e2b7
-  data.tar.gz: 2427d889bf1d2032bbfebd1de4f7dfa8e4c28493434d488d7d39004f5d855ffef9c3648dc4ef79e97695ea3f7b9c41ece0cdd9cff7a8b3bffb7d357befafd9b8
+  metadata.gz: d1f097330d572d3eadd22f03dae81c22d6bd8dfc49c29104b5aadcfb46f936cb3a1ef8470b5093752f66a892dc17e8b395b642947ddee38480099f31818f6060
+  data.tar.gz: 57c2a94053e64b871a32d15367ba531e8f5294a6760439d4e73200be1ba44a059f73dd91d2499a5dae2542aadbe3114f151bcf12846c2166eb7844245065ebd8

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # [develop](https://github.com/adhearsion/has-guarded-handlers)
 
+# [1.6.2](https://github.com/adhearsion/has-guarded-handlers/compare/v1.6.1...v1.6.2) - [2015-02-20](https://rubygems.org/gems/has-guarded-handlers/versions/1.6.2)
+  * Bugfix: Fix release pipeline
+
+# [1.6.1](https://github.com/adhearsion/has-guarded-handlers/compare/v1.6.0...v1.6.1) - [2015-02-20](https://rubygems.org/gems/has-guarded-handlers/versions/1.6.1)
+  * Bugfix: Ensure temp handlers are executed only once.
+  * Improved documentation on how chained handlers execute via `throw :pass`, `throw :halt`, and not explicitly throwing.
+
 # [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.
 

data/Gemfile

@@ -2,8 +2,3 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in has-guarded-handlers.gemspec
 gemspec
-
-if RUBY_PLATFORM =~ /darwin/
-  gem 'growl_notify'
-  gem 'rb-fsevent'
-end

data/README.md

@@ -1,4 +1,12 @@
 # HasGuardedHandlers
+
+[![Gem Version](https://badge.fury.io/rb/has-guarded-handlers.png)](https://rubygems.org/gems/has-guarded-handlers)
+[![Build Status](https://secure.travis-ci.org/adhearsion/has-guarded-handlers.png?branch=develop)](http://travis-ci.org/adhearsion/has-guarded-handlers)
+[![Dependency Status](https://gemnasium.com/adhearsion/has-guarded-handlers.png?travis)](https://gemnasium.com/adhearsion/has-guarded-handlers)
+[![Code Climate](https://codeclimate.com/github/adhearsion/has-guarded-handlers.png)](https://codeclimate.com/github/adhearsion/has-guarded-handlers)
+[![Coverage Status](https://coveralls.io/repos/adhearsion/has-guarded-handlers/badge.png?branch=develop)](https://coveralls.io/r/adhearsion/has-guarded-handlers)
+[![Inline docs](http://inch-ci.org/github/adhearsion/has-guarded-handlers.png?branch=develop)](http://inch-ci.org/github/adhearsion/has-guarded-handlers)
+
 HasGuardedHandlers allows an object's API to provide flexible handler registration, storage and matching to arbitrary events.
 
 ## Installation
@@ -78,12 +86,12 @@ a.register_handler_with_options(:event, {:tmp => true, :priority => 10}, :foo =>
 
 ### Handler chaining
 
-When multiple handlers match the event, the return value of each handler will determine if the handler chain continues. A truthy return value will cause the handler to swallow the event and halt the handler chain. A falsy return value will continue the chain.
+Each handler can control whether subsequent handlers should be executed by throwing `:pass` or `:halt`.
 
-It is possible to explicitly pass to the next handler by throwing `:pass` in your handler:
+To explicitly pass to the next handler, throw `:pass` in your handler:
 
 ```ruby
-a.register_handler(:event) { throw :pass }
+a.register_handler(:event) { do_stuff; throw :pass }
 a.register_handler(:event) { ... } # This will be executed
 
 a.trigger_handler :event, :foo
@@ -92,12 +100,30 @@ a.trigger_handler :event, :foo
 or indeed explicitly halt the handler chain by throwing `:halt` in the handler:
 
 ```ruby
-a.register_handler(:event) { throw :halt }
+a.register_handler(:event) { do_stuff; throw :halt }
 a.register_handler(:event) { ... } # This will not be executed
 
 a.trigger_handler :event, :foo
 ```
 
+If nothing is thrown in the event handler, the handler chain will be halted by default, so subsequent handlers will not be executed.  
+
+```ruby
+a.register_handler(:event) { do_stuff; }
+a.register_handler(:event) { ... } # This will not be executed
+
+a.trigger_handler :event, :foo
+```
+
+By triggering the event in broadcast mode, the handler chain will continue by default.  
+
+```ruby
+a.register_handler(:event) { do_stuff; }
+a.register_handler(:event) { ... } # This will be executed
+
+a.trigger_handler :event, :foo, broadcast: true
+```
+
 ### What are guards?
 
 Guards are a concept borrowed from Erlang. They help to better compartmentalise handlers.

data/Rakefile

@@ -3,7 +3,6 @@ Bundler::GemHelper.install_tasks
 
 require 'rspec/core'
 require 'rspec/core/rake_task'
-require 'ci/reporter/rake/rspec'
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = 'spec/**/*_spec.rb'
   spec.rspec_opts = '--color'
@@ -16,7 +15,6 @@ RSpec::Core::RakeTask.new(:rcov) do |spec|
 end
 
 task :default => :spec
-task :ci => ['ci:setup:rspec', :spec]
 
 require 'yard'
 YARD::Rake::YardocTask.new

data/has-guarded-handlers.gemspec

@@ -19,8 +19,7 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
 
   s.add_development_dependency 'bundler', ["~> 1.0"]
-  s.add_development_dependency 'rspec', [">= 2.5.0"]
-  s.add_development_dependency 'ci_reporter', [">= 1.6.3"]
+  s.add_development_dependency 'rspec', ["~> 3.0"]
   s.add_development_dependency 'yard', [">= 0.7.0"]
   s.add_development_dependency 'rake', [">= 0"]
   s.add_development_dependency 'guard-rspec'

data/lib/has_guarded_handlers.rb

@@ -1,6 +1,47 @@
 require "has_guarded_handlers/version"
 require 'securerandom'
 
+#
+# HasGuardedHandlers allows an object's API to provide flexible handler registration, storage and matching to arbitrary events.
+#
+# HasGuardedHandlers is a module that should be mixed into some object which needs to emit events.
+#
+# See the README for more usage info.
+#
+# @author Ben Langfeld <ben@langfeld.me>
+#
+# @example Simple usage
+#
+#   require 'has_guarded_handlers'
+#   
+#   class A
+#     include HasGuardedHandlers
+#   end
+#   
+#   a = A.new
+#   a.register_handler :event do |event|
+#     puts "Handled the event #{event.inspect}"
+#   end
+#   
+#   a.trigger_handler :event, "Foo!"
+#
+# @example Guarding event handlers
+#
+#   require 'has_guarded_handlers'
+#   
+#   class A
+#     include HasGuardedHandlers
+#   end
+#   
+#   a = A.new
+#   a.register_handler :event, :type => :foo do |event|
+#     puts "Handled the event of type #{event.type} with value #{event.value}"
+#   end
+#   
+#   Event = Class.new Struct.new(:type, :value)
+#   
+#   a.trigger_handler :event, Event.new(:foo, 'bar')
+#
 module HasGuardedHandlers
   # Register a handler
   #
@@ -104,7 +145,7 @@ module HasGuardedHandlers
             true unless broadcast
           end
         end
-        delete_handler_if(type) { |_, h, _| h.equal? handler } if tmp && val
+        delete_handler_if(type) { |_, h, _| h.equal? handler } if tmp && called
         val
       end
     end

data/lib/has_guarded_handlers/version.rb

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

data/spec/has_guarded_handlers_spec.rb

@@ -11,39 +11,79 @@ describe HasGuardedHandlers do
   let(:response) { double 'Response' }
 
   it 'can register a handler' do
-    response.should_receive(:call).twice.with(event)
+    expect(response).to 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
+    expect(subject.trigger_handler(:event, event)).to be true
+    expect(subject.trigger_handler(:event, event)).to be true
   end
 
   it 'can register a handler for all events, regardless of category' do
-    response.should_receive(:call).twice.with(event)
+    expect(response).to 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.should_receive(:call).exactly(3).times.with(event)
-    event.should_receive(:foo).exactly(3).times.and_return :bar
+  context 'when a one-shot (tmp) handler is registered' do
+    it 'can register a one-shot (tmp) handler' do
+      expect(response).to receive(:call).exactly(3).times.with(event)
+      expect(event).to receive(:foo).exactly(3).times.and_return :bar
 
-    nomatch_event = double 'Event(nomatch)'
-    nomatch_event.should_receive(:foo).twice.and_return :baz
+      nomatch_event = double 'Event(nomatch)'
+      expect(nomatch_event).to receive(:foo).twice.and_return :baz
 
-    subject.register_handler(:event, :foo => :bar) do |e|
-      response.call e
-      throw :pass
+      subject.register_handler(:event, :foo => :bar) do |e|
+        response.call e
+        throw :pass
+      end
+      subject.register_tmp_handler(:event, :foo => :bar) { |e| response.call e }
+
+      expect(subject.trigger_handler(:event, nomatch_event)).to be false
+      expect(subject.trigger_handler(:event, event)).to be true
+      expect(subject.trigger_handler(:event, event)).to be true
     end
-    subject.register_tmp_handler(:event, :foo => :bar) { |e| response.call e }
 
-    subject.trigger_handler(:event, nomatch_event).should be_false
-    subject.trigger_handler(:event, event).should be_true
-    subject.trigger_handler(:event, event).should be_true
+    it 'is executed once regardless of return value' do
+      expect(response).to receive(:call).exactly(3).times.with(event)
+      expect(event).to receive(:foo).exactly(3).times.and_return :bar
+
+      subject.register_tmp_handler(:event, :foo => :bar) do |e|
+        response.call e
+        throw :pass
+      end
+      subject.register_tmp_handler(:event, :foo => :bar) do |e|
+        response.call e
+        false
+      end
+      subject.register_tmp_handler(:event, :foo => :bar) do |e|
+        response.call e
+        true
+      end
+
+      expect(subject.trigger_handler(:event, event)).to be true
+      expect(subject.trigger_handler(:event, event)).to be true
+      expect(subject.trigger_handler(:event, event)).to be false
+    end
+
+    it 'does not remove the handler until executed' do
+      expect(response).to receive(:call).twice
+      expect(event).to receive(:foo).twice.and_return :bar
+
+      second_event = double 'Event(nomatch)'
+      expect(second_event).to receive(:foo).once.and_return :baz
+
+      subject.register_tmp_handler(:event, :foo => :bar) { |e| response.call e }
+      subject.register_tmp_handler(:event, :foo => :baz) { |e| response.call e }
+
+      expect(subject.trigger_handler(:event, event)).to be true
+      expect(subject.trigger_handler(:event, event)).to be false
+      expect(subject.trigger_handler(:event, second_event)).to be true
+      expect(subject.trigger_handler(:event, second_event)).to be false
+    end
   end
 
   it 'can unregister a handler after registration' do
-    response.should_receive(:call).once.with(event)
+    expect(response).to 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
@@ -51,26 +91,26 @@ describe HasGuardedHandlers do
   end
 
   it 'does not fail when no handlers are set' do
-    lambda do
+    expect(lambda do
       subject.trigger_handler :event, event
-    end.should_not raise_error
-    subject.trigger_handler(:event, event).should be_false
+    end).to_not raise_error
+    expect(subject.trigger_handler(:event, event)).to be false
   end
 
   it 'allows for breaking out of handlers' do
-    response.should_receive(:handle).once
-    response.should_receive(:fail).never
+    expect(response).to receive(:handle).once
+    expect(response).to receive(:fail).never
     subject.register_handler :event do |_|
       response.handle
       throw :halt
       response.fail
     end
-    subject.trigger_handler(:event, event).should be_true
+    expect(subject.trigger_handler(:event, event)).to be true
   end
 
   context 'when multiple handlers are registered' do
     it "stops at the first matching handler regardless of return value" do
-      response.should_receive(:handle).once
+      expect(response).to receive(:handle).once
       subject.register_handler :event do |_|
         response.handle
         false
@@ -78,12 +118,12 @@ describe HasGuardedHandlers do
       subject.register_handler :event do |_|
         response.handle
       end
-      subject.trigger_handler(:event, event).should be_true
+      expect(subject.trigger_handler(:event, event)).to 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
+        expect(response).to receive(:handle).never
         subject.register_handler :event do |_|
           raise "Oops"
         end
@@ -96,19 +136,19 @@ describe HasGuardedHandlers do
 
     context "when broadcast mode is enabled on trigger" do
       it "continues regardless of return value" do
-        response.should_receive(:handle).twice
+        expect(response).to 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
+        expect(subject.trigger_handler(:event, event, broadcast: true)).to be true
       end
 
       context "and an early one raises" do
         it "swallows that exception, and executes later handlers" do
-          response.should_receive(:handle).once
+          expect(response).to receive(:handle).once
           subject.register_handler :event do |_|
             raise "Oops"
           end
@@ -120,11 +160,11 @@ describe HasGuardedHandlers do
 
         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"
+          expect(exception_callback).to receive(:call).once.with(RuntimeError) do |e|
+            expect(e).to be_a(RuntimeError)
+            expect(e.message).to eq "Oops"
           end.ordered
-          response.should_receive(:handle).once.ordered
+          expect(response).to receive(:handle).once.ordered
           subject.register_handler :event do |_|
             raise "Oops"
           end
@@ -138,9 +178,9 @@ describe HasGuardedHandlers do
   end
 
   it 'allows for passing to the next handler of the same type' do
-    response.should_receive(:handle1).once
-    response.should_receive(:handle2).once
-    response.should_receive(:fail).never
+    expect(response).to receive(:handle1).once
+    expect(response).to receive(:handle2).once
+    expect(response).to receive(:fail).never
     subject.register_handler :event do |_|
       response.handle1
       throw :pass
@@ -149,27 +189,27 @@ describe HasGuardedHandlers do
     subject.register_handler :event do |_|
       response.handle2
     end
-    subject.trigger_handler(:event, event).should be_true
+    expect(subject.trigger_handler(:event, event)).to be true
   end
 
   context 'when there is nothing to pass to' do
     it 'correctly indicates that a handler was called' do
-      response.should_receive(:handle1).once
-      response.should_receive(:fail).never
+      expect(response).to receive(:handle1).once
+      expect(response).to receive(:fail).never
       subject.register_handler :event do |_|
         response.handle1
         throw :pass
         response.fail
       end
-      subject.trigger_handler(:event, event).should be_true
+      expect(subject.trigger_handler(:event, event)).to be true
     end
   end
 
   describe 'when registering handlers with the same priority' do
     it 'preserves the order of specification of the handlers' do
-      response.should_receive(:handle1).once.ordered
-      response.should_receive(:handle2).once.ordered
-      response.should_receive(:handle3).once.ordered
+      expect(response).to receive(:handle1).once.ordered
+      expect(response).to receive(:handle2).once.ordered
+      expect(response).to receive(:handle3).once.ordered
       subject.register_handler :event do |_|
         response.handle1
         throw :pass
@@ -188,9 +228,9 @@ describe HasGuardedHandlers do
 
   describe 'when registering handlers with a specified priority' do
     it 'executes handlers in that order' do
-      response.should_receive(:handle1).once.ordered
-      response.should_receive(:handle2).once.ordered
-      response.should_receive(:handle3).once.ordered
+      expect(response).to receive(:handle1).once.ordered
+      expect(response).to receive(:handle2).once.ordered
+      expect(response).to receive(:handle3).once.ordered
       subject.register_handler_with_priority :event, -10 do |_|
         response.handle3
         throw :pass
@@ -208,7 +248,7 @@ describe HasGuardedHandlers do
   end
 
   it 'can clear handlers' do
-    response.should_receive(:call).once
+    expect(response).to receive(:call).once
 
     subject.register_handler(:event) { |_| response.call }
     subject.trigger_handler :event, event
@@ -224,7 +264,7 @@ describe HasGuardedHandlers do
     end
 
     it 'can be a class' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, GuardedObject) { |_| response.call }
 
       subject.trigger_handler :event, GuardedObject.new
@@ -232,7 +272,7 @@ describe HasGuardedHandlers do
     end
 
     it 'can be a module' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, GuardMixin) { |_| response.call }
 
       subject.trigger_handler :event, GuardedObject.new
@@ -240,54 +280,54 @@ describe HasGuardedHandlers do
     end
 
     it 'can be a symbol' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, :chat?) { |_| response.call }
 
-      event.should_receive(:chat?).and_return true
+      expect(event).to receive(:chat?).and_return true
       subject.trigger_handler :event, event
 
-      event.should_receive(:chat?).and_return false
+      expect(event).to receive(:chat?).and_return false
       subject.trigger_handler :event, event
     end
 
     it 'can be a hash with string match' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, :body => 'exit') { |_| response.call }
 
-      event.should_receive(:body).and_return 'exit'
+      expect(event).to receive(:body).and_return 'exit'
       subject.trigger_handler :event, event
 
-      event.should_receive(:body).and_return 'not-exit'
+      expect(event).to receive(:body).and_return 'not-exit'
       subject.trigger_handler :event, event
     end
 
     it 'can be a hash with a value' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, :number => 0) { |_| response.call }
 
-      event.should_receive(:number).and_return 0
+      expect(event).to receive(:number).and_return 0
       subject.trigger_handler :event, event
 
-      event.should_receive(:number).and_return 1
+      expect(event).to receive(:number).and_return 1
       subject.trigger_handler :event, event
     end
 
     it 'can be a hash with a regexp' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, :body => /exit/) { |_| response.call }
 
-      event.should_receive(:body).and_return 'more than just exit, but exit still'
+      expect(event).to receive(:body).and_return 'more than just exit, but exit still'
       subject.trigger_handler :event, event
 
-      event.should_receive(:body).and_return 'keyword not found'
+      expect(event).to receive(:body).and_return 'keyword not found'
       subject.trigger_handler :event, event
 
-      event.should_receive(:body).and_return nil
+      expect(event).to receive(:body).and_return nil
       subject.trigger_handler :event, event
     end
 
     it 'can be a hash with arguments' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, [:[], :foo] => :bar) { |_| response.call }
 
       subject.trigger_handler :event, {:foo => :bar}
@@ -296,67 +336,67 @@ describe HasGuardedHandlers do
     end
 
     it 'can be a hash with an array' do
-      response.should_receive(:call).twice
+      expect(response).to receive(:call).twice
       subject.register_handler(:event, :type => [:result, :error]) { |_| response.call }
 
       event = double 'Event'
-      event.should_receive(:type).at_least(1).and_return :result
+      expect(event).to receive(:type).at_least(1).and_return :result
       subject.trigger_handler :event, event
 
       event = double 'Event'
-      event.should_receive(:type).at_least(1).and_return :error
+      expect(event).to receive(:type).at_least(1).and_return :error
       subject.trigger_handler :event, event
 
       event = double 'Event'
-      event.should_receive(:type).at_least(1).and_return :get
+      expect(event).to receive(:type).at_least(1).and_return :get
       subject.trigger_handler :event, event
     end
 
     it 'chained are treated like andand (short circuited)' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, :type => :get, :body => 'test') { |_| response.call }
 
       event = double 'Event'
-      event.should_receive(:type).at_least(1).and_return :get
-      event.should_receive(:body).and_return 'test'
+      expect(event).to receive(:type).at_least(1).and_return :get
+      expect(event).to receive(:body).and_return 'test'
       subject.trigger_handler :event, event
 
       event = double 'Event'
-      event.should_receive(:type).at_least(1).and_return :set
-      event.should_receive(:body).never
+      expect(event).to receive(:type).at_least(1).and_return :set
+      expect(event).to receive(:body).never
       subject.trigger_handler :event, event
     end
 
     it 'within an Array are treated as oror (short circuited)' do
-      response.should_receive(:call).twice
+      expect(response).to receive(:call).twice
       subject.register_handler(:event, [{:type => :get}, {:body => 'test'}]) { |_| response.call }
 
       event = double 'Event'
-      event.should_receive(:type).at_least(1).and_return :set
-      event.should_receive(:body).and_return 'test'
+      expect(event).to receive(:type).at_least(1).and_return :set
+      expect(event).to receive(:body).and_return 'test'
       subject.trigger_handler :event, event
 
       event = double 'Event'
-      event.should_receive(:type).at_least(1).and_return :get
-      event.should_receive(:body).never
+      expect(event).to receive(:type).at_least(1).and_return :get
+      expect(event).to receive(:body).never
       subject.trigger_handler :event, event
     end
 
     it 'can be a lambda' do
-      response.should_receive(:call).once
+      expect(response).to receive(:call).once
       subject.register_handler(:event, lambda { |e| e.number % 3 == 0 }) { |_| response.call }
 
-      event.should_receive(:number).once.and_return 3
+      expect(event).to receive(:number).once.and_return 3
       subject.trigger_handler :event, event
 
-      event.should_receive(:number).once.and_return 2
+      expect(event).to receive(:number).once.and_return 2
       subject.trigger_handler :event, event
     end
 
     it 'raises an error when a bad guard is tried' do
-      lambda {
+      expect(lambda {
         subject.register_handler(:event, 0) {}
-      }.should raise_error RuntimeError
+      }).to raise_error RuntimeError
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: has-guarded-handlers
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.6.2
 platform: ruby
 authors:
 - Ben Langfeld
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-16 00:00:00.000000000 Z
+date: 2015-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -29,30 +29,16 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.5.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 2.5.0
-- !ruby/object:Gem::Dependency
-  name: ci_reporter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.3
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.6.3
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -136,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: has-guarded-handlers
-rubygems_version: 2.2.0
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: A library for associating a set of event handlers, complete with guards,