wisper 1.0.1 → 1.1.0

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+tags

data/.travis.yml

@@ -2,5 +2,7 @@ language: ruby
 rvm:
   - '1.9.2'
   - '1.9.3'
+  - '2.0.0'
   - jruby-19mode
+  - jruby-20mode
   - rbx-19mode

data/Gemfile

@@ -2,8 +2,9 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'guard'
-gem 'guard-rspec'
-gem 'rb-fsevent', '~>0.9.1'
-
-gem 'flay'
+group :development do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'rb-fsevent', '~>0.9.1' if RUBY_PLATFORM =~ /darwin/
+  gem 'flay'
+end

data/README.md

@@ -32,7 +32,7 @@ listeners. Listeners are added, at runtime, to the publishing object.
 
 ```ruby
 class MyPublisher
-  include Wisper
+  include Wisper::Publisher
 
   def do_something
     # ...
@@ -71,34 +71,25 @@ my_publisher.on(:done_something) do |publisher|
 end
 ```
 
-### Asynchronous Publishing (Experimental)
+### Asynchronous Publishing
 
-There is support for publishing events asynchronously by passing the `async`
-option.
-
-```ruby
-my_publisher.add_subscriber(MySubscriber.new, :async => true)
-```
-
-This leans on Celluloid, which must be included in your Gemfile.
-
-The listener is transparently turned in to a Celluloid Actor.
-
-Please refer to [Celluloid](https://github.com/celluloid/celluloid/wiki)
-for more information, particually the
-[Gotchas](https://github.com/celluloid/celluloid/wiki/Gotchas).
+Please refer to the [wisper-async](https://github.com/krisleech/wisper-async) gem.
 
 ### ActiveRecord
 
 ```ruby
-class Post < ActiveRecord::Base
-  include Wisper
+class Bid < ActiveRecord::Base
+  include Wisper::Publisher
 
-  def create
-    if save
-      publish(:create_post_successful, self)
+  validates :amount, :presence => true
+
+  def commit(_attrs = nil)
+    assign_attributes(_attrs) if _attrs.present?
+    if valid?
+      save!
+      publish(:create_bid_successful, self)
     else
-      publish(:create_post_failed, self)
+      publish(:create_bid_failed, self)
     end
   end
 end
@@ -107,22 +98,28 @@ end
 ### ActionController
 
 ```ruby
-class PostsController < ApplicationController
+class BidsController < ApplicationController
+  def new
+    @bid = Bid.new
+  end
+
   def create
-    @post = Post.new(params[:post])
+    @bid = Bid.new(params[:bid])
 
-    @post.subscribe(PusherListener.new)
-    @post.subscribe(ActivityListener.new)
-    @post.subscribe(StatisticsListener.new)
+    @bid.subscribe(PusherListener.new)
+    @bid.subscribe(ActivityListener.new)
+    @bid.subscribe(StatisticsListener.new)
 
-    @post.on(:create_post_successful) { |post| redirect_to post }
-    @post.on(:create_post_failed)     { |post| render :action => :new }
+    @bid.on(:create_bid_successful) { |bid| redirect_to bid }
+    @bid.on(:create_bid_failed)     { |bid| render :action => :new }
 
-    @post.create
+    @bid.commit
   end
 end
 ```
 
+A full CRUD example is shown in the [Wiki](https://github.com/krisleech/wisper/wiki).
+
 ### Service/Use Case/Command objects
 
 A Service object is useful when an operation is complex, interacts with more
@@ -131,7 +128,7 @@ responsibility.
 
 ```ruby
 class PlayerJoiningTeam
-  include Wisper
+  include Wisper::Publisher
 
   def execute(player, team)
     membership = Membership.new(player, team)
@@ -210,6 +207,24 @@ Wisper::GlobalListeners.add_listener(MyListener.new)
 
 In a Rails app you might want to add your global listeners in an initalizer.
 
+Global listeners are threadsafe.
+
+## Temporary Global Listeners
+
+You can also globally subscribe listeners for the duration of a block.
+
+```ruby
+Wisper.with_listeners(MyListener.new, OtherListener.new) do
+  # do stuff
+end
+```
+
+Any events broadcast within the block by any publisher will be sent to the
+listeners. This is useful if you have a child object which publishes an event
+which is not bubbled down to a parent publisher.
+
+Temporary Global Listeners are threadsafe.
+
 ## Subscribing to selected events
 
 By default a listener will get notified of all events it can respond to. You
@@ -311,7 +326,8 @@ See `spec/lib/rspec_extensions_spec.rb` for a runnable example.
 
 ## Compatibility
 
-Tested with 1.9.x on MRI, JRuby and Rubinius.
+Tested with MRI 1.9.x, MRI 2.0.0, JRuby (1.9 and 2.0 mode) and Rubinius (1.9
+mode).
 See the [build status](https://travis-ci.org/krisleech/wisper) for details.
 
 ## License

data/lib/wisper.rb

@@ -1,50 +1,19 @@
-require "wisper/version"
-require "wisper/registration/registration"
-require "wisper/registration/object"
-require "wisper/registration/object/async_listener"
-require "wisper/registration/block"
+require 'set'
+require 'wisper/version'
+require 'wisper/publisher'
+require 'wisper/registration/registration'
+require 'wisper/registration/object'
+require 'wisper/registration/block'
 require 'wisper/global_listeners'
+require 'wisper/temporary_listeners'
 
 module Wisper
-  def listeners
-    @listeners ||= Set.new
+  def self.included(base)
+    warn "[DEPRECATION] `include Wisper::Publisher` instead of `include Wisper`"
+    base.class_eval { include Wisper::Publisher  }
   end
 
-  def add_listener(listener, options = {})
-    listeners << ObjectRegistration.new(listener, options)
-    self
-  end
-
-  alias :subscribe :add_listener
-
-  def add_block_listener(options = {}, &block)
-    listeners << BlockRegistration.new(block, options)
-    self
-  end
-
-  # sugar
-  def respond_to(event, &block)
-    add_block_listener({:on => event}, &block)
-  end
-
-  alias :on :respond_to
-
-  private
-
-  def all_listeners
-    listeners.merge(GlobalListeners.listeners)
-  end
-
-  def broadcast(event, *args)
-    all_listeners.each do | listener |
-      listener.broadcast(clean_event(event), *args)
-    end
-  end
-
-  alias :publish  :broadcast
-  alias :announce :broadcast
-
-  def clean_event(event)
-    event.to_s.gsub('-', '_')
+  def self.with_listeners(*args, &block)
+    TemporaryListeners.with(*args, &block)
   end
 end

data/lib/wisper/global_listeners.rb

@@ -3,26 +3,51 @@ require 'singleton'
 module Wisper
   class GlobalListeners
     include Singleton
+    attr_reader :mutex
+    private :mutex
 
     def initialize
-      @listeners = Set.new
+      @registrations = Set.new
+      @mutex         = Mutex.new
     end
 
     def add_listener(listener, options = {})
-      listeners << ObjectRegistration.new(listener, options)
+      with_mutex { @registrations << ObjectRegistration.new(listener, options) }
       self
     end
 
+    def registrations
+      with_mutex { @registrations }
+    end
+
     def listeners
-      @listeners
+      registrations.map(&:listener).freeze
+    end
+
+    def clear
+      with_mutex { @registrations.clear }
     end
 
     def self.add_listener(listener, options = {})
       instance.add_listener(listener, options)
     end
 
+    def self.registrations
+      instance.registrations
+    end
+
     def self.listeners
       instance.listeners
     end
+
+    def self.clear
+      instance.clear
+    end
+
+    private
+
+    def with_mutex
+      mutex.synchronize { yield }
+    end
   end
 end

data/lib/wisper/publisher.rb

@@ -0,0 +1,58 @@
+module Wisper
+  module Publisher
+    def listeners
+      registrations.map(&:listener).freeze
+    end
+
+    def add_listener(listener, options = {})
+      local_registrations << ObjectRegistration.new(listener, options)
+      self
+    end
+
+    alias :subscribe :add_listener
+
+    def add_block_listener(options = {}, &block)
+      local_registrations << BlockRegistration.new(block, options)
+      self
+    end
+
+    # sugar
+    def respond_to(event, &block)
+      add_block_listener({:on => event}, &block)
+    end
+
+    alias :on :respond_to
+
+    private
+
+    def local_registrations
+      @local_registrations ||= Set.new
+    end
+
+    def global_registrations
+      GlobalListeners.registrations
+    end
+
+    def temporary_registrations
+      TemporaryListeners.registrations
+    end
+
+    def registrations
+      local_registrations + global_registrations + temporary_registrations
+    end
+
+    def broadcast(event, *args)
+      registrations.each do | registration |
+        registration.broadcast(clean_event(event), *args)
+      end
+    end
+
+    alias :publish  :broadcast
+    alias :announce :broadcast
+
+    def clean_event(event)
+      event.to_s.gsub('-', '_')
+    end
+  end
+end
+

data/lib/wisper/registration/object.rb

@@ -1,27 +1,17 @@
-begin
-  require 'celluloid/autostart'
-rescue LoadError
-  # no-op
-end
-
 module Wisper
   class ObjectRegistration < Registration
-    attr_reader :with, :async
+    attr_reader :with
 
     def initialize(listener, options)
       super(listener, options)
       @with  = options[:with]
-      @async = options.fetch(:async, false)
+      fail_on_async if options.has_key?(:async)
     end
 
     def broadcast(event, *args)
       method_to_call = map_event_to_method(event)
       if should_broadcast?(event) && listener.respond_to?(method_to_call)
-        unless async
-          listener.public_send(method_to_call, *args)
-        else
-          AsyncListener.new(listener, method_to_call).async.public_send(method_to_call, *args)
-        end
+        listener.public_send(method_to_call, *args)
       end
     end
 
@@ -30,5 +20,9 @@ module Wisper
     def map_event_to_method(event)
       with || event
     end
+
+    def fail_on_async
+      raise 'The async feature has been moved to the wisper-async gem'
+    end
   end
 end

data/lib/wisper/rspec/stub_wisper_publisher.rb

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

data/lib/wisper/temporary_listeners.rb

@@ -0,0 +1,41 @@
+module Wisper
+  class TemporaryListeners
+
+    def self.with(*listeners, &block)
+      options = listeners.last.is_a?(Hash) ? listeners.pop : {}
+      new.with(listeners, options, &block)
+    end
+
+    def self.registrations
+      new.registrations
+    end
+
+    def with(listeners, options, &block)
+      add_listeners(listeners, options)
+      yield
+      clear
+    end
+
+    def registrations
+      Thread.current[key] ||= Set.new
+    end
+
+    private
+
+    def clear
+      registrations.clear
+    end
+
+    def add_listeners(listeners, options)
+      listeners.each { |listener| add_listener(listener, options)}
+    end
+
+    def add_listener(listener, options)
+      registrations << ObjectRegistration.new(listener, options)
+    end
+
+    def key
+      '__wisper_temporary_listeners'
+    end
+  end
+end

data/lib/wisper/version.rb

@@ -1,3 +1,3 @@
 module Wisper
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/spec/lib/async_spec.rb

@@ -1,34 +1,10 @@
 require 'spec_helper'
 
-class MyService
-  include Wisper
+describe 'async option' do
+  let(:listener)  { double('listener') }
+  let(:publisher) { publisher_class.new }
 
-  def execute
-    broadcast('success', self)
+  it 'it raises a deprecation exception' do
+      expect { publisher.add_listener(listener, :async => true) }.to raise_error
   end
 end
-
-# help me...
-$global = 'no'
-
-class MyListener
-  def success(command)
-    $global = 'yes'
-  end
-end
-
-describe Wisper do
-
-  it 'subscribes object to all published events' do
-    listener = MyListener.new
-
-    command = MyService.new
-
-    command.add_listener(listener, :async => true)
-
-    command.execute
-    sleep(1) # seriously...
-    $global.should == 'yes'
-  end
-end
-

data/spec/lib/global_subscribers_spec.rb

@@ -3,7 +3,9 @@ require 'spec_helper'
 describe Wisper::GlobalListeners do
   let(:global_listener)  { double('listener') }
   let(:local_listener)   { double('listener') }
-  let(:publisher)        { Object.new.extend(Wisper) }
+  let(:publisher)        { publisher_class.new }
+
+  after(:each) { Wisper::GlobalListeners.clear }
 
   describe '.add_listener' do
     it 'adds given listener to every publisher' do
@@ -24,5 +26,35 @@ describe Wisper::GlobalListeners do
 
       publisher.send(:broadcast, :it_happened)
     end
+
+    it 'is threadsafe' do
+      num_threads = 100
+      (1..num_threads).to_a.map do
+        Thread.new do
+          Wisper::GlobalListeners.add_listener(Object.new)
+          sleep(rand) # a little chaos
+        end
+      end.each(&:join)
+
+      Wisper::GlobalListeners.listeners.size.should == num_threads
+    end
+  end
+
+  describe '.listeners' do
+    it 'returns collection of global listeners' do
+      Wisper::GlobalListeners.add_listener(global_listener)
+      Wisper::GlobalListeners.listeners.should == [global_listener]
+    end
+
+    it 'returns an immutable collection' do
+      Wisper::GlobalListeners.listeners.frozen?.should be_true
+      expect { Wisper::GlobalListeners.listeners << global_listener }.to raise_error(RuntimeError)
+    end
+  end
+
+  it '.clear clears all global listeners' do
+    Wisper::GlobalListeners.add_listener(global_listener)
+    Wisper::GlobalListeners.clear
+    Wisper::GlobalListeners.listeners.should be_empty
   end
 end

data/spec/lib/integration_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 # Example
 class MyCommand
-  include Wisper
+  include Wisper::Publisher
 
   def execute(be_successful)
     if be_successful

data/spec/lib/simple_example_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class MyPublisher
-  include Wisper
+  include Wisper::Publisher
 
   def do_something
     # ...

data/spec/lib/temporary_global_listeners_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Wisper::TemporaryListeners do
+  let(:listener_1) { double('listener', :to_a => nil) } # [1]
+  let(:listener_2) { double('listener', :to_a => nil) }
+  let(:publisher)  { Object.class_eval { include Wisper::Publisher } }
+
+  describe '.with' do
+    it 'globally subscribes listener for duration of given block' do
+
+      listener_1.should_receive(:success)
+      listener_1.should_not_receive(:failure)
+
+      Wisper::TemporaryListeners.with(listener_1) do
+        publisher.instance_eval { broadcast(:success) }
+      end
+
+      publisher.instance_eval { broadcast(:failure) }
+    end
+
+    it 'globally subscribes listeners for duration of given block' do
+
+      listener_1.should_receive(:success)
+      listener_1.should_not_receive(:failure)
+
+      listener_2.should_receive(:success)
+      listener_2.should_not_receive(:failure)
+
+      Wisper::TemporaryListeners.with(listener_1, listener_2) do
+        publisher.instance_eval { broadcast(:success) }
+      end
+
+      publisher.instance_eval { broadcast(:failure) }
+    end
+
+    it 'ensures registrations are thread local' do
+      num_threads = 20
+      (1..num_threads).to_a.map do
+        Thread.new do
+          Wisper::TemporaryListeners.registrations << Object.new
+          Wisper::TemporaryListeners.registrations.size.should == 1
+        end
+      end.each(&:join)
+
+      Wisper::TemporaryListeners.registrations.size.should == 0
+    end
+  end
+end
+
+# [1] stubbing `to_a` prevents `Double "listener" received unexpected message
+# :to_a with (no args)` on MRI 1.9.2 when a double is passed to `Array()`.

data/spec/lib/wisper/publisher_spec.rb

@@ -0,0 +1,157 @@
+require 'spec_helper'
+
+describe Wisper::Publisher do
+  let(:listener)  { double('listener') }
+  let(:publisher) { publisher_class.new }
+
+  describe '.add_listener' do
+    it 'subscribes given listener to all published events' do
+      listener.should_receive(:this_happened)
+      listener.should_receive(:so_did_this)
+
+      publisher.add_listener(listener)
+
+      publisher.send(:broadcast, 'this_happened')
+      publisher.send(:broadcast, 'so_did_this')
+    end
+
+    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)
+
+        listener.respond_to?(:so_did_this).should be_true
+
+        publisher.add_listener(listener, :on => 'this_happened')
+
+        publisher.send(:broadcast, 'this_happened')
+        publisher.send(:broadcast, 'so_did_this')
+      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)
+
+        listener.respond_to?(:so_did_this).should be_true
+
+        publisher.add_listener(listener, :on => ['this_happened', 'and_this'])
+
+        publisher.send(:broadcast, 'this_happened')
+        publisher.send(:broadcast, 'so_did_this')
+        publisher.send(:broadcast, 'and_this')
+      end
+    end
+
+    describe ':with argument' do
+      it 'sets method to call listener with on event' do
+        listener.should_receive(:different_method).twice
+
+        publisher.add_listener(listener, :with => :different_method)
+
+        publisher.send(:broadcast, 'this_happened')
+        publisher.send(:broadcast, 'so_did_this')
+      end
+    end
+
+    it 'returns publisher so methods can be chained' do
+      publisher.add_listener(listener, :on => 'so_did_this').should == publisher
+    end
+
+    it 'is aliased to .subscribe' do
+      publisher.respond_to?(:subscribe).should be_true
+    end
+  end
+
+  describe '.add_block_listener' do
+    let(:insider) { double('insider') }
+
+    it 'subscribes given block to all events' do
+      insider.should_receive(:it_happened).twice
+
+      publisher.add_block_listener do
+        insider.it_happened
+      end
+
+      publisher.send(:broadcast, 'something_happened')
+      publisher.send(:broadcast, 'and_so_did_this')
+    end
+
+    describe ':on argument' do
+      it '.add_block_listener subscribes block to an event' do
+        insider.should_not_receive(:it_happened).once
+
+        publisher.add_block_listener(:on => 'something_happened') do
+          insider.it_happened
+        end
+
+        publisher.send(:broadcast, 'something_happened')
+        publisher.send(:broadcast, 'and_so_did_this')
+      end
+    end
+
+    it 'returns publisher so methods can be chained' do
+      publisher.add_block_listener(:on => 'this_thing_happened') do
+      end.should == publisher
+    end
+  end
+
+  describe '.on (alternative block syntax)' do
+    it 'subscribes given block to an event' do
+      insider = double('insider')
+      insider.should_receive(:it_happened)
+
+      publisher.on(:something_happened) do
+        insider.it_happened
+      end
+
+      publisher.send(:broadcast, 'something_happened')
+    end
+  end
+
+  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)
+
+      publisher.add_listener(listener, :on => 'so_did_this')
+
+      publisher.send(:broadcast, 'so_did_this')
+    end
+
+    describe ':event argument' do
+      it 'is indifferent to string and symbol' do
+        listener.should_receive(:this_happened).twice
+
+        publisher.add_listener(listener)
+
+        publisher.send(:broadcast, 'this_happened')
+        publisher.send(:broadcast, :this_happened)
+      end
+
+      it 'is indifferent to dasherized and underscored strings' do
+        listener.should_receive(:this_happened).twice
+
+        publisher.add_listener(listener)
+
+        publisher.send(:broadcast, 'this_happened')
+        publisher.send(:broadcast, 'this-happened')
+      end
+    end
+  end
+
+  describe '.listeners' do
+    it 'returns an immutable collection' do
+      publisher.listeners.frozen?.should be_true
+      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
+    end
+  end
+end

data/spec/lib/wisper_spec.rb

@@ -1,140 +1,33 @@
 require 'spec_helper'
 
 describe Wisper do
-  let(:listener)  { double('listener') }
-  let(:publisher) { Object.new.extend(Wisper) }
 
-  describe '.add_listener' do
-    it 'subscribes given listener to all published events' do
-      listener.should_receive(:this_happened)
-      listener.should_receive(:so_did_this)
-
-      publisher.add_listener(listener)
-
-      publisher.send(:broadcast, 'this_happened')
-      publisher.send(:broadcast, 'so_did_this')
-    end
-
-    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)
-
-        listener.respond_to?(:so_did_this).should be_true
-
-        publisher.add_listener(listener, :on => 'this_happened')
-
-        publisher.send(:broadcast, 'this_happened')
-        publisher.send(:broadcast, 'so_did_this')
-      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)
-
-        listener.respond_to?(:so_did_this).should be_true
-
-        publisher.add_listener(listener, :on => ['this_happened', 'and_this'])
-
-        publisher.send(:broadcast, 'this_happened')
-        publisher.send(:broadcast, 'so_did_this')
-        publisher.send(:broadcast, 'and_this')
-      end
-    end
-
-    describe ':with argument' do
-      it 'sets method to call listener with on event' do
-        listener.should_receive(:different_method).twice
-
-        publisher.add_listener(listener, :with => :different_method)
-
-        publisher.send(:broadcast, 'this_happened')
-        publisher.send(:broadcast, 'so_did_this')
-      end
-    end
-
-    it 'returns publisher so methods can be chained' do
-      publisher.add_listener(listener, :on => 'so_did_this').should == publisher
+  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
   end
 
