observables 0.1.1 → 0.1.2

data/test/test_base.rb

@@ -1,127 +1,127 @@
-require 'test_helper'
-
-class TestBase < Test::Unit::TestCase
-
-  context "An instance of a class that include Observables:Base" do
-    setup do
-      @obs = Class.new{include Observables::Base}.new
-    end
-
-    should "have a notifier" do
-      assert @obs.notifier.is_a?(ActiveSupport::Notifications::Fanout)
-    end
-
-    should "allow subscriptions with just a block" do
-      assert @obs.subscribe{}.is_a?(ActiveSupport::Notifications::Fanout::Subscriber)
-    end
-
-    should "allow subscriptions with a pattern and a block" do
-      assert @obs.subscribe(/whatever/){}.is_a?(ActiveSupport::Notifications::Fanout::Subscriber)
-    end
-
-    should "allow unsubscribing" do
-      sub = @obs.subscribe(/hi/){}
-      assert @obs.notifier.listening?("hi")
-      @obs.unsubscribe(sub)
-      assert_equal false, @obs.notifier.listening?("hi")
-    end
-
-    should "publish a before notification prior to executing a change" do
-      vals = []
-      x = 0
-      @obs.subscribe(/before/){|c,a|vals << c << a << x}
-      @obs.send(:changing,:a_change,:this=>:that){x+=1}
-      assert_equal :before_a_change, vals[0]
-      assert_equal @obs.send(:create_event_args,:a_change,:this=>:that),vals[1]
-      assert_equal 0, vals[2]
-      assert_equal 1, x
-    end
-
-    should "publish an after notification after executing a change" do
-      vals = []
-      x = 0
-      @obs.subscribe(/after/){|c,a|vals << c << a << x}
-      @obs.send(:changing,:a_change,:this=>:that){x+=1}
-      assert_equal :after_a_change, vals[0]
-      assert_equal @obs.send(:create_event_args,:a_change,:this=>:that),vals[1]
-      assert_equal 1, vals[2]
-      assert_equal 1, x
-    end
-
-    should "execute a proc passed in as changes to the event args" do
-      vals = []
-      @obs.subscribe(/after/){|_,a|vals << a.changes}
-      @obs.send(:changing, :a_change, :changes=>lambda {[1,2,3]}){1==1}
-      assert_equal [1,2,3], vals[0]
-    end
-
-    should "provide method level access to change args" do
-      vals = []
-      @obs.subscribe(/after/){|_,a|vals << a.haha}
-      @obs.send(:changing, :a_change, :haha=>"hoho"){1==1}
-      assert_equal "hoho", vals[0]
-    end
-
-    context "Taking ownership of an observable collection" do
-      setup do
-        @owner = Class.new do
-          def child_changed(*args)
-            @changed_args = args
-          end
-          def another_child_changed(*args)
-            @changed_args = args
-          end
-          def changed_args; @changed_args; end
-        end
-        @parent = @owner.new
-      end
-      should "notify the parent via standard callback method" do
-        @obs.set_observer @parent
-        @obs.send(:changing, :a_change){1==1}
-        assert_equal @obs, @parent.changed_args[0]
-      end
-      should "notify the parent via custom callback method when specified" do
-        @obs.set_observer @parent, :callback_method=>:another_child_changed
-        @obs.send(:changing, :a_change) {1==1}
-        assert_equal @obs, @parent.changed_args[0]
-      end
-      should "notify the parent via a block if provided" do
-        changed_args = []
-        @obs.set_observer(@parent) { |obs,*_| changed_args << obs }
-        @obs.send(:changing, :a_change) {1==1}
-        assert_equal @obs, changed_args.pop
-      end
-      should "respect a subscription pattern when notifying the parent" do
-        events = []
-        @obs.set_observer(@parent, :pattern=>/before/){|_,evt,*_| events << evt}
-        @obs.send(:changing,:a_change){1==1}
-        assert_equal 1, events.length
-        assert_equal :before_a_change, events.pop
-      end
-      should "notify the parent via argless block" do
-        events = []
-        @obs.set_observer(@parent, :pattern=>/before/){events << 1}
-        @obs.send(:changing, :a_change){1==1}
-        assert_equal 1, events.length
-      end
-      should "notify via block when no owner is given" do
-        events = []
-        my_ary = [1,2,3]
-        my_ary.make_observable
-        my_ary.set_observer(:pattern=>/before/){events << 1}
-        my_ary << 1
-        assert_equal 1, events.length
-      end
-      should "stop notifying the parent after clear_observer is called" do
-        events = []
-        @obs.set_observer(@parent){|*args|events << args}
-        @obs.send(:changing,:a_change){1==1}
-        assert_equal 2, events.length
-        @obs.clear_observer
-        @obs.send(:changing,:a_change){1==1}
-        assert_equal 2, events.length
-      end
-
-    end
-  end
+require 'test_helper'
+
+class TestBase < Test::Unit::TestCase
+
+  context "An instance of a class that include Observables:Base" do
+    setup do
+      @obs = Class.new{include Observables::Base}.new
+    end
+
+    should "have a notifier" do
+      assert @obs.notifier.is_a?(ActiveSupport::Notifications::Fanout)
+    end
+
+    should "allow subscriptions with just a block" do
+      assert @obs.subscribe{}.is_a?(ActiveSupport::Notifications::Fanout::Subscriber)
+    end
+
+    should "allow subscriptions with a pattern and a block" do
+      assert @obs.subscribe(/whatever/){}.is_a?(ActiveSupport::Notifications::Fanout::Subscriber)
+    end
+
+    should "allow unsubscribing" do
+      sub = @obs.subscribe(/hi/){}
+      assert @obs.notifier.listening?("hi")
+      @obs.unsubscribe(sub)
+      assert_equal false, @obs.notifier.listening?("hi")
+    end
+
+    should "publish a before notification prior to executing a change" do
+      vals = []
+      x = 0
+      @obs.subscribe(/before/){|c,a|vals << c << a << x}
+      @obs.send(:changing,:a_change,:this=>:that){x+=1}
+      assert_equal :before_a_change, vals[0]
+      assert_equal @obs.send(:create_event_args,:a_change,:this=>:that),vals[1]
+      assert_equal 0, vals[2]
+      assert_equal 1, x
+    end
+
+    should "publish an after notification after executing a change" do
+      vals = []
+      x = 0
+      @obs.subscribe(/after/){|c,a|vals << c << a << x}
+      @obs.send(:changing,:a_change,:this=>:that){x+=1}
+      assert_equal :after_a_change, vals[0]
+      assert_equal @obs.send(:create_event_args,:a_change,:this=>:that),vals[1]
+      assert_equal 1, vals[2]
+      assert_equal 1, x
+    end
+
+    should "execute a proc passed in as changes to the event args" do
+      vals = []
+      @obs.subscribe(/after/){|_,a|vals << a.changes}
+      @obs.send(:changing, :a_change, :changes=>lambda {[1,2,3]}){1==1}
+      assert_equal [1,2,3], vals[0]
+    end
+
+    should "provide method level access to change args" do
+      vals = []
+      @obs.subscribe(/after/){|_,a|vals << a.haha}
+      @obs.send(:changing, :a_change, :haha=>"hoho"){1==1}
+      assert_equal "hoho", vals[0]
+    end
+
+    context "Taking ownership of an observable collection" do
+      setup do
+        @owner = Class.new do
+          def child_changed(*args)
+            @changed_args = args
+          end
+          def another_child_changed(*args)
+            @changed_args = args
+          end
+          def changed_args; @changed_args; end
+        end
+        @parent = @owner.new
+      end
+      should "notify the parent via standard callback method" do
+        @obs.set_observer @parent
+        @obs.send(:changing, :a_change){1==1}
+        assert_equal @obs, @parent.changed_args[0]
+      end
+      should "notify the parent via custom callback method when specified" do
+        @obs.set_observer @parent, :callback_method=>:another_child_changed
+        @obs.send(:changing, :a_change) {1==1}
+        assert_equal @obs, @parent.changed_args[0]
+      end
+      should "notify the parent via a block if provided" do
+        changed_args = []
+        @obs.set_observer(@parent) { |obs,*_| changed_args << obs }
+        @obs.send(:changing, :a_change) {1==1}
+        assert_equal @obs, changed_args.pop
+      end
+      should "respect a subscription pattern when notifying the parent" do
+        events = []
+        @obs.set_observer(@parent, :pattern=>/before/){|_,evt,*_| events << evt}
+        @obs.send(:changing,:a_change){1==1}
+        assert_equal 1, events.length
+        assert_equal :before_a_change, events.pop
+      end
+      should "notify the parent via argless block" do
+        events = []
+        @obs.set_observer(@parent, :pattern=>/before/){events << 1}
+        @obs.send(:changing, :a_change){1==1}
+        assert_equal 1, events.length
+      end
+      should "notify via block when no owner is given" do
+        events = []
+        my_ary = [1,2,3]
+        my_ary.make_observable
+        my_ary.set_observer(:pattern=>/before/){events << 1}
+        my_ary << 1
+        assert_equal 1, events.length
+      end
+      should "stop notifying the parent after clear_observer is called" do
+        events = []
+        @obs.set_observer(@parent){|*args|events << args}
+        @obs.send(:changing,:a_change){1==1}
+        assert_equal 2, events.length
+        @obs.clear_observer
+        @obs.send(:changing,:a_change){1==1}
+        assert_equal 2, events.length
+      end
+
+    end
+  end
 end

data/test/test_hash_watcher.rb

@@ -1,88 +1,88 @@
-require "test_helper"
-
-class TestHashWatcher < Test::Unit::TestCase
-  context "A hash which has included Observables::HashWatcher" do
-    setup do
-      @hash = {:a=>1,:b=>2,:c=>"3"}.tap do |h|
-         class << h
-           include Observables::HashWatcher
-         end
-      end
-    end
-
-    should "notify observers of any change that modifies elements" do
-      before_methods, after_methods = [],[]
-      method_list = Observables::HashWatcher::MODIFIER_METHODS
-      @hash.subscribe(/before_modified/){|_,args|before_methods<<args[:trigger]}
-      @hash.subscribe(/after_modified/) {|_,args|after_methods<<args[:trigger]}
-      method_list.each do |method|
-        args = args_for(method)
-        args ? @hash.send(method,args) : @hash.send(method)
-      end
-      assert_equal method_list, before_methods
-      assert_equal method_list, after_methods
-    end
-
-    should "notify observers of any change that removes elements" do
-      before_methods, after_methods = [],[]
-      method_list = Observables::HashWatcher::REMOVE_METHODS
-      @hash.subscribe(/before_removed/){|_,args|before_methods<<args[:trigger]}
-      @hash.subscribe(/after_removed/) {|_,args|after_methods<<args[:trigger]}
-      method_list.each do |method|
-        args = args_for(method)
-        args ? @hash.send(method,*args) : @hash.send(method)
-      end
-      assert_equal method_list, before_methods
-      assert_equal method_list, after_methods
-    end
-
-    context "Calling #changes on the event args" do
-      should "calculate changes for #[]= as an addition" do
-        assert_equal [[:f,9]],get_changes(@hash){ @hash[:f] = 9}[:added]
-      end
-      should "calculate changes for #[]= as a modification" do
-        assert_equal({:removed=>[[:a,1]],:added=>[[:a,9]]}, get_changes(@hash){@hash[:a]=9})
-      end
-      should "calculate changes for #replace" do
-        assert_equal({:removed=>@hash.dup.to_a,:added=>{:t=>9,:u=>10}.to_a},get_changes(@hash){@hash.replace(:t=>9,:u=>10)})
-      end
-      should "calculate changes for #merge!, #update" do
-        [:merge!, :update].each do |method|
-          hash = @hash.dup
-          assert_equal({:removed=>{:c=>"3"}.to_a, :added=>{:c=>"4",:d=>5}.to_a},get_changes(hash){hash.send(method,{:c=>"4",:d=>5})})
-        end
-      end
-      should "calculate changes for #clear" do
-        assert_equal @hash.to_a, get_changes(@hash){@hash.clear}[:removed]
-      end
-      should "calculate changes for #delete" do
-        assert_equal({:a=>1}.to_a, get_changes(@hash){@hash.delete(:a)}[:removed])
-      end
-      should "calculate changes for #delete_if, #reject!" do
-        [:delete_if,:reject!].each do |method|
-          hash = @hash.dup
-          assert_equal({:a=>1,:c=>"3"}.to_a,get_changes(hash){hash.send(method){|k,v|[:a,:c].include?(k)}}[:removed])
-        end
-      end
-      should "calculate changes for #shift" do
-        assert_equal(@hash.dup.shift,get_changes(@hash){@hash.shift}[:removed])
-      end
-    end
-  end
-
-  def args_for(method)
-    case method
-      when :replace, :merge!, :update then {:e=>5}
-      when :delete then :a
-      else nil
-    end
-  end
-
-  def get_changes(hash)
-    changes = []
-    sub = hash.subscribe(/after/){|_,args|changes << args.changes}
-    yield
-    hash.unsubscribe(sub)
-    changes.pop
-  end
-end
+require "test_helper"
+
+class TestHashWatcher < Test::Unit::TestCase
+  context "A hash which has included Observables::HashWatcher" do
+    setup do
+      @hash = {:a=>1,:b=>2,:c=>"3"}.tap do |h|
+         class << h
+           include Observables::HashWatcher
+         end
+      end
+    end
+
+    should "notify observers of any change that modifies elements" do
+      before_methods, after_methods = [],[]
+      method_list = Observables::HashWatcher::MODIFIER_METHODS
+      @hash.subscribe(/before_modified/){|_,args|before_methods<<args[:trigger]}
+      @hash.subscribe(/after_modified/){|_,args|after_methods<<args[:trigger]}
+      method_list.each do |method|
+        args = args_for(method)
+        args ? @hash.send(method,args) : @hash.send(method)
+      end
+      assert_equal method_list, before_methods
+      assert_equal method_list, after_methods
+    end
+
+    should "notify observers of any change that removes elements" do
+      before_methods, after_methods = [],[]
+      method_list = Observables::HashWatcher::REMOVE_METHODS
+      @hash.subscribe(/before_removed/){|_,args|before_methods<<args[:trigger]}
+      @hash.subscribe(/after_removed/) {|_,args|after_methods<<args[:trigger]}
+      method_list.each do |method|
+        args = args_for(method)
+        args ? @hash.send(method,*args) : @hash.send(method)
+      end
+      assert_equal method_list, before_methods
+      assert_equal method_list, after_methods
+    end
+
+    context "Calling #changes on the event args" do
+      should "calculate changes for #[]= as an addition" do
+        assert_equal [[:f,9]],get_changes(@hash){ @hash[:f] = 9}[:added]
+      end
+      should "calculate changes for #[]= as a modification" do
+        assert_equal({:removed=>[[:a,1]],:added=>[[:a,9]]}, get_changes(@hash){@hash[:a]=9})
+      end
+      should "calculate changes for #replace" do
+        assert_equal({:removed=>@hash.dup.to_a,:added=>{:t=>9,:u=>10}.to_a},get_changes(@hash){@hash.replace(:t=>9,:u=>10)})
+      end
+      should "calculate changes for #merge!, #update" do
+        [:merge!, :update].each do |method|
+          hash = @hash.dup
+          assert_equal({:removed=>{:c=>"3"}.to_a, :added=>{:c=>"4",:d=>5}.to_a},get_changes(hash){hash.send(method,{:c=>"4",:d=>5})})
+        end
+      end
+      should "calculate changes for #clear" do
+        assert_equal [], @hash.to_a -  get_changes(@hash){@hash.clear}[:removed]
+      end
+      should "calculate changes for #delete" do
+        assert_equal({:a=>1}.to_a, get_changes(@hash){@hash.delete(:a)}[:removed])
+      end
+      should "calculate changes for #delete_if, #reject!" do
+        [:delete_if,:reject!].each do |method|
+          hash = @hash.dup
+          assert_equal({:a=>1,:c=>"3"}.to_a,get_changes(hash){hash.send(method){|k,v|[:a,:c].include?(k)}}[:removed])
+        end
+      end
+      should "calculate changes for #shift" do
+        assert_equal(@hash.dup.shift,get_changes(@hash){@hash.shift}[:removed])
+      end
+    end
+  end
+
+  def args_for(method)
+    case method
+      when :replace, :merge!, :update then {:e=>5}
+      when :delete then :a
+      else nil
+    end
+  end
+
+  def get_changes(hash)
+    changes = []
+    sub = hash.subscribe(/after/){|_,args|changes << args.changes}
+    yield
+    hash.unsubscribe(sub)
+    changes.pop
+  end
+end

data/test/test_helper.rb

@@ -1,13 +1,13 @@
-require 'rubygems'
-require 'bundler/setup'
-
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
-
-require 'observables'
-
-require 'shoulda'
-
-class Test::Unit::TestCase
-
-end
-
+require 'rubygems'
+require 'bundler/setup'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'observables'
+
+require 'shoulda'
+
+class Test::Unit::TestCase
+
+end
+