aquarium 0.3.0 → 0.3.1

data/spec/aquarium/aspects/join_point_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 
 require 'aquarium/extensions/hash'
 require 'aquarium/aspects/join_point'
@@ -22,18 +22,41 @@ end
 
 describe Aquarium::Aspects::JoinPoint, "#initialize with invalid parameters" do
   
-  it "should require either a :type or an :object parameter when creating." do
+  it "should require either a :type or an :object parameter, but not both." do
     lambda { Aquarium::Aspects::JoinPoint.new :method_name => :count }.should raise_error(Aquarium::Utils::InvalidOptions)
     lambda { Aquarium::Aspects::JoinPoint.new :type => String, :object => "", :method_name => :count }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
   
-  it "should require a :method_name parameter when creating." do
+  it "should require a :method_name." do
     lambda { Aquarium::Aspects::JoinPoint.new :type => String }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 
-  it "should except :method as a synonym for the :method_name parameter." do
+  it "should except :method as a synonym for :method_name." do
     lambda { Aquarium::Aspects::JoinPoint.new :type => String, :method => :split }.should_not raise_error(Aquarium::Utils::InvalidOptions)
   end
+
+  it "should require a valid type name if a name is specified." do
+    lambda { Aquarium::Aspects::JoinPoint.new :type => "String", :method => :split }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aquarium::Aspects::JoinPoint.new :type => "Stringgy", :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+
+  it "should require a valid type name symbol if a name is specified." do
+    lambda { Aquarium::Aspects::JoinPoint.new :type => :String, :method => :split }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aquarium::Aspects::JoinPoint.new :type => :Stringgy, :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+
+  it "should require a valid type name regular expression if one is specified." do
+    lambda { Aquarium::Aspects::JoinPoint.new :type => /^String$/, :method => :split }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aquarium::Aspects::JoinPoint.new :type => /^Stringgy$/, :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+
+  it "should reject a regular expression that matches no types." do
+    lambda { Aquarium::Aspects::JoinPoint.new :type => /^Stringgy$/, :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+
+  it "should reject a regular expression that matches more than one type." do
+    lambda { Aquarium::Aspects::JoinPoint.new :type => /^M/, :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
 end
   
 describe Aquarium::Aspects::JoinPoint, "#initialize with parameters that specify class vs. instance methods" do

data/spec/aquarium/aspects/pointcut_and_composition_spec.rb

@@ -1,14 +1,39 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/utils'
 require 'aquarium/extensions'
 require 'aquarium/aspects/pointcut'
 require 'aquarium/aspects/pointcut_composition'
 
-describe "Intersection of Pointcuts", :shared => true do
-  include Aquarium::Utils::HashUtils
-  # include Aquarium::Utils::HtmlEscaper
+include Aquarium::Utils::HashUtils
+include Aquarium::Aspects
+
+describe Pointcut, "#and" do
+  it "should return a new Pointcut." do
+    pc1 = Pointcut.new
+    pc2 = Pointcut.new :types => ClassWithPublicInstanceMethod, :method_options => :exclude_ancestor_methods
+    pc12 = (pc1.and(pc2))
+    pc12.should_not equal(pc1)
+    pc12.should_not equal(pc2)
+  end
+end  
+  
+describe Pointcut, "#and (when one pointcut is empty)" do
+  before :all do
+    @pc1 = Pointcut.new
+    @pc2 = Pointcut.new :types => ClassWithPublicInstanceMethod, :method_options => :exclude_ancestor_methods
+  end
   
+  it "should return a new empty Pointcut if the left-hand Pointcut is empty, independent of the right-hand Pointcut." do
+    (@pc1.and(@pc2)).should == @pc1
+  end
+   
+  it "should return a new empty Pointcut if the right-hand Pointcut is empty, independent of the left-hand Pointcut." do
+    (@pc2.and(@pc1)).should == @pc1
+  end
+end
+   
+describe Pointcut, "#and (when both pointcuts are not empty)" do
   before(:each) do
     @example_types = {}
     [ClassWithPublicInstanceMethod, ClassWithProtectedInstanceMethod, ClassWithPrivateInstanceMethod, 
@@ -16,145 +41,116 @@ describe "Intersection of Pointcuts", :shared => true do
     @empty_set = Set.new
   end
 
-  it "should return an empty Aquarium::Aspects::Pointcut if the left-hand Aquarium::Aspects::Pointcut is empty, independent of the right-hand Aquarium::Aspects::Pointcut." do
-    pc1 = Aquarium::Aspects::Pointcut.new
-    pc2 = Aquarium::Aspects::Pointcut.new :types => /Class.*Method/
-    (pc1.and(pc2)).should == pc1
-    pc3 = Aquarium::Aspects::Pointcut.new :object => ClassWithPublicInstanceMethod.new
-    (pc1.and(pc3)).should == pc1
-  end
-   
-  it "should return an empty Aquarium::Aspects::Pointcut if the second pointcut has no join points." do
-    pc1 = Aquarium::Aspects::Pointcut.new :types => /Class.*Method/
-    pc2 = Aquarium::Aspects::Pointcut.new
-    (pc1.and(pc2)).should == pc2
-    pc3 = Aquarium::Aspects::Pointcut.new :object => ClassWithPublicInstanceMethod.new
-    (pc3.and(pc2)).should == pc2
-  end
-   
-  it "should return a new Aquarium::Aspects::Pointcut whose join points are the intersection of the left- and right-hand side Aquarium::Aspects::Pointcuts, each with multiple types." do
-    pc1 = Aquarium::Aspects::Pointcut.new :types => [ClassWithAttribs, ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod], :attributes => [/^attr/], :attribute_options => [:readers]
-    pc2 = Aquarium::Aspects::Pointcut.new :types => [ClassWithAttribs, ClassWithPublicInstanceMethod, ClassWithProtectedInstanceMethod], :attributes => :attrRW_ClassWithAttribs
+  it "should return a new Pointcut whose join points are the intersection of the left- and right-hand side Pointcuts, each with multiple types." do
+    pc1 = Pointcut.new :types => [ClassWithAttribs, ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod], :attributes => [/^attr/], :attribute_options => [:readers]
+    pc2 = Pointcut.new :types => [ClassWithAttribs, ClassWithPublicInstanceMethod, ClassWithProtectedInstanceMethod], :attributes => :attrRW_ClassWithAttribs, :attribute_options => [:exclude_ancestor_methods]
     pc = pc1.and pc2
-    expected_jp = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs
+    expected_jp = JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs
     pc.join_points_matched.should == Set.new([expected_jp])
     pc.join_points_not_matched.should == @empty_set
   end
   
-  it "should return a new Aquarium::Aspects::Pointcut whose join points are the intersection of the left- and right-hand side Aquarium::Aspects::Pointcuts, each with multiple objects." do
+  it "should return a new Pointcut whose join points are the intersection of the left- and right-hand side Pointcuts, each with multiple objects." do
     cwa = ClassWithAttribs.new
     pub = ClassWithPublicInstanceMethod.new 
     pri = ClassWithPrivateInstanceMethod.new
     pro = ClassWithProtectedInstanceMethod.new
-    pc1 = Aquarium::Aspects::Pointcut.new :objects => [cwa, pub, pri], :attributes => [/^attr/], :attribute_options => [:readers]
-    pc2 = Aquarium::Aspects::Pointcut.new :objects => [cwa, pub, pro], :attributes => :attrRW_ClassWithAttribs
+    pc1 = Pointcut.new :objects => [cwa, pub, pri], :attributes => [/^attr/], :attribute_options => [:readers, :exclude_ancestor_methods]
+    pc2 = Pointcut.new :objects => [cwa, pub, pro], :attributes => :attrRW_ClassWithAttribs
     pc = pc1.and pc2
-    expected_jp = Aquarium::Aspects::JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs
+    expected_jp = JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs
     pc.join_points_matched.should == Set.new([expected_jp])
     pc.join_points_not_matched.should == @empty_set
   end
    
-  it "should return a new Aquarium::Aspects::Pointcut whose join points are the intersection of the left- and right-hand side Aquarium::Aspects::Pointcuts, each with a single type." do
-    pc1 = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:readers]
-    pc2 = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => :attrRW_ClassWithAttribs
+  it "should return a new Pointcut whose join points are the intersection of the left- and right-hand side Pointcuts, each with a single type." do
+    pc1 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:readers]
+    pc2 = Pointcut.new :types => "ClassWithAttribs", :attributes => :attrRW_ClassWithAttribs
     pc = pc1.and pc2
-    expected_jp = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs
+    expected_jp = JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs
     pc.join_points_matched.should == Set.new([expected_jp])
     pc.join_points_not_matched.should == @empty_set
   end
   
-  it "should return a new Aquarium::Aspects::Pointcut whose join points are the intersection of the left- and right-hand side Aquarium::Aspects::Pointcuts, each with a single object." do
+  it "should return a new Pointcut whose join points are the intersection of the left- and right-hand side Pointcuts, each with a single object." do
     cwa = ClassWithAttribs.new
-    pc1 = Aquarium::Aspects::Pointcut.new :object => cwa, :attributes => [/^attr/], :attribute_options => [:readers]
-    pc2 = Aquarium::Aspects::Pointcut.new :object => cwa, :attributes => :attrRW_ClassWithAttribs
+    pc1 = Pointcut.new :object => cwa, :attributes => [/^attr/], :attribute_options => [:readers]
+    pc2 = Pointcut.new :object => cwa, :attributes => :attrRW_ClassWithAttribs
     pc = pc1.and pc2
-    expected_jp = Aquarium::Aspects::JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs
+    expected_jp = JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs
     pc.join_points_matched.should == Set.new([expected_jp])
     pc.join_points_not_matched.should == @empty_set
   end
-   
-  it "should be unitary for type-based Aquarium::Aspects::Pointcuts." do 
-    pc1 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc = pc1.and pc2
-    pc.should == pc1
-    pc.should == pc2
+end
+
+describe Pointcut, "#and (algebraic properties for type-based pointcuts)" do
+  before :all do
+    @pc1 = Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
+    @pc2 = Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
+    @pc3 = Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/]
   end
   
-  it "should be unitary for object-based Aquarium::Aspects::Pointcuts." do 
-    cwa = ClassWithAttribs.new
-    pc1 = Aquarium::Aspects::Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Aquarium::Aspects::Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc = pc1.and pc2
-    pc.should == pc1
-    pc.should == pc2
+  it "should be unitary for type-based Pointcuts." do 
+    pc = @pc1.and @pc2
+    pc.should == @pc1
+    pc.should == @pc2
   end
-   
-  it "should be commutative for type-based Aquarium::Aspects::Pointcuts." do 
-    pc1 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Aquarium::Aspects::Pointcut.new :types => /Class.*Method/
-    pc12 = pc1.and pc2
-    pc21 = pc2.and pc1
-    pc12.should == pc21
+
+  it "should be commutative for type-based Pointcuts." do 
+    pc13 = @pc1.and @pc3
+    pc31 = @pc3.and @pc1
+    pc13.should == pc31
   end
   
-  it "should be commutative for object-based Aquarium::Aspects::Pointcuts." do 
+  it "should be associativity for type-based Pointcuts." do 
+    pc123a = (@pc1.and(@pc2)).and(@pc3)
+    pc123b = @pc1.and(@pc2.and(@pc3))
+    pc123a.should == pc123b
+  end  
+end
+
+describe Pointcut, "#and (algebraic properties for object-based pointcuts)" do
+  before :all do
     cwa = ClassWithAttribs.new
-    pub = ClassWithPublicInstanceMethod.new 
-    pc1 = Aquarium::Aspects::Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Aquarium::Aspects::Pointcut.new :objects => pub, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc12 = pc1.and pc2
-    pc21 = pc2.and pc1
-    pc12.should == pc21
+    @pc1 = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
+    @pc2 = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
+    @pc3 = Pointcut.new :objects => cwa, :attributes => [/^attr/]
+  end
+  
+  it "should be unitary for object-based Pointcuts." do 
+    pc = @pc1.and @pc2
+    pc.should == @pc1
+    pc.should == @pc2
   end
    
-  it "should be associativity for type-based Aquarium::Aspects::Pointcuts." do 
-    pc1 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:readers]
-    pc3 = Aquarium::Aspects::Pointcut.new :types => /Class.*Method/
-    pc123a = (pc1.and(pc2)).and(pc3)
-    pc123b = pc1.and(pc2.and(pc3))
-    pc123a.should == pc123b
+  it "should be commutative for object-based Pointcuts." do 
+    pc13 = @pc1.and @pc3
+    pc31 = @pc3.and @pc1
+    pc13.should == pc31
   end
-  
-  it "should be associativity for object-based Aquarium::Aspects::Pointcuts." do 
-    cwa = ClassWithAttribs.new
-    pub = ClassWithPublicInstanceMethod.new 
-    pc1 = Aquarium::Aspects::Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Aquarium::Aspects::Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:readers]
-    pc3 = Aquarium::Aspects::Pointcut.new :objects => pub
-    pc123a = (pc1.and(pc2)).and(pc3)
-    pc123b = pc1.and(pc2.and(pc3))
+   
+  it "should be associativity for object-based Pointcuts." do 
+    pc123a = (@pc1.and(@pc2)).and(@pc3)
+    pc123b = @pc1.and(@pc2.and(@pc3))
     pc123a.should == pc123b
   end
 end
 
-describe Aquarium::Aspects::Pointcut, "#and" do
-  it_should_behave_like "Intersection of Pointcuts"
-end
-
-describe Aquarium::Aspects::Pointcut, "#&" do
-  include Aquarium::Utils::HashUtils
+describe Pointcut, "#&" do
 
-  it_should_behave_like "Intersection of Pointcuts"
-
-  it "should be associativity for type-based Aquarium::Aspects::Pointcuts." do 
-    pc1 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:readers]
-    pc3 = Aquarium::Aspects::Pointcut.new :types => /Class.*Method/
+  it "should be a synonym for #and." do 
+    pc1 = Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
+    pc2 = Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers]
+    pc3 = Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/]
     pc123a = (pc1 & pc2) & pc3
     pc123b = pc1 & (pc2 & pc3)
     pc123a.should == pc123b
-  end
-
-  it "should be associativity for object-based Aquarium::Aspects::Pointcuts." do 
     cwa = ClassWithAttribs.new
-    pub = ClassWithPublicInstanceMethod.new 
-    pc1 = Aquarium::Aspects::Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Aquarium::Aspects::Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:readers]
-    pc3 = Aquarium::Aspects::Pointcut.new :objects => pub
-    pc123a = (pc1 & pc2) & pc3
-    pc123b = pc1 & (pc2 & pc3)
-    pc123a.should == pc123b
+    pca = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
+    pcb = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
+    pcc = Pointcut.new :objects => cwa, :attributes => [/^attr/]
+    pcabc1 = (pca & pcb) & pcc
+    pcabc2 = pca & (pcb & pcc)
+    pcabc1.should == pcabc2
   end
 end

data/spec/aquarium/aspects/pointcut_or_composition_spec.rb

@@ -1,5 +1,5 @@
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/utils'
 require 'aquarium/extensions'
 require 'aquarium/aspects/pointcut'
@@ -8,148 +8,136 @@ require 'aquarium/aspects/pointcut_composition'
 include Aquarium::Utils::HashUtils
 include Aquarium::Aspects
 
-describe "Union of Pointcuts", :shared => true do
+describe Pointcut, "#or" do
   
-  before(:each) do
-    classes = [
-      ClassWithProtectedInstanceMethod, 
-      ClassWithPrivateInstanceMethod, 
-      ClassWithPublicClassMethod, 
-      ClassWithPrivateClassMethod,
-      ClassIncludingModuleWithPrivateClassMethod, 
-      ClassIncludingModuleWithPublicClassMethod,
-      ClassIncludingModuleWithProtectedInstanceMethod, 
-      ClassIncludingModuleWithPrivateInstanceMethod]
-    jps_array = classes.map {|c| Aquarium::Aspects::JoinPoint.new :type => c, :method => :all}
-    @not_matched_jps = Set.new(jps_array)
+  before :all do
+    @pc1 = Pointcut.new
+    @pc2 = Pointcut.new :types => /Class.*Public.*Method/, :method_options => [:exclude_ancestor_methods]
+    @pc3 = Pointcut.new :object => ClassWithProtectedInstanceMethod.new, :method_options => [:protected, :exclude_ancestor_methods]
   end
-
-  it "should return a Pointcut equal to the second, appended, non-empty Pointcut if self is empty (has no join points)." do
-    pc1 = Pointcut.new
-    pc2 = Pointcut.new :types => /Class.*Method/
-    pc1.or(pc2).should eql(pc2)
-    pc3 = Pointcut.new :object => ClassWithPublicInstanceMethod.new
-    pc1.or(pc3).should eql(pc3)
+   
+  it "should return a new Pointcut equal to the second, appended, non-empty Pointcut if self is empty (has no join points)." do
+    @pc1.or(@pc2).should eql(@pc2)
+    @pc1.or(@pc3).should eql(@pc3)
   end
    
-  it "should return a Pointcut equal to self if the second pointcut is empty." do
-    pc1 = Pointcut.new :types => /Class.*Method/
-    pc2 = Pointcut.new
-    pc1.or(pc2).should eql(pc1)
-    pc3 = Pointcut.new :object => ClassWithPublicInstanceMethod.new
-    pc3.or(pc2).should eql(pc3)
+  it "should return a new Pointcut equal to self if the second pointcut is empty." do
+    @pc2.or(@pc1).should eql(@pc2)
+    @pc3.or(@pc1).should eql(@pc3)
   end
+end
    
+describe Pointcut, "#or (with two non-empty pointcuts)" do
+  
   it "should return a new Pointcut whose join points are the union of the left- and right-hand side Pointcuts for type-based Pointcuts." do
-    pc1 = Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
-    # "[^F]" excludes the ClassWithFunkyMethodNames ...
-    pc2 = Pointcut.new :types => [/ClassWith[^F]+Method/, /ClassDerived/, /ClassIncludingMod/], :method_options => :exclude_ancestor_methods
-    pc = pc1.or pc2
-    jp1 = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs=
-    jp2 = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method => :attrW_ClassWithAttribs=
-    jp3 = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod,  :method => :public_instance_test_method
-    jp4 = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod2, :method => :public_instance_test_method2
-    jp5 = Aquarium::Aspects::JoinPoint.new :type => ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod, :method => :public_instance_class_derived_from_class_including_module_test_method
-    jp6 = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithPublicInstanceMethod, :method => :public_instance_class_including_module_test_method
-    pc.join_points_matched.should == Set.new([jp1, jp2, jp3, jp4, jp5, jp6])
-    pc.join_points_not_matched.should == @not_matched_jps
+    pc4 = Pointcut.new :type => ClassWithPublicInstanceMethod, :method_options => :exclude_ancestor_methods
+    pc5 = Pointcut.new :type => ClassWithAttribs, :methods => /^attr.*=$/, :method_options => :exclude_ancestor_methods
+    jp_np1 = JoinPoint.new :type => ClassIncludingModuleWithPublicInstanceMethod, :method => :public_instance_class_including_module_test_method
+    jp_np2 = JoinPoint.new :type => ModuleWithPublicInstanceMethod, :method => :public_instance_module_test_method
+    pc4.join_points_not_matched << jp_np1
+    pc5.join_points_not_matched << jp_np2
+    pc = pc4.or pc5
+    jp1 = JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs=
+    jp2 = JoinPoint.new :type => ClassWithAttribs, :method => :attrW_ClassWithAttribs=
+    jp3 = JoinPoint.new :type => ClassWithPublicInstanceMethod,  :method => :public_instance_test_method
+    pc.join_points_matched.should == Set.new([jp1, jp2, jp3])
+    pc.join_points_not_matched.should == Set.new([jp_np1, jp_np2])
   end
    
   it "should return a new Pointcut whose join points are the union of the left- and right-hand side Pointcuts for object-based Pointcuts." do
     cwa = ClassWithAttribs.new
     pub = ClassWithPublicInstanceMethod.new
-    pc1 = Pointcut.new :objects => [cwa], :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
-    pc2 = Pointcut.new :object  => pub, :method_options => :exclude_ancestor_methods
-    pc = pc1.or pc2
-    jp1 = Aquarium::Aspects::JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs=
-    jp2 = Aquarium::Aspects::JoinPoint.new :object => cwa, :method => :attrW_ClassWithAttribs=
-    jp3 = Aquarium::Aspects::JoinPoint.new :object => pub, :method => :public_instance_test_method
+    pc4 = Pointcut.new :objects => [cwa], :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+    pc5 = Pointcut.new :object  => pub, :method_options => :exclude_ancestor_methods
+    pc = pc4.or pc5
+    jp1 = JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs=
+    jp2 = JoinPoint.new :object => cwa, :method => :attrW_ClassWithAttribs=
+    jp3 = JoinPoint.new :object => pub, :method => :public_instance_test_method
     pc.join_points_matched.sort.should == [jp1, jp2, jp3].sort
     pc.join_points_not_matched.sort.should == []
   end
-   
+end
+ 
+describe Pointcut, "#or (algebraic properties for type-based pointcuts)" do
+  before :all do
+    @pc1 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+    @pc2 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+    @pc3 = Pointcut.new :types => /Class.*Public.*Method/, :method_options => [:public, :exclude_ancestor_methods]
+  end
+  
   it "should be unitary for type-based Pointcuts." do 
-    pc1 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers]
-    pc = pc1.or pc2
-    pc.should eql(pc1)
-    pc.should eql(pc2)
+    pc = @pc1.or @pc2
+    pc.should eql(@pc1)
+    pc.should eql(@pc2)
   end
    
-  it "should be unitary for object-based Pointcuts." do 
-    cwa = ClassWithAttribs.new
-    pc1 = Pointcut.new :object => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Pointcut.new :object => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc = pc1.or pc2
-    pc.should eql(pc1)
-    pc.should eql(pc2)
+  it "should be commutative for type-based Pointcuts." do 
+    pc13 = @pc1.or @pc3
+    pc31 = @pc3.or @pc1
+    pc13.should eql(pc31)
   end
    
-  it "should be commutative for type-based Pointcuts." do 
-    pc1 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Pointcut.new :types => /Class.*Method/
-    pc12 = pc1.or pc2
-    pc21 = pc2.or pc1
-    pc12.should eql(pc21)
+  it "should be associativity for type-based Pointcuts." do 
+    pc123a = (@pc1.or(@pc2)).or(@pc3)
+    pc123b = @pc1.or(@pc2.or(@pc3))
+    pc123a.should eql(pc123b)
   end
+end
    
-  it "should be commutative for object-based Pointcuts." do 
+describe Pointcut, "#or (algebraic properties for object-based pointcuts)" do
+  before :all do
     cwa = ClassWithAttribs.new
     pub = ClassWithPublicInstanceMethod.new 
-    pc1 = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Pointcut.new :objects => pub, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc12 = pc1.or pc2
-    pc21 = pc2.or pc1
-    pc12.should eql(pc21)
+    @pc1 = Pointcut.new :object => cwa, :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+    @pc2 = Pointcut.new :object => cwa, :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+    @pc3 = Pointcut.new :objects => pub, :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+  end
+  
+  it "should be unitary for object-based Pointcuts." do 
+    pc12 = @pc1.or @pc2
+    pc12.should eql(@pc1)
+    pc12.should eql(@pc2)
   end
    
-  it "should be associativity for type-based Pointcuts." do 
-    pc1 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:readers]
-    pc3 = Pointcut.new :types => /Class.*Method/
-    pc123a = (pc1.or(pc2)).or(pc3)
-    pc123b = pc1.or(pc2.or(pc3))
-    pc123a.should eql(pc123b)
+  it "should be commutative for object-based Pointcuts." do 
+    pc13 = @pc1.or @pc3
+    pc31 = @pc3.or @pc1
+    pc13.should eql(pc31)
   end
    
   it "should be associativity for object-based Pointcuts." do 
-    cwa = ClassWithAttribs.new
-    pub = ClassWithPublicInstanceMethod.new 
-    pc1 = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:readers]
-    pc3 = Pointcut.new :objects => pub
-    pc123a = (pc1.or(pc2)).or(pc3)
-    pc123b = pc1.or(pc2.or(pc3))
+    pc123a = (@pc1.or(@pc2)).or(@pc3)
+    pc123b = @pc1.or(@pc2.or(@pc3))
     pc123a.should eql(pc123b)
   end
-
 end
 
-describe Pointcut, "#or" do
-  it_should_behave_like "Union of Pointcuts"
-end
 
 describe Pointcut, "#|" do
- 
-  it_should_behave_like "Union of Pointcuts"
-
-  it "should be associativity for type-based Pointcuts." do 
-    pc1 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:readers]
-    pc3 = Pointcut.new :types => /Class.*Method/
-    pc123a = (pc1 | pc2) | pc3
-    pc123b = pc1 | (pc2 | pc3)
-    pc123a.should eql(pc123b)
-  end
-   
-  it "should be associativity for object-based Pointcuts." do 
+  it "should be a synonym for #or." do
+    pc1 = Pointcut.new
+    pc2 = Pointcut.new :types => /Class.*Public.*Method/, :method_options => [:public, :exclude_ancestor_methods]
+    pc3 = Pointcut.new :object => ClassWithPublicInstanceMethod.new, :method_options => [:exclude_ancestor_methods]
+    pc12 = pc1 | pc2
+    pc32 = pc3 | pc2
+    pc23 = pc2 | pc3
+    pc12.should_not equal(pc1)
+    pc12.should_not equal(pc2)
+    pc12.should eql(pc2)
+    pc32.should eql(pc23)
+    pca = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+    pcb = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:readers, :exclude_ancestor_methods]
+    pcc = Pointcut.new :types => /Class.*Method/, :method_options => [:exclude_ancestor_methods]
+    pcabc1 = (pca | pcb) | pcc
+    pcabc2 = pca | (pcb | pcc)
+    pcabc1.should eql(pcabc2)
     cwa = ClassWithAttribs.new
     pub = ClassWithPublicInstanceMethod.new 
-    pc1 = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers]
-    pc2 = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:readers]
-    pc3 = Pointcut.new :objects => pub
-    pc123a = (pc1 | pc2) | pc3
-    pc123b = pc1 | (pc2 | pc3)
-    pc123a.should eql(pc123b)
+    pcd = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+    pce = Pointcut.new :objects => cwa, :attributes => [/^attr/], :attribute_options => [:readers, :exclude_ancestor_methods]
+    pcf = Pointcut.new :objects => pub, :method_options => [:exclude_ancestor_methods]
+    pcdef1 = (pcd | pce) | pcf
+    pcdef2 = pcd | (pce | pcf)
+    pcdef1.should eql(pcdef2)
   end
 end