unobservable 0.6.1 → 0.8.0

data/TODO.rdoc

@@ -1,5 +1,5 @@
 = TODO
 
-* Add support for singleton events
 * Figure out a decent way to restrict access to Unobservable::Event#call to encourage proper encapsulation.
+* Move Unobservable::Event#handler_for to Unobservable::handler_for
 

data/VERSION

@@ -1 +1 @@
-0.6.1
+0.8.0

data/lib/unobservable.rb

@@ -165,7 +165,12 @@ module Unobservable
       if block
         return block
       elsif args.size == 1
-        return args[0]
+        candidate = args[0]
+        if candidate.respond_to?(:to_proc)
+          return candidate.to_proc
+        else
+          raise ArgumentError, "The argument does not respond to the #to_proc method"
+        end
       elsif args.size == 2
         return args[0].method(args[1])
       end
@@ -208,7 +213,11 @@ module Unobservable
       else
         # TODO: Add some form of error-handling
         @handlers.each do |h|
-          h.call(*args, &block)
+          begin
+            h.call(*args, &block)
+          rescue Exception
+            # TODO: Should probably log when this happens
+          end
         end
 
         return true

data/spec/event_spec.rb

@@ -2,5 +2,158 @@ require 'spec_helper'
 
 module Unobservable
   
+  describe Event do
+    
+    let(:e) { Event.new }
+    
+    describe "#handler_for" do
+      it "raises an ArgumentError when it does not receive any arguments" do
+        expect{ e.handler_for() }.to raise_error(ArgumentError)
+      end
+
+
+      it "raises an ArgumentError when it is receives an argument that cannot be converted into a Proc" do
+        expect{ e.handler_for(Object.new) }.to raise_error(ArgumentError)
+      end
+      
+      it "allows a Proc to be used has an event handler" do
+        p = Proc.new {}
+        e.handler_for(p).should == p
+      end
+      
+      it "allows a Block to be used as an event handler" do
+        p = Proc.new {}
+        e.handler_for(&p).should == p
+      end
+      
+      it "can use a specified method on an object as an event handler" do
+        x = Object.new
+        e.handler_for(x, :class).should == x.method(:class)
+      end
+      
+      
+      it "raises an ArgumentError when it receives 3 or more arguments" do
+        expect{ e.handler_for(Proc.new, :foo, :bar) }.to raise_error(ArgumentError)
+      end
+
+
+    end
+    
+    
+    describe "#register" do
+      
+      it "returns the event handler that was added to the event's list of handlers" do
+        handler = Proc.new {}
+        e.register(handler).should == handler
+      end
+      
+      it "adds an event handler to the event's list of handlers" do
+        handler = Proc.new {}
+        
+        expect do
+          e.register(handler)
+        end.to change{ e.handlers.size }.from(0).to(1)
+        
+        e.handlers.should include(handler)
+      end
+      
+      it "allows multiple event handlers to be registered to the same event" do
+        h1 = Proc.new { puts "one" }
+        h2 = Proc.new { puts "two" }
+                
+        expect do
+          e.register h1
+          e.register h2
+        end.to change{ e.handlers.size }.from(0).to(2)
+        
+        e.handlers.should include(h1)
+        e.handlers.should include(h2)
+        
+        h1.should_not == h2
+      end
+      
+      
+      it "allows the same event handler to be registered multiple times" do
+        handler = Proc.new {}
+        
+        expect do
+          3.times { e.register handler }
+        end.to change{ e.handlers.size }.from(0).to(3)
+        
+        e.handlers.each {|h| h.should == handler}
+      end
+      
+    end
+    
+    
+    describe "#unregister" do
+
+      it "returns nil when asked to unregister a handler that was never registered" do
+        p = Proc.new {}
+        e.handlers.should_not include(p)
+        e.unregister(p).should be_nil
+      end
+
+      it "returns the handler that was unregistered" do
+        p = Proc.new {}
+        e.register p
+        
+        e.handlers.should include(p)
+        expect do
+          e.unregister(p).should == p
+        end.to change{ e.handlers.size }.from(1).to(0)
+        
+        e.handlers.should_not include(p)
+      end
+      
+      
+      it "only unregisters 1 occurrence of the specified event handler" do
+        p = Proc.new { "hello" }
+        3.times { e.register p }
+                
+        expect{ e.unregister p }.to change{ e.handlers.size }.from(3).to(2)
+        
+        e.handlers.each{|h| h.should == p}
+      end
+
+    end
+    
+    
+    
+    describe "#call" do
+      it "can be called when no event handlers have been registered" do
+        expect{ e.call }.to_not raise_error
+        expect{ e.call 1, 2, 3 }.to_not raise_error
+      end
+      
+      it "passes its arguments to each event handler" do
+        3.times do |i|
+          h = mock("handler #{i}")
+          h.should_receive(:some_method).with("arg1", "arg2")
+          e.register h, :some_method
+        end
+        
+        e.call "arg1", "arg2"
+      end
+      
+      
+      it "should invoke each event handler even if one or more event handlers raise an exception." do
+        3.times do |i|
+          h = mock("handler #{i}")
+          h.should_receive(:some_method).with("arg1", "arg2").and_raise(Exception)
+          e.register h, :some_method
+        end
+        
+        expect{ e.call "arg1", "arg2" }.to_not raise_error
+      end
+      
+    end
+    
+  end
+  
+  
   
