unobservable 0.8.0 → 0.10.1

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.10.1

data/lib/unobservable.rb

@@ -53,22 +53,33 @@ module Unobservable
     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
+    def define_event(name, args = {})
+      args = {:create_method => true}.merge(args)
+      name = name.to_sym
       
-      names.each do |n|
-        define_method n do
-          return event(n)
+      if args[:create_method]
+        define_method name do
+          return event(name)
         end
-        @unobservable_instance_events.add(n.to_sym)
       end
       
-      return @unobservable_instance_events.to_a
+      @unobservable_instance_events ||= Set.new
+      if @unobservable_instance_events.include? name
+        return false
+      else
+        @unobservable_instance_events.add name
+        return true
+      end
     end
     
-    alias :define_event :attr_event
+    
+    # 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)
+      args = (names[-1].is_a? Hash) ? names.pop : {}
+      names.each {|n| define_event(n, args) }
+      return nil
+    end
 
   end
 
@@ -105,8 +116,8 @@ module Unobservable
     end
 
     # Defines an event directly on the object.
-    def define_singleton_event(*name)
-      self.singleton_class.send(:attr_event, *name)
+    def define_singleton_event(name, args = {})
+      self.singleton_class.send(:define_event, name, args)
     end
 
     # Obtains the names of the events that are supported by this object.  If
@@ -185,6 +196,8 @@ module Unobservable
       @handlers << h
       return h
     end
+    
+    alias :add :register
 
 
     # Removes a single instance of the specified event handler
@@ -203,6 +216,8 @@ module Unobservable
     end
 
 
+    alias :delete :unregister
+
     
     # Pass the specific arguments / block to all of the
     # event handlers.  Return true if there was at least

data/spec/instance_event_container_spec.rb

@@ -0,0 +1,130 @@
+require 'spec_helper'
+
+include Unobservable::SpecHelper
+
+
+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
+
+    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
+    
+    let(:c){ described_class.new{ include Unobservable::Support } }
+
+    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 "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
+
+
+    describe "#define_event" do
+            
+      it "returns true if the specified event did not already exist" do
+        c.send(:define_event, :quux).should be_true
+      end
+      
+      it "returns false if the specified event already existed" do
+        c.send(:define_event, :quux)
+        c.send(:define_event, :quux).should be_false
+      end
+      
+      
+      it "defines an instance event" do
+        c.instance_events.should_not include(:quux)
+        c.send(:define_event, :quux)
+        c.instance_events.should include(:quux)
+      end
+      
+      it "creates a corresponding instance method when :create_method => true" do
+        c.instance_methods.should_not include(:quux)
+        c.send(:define_event, :quux, :create_method => true)
+        c.instance_methods.should include(:quux)
+      end
+      
+      it "does not create a corresponding instance method when :create_method => false" do
+        c.instance_methods.should_not include(:quux)
+        c.send(:define_event, :quux, :create_method => false)
+        c.instance_methods.should_not include(:quux)
+      end
+      
+      it "creates corresponding instance method by default" do
+        c.instance_methods.should_not include(:quux)
+        c.send(:define_event, :quux)
+        c.instance_methods.should include(:quux)
+      end
+      
+    end
+    
+    
+    describe "#attr_event" do
+      
+      it "defines several events at once" do
+        c.instance_events.should_not include(:one, :two, :three)
+        c.send(:attr_event, :one, :two, :three)
+        c.instance_events.should include(:one, :two, :three)
+      end
+      
+      it "creates corresponding instance methods when :create_method => true" do
+        c.instance_methods.should_not include(:one, :two, :three)
+        c.send(:attr_event, :one, :two, :three, :create_method => true)
+        c.instance_methods.should include(:one, :two, :three)
+      end
+      
+      it "does not create corresponding instance methods when :create_method => false" do
+        c.instance_methods.should_not include(:one, :two, :three)
+        c.send(:attr_event, :one, :two, :three, :create_method => false)
+        c.instance_methods.should_not include(:one, :two, :three)
+      end
+      
+    end
+
+  end
+  
+end
+
+
+describe Module do
+  it_behaves_like "instance event container"
+end
+
+describe Class do
+  it_behaves_like "instance event container"
+end

data/spec/support_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+include Unobservable::SpecHelper
+
+module Unobservable
+  describe Support do
+    let(:my_class) { class_with_instance_events(:foo, :bar) }
+    let(:obj) { my_class.new }
+
+    context "when included by a module" do
+      it "causes the module to extend Unobservable::ModuleSupport" do
+        m = Module.new{ include Unobservable::Support }
+
+        m.should include(Unobservable::Support)
+        m.singleton_class.should include(Unobservable::ModuleSupport)
+      end
+    end
+
+    
+    context "when extended by an Object" do
+      it "causes the object's singleton class to extend Unobservable::ModuleSupport" do
+        x = Object.new
+        x.extend Unobservable::Support
+
+        x.singleton_class.should include(Unobservable::Support)
+        x.singleton_class.singleton_class.should include(Unobservable::ModuleSupport)
+      end
+    end
+
+
+    describe "#define_singleton_event" do
+      
+      it "defines a new singleton event directly on the object" do
+        the_singleton_event = :quux
+        
+        obj.class.instance_events.should_not include(the_singleton_event)
+        obj.singleton_events(false).should_not include(the_singleton_event)
+        expect{ obj.event(the_singleton_event) }.to raise_error
+        
+        expect{ obj.define_singleton_event the_singleton_event }.to change{ obj.singleton_events(false).size }.by(1)
+        
+        obj.class.instance_events.should_not include(the_singleton_event)
+        obj.singleton_events(false).should include(the_singleton_event)
+        expect{ obj.event(the_singleton_event) }.to_not raise_error
+      end
+      
+      it "returns True if the object did not already define the event as a singleton event" do
+        obj.define_singleton_event(:foo).should be_true
+      end
+      
+      it "returns False if the object already defined the event as a singleton event" do
+        obj.define_singleton_event(:foo)
+        obj.define_singleton_event(:foo).should be_false
+      end
+      
+      
+      it "creates a corresponding instance method when :create_method => true" do
+        obj.methods.should_not include(:quux)
+        obj.define_singleton_event :quux, :create_method => true
+        obj.methods.should include(:quux)
+      end
+      
+      it "does not create a corresponding instance method when :create_method => false" do
+        obj.methods.should_not include(:quux)
+        obj.define_singleton_event :quux, :create_method => false
+        obj.methods.should_not include(:quux)
+      end
+      
+      it "creates a corresponding instance method by default" do
+        obj.methods.should_not include(:quux)
+        obj.define_singleton_event :quux
+        obj.methods.should include(:quux)
+      end
+      
+    end
+
+
+    describe "#event" do
+      it "raises a NameError when the specified event is not defined" do
+        expect{ obj.event(:not_exist) }.to raise_error(NameError)
+      end
+      
+      it "maps different names to different Event instances" do
+        obj.event(:foo).should_not === obj.event(:bar)
+      end
+      
+      it "maps the same name to the same Event instance" do
+        obj.event(:foo).should === obj.event(:foo)
+        obj.event(:bar).should === obj.event(:bar)
+      end
+      
+      it "maintains separate Events for each object" do
+        x = my_class.new
+        y = my_class.new
+        
+        x.event(:foo).should_not === y.event(:foo)
+      end
+    end
+    
+    
+    describe "#raise_event" do
+      
+      it "raises a NameError when the specified event is not defined" do
+        expect{ obj.send :raise_event, :not_exist }.to raise_error(NameError)
+        expect{ obj.send :raise_event, :not_exist, 1, 2, 3 }.to raise_error(NameError)
+      end
+            
+      it "calls the specified event" do
+        args = [1, 2, 3]
+        obj.event(:foo).should_receive(:call).with(*args)
+        obj.send :raise_event, :foo, *args
+      end
+      
+    end
+
+  end
+end
+

data/spec/unobservable_spec.rb

@@ -3,69 +3,6 @@ require 'spec_helper'
 include Unobservable::SpecHelper
 
 
-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
-
-    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 "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
-
-
-describe Module do
-  it_behaves_like "instance event container"
-end
-
-describe Class do
-  it_behaves_like "instance event container"
-end
-
-
 
 describe Unobservable do
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: unobservable
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-10 00:00:00.000000000 Z
+date: 2012-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
@@ -108,7 +108,9 @@ files:
 - VERSION
 - lib/unobservable.rb
 - spec/event_spec.rb
+- spec/instance_event_container_spec.rb
 - spec/spec_helper.rb
+- spec/support_spec.rb
 - spec/unobservable_spec.rb
 - test/helper.rb
 - test/test_unobservable.rb
@@ -127,7 +129,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2686370053034444533
+      hash: -1060921785598011427
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: