unobservable 0.1.1 → 0.1.3

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.1.3

data/lib/unobservable.rb

@@ -2,6 +2,10 @@ require 'set'
 
 module Unobservable
 
+  # Produces a list of instance events for any module regardless of whether or
+  # not that module includes the Unobservable::ModuleSupport mixin.  If
+  # include_supers = true, then the list will also contain instance events
+  # defined by superclasses and included modules.  By default, include_supers = true
   def self.instance_events_for(mod, include_supers = true)
     raise TypeError, "Only modules and classes can have instance_events" unless mod.is_a? Module
 
@@ -24,18 +28,22 @@ module Unobservable
     return retval.to_a
   end
 
+
+
+  # This module is a mixin that provides support for "instance events".
   module ModuleSupport
+    
+    # This is just a shortcut for Unobservable#instance_events_for .   It passes
+    # in self as the first argument.
     def instance_events(include_supers = true)
-      if include_supers == false
-        @unobservable_instance_events ||= Set.new
-        return @unobservable_instance_events.to_a
-      else
-        return Unobservable.instance_events_for(self, true)
-      end
+      Unobservable.instance_events_for(self, include_supers)
     end
 
 
     private
+    
+    # This helper method is similar to attr_reader and attr_accessor.  It allows
+    # for instance events to be declared inside the body of the class.
     def attr_event(*names)
       @unobservable_instance_events ||= Set.new
       
@@ -48,16 +56,12 @@ module Unobservable
       
       return @unobservable_instance_events.to_a
     end
-  end
-
 
+  end
 
 
-  module Support
 
-    def self.included(other_mod)
-      other_mod.extend ModuleSupport
-    end
+  module ObjectSupport
 
     def events
       unobservable_events_map.keys
@@ -68,6 +72,11 @@ module Unobservable
     end
 
     private
+    def raise_event(name, *args, &block)
+      event(name).call(*args, &block)
+    end
+    
+    
     def unobservable_events_map
       @unobservable_events_map ||= initialize_unobservable_events_map(self.class)
     end
@@ -85,6 +94,23 @@ module Unobservable
     end
     
   end
+  
+  
+  # Typically, when you add support for Events to a class, you also want
+  # support for the handy attr_event keyword.  So, including this module
+  # is equivalent to the following:
+  #
+  # class MyClass
+  #   extend  Unobservable::ModuleSupport  # Get support for the attr_event keyword
+  #   include Unobservable::ObjectSupport  # Get support for the instance methods
+  # end
+  module Support
+    include ObjectSupport
+    
+    def self.included(other_mod)
+      other_mod.extend ModuleSupport
+    end
+  end
 
 
 
@@ -133,6 +159,7 @@ module Unobservable
     end
 
 
+    
     # Pass the specific arguments / block to all of the
     # event handlers.  Return true if there was at least
     # 1 event handler; return false otherwise.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: unobservable
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -107,7 +107,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1272519931839892876
+      hash: 2472220124637666856
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: