aquarium 0.4.4 → 0.5.1

data/spec/aquarium/aspects/aspect_spec.rb

@@ -1,6 +1,7 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'aquarium/spec_example_types'
 require 'aquarium/aspects'
+require 'aquarium/utils'
 require 'logger'
 
 include Aquarium::Aspects
@@ -23,10 +24,10 @@ end
 
 
 describe Aspect, " cannot advise the private implementation methods inserted by other aspects" do  
+  class WithAspectLikeMethod
+    def _aspect_foo; end
+  end
   it "should have no affect." do
-    class WithAspectLikeMethod
-      def _aspect_foo; end
-    end
     aspect = Aspect.new(:after, :pointcut => {:type => WithAspectLikeMethod, :methods => :_aspect_foo}) {|jp, obj, *args| fail}
     WithAspectLikeMethod.new._aspect_foo
     aspect.unadvise
@@ -40,7 +41,7 @@ describe Aspect, " when advising a type" do
   after(:each) do
     @aspect.unadvise
   end
-  
+
   it "should not add new public instance or class methods that the advised type responds to." do
     all_public_methods_before = all_public_methods_of_type Watchful
     @aspect = Aspect.new :after, :pointcut => {:type => Watchful, :method_options => :exclude_ancestor_methods}, :advice => @advice 
@@ -153,26 +154,25 @@ describe Aspect, " with :after advice" do
     do_watchful_public_protected_private 
   end
   
-  it "should ignore the value returned by the advice" do
-    class ReturningValue
-      def doit args
-        args + ["d"]
-      end
+  class ReturningValue
+    def doit args
+      args + ["d"]
     end
+  end
+
+  it "should ignore the value returned by the advice" do
     ary = %w[a b c]
     ReturningValue.new.doit(ary).should == %w[a b c d]
+    advise_called = false
     @aspect = Aspect.new :after, :type => ReturningValue, :method => :doit do |jp, obj, *args|
+      advise_called = true
       %w[aa] + jp.context.returned_value + %w[e]
     end 
     ReturningValue.new.doit(ary).should == %w[a b c d]
+    advise_called.should == true
   end
 
-  it "should all the advice to assign a new return value" do
-    class ReturningValue
-      def doit args
-        args + ["d"]
-      end
-    end
+  it "should allow the advice to assign a new return value" do
     ary = %w[a b c]
     ReturningValue.new.doit(ary).should == %w[a b c d]
     @aspect = Aspect.new :after, :type => ReturningValue, :method => :doit do |jp, obj, *args|
@@ -223,26 +223,25 @@ describe Aspect, " with :after_returning advice" do
     do_watchful_public_protected_private 
   end
   
-  it "should ignore the value returned by the advice" do
-    class ReturningValue
-      def doit args
-        args + ["d"]
-      end
+  class ReturningValue
+    def doit args
+      args + ["d"]
     end
+  end
+
+  it "should ignore the value returned by the advice" do
     ary = %w[a b c]
     ReturningValue.new.doit(ary).should == %w[a b c d]
+    advice_called = false
     @aspect = Aspect.new :after_returning, :type => ReturningValue, :method => :doit do |jp, obj, *args|
+      advice_called = true
       %w[aa] + jp.context.returned_value + %w[e]
     end 
     ReturningValue.new.doit(ary).should == %w[a b c d]
+    advice_called.should == true
   end
 
   it "should allow the advice to change the returned value" do
-    class ReturningValue
-      def doit args
-        args + ["d"]
-      end
-    end
     ary = %w[a b c]
     ReturningValue.new.doit(ary).should == %w[a b c d]
     @aspect = Aspect.new :after_returning, :type => ReturningValue, :method => :doit do |jp, obj, *args|
@@ -567,25 +566,25 @@ describe Aspect, " with :around advice" do
     advice_called.should be_true
   end
 
-  it "should advise subclass invocations of methods advised in the superclass." do
-    module AdvisingSuperClass
-      class SuperClass
-        def public_method *args
-          # yield *args if block_given?
-        end
-        protected
-        def protected_method *args
-          yield *args if block_given?
-        end
-        private
-        def private_method *args
-          yield *args if block_given?
-        end
+  module AdvisingSuperClass
+    class SuperClass
+      def public_method *args
+        # yield *args if block_given?
       end
-      class SubClass < SuperClass
+      protected
+      def protected_method *args
+        yield *args if block_given?
+      end
+      private
+      def private_method *args
+        yield *args if block_given?
       end
     end
-    
+    class SubClass < SuperClass
+    end
+  end
+  
+  it "should advise subclass invocations of methods advised in the superclass." do
     child = AdvisingSuperClass::SubClass.new
     advice_called = false
     @aspect = Aspect.new :around, :pointcut => {:type => AdvisingSuperClass::SuperClass, :methods => [:public_method]} do |jp, obj, *args|
@@ -608,25 +607,25 @@ describe Aspect, " with :around advice" do
     advice_called.should be_true
   end
 
-  it "should advise subclass invocations of methods advised in the subclass that are defined in the superclass." do
-    module AdvisingSubClass
-      class SuperClass
-        def public_method *args
-          # yield *args if block_given?
-        end
-        protected
-        def protected_method *args
-          yield *args if block_given?
-        end
-        private
-        def private_method *args
-          yield *args if block_given?
-        end
+  module AdvisingSubClass
+    class SuperClass
+      def public_method *args
+        # yield *args if block_given?
       end
-      class SubClass < SuperClass
+      protected
+      def protected_method *args
+        yield *args if block_given?
+      end
+      private
+      def private_method *args
+        yield *args if block_given?
       end
     end
-    
+    class SubClass < SuperClass
+    end
+  end
+  
+  it "should advise subclass invocations of methods advised in the subclass that are defined in the superclass." do
     child = AdvisingSubClass::SubClass.new
     advice_called = false
     @aspect = Aspect.new :around, :pointcut => {:type => AdvisingSubClass::SuperClass, :methods => [:public_method]} do |jp, obj, *args|
@@ -649,18 +648,19 @@ describe Aspect, " with :around advice" do
     advice_called.should be_true
   end
 
-  it "should not advise subclass overrides of superclass methods, when advising superclasses (but calls to superclass methods are advised)." do
-    class WatchfulChild2 < Watchful
-      def public_watchful_method *args
-        @override_called = true
-        yield(*args) if block_given?
-      end
-      attr_reader :override_called
-      def initialize
-        super
-        @override_called = false
-      end
+  class WatchfulChild2 < Watchful
+    def public_watchful_method *args
+      @override_called = true
+      yield(*args) if block_given?
     end
+    attr_reader :override_called
+    def initialize
+      super
+      @override_called = false
+    end
+  end
+
+  it "should not advise subclass overrides of superclass methods, when advising superclasses (but calls to superclass methods are advised)." do
     @aspect = Aspect.new(:around, :pointcut => {:type => Watchful, :methods => [:public_watchful_method]}) {|jp, obj, *args| fail}
     child = WatchfulChild2.new
     public_block_called = false
@@ -697,12 +697,13 @@ describe Aspect, " with :around advice" do
     watchful.public_watchful_method_args.should == [:a4, :a5, :a6]
   end
   
-  it "should return the value returned by the advice, NOT the value returned by the advised join point!" do
-    class ReturningValue
-      def doit args
-        args + ["d"]
-      end
+  class ReturningValue
+    def doit args
+      args + ["d"]
     end
+  end
+
+  it "should return the value returned by the advice, NOT the value returned by the advised join point!" do
     ary = %w[a b c]
     ReturningValue.new.doit(ary).should == %w[a b c d]
     @aspect = Aspect.new :around, :type => ReturningValue, :method => :doit do |jp, obj, *args|
@@ -713,11 +714,6 @@ describe Aspect, " with :around advice" do
   end
 
   it "should return the value returned by the advised join point only if the advice returns the value" do
-    class ReturningValue
-      def doit args
-        args + ["d"]
-      end
-    end
     ary = %w[a b c]
     ReturningValue.new.doit(ary).should == %w[a b c d]
     @aspect = Aspect.new :around, :type => ReturningValue, :method => :doit do |jp, obj, *args|
@@ -923,8 +919,9 @@ end
 %w[public protected private].each do |protection|
   describe Aspect, " when advising and unadvising #{protection} methods" do
     it "should keep the protection level of the advised methods unchanged." do
-      meta   = "#{protection}_instance_methods"
-      method = "#{protection}_watchful_method"
+      meta   = :"#{protection}_instance_methods"
+      method_name = "#{protection}_watchful_method"
+      method = Aquarium::Utils::MethodUtils.to_name method_name
       Watchful.send(meta).should include(method)
       aspect = Aspect.new(:after, :type => Watchful, :method => method.intern, :method_options => [protection.intern]) {|jp, obj, *args| true }
       Watchful.send(meta).should include(method)
@@ -935,13 +932,18 @@ end
 end
 
 
+class TypeDefinedMethodClass
+  def inititalize; @called = false; end
+  def m; @called = true; end
+  attr_reader :called
+end
+
+class InstanceDefinedMethodClass
+  def inititalize; @called = false; end
+  attr_reader :called
+end
+
 describe Aspect, " when unadvising methods for instance-type pointcuts for type-defined methods" do
-  class TypeDefinedMethodClass
-    def inititalize; @called = false; end
-    def m; @called = true; end
-    attr_reader :called
-  end
-  
   it "should cause the object to respond to the type's original method." do
     object = TypeDefinedMethodClass.new
     aspect = Aspect.new(:before, :object => object, :method => :m) {true}
@@ -952,11 +954,6 @@ describe Aspect, " when unadvising methods for instance-type pointcuts for type-
 end
 
 describe Aspect, " when unadvising methods for instance-type pointcuts for instance-defined methods" do
-  class InstanceDefinedMethodClass
-    def inititalize; @called = false; end
-    attr_reader :called
-  end
-  
   it "should cause the object to respond to the object's original method." do
     object = TypeDefinedMethodClass.new
     def object.m; @called = true; end

data/spec/aquarium/aspects/concurrent_aspects_spec.rb

@@ -95,7 +95,7 @@ module ConcurrentAspectsSpecSupport
   end
 end
 
-describe "concurrent advice", :shared => true do
+shared_examples_for "concurrent advice" do
   include ConcurrentAspectsSpecSupport
   
   before :all do

data/spec/aquarium/aspects/concurrent_aspects_with_objects_and_types_spec.rb

@@ -37,7 +37,9 @@ describe "Advising an object join point and then the corresponding type join poi
       rescue ConcurrentlyAccessed::Error
         fail unless advice_kind == :after_raising 
       end
-      @invoked.sort.should == [:object, :type]
+      @invoked.length.should == 2
+      @invoked.should include(:object)
+      @invoked.should include(:type)
     end
   end  
   

data/spec/aquarium/aspects/join_point_spec.rb

@@ -269,7 +269,6 @@ describe JoinPoint, "#invoke_original_join_point" do
   end
 end
 
-  
 describe JoinPoint, "#dup" do
   it "should duplicate the fields in the join point." do
     jp  = JoinPoint.new :type => String, :method_name => :count

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -95,8 +95,11 @@ def before_pointcut_module_spec
 end
 
 def ignored_join_point jp
-  # Ignore any types introduced by RSpec, other Aquarium types, and the "pretty printer" module (which Rake uses?)
-  jp.target_type.name =~ /^Spec/ or 
+  # Ignore any type ambiguities introduced by Ruby 1.9.X.
+  # Igore types introduced by RSpec, other Aquarium types, 
+  # and the "pretty printer" module (which Rake uses?)
+  jp.target_type.name =~ /^(Basic)?Object/ or 
+  jp.target_type.name =~ /^R?Spec/ or 
   jp.target_type.name =~ /^Aquarium::(Aspects|Extras|Utils|PointcutFinderTestClasses)/ or 
   jp.target_type.name =~ /^PP/ or
   jp.target_type.name =~ /InstanceExecHelper/
@@ -286,7 +289,7 @@ describe Pointcut, "methods" do
 
     it "should match classes specified and their ancestor and descendent modules and classes." do
       pc = Pointcut.new :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, :types_and_descendents => /^Class(Including|DerivedFrom).*Method/, :methods => :all, :method_options => :exclude_ancestor_methods
-      expected_types = @example_modules_with_public_instance_method + [Kernel, Module, Object]
+      expected_types = @example_modules_with_public_instance_method + [Kernel, Module]
       pc.join_points_matched.each do |jp|
         next if ignored_join_point(jp)
         expected_types.should include(jp.target_type)
@@ -555,15 +558,14 @@ describe Pointcut, "methods" do
       expected_types = [
         ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod, 
         ClassIncludingModuleWithPublicInstanceMethod,
-        Kernel,
-        Object]
+        Kernel]
       found_types = {}
       pc.join_points_matched.each do |jp|
         next if ignored_join_point(jp)
         expected_types.should include(jp.target_type)
         found_types[jp.target_type] = true
       end
-      found_types.size.should == 4
+      found_types.size.should == 3
       not_expected_types = @expected_modules_not_matched_jps.map {|jp| jp.target_type}
       pc.join_points_not_matched.each do |jp|
         next if ignored_join_point(jp)
@@ -583,14 +585,14 @@ describe Pointcut, "methods" do
     end
 
     def check_module_descendents pc
