events 0.9.0 → 0.9.1

data/lib/events.rb

@@ -1,4 +1,5 @@
 module Events # :nodoc:
+  UncaughtError = Class.new(StandardError)
   
   # The Events::Emitter mixin provides a clone of the Node.js EventEmitter API
   # for Ruby.
@@ -23,6 +24,10 @@ module Events # :nodoc:
   # Outputs "added new listener #<Proc:0x0000000000000000@example.rb:12> for
   # event connection".
   # 
+  # When an EventEmitter experiences an error, the typical action is to emit an
+  # :error event. Error events are special -- if there is no handler for them
+  # they raise an Events::UncaughtError exception.
+  # 
   module Emitter
     
     # :call-seq: emitter.listeners(event) -> array
@@ -39,7 +44,14 @@ module Events # :nodoc:
     # Execute each of the listeners in order with the supplied arguments.
     # 
     def emit(event, *args)
-      listeners(event).each do |listener|
+      listeners = listeners(event).dup
+      
+      if event == :error && listeners.empty?
+        raise args.first if args.first.kind_of?(Exception)
+        raise Events::UncaughtError.new("Uncaught, unspecified 'error' event.")
+      end
+      
+      listeners.each do |listener|
         listener.call(*args)
       end.any?
     end
@@ -65,6 +77,15 @@ module Events # :nodoc:
       listeners(event).delete(proc)
       self
     end
+    
+    # :call-seq: emitter.remove_all_listeners(event) -> emitter
+    # 
+    # Removes all listeners from the listener array for the specified event.
+    # 
+    def remove_all_listeners(event)
+      listeners(event).clear
+      self
+    end
   end
   
   # The Events::EventEmitter class provides a clone of the Node.js EventEmitter

data/test/event_emitter_test.rb

@@ -40,6 +40,7 @@ class TestEventEmitter < Test::Unit::TestCase
     @callback1 = Proc.new do
       callbacks_called.push(:callback1)
       e.add_listener(:foo, &@callback2)
+      e.add_listener(:foo, &@callback3)
       e.remove_listener(:foo, @callback1)
     end
     
@@ -48,20 +49,78 @@ class TestEventEmitter < Test::Unit::TestCase
       e.remove_listener(:foo, @callback2)
     end
     
+    @callback3 = Proc.new do
+      callbacks_called.push(:callback3)
+      e.remove_listener(:foo, @callback3)
+    end
+    
     e.add_listener(:foo, &@callback1)
     assert_equal(1, e.listeners(:foo).length)
     
     e.emit(:foo)
-    assert_equal(1, e.listeners(:foo).length)
+    assert_equal(2, e.listeners(:foo).length)
     assert_equal([:callback1], callbacks_called)
     
     e.emit(:foo)
     assert_equal(0, e.listeners(:foo).length)
-    assert_equal([:callback1, :callback2], callbacks_called)
+    assert_equal([:callback1, :callback2, :callback3], callbacks_called)
+    
+    e.emit(:foo)
+    assert_equal(0, e.listeners(:foo).length)
+    assert_equal([:callback1, :callback2, :callback3], callbacks_called)
+    
+    e.add_listener(:foo, &@callback1)
+    e.add_listener(:foo, &@callback2)
+    assert_equal(2, e.listeners(:foo).length)
+    e.remove_all_listeners(:foo)
+    assert_equal(0, e.listeners(:foo).length)
+    
+    # Verify that removing callbacks while in emit allows emits to propagate to
+    # all listeners
+    callbacks_called = []
     
+    e.add_listener(:foo, &@callback2)
+    e.add_listener(:foo, &@callback3)
+    assert_equal(2, e.listeners(:foo).length)
     e.emit(:foo)
+    assert_equal([:callback2, :callback3], callbacks_called)
     assert_equal(0, e.listeners(:foo).length)
-    assert_equal([:callback1, :callback2], callbacks_called)
+  end
+  
+  # /test/simple/test-event-emitter-remove-listeners.js
+  def test_event_emitter_remove_listeners
+    count = 0
+    
+    listener1 = Proc.new do
+      puts("listener1")
+      count +=1
+    end
+    
+    listener2 = Proc.new do
+      puts("listener2")
+      count +=1
+    end
+    
+    listener3 = Proc.new do
+      puts("listener3")
+      count +=1
+    end
+    
+    e1 = Events::EventEmitter.new
+    e1.add_listener(:hello, &listener1)
+    e1.remove_listener(:hello, listener1)
+    assert_equal([], e1.listeners(:hello))
+    
+    e2 = Events::EventEmitter.new
+    e2.add_listener(:hello, &listener1)
+    e2.remove_listener(:hello, listener2)
+    assert_equal([listener1], e2.listeners(:hello))
+    
+    e3 = Events::EventEmitter.new
+    e3.add_listener(:hello, &listener1)
+    e3.add_listener(:hello, &listener2)
+    e3.remove_listener(:hello, listener1)
+    assert_equal([listener2], e3.listeners(:hello))
   end
   
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 9
-  - 0
-  version: 0.9.0
+  - 1
+  version: 0.9.1
 platform: ruby
 authors: 
 - Matthew Sadler
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-07 00:00:00 +01:00
+date: 2010-05-15 00:00:00 +01:00
 default_executable: 
 dependencies: []