-end
+  
+end
+
+

data/spec/spec_helper.rb

@@ -9,3 +9,34 @@ RSpec.configure do |config|
   
 end
 
+
+module Unobservable
+  module SpecHelper
+    
+    def module_with_instance_events(*names, &block)
+      m = Module.new do
+        include Unobservable::Support
+        attr_event *names
+      end
+      
+      m.class_exec(&block) if block_given?
+      
+      return m
+    end
+
+    def class_with_instance_events(*names, &block)
+      args = {superclass: Object}
+      args.merge!(names.pop) if names[-1].is_a? Hash
+
+      c = Class.new(args[:superclass]) do
+        include Unobservable::Support
+        attr_event *names
+      end
+      
+      c.class_exec(&block) if block_given?
+      
+      return c
+    end
+    
+  end
+end

data/spec/unobservable_spec.rb

@@ -1,72 +1,137 @@
 require 'spec_helper'
 
+include Unobservable::SpecHelper
 
 
-describe Unobservable do
+shared_examples_for "instance event container" do
+  
+  context "Unobservable::Support is not included" do
+    it "does not have any instance events" do
+      c = described_class.new
+      Unobservable::instance_events_for(c, true).should be_empty
+      Unobservable::instance_events_for(c, false).should be_empty
+    end
+  end
+  
+  
+  context "Unobservable::Support is included" do
 
-  describe "#instance_events_for" do
-    
-    it "raises a type error when it receives a non-Module" do
-      expect do
-        Unobservable.instance_events_for(Object.new)
-      end.to raise_error(TypeError)
+    let(:mixin_module) do
+      module_with_instance_events :one, :two
     end
     
+    let(:instance_event_container) do
+      m = mixin_module
+      described_class.new do
+        include Unobservable::Support
+        include m
+        
+        attr_event :three, :four
+      end
+    end
 
+    it "does not have any events by default" do
+      c = described_class.new { include Unobservable::Support }
+      Unobservable::instance_events_for(c, true).should be_empty
+      Unobservable::instance_events_for(c, false).should be_empty
+    end
+    
+    it "knows which events have been defined explicitly" do
+      events = Unobservable::instance_events_for(instance_event_container, false)
+      events.size.should == 2
+      events.should include(:three)
+      events.should include(:four)
+    end
 
-    it "returns an empty list when given a Module that does not support events" do
-      plain_module = Module.new
-      Unobservable.instance_events_for(plain_module, true).should be_empty
-      Unobservable.instance_events_for(plain_module, false).should be_empty
+    it "inherits instance events defined by included Modules" do
+      events = Unobservable::instance_events_for(instance_event_container, true)
+      events.size.should == 4
+      events.should include(:one)
+      events.should include(:two)
+      events.should include(:three)
+      events.should include(:four)
     end
 
+  end
+  
+end
+
 
-    it "returns an empty list when given a Module that does not have any instance events defined" do
-      module_without_events = Module.new { include Unobservable::Support }
-      Unobservable.instance_events_for(module_without_events, true).should be_empty
-      Unobservable.instance_events_for(module_without_events, false).should be_empty
-    end
+describe Module do
+  it_behaves_like "instance event container"
+end
+
+describe Class do
+  it_behaves_like "instance event container"
+end
+
+
+
+describe Unobservable do
 
+  describe "#instance_events_for" do
     
+    it "raises TypeError when it receives a non-Module" do
+      expect{ Unobservable.instance_events_for(Object.new) }.to raise_error(TypeError)
+    end
     
-    context "Module defines instance events" do
-      let(:mixin_module) do
-        Module.new do
-          include Unobservable::Support
-          attr_event :one, :two
-        end
-      end
-      
-      let(:module_with_events) do
-        # Due to scoping weirdness, we need to place the mixin module
-        # in a local variable first.
-        m = mixin_module
-        Module.new do
-          include Unobservable::Support
-          include m
-          attr_event :three, :four
-        end
-      end
+  end
+  
+  
+  describe "#collect_instance_events_defined_by" do
+    let(:mixin_module) do
+      module_with_instance_events(:mixin_1, :mixin_2)
+    end
+    
+    let(:baseclass) do
+      class_with_instance_events(:bc_1, :bc_2)
+    end
     
-      it "returns instance events defined explicitly by the Module when all=false" do
-        events = Unobservable::instance_events_for(module_with_events, false)
-        events.size.should eq(2)
-        events.should include(:three)
-        events.should include(:four)
+    let(:subclass) do
+      m = mixin_module
+      class_with_instance_events(:sc_1, :sc_2, superclass: baseclass) do
+        include m
       end
+    end
+    
+    
+    it "only collects the instance events that the contributors define explicitly" do
+      events = Unobservable::collect_instance_events_defined_by([subclass])
+      events.size.should == 2
+      events.should include(:sc_1)
+      events.should include(:sc_2)
+    end
+    
+    it "collects the instance events defined by each contributor" do
+      classes = (1..3).map{|i| class_with_instance_events("a#{i}", "b#{i}") }
+      modules = (1..3).map{|i| module_with_instance_events("c#{i}", "d#{i}") }
       
-      
-      it "returns instance events defined explicitly and through included Modules when all=true" do
-        events = Unobservable::instance_events_for(module_with_events, true)
-        events.size.should eq(4)
-        events.should include(:one)
-        events.should include(:two)
-        events.should include(:three)
-        events.should include(:four)
+      events = Unobservable::collect_instance_events_defined_by(classes + modules)
+      events.size.should == 12
+      (1..3).each do |i|
+        events.should include("a#{i}".to_sym)
+        events.should include("b#{i}".to_sym)
+        events.should include("c#{i}".to_sym)
+        events.should include("d#{i}".to_sym)
       end
+    end
+    
+    
+    it "does not repeat duplicate instance events" do
+      c1 = class_with_instance_events(:one, :two)
+      c2 = class_with_instance_events(:one, :three)
+      m1 = module_with_instance_events(:two, :three)
+      m2 = module_with_instance_events(:two)
       
+      events = Unobservable::collect_instance_events_defined_by([c1, c2, m1, m2])
+      events.size.should == 3
+      events.should include(:one)
+      events.should include(:two)
+      events.should include(:three)
     end
 
+
   end
   
-end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: unobservable
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-04 00:00:00.000000000 Z
+date: 2012-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
@@ -127,7 +127,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2302660534203151431
+      hash: 2686370053034444533
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: