Created shared specs for Concurrent::Observable and updated tests for observable classes.

Author: jdantonio

README.md

@@ -128,6 +128,7 @@ ibm.value #=> 187.57
 * [Michele Della Torre](https://github.com/mighe)
 * [Chris Seaton](https://github.com/chrisseaton)
 * [Lucas Allan](https://github.com/lucasallan)
+* [Ravil Bayramgalin](https://github.com/brainopia)
 * [Giuseppe Capizzi](https://github.com/gcapizzi)
 * [Brian Shirai](https://github.com/brixen)
 * [Chip Miller](https://github.com/chip-miller)

lib/concurrent/atomic/copy_on_notify_observer_set.rb

@@ -16,8 +16,10 @@ def initialize
     # @param [Symbol] func the function to call on the observer during notification. Default is :update
     # @return [Symbol] the added function
     def add_observer(observer=nil, func=:update, &block)
-      unless !!observer ^ block # xor
+      if observer.nil? && block.nil?
         raise ArgumentError, 'should pass observer as a first argument or block'
+      elsif observer && block
+        raise ArgumentError.new('cannot provide both an observer and a block')
       end
 
       if block

lib/concurrent/atomic/copy_on_write_observer_set.rb

@@ -15,8 +15,10 @@ def initialize
     # @param [Symbol] func the function to call on the observer during notification. Default is :update
     # @return [Symbol] the added function
     def add_observer(observer=nil, func=:update, &block)
-      unless !!observer ^ block # xor
+      if observer.nil? && block.nil?
         raise ArgumentError, 'should pass observer as a first argument or block'
+      elsif observer && block
+        raise ArgumentError.new('cannot provide both an observer and a block')
       end
 
       if block

lib/concurrent/ivar.rb

@@ -42,7 +42,8 @@ def initialize(value = NO_VALUE, opts = {})
     #
     # @param [Object] observer the object that will be notified of changes
     # @param [Symbol] func symbol naming the method to call when this `Observable` has changes`
-    def add_observer(observer, func = :update, &block)
+    def add_observer(observer = nil, func = :update, &block)
+      raise ArgumentError.new('cannot provide both an observer and a block') if observer && block
       direct_notification = false
 
       if block

lib/concurrent/observable.rb

@@ -15,6 +15,7 @@ def delete_observer(*args)
 
     def delete_observers
       observers.delete_observers
+      self
     end
 
     def count_observers

spec/concurrent/agent_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require_relative 'dereferenceable_shared'
+require_relative 'observable_shared'
 
 module Concurrent
 
@@ -38,6 +39,17 @@ def execute_dereferenceable(subject)
       end
 
       it_should_behave_like :dereferenceable
+
+      # observable
+      
+      subject{ Agent.new(0) }
+      
+      def trigger_observable(observable)
+        observable.post{ nil }
+        sleep(0.1)
+      end
+
+      it_should_behave_like :observable
     end
 
     context '#initialize' do

spec/concurrent/channel/probe_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require_relative '../observable_shared'
 
 module Concurrent
 
@@ -7,6 +8,19 @@ module Concurrent
     let(:channel) { Object.new }
     let(:probe) { Channel::Probe.new }
 
+    describe 'behavior' do
+
+      # observable
+      
+      subject{ Channel::Probe.new }
+      
+      def trigger_observable(observable)
+        observable.set('value')
+      end
+
+      it_should_behave_like :observable
+    end
+
     describe '#set_unless_assigned' do
       context 'empty probe' do
         it 'assigns the value' do

spec/concurrent/future_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
+require_relative 'observable_shared'
 
 module Concurrent
 
@@ -54,6 +55,17 @@ def execute_dereferenceable(subject)
       end
 
       it_should_behave_like :dereferenceable
+
+      # observable
+      
+      subject{ Future.new{ nil } }
+      
+      def trigger_observable(observable)
+        observable.execute
+        sleep(0.1)
+      end
+
+      it_should_behave_like :observable
     end
 
     context 'subclassing' do

spec/concurrent/ivar_spec.rb

@@ -1,6 +1,7 @@
 require 'spec_helper'
 require_relative 'dereferenceable_shared'
 require_relative 'obligation_shared'
+require_relative 'observable_shared'
 
 module Concurrent
 
@@ -56,10 +57,19 @@ def dereferenceable_observable(opts = {})
 
       def execute_dereferenceable(subject)
         subject.set('value')
-        sleep(0.1)
       end
 
       it_should_behave_like :dereferenceable
+
+      # observable
+      
+      subject{ IVar.new }
+      
+      def trigger_observable(observable)
+        observable.set('value')
+      end
+
+      it_should_behave_like :observable
     end
 
     context '#initialize' do

spec/concurrent/observable_shared.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+share_examples_for :observable do
+
+  let(:observer_set) do
+    subject.instance_variable_get(:@observers)
+  end
+
+  let(:observer_class) do
+    Class.new do
+      def initialize(&block)
+        @block = block
+      end
+      def update(*args)
+        @block.call(*args) if @block
+      end
+    end
+  end
+
+  let(:observer){ observer_class.new }
+
+  let!(:observer_func){ :notify }
+
+  let(:observer_with_func_class) do
+    Class.new do
+      def initialize(&block)
+        @block = block
+      end
+      def notify(*args)
+        @block.call(*args) if @block
+      end
+    end
+  end
+
+  let(:observer_with_func){ observer_with_func_class.new }
+
+  context '#add_observer' do
+
+    it 'adds an observer if called before first notification' do
+      observer_set.should_receive(:add_observer).with(any_args)
+      subject.add_observer(observer)
+    end
+
+    it 'adds an observer with :func if called before first notification' do
+      observer_set.should_receive(:add_observer).with(observer_with_func, :notify)
+      subject.add_observer(observer_with_func, observer_func)
+    end
+
+    it 'creates an observer from a block if called before first notification' do
+      block = proc{ nil }
+      observer_set.should_receive(:add_observer).with(any_args)
+      subject.add_observer(&block)
+    end
+
+    it 'raises an exception if not given an observer or a block' do
+      expect {
+        subject.add_observer
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'raises an exception when given both an observer and a block' do
+      expect {
+        subject.add_observer(observer){ nil }
+      }.to raise_error(ArgumentError)
+    end
+  end
+  
+  context '#delete_observer' do
+  
+    it 'deletes the given observer if called before first notification' do
+      subject.count_observers.should eq 0
+      subject.add_observer(observer)
+      subject.count_observers.should eq 1
+      subject.delete_observer(observer)
+      subject.count_observers.should eq 0
+    end
+
+    it 'returns the removed observer if found in the observer set' do
+      subject.add_observer(observer)
+      subject.delete_observer(observer).should eq observer
+    end
+
+    it 'returns the given observer even when not found in the observer set' do
+      subject.delete_observer(observer).should eq observer
+    end
+  end
+  
+  context '#delete_observers' do
+
+    it 'deletes all observers when called before first notification' do
+      5.times{ subject.add_observer(observer_class.new) }
+      subject.count_observers.should eq 5
+      subject.delete_observers
+      subject.count_observers.should eq 0
+    end
+
+    it 'returns self' do
+      subject.delete_observers.should eq subject
+    end
+  end
+  
+  context '#count_observers' do
+  
+    it 'returns zero for a new observable object' do
+      subject.count_observers.should eq 0
+    end
+
+    it 'returns a count of registered observers if called before first notification' do
+      5.times{ subject.add_observer(observer_class.new) }
+      subject.count_observers.should eq 5
+    end
+
+    it 'returns zero after #delete_observers has been called' do
+      5.times{ subject.add_observer(observer_class.new) }
+      subject.delete_observers
+      subject.count_observers.should eq 0
+    end
+  end
+
+  context 'first notification' do
+
+    it 'calls the #update method on all observers without a specified :func' do
+      latch = Concurrent::CountDownLatch.new(5)
+      5.times do
+        subject.add_observer(observer_class.new{ latch.count_down })
+      end
+      trigger_observable(subject)
+      latch.count.should eq 0
+    end
+
+    it 'calls the appropriate function on all observers which specified a :func' do
+      latch = Concurrent::CountDownLatch.new(5)
+      5.times do
+        obs = observer_with_func_class.new{ latch.count_down }
+        subject.add_observer(obs, observer_func)
+      end
+      trigger_observable(subject)
+      latch.count.should eq 0
+    end
+
+    it 'calls the proc for all observers added as a block' do
+      latch = Concurrent::CountDownLatch.new(5)
+      5.times do
+        subject.add_observer{ latch.count_down }
+      end
+      trigger_observable(subject)
+      latch.count.should eq 0
+    end
+
+    it 'does not notify any observers removed with #delete_observer' do
+      latch = Concurrent::CountDownLatch.new(5)
+      
+      obs = observer_class.new{ latch.count_down }
+      subject.add_observer(obs)
+      subject.delete_observer(obs)
+
+      trigger_observable(subject)
+      latch.count.should eq 5
+    end
+
+    it 'does not notify any observers after #delete_observers called' do
+      latch = Concurrent::CountDownLatch.new(5)
+      5.times do
+        subject.add_observer(observer_class.new{ latch.count_down })
+      end
+
+      subject.delete_observers
+
+      trigger_observable(subject)
+      latch.count.should eq 5
+    end
+  end
+end