unobservable 0.1.4 → 0.4.0

data/README.rdoc

@@ -7,9 +7,31 @@ then the Observable mixin is the wrong tool for the job.
 Unobservable overcomes the limitations of the Observable mixin by allowing objects to own one or more Event
 objects.
 
+== 2-Second Tour
+
+  require 'unobservable'
+
+
+  class Button
+    include Unobservable::Support
+
+    attr_event :clicked
+
+    def click(x, y)
+      raise_event(:clicked, x, y)
+    end
+  end
+
+
+  button  = Button.new
+  button.clicked.register {|x, y| puts "You just clicked: #{x} #{y}"}
+
+  button.click(2, 3)
+
+
 == 2-Minute Tour
 
-Instead of a lengthy introduction, here's a short program that demonstrates the main concepts:
+Now here's a slightly-longer demonstration of Unobservable.  This time, I even included comments!
 
 
   require 'unobservable'

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.4.0

data/lib/unobservable.rb

@@ -15,6 +15,11 @@ module Unobservable
       contributors += mod.ancestors[1...-1] if mod.is_a? Class
     end
 
+    self.collect_instance_events_defined_by(contributors)
+  end
+
+
+  def self.collect_instance_events_defined_by(contributors)
     retval = Set.new
     
     contributors.each do |c|
@@ -29,88 +34,92 @@ module Unobservable
   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)
-      Unobservable.instance_events_for(self, include_supers)
+    def instance_events(all = true)
+      Unobservable.instance_events_for(self, all)
     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
       
       names.each do |n|
-        @unobservable_instance_events.add(n.to_sym)
         define_method n do
           return event(n)
         end
+        @unobservable_instance_events.add(n.to_sym)
       end
       
       return @unobservable_instance_events.to_a
     end
+    
+    alias :define_event :attr_event
 
   end
 
 
 
-  module ObjectSupport
+  module Support
 
-    def events
-      unobservable_events_map.keys
+    def self.extended(obj)
+      obj.singleton_class.extend ModuleSupport
     end
     
-    def event(name)
-      unobservable_events_map[name]
+    def self.included(other_mod)
+      other_mod.extend ModuleSupport
     end
+    
 
-    private
-    def raise_event(name, *args, &block)
-      event(name).call(*args, &block)
+    def singleton_events(all = true)
+      if all
+        contributors  = self.singleton_class.included_modules
+        contributors -= self.class.included_modules
+        contributors.push self.singleton_class
+        Unobservable.collect_instance_events_defined_by(contributors)
+      else
+        Unobservable.collect_instance_events_defined_by([self.singleton_class])
+      end
     end
+
     
-    
-    def unobservable_events_map
-      @unobservable_events_map ||= initialize_unobservable_events_map(self.class)
+    def define_singleton_event(*name)
+      self.singleton_class.send(:attr_event, *name)
     end
 
-
-    def initialize_unobservable_events_map(clazz)
-      retval = {}
-      if clazz.respond_to? :instance_events
-        clazz.instance_events.each do |e|
-          retval[e] = Event.new
+    def events(all = true)
+      self.singleton_class.instance_events(all)
+    end
+    
+    def event(name)
+      @unobservable_events_map ||= {}
+      e = @unobservable_events_map[name]
+      if not e
+        if self.events.include? name
+          e = Event.new
+          @unobservable_events_map[name] = e
+        else
+          raise NameError, "Undefined event: #{name}"
         end
       end
+      return e
+    end
 
-      return retval
+    private
+    def raise_event(name, *args, &block)
+      event(name).call(*args, &block)
     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
+
 
 
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: unobservable
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-04 00:00:00.000000000 Z
+date: 2012-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
@@ -108,7 +108,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 1737406497350544853
+      hash: -2089249244928206460
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: