eventable 0.1.2 → 0.1.3

data/README.markdown

@@ -4,7 +4,7 @@ An incredibly simple way to add events to your classes.
 
 ##Description##
 
-Provides an easy to use and understand event model. Other systems did way too much for my needs. I didn't need to monitor network IO ports, I didn't want a central loop that polled IO, I just wanted a simple way to add real, non-polled events to a class and to register other classes to listen for those events.
+Provides an easy to use and understand event model. Other systems did way too much for my needs: I didn't need to monitor network IO ports, I didn't want a central loop that polled IO, I just wanted a simple way to add real, non-polled events to a class and to register other classes to listen for those events.
 
 If you want a simple way to add events to your classes without a bunch of other unrelated IO stuff this is the solution for you. (If you want to monitor IO events check out EventMachine)
 
@@ -16,6 +16,10 @@ Eventable will even automatically remove registered listeners when they get garb
 
 Eventable also allows for more fine-grain control than Observable. You can register for specific events instead of just saying, "Hey, let me know when anything changes."
 
+##Concurrency considerations##
+
+Events and threads do not scale well past a certain point but that's OK; they aren't meant to. They are meant for fast, simple communication beteen processes not large distributed processes like serving websites on massive server farms. If you need a solution that scales well to large distributed systems check out the Actor concurrency model.
+
 ##Install##
 
 `$ gem install eventable`
@@ -165,6 +169,17 @@ This example shows you how you might actually use it in a multi-threaded environ
 
 ##Version History##
 
+**2011.06.28**  
+Ver: 0.1.3  
+
+Updates:  
+
+Callbacks are now threaded:  
+This patches one of the last concurrency issues; if a callback takes a long time or hangs it won't affect any other callbacks or events that need to fire.  
+
+It's your responsiblity to make sure your callback works, as long as it does the callback thread will go out of scope (unless you retain it) and everyone is happy.  
+
+**2011.06.17**
 Ver: 0.1.2
 
 Design updates/fixes:

data/eventable.gemspec

@@ -2,7 +2,8 @@
 $:.push File.expand_path("../lib", __FILE__)
 # Kludge for older RubyGems not handling unparsable dates gracefully 
 # (psych 1.2.0 gem wouldn't build on test system so we're stuck with syck)
-YAML::ENGINE.yamler = 'syck' 
+YAML::ENGINE.yamler = 'syck'
+
 require "rubygems"
 require "eventable/version"
 
@@ -14,8 +15,12 @@ Gem::Specification.new do |s|
   s.homepage    = "http://mikbe.tk/projects#eventable"
   s.summary     = %q{An incredibly simple and easy to use event mixin module.}
   s.description = %q{Provides an easy to use and understand event model. If you want a simple, light-weight way to add events to your classes this is the solution for you.}
+  s.license     = 'MIT'
+
+  s.required_ruby_version = ">= 1.9.2"
 
   s.add_development_dependency('rspec', "~>2.6")
+  s.add_development_dependency('bundler', "~>1.0")
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {spec}/*`.split("\n")

data/example/example_output.txt

@@ -0,0 +1,56 @@
+[1] did some stuff, sleeping
+[1, 932]: do_somestuff
+firing :stuff_happens
+[1] stuff_happened callback: 824
+firing :other_stuff_happens
+[n/a] same_stuff_happened callback: n/a
+[1, 932]: do_somestuff
+firing :stuff_happens
+[1] stuff_happened callback: 407
+[1, 932]: do_somestuff
+firing :stuff_happens
+[1] stuff_happened callback: 841
+firing :other_stuff_happens
+[n/a] same_stuff_happened callback: n/a
+[1, 932]: do_somestuff
+firing :stuff_happens
+[1] stuff_happened callback: 779
+[1] slept
+[2] did some stuff, sleeping
+firing :other_stuff_happens
+[n/a] same_stuff_happened callback: n/a
+[1, 932]: do_somestuff
+firing :stuff_happens
+[1] stuff_happened callback: 252
+[2, 316]: do_somestuff
+firing :stuff_happens
+[2] stuff_happened callback: 174
+firing :other_stuff_happens
+[n/a] same_stuff_happened callback: n/a
+[2, 316]: do_somestuff
+firing :stuff_happens
+[2] stuff_happened callback: 193
+[1, 932]: do_somestuff
+firing :stuff_happens
+[1] stuff_happened callback: 535
+[2] slept
+[3] did some stuff, sleeping
+firing :other_stuff_happens
+[n/a] same_stuff_happened callback: n/a
+[2, 316]: do_somestuff
+firing :stuff_happens
+[2] stuff_happened callback: 420
+[3, 748]: do_somestuff
+firing :stuff_happens
+[3] stuff_happened callback: 545
+[2, 316]: do_somestuff
+firing :stuff_happens
+[2] stuff_happened callback: 471
+[3, 748]: do_somestuff
+firing :stuff_happens
+[2, 316]: do_somestuff
+[3] stuff_happened callback: 266
+firing :stuff_happens
+[2] stuff_happened callback: 481
+[3] slept
+all done

data/example/simple_output.txt

@@ -0,0 +1,2 @@
+firing :stuff_happens
+stuff happened callback: 454

data/lib/eventable/eventable.rb

@@ -3,40 +3,40 @@ require 'thread'
 # Incredibly simple framework for adding events
 module Eventable
 
-  # Allows for dynamic discovery of hooked callbacks
-  attr_reader :callbacks
+  module EventableEventMethods
 
-  # Add the #event method to the extending class not instances of that class
-  def self.included(base)
-    base.extend(EventableClassMethods)
-  end
-  
-  module EventableClassMethods
-    
     # register an event
     def event(event_name)
       @eventable_events ||= []
       @eventable_events << event_name unless @eventable_events.include? event_name
     end
-    
+
     # returns a list of registered events
     def events
       @eventable_events.clone
     end
-    
+
   end
 
   def events
     self.class.events
   end
-  
+
+  # Allows for dynamic discovery of hooked callbacks
+  attr_reader :callbacks
+
+  # Add the #event method to the extending class not instances of that class
+  def self.included(base)
+    base.extend(EventableEventMethods)
+  end
+
   def initialize
+    super
     @eventable_mutex = Mutex.new
   end
-  
+
   # When the event happens the class where it happens runs this
   def fire_event(event, *return_value, &block)
-    # We don't want the callback array being altered when we're trying to read it
     check_mutex
     @eventable_mutex.synchronize {
 
@@ -45,7 +45,9 @@ module Eventable
       @callbacks[event].each do |listener_id, callbacks|
         begin
           listener = ObjectSpace._id2ref(listener_id)
-          callbacks.each {|callback| listener.send callback, *return_value, &block}
+          callbacks.each do |callback|
+            Thread.new {listener.send callback, *return_value, &block}
+          end
         rescue RangeError => re
           # Don't bubble up a missing recycled object, I don't care if it's not there, I just won't call it
           raise re unless re.message.match(/is recycled object/)
@@ -61,19 +63,19 @@ module Eventable
       raise ArgumentError, "Missing parameter :#{parameter}" unless args[parameter]
     end
 
-    event = args[:event]
-    raise Errors::UnknownEvent unless events.include? event
-    
-    # Make access to the callback cache threadsafe
+    # Make access to the callback array threadsafe
     check_mutex
     @eventable_mutex.synchronize {
+      event = args[:event]
+      raise Errors::UnknownEvent unless events.include? event
+
       @callbacks ||= {}
       @callbacks[event] ||= {}
-    
+
       listener    = args[:listener]
       listener_id = listener.object_id
       callback    = args[:callback]
-    
+
       # save the callback info without creating a reference to the object
       @callbacks[event][listener_id] ||= []
       @callbacks[event][listener_id] << callback
@@ -92,7 +94,7 @@ module Eventable
     @eventable_mutex.synchronize {
       event = args[:event]
       return unless @callbacks && @callbacks[event]
-    
+
       listener_id = args[:listener_id] || args[:listener].object_id
       callback    = args[:callback]
       @callbacks[event].delete_if do |listener, callbacks|
@@ -103,7 +105,7 @@ module Eventable
   end
 
   private
-  
+
   def check_mutex
     raise Errors::SuperNotCalledInInitialize, "You must include super in your class's initialize method" unless @eventable_mutex
   end
@@ -113,7 +115,5 @@ module Eventable
   def unregister_finalizer(event, listener_id, callback)
     proc {unregister_for_event(event: event, listener_id: listener_id, callback: callback)}
   end
-  
-end
-
 
+end

data/lib/eventable/version.rb

@@ -1,3 +1,3 @@
 module Eventable
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/spec/eventable/eventable_spec.rb

@@ -1,5 +1,8 @@
 require 'spec_helper'
 
+# Callbacks are threaded to avoid blocking so tests need to wait for the callback to be scheduled and run
+CALLBACK_WAIT = 0.01
+
 describe Eventable do
 
   before(:each) do
@@ -15,8 +18,8 @@ describe Eventable do
           include Eventable
           event :do_stuff
         end
-        f = Foo.new
-        f.fire_event(:do_stuff)
+      f = Foo.new
+      f.fire_event(:do_stuff)
       }.should_not raise_error
     end
 
@@ -33,7 +36,7 @@ describe Eventable do
         f.fire_event(:do_stuff)
       }.should_not raise_error
     end
-    
+
     it "should raise an error if super is not called in initialize" do
       lambda{
         class Foo
@@ -46,7 +49,7 @@ describe Eventable do
         f.fire_event(:do_stuff)
       }.should raise_error(Eventable::Errors::SuperNotCalledInInitialize)
     end
-    
+
   end
 
   context "when specifiying an event" do
@@ -54,7 +57,7 @@ describe Eventable do
     it 'should list the event from the class' do
       EventClass.events.should include(:stuff_happens)
     end
-    
+
     it 'should list more than one event' do
       EventClass.events.should include(:other_stuff_happens)
     end
@@ -62,42 +65,39 @@ describe Eventable do
     it 'should list the event from an instance of the class' do
       @evented.events.should include(:stuff_happens)
     end
-    
+
     it 'should list more than one event from an instance' do
       @evented.events.should include(:other_stuff_happens)
     end
 
     it "should not add an event that's already been added" do
       eval %{
-        class EventClass
-          include Eventable
-          event :stuff_happens
-        end
+      class EventClass
+        include Eventable
+        event :stuff_happens
+      end
       }
       EventClass.events.count.should == 2
     end
 
     it "should not add events to other classes" do
       eval %{
-        class EventClass2
-          include Eventable
-          event :some_other_event
-        end
+      class EventClass2
+        include Eventable
+        event :some_other_event
+      end
       }
       EventClass.events.should_not include(:some_other_event)
     end
-    
+
     it "should not allow its event list to be altered external" do
       events = EventClass.events
       events.pop
       events.should_not == EventClass.events
     end
-  
-    it "should allow multiple classes to use the mixin" do
-    end
-  
+
   end
-  
+
   context "when registering for an event" do
 
     context "and there is a missing parameter" do
@@ -141,7 +141,7 @@ describe Eventable do
       @evented.register_for_event(event: :other_stuff_happens, listener: @listener, callback: :callback)
       @evented.callbacks.count.should == 2 
     end
-    
+
     it "should not add a callback that's already been added" do
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
@@ -159,6 +159,7 @@ describe Eventable do
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback2)
       @evented.do_event
+      sleep(CALLBACK_WAIT)
       @listener.callback?.should be_true
       @listener.callback2?.should be_true
     end
@@ -167,6 +168,7 @@ describe Eventable do
       # should be a no brainer because a class is an object too, but just to be sure
       @evented.register_for_event(event: :stuff_happens, listener: ListenClass, callback: :class_callback)
       @evented.do_event
+      sleep(CALLBACK_WAIT)
       ListenClass.class_callback?.should be_true
     end
 
@@ -180,6 +182,7 @@ describe Eventable do
         @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
         another_evented.register_for_event(event: :stuff_happens, listener: another_listener, callback: :callback)
         @evented.do_event
+        sleep(CALLBACK_WAIT)
         @listener.callback?.should be_true
         another_listener.callback?.should_not be_true
       end
@@ -191,6 +194,7 @@ describe Eventable do
         another_evented.register_for_event(event: :stuff_happens, listener: another_listener, callback: :callback2)
         @evented.do_event
         another_evented.do_event
+        sleep(CALLBACK_WAIT)
         @listener.callback?.should be_true
         another_listener.callback2?.should be_true
       end
@@ -198,28 +202,28 @@ describe Eventable do
     end
 
   end
-  
+
   context "when unregistering for an event" do
 
     it "should not throw an error if unregistering for an event you weren't registered for" do
       # Is this supporting sloppy programming(bad) or lazy programming(good)?
       lambda{@evented.unregister_for_event(event: :stuff_happens, listener: @listener, callback: :callback)}.should_not raise_error
     end
-  
+
     it "should remove a callback" do
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.callbacks[:stuff_happens].keys.should include(@listener.object_id) # <= just to be sure...
       @evented.unregister_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.callbacks[:stuff_happens].keys.should_not include(@listener.object_id)
     end
-  
+
     it "should not call a callback that has been removed" do
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.unregister_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.do_event
       @listener.callback?.should_not be_true
     end
-  
+
     it "should automatically remove callbacks to objects that are garbage collected" do
       listener_object_id = nil
       (0..1).each do
@@ -230,7 +234,7 @@ describe Eventable do
       GC.start
       @evented.callbacks[:stuff_happens].keys.should_not include(listener_object_id) 
     end
-  
+
   end
 
   context "when an event is fired" do
@@ -249,39 +253,40 @@ describe Eventable do
       @evented.do_event
       lambda{@evented.do_event}.should_not raise_error
     end
-  
+
     it "should call back the specified method when the event is fired" do
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.do_event
+      sleep(CALLBACK_WAIT)
       @listener.callback?.should be_true
     end
-      
+
     it "should not call back the wrong method when the event is fired" do
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.do_event
       @listener.callback2?.should_not be_true
     end
-    
+
     it "should call back more than one class" do
       listener2 = ListenClass.new
-    
+
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.register_for_event(event: :stuff_happens, listener: listener2, callback: :callback2)
-    
+
       @evented.do_event
-    
+      sleep(CALLBACK_WAIT)
       @listener.callback?.should be_true
       listener2.callback2?.should be_true
     end
 
     it "should not call back the wrong method when using multiple classes" do
       listener2 = ListenClass.new
-    
+
       @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback)
       @evented.register_for_event(event: :stuff_happens, listener: listener2, callback: :callback2)
-    
+
       @evented.do_event
-    
+      sleep(CALLBACK_WAIT)
       @listener.callback2?.should_not be_true
       listener2.callback?.should_not be_true
     end
@@ -292,6 +297,7 @@ describe Eventable do
         @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback_with_args)
         a, b, c = rand(100), rand(100), rand(100)
         @evented.do_event_with_args(a,b,c)
+        sleep(CALLBACK_WAIT)
         @listener.callback_with_args?.should == [a,b,c]
       end
 
@@ -299,6 +305,7 @@ describe Eventable do
         @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback_with_block)
         block = proc {"a block"}
         @evented.do_event_with_block(&block)
+        sleep(CALLBACK_WAIT)
         @listener.callback_with_block?.should == block
       end
 
@@ -306,17 +313,42 @@ describe Eventable do
         @evented.register_for_event(event: :stuff_happens, listener: @listener, callback: :callback_with_args_and_block)
         a, b, c, block = rand(100), rand(100), rand(100), proc {"a block"}
         @evented.do_event_with_args_and_block(a,b,c,&block)
+        sleep(CALLBACK_WAIT)
         @listener.callback_with_args_and_block?.should == [a,b,c,block]
       end
 
     end
-    
+
+    context "when multithreading" do
+
+      it "should not block on callbacks" do
+        bc = BlockingClass.new
+        @evented.register_for_event(event: :stuff_happens, listener: bc, callback: :blocking_call)
+        start_time = Time.now
+        @evented.do_event
+        sleep(CALLBACK_WAIT * 2) # Just to make sure the event cycle starts
+        Time.now.should_not > start_time + 1
+      end
+
+    end
+
   end
 
 end
 
 # Test classes
 
+class BlockingClass
+  def blocking_call
+    # I don't know how long this will take but it's a lot longer than 1 second
+    1000000000.times { Math.sqrt(98979872938749283749729384792734927) }
+    non_blocking_call
+  end
+  def non_blocking_call
+    "all done"
+  end
+end
+
 class EventClass
   include Eventable
   event :stuff_happens
@@ -339,7 +371,7 @@ class AnotherEventClass
   include Eventable
   event :stuff_happens
   event :different_happens
-  
+
   def do_event(event=:stuff_happens)
     fire_event(event)
   end
@@ -391,7 +423,7 @@ class AnotherListenClass
   def callback
     @callback = true
   end
-    def callback2?
+  def callback2?
     @callback2
   end
   def callback2

metadata

@@ -2,7 +2,7 @@
 name: eventable
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Mike Bethany
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-18 00:00:00 Z
+date: 2011-06-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -23,6 +23,17 @@ dependencies:
         version: "2.6"
   type: :development
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+  type: :development
+  version_requirements: *id002
 description: Provides an easy to use and understand event model. If you want a simple, light-weight way to add events to your classes this is the solution for you.
 email: 
 - mikbe.tk@gmail.com
@@ -33,6 +44,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- .DS_Store
 - .gitignore
 - Gemfile
 - LICENSE.txt
@@ -41,16 +53,21 @@ files:
 - autotest/discover.rb
 - eventable.gemspec
 - example/example.rb
+- example/example_output.txt
 - example/simple_example.rb
+- example/simple_output.txt
+- lib/.DS_Store
 - lib/eventable.rb
 - lib/eventable/errors.rb
 - lib/eventable/eventable.rb
 - lib/eventable/version.rb
+- spec/.DS_Store
 - spec/eventable/eventable_spec.rb
 - spec/spec_helper.rb
+- vendor/.DS_Store
 homepage: http://mikbe.tk/projects#eventable
-licenses: []
-
+licenses: 
+- MIT
 post_install_message: 
 rdoc_options: []
 
@@ -61,7 +78,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      version: "0"
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: