events 0.9.6 → 0.9.7

data/lib/events.rb

@@ -1,5 +1,5 @@
 module Events # :nodoc:
-  UncaughtError = Class.new(StandardError)
+  UncaughtError = Class.new(RuntimeError)
   
   # The Events::Emitter mixin provides a clone of the Node.js EventEmitter API
   # for Ruby.
@@ -73,7 +73,8 @@ module Events # :nodoc:
       listeners = @listeners && @listeners.key?(event) && @listeners[event]
       
       if event == :error && (!listeners || listeners.empty?)
-        raise args.first if args.first.kind_of?(Exception)
+        raise *args if args.first.respond_to?(:exception)
+        raise Events::UncaughtError, args.first if args.first.is_a?(String)
         raise Events::UncaughtError.new("Uncaught, unspecified 'error' event.")
       elsif listeners
         listeners.dup.each do |listener|
@@ -134,7 +135,7 @@ module Events # :nodoc:
       end
       once = OnceWrapper.new do |*args|
         remove_listener(event, once)
-        listener.call(args)
+        listener.call(*args)
       end
       once.original = listener
       

data/test/events_test.rb

@@ -0,0 +1,156 @@
+require "test/unit"
+require "../lib/events"
+require "stringio"
+
+class TestEvents < Test::Unit::TestCase
+  
+  def test_emit_error_raises_without_handler
+    emitter = Events::EventEmitter.new
+    
+    assert_raise(Events::UncaughtError) {emitter.emit(:error)}
+    assert_raise(Events::UncaughtError) {emitter.emit(:error, "error")}
+    assert(Events::UncaughtError < RuntimeError, "should be a subclass")
+    assert_raise(StandardError) {emitter.emit(:error, StandardError.new("error"))}
+    assert_raise(StandardError) {emitter.emit(:error, StandardError, "error")}
+  end
+  
+  def test_emit_error_raises_without_handler_with_correct_message
+    emitter = Events::EventEmitter.new
+    
+    begin
+      emitter.emit(:error)
+    rescue => e
+      assert_equal("Uncaught, unspecified 'error' event.", e.message)
+    end
+    
+    begin
+      emitter.emit(:error, "test error message")
+    rescue => e
+      assert_equal("test error message", e.message)
+    end
+    
+    begin
+      emitter.emit(:error, StandardError.new("error test message"))
+    rescue => e
+      assert_equal("error test message", e.message)
+    end
+    
+    begin
+      emitter.emit(:error, StandardError, "message test error")
+    rescue => e
+      assert_equal("message test error", e.message)
+    end
+  end
+  
+  def test_any_listener_that_responds_to_call_is_accepted
+    emitter = Events::EventEmitter.new
+    block_result, proc_result, lambda_result = nil
+    stringio = StringIO.new
+    object = Object.new
+    class << object
+      attr_reader :result
+      def call
+        @result = true
+      end
+    end
+    
+    emitter.add_listener(:block) {block_result = true}
+    emitter.emit(:block)
+    assert(block_result, "block not called")
+    
+    emitter.add_listener(:proc, Proc.new {proc_result = true})
+    emitter.emit(:proc)
+    assert(proc_result, "proc not called")
+    
+    emitter.add_listener(:lambda, lambda {lambda_result = true})
+    emitter.emit(:lambda)
+    assert(lambda_result, "lambda not called")
+    
+    emitter.add_listener(:method, stringio.method(:puts))
+    emitter.emit(:method)
+    assert_equal("\n", stringio.string)
+    
+    emitter.add_listener(:object, object)
+    emitter.emit(:object)
+    assert(object.result, "object not called")
+  end
+  
+  def test_any_once_listener_that_responds_to_call_is_accepted
+    emitter = Events::EventEmitter.new
+    block_result, proc_result, lambda_result = nil
+    stringio = StringIO.new
+    object = Object.new
+    class << object
+      attr_reader :result
+      def call
+        @result = true
+      end
+    end
+    
+    emitter.once(:block) {block_result = true}
+    emitter.emit(:block)
+    assert(block_result, "block not called")
+    
+    emitter.once(:proc, Proc.new {proc_result = true})
+    emitter.emit(:proc)
+    assert(proc_result, "proc not called")
+    
+    emitter.once(:lambda, lambda {lambda_result = true})
+    emitter.emit(:lambda)
+    assert(lambda_result, "lambda not called")
+    
+    emitter.once(:method, stringio.method(:puts))
+    emitter.emit(:method)
+    assert_equal("\n", stringio.string)
+    
+    emitter.once(:object, object)
+    emitter.emit(:object)
+    assert(object.result, "object not called")
+  end
+  
+  def test_listener_is_required_to_respond_to_call
+    emitter = Events::EventEmitter.new
+    
+    assert_raise(ArgumentError) {emitter.on(:test)}
+    assert_raise(ArgumentError) {emitter.on(:test, "foo")}
+    assert_raise(ArgumentError) {emitter.once(:test)}
+    assert_raise(ArgumentError) {emitter.once(:test, "foo")}
+  end
+  
+  def test_multi_arguments
+    emitter = Events::EventEmitter.new
+    
+    emitter.on(:block) do |a, b|
+      assert_equal("a", a)
+      assert_equal("b", b)
+    end
+    
+    emitter.emit(:block, "a", "b")
+    
+    emitter.on(:lambda, lambda do |a, b|
+      assert_equal("a", a)
+      assert_equal("b", b)
+    end)
+    
+    emitter.emit(:lambda, "a", "b")
+  end
+  
+  def test_multi_arguments_once
+    emitter = Events::EventEmitter.new
+    
+    emitter.once(:block) do |a, b|
+      assert_equal("a", a)
+      assert_equal("b", b)
+    end
+    
+    emitter.emit(:block, "a", "b")
+    
+    emitter.once(:lambda, lambda do |a, b|
+      assert_equal("a", a)
+      assert_equal("b", b)
+    end)
+    
+    emitter.emit(:lambda, "a", "b")
+  end
+  
+end

data/test/{event_emitter_test.rb → node_transliterated_test.rb}

@@ -122,6 +122,54 @@ class TestEventEmitter < Test::Unit::TestCase
     assert_equal(0, e.listeners(:foo).length)
   end
   
+  # /test/simple/test-event-emitter-num-args.js
+  def test_event_emitter_num_args
+    e = Events::EventEmitter.new
+    num_args_emited = []
+    
+    e.on(:num_args) do |*args|
+      num_args = args.length
+      puts "num_args: #{num_args}"
+      num_args_emited.push(num_args)
+    end
+    
+    puts "start"
+    
+    e.emit(:num_args)
+    e.emit(:num_args, nil)
+    e.emit(:num_args, nil, nil)
+    e.emit(:num_args, nil, nil, nil)
+    e.emit(:num_args, nil, nil, nil, nil)
+    e.emit(:num_args, nil, nil, nil, nil, nil)
+    
+    assert_equal([0, 1, 2, 3, 4, 5], num_args_emited)
+  end
+  
+  # /test/simple/test-event-emitter-once.js
+  def test_event_emitter_once
+    e = Events::EventEmitter.new
+    times_hello_emited = 0
+    
+    e.once(:hello) do |a, b|
+      times_hello_emited += 1
+    end
+    
+    e.emit(:hello, "a", "b")
+    e.emit(:hello, "a", "b")
+    e.emit(:hello, "a", "b")
+    e.emit(:hello, "a", "b")
+    
+    remove = Proc.new do
+      flunk("once->foo should not be emitted")
+    end
+    
+    e.once(:foo, remove)
+    e.remove_listener(:foo, remove)
+    e.emit(:foo)
+    
+    assert_equal(1, times_hello_emited)
+  end
+  
   # /test/simple/test-event-emitter-remove-all-listeners.js
   def test_event_emitter_remove_all_listeners
     listener = Proc.new {}
@@ -177,52 +225,4 @@ class TestEventEmitter < Test::Unit::TestCase
     assert_equal([listener2], e3.listeners(:hello))
   end
   
-  # /test/simple/test-event-emitter-once.js
-  def test_event_emitter_once
-    e = Events::EventEmitter.new
-    times_hello_emited = 0
-    
-    e.once(:hello) do |a, b|
-      times_hello_emited += 1
-    end
-    
-    e.emit(:hello, "a", "b")
-    e.emit(:hello, "a", "b")
-    e.emit(:hello, "a", "b")
-    e.emit(:hello, "a", "b")
-    
-    remove = Proc.new do
-      flunk("once->foo should not be emitted")
-    end
-    
-    e.once(:foo, remove)
-    e.remove_listener(:foo, remove)
-    e.emit(:foo)
-    
-    assert_equal(1, times_hello_emited)
-  end
-  
-  # /test/simple/test-event-emitter-num-args.js
-  def test_event_emitter_num_args
-    e = Events::EventEmitter.new
-    num_args_emited = []
-    
-    e.on(:num_args) do |*args|
-      num_args = args.length
-      puts "num_args: #{num_args}"
-      num_args_emited.push(num_args)
-    end
-    
-    puts "start"
-    
-    e.emit(:num_args)
-    e.emit(:num_args, nil)
-    e.emit(:num_args, nil, nil)
-    e.emit(:num_args, nil, nil, nil)
-    e.emit(:num_args, nil, nil, nil, nil)
-    e.emit(:num_args, nil, nil, nil, nil, nil)
-    
-    assert_equal([0, 1, 2, 3, 4, 5], num_args_emited)
-  end
-  
 end

metadata

@@ -1,13 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: events
 version: !ruby/object:Gem::Version 
-  hash: 55
   prerelease: false
   segments: 
   - 0
   - 9
-  - 6
-  version: 0.9.6
+  - 7
+  version: 0.9.7
 platform: ruby
 authors: 
 - Matthew Sadler
@@ -15,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-25 00:00:00 +01:00
+date: 2011-08-06 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -29,7 +28,8 @@ extra_rdoc_files:
 - readme.rdoc
 files: 
 - lib/events.rb
-- test/event_emitter_test.rb
+- test/events_test.rb
+- test/node_transliterated_test.rb
 - readme.rdoc
 has_rdoc: true
 homepage: http://github.com/matsadler/rb-event-emitter
@@ -42,29 +42,26 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Clone of the node.js EventEmitter api for Ruby
 test_files: 
-- test/event_emitter_test.rb
+- test/events_test.rb
+- test/node_transliterated_test.rb