-  describe '.add_block_listener' do
-    let(:insider) { double('insider') }
-
-    it 'subscribes given block to all events' do
-      insider.should_receive(:it_happened).twice
-
-      publisher.add_block_listener do
-        insider.it_happened
-      end
-
-      publisher.send(:broadcast, 'something_happened')
-      publisher.send(:broadcast, 'and_so_did_this')
-    end
-
-    describe ':on argument' do
-      it '.add_block_listener subscribes block to an event' do
-        insider.should_not_receive(:it_happened).once
+  it '.with_listeners subscribes listeners to all broadcast events for the duration of block' do
+    publisher = publisher_class.new
+    listener = double('listener')
 
-        publisher.add_block_listener(:on => 'something_happened') do
-          insider.it_happened
-        end
+    listener.should_receive(:im_here)
+    listener.should_not_receive(:not_here)
 
-        publisher.send(:broadcast, 'something_happened')
-        publisher.send(:broadcast, 'and_so_did_this')
-      end
+    Wisper.with_listeners(listener) do
+      publisher.send(:broadcast, 'im_here')
     end
 
-    it 'returns publisher so methods can be chained' do
-      publisher.add_block_listener(:on => 'this_thing_happened') do
-      end.should == publisher
-    end
-  end
-
-  describe '.on (alternative block syntax)' do
-    it 'subscribes given block to an event' do
-      insider = double('insider')
-      insider.should_receive(:it_happened)
-
-      publisher.on(:something_happened) do
-        insider.it_happened
-      end
-
-      publisher.send(:broadcast, 'something_happened')
-    end
+    publisher.send(:broadcast, 'not_here')
   end
+end
 
-  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)
-
-      publisher.add_listener(listener, :on => 'so_did_this')
-
-      publisher.send(:broadcast, 'so_did_this')
-    end
-
-    describe ':event argument' do
-      it 'is indifferent to string and symbol' do
-        listener.should_receive(:this_happened).twice
-
-        publisher.add_listener(listener)
-
-        publisher.send(:broadcast, 'this_happened')
-        publisher.send(:broadcast, :this_happened)
-      end
-
-      it 'is indifferent to dasherized and underscored strings' do
-        listener.should_receive(:this_happened).twice
-
-        publisher.add_listener(listener)
-
-        publisher.send(:broadcast, 'this_happened')
-        publisher.send(:broadcast, 'this-happened')
-      end
-    end
-  end
+# prevents deprecation warning showing up in spec output
+def silence_warnings
+  original_verbosity = $VERBOSE
+  $VERBOSE = nil
+  yield
+  $VERBOSE = original_verbosity
 end

data/spec/spec_helper.rb

@@ -9,3 +9,8 @@ RSpec.configure do |config|
   config.filter_run :focus
   config.order = 'random'
 end
+
+# returns an anonymous wispered class
+def publisher_class
+  Class.new { include Wisper::Publisher }
+end

data/wisper.gemspec

@@ -20,5 +20,4 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'simplecov'
-  gem.add_development_dependency 'celluloid'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wisper
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-02 00:00:00.000000000Z
+date: 2013-06-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2152451840 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152451840
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2152451300 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +37,15 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152451300
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &2152450760 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,18 +53,12 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2152450760
-- !ruby/object:Gem::Dependency
-  name: celluloid
-  requirement: &2152450220 !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *2152450220
 description: pub/sub for Ruby objects
 email:
 - kris.leech@gmail.com
@@ -71,17 +75,20 @@ files:
 - Rakefile
 - lib/wisper.rb
 - lib/wisper/global_listeners.rb
+- lib/wisper/publisher.rb
 - lib/wisper/registration/block.rb
 - lib/wisper/registration/object.rb
-- lib/wisper/registration/object/async_listener.rb
 - lib/wisper/registration/registration.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_spec.rb
 - spec/spec_helper.rb
 - wisper.gemspec
@@ -105,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: pub/sub for Ruby objects
@@ -115,6 +122,8 @@ test_files:
 - 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_spec.rb
 - spec/spec_helper.rb
 has_rdoc: 

data/lib/wisper/registration/object/async_listener.rb

@@ -1,23 +0,0 @@
-class AsyncListener
-  include Celluloid if defined?(Celluloid)
-
-  attr_reader :listener, :event_method
-
-  def initialize(listener, event_method)
-    @listener     = listener
-    @event_method = event_method.to_sym
-  end
-
-  def method_missing(method, *args, &block)
-    if listener.respond_to?(method)
-      if method == event_method
-        listener.public_send(method, *args, &block)
-        terminate
-      else
-        listener.public_send(method, *args, &block)
-      end
-    else
-      super(method, *args, &block)
-    end
-  end
-end