eventable 0.1.0.beta1 → 0.1.0.beta2

data/README.markdown

@@ -8,7 +8,9 @@ Provides an easy to use and understand event model. Other systems did way too mu
 
 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)
 
-You don't have to worry about memory leaks either because Eventable only make a reference to the listening object when it needs to talk to it then it disposes of that reference. Best of all it will automatically remove registered listeners when they get garbage collected.
+You might be saying, "What about Observable? Why not just use that?" The problem with observable is that it saves a reference to the observing object. If you drop and add a bunch of them you've got the potential for a huge memory leak. With Eventable you don't have to worry about memory leaks because Eventable only make a reference to the listening object when it needs to talk to it and when it's done it disposes of that reference. Eventable will even automatically remove registered listeners when they get garbage collected. You can set up a listener and not worry about removing your event hook yourself, it's done for you.
+
+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."
 
 Eventable couldn't be easier to use. 
 

data/lib/eventable/eventable.rb

@@ -31,10 +31,19 @@ module Eventable
   # When the event happens the class where it happens runs this
   def fire_event(event, *return_value, &block)
     return false unless @callbacks[event] && !@callbacks[event].empty?
-    @callbacks[event].each do |listener_id, callbacks|
-      listener = ObjectSpace._id2ref(listener_id)
-      callbacks.each {|callback| listener.send callback, *return_value, &block}
-    end
+    
+    # We don't want the callback array being altered when we're trying to read it
+    @mutex.synchronize{
+      @callbacks[event].each do |listener_id, callbacks|
+        begin
+          listener = ObjectSpace._id2ref(listener_id)
+          callbacks.each {|callback| listener.send callback, *return_value, &block}
+        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/)
+        end
+      end
+    }
   end
 
   # Allows an object to listen for an event and have a callback run when the event happens
@@ -45,23 +54,27 @@ module Eventable
 
     event = args[:event]
     raise Errors::UnknownEvent unless events.include? event
-    @callbacks ||= {}
-    @callbacks[event] ||= {}
     
-    listener    = args[:listener]
-    listener_id = listener.object_id
-    callback    = args[:callback]
+    # Make access to the callback cache threadsafe
+    @mutex ||= Mutex.new
+    @mutex.synchronize {
+      @callbacks ||= {}
+      @callbacks[event] ||= {}
     
-    # save the callback info without creating a reference to the object
-    @callbacks[event][listener_id] ||= []
-    @callbacks[event][listener_id] << callback
-
-    # will remove the object from the callback list if it is destroyed
-    ObjectSpace.define_finalizer(
-      listener, 
-      unregister_finalizer(event, listener_id, callback)
-    )
+      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
 
+      # will remove the object from the callback list if it is destroyed
+      ObjectSpace.define_finalizer(
+        listener, 
+        unregister_finalizer(event, listener_id, callback)
+      )
+    }
   end
 
   # Allows objects to stop listening to events
@@ -72,10 +85,12 @@ module Eventable
     listener_id = args[:listener_id] || args[:listener].object_id
     callback    = args[:callback]
     
-    @callbacks[event].delete_if do |listener, callbacks|
-      callbacks.delete(callback) if listener == listener_id
-      callbacks.empty?
-    end
+    @mutex.synchronize {
+      @callbacks[event].delete_if do |listener, callbacks|
+        callbacks.delete(callback) if listener == listener_id
+        callbacks.empty?
+      end
+    }
   end
 
   # Wrapper for the finalize proc. You have to call a method

data/lib/eventable/version.rb

@@ -1,3 +1,3 @@
 module Eventable
-  VERSION = "0.1.0.beta1"
+  VERSION = "0.1.0.beta2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: eventable
 version: !ruby/object:Gem::Version
-  version: 0.1.0.beta1
+  version: 0.1.0.beta2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-06-05 00:00:00.000000000Z
+date: 2011-06-06 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2156146420 !ruby/object:Gem::Requirement
+  requirement: &2156717840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,7 @@ dependencies:
         version: '2.6'
   type: :development
   prerelease: false
-  version_requirements: *2156146420
+  version_requirements: *2156717840
 description: Provides an easy to use and understand event model. 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)