-      expected_types = [Kernel, Object]
+      expected_types = [Kernel]
       found_types = {}
       pc.join_points_matched.each do |jp|
         next if ignored_join_point(jp)
         expected_types.should include(jp.target_type)
         found_types[jp.target_type] = true
       end
-      found_types.size.should == 2
+      found_types.size.should == 1
       not_expected_types = @expected_modules_not_matched_jps.map {|jp| jp.target_type}
       pc.join_points_not_matched.each do |jp|
         next if ignored_join_point(jp)
@@ -637,14 +639,14 @@ describe Pointcut, "methods" do
     end
   
     def check_class_descendents pc
-      expected_types = [Kernel, ModuleIncludingModuleWithPublicInstanceMethod, ModuleWithPublicInstanceMethod, Object]
+      expected_types = [Kernel, ModuleIncludingModuleWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
       found_types = {}
       pc.join_points_matched.each do |jp|
         next if ignored_join_point(jp)
         expected_types.should include(jp.target_type)
         found_types[jp.target_type] = true
       end
-      found_types.size.should == 4
+      found_types.size.should == 3
       not_expected_types = @expected_modules_not_matched_jps.map {|jp| jp.target_type}
       pc.join_points_not_matched.each do |jp|
         next if ignored_join_point(jp)
@@ -1423,15 +1425,15 @@ describe Pointcut, "methods" do
     end
   end
 
-  describe Pointcut, ".new (methods that end in non-alphanumeric characters)" do
-    class ClassWithFunkyMethodNames
-      def huh?; true; end
-      def yes!; true; end
-      def x= other; false; end
-      def == other; false; end
-      def =~ other; false; end
-    end
+  class ClassWithFunkyMethodNames
+    def huh?; true; end
+    def yes!; true; end
+    def x= other; false; end
+    def == other; false; end
+    def =~ other; false; end
+  end
   
+  describe Pointcut, ".new (methods that end in non-alphanumeric characters)" do
     before(:each) do
       @funky = ClassWithFunkyMethodNames.new
     end  
@@ -1725,6 +1727,7 @@ describe Pointcut, "methods" do
       pc1 = Pointcut.new  :types => /Class.*Method/, :methods => /_test_method$/
       pc2 = Pointcut.new  :types => /Class.*Method/, :methods => /_test_method$/
       pc3 = Pointcut.new  :objects => [ClassWithPublicInstanceMethod.new, ClassWithPublicInstanceMethod.new]
+      
       pc1.should be_eql(pc1)
       pc1.should be_eql(pc2)
       pc1.should_not eql(pc3)

data/spec/aquarium/extensions/hash_spec.rb

@@ -19,260 +19,252 @@ class CC
   end
 end
 
-def before_hash_spec
-  @c1 = CC.new(1)
-  @c2 = CC.new(2)
-  @c3 = CC.new(3)
-  @cc1 = [@c1, @c2]
-  @cc2 = [@c2, @c3]
-  @hash = {:a => ['a1'], :b => [:b1, :b2], :c => @cc1}
-end
-
-describe "intersection of hashes", :shared => true do
-  include Aquarium::Utils::ArrayUtils
-  include Aquarium::Utils::HashUtils
-
+describe "hash extensions" do
   before(:each) do
-    before_hash_spec
-  end
-  
-  it "should return the same hash if intersected with itself." do
-    @hash.and(@hash).should == @hash
-  end 
-
-  it "should return the same hash if intersected with an equivalent hash." do
-    @hash.and({:a => ['a1'], :b => [:b1, :b2], :c => @cc1}).should == @hash
-  end 
-
-  it "should return an empty hash if one of the input hashes is empty." do
-    {}.and(@hash).should == {}
-  end 
-
-  it "should return the common subset hash for two, if the values respond to #&." do
-    hash2 = {:b => [:b1], :c => @cc2, :d => ['d']}
-    @hash.and(hash2).should == {:b => [:b1], :c => [@c2]}
-  end 
-
-  it "should return the common subset of hash values for partially-overlapping keys as specified by a given block." do
-    hash2 = {:b =>:b1, :c => @cc2, :d => 'd'}
-    @hash.and(hash2){|value1, value2| Set.new(make_array(value1)).intersection(Set.new(make_array(value2)))}.should == {:b => Set.new([:b1]), :c => Set.new([@c2])}
+    @c1 = CC.new(1)
+    @c2 = CC.new(2)
+    @c3 = CC.new(3)
+    @cc1 = [@c1, @c2]
+    @cc2 = [@c2, @c3]
+    @hash = {:a => ['a1'], :b => [:b1, :b2], :c => @cc1}
   end
-end
 
-describe Hash, "#intersection" do
-  it_should_behave_like "intersection of hashes"
-end
+  shared_examples_for "intersection of hashes" do
+    include Aquarium::Utils::ArrayUtils
+    include Aquarium::Utils::HashUtils
 
-describe Hash, "#and" do
-  it_should_behave_like "intersection of hashes"
-end
+    it "should return the same hash if intersected with itself." do
+      @hash.and(@hash).should == @hash
+    end 
 
-describe Hash, "#&" do
-  it_should_behave_like "intersection of hashes"
-  
-  it "should support operator-style semantics" do
-    ({:a => ['a1', 'a2'], :c => @cc1} & {:a => ['a1'], :b => [:b1, :b2], :c => @cc2}).should == {:a => ['a1'], :c => [@c2]}
-  end
-end
+    it "should return the same hash if intersected with an equivalent hash." do
+      @hash.and({:a => ['a1'], :b => [:b1, :b2], :c => @cc1}).should == @hash
+    end 
 
-describe "union of hashes", :shared => true do
-  include Aquarium::Utils::ArrayUtils
-  include Aquarium::Utils::HashUtils
+    it "should return an empty hash if one of the input hashes is empty." do
+      {}.and(@hash).should == {}
+    end 
 
-  before(:each) do
-    before_hash_spec
-  end
-  
-  it "should return the same hash if unioned with itself." do
-    @hash.union(@hash).should == @hash
-  end 
-
-  it "should return the same hash if unioned with an equivalent hash." do
-    @hash.union({:a => ['a1'], :b => [:b1, :b2], :c => @cc1}).should == @hash
-  end 
-
-  it "should return a hash that is equivalent to the non-empty hash if the other hash is empty." do
-    {}.union(@hash).should == @hash
-    @hash.union({}).should == @hash
-  end 
-
-  it "should return the same hash if unioned with nil." do
-    @hash.union(nil).should == @hash
-  end 
-
-  it "should return the combined hash value, if the values respond to #|." do
-    hash2 = {:b => [:b3], :c => @cc2, :d => ['d']}
-    @hash.union(hash2).should == {:a => ['a1'], :b => [:b1, :b2, :b3], :c => [@c1, @c2, @c3], :d => ['d']}
-  end 
-
-  it "should return a hash equivalent to the output of Hash#merge for two, non-equivalent hashes, with no block given and values don't respond to #|." do
-    hash2 = {:b => :b3, :c => @cc2, :d => 'd'}
-    @hash.union(hash2).should == {:a => ['a1'], :b => :b3, :c => [@c1, @c2, @c3], :d => 'd'}
-  end 
-
-  it "should return the combined hash values as specified by a given block." do
-    hash2 = {:b => :b3, :c => @cc2, :d => 'd'}
-    @hash.union(hash2){|value1, value2| Set.new(make_array(value1)).union(Set.new(make_array(value2)))}.should == {:a => Set.new(['a1']), :b => Set.new([:b1, :b2, :b3]), :c => Set.new([@c1, @c2, @c3]), :d => Set.new(['d'])}
-  end 
-end
+    it "should return the common subset hash for two, if the values respond to #&." do
+      hash2 = {:b => [:b1], :c => @cc2, :d => ['d']}
+      @hash.and(hash2).should == {:b => [:b1], :c => [@c2]}
+    end 
 
-describe Hash, "#union" do
-  it_should_behave_like "union of hashes"
-end
+    it "should return the common subset of hash values for partially-overlapping keys as specified by a given block." do
+      hash2 = {:b =>:b1, :c => @cc2, :d => 'd'}
+      @hash.and(hash2){|value1, value2| Set.new(make_array(value1)).intersection(Set.new(make_array(value2)))}.should == {:b => Set.new([:b1]), :c => Set.new([@c2])}
+    end
+  end
 
-describe Hash, "#or" do
-  it_should_behave_like "union of hashes"
-end  
+  describe Hash, "#intersection" do
+    it_should_behave_like "intersection of hashes"
+  end
 
-describe Hash, "#|" do
-  it_should_behave_like "union of hashes"
-  
-  it "should support operator-style semantics" do
-    ({:a => ['a1'], :d => ['d']} | {:a => ['a2'], :b => [:b1, :b2], :c => @cc2}).should == {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc2, :d => ['d']}
+  describe Hash, "#and" do
+    it_should_behave_like "intersection of hashes"
   end
-end
 
+  describe Hash, "#&" do
+    it_should_behave_like "intersection of hashes"
+    
+    it "should support operator-style semantics" do
+      ({:a => ['a1', 'a2'], :c => @cc1} & {:a => ['a1'], :b => [:b1, :b2], :c => @cc2}).should == {:a => ['a1'], :c => [@c2]}
+    end
+  end
 
-describe "subtraction of hashes", :shared => true do
-  include Aquarium::Utils::ArrayUtils
-  include Aquarium::Utils::HashUtils
-  
-  before(:each) do
-    before_hash_spec
-    # override value:
-    @hash = {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc1}
+  shared_examples_for "union of hashes" do
+    include Aquarium::Utils::ArrayUtils
+    include Aquarium::Utils::HashUtils
+
+    it "should return the same hash if unioned with itself." do
+      @hash.union(@hash).should == @hash
+    end 
+
+    it "should return the same hash if unioned with an equivalent hash." do
+      @hash.union({:a => ['a1'], :b => [:b1, :b2], :c => @cc1}).should == @hash
+    end 
+
+    it "should return a hash that is equivalent to the non-empty hash if the other hash is empty." do
+      {}.union(@hash).should == @hash
+      @hash.union({}).should == @hash
+    end 
+
+    it "should return the same hash if unioned with nil." do
+      @hash.union(nil).should == @hash
+    end 
+
+    it "should return the combined hash value, if the values respond to #|." do
+      hash2 = {:b => [:b3], :c => @cc2, :d => ['d']}
+      @hash.union(hash2).should == {:a => ['a1'], :b => [:b1, :b2, :b3], :c => [@c1, @c2, @c3], :d => ['d']}
+    end 
+
+    it "should return a hash equivalent to the output of Hash#merge for two, non-equivalent hashes, with no block given and values don't respond to #|." do
+      hash2 = {:b => :b3, :c => @cc2, :d => 'd'}
+      @hash.union(hash2).should == {:a => ['a1'], :b => :b3, :c => [@c1, @c2, @c3], :d => 'd'}
+    end 
+
+    it "should return the combined hash values as specified by a given block." do
+      hash2 = {:b => :b3, :c => @cc2, :d => 'd'}
+      @hash.union(hash2){|value1, value2| Set.new(make_array(value1)).union(Set.new(make_array(value2)))}.should == {:a => Set.new(['a1']), :b => Set.new([:b1, :b2, :b3]), :c => Set.new([@c1, @c2, @c3]), :d => Set.new(['d'])}
+    end 
   end
-  
-  it "should return an empty hash if subtracted from itself." do
-    (@hash - @hash).should be_empty
-  end 
 
-  it "should return an empty hash if an equivalent hash is subtracted from it." do
-    (@hash - {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc1}).should be_empty
-  end 
+  describe Hash, "#union" do
+    it_should_behave_like "union of hashes"
+  end
 
-  it "should return an equivalent hash if the second hash is empty." do
-    (@hash - {}).should == @hash
-  end 
+  describe Hash, "#or" do
+    it_should_behave_like "union of hashes"
+  end  
 
-  it "should return an equivalent hash if the second hash is nil." do
-    (@hash - nil).should == @hash
-  end 
-  
-  it "should return an empty hash if the first hash is empty, independent of the second hash." do
-    ({} - @hash).should be_empty
-  end 
-
-  it "should return a hash with all keys in the second hash removed, independent of the corresponding values, if no block is given." do
-    hash2 = {:b =>:b3, :c => 'c', :d => 'd'}
-    (@hash - hash2).should == {:a => ['a1', 'a2']}
-  end 
-
-  it "should return a hash with the values subtraced for partially-overlapping keys as specified by a given block." do
-    hash2 = {:b =>:b2, :c => @cc2, :d => 'd'}
-    @hash.minus(hash2) do |value1, value2| 
-      Set.new(make_array(value1)) - Set.new(make_array(value2))
-    end.should == {:a => Set.new(['a1', 'a2']), :b => Set.new([:b1]), :c => Set.new([@c1])}
-  end 
-
-  it "should be not associative." do
-    hash1 = {:a => :a1, :b =>:b1, :c => :c1, :d => :d1}
-    hash2 = {:b =>:b3, :c => 'c'}
-    hash3 = {:a =>:a4, :c => 'c'}
-    ((hash1 - hash2) - hash3).should == {:d => :d1}
-    (hash1 - (hash2 - hash3)).should == {:a => :a1, :c => :c1, :d => :d1}
-  end 
-end
+  describe Hash, "#|" do
+    it_should_behave_like "union of hashes"
+    
+    it "should support operator-style semantics" do
+      ({:a => ['a1'], :d => ['d']} | {:a => ['a2'], :b => [:b1, :b2], :c => @cc2}).should == {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc2, :d => ['d']}
+    end
+  end
 
-describe Hash, "#minus" do
-  it_should_behave_like "subtraction of hashes"
-end
 
-describe Hash, "#-" do
-  it_should_behave_like "subtraction of hashes"
+  shared_examples_for "subtraction of hashes" do
+    include Aquarium::Utils::ArrayUtils
+    include Aquarium::Utils::HashUtils
+    
+    before(:each) do
+      # override value:
+      @hash = {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc1}
+    end
+    
+    it "should return an empty hash if subtracted from itself." do
+      (@hash - @hash).should be_empty
+    end 
 
-  it "should support operator-style semantics" do
-    hash1 = {:a => :a1, :b =>:b1, :c => :c1, :d => :d1}
-    hash2 = {:b =>:b3, :c => 'c'}
-    hash3 = {:a =>:a4, :c => 'c'}
-    ((hash1 - hash2) - hash3).should == {:d => :d1}
-    (hash1 - (hash2 - hash3)).should == {:a => :a1, :c => :c1, :d => :d1}
-  end 
-end
+    it "should return an empty hash if an equivalent hash is subtracted from it." do
+      (@hash - {:a => ['a1', 'a2'], :b => [:b1, :b2], :c => @cc1}).should be_empty
+    end 
 
-describe Hash, "#eql_when_keys_compared?" do
-  include Aquarium::Utils::ArrayUtils
-  include Aquarium::Utils::HashUtils
+    it "should return an equivalent hash if the second hash is empty." do
+      (@hash - {}).should == @hash
+    end 
 
-  it "should return true when comparing a hash to itself." do
-    h1={"1" => :a1, "2" => :a2, "3" => :a3}
-    h1.eql_when_keys_compared?(h1).should == true
+    it "should return an equivalent hash if the second hash is nil." do
+      (@hash - nil).should == @hash
+    end 
+    
+    it "should return an empty hash if the first hash is empty, independent of the second hash." do
+      ({} - @hash).should be_empty
+    end 
+
+    it "should return a hash with all keys in the second hash removed, independent of the corresponding values, if no block is given." do
+      hash2 = {:b =>:b3, :c => 'c', :d => 'd'}
+      (@hash - hash2).should == {:a => ['a1', 'a2']}
+    end 
+
+    it "should return a hash with the values subtraced for partially-overlapping keys as specified by a given block." do
+      hash2 = {:b =>:b2, :c => @cc2, :d => 'd'}
+      @hash.minus(hash2) do |value1, value2| 
+        Set.new(make_array(value1)) - Set.new(make_array(value2))
+      end.should == {:a => Set.new(['a1', 'a2']), :b => Set.new([:b1]), :c => Set.new([@c1])}
+    end 
+
+    it "should be not associative." do
+      hash1 = {:a => :a1, :b =>:b1, :c => :c1, :d => :d1}
+      hash2 = {:b =>:b3, :c => 'c'}
+      hash3 = {:a =>:a4, :c => 'c'}
+      ((hash1 - hash2) - hash3).should == {:d => :d1}
+      (hash1 - (hash2 - hash3)).should == {:a => :a1, :c => :c1, :d => :d1}
+    end 
   end
 
-  it "should return true for hashes with string keys that satisfy String#==." do
-    h1={"1" => :a1, "2" => :a2, "3" => :a3}
-    h2={"1" => :a1, "2" => :a2, "3" => :a3}
-    h1.eql_when_keys_compared?(h2).should == true
+  describe Hash, "#minus" do
+    it_should_behave_like "subtraction of hashes"
   end
 
-  it "should return false for hashes with matching keys, but different values." do
-    h1={"1" => :a1, "2" => :a2, "3" => /a/}
-    h2={"1" => :a1, "2" => :a2, "3" => /b/}
-    h1.eql_when_keys_compared?(h2).should == false
-  end
+  describe Hash, "#-" do
+    it_should_behave_like "subtraction of hashes"
 
-  it "should return false for hashes where one hash is a subset of the other." do
-    h1={"1" => :a1, "2" => :a2}
-    h2={"1" => :a1, "2" => :a2, "3" => :a3}
-    h1.eql_when_keys_compared?(h2).should == false
-    h2.eql_when_keys_compared?(h1).should == false
+    it "should support operator-style semantics" do
+      hash1 = {:a => :a1, :b =>:b1, :c => :c1, :d => :d1}
+      hash2 = {:b =>:b3, :c => 'c'}
+      hash3 = {:a =>:a4, :c => 'c'}
+      ((hash1 - hash2) - hash3).should == {:d => :d1}
+      (hash1 - (hash2 - hash3)).should == {:a => :a1, :c => :c1, :d => :d1}
+    end 
   end
-  
-  it "should return true for hashes with Object keys that define a #<=> method, while Hash#eql? would return false." do
-    class Key
-      def initialize key
-        @key = key
-      end
-      attr_reader :key
-      def eql? other
-        key.eql? other.key
-      end
-      def <=> other
-        key <=> other.key
-      end
+
+  describe Hash, "#eql_when_keys_compared?" do
+    include Aquarium::Utils::ArrayUtils
+    include Aquarium::Utils::HashUtils
+
+    it "should return true when comparing a hash to itself." do
+      h1={"1" => :a1, "2" => :a2, "3" => :a3}
+      h1.eql_when_keys_compared?(h1).should == true
+    end
+
+    it "should return true for hashes with string keys that satisfy String#==." do
+      h1={"1" => :a1, "2" => :a2, "3" => :a3}
+      h2={"1" => :a1, "2" => :a2, "3" => :a3}
+      h1.eql_when_keys_compared?(h2).should == true
+    end
+
+    it "should return false for hashes with matching keys, but different values." do
+      h1={"1" => :a1, "2" => :a2, "3" => /a/}
+      h2={"1" => :a1, "2" => :a2, "3" => /b/}
+      h1.eql_when_keys_compared?(h2).should == false
+    end
+
+    it "should return false for hashes where one hash is a subset of the other." do
+      h1={"1" => :a1, "2" => :a2}
+      h2={"1" => :a1, "2" => :a2, "3" => :a3}
+      h1.eql_when_keys_compared?(h2).should == false
+      h2.eql_when_keys_compared?(h1).should == false
     end
     
-    h1 = {}; h2 = {}
-    (0...4).each do |index|
-      h1[Key.new(index)] = {index.to_s => [index, index+1]}
-      h2[Key.new(index)] = {index.to_s => [index, index+1]}
+    it "should return true for hashes with Object keys that define a #<=> method, while Hash#eql? would return false." do
+      class Key
+        def initialize key
+          @key = key
+        end
+        attr_reader :key
+        def eql? other
+          key.eql? other.key
+        end
+        def <=> other
+          key <=> other.key
+        end
+      end
+      
+      h1 = {}; h2 = {}
+      (0...4).each do |index|
+        h1[Key.new(index)] = {index.to_s => [index, index+1]}
+        h2[Key.new(index)] = {index.to_s => [index, index+1]}
+      end
+      h1.eql_when_keys_compared?(h2).should == true
+      h1.eql?(h2).should == false
     end
-    h1.eql_when_keys_compared?(h2).should == true
-    h1.eql?(h2).should == false
   end
-end
 
-describe Hash, "#equivalent_key" do
-  it "should return the key in the hash for which input_value#==(key) is true." do
-    class Key
-      def initialize key
-        @key = key
+  describe Hash, "#equivalent_key" do
+    it "should return the key in the hash for which input_value#==(key) is true." do
+      class Key
+        def initialize key
+          @key = key
+        end
+        attr_reader :key
+        def eql? other
+          key.eql? other.key
+        end
+        alias :== :eql?
       end
-      attr_reader :key
-      def eql? other
-        key.eql? other.key
+      
+      h1 = {}; h2 = {}
+      (0...4).each do |index|
+        h1[Key.new(index)] = {index.to_s => [index, index+1]}
+        h2[Key.new(index)] = {index.to_s => [index, index+1]}
       end
-      alias :== :eql?
+      h1[Key.new(0)].should be_nil
+      h1.equivalent_key(Key.new(0)).should_not be_nil
+      h1.equivalent_key(Key.new(5)).should     be_nil
     end
-    
-    h1 = {}; h2 = {}
-    (0...4).each do |index|
-      h1[Key.new(index)] = {index.to_s => [index, index+1]}
-      h2[Key.new(index)] = {index.to_s => [index, index+1]}
-    end
-    h1[Key.new(0)].should be_nil
-    h1.equivalent_key(Key.new(0)).should_not be_nil
-    h1.equivalent_key(Key.new(5)).should     be_nil
   end
-  
 end