wisper 1.3.0 → 1.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: c905b4f311d82eadf52d61a11a0515109335d592
+  data.tar.gz: 9be198a62d94f3c8fbc46253cd109a438d857206
+SHA512: 
+  metadata.gz: 44ddd88e30752991d23dafa678086611a05f0206f152066b18b0283b0eb9462728b06be38f46fdf08caba0ead38919e88530ad1566cc2d8d92d751813805e851
+  data.tar.gz: d7ee6c49e1c6320596e00f1a79624e8ea3bb7f413b4fa76348415e3ff40225772522d1f861946dd83aaf1fbff0e86a89eccb72dd0dca1ca91843a72d78a3193a

data/.travis.yml

@@ -5,6 +5,13 @@ rvm:
   - '1.9.2'
   - '1.9.3'
   - '2.0.0'
-  - jruby-19mode
-  - jruby-20mode
-  - rbx
+  - '2.1.2'
+  - jruby
+  - rbx-2
+  ### ALLOWED FAILURES ###
+  # see how compatible we are with dev versions, but do not fail the build
+  - ruby-head
+  - jruby-head
+allow_failures:
+  - rvm: ruby-head
+  - rvm: jruby-head

data/CHANGELOG.md

@@ -0,0 +1,87 @@
+## Unreleased (no breaking changes)
+
+None
+
+## 1.4.0 (8th Sept 2014)
+
+Authors: Kris Leech, Marc Ignacio, Ahmed Abdel Razzak, kmehkeri, Jake Hoffner
+
+* feature: matcher for rspec 3
+* fix: temporary global listeners are cleared if an exception is raised
+* refactor: update all specs to rspec 3 expect syntax
+* docs: update README to rspec 3 expect syntax
+* feature: combine global and temporary listener methods as `Wisper.subscribe`
+* deprecate: `Wisper.add_listener` and `Wisper.with_listeners,` use `Wisper.subscribe` instead
+
+## 1.3.0 (18th Jan 2014)
+
+Authors: Kris Leech, Yan Pritzker, Charlie Tran
+
+* feature: global subscriptions can be scoped to a class (and sub-classes)
+* upgrade: use rspec 3
+* feature: allow prefixing of events with 'on'
+* feature: Allow stubbed publisher method to accept arbitrary args
+
+## 1.2.1 (7th Oct 2013)
+
+Authors: Kris Leech, Tomasz Szymczyszyn, Alex Heeton
+
+* feature: global subscriptions can be passed options
+* docs: improve README examples
+* docs: add license to gemspec
+
+## 1.2.0 (21st July 2013)
+
+Authors: Kris Leech, Darren Coxall
+
+* feature: support for multiple events at once
+* fix: clear global listeners after each spec
+
+## 1.1.0 (7th June 2013)
+
+Authors: Kris Leech, chatgris
+
+* feature: add temporary global listeners
+* docs: improve ActiveRecord example
+* refactor: improve specs
+* upgrade: add Ruby 2.0 support
+* fix: make listener collection immutable
+* remove: async publishing and Celluloid dependency
+* fix: Make global listeners getter and setter threadsafe [9]
+
+## 1.0.1 (2nd May 2013)
+
+Authors: Kris Leech, Yan Pritzker
+
+* feature: add async publishing using Celluloid
+* docs: improve README examples
+* feature: `stub_wisper_publisher` rspec helper
+* feature: global listeners
+* refactor: improve specs
+
+## 1.0.0 (7th April 2013)
+
+Authors: Kris Leech
+
+* refactor: specs
+* refactor: registrations
+* feature: Add `with` argument to `subscribe`
+* docs: improve README examples
+* feature: Allow subscriptions to be chainable
+* feature: Add `on` syntax for block subscription
+* remove: Remove support for Ruby 1.8.7
+* docs: Add badges to README
+
+## 0.0.2 (30th March 2013)
+
+Authors: Kris Leech
+
+* remove: ActiveSupport dependency
+* docs: fix syntax highlighting in README
+
+## 0.0.1 (30th March 2013)
+
+Authors: Kris Leech
+
+* docs: add README
+* feature: registration of objects and blocks

data/Gemfile

@@ -4,7 +4,13 @@ gemspec
 
 gem 'rubysl', '~> 2.0', :platforms => :rbx
 
+gem 'coveralls', require: false
+
 group :metrics do
-  gem 'simplecov'
   gem 'flay'
 end
+
+group :development do
+  gem 'rake',  '~> 10.3.0'
+  gem 'rspec', '~> 3.0.0'
+end

data/README.md

@@ -3,8 +3,10 @@
 Wisper is a Ruby library for decoupling and managing the dependencies of your
 Ruby objects using Pub/Sub.
 
+[![Gem Version](https://badge.fury.io/rb/wisper.png)](http://badge.fury.io/rb/wisper)
 [![Code Climate](https://codeclimate.com/github/krisleech/wisper.png)](https://codeclimate.com/github/krisleech/wisper)
 [![Build Status](https://travis-ci.org/krisleech/wisper.png?branch=master)](https://travis-ci.org/krisleech/wisper)
+[![Coverage Status](https://coveralls.io/repos/krisleech/wisper/badge.png?branch=master)](https://coveralls.io/r/krisleech/wisper?branch=master)
 
 Wisper was extracted from a Rails codebase but is not dependant on Rails.
 
@@ -16,7 +18,7 @@ to reduce coupling between data and domain layers.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'wisper', '~>1.2.0'
+gem 'wisper'
 ```
 
 ## Usage
@@ -76,7 +78,7 @@ Please refer to the [wisper-async](https://github.com/krisleech/wisper-async) ge
 class Bid < ActiveRecord::Base
   include Wisper::Publisher
 
-  validates :amount, :presence => true
+  validates :amount, presence: true
 
   def commit(_attrs = nil)
     assign_attributes(_attrs) if _attrs.present?
@@ -106,7 +108,7 @@ class BidsController < ApplicationController
     @bid.subscribe(StatisticsListener.new)
 
     @bid.on(:create_bid_successful) { |bid| redirect_to bid }
-    @bid.on(:create_bid_failed)     { |bid| render :action => :new }
+    @bid.on(:create_bid_failed)     { |bid| render action: :new }
 
     @bid.commit
   end
@@ -205,7 +207,7 @@ obvious on reading the code and of course you are introducing global state and
 'always on' behaviour. This may not desirable.
 
 ```ruby
-Wisper.add_listener(MyListener.new)
+Wisper.subscribe(MyListener.new)
 ```
 
 In a Rails app you might want to add your global listeners in an initalizer.
@@ -218,7 +220,7 @@ You might want to globally subscribe a listener to publishers with a certain
 class.
 
 ```ruby
-Wisper.add_listener(MyListener.new, :scope => :MyPublisher)
+Wisper.subscribe(MyListener.new, scope: :MyPublisher)
 ```
 
 This will subscribe the listener to all instances of `MyPublisher` and its
@@ -227,7 +229,7 @@ subclasses.
 Alternatively you can also do exactly the same with a publisher class:
 
 ```ruby
-MyPublisher.add_listener(MyListener.new)
+MyPublisher.subscribe(MyListener.new)
 ```
 
 ## Temporary Global Listeners
@@ -235,7 +237,7 @@ MyPublisher.add_listener(MyListener.new)
 You can also globally subscribe listeners for the duration of a block.
 
 ```ruby
-Wisper.with_listeners(MyListener.new, OtherListener.new) do
+Wisper.subscribe(MyListener.new, OtherListener.new) do
   # do stuff
 end
 ```
@@ -250,19 +252,19 @@ Temporary Global Listeners are threadsafe.
 
 By default a listener will get notified of all events it can respond to. You
 can limit which events a listener is notified of by passing an event or array
-of events to `:on`.
+of events to `on:`.
 
 ```ruby
-post_creater.subscribe(PusherListener.new, :on => :create_post_successful)
+post_creater.subscribe(PusherListener.new, on: :create_post_successful)
 ```
 
 ## Prefixing broadcast events
 
 If you would prefer listeners to receive events with a prefix, for example
-`on`, you can do so by passing a string or symbol to `:prefix`.
+`on`, you can do so by passing a string or symbol to `prefix:`.
 
 ```ruby
-post_creater.subscribe(PusherListener.new, :prefix => :on)
+post_creater.subscribe(PusherListener.new, prefix: :on)
 ```
 
 If `post_creater` where to broadcast the event `post_created` the subscribed
@@ -272,42 +274,72 @@ use the default prefix, "on".
 ## Mapping an event to a different method
 
 By default the method called on the subscriber is the same as the event
-broadcast. However it can be mapped to a different method using `:with`.
+broadcast. However it can be mapped to a different method using `with:`.
 
 ```ruby
-report_creator.subscribe(MailResponder.new, :with => :successful)
+report_creator.subscribe(MailResponder.new, with: :successful)
 ```
 
-This is pretty useless unless used in conjuction with `:on`, since all events 
+This is pretty useless unless used in conjuction with `on:`, since all events
 will get mapped to `:successful`. Instead you might do something like this:
 
 ```ruby
-report_creator.subscribe(MailResponder.new, :on   => :create_report_successful,
-                                            :with => :successful)
+report_creator.subscribe(MailResponder.new, on:   :create_report_successful,
+                                            with: :successful)
 ```
 
-If you pass an array of events to `:on` each event will be mapped to the same
-method when `:with` is specified. If you need to listen for select events
+If you pass an array of events to `on:` each event will be mapped to the same
+method when `with:` is specified. If you need to listen for select events
 _and_ map each one to a different method subscribe the listener once for
 each mapping:
 
 ```ruby
-report_creator.subscribe(MailResponder.new, :on   => :create_report_successful,
-                                            :with => :successful)
+report_creator.subscribe(MailResponder.new, on:   :create_report_successful,
+                                            with: :successful)
 
-report_creator.subscribe(MailResponder.new, :on   => :create_report_failed,
-                                            :with => :failed)
+report_creator.subscribe(MailResponder.new, on:   :create_report_failed,
+                                            with: :failed)
 ```
 
 ## Chaining subscriptions
 
 ```ruby
 post.on(:success) { |post| redirect_to post }
-    .on(:failure) { |post| render :action => :edit, :locals => :post => post }
+    .on(:failure) { |post| render action: :edit, locals: { post: post } }
 ```
 
 ## RSpec
 
+### Broadcast Matcher
+
+```ruby
+require 'wisper/rspec/matchers'
+
+RSpec::configure do |config|
+  config.include(Wisper::RSpec::BroadcastMatcher)
+end
+
+expect { publisher.execute }.to broadcast(:an_event)
+```
+
+### Using message expections
+
+If you need to assert on the arguments broadcast you can subscribe a double 
+with a [message expection](https://github.com/rspec/rspec-mocks#message-expectations)
+and then use any of the [argument matchers](https://github.com/rspec/rspec-mocks#argument-matchers).
+
+```ruby
+listener = double('Listener')
+
+expect(listener).to receive(:an_event).with(some_args)
+
+publisher.subscribe(listener)
+
+publisher.execute
+```
+
+### Stubbing publishers
+
 Wisper comes with a method for stubbing event publishers so that you can create 
 isolation tests that only care about reacting to events.
 
@@ -338,7 +370,7 @@ describe CodeThatReactsToEvents do
 
     it "renders" do
       response = CodeThatReactsToEvents.new.do_something
-      response.should == "Hello with foo!"
+      expect(response).to eq "Hello with foo!"
     end
   end
 end

data/Rakefile

@@ -1,7 +1,10 @@
 require "bundler/gem_tasks"
-
 require 'rspec/core/rake_task'
+require 'coveralls/rake/task'
 
 RSpec::Core::RakeTask.new
+Coveralls::RakeTask.new
+
+task :test_with_coveralls => [:spec, 'coveralls:push']
 
 task :default => :spec

data/lib/wisper.rb

@@ -14,10 +14,23 @@ module Wisper
   end
 
   def self.with_listeners(*args, &block)
-    TemporaryListeners.with(*args, &block)
+    warn "[DEPRECATION] `use Wisper.subscribe` instead of `Wisper.with_listeners`"
+    self.subscribe(*args, &block)
   end
 
   def self.add_listener(listener, options = {})
-    GlobalListeners.add(listener, options)
+    warn "[DEPRECATION] `use Wisper.subscribe` instead of `Wisper.add_listener`"
+    self.subscribe(listener, options)
+  end
+
+  def self.subscribe(*args, &block)
+    if block_given?
+      TemporaryListeners.with(*args, &block)
+    else
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      args.each do |listener|
+        GlobalListeners.add(listener, options)
+      end
+    end
   end
 end

data/lib/wisper/rspec/matchers.rb

@@ -0,0 +1,57 @@
+require 'rspec/expectations'
+
+module Wisper
+  module RSpec
+    class EventRecorder
+      def initialize
+        @broadcast_events = []
+      end
+
+      def respond_to?(method_name)
+        true
+      end
+
+      def method_missing(method_name, *args, &block)
+        @broadcast_events << method_name.to_s
+      end
+
+      def broadcast?(event_name)
+        @broadcast_events.include?(event_name.to_s)
+      end
+    end
+
+    module BroadcastMatcher
+      class Matcher
+        def initialize(event)
+          @event = event
+        end
+
+        def supports_block_expectations?
+          true
+        end
+
+        def matches?(block)
+          event_recorder = EventRecorder.new
+
+          Wisper.subscribe(event_recorder) do
+            block.call
+          end
+
+          event_recorder.broadcast?(@event)
+        end
+
+        def failure_message
+          "expected publisher to broadcast #{@event} event"
+        end
+
+        def failure_message_when_negated
+          "expected publisher not to broadcast #{@event} event"
+        end
+      end
+
+      def broadcast(event)
+        Matcher.new(event)
+      end
+    end
+  end
+end

data/lib/wisper/rspec/stub_wisper_publisher.rb

@@ -1,6 +1,3 @@
-### Wisper Stubbing
-# This is a proposal for integration as part of wisper core
-# for testing: https://github.com/krisleech/wisper/issues/1
 class TestWisperPublisher
   include Wisper::Publisher
   def initialize(*args); end

data/lib/wisper/temporary_listeners.rb

@@ -11,9 +11,12 @@ module Wisper
     end
 
     def with(listeners, options, &block)
-      add_listeners(listeners, options)
-      yield
-      clear
+      begin
+        add_listeners(listeners, options)
+        yield
+      ensure
+        clear
+      end
     end
 
     def registrations

data/lib/wisper/version.rb

@@ -1,3 +1,3 @@
 module Wisper
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/spec/lib/async_spec.rb

@@ -5,6 +5,6 @@ describe 'async option' do
   let(:publisher) { publisher_class.new }
 
   it 'it raises a deprecation exception' do
-      expect { publisher.add_listener(listener, :async => true) }.to raise_error
+    expect { publisher.add_listener(listener, :async => true) }.to raise_error
   end
 end

data/spec/lib/global_subscribers_spec.rb

@@ -8,15 +8,15 @@ describe Wisper::GlobalListeners do
   describe '.add' do
     it 'adds given listener to every publisher' do
       Wisper::GlobalListeners.add(global_listener)
-      global_listener.should_receive(:it_happened)
+      expect(global_listener).to receive(:it_happened)
       publisher.send(:broadcast, :it_happened)
     end
 
     it 'works with options' do
       Wisper::GlobalListeners.add(global_listener, :on => :it_happened,
                                                    :with => :woot)
-      global_listener.should_receive(:woot).once
-      global_listener.should_not_receive(:it_happened_again)
+      expect(global_listener).to receive(:woot).once
+      expect(global_listener).not_to receive(:it_happened_again)
       publisher.send(:broadcast, :it_happened)
       publisher.send(:broadcast, :it_happened_again)
     end
@@ -28,8 +28,8 @@ describe Wisper::GlobalListeners do
       # local listener
       publisher.add_listener(local_listener)
 
-      global_listener.should_receive(:it_happened)
-      local_listener.should_receive(:it_happened)
+      expect(global_listener).to receive(:it_happened)
+      expect(local_listener).to receive(:it_happened)
 
       publisher.send(:broadcast, :it_happened)
     end
@@ -42,9 +42,9 @@ describe Wisper::GlobalListeners do
       Wisper::GlobalListeners.add(global_listener, :scope => [publisher_1.class,
                                                               publisher_2.class])
 
-      global_listener.should_receive(:it_happened_1).once
-      global_listener.should_receive(:it_happened_2).once
-      global_listener.should_not_receive(:it_happened_3)
+      expect(global_listener).to receive(:it_happened_1).once
+      expect(global_listener).to receive(:it_happened_2).once
+      expect(global_listener).not_to receive(:it_happened_3)
 
       publisher_1.send(:broadcast, :it_happened_1)
       publisher_2.send(:broadcast, :it_happened_2)
@@ -60,18 +60,18 @@ describe Wisper::GlobalListeners do
         end
       end.each(&:join)
 
-      Wisper::GlobalListeners.listeners.size.should == num_threads
+      expect(Wisper::GlobalListeners.listeners.size).to eq num_threads
     end
   end
 
   describe '.listeners' do
     it 'returns collection of global listeners' do
       Wisper::GlobalListeners.add(global_listener)
-      Wisper::GlobalListeners.listeners.should == [global_listener]
+      expect(Wisper::GlobalListeners.listeners).to eq [global_listener]
     end
 
     it 'returns an immutable collection' do
-      Wisper::GlobalListeners.listeners.should be_frozen
+      expect(Wisper::GlobalListeners.listeners).to be_frozen
       expect { Wisper::GlobalListeners.listeners << global_listener }.to raise_error(RuntimeError)
     end
   end
@@ -79,14 +79,14 @@ describe Wisper::GlobalListeners do
   it '.clear clears all global listeners' do
     Wisper::GlobalListeners.add(global_listener)
     Wisper::GlobalListeners.clear
-    Wisper::GlobalListeners.listeners.should be_empty
+    expect(Wisper::GlobalListeners.listeners).to be_empty
   end
 
   describe 'backwards compatibility' do
     it '.add_listener adds a listener' do
       silence_warnings do
         Wisper::GlobalListeners.add_listener(global_listener)
-        global_listener.should_receive(:it_happened)
+        expect(global_listener).to receive(:it_happened)
         publisher.send(:broadcast, :it_happened)
       end
     end

data/spec/lib/integration_spec.rb

@@ -17,7 +17,7 @@ describe Wisper do
 
   it 'subscribes object to all published events' do
     listener = double('listener')
-    listener.should_receive(:success).with('hello')
+    expect(listener).to receive(:success).with('hello')
 
     command = MyCommand.new
 
@@ -28,7 +28,7 @@ describe Wisper do
 
   it 'subscribes block to all published events' do
     insider = double('Insider')
-    insider.should_receive(:render).with('hello')
+    expect(insider).to receive(:render).with('hello')
 
     command = MyCommand.new
 
@@ -42,8 +42,8 @@ describe Wisper do
   it 'maps events to different methods' do
     listener_1 = double('listener')
     listener_2 = double('listener')
-    listener_1.should_receive(:happy_days).with('hello')
-    listener_2.should_receive(:sad_days).with('world')
+    expect(listener_1).to receive(:happy_days).with('hello')
+    expect(listener_2).to receive(:sad_days).with('world')
 
     command = MyCommand.new
 
@@ -57,8 +57,8 @@ describe Wisper do
   it 'subscribes block can be chained' do
     insider = double('Insider')
 
-    insider.should_receive(:render).with('success')
-    insider.should_receive(:render).with('failure')
+    expect(insider).to receive(:render).with('success')
+    expect(insider).to receive(:render).with('failure')
 
     command = MyCommand.new
 

data/spec/lib/simple_example_spec.rb

@@ -13,8 +13,8 @@ end
 describe 'simple publishing' do
   it 'subscribes listener to events' do
     listener = double('listener')
-    listener.should_receive(:foo).with instance_of MyPublisher
-    listener.should_receive(:bar).with instance_of MyPublisher
+    expect(listener).to receive(:foo).with instance_of MyPublisher
+    expect(listener).to receive(:bar).with instance_of MyPublisher
 
     my_publisher = MyPublisher.new
     my_publisher.add_listener(listener)

data/spec/lib/temporary_global_listeners_spec.rb

@@ -8,8 +8,8 @@ describe Wisper::TemporaryListeners do
   describe '.with' do
     it 'globally subscribes listener for duration of given block' do
 
-      listener_1.should_receive(:success)
-      listener_1.should_not_receive(:failure)
+      expect(listener_1).to receive(:success)
+      expect(listener_1).to_not receive(:failure)
 
       Wisper::TemporaryListeners.with(listener_1) do
         publisher.instance_eval { broadcast(:success) }
@@ -20,11 +20,11 @@ describe Wisper::TemporaryListeners do
 
     it 'globally subscribes listeners for duration of given block' do
 
-      listener_1.should_receive(:success)
-      listener_1.should_not_receive(:failure)
+      expect(listener_1).to receive(:success)
+      expect(listener_1).to_not receive(:failure)
 
-      listener_2.should_receive(:success)
-      listener_2.should_not_receive(:failure)
+      expect(listener_2).to receive(:success)
+      expect(listener_2).to_not receive(:failure)
 
       Wisper::TemporaryListeners.with(listener_1, listener_2) do
         publisher.instance_eval { broadcast(:success) }
@@ -38,11 +38,22 @@ describe Wisper::TemporaryListeners do
       (1..num_threads).to_a.map do
         Thread.new do
           Wisper::TemporaryListeners.registrations << Object.new
-          Wisper::TemporaryListeners.registrations.size.should == 1
+          expect(Wisper::TemporaryListeners.registrations.size).to eql 1
         end
       end.each(&:join)
 
-      Wisper::TemporaryListeners.registrations.size.should == 0
+      expect(Wisper::TemporaryListeners.registrations.size).to eql 0
+    end
+
+    it 'ensures registrations are cleared after exception raised in block' do
+      begin
+        Wisper::TemporaryListeners.with(listener_1) do
+          raise StandardError
+        end
+      rescue StandardError
+      end
+
+      expect(Wisper::TemporaryListeners.registrations.size).to eql 0
     end
   end
 end

data/spec/lib/wisper/publisher_spec.rb

@@ -6,8 +6,8 @@ describe Wisper::Publisher do
 
   describe '.add_listener' do
     it 'subscribes given listener to all published events' do
-      listener.should_receive(:this_happened)
-      listener.should_receive(:so_did_this)
+      expect(listener).to receive(:this_happened)
+      expect(listener).to receive(:so_did_this)
 
       publisher.add_listener(listener)
 
@@ -17,11 +17,11 @@ describe Wisper::Publisher do
 
     describe ':on argument' do
       it 'subscribes given listener to a single event' do
-        listener.should_receive(:this_happened)
-        listener.stub(:so_did_this)
-        listener.should_not_receive(:so_did_this)
+        expect(listener).to receive(:this_happened)
+        allow(listener).to receive(:so_did_this)
+        expect(listener).not_to receive(:so_did_this)
 
-        listener.should respond_to(:so_did_this)
+        expect(listener).to respond_to(:so_did_this)
 
         publisher.add_listener(listener, :on => 'this_happened')
 
@@ -30,12 +30,12 @@ describe Wisper::Publisher do
       end
 
       it 'subscribes given listener to many events' do
-        listener.should_receive(:this_happened)
-        listener.should_receive(:and_this)
-        listener.stub(:so_did_this)
-        listener.should_not_receive(:so_did_this)
+        expect(listener).to receive(:this_happened)
+        expect(listener).to receive(:and_this)
+        allow(listener).to receive(:so_did_this)
+        expect(listener).not_to receive(:so_did_this)
 
-        listener.should respond_to(:so_did_this)
+        expect(listener).to respond_to(:so_did_this)
 
         publisher.add_listener(listener, :on => ['this_happened', 'and_this'])
 
@@ -47,7 +47,7 @@ describe Wisper::Publisher do
 
     describe ':with argument' do
       it 'sets method to call listener with on event' do
-        listener.should_receive(:different_method).twice
+        expect(listener).to receive(:different_method).twice
 
         publisher.add_listener(listener, :with => :different_method)
 
@@ -58,8 +58,8 @@ describe Wisper::Publisher do
 
     describe ':prefix argument' do
       it 'prefixes broadcast events with given symbol' do
-        listener.should_receive(:after_it_happened)
-        listener.should_not_receive(:it_happened)
+        expect(listener).to receive(:after_it_happened)
+        expect(listener).not_to receive(:it_happened)
 
         publisher.add_listener(listener, :prefix => :after)
 
@@ -67,8 +67,8 @@ describe Wisper::Publisher do
       end
 
       it 'prefixes broadcast events with "on" when given true' do
-        listener.should_receive(:on_it_happened)
-        listener.should_not_receive(:it_happened)
+        expect(listener).to receive(:on_it_happened)
+        expect(listener).not_to receive(:it_happened)
 
         publisher.add_listener(listener, :prefix => true)
 
@@ -79,23 +79,23 @@ describe Wisper::Publisher do
     # NOTE: these are not realistic use cases, since you would only ever use
     # `scope` when globally subscribing.
     describe ':scope argument' do
-      let(:listener_1) {double('Listener')  }
-      let(:listener_2) {double('Listener')  }
+      let(:listener_1) { double('Listener') }
+      let(:listener_2) { double('Listener') }
 
       before do
       end
 
       it 'scopes listener to given class' do
-        listener_1.should_receive(:it_happended)
-        listener_2.should_not_receive(:it_happended)
+        expect(listener_1).to receive(:it_happended)
+        expect(listener_2).not_to receive(:it_happended)
         publisher.add_listener(listener_1, :scope => publisher.class)
         publisher.add_listener(listener_2, :scope => Class.new)
         publisher.send(:broadcast, 'it_happended')
       end
 
       it 'scopes listener to given class string' do
-        listener_1.should_receive(:it_happended)
-        listener_2.should_not_receive(:it_happended)
+        expect(listener_1).to receive(:it_happended)
+        expect(listener_2).not_to receive(:it_happended)
         publisher.add_listener(listener_1, :scope => publisher.class.to_s)
         publisher.add_listener(listener_2, :scope => Class.new.to_s)
         publisher.send(:broadcast, 'it_happended')
@@ -106,7 +106,7 @@ describe Wisper::Publisher do
         publisher_sub_klass = Class.new(publisher_super_klass)
 
         listener = double('Listener')
-        listener.should_receive(:it_happended).once
+        expect(listener).to receive(:it_happended).once
 
         publisher = publisher_sub_klass.new
 
@@ -116,11 +116,12 @@ describe Wisper::Publisher do
     end
 
     it 'returns publisher so methods can be chained' do
-      publisher.add_listener(listener, :on => 'so_did_this').should == publisher
+      expect(publisher.add_listener(listener, :on => 'so_did_this')).to \
+        eq publisher
     end
 
     it 'is aliased to .subscribe' do
-      publisher.should respond_to(:subscribe)
+      expect(publisher).to respond_to(:subscribe)
     end
   end
 
@@ -128,7 +129,7 @@ describe Wisper::Publisher do
     let(:insider) { double('insider') }
 
     it 'subscribes given block to all events' do
-      insider.should_receive(:it_happened).twice
+      expect(insider).to receive(:it_happened).twice
 
       publisher.add_block_listener do
         insider.it_happened
@@ -140,7 +141,7 @@ describe Wisper::Publisher do
 
     describe ':on argument' do
       it '.add_block_listener subscribes block to an event' do
-        insider.should_not_receive(:it_happened).once
+        expect(insider).not_to receive(:it_happened).once
 
         publisher.add_block_listener(:on => 'something_happened') do
           insider.it_happened
@@ -151,7 +152,7 @@ describe Wisper::Publisher do
       end
 
       it '.add_block_listener subscribes block to all listed events' do
-        insider.should_receive(:it_happened).twice
+        expect(insider).to receive(:it_happened).twice
 
         publisher.add_block_listener(
           :on => ['something_happened', 'and_so_did_this']) do
@@ -165,8 +166,8 @@ describe Wisper::Publisher do
     end
 
     it 'returns publisher so methods can be chained' do
-      publisher.add_block_listener(:on => 'this_thing_happened') do
-      end.should == publisher
+      expect(publisher.add_block_listener(:on => 'this_thing_happened') do
+      end).to eq publisher
     end
   end
 
@@ -174,7 +175,7 @@ describe Wisper::Publisher do
     let(:insider) { double('insider') }
 
     it 'subscribes given block to an event' do
-      insider.should_receive(:it_happened)
+      expect(insider).to receive(:it_happened)
 
       publisher.on(:something_happened) do
         insider.it_happened
@@ -184,7 +185,7 @@ describe Wisper::Publisher do
     end
 
     it 'subscribes given block to multiple events' do
-      insider.should_receive(:it_happened).twice
+      expect(insider).to receive(:it_happened).twice
 
       publisher.on(:something_happened, :and_so_did_this) do
         insider.it_happened
@@ -198,8 +199,8 @@ describe Wisper::Publisher do
 
   describe '.broadcast' do
     it 'does not publish events which cannot be responded to' do
-      listener.should_not_receive(:so_did_this)
-      listener.stub(:respond_to? => false)
+      expect(listener).not_to receive(:so_did_this)
+      allow(listener).to receive(:respond_to?).and_return(false)
 
       publisher.add_listener(listener, :on => 'so_did_this')
 
@@ -208,7 +209,7 @@ describe Wisper::Publisher do
 
     describe ':event argument' do
       it 'is indifferent to string and symbol' do
-        listener.should_receive(:this_happened).twice
+        expect(listener).to receive(:this_happened).twice
 
         publisher.add_listener(listener)
 
@@ -217,7 +218,7 @@ describe Wisper::Publisher do
       end
 
       it 'is indifferent to dasherized and underscored strings' do
-        listener.should_receive(:this_happened).twice
+        expect(listener).to receive(:this_happened).twice
 
         publisher.add_listener(listener)
 
@@ -229,14 +230,14 @@ describe Wisper::Publisher do
 
   describe '.listeners' do
     it 'returns an immutable collection' do
-      publisher.listeners.should be_frozen
+      expect(publisher.listeners).to be_frozen
       expect { publisher.listeners << listener }.to raise_error(RuntimeError)
     end
 
     it 'returns local listeners' do
        publisher.add_listener(listener)
-       publisher.listeners.should == [listener]
-       publisher.listeners.size.should == 1
+       expect(publisher.listeners).to eq [listener]
+       expect(publisher.listeners.size).to eq 1
     end
   end
 
@@ -246,13 +247,13 @@ describe Wisper::Publisher do
 
     it 'subscribes listeners to all instances of publisher' do
       publisher_klass_1.add_listener(listener)
-      listener.should_receive(:it_happened).once
+      expect(listener).to receive(:it_happened).once
       publisher_klass_1.new.send(:broadcast, 'it_happened')
       publisher_klass_2.new.send(:broadcast, 'it_happened')
     end
 
     it 'is aliased to #subscribe' do
-      publisher_klass_1.should respond_to(:subscribe)
+      expect(publisher_klass_1).to respond_to(:subscribe)
     end
   end
 end

data/spec/lib/wisper/rspec/matchers_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'wisper/rspec/matchers'
+
+RSpec::configure do |config|
+  config.include(Wisper::RSpec::BroadcastMatcher)
+end
+
+describe 'broadcast matcher' do
+  it 'passes when publisher broadcasts inside block' do
+    publisher = publisher_class.new
+    expect { publisher.send(:broadcast, :foobar) }.to broadcast(:foobar)
+  end
+
+  it 'passes with not_to when publisher does not broadcast inside block' do
+    publisher = publisher_class.new
+    expect { publisher }.not_to broadcast(:foobar)
+  end
+end

data/spec/lib/{rspec_extensions_spec.rb → wisper/rspec/stub_wisper_publisher_spec.rb}

@@ -1,7 +1,6 @@
-require 'spec_helper'
 require 'wisper/rspec/stub_wisper_publisher'
 
-describe Wisper do
+describe '#stub_wisper_publisher' do
   describe "given a piece of code invoking a publisher" do
     class CodeThatReactsToEvents
       def do_something
@@ -20,7 +19,7 @@ describe Wisper do
 
       it "emits the event" do
         response = CodeThatReactsToEvents.new.do_something
-        response.should == "Hello with foo1 foo2!"
+        expect(response).to eq "Hello with foo1 foo2!"
       end
     end
   end

data/spec/lib/wisper_spec.rb

@@ -1,31 +1,82 @@
 require 'spec_helper'
 
 describe Wisper do
+  before do
+    # assign the stderr to a new StringIO to test errors
+    @orig_stderr, $stderr = $stderr, StringIO.new
+  end
+
+  after do
+    # reassign the stderr to the original <IO:<STDERR>> instead of StringIO
+    # used for testing
+    $stderr = @orig_stderr
+  end
 
   it 'includes Wisper::Publisher for backwards compatibility' do
-    silence_warnings do
-      publisher_class = Class.new { include Wisper }
-      publisher_class.ancestors.should include Wisper::Publisher
-    end
+    publisher_class = Class.new { include Wisper }
+    expect(publisher_class.ancestors).to include Wisper::Publisher
+
+    $stderr.rewind
+    expect($stderr.gets.chomp).to include 'DEPRECATION'
   end
 
+  # NOTE .with_listeners is deprecated
   it '.with_listeners subscribes listeners to all broadcast events for the duration of block' do
     publisher = publisher_class.new
     listener = double('listener')
 
-    listener.should_receive(:im_here)
-    listener.should_not_receive(:not_here)
-
     Wisper.with_listeners(listener) do
       publisher.send(:broadcast, 'im_here')
     end
 
-    publisher.send(:broadcast, 'not_here')
+    $stderr.rewind
+    expect($stderr.string.chomp).to include 'DEPRECATION'
   end
 
+  # NOTE .add_listener is deprecated
   it '.add_listener adds a global listener' do
     listener = double('listener')
+
     Wisper.add_listener(listener)
-    Wisper::GlobalListeners.listeners.should == [listener]
+
+    $stderr.rewind
+    expect($stderr.string.chomp).to include 'DEPRECATION'
+  end
+
+  describe '.subscribe' do
+    context 'given block' do
+      it 'subscribes listeners to all events for duration of the block' do
+        publisher = publisher_class.new
+        listener = double('listener')
+
+        expect(listener).to receive(:im_here)
+        expect(listener).not_to receive(:not_here)
+
+        Wisper.subscribe(listener) do
+          publisher.send(:broadcast, 'im_here')
+        end
+
+        publisher.send(:broadcast, 'not_here')
+      end
+    end
+
+    context 'no block given' do
+      it 'subscribes a listener to all events' do
+        listener = double('listener')
+        Wisper.subscribe(listener)
+        expect(Wisper::GlobalListeners.listeners).to eq [listener]
+      end
+
+      it 'subscribes multiple listeners to all events' do
+        listener_1 = double('listener')
+        listener_2 = double('listener')
+        listener_3 = double('listener')
+
+        Wisper.subscribe(listener_1, listener_2)
+
+        expect(Wisper::GlobalListeners.listeners).to include listener_1, listener_2
+        expect(Wisper::GlobalListeners.listeners).not_to include listener_3
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,8 +1,5 @@
-begin
-  require 'simplecov'
-  SimpleCov.start
-rescue LoadError
-end
+require 'coveralls'
+Coveralls.wear!
 
 require 'wisper'
 
@@ -12,13 +9,12 @@ RSpec.configure do |config|
   config.order = 'random'
   config.after(:each) { Wisper::GlobalListeners.clear }
 
-  # Support both Rspec2 should and Rspec3 expect syntax
   config.expect_with :rspec do |c|
-    c.syntax = [:should, :expect]
+    c.syntax = :expect
   end
 
   config.mock_with :rspec do |c|
-    c.syntax = [:should, :expect]
+    c.syntax = :expect
   end
 end
 

data/wisper.gemspec

@@ -17,6 +17,4 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-
-  gem.add_development_dependency 'rspec', "~> 3.0.0.beta1"
 end

metadata

@@ -1,42 +1,31 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: wisper
-version: !ruby/object:Gem::Version
-  version: 1.3.0
-  prerelease: 
+version: !ruby/object:Gem::Version 
+  version: 1.4.0
 platform: ruby
-authors:
+authors: 
 - Kris Leech
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-18 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.0.0.beta1
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 3.0.0.beta1
+
+date: 2014-09-08 00:00:00 Z
+dependencies: []
+
 description: pub/sub for Ruby objects
-email:
+email: 
 - kris.leech@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - .rspec
 - .travis.yml
+- CHANGELOG.md
 - Gemfile
 - Guardfile
 - README.md
@@ -47,52 +36,55 @@ files:
 - lib/wisper/registration/block.rb
 - lib/wisper/registration/object.rb
 - lib/wisper/registration/registration.rb
+- lib/wisper/rspec/matchers.rb
 - lib/wisper/rspec/stub_wisper_publisher.rb
 - lib/wisper/temporary_listeners.rb
 - lib/wisper/version.rb
 - spec/lib/async_spec.rb
 - spec/lib/global_subscribers_spec.rb
 - spec/lib/integration_spec.rb
-- spec/lib/rspec_extensions_spec.rb
 - spec/lib/simple_example_spec.rb
 - spec/lib/temporary_global_listeners_spec.rb
 - spec/lib/wisper/publisher_spec.rb
+- spec/lib/wisper/rspec/matchers_spec.rb
+- spec/lib/wisper/rspec/stub_wisper_publisher_spec.rb
 - spec/lib/wisper_spec.rb
 - spec/spec_helper.rb
 - wisper.gemspec
 homepage: https://github.com/krisleech/wisper
-licenses:
+licenses: 
 - MIT
+metadata: {}
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+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'
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - &id001 
+    - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id001
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: pub/sub for Ruby objects
-test_files:
+test_files: 
 - spec/lib/async_spec.rb
 - spec/lib/global_subscribers_spec.rb
 - spec/lib/integration_spec.rb
-- spec/lib/rspec_extensions_spec.rb
 - spec/lib/simple_example_spec.rb
 - spec/lib/temporary_global_listeners_spec.rb
 - spec/lib/wisper/publisher_spec.rb
+- spec/lib/wisper/rspec/matchers_spec.rb
+- spec/lib/wisper/rspec/stub_wisper_publisher_spec.rb
 - spec/lib/wisper_spec.rb
 - spec/spec_helper.rb
-has_rdoc: