aquarium 0.1.6 → 0.1.7

data/spec/aquarium/aspects/aspect_spec.rb

@@ -416,27 +416,27 @@ describe Aspect, "#new modifications to the list of methods for the advised obje
   
   it "should not include new public instance or class methods for the advised type." do
     all_public_methods_before = all_public_methods_of_type Watchful
-    @aspect = Aspect.new :after, :pointcut => {:type => Watchful, :method_options => :suppress_ancestor_methods}, :advice => @advice 
+    @aspect = Aspect.new :after, :pointcut => {:type => Watchful, :method_options => :exclude_ancestor_methods}, :advice => @advice 
     (all_public_methods_of_type(Watchful) - all_public_methods_before).should == []
   end
 
   it "should not include new protected instance or class methods for the advised type." do
     all_protected_methods_before = all_protected_methods_of_type Watchful
-    @aspect = Aspect.new :after, :pointcut => {:type => Watchful, :method_options => :suppress_ancestor_methods}, :advice => @advice  
+    @aspect = Aspect.new :after, :pointcut => {:type => Watchful, :method_options => :exclude_ancestor_methods}, :advice => @advice  
     (all_protected_methods_of_type(Watchful) - all_protected_methods_before).should == []
   end
 
   it "should not include new public methods for the advised object." do
     watchful = Watchful.new
     all_public_methods_before = all_public_methods_of_object Watchful
-    @aspect = Aspect.new :after, :pointcut => {:object => watchful, :method_options => :suppress_ancestor_methods}, :advice => @advice  
+    @aspect = Aspect.new :after, :pointcut => {:object => watchful, :method_options => :exclude_ancestor_methods}, :advice => @advice  
     (all_public_methods_of_object(Watchful) - all_public_methods_before).should == []
   end
 
   it "should not include new protected methods for the advised object." do
     watchful = Watchful.new
     all_protected_methods_before = all_protected_methods_of_object Watchful
-    @aspect = Aspect.new :after, :pointcut => {:object => watchful, :method_options => :suppress_ancestor_methods}, :advice => @advice  
+    @aspect = Aspect.new :after, :pointcut => {:object => watchful, :method_options => :exclude_ancestor_methods}, :advice => @advice  
     (all_protected_methods_of_object(Watchful) - all_protected_methods_before).should == []
   end
 end
@@ -808,7 +808,7 @@ describe Aspect, "#new with :around advice" do
     module AdvisingSuperClass
       class SuperClass
         def public_method *args
-          yield *args if block_given?
+          # yield *args if block_given?
         end
         protected
         def protected_method *args
@@ -848,7 +848,7 @@ describe Aspect, "#new with :around advice" do
     module AdvisingSubClass
       class SuperClass
         def public_method *args
-          yield *args if block_given?
+          # yield *args if block_given?
         end
         protected
         def protected_method *args
@@ -1005,7 +1005,7 @@ describe Aspect, "#unadvise" do
     
   it "should remove all advice added by the aspect." do
     advice_called = false
-    aspect = Aspect.new(:after, :pointcut => {:type => Watchful, :method_options => :suppress_ancestor_methods}) {|jp, *args| advice_called = true}
+    aspect = Aspect.new(:after, :pointcut => {:type => Watchful, :method_options => :exclude_ancestor_methods}) {|jp, *args| advice_called = true}
     aspect.unadvise
     watchful = Watchful.new
 
@@ -1023,7 +1023,7 @@ describe Aspect, "#unadvise" do
       def bar; end
     end
     before = Foo.private_instance_methods.sort
-    aspect = Aspect.new(:after, :pointcut => {:type => Foo, :method_options => :suppress_ancestor_methods}) {|jp, *args| true}
+    aspect = Aspect.new(:after, :pointcut => {:type => Foo, :method_options => :exclude_ancestor_methods}) {|jp, *args| true}
     after  = Foo.private_instance_methods
     (after - before).should_not == []
     aspect.unadvise
@@ -1053,6 +1053,41 @@ describe Aspect, "Unadvising methods should restore the original protection leve
   it_should_behave_like("invariant protection level of methods under advising and unadvising")
 end
 
+
+describe Aspect, "Advising methods with non-alphanumeric characters" do
+  module Aquarium::Aspects
+    class ClassWithMethodNamesContainingOddChars
+      @@method_names = []
+      %w[= ! ?].each do |s|
+        @@method_names << "_a#{s}" << "a#{s}"
+      end
+      %w[+ - * / < << > >> =~ == === <=> % ^ ~ [] & | `].each do |s|
+        @@method_names << s 
+      end
+      @@method_names.each do |s|
+        class_eval <<-EOF
+          def #{s}; "#{s}"; end
+        EOF
+      end
+      def self.method_names; @@method_names; end
+    end
+  end
+  it "should work with any valid ruby character" do
+    actual = ""
+    Aspect.new :before, :type => Aquarium::Aspects::ClassWithMethodNamesContainingOddChars, 
+      :methods => Aquarium::Aspects::ClassWithMethodNamesContainingOddChars.method_names do |jp, *args|
+      actual += ", #{jp.method_name}"
+    end
+    object = Aquarium::Aspects::ClassWithMethodNamesContainingOddChars.new
+    expected = ""
+    Aquarium::Aspects::ClassWithMethodNamesContainingOddChars.method_names.each do |s|
+      object.send s
+      expected += ", #{s}"
+    end
+    actual.should == expected
+  end
+end
+
 describe Aspect, "#eql?" do
   before(:all) do
     @advice = Proc.new {}

data/spec/aquarium/aspects/pointcut_and_composition_spec.rb

@@ -5,9 +5,9 @@ require 'aquarium/extensions'
 require 'aquarium/aspects/pointcut'
 require 'aquarium/aspects/pointcut_composition'
 
-describe "Aquarium::Aspects::Pointcut#and" do
+describe "Intersection of Pointcuts", :shared => true do
   include Aquarium::Utils::HashUtils
-  include Aquarium::Utils::HtmlEscaper
+  # include Aquarium::Utils::HtmlEscaper
   
   before(:each) do
     @example_types = {}
@@ -127,5 +127,34 @@ describe "Aquarium::Aspects::Pointcut#and" do
     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
+
+  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/
+    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
+  end
 end

data/spec/aquarium/aspects/pointcut_or_composition_spec.rb

@@ -5,7 +5,7 @@ require 'aquarium/extensions'
 require 'aquarium/aspects/pointcut'
 require 'aquarium/aspects/pointcut_composition'
 
-describe "Aquarium::Aspects::Pointcut#and" do
+describe "Union of Pointcuts", :shared => true do
   include Aquarium::Utils::HashUtils
   
   before(:each) do
@@ -31,9 +31,9 @@ describe "Aquarium::Aspects::Pointcut#and" do
   end
    
   it "should return a new Aquarium::Aspects::Pointcut whose join points are the union of the left- and right-hand side Aquarium::Aspects::Pointcuts for type-based Aquarium::Aspects::Pointcuts." do
-    pc1 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers, :suppress_ancestor_methods]
+    pc1 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
     # "[^F]" excludes the ClassWithFunkyMethodNames...
-    pc2 = Aquarium::Aspects::Pointcut.new :types => /Class[^F]+Method/, :method_options => :suppress_ancestor_methods
+    pc2 = Aquarium::Aspects::Pointcut.new :types => /Class[^F]+Method/, :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=
@@ -46,8 +46,8 @@ describe "Aquarium::Aspects::Pointcut#and" do
   it "should return a new Aquarium::Aspects::Pointcut whose join points are the union of the left- and right-hand side Aquarium::Aspects::Pointcuts 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, :suppress_ancestor_methods]
-    pc2 = Aquarium::Aspects::Pointcut.new :object  => pub, :method_options => :suppress_ancestor_methods
+    pc1 = Aquarium::Aspects::Pointcut.new :objects => [cwa], :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
+    pc2 = Aquarium::Aspects::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=
@@ -110,4 +110,35 @@ describe "Aquarium::Aspects::Pointcut#and" do
     pc123b = pc1.or(pc2.or(pc3))
     pc123a.should eql(pc123b)
   end
+
+end
+
+describe Aquarium::Aspects::Pointcut, "#or" do
+  it_should_behave_like "Union of Pointcuts"
+end
+
+describe Aquarium::Aspects::Pointcut, "#|" do
+  include Aquarium::Utils::HashUtils
+ 
+  it_should_behave_like "Union 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/
+    pc123a = (pc1 | pc2) | pc3
+    pc123b = pc1 | (pc2 | pc3)
+    pc123a.should eql(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 eql(pc123b)
+  end
 end

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -6,7 +6,50 @@ require 'aquarium/aspects/join_point'
 require 'aquarium/aspects/pointcut'
 require 'aquarium/utils'
 
-def common_setup
+class ExcludeTestOne
+  def method11; end
+  def method12; end
+  def method13; end
+end
+class ExcludeTestTwo
+  def method21; end
+  def method22; end
+  def method23; end
+end
+class ExcludeTestThree
+  def method31; end
+  def method32; end
+  def method33; end
+end
+
+def before_exclude_spec
+  @jp11  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestOne,   :method_name => :method11
+  @jp12  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestOne,   :method_name => :method12
+  @jp13  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestOne,   :method_name => :method13
+  @jp21  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestTwo,   :method_name => :method21
+  @jp22  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestTwo,   :method_name => :method22
+  @jp23  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestTwo,   :method_name => :method23
+  @jp31  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestThree, :method_name => :method31
+  @jp32  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestThree, :method_name => :method32
+  @jp33  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestThree, :method_name => :method33
+  @et1 = ExcludeTestOne.new
+  @et2 = ExcludeTestTwo.new
+  @et3 = ExcludeTestThree.new
+  @ojp11 = Aquarium::Aspects::JoinPoint.new :object => @et1, :method_name => :method11
+  @ojp12 = Aquarium::Aspects::JoinPoint.new :object => @et1, :method_name => :method12
+  @ojp13 = Aquarium::Aspects::JoinPoint.new :object => @et1, :method_name => :method13
+  @ojp21 = Aquarium::Aspects::JoinPoint.new :object => @et2, :method_name => :method21
+  @ojp22 = Aquarium::Aspects::JoinPoint.new :object => @et2, :method_name => :method22
+  @ojp23 = Aquarium::Aspects::JoinPoint.new :object => @et2, :method_name => :method23
+  @ojp31 = Aquarium::Aspects::JoinPoint.new :object => @et3, :method_name => :method31
+  @ojp32 = Aquarium::Aspects::JoinPoint.new :object => @et3, :method_name => :method32
+  @ojp33 = Aquarium::Aspects::JoinPoint.new :object => @et3, :method_name => :method33
+  @all_type_jps   = [@jp11,  @jp12,  @jp13,  @jp21,  @jp22,  @jp23,  @jp31,  @jp32,  @jp33]
+  @all_object_jps = [@ojp11, @ojp12, @ojp13, @ojp21, @ojp22, @ojp23, @ojp31, @ojp32, @ojp33]
+  @all_jps = @all_type_jps + @all_object_jps
+end
+
+def before_pointcut_spec
   @example_types_without_public_instance_method = 
   [ClassWithProtectedInstanceMethod, ClassWithPrivateInstanceMethod, ClassWithPublicClassMethod, ClassWithPrivateClassMethod]
   @example_types = ([ClassWithPublicInstanceMethod] + @example_types_without_public_instance_method)
@@ -95,75 +138,75 @@ describe Aquarium::Aspects::Pointcut, "#empty?" do
 end
 
 describe Aquarium::Aspects::Pointcut, " (types specified using regular expressions)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
 
-  it "should match multiple classes using regular expressions that cover the full class names." do
-    pc = Aquarium::Aspects::Pointcut.new :types => /Class.*Method\Z/, :method_options => :suppress_ancestor_methods
+  it "should match multiple types using regular expressions that cover the full class names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /Class.*Method\Z/, :method_options => :exclude_ancestor_methods
     pc.join_points_matched.should == @expected_matched_jps
     pc.join_points_not_matched.should == @expected_not_matched_jps
   end
 
-  it "should match classes using regular expressions that only cover partial class names." do
-    pc = Aquarium::Aspects::Pointcut.new :types => /lass.*Pro.*Inst.*Met/, :method_options => [:public, :protected, :suppress_ancestor_methods]
+  it "should match types using regular expressions that only cover partial class names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /lass.*Pro.*Inst.*Met/, :method_options => [:public, :protected, :exclude_ancestor_methods]
     pc.join_points_matched.should == Set.new([@pro_jp])
     pc.join_points_not_matched.size.should == 0
   end
 end
 
 describe Aquarium::Aspects::Pointcut, " (types specified using names)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
 
-  it "should match multiple classes using names." do
-    pc = Aquarium::Aspects::Pointcut.new :types => @example_types.map {|t| t.to_s}, :method_options => :suppress_ancestor_methods
+  it "should match multiple types using names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_types.map {|t| t.to_s}, :method_options => :exclude_ancestor_methods
     pc.join_points_matched.should == @expected_matched_jps
     pc.join_points_not_matched.should == @expected_not_matched_jps
   end
   
-  it "should match multiple classes using types themselves." do
-    pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :method_options => :suppress_ancestor_methods
+  it "should match multiple types using types themselves." do
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :method_options => :exclude_ancestor_methods
     pc.join_points_matched.should == @expected_matched_jps
     pc.join_points_not_matched.should == @expected_not_matched_jps
   end
   
   it "should match :all public instance methods for types by default." do
-    pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :method_options => :suppress_ancestor_methods
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :method_options => :exclude_ancestor_methods
     pc.join_points_matched.should == @expected_matched_jps
     pc.join_points_not_matched.should == @expected_not_matched_jps
   end
 
-  it "should support MethodFinder's :suppress_ancestor_methods option when using types." do
-    pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :method_options => :suppress_ancestor_methods
+  it "should support MethodFinder's :exclude_ancestor_methods option when using types." do
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :method_options => :exclude_ancestor_methods
     pc.join_points_matched.should == @expected_matched_jps
     pc.join_points_not_matched.should == @expected_not_matched_jps
   end
 end
 
 describe Aquarium::Aspects::Pointcut, " (objects specified)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
 
   it "should match :all public instance methods for objects by default." do
     pub, pro = ClassWithPublicInstanceMethod.new, ClassWithProtectedInstanceMethod.new
-    pc = Aquarium::Aspects::Pointcut.new :objects => [pub, pro], :method_options => :suppress_ancestor_methods
+    pc = Aquarium::Aspects::Pointcut.new :objects => [pub, pro], :method_options => :exclude_ancestor_methods
     pc.join_points_matched.should == Set.new([Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :public_instance_test_method)])
     pc.join_points_not_matched.should == Set.new([Aquarium::Aspects::JoinPoint.new(:object => pro, :method_name => :all)])
   end
   
-  it "should support MethodFinder's :suppress_ancestor_methods option when using objects." do
+  it "should support MethodFinder's :exclude_ancestor_methods option when using objects." do
     pub, pro = ClassWithPublicInstanceMethod.new, ClassWithProtectedInstanceMethod.new
-    pc = Aquarium::Aspects::Pointcut.new :objects => [pub, pro], :method_options => :suppress_ancestor_methods
+    pc = Aquarium::Aspects::Pointcut.new :objects => [pub, pro], :method_options => :exclude_ancestor_methods
     pc.join_points_matched.should == Set.new([Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :public_instance_test_method)])
     pc.join_points_not_matched.should == Set.new([Aquarium::Aspects::JoinPoint.new(:object => pro, :method_name => :all)])
   end
   
   it "should match all possible methods on the specified objects." do
     pub, pro = ClassWithPublicInstanceMethod.new, ClassWithProtectedInstanceMethod.new
-    pc = Aquarium::Aspects::Pointcut.new :objects => [pub, pro], :methods => :all, :method_options => [:public, :protected, :suppress_ancestor_methods]
+    pc = Aquarium::Aspects::Pointcut.new :objects => [pub, pro], :methods => :all, :method_options => [:public, :protected, :exclude_ancestor_methods]
     pc.join_points_matched.size.should == 2
     pc.join_points_not_matched.size.should == 0
     pc.join_points_matched.should == Set.new([
@@ -182,105 +225,290 @@ describe Aquarium::Aspects::Pointcut, " (objects specified)" do
   end  
 end
 
+describe Aquarium::Aspects::Pointcut, " (:exclude_types => types specified)" do
+  before(:each) do
+    before_exclude_spec
+  end
+  
+  it "should remove from a list of explicitly-specified types the set of explicitly-specified excluded types." do
+    pc = Aquarium::Aspects::Pointcut.new :types => [ExcludeTestOne, ExcludeTestTwo, ExcludeTestThree], :exclude_type => ExcludeTestTwo, :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 2
+    actual.should include(ExcludeTestOne)
+    actual.should include(ExcludeTestThree)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from a list of explicitly-specified types the set of excluded types specified by regular expression." do
+    pc = Aquarium::Aspects::Pointcut.new :types => [ExcludeTestOne, ExcludeTestTwo, ExcludeTestThree], :exclude_types => /Two$/, :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 2
+    actual.should include(ExcludeTestOne)
+    actual.should include(ExcludeTestThree)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from a list of explicitly-specified types the set of excluded types specified by name." do
+    pc = Aquarium::Aspects::Pointcut.new :types => [ExcludeTestOne, ExcludeTestTwo, ExcludeTestThree], :exclude_type => "ExcludeTestTwo", :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 2
+    actual.should include(ExcludeTestOne)
+    actual.should include(ExcludeTestThree)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from the types specified by regular expression the explicitly-specified excluded types." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /ExcludeTest/, :exclude_type => ExcludeTestTwo, :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 2
+    actual.should include(ExcludeTestOne)
+    actual.should include(ExcludeTestThree)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from the types specified by regular expression the excluded types specified by regular expression." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /ExcludeTest/, :exclude_type => /Two$/, :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 2
+    actual.should include(ExcludeTestOne)
+    actual.should include(ExcludeTestThree)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from the types specified by regular expression the excluded types specified by name." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /ExcludeTest/, :exclude_type => "ExcludeTestTwo", :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 2
+    actual.should include(ExcludeTestOne)
+    actual.should include(ExcludeTestThree)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from the join points corresponding to the excluded types, specified by name." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_type_jps, :exclude_type => "ExcludeTestTwo", :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 2
+    actual.should include(ExcludeTestOne)
+    actual.should include(ExcludeTestThree)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove the specified join points corresponding to the excluded types, specified by regular expression." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_type_jps, :exclude_type => /Exclude.*Two/, :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 2
+    actual.should include(ExcludeTestOne)
+    actual.should include(ExcludeTestThree)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should not add excluded types to the #not_matched results." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /ExcludeTest/, :exclude_type => ExcludeTestTwo, :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should be a synonym for :exclude_type." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /ExcludeTest/, :exclude_types => [ExcludeTestTwo, ExcludeTestThree], :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 1
+    actual.should include(ExcludeTestOne)
+    pc.join_points_not_matched.size.should == 0
+  end
+end
+
+describe Aquarium::Aspects::Pointcut, " (:exclude_objects => objects specified)" do
+  before(:each) do
+    @e11 = ExcludeTestOne.new  
+    @e12 = ExcludeTestOne.new  
+    @e21 = ExcludeTestTwo.new  
+    @e22 = ExcludeTestTwo.new  
+    @e31 = ExcludeTestThree.new  
+    @e32 = ExcludeTestThree.new  
+    @objects = [@e11, @e12, @e21, @e22, @e31, @e32]
+  end
+  
+  it "should remove from the matched objects the excluded objects." do
+    pc = Aquarium::Aspects::Pointcut.new :objects => @objects, :exclude_objects => [@e22, @e31], :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 4
+    [@e11, @e12, @e21, @e32].each {|e| actual.should include(e)}
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove the specified join points corresponding to the excluded objects." do
+    jps11 = Aquarium::Aspects::JoinPoint.new :object => @e11, :method => :method11
+    jps21 = Aquarium::Aspects::JoinPoint.new :object => @e21, :method => :method21
+    jps22 = Aquarium::Aspects::JoinPoint.new :object => @e22, :method => :method22
+    jps31 = Aquarium::Aspects::JoinPoint.new :object => @e31, :method => :method31
+    jps = [jps11, jps21, jps22, jps31]
+    pc = Aquarium::Aspects::Pointcut.new :join_points => jps, :exclude_objects => [@e22, @e31], :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.size.should == 2
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    [@e11, @e21].each {|e| actual.should include(e)}
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should not add excluded objects to the #not_matched results." do
+    pc = Aquarium::Aspects::Pointcut.new :objects => @objects, :exclude_objects => [@e22, @e31], :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should be a synonym for :exclude_object." do
+    pc = Aquarium::Aspects::Pointcut.new :objects => @objects, :exclude_object => @e22, :method_options => :exclude_ancestor_methods
+    actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
+    actual.size.should == 5
+    [@e11, @e12, @e21, @e31, @e32].each {|e| actual.should include(e)}
+    pc.join_points_not_matched.size.should == 0
+  end
+end
+
+describe Aquarium::Aspects::Pointcut, " (:exclude_join_points => join_points specified)" do
+  before(:each) do
+    before_exclude_spec
+  end
+
+  it "should remove from a list of explicitly-specified join points the set of explicitly-specified excluded join points." do
+    excluded = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_join_points => excluded
+    pc.join_points_matched.should == Set.new(@all_jps - excluded)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from the list of generated, type-based join points the set of explicitly-specified excluded join points." do
+    jp11  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestOne,   :method_name => :method11
+    jp22  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestTwo,   :method_name => :method22
+    jp33  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestThree, :method_name => :method33
+    excluded = [jp11, jp22, jp33]
+    pc = Aquarium::Aspects::Pointcut.new :types => /ExcludeTest/, :exclude_join_points => excluded, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == Set.new(@all_type_jps - excluded)
+    pc.join_points_not_matched.size.should == 0
+  end
+
+  it "should remove from the list of generated, object-based join points the set of explicitly-specified excluded join points." do
+    ojp12 = Aquarium::Aspects::JoinPoint.new :object => @et1, :method_name => :method12
+    ojp23 = Aquarium::Aspects::JoinPoint.new :object => @et2, :method_name => :method23
+    ojp31 = Aquarium::Aspects::JoinPoint.new :object => @et3, :method_name => :method31
+    excluded = [ojp12, ojp23, ojp31]  
+    pc = Aquarium::Aspects::Pointcut.new :objects => [@et1, @et2, @et3], :exclude_join_points => excluded, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == Set.new(@all_object_jps - excluded)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should not add excluded types to the #not_matched results." do
+    excluded = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_join_points => excluded
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should be a synonym for :exclude_join_point." do
+    excluded = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_join_point => excluded
+    pc.join_points_matched.should == Set.new(@all_jps - excluded)
+    pc.join_points_not_matched.size.should == 0
+  end
+end
+
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with public instance methods)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
 
   it "should support MethodFinder's :public and :instance options for the specified types." do
-    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithPublicInstanceMethod, :method_options => [:public, :instance, :suppress_ancestor_methods]
-    pc.join_points_matched.should eql(Set.new([@pub_jp]))
+    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithPublicInstanceMethod, :method_options => [:public, :instance, :exclude_ancestor_methods]
+    pc.join_points_matched.should be_eql(Set.new([@pub_jp]))
     pc.join_points_not_matched.size.should == 0
   end
   
   it "should support MethodFinder's :public and :instance options for the specified objects." do
     pub = ClassWithPublicInstanceMethod.new
-    pc = Aquarium::Aspects::Pointcut.new :objects => pub, :method_options => [:public, :instance, :suppress_ancestor_methods]
-    pc.join_points_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :public_instance_test_method)]))
+    pc = Aquarium::Aspects::Pointcut.new :objects => pub, :method_options => [:public, :instance, :exclude_ancestor_methods]
+    pc.join_points_matched.should be_eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :public_instance_test_method)]))
     pc.join_points_not_matched.size.should == 0
   end
 end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with protected instance methods)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
   
   it "should support MethodFinder's :protected and :instance options for the specified types." do
-    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithProtectedInstanceMethod, :method_options => [:protected, :instance, :suppress_ancestor_methods]
-    pc.join_points_matched.should eql(Set.new([@pro_jp]))
+    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithProtectedInstanceMethod, :method_options => [:protected, :instance, :exclude_ancestor_methods]
+    pc.join_points_matched.should be_eql(Set.new([@pro_jp]))
     pc.join_points_not_matched.size.should == 0
   end
   
   it "should support MethodFinder's :protected and :instance options for the specified objects." do
     pro = ClassWithProtectedInstanceMethod.new
-    pc = Aquarium::Aspects::Pointcut.new :objects => pro, :method_options => [:protected, :instance, :suppress_ancestor_methods]
-    pc.join_points_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pro, :method_name => :protected_instance_test_method)]))
+    pc = Aquarium::Aspects::Pointcut.new :objects => pro, :method_options => [:protected, :instance, :exclude_ancestor_methods]
+    pc.join_points_matched.should be_eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pro, :method_name => :protected_instance_test_method)]))
     pc.join_points_not_matched.size.should == 0
   end
 end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with private instance methods)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
   
   it "should support MethodFinder's :private and :instance options for the specified types." do
-    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithPrivateInstanceMethod, :method_options => [:private, :instance, :suppress_ancestor_methods]
-    pc.join_points_matched.should eql(Set.new([@pri_jp]))
+    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithPrivateInstanceMethod, :method_options => [:private, :instance, :exclude_ancestor_methods]
+    pc.join_points_matched.should be_eql(Set.new([@pri_jp]))
     pc.join_points_not_matched.size.should == 0
   end
   
   it "should support MethodFinder's :private and :instance options for the specified objects." do
     pro = ClassWithPrivateInstanceMethod.new
-    pc = Aquarium::Aspects::Pointcut.new :objects => pro, :method_options => [:private, :instance, :suppress_ancestor_methods]
-    pc.join_points_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pro, :method_name => :private_instance_test_method)]))
+    pc = Aquarium::Aspects::Pointcut.new :objects => pro, :method_options => [:private, :instance, :exclude_ancestor_methods]
+    pc.join_points_matched.should be_eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pro, :method_name => :private_instance_test_method)]))
     pc.join_points_not_matched.size.should == 0
   end
 end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with public class methods)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
   
   it "should support MethodFinder's :public and :class options for the specified types." do
-    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithPublicClassMethod, :method_options => [:public, :class, :suppress_ancestor_methods]
-    pc.join_points_matched.should eql(Set.new([@cpub_jp]))
+    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithPublicClassMethod, :method_options => [:public, :class, :exclude_ancestor_methods]
+    pc.join_points_matched.should be_eql(Set.new([@cpub_jp]))
     pc.join_points_not_matched.size.should == 0
   end
   
   it "should support MethodFinder's :public and :class options for the specified objects, which will return no methods." do
     pub = ClassWithPublicInstanceMethod.new
-    pc = Aquarium::Aspects::Pointcut.new :objects => pub, :method_options => [:public, :class, :suppress_ancestor_methods]
+    pc = Aquarium::Aspects::Pointcut.new :objects => pub, :method_options => [:public, :class, :exclude_ancestor_methods]
     pc.join_points_matched.size.should == 0
     pc.join_points_not_matched.size.should == 1
-    pc.join_points_not_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :all, :class_method => true)]))
+    pc.join_points_not_matched.should be_eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pub, :method_name => :all, :class_method => true)]))
   end
 end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with private class methods)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
   
   it "should support MethodFinder's :private and :class options for the specified types." do
-    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithPrivateClassMethod, :method_options => [:private, :class, :suppress_ancestor_methods]
-    pc.join_points_matched.should eql(Set.new([@cpri_jp]))
+    pc = Aquarium::Aspects::Pointcut.new :types => ClassWithPrivateClassMethod, :method_options => [:private, :class, :exclude_ancestor_methods]
+    pc.join_points_matched.should be_eql(Set.new([@cpri_jp]))
     pc.join_points_not_matched.size.should == 0
   end
   
   it "should support MethodFinder's :private and :class options for the specified objects, which will return no methods." do
     pri = ClassWithPrivateInstanceMethod.new
-    pc = Aquarium::Aspects::Pointcut.new :objects => pri, :method_options => [:private, :class, :suppress_ancestor_methods]
-    pc.join_points_not_matched.should eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pri, :method_name => :all, :class_method => true)]))
+    pc = Aquarium::Aspects::Pointcut.new :objects => pri, :method_options => [:private, :class, :exclude_ancestor_methods]
+    pc.join_points_not_matched.should be_eql(Set.new([Aquarium::Aspects::JoinPoint.new(:object => pri, :method_name => :all, :class_method => true)]))
     pc.join_points_not_matched.size.should == 1
   end
 end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with method regular expressions)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
     @jp_rwe = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method_name => :attrRW_ClassWithAttribs=
     @jp_rw  = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method_name => :attrRW_ClassWithAttribs
     @jp_we  = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method_name => :attrW_ClassWithAttribs=
@@ -310,9 +538,57 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with method
   end
 end
 
+describe Aquarium::Aspects::Pointcut, " (:exclude_methods => methods specified)" do
+  before(:each) do
+    before_exclude_spec
+  end
+  
+  it "should remove type-specified JoinPoints matching the excluded methods specified by name." do
+    pc = Aquarium::Aspects::Pointcut.new :types => [ExcludeTestOne, ExcludeTestTwo, ExcludeTestThree], :exclude_methods => [:method11, :method23], :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.size.should == 7
+    pc.join_points_matched.should == Set.new([@jp12, @jp13, @jp21, @jp22, @jp31, @jp32, @jp33])
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove type-specified JoinPoints matching the excluded methods specified by regular expression." do
+    pc = Aquarium::Aspects::Pointcut.new :types => [ExcludeTestOne, ExcludeTestTwo, ExcludeTestThree], :exclude_methods => /method[12][13]/, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.size.should == 5
+    pc.join_points_matched.should == Set.new([@jp12, @jp22, @jp31, @jp32, @jp33])
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove object-specified JoinPoints matching the excluded methods specified by name." do
+    pc = Aquarium::Aspects::Pointcut.new :objects => [@et1, @et2, @et3], :exclude_methods => [:method11, :method23], :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.size.should == 7
+    pc.join_points_matched.should == Set.new([@ojp12, @ojp13, @ojp21, @ojp22, @ojp31, @ojp32, @ojp33])
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove object-specified JoinPoints matching the excluded methods specified by regular expression." do
+    pc = Aquarium::Aspects::Pointcut.new :objects => [@et1, @et2, @et3], :exclude_methods => /method[12][13]/, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.size.should == 5
+    pc.join_points_matched.should == Set.new([@ojp12, @ojp22, @ojp31, @ojp32, @ojp33])
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove join-point-specified JoinPoints matching the excluded methods specified by name." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_methods => [:method11, :method23], :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.size.should == 14
+    pc.join_points_matched.should == Set.new([@jp12, @jp13, @jp21, @jp22, @jp31, @jp32, @jp33, @ojp12, @ojp13, @ojp21, @ojp22, @ojp31, @ojp32, @ojp33])
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove join-point-specified JoinPoints matching the excluded methods specified by regular expression." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_methods => /method[12][13]/, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.size.should == 10
+    pc.join_points_matched.should == Set.new([@jp12, @jp22, @jp31, @jp32, @jp33, @ojp12, @ojp22, @ojp31, @ojp32, @ojp33])
+    pc.join_points_not_matched.size.should == 0
+  end
+end
+  
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribute regular expressions)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
     @jp_rwe = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method_name => :attrRW_ClassWithAttribs=
     @jp_rw  = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method_name => :attrRW_ClassWithAttribs
     @jp_we  = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method_name => :attrW_ClassWithAttribs=
@@ -328,6 +604,7 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribu
   
   it "should match on public attribute readers and writers for type names by default." do
     pc = Aquarium::Aspects::Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/]
+    pc.join_points_matched.size.should == 4
     pc.join_points_matched.should == @expected_for_types
   end
   
@@ -463,8 +740,8 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribu
 end
 
 describe Aquarium::Aspects::Pointcut, " (join points specified)" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
     @anClassWithPublicInstanceMethod = ClassWithPublicInstanceMethod.new
     @expected_matched = [@pub_jp, @pro_jp, @pri_jp, @cpub_jp, @cpri_jp,
         Aquarium::Aspects::JoinPoint.new(:object => @anClassWithPublicInstanceMethod, :method => :public_instance_test_method)]
@@ -506,25 +783,25 @@ describe Aquarium::Aspects::Pointcut, " (methods that end in non-alphanumeric ch
 
   {'?' => :huh?, '!' => :yes!, '=' => :x=}.each do |char, method|
     it "should match instance methods for types when searching for names that end with a '#{char}' character." do
-      pc = Aquarium::Aspects::Pointcut.new :types => ClassWithFunkyMethodNames, :method => method, :method_options => [:suppress_ancestor_methods]
+      pc = Aquarium::Aspects::Pointcut.new :types => ClassWithFunkyMethodNames, :method => method, :method_options => [:exclude_ancestor_methods]
       expected_jp = Aquarium::Aspects::JoinPoint.new :type => ClassWithFunkyMethodNames, :method_name => method
       pc.join_points_matched.should == Set.new([expected_jp])
     end
 
     it "should match instance methods for objects when searching for names that end with a '#{char}' character." do
-      pc = Aquarium::Aspects::Pointcut.new :object => @funky, :method => method, :method_options => [:suppress_ancestor_methods]
+      pc = Aquarium::Aspects::Pointcut.new :object => @funky, :method => method, :method_options => [:exclude_ancestor_methods]
       expected_jp = Aquarium::Aspects::JoinPoint.new :object => @funky, :method_name => method
       pc.join_points_matched.should == Set.new([expected_jp])
     end
 
     it "should match instance methods for types when searching for names that end with a '#{char}' character, using a regular expressions." do
-      pc = Aquarium::Aspects::Pointcut.new :types => ClassWithFunkyMethodNames, :methods => /#{Regexp.escape(char)}$/, :method_options => [:suppress_ancestor_methods]
+      pc = Aquarium::Aspects::Pointcut.new :types => ClassWithFunkyMethodNames, :methods => /#{Regexp.escape(char)}$/, :method_options => [:exclude_ancestor_methods]
       expected_jp = Aquarium::Aspects::JoinPoint.new :type => ClassWithFunkyMethodNames, :method_name => method
       pc.join_points_matched.should == Set.new([expected_jp])
     end
 
     it "should match instance methods for object when searching for names that end with a '#{char}' character, using a regular expressions." do
-      pc = Aquarium::Aspects::Pointcut.new :object => @funky, :methods => /#{Regexp.escape(char)}$/, :method_options => [:suppress_ancestor_methods]
+      pc = Aquarium::Aspects::Pointcut.new :object => @funky, :methods => /#{Regexp.escape(char)}$/, :method_options => [:exclude_ancestor_methods]
       expected_jp = Aquarium::Aspects::JoinPoint.new :object => @funky, :method_name => method
       pc.join_points_matched.should == Set.new([expected_jp])
     end
@@ -568,7 +845,7 @@ end
 
 describe "Aquarium::Aspects::Pointcut" do
   
-  setup do
+  before(:each) do
     class Empty; end
 
     @objectWithSingletonMethod = Empty.new
@@ -593,7 +870,7 @@ describe "Aquarium::Aspects::Pointcut" do
   end    
   
   it "should find type-level singleton methods for types when :singleton is specified." do
-    pc = Aquarium::Aspects::Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :suppress_ancestor_methods]
+    pc = Aquarium::Aspects::Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :exclude_ancestor_methods]
     pc.join_points_matched.should == Set.new([Aquarium::Aspects::JoinPoint.new(:type => NotQuiteEmpty, :method_name => :a_class_singleton_method)])
     pc.join_points_not_matched.should == Set.new([Aquarium::Aspects::JoinPoint.new(:type => Empty, :method_name => :all)])
   end
@@ -610,15 +887,15 @@ end
 describe Aquarium::Aspects::Pointcut, "#eql?" do  
   it "should return true for the same Aquarium::Aspects::Pointcut object." do
     pc = Aquarium::Aspects::Pointcut.new  :types => /Class.*Method/, :methods => /_test_method$/
-    pc.should eql(pc)
+    pc.should be_eql(pc)
     pc1 = Aquarium::Aspects::Pointcut.new  :object => ClassWithPublicClassMethod.new, :methods => /_test_method$/
-    pc1.should eql(pc1)
+    pc1.should be_eql(pc1)
   end
   
   it "should return true for Aquarium::Aspects::Pointcuts that specify the same types and methods." do
     pc1 = Aquarium::Aspects::Pointcut.new  :types => /Class.*Method/, :methods => /_test_method$/
     pc2 = Aquarium::Aspects::Pointcut.new  :types => /Class.*Method/, :methods => /_test_method$/
-    pc1.should eql(pc2)
+    pc1.should be_eql(pc2)
   end
   
   it "should return false for Aquarium::Aspects::Pointcuts that specify different types." do
@@ -731,16 +1008,16 @@ describe "Aquarium::Aspects::Pointcut#eql?" do
     pc1 = Aquarium::Aspects::Pointcut.new  :types => /Class.*Method/, :methods => /_test_method$/
     pc2 = Aquarium::Aspects::Pointcut.new  :types => /Class.*Method/, :methods => /_test_method$/
     pc3 = Aquarium::Aspects::Pointcut.new  :objects => [ClassWithPublicInstanceMethod.new, ClassWithPublicInstanceMethod.new]
-    pc1.should eql(pc1)
-    pc1.should eql(pc2)
+    pc1.should be_eql(pc1)
+    pc1.should be_eql(pc2)
     pc1.should_not eql(pc3)
     pc2.should_not eql(pc3)
   end
 end
 
 describe Aquarium::Aspects::Pointcut, "#candidate_types" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
   
   it "should return only candidate matching types when the input types exist." do
@@ -769,8 +1046,8 @@ describe Aquarium::Aspects::Pointcut, "#candidate_types" do
 end
 
 describe Aquarium::Aspects::Pointcut, "#candidate_objects" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
   
   it "should return only candidate matching objects when the input are objects." do
@@ -784,8 +1061,8 @@ describe Aquarium::Aspects::Pointcut, "#candidate_objects" do
 end
 
 describe Aquarium::Aspects::Pointcut, "#candidate_join_points" do
-  setup do
-    common_setup
+  before(:each) do
+    before_pointcut_spec
   end
   
   it "should return only candidate non-matching join points for the input join points that do not exist." do
@@ -813,63 +1090,60 @@ describe Aquarium::Aspects::Pointcut, "#candidate_join_points" do
 end
 
 describe Aquarium::Aspects::Pointcut, "#specification" do
-  setup do
-    common_setup
-    @expected_specification_subset = {
-      :methods => [:all], :method_options => [:suppress_ancestor_methods], 
-      :attributes => [], :attribute_options => []} 
+  before(:each) do
+    before_pointcut_spec
     @empty_set = Set.new
+    @default_specification = {
+      :types => @empty_set, :objects => @empty_set, :join_points => @empty_set,
+      :methods => @empty_set, :method_options => @empty_set,
+      :attributes => @empty_set, :attribute_options => @empty_set, 
+      :exclude_types => @empty_set,
+      :exclude_objects => @empty_set,
+      :exclude_join_points => @empty_set,
+      :exclude_methods => @empty_set,
+      :default_object => @empty_set} 
+    @default_specification_all_methods = { :methods => Set.new([:all]) } | @default_specification
   end
 
   it "should return ':attribute_options => []', by default, if no arguments are given." do
     pc = Aquarium::Aspects::Pointcut.new
-    pc.specification.should == { :types => @empty_set, :objects => @empty_set, :join_points => @empty_set,
-      :methods => Set.new([:all]), :method_options => Set.new([]), :default_object => @empty_set,
-      :attributes => @empty_set, :attribute_options => @empty_set }
+    pc.specification.should == @default_specification_all_methods
   end
 
   it "should return the input :types and :type arguments combined into an array keyed by :types." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :type => String
-    pc.specification.should == { :types => Set.new(@example_types + [String]), :objects => @empty_set, :join_points => @empty_set,
-      :methods => Set.new([:all]), :method_options => Set.new([]), :default_object => @empty_set,
-      :attributes => @empty_set, :attribute_options => @empty_set } 
+    pc.specification.should == { :types => Set.new(@example_types + [String]) } | @default_specification_all_methods
   end
   
   it "should return the input :objects and :object arguments combined into an array keyed by :objects." do
     example_objs = @example_types.map {|t| t.new}
     s1234 = "1234"
     pc = Aquarium::Aspects::Pointcut.new :objects => example_objs, :object => s1234
-    pc.specification.should == { :types => @empty_set, :objects => Set.new(example_objs + [s1234]), :join_points => @empty_set,
-      :methods => Set.new([:all]), :method_options => Set.new([]), :default_object => @empty_set,
-      :attributes => @empty_set, :attribute_options => @empty_set } 
+    pc.specification.should == { :objects => Set.new(example_objs + [s1234]) } | @default_specification_all_methods
   end
 
   it "should return the input :methods and :method arguments combined into an array keyed by :methods." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :methods => /^get/, :method => "dup"
-    pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :join_points => @empty_set,
-      :methods => Set.new([/^get/, "dup"]), :method_options => Set.new([]), :default_object => @empty_set,
-      :attributes => @empty_set, :attribute_options => @empty_set } 
+    pc.specification.should == { :types => Set.new(@example_types), :methods => Set.new([/^get/, "dup"]) } | @default_specification
   end
   
   it "should return the input :method_options verbatim." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :methods => /^get/, :method => "dup", :method_options => [:instance, :public]
-    pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :join_points => @empty_set,
-      :methods => Set.new([/^get/, "dup"]), :method_options => Set.new([:instance, :public]), :default_object => @empty_set,
-      :attributes => @empty_set, :attribute_options => @empty_set } 
+    pc.specification.should == { :types => Set.new(@example_types), :methods => Set.new([/^get/, "dup"]), 
+        :method_options => Set.new([:instance, :public]), :default_object => @empty_set } | @default_specification
   end
   
   it "should return the input :methods and :method arguments combined into an array keyed by :methods." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :attributes => /^state/, :attribute => "name"
     pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :join_points => @empty_set,
       :methods => @empty_set, :method_options => Set.new([]), :default_object => @empty_set,
-      :attributes => Set.new([/^state/, "name"]), :attribute_options => @empty_set } 
+      :attributes => Set.new([/^state/, "name"]), :attribute_options => @empty_set } | @default_specification
   end
   
   it "should return the input :attributes, :attribute and :attribute_options arguments, verbatim." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :attributes => /^state/, :attribute => "name", :attribute_options => :reader
-    pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :join_points => @empty_set,
-      :methods => @empty_set, :method_options => Set.new([]), :default_object => @empty_set,
-      :attributes => Set.new([/^state/, "name"]), :attribute_options => Set.new([:reader]) } 
+    pc.specification.should == { :types => Set.new(@example_types), :attributes => Set.new([/^state/, "name"]), 
+      :attribute_options => Set.new([:reader]) } | @default_specification
   end
 end