aquarium 0.1.8 → 0.2.0

data/spec/aquarium/aspects/dsl/aspect_dsl_spec.rb

@@ -8,7 +8,7 @@ end
 
 describe "DSL method #before" do  
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -24,7 +24,7 @@ end
 
 describe "DSL method #after" do    
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -41,7 +41,7 @@ end
 describe "DSL method #after_raising_within_or_returning_from" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -58,7 +58,7 @@ end
 describe "DSL method #after_returning" do      
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -75,7 +75,7 @@ end
 describe "DSL method #after_returning_from" do      
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -92,7 +92,7 @@ end
 describe "DSL method #after_raising" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -112,7 +112,7 @@ end
 describe "DSL method #after_raising_within" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -132,7 +132,7 @@ end
 describe "DSL method #before_and_after" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -149,7 +149,7 @@ end
 describe "DSL method #before_and_after_raising_within_or_returning_from" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -166,7 +166,7 @@ end
 describe "DSL method #before_and_after_returning" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -183,7 +183,7 @@ end
 describe "DSL method #before_and_after_returning_from" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -200,7 +200,7 @@ end
 describe "DSL method #before_and_after_raising" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -217,7 +217,7 @@ end
 describe "DSL method #around" do    
   before :each do
     @dsl = DSLClass.new
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -243,11 +243,11 @@ describe "DSL method #advise, when determining the \"self\" to advise," do
     class Watchful1
       include Aquarium::Aspects::DSL::AspectDSL
       @@watchful = Watchful1.new
-      @@aspect = after(:object => @@watchful, :method => :public_watchful_method) {|jp,*args|}
+      @@aspect = after(:object => @@watchful, :method => :public_watchful_method) {|jp, obj, *args|}
       def self.watchful; @@watchful; end
       def self.aspect; @@aspect; end
     end
-    @aspects << DSLClass.after(:object => Watchful1.watchful, :method => :public_watchful_method) {|jp,*args|}
+    @aspects << DSLClass.after(:object => Watchful1.watchful, :method => :public_watchful_method) {|jp, obj, *args|}
     @aspects << Watchful1.aspect
     @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
     @aspects[1].pointcuts.should == @aspects[0].pointcuts
@@ -256,10 +256,10 @@ describe "DSL method #advise, when determining the \"self\" to advise," do
   it "should ignore the default object \"self\" when a :type is specified." do
     class Watchful2
       include Aquarium::Aspects::DSL::AspectDSL
-      @@aspect = after(:type => Watchful2, :method => :public_watchful_method) {|jp,*args|}
+      @@aspect = after(:type => Watchful2, :method => :public_watchful_method) {|jp, obj, *args|}
       def self.aspect; @@aspect; end
     end
-    @aspects << DSLClass.after(:type => Watchful2, :method => :public_watchful_method) {|jp,*args|}
+    @aspects << DSLClass.after(:type => Watchful2, :method => :public_watchful_method) {|jp, obj, *args|}
     @aspects << Watchful2.aspect
     @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
     @aspects[1].pointcuts.should == @aspects[0].pointcuts
@@ -282,9 +282,9 @@ describe "DSL method #advise, when determining the type or object to advise," do
   end
 
   it "should infer the type as \"self\" when no :object, :type, or :pointcut is specified." do
-    @aspects << DSLClass.after(:type => WatchfulSelf, :method => :public_watchful_method) {|jp,*args|}
+    @aspects << DSLClass.after(:type => WatchfulSelf, :method => :public_watchful_method) {|jp, obj, *args|}
     class WatchfulSelf
-      @@aspect = after(:method => :public_watchful_method) {|jp,*args|}
+      @@aspect = after(:method => :public_watchful_method) {|jp, obj, *args|}
     end
     @aspects << WatchfulSelf.aspect
     @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
@@ -294,14 +294,14 @@ describe "DSL method #advise, when determining the type or object to advise," do
   it "should infer the object as \"self\" when no :object, :type, or :pointcut is specified." do
     watchful_self = WatchfulSelf.new
     watchful_self.extend Aquarium::Aspects::DSL::AspectDSL
-    @aspects << watchful_self.after(:method => :public_watchful_method)  {|jp,*args|}
-    @aspects << DSLClass.advise(         :after, :pointcut => {:object => watchful_self, :method => :public_watchful_method}) {|jp,*args|}
+    @aspects << DSLClass.advise(:after, :pointcut => {:object => watchful_self, :method => :public_watchful_method}) {|jp, obj, *args|}
+    @aspects << watchful_self.after(:method => :public_watchful_method)  {|jp, obj, *args|}
     @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
     @aspects[1].pointcuts.should == @aspects[0].pointcuts
   end
 
   it "should infer no types or objects if a :pointcut => {...} parameter is used and it does not specify a type or object." do
-    @aspects << DSLClass.after(:pointcut => {:method => /method/}) {|jp,*args|}
+    @aspects << DSLClass.after(:pointcut => {:method => /method/}) {|jp, obj, *args|}
     @aspects[0].join_points_matched.size.should == 0 
   end
 end
@@ -320,7 +320,7 @@ describe "DSL method #advise, when parsing the parameter list," do
   end
 
   it "should infer the first symbol parameter after the advice kind parameter to be the method name to advise if no other :method => ... parameter is used." do
-    @aspects << Watchful3.after(:public_watchful_method) {|jp,*args|}
+    @aspects << Watchful3.after(:public_watchful_method) {|jp, obj, *args|}
     @aspects.each do |aspect|
       aspect.join_points_matched.size.should == 1 
       aspect.specification[:methods].should == Set.new([:public_watchful_method])
@@ -342,7 +342,7 @@ describe "DSL method #advise, when determining instance or class methods to advi
       def public_watchful_method *args; end
     end
     advice_called = 0
-    WatchfulExampleWithSeparateAdviseCall.advise :before, :public_watchful_method do |jp, *args|
+    WatchfulExampleWithSeparateAdviseCall.advise :before, :public_watchful_method do |jp, obj, *args|
       advice_called += 1
     end
     WatchfulExampleWithSeparateAdviseCall.new.public_watchful_method :a1, :a2
@@ -357,7 +357,7 @@ describe "DSL method #advise, when determining instance or class methods to advi
       def public_watchful_method *args; end
     end
     advice_called = 0
-    WatchfulExampleWithSeparateAdviseCall2.advise :before, :type => WatchfulExampleWithSeparateAdviseCall2, :methods => /public_watchful_method/, :method_options =>[:instance] do |jp, *args|
+    WatchfulExampleWithSeparateAdviseCall2.advise :before, :type => WatchfulExampleWithSeparateAdviseCall2, :methods => /public_watchful_method/, :method_options =>[:instance] do |jp, obj, *args|
       advice_called += 1
     end
     WatchfulExampleWithSeparateAdviseCall2.class_public_watchful_method :a1, :a2
@@ -375,7 +375,7 @@ describe "DSL method #advise, when determining instance or class methods to advi
       def public_watchful_method *args; end
     end
     advice_called = 0
-    WatchfulExampleWithSeparateAdviseCall3.advise :before, :methods => /public_watchful_method/, :method_options =>[:class] do |jp, *args|
+    WatchfulExampleWithSeparateAdviseCall3.advise :before, :methods => /public_watchful_method/, :method_options =>[:class] do |jp, obj, *args|
       advice_called += 1
     end
     WatchfulExampleWithSeparateAdviseCall3.class_public_watchful_method :a1, :a2
@@ -391,7 +391,7 @@ describe "DSL method #advise, when determining instance or class methods to advi
       include Aquarium::Aspects::DSL::AspectDSL
       @@advice_called = 0
       def public_watchful_method *args; end
-      before :public_watchful_method do |jp, *args|
+      before :public_watchful_method do |jp, obj, *args|
         @@advice_called += 1
       end
       def self.advice_called; @@advice_called; end
@@ -409,7 +409,7 @@ describe "DSL methods for the advice kind, when determining instance or class me
   end
 
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = []
   end
   after :each do
@@ -429,7 +429,7 @@ end
 
 describe "Synonyms for :types" do
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = [DSLClass.after(:noop, :types => Watchful, :methods => :public_watchful_method, &@advice)]
   end
   after :each do
@@ -454,7 +454,7 @@ end
 
 describe "Synonyms for :objects" do
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = [DSLClass.after(:noop, :objects => @watchful, :methods => :public_watchful_method, &@advice)]
   end
   after :each do
@@ -479,7 +479,7 @@ end
 
 describe "Synonyms for :methods" do
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = [DSLClass.after(:noop, :objects => @watchful, :methods => :public_watchful_method, &@advice)]
   end
   after :each do
@@ -504,7 +504,7 @@ end
 
 describe "Synonyms for :pointcut" do
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @aspects = [DSLClass.after(:noop, :pointcut => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)]
   end
   after :each do
@@ -533,7 +533,7 @@ describe "DSL method #advise (or synonyms) called within a type body" do
       include Aquarium::Aspects::DSL::AspectDSL
       @@advice_called = 0
       def public_watchful_method *args; end
-      before :public_watchful_method do |jp, *args|
+      before :public_watchful_method do |jp, obj, *args|
         @@advice_called += 1
       end
       def self.advice_called; @@advice_called; end
@@ -544,7 +544,7 @@ describe "DSL method #advise (or synonyms) called within a type body" do
     class WatchfulWithMethodNotYetDefined
       include Aquarium::Aspects::DSL::AspectDSL
       @@advice_called = 0
-      before(:public_watchful_method) {|jp, *args| @@advice_called += 1}
+      before(:public_watchful_method) {|jp, obj, *args| @@advice_called += 1}
       def public_watchful_method *args; end
       def self.advice_called; @@advice_called; end
     end

data/spec/aquarium/aspects/join_point_spec.rb

@@ -181,6 +181,85 @@ describe Aquarium::Aspects::JoinPoint, "#target_object" do
     jp.target_object.should be_eql(example)
   end
 end
+
+class InvokeOriginalClass
+  def invoke; @called = true; end
+  def called; @called; end
+end
+
+describe Aquarium::Aspects::JoinPoint, "#proceed" do
+  it "should raise when the join point doesn't have a context" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => InvokeOriginalClass, :method => :invoke
+    lambda { jp.proceed }.should raise_error(Aquarium::Aspects::JoinPoint::ContextNotDefined)
+  end
+  
+  it "should raise when the the context object doesn't have a 'proceed proc'" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => InvokeOriginalClass, :method => :invoke
+    ioc = InvokeOriginalClass.new
+    context_opts = {
+      :advice_kind => :around, 
+      :advised_object => ioc, 
+      :parameters => [],
+      :proceed_proc => nil
+    }
+    jp2 = jp.make_current_context_join_point context_opts
+    lambda { jp2.proceed }.should raise_error(Aquarium::Aspects::JoinPoint::ProceedMethodNotAvailable)
+  end
+
+  it "should not raise when the advice is :around advice" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => InvokeOriginalClass, :method => :invoke
+    ioc = InvokeOriginalClass.new
+    context_opts = {
+      :advice_kind => :around, 
+      :advised_object => ioc, 
+      :parameters => [],
+      :proceed_proc => Aquarium::Aspects::NoAdviceChainNode.new({:alias_method_name => :invoke})
+    }
+    jp2 = jp.make_current_context_join_point context_opts
+    lambda { jp2.proceed }.should_not raise_error(Aquarium::Aspects::JoinPoint::ProceedMethodNotAvailable)
+  end
+  
+  it "should invoke the actual join point" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => InvokeOriginalClass, :method => :invoke
+    ioc = InvokeOriginalClass.new
+    context_opts = {
+      :advice_kind => :around, 
+      :advised_object => ioc, 
+      :parameters => [],
+      :proceed_proc => Aquarium::Aspects::NoAdviceChainNode.new({:alias_method_name => :invoke})
+    }
+    jp2 = jp.make_current_context_join_point context_opts
+    jp2.proceed
+    ioc.called.should be_true
+  end
+end
+
+class InvokeOriginalClass
+  def invoke; @called = true; end
+  def called; @called; end
+end
+
+describe Aquarium::Aspects::JoinPoint, "#invoke_original_join_point" do
+  it "should raise when the join point doesn't have a context" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => InvokeOriginalClass, :method => :invoke
+    lambda { jp.invoke_original_join_point }.should raise_error(Aquarium::Aspects::JoinPoint::ContextNotDefined)
+  end
+
+  it "should invoke the original join point" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => InvokeOriginalClass, :method => :invoke
+    ioc = InvokeOriginalClass.new
+    context_opts = {
+      :advice_kind => :around, 
+      :advised_object => ioc, 
+      :parameters => [],
+      :proceed_proc => Aquarium::Aspects::NoAdviceChainNode.new({:alias_method_name => :invoke})
+    }
+    jp2 = jp.make_current_context_join_point context_opts
+    jp2.invoke_original_join_point
+    ioc.called.should be_true
+  end
+end
+
   
 describe Aquarium::Aspects::JoinPoint, "#dup" do
   it "should duplicate the fields in the join point." do

data/spec/aquarium/aspects/pointcut_or_composition_spec.rb

@@ -9,7 +9,15 @@ describe "Union of Pointcuts", :shared => true do
   include Aquarium::Utils::HashUtils
   
   before(:each) do
-    classes = [ClassWithProtectedInstanceMethod, ClassWithPrivateInstanceMethod, ClassWithPublicClassMethod, ClassWithPrivateClassMethod]
+    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)
   end
@@ -32,14 +40,16 @@ describe "Union of Pointcuts", :shared => true 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 type-based Aquarium::Aspects::Pointcuts." do
     pc1 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers, :exclude_ancestor_methods]
-    # "[^F]" excludes the ClassWithFunkyMethodNames...
+    # "[^F]" excludes the ClassWithFunkyMethodNames ...
     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=
     jp3 = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod,  :method => :public_instance_test_method
     jp4 = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod2, :method => :public_instance_test_method2
-    pc.join_points_matched.should == Set.new([jp1, jp2, jp3, jp4])
+    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
   end
    

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -33,10 +33,10 @@ def before_exclude_spec
   @all_jps = @all_type_jps + @all_object_jps
 end
 
-def before_pointcut_spec
-  @example_types_without_public_instance_method = 
+def before_pointcut_class_spec
+  @example_classes_without_public_instance_method = 
   [ClassWithProtectedInstanceMethod, ClassWithPrivateInstanceMethod, ClassWithPublicClassMethod, ClassWithPrivateClassMethod]
-  @example_types = ([ClassWithPublicInstanceMethod] + @example_types_without_public_instance_method)
+  @example_classes = ([ClassWithPublicInstanceMethod] + @example_classes_without_public_instance_method)
   @pub_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod,    :method_name => :public_instance_test_method
   @pro_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassWithProtectedInstanceMethod, :method_name => :protected_instance_test_method
   @pri_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassWithPrivateInstanceMethod,   :method_name => :private_instance_test_method
@@ -46,17 +46,64 @@ def before_pointcut_spec
   @apri_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassWithPrivateInstanceMethod,   :method_name => :all
   @acpub_jp = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicClassMethod,       :method_name => :all
   @acpri_jp = Aquarium::Aspects::JoinPoint.new :type => ClassWithPrivateClassMethod,      :method_name => :all
-  @expected_matched_jps = Set.new [@pub_jp]
-  @expected_not_matched_jps = Set.new [@apro_jp, @apri_jp, @acpub_jp, @acpri_jp]
+  @cdcimpub_jp = Aquarium::Aspects::JoinPoint.new :type => ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod, :method_name => :public_instance_class_derived_from_class_including_module_test_method
+  @expected_classes_matched_jps = Set.new [@pub_jp]
+  @expected_classes_not_matched_jps = Set.new [@apro_jp, @apri_jp, @acpub_jp, @acpri_jp]
 end
 
-describe Aquarium::Aspects::Pointcut, "#new (invalid arguments)" do
+def before_pointcut_module_spec
+  @example_modules_with_public_instance_method = [
+    ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod,
+    ClassIncludingModuleWithPublicInstanceMethod,
+    ModuleIncludingModuleWithPublicInstanceMethod, 
+    ModuleWithPublicInstanceMethod]    
+  @example_modules_without_public_instance_method = [
+    ClassIncludingModuleWithProtectedInstanceMethod, 
+    ClassIncludingModuleWithPrivateInstanceMethod, 
+    ClassIncludingModuleWithPublicClassMethod, 
+    ClassIncludingModuleWithPrivateClassMethod,
+    ModuleWithProtectedInstanceMethod, 
+    ModuleWithPrivateInstanceMethod, 
+    ModuleWithPublicClassMethod, 
+    ModuleWithPrivateClassMethod]
+  @example_modules = (@example_modules_with_public_instance_method + @example_modules_without_public_instance_method)
+  @mimpub_jp = Aquarium::Aspects::JoinPoint.new :type => ModuleIncludingModuleWithPublicInstanceMethod, :method_name => :public_instance_module_including_module_test_method
+  @mpub_jp   = Aquarium::Aspects::JoinPoint.new :type => ModuleWithPublicInstanceMethod,    :method_name => :public_instance_module_test_method
+  @mpro_jp   = Aquarium::Aspects::JoinPoint.new :type => ModuleWithProtectedInstanceMethod, :method_name => :protected_instance_module_test_method
+  @mpri_jp   = Aquarium::Aspects::JoinPoint.new :type => ModuleWithPrivateInstanceMethod,   :method_name => :private_instance_module_test_method
+  @cmpub_jp  = Aquarium::Aspects::JoinPoint.new :type => ModuleWithPublicClassMethod,       :method_name => :public_class_module_test_method, :class_method => true
+  @cmpri_jp  = Aquarium::Aspects::JoinPoint.new :type => ModuleWithPrivateClassMethod,      :method_name => :private_class_module_test_method, :class_method => true
+  @ampro_jp  = Aquarium::Aspects::JoinPoint.new :type => ModuleWithProtectedInstanceMethod, :method_name => :all
+  @ampri_jp  = Aquarium::Aspects::JoinPoint.new :type => ModuleWithPrivateInstanceMethod,   :method_name => :all
+  @acmpub_jp = Aquarium::Aspects::JoinPoint.new :type => ModuleWithPublicClassMethod,       :method_name => :all
+  @acmpri_jp = Aquarium::Aspects::JoinPoint.new :type => ModuleWithPrivateClassMethod,      :method_name => :all
+  @cdcimpub_jp = Aquarium::Aspects::JoinPoint.new :type => ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod, :method_name => :public_instance_class_derived_from_class_including_module_test_method
+  @cimpub_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithPublicInstanceMethod,    :method_name => :public_instance_class_including_module_test_method
+  @cimpro_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithProtectedInstanceMethod, :method_name => :protected_instance_class_including_module_test_method
+  @cimpri_jp   = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithPrivateInstanceMethod,   :method_name => :private_instance_class_including_module_test_method
+  @ccimpub_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithPublicClassMethod,       :method_name => :public_class_class_including_module_test_method, :class_method => true
+  @ccimpri_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithPrivateClassMethod,      :method_name => :private_class_class_including_module_test_method, :class_method => true
+  @acimpro_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithProtectedInstanceMethod, :method_name => :all
+  @acimpri_jp  = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithPrivateInstanceMethod,   :method_name => :all
+  @accimpub_jp = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithPublicClassMethod,       :method_name => :all
+  @accimpri_jp = Aquarium::Aspects::JoinPoint.new :type => ClassIncludingModuleWithPrivateClassMethod,      :method_name => :all
+  @expected_modules_matched_jps = Set.new [@mimpub_jp, @mpub_jp, @cdcimpub_jp, @cimpub_jp]
+  @expected_modules_not_matched_jps = Set.new [@ampro_jp, @ampri_jp, @acmpub_jp, @acmpri_jp, @acimpro_jp, @acimpri_jp, @accimpub_jp, @accimpri_jp]
+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 jp.target_type.name =~ /^Aquarium::(Aspects|Extras|Utils)/ or jp.target_type.name =~ /^PP/
+end
+
+
+describe Aquarium::Aspects::Pointcut, ".new (invalid arguments)" do
   it "should raise if an unknown argument is specified" do
     lambda { Aquarium::Aspects::Pointcut.new :foo => :bar }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 end
 
-describe Aquarium::Aspects::Pointcut, "#new (empty)" do
+describe Aquarium::Aspects::Pointcut, ".new (empty)" do
   it "should match no join points by default." do
     pc = Aquarium::Aspects::Pointcut.new
     pc.should be_empty
@@ -121,57 +168,134 @@ describe Aquarium::Aspects::Pointcut, "#empty?" do
   end
 end
 
-describe Aquarium::Aspects::Pointcut, " (types specified using regular expressions)" do
+describe Aquarium::Aspects::Pointcut, " (classes specified using regular expressions)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
 
-  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
+  it "should match multiple classes using regular expressions that cover the full class names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /\AClass(?!IncludingModule).*Method\Z/, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == (@expected_classes_matched_jps + [@cdcimpub_jp])
+    pc.join_points_not_matched.should == @expected_classes_not_matched_jps
   end
 
-  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]
+  it "should match clases using regular expressions that only cover partial class names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /lass(?!IncludingModule).*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
+describe Aquarium::Aspects::Pointcut, " (classes specified using names)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
+  end
+
+  it "should match multiple classes using names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes.map {|t| t.to_s}, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == @expected_classes_matched_jps
+    pc.join_points_not_matched.should == @expected_classes_not_matched_jps
+  end
+  
+  it "should match multiple classes using classes themselves." do
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == @expected_classes_matched_jps
+    pc.join_points_not_matched.should == @expected_classes_not_matched_jps
+  end
+  
+  it "should match :all public instance methods for classes by default." do
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == @expected_classes_matched_jps
+    pc.join_points_not_matched.should == @expected_classes_not_matched_jps
+  end
+
+  it "should support MethodFinder's :exclude_ancestor_methods option when using classes." do
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == @expected_classes_matched_jps
+    pc.join_points_not_matched.should == @expected_classes_not_matched_jps
+  end
+end
+
+describe Aquarium::Aspects::Pointcut, " (modules specified using regular expressions)" do
+  it "should match multiple types using regular expressions that cover the full module names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /\AModule.*Method\Z/, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.size.should == 2
+    pc.join_points_matched.each do |jp| 
+      [ModuleIncludingModuleWithPublicInstanceMethod, ModuleWithPublicInstanceMethod].should include(jp.target_type)
+    end
+    pc.join_points_not_matched.size.should == 4
+    pc.join_points_not_matched.each do |jp|
+      [ModuleWithPrivateInstanceMethod, ModuleWithProtectedInstanceMethod, 
+        ModuleWithPublicClassMethod, ModuleWithPrivateClassMethod].should include(jp.target_type)
+    end
   end
+end
 
-  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
+describe Aquarium::Aspects::Pointcut, " (modules specified using names)" do
+  def do_module type_spec
+    pc = Aquarium::Aspects::Pointcut.new :types => type_spec, :method_options => :exclude_ancestor_methods 
+    pc.join_points_matched.size.should == 1
+    pc.join_points_matched.each do |jp| 
+      jp.target_type.should == ModuleWithPublicInstanceMethod
+      jp.method_name.should == :public_instance_module_test_method
+    end
+    pc.join_points_not_matched.size.should == 1
+    pc.join_points_not_matched.each do |jp| 
+      jp.target_type.should == ModuleWithPublicClassMethod
+      jp.method_name.should == :all
+    end
+  end
+  
+  it "should match multiple types using module names." do
+    do_module ["ModuleWithPublicInstanceMethod", "ModuleWithPublicClassMethod"]
   end
   
-  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
+  it "should match multiple types using module-name regular expressions." do
+    do_module /^ModuleWithPublic.*Method/
   end
   
-  it "should match :all public instance methods for types by default." 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
+  it "should match multiple types using modules themselves." do
+    do_module [ModuleWithPublicInstanceMethod, ModuleWithPublicClassMethod]
+  end
+  
+  it "should match :all public instance methods for modules by default." do
+    do_module [ModuleWithPublicInstanceMethod, ModuleWithPublicClassMethod]
   end
 
-  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
+  it "should support MethodFinder's :exclude_ancestor_methods option when using modules." do
+    do_module [ModuleWithPublicInstanceMethod, ModuleWithPublicClassMethod]
   end
 end
 
+describe Aquarium::Aspects::Pointcut, " (types and their descendents and ancestors)" do
+  before(:each) do
+    before_pointcut_module_spec
+  end
+
+  it "should match classes specified and their ancestor and descendent modules and classes." do
+    pc = Aquarium::Aspects::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]
+    pc.join_points_matched.each do |jp|
+      next if ignored_join_point(jp)
+      expected_types.should include(jp.target_type)
+    end
+    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)
+      not_expected_types.should include(jp.target_type)
+    end
+  end
+
+  it "should match modules specified, their ancestor and descendent modules, and including classes." do
+    pc = Aquarium::Aspects::Pointcut.new :types_and_ancestors => /^Module.*Method/, :types_and_descendents => /^Module.*Method/, :methods => :all, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == (@expected_modules_matched_jps + [@mimpub_jp])
+    pc.join_points_not_matched.should == @expected_modules_not_matched_jps
+  end
+end
+  
 describe Aquarium::Aspects::Pointcut, " (objects specified)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
 
   it "should match :all public instance methods for objects by default." do
@@ -301,6 +425,124 @@ describe Aquarium::Aspects::Pointcut, " (:exclude_types => types specified)" do
   end
 end
 
+describe Aquarium::Aspects::Pointcut, " (exclude types and their descendents and ancestors)" do
+  before(:each) do
+    before_pointcut_module_spec
+  end
+
+  def check_module_ancestors pc
+    expected_types = [
+      ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod, 
+      ClassIncludingModuleWithPublicInstanceMethod,
+      Kernel,
+      Object]
+    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
+    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)
+      not_expected_types.should include(jp.target_type)
+    end
+  end
+  
+  it "should exclude modules specified and their included modules when excluding ancestors." do
+    pc = Aquarium::Aspects::Pointcut.new :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, 
+    :exclude_types_and_ancestors => ModuleIncludingModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
+    check_module_ancestors pc
+  end
+  it "should exclude join_points whose types match an excluded ancestor modules." do
+    pc = Aquarium::Aspects::Pointcut.new :join_point => @mimpub_jp, :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, 
+    :exclude_types_and_ancestors => ModuleIncludingModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
+    check_module_ancestors pc
+  end
+
+  def check_module_descendents pc
+    expected_types = [Kernel, Object]
+    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
+    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)
+      not_expected_types.should include(jp.target_type)
+    end
+  end
+  
+  it "should exclude modules specified and their including modules and classes when excluding descendents." do
+    pc = Aquarium::Aspects::Pointcut.new :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, 
+    :exclude_types_and_descendents => ModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
+    check_module_descendents pc
+  end
+  it "should exclude join_points whose types match an excluded descendent modules." do
+    pc = Aquarium::Aspects::Pointcut.new :join_point => @mpub_jp, :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, 
+    :exclude_types_and_descendents => ModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
+    check_module_descendents pc
+  end
+
+  def check_class_ancestors pc
+    expected_types = [ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod, ModuleIncludingModuleWithPublicInstanceMethod]
+    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
+    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)
+      not_expected_types.should include(jp.target_type)
+    end
+  end
+  
+  it "should exclude classes specified and their included modules and ancestor classes when excluding ancestors." do
+    pc = Aquarium::Aspects::Pointcut.new :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, 
+    :exclude_types_and_ancestors => ClassIncludingModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
+    check_class_ancestors pc
+  end
+  it "should exclude join_points whose types match an excluded ancestor classes." do
+    pc = Aquarium::Aspects::Pointcut.new :join_point => @cimpub_jp, :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, 
+    :exclude_types_and_ancestors => ClassIncludingModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
+    check_class_ancestors pc
+  end
+  
+  def check_class_descendents pc
+    expected_types = [Kernel, ModuleIncludingModuleWithPublicInstanceMethod, ModuleWithPublicInstanceMethod, Object]
+    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
+    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)
+      not_expected_types.should include(jp.target_type)
+    end
+  end
+  
+  it "should exclude classes specified and their including modules and descendent classes when excluding descendents." do
+    pc = Aquarium::Aspects::Pointcut.new :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, 
+    :exclude_types_and_descendents => ClassIncludingModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
+    check_class_descendents pc
+  end
+  it "should exclude join_points whose types match an excluded descendent types." do
+    pc = Aquarium::Aspects::Pointcut.new :join_point => @cimpub_jp, :types_and_ancestors => /^Class(Including|DerivedFrom).*Method/, 
+    :exclude_types_and_descendents => ClassIncludingModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
+    check_class_descendents pc
+  end
+end
+  
 describe Aquarium::Aspects::Pointcut, " (:exclude_objects => objects specified)" do
   before(:each) do
     @e11 = ExcludeTestOne.new  
@@ -451,7 +693,7 @@ end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with public instance methods)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
 
   it "should support MethodFinder's :public and :instance options for the specified types." do
@@ -470,7 +712,7 @@ end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with protected instance methods)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
   
   it "should support MethodFinder's :protected and :instance options for the specified types." do
@@ -489,7 +731,7 @@ end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with private instance methods)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
   
   it "should support MethodFinder's :private and :instance options for the specified types." do
@@ -508,7 +750,7 @@ end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with public class methods)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
   
   it "should support MethodFinder's :public and :class options for the specified types." do
@@ -528,7 +770,7 @@ end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with private class methods)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
   
   it "should support MethodFinder's :private and :class options for the specified types." do
@@ -547,7 +789,7 @@ end
 
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with method regular expressions)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_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=
@@ -627,7 +869,7 @@ end
   
 describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribute regular expressions)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_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=
@@ -780,7 +1022,7 @@ end
 
 describe Aquarium::Aspects::Pointcut, " (join points specified)" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_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)]
@@ -1057,18 +1299,18 @@ end
 
 describe Aquarium::Aspects::Pointcut, "#candidate_types" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
   
   it "should return only candidate matching types when the input types exist." do
-    pc = Aquarium::Aspects::Pointcut.new :types => @example_types 
-    pc.candidate_types.matched_keys.sort {|x,y| x.to_s <=> y.to_s}.should == @example_types.sort {|x,y| x.to_s <=> y.to_s}
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes 
+    pc.candidate_types.matched_keys.sort {|x,y| x.to_s <=> y.to_s}.should == @example_classes.sort {|x,y| x.to_s <=> y.to_s}
     pc.candidate_types.not_matched_keys.should == []
   end
 
   it "should return only candidate matching types when the input type names correspond to existing types." do
-    pc = Aquarium::Aspects::Pointcut.new :types => @example_types.map {|t| t.to_s}
-    pc.candidate_types.matched_keys.sort {|x,y| x.to_s <=> y.to_s}.should == @example_types.sort {|x,y| x.to_s <=> y.to_s}
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes.map {|t| t.to_s}
+    pc.candidate_types.matched_keys.sort {|x,y| x.to_s <=> y.to_s}.should == @example_classes.sort {|x,y| x.to_s <=> y.to_s}
     pc.candidate_types.not_matched_keys.should == []
   end
 
@@ -1079,7 +1321,7 @@ describe Aquarium::Aspects::Pointcut, "#candidate_types" do
   end
 
   it "should return no candidate matching or non-matching types when only objects are input." do
-    pc = Aquarium::Aspects::Pointcut.new :objects => @example_types.map {|t| t.new}
+    pc = Aquarium::Aspects::Pointcut.new :objects => @example_classes.map {|t| t.new}
     pc.candidate_types.matched_keys.should == []
     pc.candidate_types.not_matched_keys.should == []
   end
@@ -1087,11 +1329,11 @@ end
 
 describe Aquarium::Aspects::Pointcut, "#candidate_objects" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
   
   it "should return only candidate matching objects when the input are objects." do
-    example_objs = @example_types.map {|t| t.new}
+    example_objs = @example_classes.map {|t| t.new}
     pc = Aquarium::Aspects::Pointcut.new :objects => example_objs
     example_objs.each do |obj|
       pc.candidate_objects.matched[obj].should_not be(nil?)
@@ -1102,7 +1344,7 @@ end
 
 describe Aquarium::Aspects::Pointcut, "#candidate_join_points" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
   end
   
   it "should return only candidate non-matching join points for the input join points that do not exist." do
@@ -1131,13 +1373,18 @@ end
 
 describe Aquarium::Aspects::Pointcut, "#specification" do
   before(:each) do
-    before_pointcut_spec
+    before_pointcut_class_spec
     @empty_set = Set.new
     @default_specification = {
       :types => @empty_set, :objects => @empty_set, :join_points => @empty_set,
+      :types_and_ancestors => @empty_set,
+      :types_and_descendents => @empty_set,
       :methods => @empty_set, :method_options => @empty_set,
       :attributes => @empty_set, :attribute_options => @empty_set, 
       :exclude_types => @empty_set,
+      :exclude_types_calculated => @empty_set,
+      :exclude_types_and_ancestors => @empty_set,
+      :exclude_types_and_descendents => @empty_set,
       :exclude_objects => @empty_set,
       :exclude_join_points => @empty_set,
       :exclude_pointcuts => @empty_set,
@@ -1152,38 +1399,38 @@ describe Aquarium::Aspects::Pointcut, "#specification" do
   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]) } | @default_specification_all_methods
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes, :type => String
+    pc.specification.should == { :types => Set.new(@example_classes + [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}
+    example_objs = @example_classes.map {|t| t.new}
     s1234 = "1234"
     pc = Aquarium::Aspects::Pointcut.new :objects => example_objs, :object => s1234
     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), :methods => Set.new([/^get/, "dup"]) } | @default_specification
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes, :methods => /^get/, :method => "dup"
+    pc.specification.should == { :types => Set.new(@example_classes), :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), :methods => Set.new([/^get/, "dup"]), 
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes, :methods => /^get/, :method => "dup", :method_options => [:instance, :public]
+    pc.specification.should == { :types => Set.new(@example_classes), :methods => Set.new([/^get/, "dup"]), 
         :method_options => Set.new([:instance, :public]), :default_objects => @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,
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes, :attributes => /^state/, :attribute => "name"
+    pc.specification.should == { :types => Set.new(@example_classes), :objects => @empty_set, :join_points => @empty_set,
       :methods => @empty_set, :method_options => Set.new([]), :default_objects => @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), :attributes => Set.new([/^state/, "name"]), 
+    pc = Aquarium::Aspects::Pointcut.new :types => @example_classes, :attributes => /^state/, :attribute => "name", :attribute_options => :reader
+    pc.specification.should == { :types => Set.new(@example_classes), :attributes => Set.new([/^state/, "name"]), 
       :attribute_options => Set.new([:reader]) } | @default_specification
   end
 end