aquarium 0.1.8 → 0.2.0

data/lib/aquarium/utils.rb

@@ -7,4 +7,5 @@ require 'aquarium/utils/name_utils'
 
 require 'aquarium/utils/html_escaper'
 require 'aquarium/utils/invalid_options'
+require 'aquarium/utils/logic_error'
 require 'aquarium/utils/nil_object'

data/lib/aquarium/utils/logic_error.rb

@@ -0,0 +1,9 @@
+module Aquarium
+  module Utils
+    class LogicError < Exception 
+      def initialize *args
+        super
+      end
+    end
+  end
+end

data/lib/aquarium/utils/method_utils.rb

@@ -1,4 +1,5 @@
 require 'aquarium/utils/type_utils'
+require 'aquarium/utils/logic_error'
 
 module Aquarium
   module Utils
@@ -18,13 +19,13 @@ module Aquarium
       end
 
       def self.visibility type_or_instance, method_sym, class_or_instance_only = nil, include_ancestors = true
-        find_method(type_or_instance, method_sym, class_or_instance_only, include_ancestors) do |type_or_instance, method_sym, protection| 
+        find_method(type_or_instance, method_sym, class_or_instance_only, include_ancestors) do |t_or_o, msym, protection| 
           return protection
         end
       end
       
       def self.has_method type_or_instance, method_sym, class_or_instance_only = nil, include_ancestors = true
-        found = find_method(type_or_instance, method_sym, class_or_instance_only, include_ancestors) do |type_or_instance, method_sym, protection| 
+        found = find_method(type_or_instance, method_sym, class_or_instance_only, include_ancestors) do |t_or_o, msym, protection| 
           return true
         end 
         found ? true : false   # found could be nil; return false, if so
@@ -69,7 +70,7 @@ module Aquarium
         if candidates.size == 2 and Aquarium::Utils::TypeUtils.is_type?(type_or_instance) == false
           return determine_actual_parent(type_or_instance, candidates)
         end
-        candidates.size == 1 ? candidates.first : raise("Bug: Got multiple types #{candidates.inspect} that implement method #{method_sym}")
+        candidates.size == 1 ? candidates.first : raise(Aquarium::Utils::LogicError.new("Bug: Got multiple types #{candidates.inspect} that implement method #{method_sym}"))
       end
       
       def self.determine_actual_parent object, candidates

data/lib/aquarium/utils/nil_object.rb

@@ -5,6 +5,7 @@
 module Aquarium
   module Utils
     class Aquarium::Utils::NilObject
+            
       def method_missing method_sym, *args
         self
       end

data/lib/aquarium/utils/type_utils.rb

@@ -4,6 +4,25 @@ module Aquarium
       def self.is_type? type_or_object
         type_or_object.kind_of?(Class) or type_or_object.kind_of?(Module)
       end
+
+      def self.descendents clazz
+        do_descendents clazz, Class, ["Class", "Module", "Object", clazz]
+      end
+      
+      protected
+      
+      def self.do_descendents clazz, class_with_consts, visited
+        result = [clazz]
+        visited << class_with_consts.name
+        class_with_consts.constants.each do |const| 
+          next if const == clazz.name or visited.include?(const)
+          clazz2 = class_with_consts.class_eval "#{const}"
+          next unless clazz2.respond_to?(:ancestors)
+          result += [clazz2] if clazz2.ancestors.include? clazz
+          result += do_descendents(clazz, clazz2, visited) unless visited.include?(clazz2.name)
+        end
+        result.flatten.uniq
+      end
     end
   end
 end

data/lib/aquarium/version.rb

@@ -8,8 +8,8 @@ module Aquarium
 
     unless defined? MAJOR
       MAJOR  = 0
-      MINOR  = 1
-      TINY   = 8
+      MINOR  = 2
+      TINY   = 0
       RELEASE_CANDIDATE = nil
       
       # RANDOM_TOKEN: 0.598704893979657

data/spec/aquarium/aspects/advice_chain_node_spec.rb

@@ -9,7 +9,7 @@ include Aquarium::Aspects::Advice
 describe Aquarium::Aspects::AdviceChainNode, "#each" do
   it "should return each node in succession" do
     static_join_point = :static_join_point
-    advice = lambda {|jp, *args| p ":none advice"}
+    advice = lambda {|jp, obj, *args| p ":none advice"}
     options = {
       :advice_kind => :none, 
       :advice => advice,
@@ -18,7 +18,7 @@ describe Aquarium::Aspects::AdviceChainNode, "#each" do
     advice_chain = Aquarium::Aspects::AdviceChainNodeFactory.make_node options
 
     KINDS_IN_PRIORITY_ORDER.each do |advice_kind|
-      advice = lambda {|jp, *args| p "#{advice_kind} advice"}
+      advice = lambda {|jp, obj, *args| p "#{advice_kind} advice"}
       options[:advice_kind] = advice_kind
       options[:advice]      = advice,
       options[:next_node]   = advice_chain

data/spec/aquarium/aspects/advice_spec.rb

@@ -18,9 +18,32 @@ describe Advice, "#sort_by_priority_order" do
   end
 end
 
+describe Advice, "#invoke_original_join_point" do
+  class InvocationCounter
+    def initialize; @counter = 0; end
+    def increment; @counter += 1; end
+    def counter; @counter; end
+  end
+  
+  it "should invoke the original join_point" do
+    aspect1 = Aspect.new :before, :type => InvocationCounter, :method => :increment do |jp, o|
+      jp.invoke_original_join_point
+    end
+    aspect2 = Aspect.new :around, :type => InvocationCounter, :method => :increment do |jp, o|
+      jp.invoke_original_join_point
+      jp.proceed
+    end
+    ic = InvocationCounter.new
+    ic.increment
+    ic.counter == 3
+    aspect1.unadvise
+    aspect2.unadvise
+  end
+end
+
 describe Advice, "that raises an exception" do
   it "should add the kind of advice to the exception message." do
-    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, *args| 
+    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, obj, *args| 
       raise SpecExceptionForTesting.new("advice called with args: #{args.inspect}")
     end
     begin
@@ -32,7 +55,7 @@ describe Advice, "that raises an exception" do
   end
 
   it "should add the \"Class#method\" of the advised object's type and method to the exception message." do
-    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, *args| 
+    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_watchful_method} do |jp, obj, *args| 
       raise "advice called with args: #{args.inspect}"
     end
     begin
@@ -44,7 +67,7 @@ describe Advice, "that raises an exception" do
   end
 
   it "should add the \"Class.method\" of the advised type's class method to the exception message." do
-    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, *args| 
+    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, obj, *args| 
       raise "advice called with args: #{args.inspect}"
     end
     begin
@@ -57,7 +80,7 @@ describe Advice, "that raises an exception" do
 
   it "should rethrow an exception of the same type as the original exception." do
     class MyException < Exception; end
-    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, *args| 
+    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, obj, *args| 
       raise MyException.new("advice called with args: #{args.inspect}")
     end
     lambda { Watchful.public_class_watchful_method :a1, :a2 }.should raise_error(MyException)
@@ -67,7 +90,7 @@ describe Advice, "that raises an exception" do
   it "should rethrow an exception with the same backtrace as the original exception." do
     class MyException < Exception; end
     @backtrace = nil
-    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, *args| 
+    aspect = Aspect.new :before, :pointcut => {:type => Watchful, :methods => :public_class_watchful_method, :method_options => [:class]} do |jp, obj, *args| 
       begin
         exception = MyException.new("advice called with args: #{args.inspect}")
         raise exception

data/spec/aquarium/aspects/aspect_invocation_spec.rb

@@ -29,114 +29,128 @@ def join_points_should_be_equal num_jps, aspect1, aspect2
   aspect1.join_points_not_matched.should eql(aspect2.join_points_not_matched)
 end
 
+module Aquarium
+  class AspectInvocationTestClass
+    include Aquarium::Aspects::DSL::AspectDSL
+    attr_accessor :public_test_method_args
+    def public_test_method *args; @args=args; end
+    protected
+    def protected_test_method *args; @args=args; end
+    private
+    def private_test_method *args; @args=args; end
+    def self.public_class_test_method *args; end
+    def self.private_class_test_method *args; end
+    private_class_method :private_class_test_method
+  end
+end
 
-describe Aspect, "#new parameters that specify the kind of advice" do
+describe Aspect, ".new parameters that specify the kind of advice" do
   it "should require the kind of advice as the first parameter." do
-    lambda { Aspect.new :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :pointcut => {:type => Aquarium::AspectInvocationTestClass} }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should contain no other advice types if :around advice specified." do
-    lambda { Aspect.new :around, :before,          :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { Aspect.new :around, :after,           :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { Aspect.new :around, :after_returning, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { Aspect.new :around, :after_raising,   :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :around, :before,          :pointcut => {:type => Aquarium::AspectInvocationTestClass} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :around, :after,           :pointcut => {:type => Aquarium::AspectInvocationTestClass} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :around, :after_returning, :pointcut => {:type => Aquarium::AspectInvocationTestClass} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :around, :after_raising,   :pointcut => {:type => Aquarium::AspectInvocationTestClass} }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should allow only one of :after, :after_returning, or :after_raising advice to be specified." do
-    lambda { Aspect.new :after, :after_returning, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { Aspect.new :after, :after_raising,   :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { Aspect.new :after_returning, :after_raising, :pointcut => {:type => Watchful} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :after, :after_returning, :pointcut => {:type => Aquarium::AspectInvocationTestClass} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :after, :after_raising,   :pointcut => {:type => Aquarium::AspectInvocationTestClass} }.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :after_returning, :after_raising, :pointcut => {:type => Aquarium::AspectInvocationTestClass} }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should allow :before to be specified with :after." do
-    lambda { Aspect.new :before, :after, :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :before, :after, :pointcut => {:type => Aquarium::AspectInvocationTestClass}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should allow :before to be specified with :after_returning." do
-    lambda { Aspect.new :before, :after_returning, :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :before, :after_returning, :pointcut => {:type => Aquarium::AspectInvocationTestClass}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should allow :before to be specified with :after_raising." do
-    lambda { Aspect.new :before, :after_raising,   :pointcut => {:type => Watchful}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    lambda { Aspect.new :before, :after_raising,   :pointcut => {:type => Aquarium::AspectInvocationTestClass}, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
   end
 end
 
-describe Aspect, "#new parameters that specify join points" do
+describe Aspect, ".new parameters that specify join points" do
   it "should contain at least one of :method(s), :pointcut(s), :type(s), or :object(s)." do
-    lambda {Aspect.new(:after) {|jp, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda {Aspect.new(:after) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should contain at least one of :pointcut(s), :type(s), or :object(s) unless :default_object => object is given." do
-    aspect = Aspect.new(:after, :default_object => Watchful.new, :methods => :public_watchful_method) {|jp, *args| true}
+    aspect = Aspect.new(:after, :default_object => Aquarium::AspectInvocationTestClass.new, :methods => :public_test_method) {|jp, obj, *args| true}
     aspect.unadvise
   end
 
   it "should not contain :pointcut(s) and either :type(s) or :object(s)." do
-    lambda {Aspect.new(:after, :pointcuts => {:type => Watchful, :methods => :public_watchful_method}, :type => Watchful, :methods => :public_watchful_method) {|jp, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda {Aspect.new(:after, :pointcuts => {:type => Watchful, :methods => :public_watchful_method}, :object => Watchful.new, :methods => :public_watchful_method) {|jp, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda {Aspect.new(:after, :pointcuts => {:type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method}, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda {Aspect.new(:after, :pointcuts => {:type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method}, :object => Aquarium::AspectInvocationTestClass.new, :methods => :public_test_method) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should include an advice block or :advice => advice parameter." do
-    lambda {Aspect.new(:after, :type => Watchful, :methods => :public_watchful_method)}.should raise_error(Aquarium::Utils::InvalidOptions)
+    lambda {Aspect.new(:after, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method)}.should raise_error(Aquarium::Utils::InvalidOptions)
   end
 end
 
 
-describe Aspect, "#new :type parameter" do
+describe Aspect, ".new :type parameter" do
   it "should be accepted as a synonym for :types" do
     @advice = Proc.new {}
-    @expected_methods = [:public_watchful_method]
-    aspect1 = Aspect.new :before, :type  => Watchful, :method => @expected_methods, :advice => @advice
-    aspect2 = Aspect.new :before, :types => Watchful, :method => @expected_methods, :advice => @advice
+    @expected_methods = [:public_test_method]
+    aspect1 = Aspect.new :before, :type  => Aquarium::AspectInvocationTestClass, :method => @expected_methods, :advice => @advice
+    aspect2 = Aspect.new :before, :types => Aquarium::AspectInvocationTestClass, :method => @expected_methods, :advice => @advice
     aspects_should_be_equal 1, aspect1, aspect2
     aspect1.unadvise
     aspect2.unadvise
   end
 end
 
-describe Aspect, "#new :pointcut parameter" do
+describe Aspect, ".new :pointcut parameter" do
   it "should be accepted as a synonym for :pointcuts" do
     @advice = Proc.new {}
-    @expected_methods = [:public_watchful_method]
-    aspect1 = Aspect.new :before, :pointcut  => {:type => Watchful, :method => @expected_methods}, :advice => @advice
-    aspect2 = Aspect.new :before, :pointcuts => {:type => Watchful, :method => @expected_methods}, :advice => @advice
+    @expected_methods = [:public_test_method]
+    aspect1 = Aspect.new :before, :pointcut  => {:type => Aquarium::AspectInvocationTestClass, :method => @expected_methods}, :advice => @advice
+    aspect2 = Aspect.new :before, :pointcuts => {:type => Aquarium::AspectInvocationTestClass, :method => @expected_methods}, :advice => @advice
     aspects_should_be_equal 1, aspect1, aspect2
     aspect1.unadvise
     aspect2.unadvise
   end
 end
 
-describe Aspect, "#new :object parameter" do
+describe Aspect, ".new :object parameter" do
   it "should be accepted as a synonym for :objects" do
     @advice = Proc.new {}
-    @expected_methods = [:public_watchful_method]
-    watchful = Watchful.new
-    aspect1 = Aspect.new :before, :object  => watchful, :method => @expected_methods, :advice => @advice
-    aspect2 = Aspect.new :before, :objects => watchful, :method => @expected_methods, :advice => @advice
+    @expected_methods = [:public_test_method]
+    object = Aquarium::AspectInvocationTestClass.new
+    aspect1 = Aspect.new :before, :object  => object, :method => @expected_methods, :advice => @advice
+    aspect2 = Aspect.new :before, :objects => object, :method => @expected_methods, :advice => @advice
     aspects_should_be_equal 1, aspect1, aspect2
     aspect1.unadvise
     aspect2.unadvise
   end
 end
 
-describe Aspect, "#new :method parameter" do
+describe Aspect, ".new :method parameter" do
   it "should be accepted as a synonym for :methods" do
     @advice = Proc.new {}
-    @expected_methods = [:public_watchful_method]
-    aspect1 = Aspect.new :before, :type => Watchful, :method  => @expected_methods, :advice => @advice
-    aspect2 = Aspect.new :before, :type => Watchful, :methods => @expected_methods, :advice => @advice
+    @expected_methods = [:public_test_method]
+    aspect1 = Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :method  => @expected_methods, :advice => @advice
+    aspect2 = Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :methods => @expected_methods, :advice => @advice
     aspects_should_be_equal 1, aspect1, aspect2
     aspect1.unadvise
     aspect2.unadvise
   end
 end
 
-describe Aspect, "#new :attribute parameter" do
+describe Aspect, ".new :attribute parameter" do
   it "should be accepted as a synonym for :attributes" do
     @advice = Proc.new {}
-    @expected_methods = [:public_watchful_method_args, :public_watchful_method_args=]
-    aspect1 = Aspect.new :before, :type => Watchful, :attribute  => @expected_methods, :advice => @advice
-    aspect2 = Aspect.new :before, :type => Watchful, :attributes => @expected_methods, :advice => @advice
+    @expected_methods = [:public_test_method_args, :public_test_method_args=]
+    aspect1 = Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :attribute  => @expected_methods, :advice => @advice
+    aspect2 = Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :attributes => @expected_methods, :advice => @advice
     aspects_should_be_equal 2, aspect1, aspect2
     aspect1.unadvise
     aspect2.unadvise
@@ -144,103 +158,146 @@ describe Aspect, "#new :attribute parameter" do
 end
 
 
-describe Aspect, "#new with a :type(s) parameter and a :method(s) parameter" do  
+describe Aspect, ".new with a :type(s) parameter and a :method(s) parameter" do  
   before :each do
     @protection = 'public'
     @are_class_methods = false
+    @types_option = :types
     @method_options = []
   end
   
   def do_type_spec
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :types => @type_spec, :methods => @method_spec, :method_options => @method_options do |jp, *args|
+    aspect = Aspect.new :before, @types_option => @type_spec, :methods => @method_spec, :method_options => @method_options do |jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
     if @are_class_methods
-      Watchful.method("#{@protection}_class_watchful_method").call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+      Aquarium::AspectInvocationTestClass.method("#{@protection}_class_test_method").call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     else
-      Watchful.new.method("#{@protection}_watchful_method").call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+      Aquarium::AspectInvocationTestClass.new.method("#{@protection}_test_method").call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     end
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should accept :type(s) => [T1, ...], :methods => [m, ...]" do  
-    @type_spec = [Watchful]
-    @method_spec = [:public_watchful_method]
+    @type_spec = [Aquarium::AspectInvocationTestClass]
+    @method_spec = [:public_test_method]
+    do_type_spec
+  end
+
+  it "should accept :type(s)_and_ancestors => [T1, ...], :methods => [m, ...]" do  
+    @types_option = :types_and_ancestors
+    @type_spec = [Aquarium::AspectInvocationTestClass]
+    @method_spec = [:public_test_method]
+    do_type_spec
+  end
+
+  it "should accept :type(s)_and_descendents => [T1, ...], :methods => [m, ...]" do  
+    @types_option = :types_and_descendents
+    @type_spec = [Aquarium::AspectInvocationTestClass]
+    @method_spec = [:public_test_method]
     do_type_spec
   end
 
   it "should accept :type(s) => [T1, ...], :methods => m" do  
-    @type_spec = [Watchful]
-    @method_spec = :public_watchful_method
+    @type_spec = [Aquarium::AspectInvocationTestClass]
+    @method_spec = :public_test_method
     do_type_spec
   end
 
   it "should accept :type(s) => [T1, ...], :methods => /m/" do  
-    @type_spec = [Watchful]
-    @method_spec = /watchful_method/
+    @type_spec = [Aquarium::AspectInvocationTestClass]
+    @method_spec = /test_method/
     do_type_spec
   end
 
   it "should accept :type(s) => T1, :methods => [m, ...]" do  
-    @type_spec = Watchful
-    @method_spec = [:public_watchful_method]
+    @type_spec = Aquarium::AspectInvocationTestClass
+    @method_spec = [:public_test_method]
+    do_type_spec
+  end
+
+  it "should accept :type(s)_and_ancestors => T1, :methods => [m, ...]" do  
+    @types_option = :types_and_ancestors
+    @type_spec = Aquarium::AspectInvocationTestClass
+    @method_spec = [:public_test_method]
+    do_type_spec
+  end
+
+  it "should accept :type(s)_and_descendents => T1, :methods => [m, ...]" do  
+    @types_option = :types_and_descendents
+    @type_spec = Aquarium::AspectInvocationTestClass
+    @method_spec = [:public_test_method]
     do_type_spec
   end
 
   it "should accept :type(s) => T1, :methods => m" do  
-    @type_spec = Watchful
-    @method_spec = :public_watchful_method
+    @type_spec = Aquarium::AspectInvocationTestClass
+    @method_spec = :public_test_method
     do_type_spec
   end
 
   it "should accept :type(s) => T1, :methods => /m/" do  
-    @type_spec = Watchful
-    @method_spec = /watchful_method/
+    @type_spec = Aquarium::AspectInvocationTestClass
+    @method_spec = /test_method/
     do_type_spec
   end
 
   it "should accept :type(s) => /T1/, :methods => [m, ...]" do  
-    @type_spec = /Watchful/
-    @method_spec = [:public_watchful_method]
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @method_spec = [:public_test_method]
+    do_type_spec
+  end
+
+  it "should accept :type(s)_and_ancestors => /T1/, :methods => [m, ...]" do  
+    @types_option = :types_and_ancestors
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @method_spec = [:public_test_method]
+    do_type_spec
+  end
+
+  it "should accept :type(s)_and_descendents => /T1/, :methods => [m, ...]" do  
+    @types_option = :types_and_descendents
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @method_spec = [:public_test_method]
     do_type_spec
   end
 
   it "should accept :type(s) => /T1/, :methods => m" do  
-    @type_spec = /Watchful/
-    @method_spec = :public_watchful_method
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @method_spec = :public_test_method
     do_type_spec
   end
 
   it "should accept :type(s) => /T1/, :methods => /m/" do  
-    @type_spec = /Watchful/
-    @method_spec = /watchful_method/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @method_spec = /test_method/
     do_type_spec
   end
 
   it "should accept :type(s) => ..., :methods => ..., :method_options => [:exclude_ancestor_methods] to exclude methods defined in ancestors" do  
-    @type_spec = /Watchful/
-    @method_spec = /watchful_method/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @method_spec = /test_method/
     @method_options = [:exclude_ancestor_methods]
     do_type_spec
   end
 
   it "should accept :type(s) => ..., :methods => ..., :method_options => [:instance, :public] to match only instance and public (both are the defaults) methods" do  
-    @type_spec = /Watchful/
-    @method_spec = /watchful_method/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @method_spec = /test_method/
     @method_options = [:instance, :public]
     do_type_spec
   end
 
   %w[public protected private].each do |protection|
     it "should accept :type(s) => ..., :methods => ..., :method_options => [#{protection.intern}] to match only instance (default) #{protection} methods" do  
-      @type_spec = /Watchful/
-      @method_spec = /watchful_method/
+      @type_spec = /Aquarium::AspectInvocationTestClass/
+      @method_spec = /test_method/
       @method_options = [protection.intern]
       @protection = protection
       do_type_spec
@@ -248,8 +305,8 @@ describe Aspect, "#new with a :type(s) parameter and a :method(s) parameter" do
   end
 
   it "should accept :type(s) => ..., :methods => ..., :method_options => [:class] to match only public (default) class methods" do  
-    @type_spec = /Watchful/
-    @method_spec = /watchful_method/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @method_spec = /test_method/
     @method_options = [:class]
     @are_class_methods = true
     do_type_spec
@@ -257,8 +314,8 @@ describe Aspect, "#new with a :type(s) parameter and a :method(s) parameter" do
 
   %w[public private].each do |protection|
     it "should accept :type(s) => ..., :methods => ..., :method_options => [:class, :#{protection.intern}] to match only class #{protection} methods" do  
-      @type_spec = /Watchful/
-      @method_spec = /watchful_method/
+      @type_spec = /Aquarium::AspectInvocationTestClass/
+      @method_spec = /test_method/
       @method_options = [:class, protection.intern]
       @protection = protection
       @are_class_methods = true
@@ -268,7 +325,7 @@ describe Aspect, "#new with a :type(s) parameter and a :method(s) parameter" do
 end
 
 
-describe Aspect, "#new with a :type(s) parameter and a :attribute(s) parameter" do  
+describe Aspect, ".new with a :type(s) parameter and a :attribute(s) parameter" do  
   before :each do
     @protection = 'public'
     @attribute_options = []
@@ -278,137 +335,137 @@ describe Aspect, "#new with a :type(s) parameter and a :attribute(s) parameter"
   def do_type_attribute_spec
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :types => @type_spec, :attributes => @attribute_spec, :attribute_options => @attribute_options do |jp, *args|
+    aspect = Aspect.new :before, :types => @type_spec, :attributes => @attribute_spec, :attribute_options => @attribute_options do |jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       expected_args = make_array(@expected_args)
       args.should == expected_args
       args.size.should == expected_args.size
     end 
-    watchful = Watchful.new
+    object = Aquarium::AspectInvocationTestClass.new
     @expected_args = nil
-    watchful.method("#{@protection}_watchful_method_args".intern).call 
+    object.method("#{@protection}_test_method_args".intern).call 
     @expected_args = :a1
-    watchful.method("#{@protection}_watchful_method_args=".intern).call @expected_args
+    object.method("#{@protection}_test_method_args=".intern).call @expected_args
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should accept :type(s) => [T1, ...], :attribute(s) => [a, ...]" do  
-    @type_spec = [Watchful]
-    @attribute_spec = [:public_watchful_method_args]
+    @type_spec = [Aquarium::AspectInvocationTestClass]
+    @attribute_spec = [:public_test_method_args]
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => [T1, ...], :attribute(s) => a" do  
-    @type_spec = [Watchful]
-    @attribute_spec = :public_watchful_method_args
+    @type_spec = [Aquarium::AspectInvocationTestClass]
+    @attribute_spec = :public_test_method_args
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => [T1, ...], :attribute(s) => /a/" do  
-    @type_spec = [Watchful]
-    @attribute_spec = /watchful_method_args/
+    @type_spec = [Aquarium::AspectInvocationTestClass]
+    @attribute_spec = /test_method_args/
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => T1, :attribute(s) => [a]" do  
-    @type_spec = Watchful
-    @attribute_spec = [:public_watchful_method_args]
+    @type_spec = Aquarium::AspectInvocationTestClass
+    @attribute_spec = [:public_test_method_args]
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => T1, :attribute(s) => a" do  
-    @type_spec = Watchful
-    @attribute_spec = :public_watchful_method_args
+    @type_spec = Aquarium::AspectInvocationTestClass
+    @attribute_spec = :public_test_method_args
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => T1, :attribute(s) => /a/" do  
-    @type_spec = Watchful
-    @attribute_spec = /watchful_method_args/
+    @type_spec = Aquarium::AspectInvocationTestClass
+    @attribute_spec = /test_method_args/
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => /T1/, :attribute(s) => [a, ...]" do  
-    @type_spec = /Watchful/
-    @attribute_spec = [:public_watchful_method_args]
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = [:public_test_method_args]
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => /T1/, :attribute(s) => a" do  
-    @type_spec = /Watchful/
-    @attribute_spec = :public_watchful_method_args
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = :public_test_method_args
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => /T1/, :attribute(s) => a" do  
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => ..., :attributes => ..., :attribute_options => [:readers, :writers] to include both attribute reader and writer methods (default)" do  
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     @attribute_options = [:readers, :writers]
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => ..., :attributes => ..., :attribute_options => [:readers] to include only attribute reader methods" do  
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     @attribute_options = [:readers]
     do_type_attribute_spec
   end
 
   it "should accept attribute option :reader as a synonym for :readers" do
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     @attribute_options = [:reader]
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => ..., :attributes => ..., :attribute_options => [:writers] to include only attribute writer methods" do  
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     @attribute_options = [:writers]
     do_type_attribute_spec
   end
 
   it "should accept attribute option :writer as a synonym for :writers" do
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     @attribute_options = [:writer]
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => ..., :attributes => ..., :attribute_options => [:class, :readers, :writers] to include both attribute reader and writer methods (default) for class methods" do  
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     @attribute_options = [:class, :readers, :writers]
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => ..., :attributes => ..., :attribute_options => [:class, :readers] to include only attribute reader class methods" do  
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     @attribute_options = [:class, :readers]
     do_type_attribute_spec
   end
 
   it "should accept :type(s) => ..., :attributes => ..., :attribute_options => [:class, :writers] to include only attribute writer class methods" do  
-    @type_spec = /Watchful/
-    @attribute_spec = /watchful_method_args/
+    @type_spec = /Aquarium::AspectInvocationTestClass/
+    @attribute_spec = /test_method_args/
     @attribute_options = [:class, :writers]
     do_type_attribute_spec
   end
 end
 
-describe Aspect, "#new with a :object(s) parameter and a :method(s) parameter" do  
+describe Aspect, ".new with a :object(s) parameter and a :method(s) parameter" do  
   before :each do
-    @watchful1 = Watchful.new
-    @watchful2 = Watchful.new
+    @object1 = Aquarium::AspectInvocationTestClass.new
+    @object2 = Aquarium::AspectInvocationTestClass.new
     @protection = 'public'
     @method_options = []
   end
@@ -416,80 +473,80 @@ describe Aspect, "#new with a :object(s) parameter and a :method(s) parameter" d
   def do_object_spec
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :objects => @object_spec, :methods => @method_spec, :method_options => @method_options do |jp, *args|
+    aspect = Aspect.new :before, :objects => @object_spec, :methods => @method_spec, :method_options => @method_options do |jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
     make_array(@object_spec).each do |object|
-      object.method("#{@protection}_watchful_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+      object.method("#{@protection}_test_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     end
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should accept :object(s) => [o1, ...], :methods => [m, ...]" do  
-    @object_spec = [@watchful1, @watchful2]
-    @method_spec = [:public_watchful_method]
+    @object_spec = [@object1, @object2]
+    @method_spec = [:public_test_method]
     do_object_spec
   end
 
   it "should accept :object(s) => [o1, ...], :methods => m" do  
-    @object_spec = [@watchful1, @watchful2]
-    @method_spec = :public_watchful_method
+    @object_spec = [@object1, @object2]
+    @method_spec = :public_test_method
     do_object_spec
   end
 
   it "should accept :object(s) => [o1, ...], :methods => /m/" do  
-    @object_spec = [@watchful1, @watchful2]
-    @method_spec = /watchful_method/
+    @object_spec = [@object1, @object2]
+    @method_spec = /test_method/
     do_object_spec
   end
 
   it "should accept :object(s) => o1, :methods => [m, ...]" do  
-    @object_spec = @watchful1
-    @method_spec = [:public_watchful_method]
+    @object_spec = @object1
+    @method_spec = [:public_test_method]
     do_object_spec
   end
 
   it "should accept :object(s) => o1, :methods => m" do  
-    @object_spec = @watchful1
-    @method_spec = :public_watchful_method
+    @object_spec = @object1
+    @method_spec = :public_test_method
     do_object_spec
   end
 
   it "should accept :object(s) => o1, :methods => /m/" do  
-    @object_spec = @watchful1
-    @method_spec = /watchful_method/
+    @object_spec = @object1
+    @method_spec = /test_method/
     do_object_spec
   end
 
   it "should accept :object(s) => ..., :methods => ..., :method_options => [:exclude_ancestor_methods] to exclude methods defined in ancestors" do  
-    @object_spec = @watchful1
-    @method_spec = /watchful_method/
+    @object_spec = @object1
+    @method_spec = /test_method/
     @method_options = [:exclude_ancestor_methods]
     do_object_spec
   end
 
   it "should accept :object(s) => ..., :methods => ..., :method_options => [:instance, :public] to match only instance and public (both are the defaults) methods" do  
-    @object_spec = @watchful1
-    @method_spec = /watchful_method/
+    @object_spec = @object1
+    @method_spec = /test_method/
     @method_options = [:instance, :public]
     do_object_spec
   end
 
   %w[public protected private].each do |protection|
     it "should accept :object(s) => ..., :methods => ..., :method_options => [#{protection.intern}] to match only instance (default) #{protection} methods" do  
-      @object_spec = @watchful1
-      @method_spec = /watchful_method/
+      @object_spec = @object1
+      @method_spec = /test_method/
       @method_options = [protection.intern]
       @protection = protection
       do_object_spec
     end
 
     it "should accept :object(s) => ..., :methods => ..., :method_options => [:instance, #{protection.intern}] to match only instance #{protection} methods" do  
-      @object_spec = @watchful1
-      @method_spec = /watchful_method/
+      @object_spec = @object1
+      @method_spec = /test_method/
       @method_options = [:instance, protection.intern]
       @protection = protection
       do_object_spec
@@ -497,10 +554,10 @@ describe Aspect, "#new with a :object(s) parameter and a :method(s) parameter" d
   end
 end
 
-describe Aspect, "#new with a :object(s) parameter and a :attribute(s) parameter" do  
+describe Aspect, ".new with a :object(s) parameter and a :attribute(s) parameter" do  
   before :each do
-    @watchful1 = Watchful.new
-    @watchful2 = Watchful.new
+    @object1 = Aquarium::AspectInvocationTestClass.new
+    @object2 = Aquarium::AspectInvocationTestClass.new
     @protection = 'public'
     @attribute_options = []
   end
@@ -508,7 +565,7 @@ describe Aspect, "#new with a :object(s) parameter and a :attribute(s) parameter
   def do_object_attribute_spec
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :objects => @object_spec, :attributes => @attribute_spec, :attribute_options => @attribute_options do |jp, *args|
+    aspect = Aspect.new :before, :objects => @object_spec, :attributes => @attribute_spec, :attribute_options => @attribute_options do |jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       expected_args = make_array(@expected_args)
@@ -517,87 +574,87 @@ describe Aspect, "#new with a :object(s) parameter and a :attribute(s) parameter
     end 
     make_array(@object_spec).each do |object|
       @expected_args = nil
-      object.method("#{@protection}_watchful_method_args".intern).call 
+      object.method("#{@protection}_test_method_args".intern).call 
       @expected_args = :a1
-      object.method("#{@protection}_watchful_method_args=".intern).call @expected_args
+      object.method("#{@protection}_test_method_args=".intern).call @expected_args
       advice_called.should be_true
     end
     aspect.unadvise
   end
 
   it "should accept :object(s) => [T1, ...], :attribute(s) => [a, ...]" do  
-    @object_spec = [@watchful1, @watchful2]
-    @attribute_spec = [:public_watchful_method_args]
+    @object_spec = [@object1, @object2]
+    @attribute_spec = [:public_test_method_args]
     do_object_attribute_spec
   end
 
   it "should accept :object(s) => [T1, ...], :attribute(s) => a" do  
-    @object_spec = [@watchful1, @watchful2]
-    @attribute_spec = :public_watchful_method_args
+    @object_spec = [@object1, @object2]
+    @attribute_spec = :public_test_method_args
     do_object_attribute_spec
   end
 
   it "should accept :object(s) => [T1, ...], :attribute(s) => /a/" do  
-    @object_spec = [@watchful1, @watchful2]
-    @attribute_spec = /watchful_method_args/
+    @object_spec = [@object1, @object2]
+    @attribute_spec = /test_method_args/
     do_object_attribute_spec
   end
 
   it "should accept :object(s) => T1, :attribute(s) => [a]" do  
-    @object_spec = @watchful1
-    @attribute_spec = [:public_watchful_method_args]
+    @object_spec = @object1
+    @attribute_spec = [:public_test_method_args]
     do_object_attribute_spec
   end
 
   it "should accept :object(s) => T1, :attribute(s) => a" do  
-    @object_spec = @watchful1
-    @attribute_spec = :public_watchful_method_args
+    @object_spec = @object1
+    @attribute_spec = :public_test_method_args
     do_object_attribute_spec
   end
 
   it "should accept :object(s) => T1, :attribute(s) => /a/" do  
-    @object_spec = @watchful1
-    @attribute_spec = /watchful_method_args/
+    @object_spec = @object1
+    @attribute_spec = /test_method_args/
     do_object_attribute_spec
   end
 
   it "should accept :object(s) => ..., :attributes => ..., :attribute_options => [:readers, :writers] to include both attribute reader and writer methods (default)" do  
-    @object_spec = @watchful1
-    @attribute_spec = /watchful_method_args/
+    @object_spec = @object1
+    @attribute_spec = /test_method_args/
     @attribute_options = [:readers, :writers]
     do_object_attribute_spec
   end
 
   it "should accept :object(s) => ..., :attributes => ..., :attribute_options => [:readers] to include only attribute reader methods" do  
-    @object_spec = @watchful1
-    @attribute_spec = /watchful_method_args/
+    @object_spec = @object1
+    @attribute_spec = /test_method_args/
     @attribute_options = [:readers]
     do_object_attribute_spec
   end
 
   it "should accept attribute option :reader as a synonym for :readers" do
-    @object_spec = @watchful1
-    @attribute_spec = /watchful_method_args/
+    @object_spec = @object1
+    @attribute_spec = /test_method_args/
     @attribute_options = [:reader]
     do_object_attribute_spec
   end
 
   it "should accept :object(s) => ..., :attributes => ..., :attribute_options => [:writers] to include only attribute writer methods" do  
-    @object_spec = @watchful1
-    @attribute_spec = /watchful_method_args/
+    @object_spec = @object1
+    @attribute_spec = /test_method_args/
     @attribute_options = [:writers]
     do_object_attribute_spec
   end
 
   it "should accept attribute option :writer as a synonym for :writers" do
-    @object_spec = @watchful1
-    @attribute_spec = /watchful_method_args/
+    @object_spec = @object1
+    @attribute_spec = /test_method_args/
     @attribute_options = [:writer]
     do_object_attribute_spec
   end
 end
 
-describe Aspect, "#new with a :pointcut parameter taking a hash with type specifications" do  
+describe Aspect, ".new with a :pointcut parameter taking a hash with type specifications" do  
   before :each do
     @protection = 'public'
     @are_class_methods = false
@@ -606,77 +663,107 @@ describe Aspect, "#new with a :pointcut parameter taking a hash with type specif
   def do_type_pointcut_spec
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :pointcut => @pointcut_hash do |jp, *args|
+    aspect = Aspect.new :before, :pointcut => @pointcut_hash do |jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
     if @are_class_methods
-      Watchful.method("#{@protection}_class_watchful_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+      Aquarium::AspectInvocationTestClass.method("#{@protection}_class_test_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     else
-      Watchful.new.method("#{@protection}_watchful_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+      Aquarium::AspectInvocationTestClass.new.method("#{@protection}_test_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     end
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should accept {:type(s) => [T1, ...], :methods => [m, ...]} " do  
-    @pointcut_hash = {:type => [Watchful], :methods => [:public_watchful_method]}
+    @pointcut_hash = {:type => [Aquarium::AspectInvocationTestClass], :methods => [:public_test_method]}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => [T1, ...], :methods => m} " do  
-    @pointcut_hash = {:type => [Watchful], :methods => :public_watchful_method}
+    @pointcut_hash = {:type => [Aquarium::AspectInvocationTestClass], :methods => :public_test_method}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => [T1, ...], :methods => /m/} " do  
-    @pointcut_hash = {:type => [Watchful], :methods => /watchful_method/}
+    @pointcut_hash = {:type => [Aquarium::AspectInvocationTestClass], :methods => /test_method/}
+    do_type_pointcut_spec
+  end
+
+  it "should accept {:type(s)_and_ancestors => [T1, ...], :methods => /m/} " do  
+    @pointcut_hash = {:type_and_ancestors => [Aquarium::AspectInvocationTestClass], :methods => /test_method/}
+    do_type_pointcut_spec
+  end
+
+  it "should accept {:type(s)_and_descendents => [T1, ...], :methods => /m/} " do  
+    @pointcut_hash = {:type_and_descendents => [Aquarium::AspectInvocationTestClass], :methods => /test_method/}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => T1, :methods => [m, ...]} " do  
-    @pointcut_hash = {:type => Watchful, :methods => [:public_watchful_method]}
+    @pointcut_hash = {:type => Aquarium::AspectInvocationTestClass, :methods => [:public_test_method]}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => T1, :methods => m} " do  
-    @pointcut_hash = {:type => Watchful, :methods => :public_watchful_method}
+    @pointcut_hash = {:type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => T1, :methods => /m/} " do  
-    @pointcut_hash = {:type => Watchful, :methods => /watchful_method/}
+    @pointcut_hash = {:type => Aquarium::AspectInvocationTestClass, :methods => /test_method/}
+    do_type_pointcut_spec
+  end
+
+  it "should accept {:type(s)_and_ancestors => T1, :methods => /m/} " do  
+    @pointcut_hash = {:type_and_ancestors => Aquarium::AspectInvocationTestClass, :methods => /test_method/}
+    do_type_pointcut_spec
+  end
+
+  it "should accept {:type(s)_and_descendents => T1, :methods => /m/} " do  
+    @pointcut_hash = {:type_and_descendents => Aquarium::AspectInvocationTestClass, :methods => /test_method/}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => /T1/, :methods => [m, ...]} " do  
-    @pointcut_hash = {:type => /Watchful/, :methods => [:public_watchful_method]}
+    @pointcut_hash = {:type => /Aquarium::AspectInvocationTestClass/, :methods => [:public_test_method]}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => /T1/, :methods => m} " do  
-    @pointcut_hash = {:type => /Watchful/, :methods => :public_watchful_method}
+    @pointcut_hash = {:type => /Aquarium::AspectInvocationTestClass/, :methods => :public_test_method}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => /T1/, :methods => /m/} " do  
-    @pointcut_hash = {:type => /Watchful/, :methods => /watchful_method/}
+    @pointcut_hash = {:type => /Aquarium::AspectInvocationTestClass/, :methods => /test_method/}
+    do_type_pointcut_spec
+  end
+
+  it "should accept {:type(s)_and_ancestors => /T1/, :methods => /m/} " do  
+    @pointcut_hash = {:type_and_ancestors => /Aquarium::AspectInvocationTestClass/, :methods => /test_method/}
+    do_type_pointcut_spec
+  end
+
+  it "should accept {:type(s)_and_descendents => /T1/, :methods => /m/} " do  
+    @pointcut_hash = {:type_and_descendents => /Aquarium::AspectInvocationTestClass/, :methods => /test_method/}
     do_type_pointcut_spec
   end
 
   %w[public protected private].each do |protection|
     it "should accept {:type(s) => T1, :methods => /m/, :method_options =>[:instance, #{protection}]} " do  
       @protection = protection
-      @pointcut_hash = {:type => Watchful, :methods => /watchful_method/, :method_options =>[:instance, protection.intern]}
+      @pointcut_hash = {:type => Aquarium::AspectInvocationTestClass, :methods => /test_method/, :method_options =>[:instance, protection.intern]}
       do_type_pointcut_spec
     end
   end
 
   %w[public private].each do |protection|
     it "should accept {:type(s) => T1, :methods => /m/, :method_options =>[:class, #{protection}]} " do  
-      @pointcut_hash = {:type => Watchful, :methods => /class_watchful_method/, :method_options =>[:class, protection.intern]}
+      @pointcut_hash = {:type => Aquarium::AspectInvocationTestClass, :methods => /class_test_method/, :method_options =>[:class, protection.intern]}
       @protection = protection
       @are_class_methods = true
       do_type_pointcut_spec
@@ -684,133 +771,133 @@ describe Aspect, "#new with a :pointcut parameter taking a hash with type specif
   end
 
   it "should accept {:type(s) => T1, :methods => /m/, :method_options =>[:instance]} defaults to public methods" do  
-    @pointcut_hash = {:type => Watchful, :methods => /watchful_method/, :method_options =>[:instance]}
+    @pointcut_hash = {:type => Aquarium::AspectInvocationTestClass, :methods => /test_method/, :method_options =>[:instance]}
     do_type_pointcut_spec
   end
 
   it "should accept {:type(s) => T1, :methods => /m/, :method_options =>[:class]} defaults to public class methods" do  
-    @pointcut_hash = {:type => Watchful, :methods => /watchful_method/, :method_options =>[:class]}
+    @pointcut_hash = {:type => Aquarium::AspectInvocationTestClass, :methods => /test_method/, :method_options =>[:class]}
     @are_class_methods = true
     do_type_pointcut_spec
   end
 end
 
-describe Aspect, "#new with a :pointcut parameter taking a hash with object specifications" do  
+describe Aspect, ".new with a :pointcut parameter taking a hash with object specifications" do  
   before :each do
     @protection = 'public'
     @expected_advice_count = 2
-    @watchful1 = Watchful.new
-    @watchful2 = Watchful.new
+    @object1 = Aquarium::AspectInvocationTestClass.new
+    @object2 = Aquarium::AspectInvocationTestClass.new
   end
   
   def do_object_pointcut_spec
     aspect = nil
     advice_count = 0
-    aspect = Aspect.new :before, :pointcut => @pointcut_hash do |jp, *args|
+    aspect = Aspect.new :before, :pointcut => @pointcut_hash do |jp, obj, *args|
       advice_count += 1
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
-    @watchful1.method("#{@protection}_watchful_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
-    @watchful2.method("#{@protection}_watchful_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    @object1.method("#{@protection}_test_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    @object2.method("#{@protection}_test_method".intern).call :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_count.should == @expected_advice_count
     aspect.unadvise
   end
 
   it "should accept {:objects => [o1, ...], :methods => [m, ...]} " do  
-    @pointcut_hash = {:objects => [@watchful1, @watchful2], :methods => [:public_watchful_method]}
+    @pointcut_hash = {:objects => [@object1, @object2], :methods => [:public_test_method]}
     do_object_pointcut_spec
   end
 
   it "should accept {:objects => [o1, ...], :methods => m} " do  
-    @pointcut_hash = {:objects => [@watchful1, @watchful2], :methods => :public_watchful_method}
+    @pointcut_hash = {:objects => [@object1, @object2], :methods => :public_test_method}
     do_object_pointcut_spec
   end
 
   it "should accept {:objects => [o1, ...], :methods => /m/} " do  
-    @pointcut_hash = {:objects => [@watchful1, @watchful2], :methods => /watchful_method/}
+    @pointcut_hash = {:objects => [@object1, @object2], :methods => /test_method/}
     do_object_pointcut_spec
   end
 
   it "should accept {:object => o1, :methods => [m, ...]} " do  
     @expected_advice_count = 1
-    @pointcut_hash = {:object => @watchful1, :methods => [:public_watchful_method]}
+    @pointcut_hash = {:object => @object1, :methods => [:public_test_method]}
     do_object_pointcut_spec
   end
 
   it "should accept {:objects => o1, :methods => m} " do  
     @expected_advice_count = 1
-    @pointcut_hash = {:objects => @watchful1, :methods => :public_watchful_method}
+    @pointcut_hash = {:objects => @object1, :methods => :public_test_method}
     do_object_pointcut_spec
   end
 
   it "should accept {:objects => o1, :methods => /m/} " do  
     @expected_advice_count = 1
-    @pointcut_hash = {:objects => @watchful1, :methods => /watchful_method/}
+    @pointcut_hash = {:objects => @object1, :methods => /test_method/}
     do_object_pointcut_spec
   end
 end
 
-describe Aspect, "#new with a :pointcut parameter and a Pointcut object or an array of Pointcuts" do  
+describe Aspect, ".new with a :pointcut parameter and a Pointcut object or an array of Pointcuts" do  
   def do_pointcut_pointcut_spec
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :pointcut => @pointcuts do |jp, *args|
+    aspect = Aspect.new :before, :pointcut => @pointcuts do |jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
-    Watchful.new.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    Aquarium::AspectInvocationTestClass.new.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should accept a single Pointcut object." do
-    @pointcuts = Pointcut.new :type => [Watchful], :methods => :public_watchful_method
+    @pointcuts = Pointcut.new :type => [Aquarium::AspectInvocationTestClass], :methods => :public_test_method
     do_pointcut_pointcut_spec
   end
   
   it "should accept an array of Pointcut objects." do
-    pointcut1 = Pointcut.new :type => [Watchful], :methods => :public_watchful_method
-    pointcut2 = Pointcut.new :type => [Watchful], :methods => :public_class_watchful_method, :method_options => [:class]
+    pointcut1 = Pointcut.new :type => [Aquarium::AspectInvocationTestClass], :methods => :public_test_method
+    pointcut2 = Pointcut.new :type => [Aquarium::AspectInvocationTestClass], :methods => :public_class_test_method, :method_options => [:class]
     @pointcuts = [pointcut1, pointcut2]
     do_pointcut_pointcut_spec
   end
 end
 
-describe Aspect, "#new with a :pointcut parameter and an array of Pointcuts" do  
+describe Aspect, ".new with a :pointcut parameter and an array of Pointcuts" do  
   it "should treat the array as if it is one Pointcut \"or'ed\" together." do
     advice_called = 0
-    advice = Proc.new {|jp, *args|
+    advice = Proc.new {|jp, obj, *args|
       advice_called += 1
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     }
-    pointcut1 = Pointcut.new :type => [Watchful], :methods => :public_watchful_method
-    pointcut2 = Pointcut.new :type => [Watchful], :methods => :public_class_watchful_method, :method_options => [:class]
+    pointcut1 = Pointcut.new :type => [Aquarium::AspectInvocationTestClass], :methods => :public_test_method
+    pointcut2 = Pointcut.new :type => [Aquarium::AspectInvocationTestClass], :methods => :public_class_test_method, :method_options => [:class]
     pointcut12 = pointcut1.or pointcut2
     aspect1 = Aspect.new :before, :pointcut => [pointcut1, pointcut2], :advice => advice
-    Watchful.new.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
-    Watchful.public_class_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    Aquarium::AspectInvocationTestClass.new.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    Aquarium::AspectInvocationTestClass.public_class_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should == 2
     aspect1.unadvise
     advice_called = 0
     aspect2 = Aspect.new :before, :pointcut => pointcut12, :advice => advice
-    Watchful.new.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
-    Watchful.public_class_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    Aquarium::AspectInvocationTestClass.new.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    Aquarium::AspectInvocationTestClass.public_class_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should == 2
     aspect2.unadvise
     aspect1.join_points_matched.should eql(aspect2.join_points_matched)
   end
 end
 
-describe Aspect, "#new with a :type(s) parameter and a :method(s) parameter or one of several equivalent :pointcut parameters" do
+describe Aspect, ".new with a :type(s) parameter and a :method(s) parameter or one of several equivalent :pointcut parameters" do
   before :each do
-    @advice = proc {|jp,*args| "advice"}
-    @expected_methods = [:public_watchful_method]
+    @advice = proc {|jp, obj, *args| "advice"}
+    @expected_methods = [:public_test_method]
   end
   after :each do
     @aspect1.unadvise
@@ -818,41 +905,82 @@ describe Aspect, "#new with a :type(s) parameter and a :method(s) parameter or o
   end
   
   it "should advise equivalent join points when :type => T and :method => m is used or :pointcut =>{:type => T, :method => m} is used." do
-    @aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &@advice
-    @aspect2 = Aspect.new :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &@advice
+    @aspect1 = Aspect.new :after, :type => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:type => Aquarium::AspectInvocationTestClass, :method => :public_test_method}, &@advice
     aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise equivalent join points when :type => T and :method => m is used or :pointcut => pointcut is used, where pointcut matches :type => T and :method => m." do
-    @aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &@advice
-    pointcut = Aquarium::Aspects::Pointcut.new :type => Watchful, :method => :public_watchful_method
+    @aspect1 = Aspect.new :after, :type => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :type => Aquarium::AspectInvocationTestClass, :method => :public_test_method
     @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
     aspects_should_be_equal 1, @aspect1, @aspect2
   end
   
   it "should advise equivalent join points when :pointcut =>{:type => T, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :type => T and :method => m." do
-    @aspect1 = Aspect.new :after, :pointcut => {:type => Watchful, :method => :public_watchful_method}, &@advice
-    pointcut = Aquarium::Aspects::Pointcut.new :type => Watchful, :method => :public_watchful_method
+    @aspect1 = Aspect.new :after, :pointcut => {:type => Aquarium::AspectInvocationTestClass, :method => :public_test_method}, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :type => Aquarium::AspectInvocationTestClass, :method => :public_test_method
     @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
     aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise an equivalent join point when :type => T and :method => m is used or :pointcut => join_point is used, where join_point matches :type => T and :method => m." do
-    @aspect1 = Aspect.new :after, :type => Watchful, :method => :public_watchful_method, &@advice
-    join_point = Aquarium::Aspects::JoinPoint.new :type => Watchful, :method => :public_watchful_method
+    @aspect1 = Aspect.new :after, :type => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+    join_point = Aquarium::Aspects::JoinPoint.new :type => Aquarium::AspectInvocationTestClass, :method => :public_test_method
     @aspect2 = Aspect.new :after, :pointcut => join_point, &@advice
     join_points_should_be_equal 1, @aspect1, @aspect2
   end
+  
+  it "should advise equivalent join points when :type_and_ancestors => T and :method => m is used or :pointcut =>{:type_and_ancestors => T, :method => m} is used." do
+    @aspect1 = Aspect.new :after, :type_and_ancestors => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:type_and_ancestors => Aquarium::AspectInvocationTestClass, :method => :public_test_method}, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type_and_ancestors => T and :method => m is used or :pointcut => pointcut is used, where pointcut matches :type_and_ancestors => T and :method => m." do
+    @aspect1 = Aspect.new :after, :type_and_ancestors => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :type_and_ancestors => Aquarium::AspectInvocationTestClass, :method => :public_test_method
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
+  end
+  
+  it "should advise equivalent join points when :pointcut =>{:type_and_ancestors => T, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :type_and_ancestors => T and :method => m." do
+    @aspect1 = Aspect.new :after, :pointcut => {:type_and_ancestors => Aquarium::AspectInvocationTestClass, :method => :public_test_method}, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :type_and_ancestors => Aquarium::AspectInvocationTestClass, :method => :public_test_method
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type_and_descendents => T and :method => m is used or :pointcut =>{:type_and_descendents => T, :method => m} is used." do
+    @aspect1 = Aspect.new :after, :type_and_descendents => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:type_and_descendents => Aquarium::AspectInvocationTestClass, :method => :public_test_method}, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
+  end
+
+  it "should advise equivalent join points when :type_and_descendents => T and :method => m is used or :pointcut => pointcut is used, where pointcut matches :type_and_descendents => T and :method => m." do
+    @aspect1 = Aspect.new :after, :type_and_descendents => Aquarium::AspectInvocationTestClass, :method => :public_test_method, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :type_and_descendents => Aquarium::AspectInvocationTestClass, :method => :public_test_method
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
+  end
+  
+  it "should advise equivalent join points when :pointcut =>{:type_and_descendents => T, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :type_and_descendents => T and :method => m." do
+    @aspect1 = Aspect.new :after, :pointcut => {:type_and_descendents => Aquarium::AspectInvocationTestClass, :method => :public_test_method}, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :type_and_descendents => Aquarium::AspectInvocationTestClass, :method => :public_test_method
+    @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
+    aspects_should_be_equal 1, @aspect1, @aspect2
+  end
+
 end
 
-describe Aspect, "#new with a :type(s) parameter and an :attributes(s) parameter or one of several equivalent :pointcut parameters" do
+describe Aspect, ".new with a :type(s) parameter and an :attributes(s) parameter or one of several equivalent :pointcut parameters" do
   class ClassWithAttrib1
     def dummy; end
     attr_accessor :state
   end
   
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @expected_methods = [:state, :state=]
   end
   after :each do
@@ -902,10 +1030,10 @@ describe Aspect, "#new with a :type(s) parameter and an :attributes(s) parameter
   end
 end
 
-describe Aspect, "#new with a :object(s) parameter and a :method(s) parameter or one of several equivalent :pointcut parameters" do
+describe Aspect, ".new with a :object(s) parameter and a :method(s) parameter or one of several equivalent :pointcut parameters" do
   before :each do
-    @advice = proc {|jp,*args| "advice"}
-    @expected_methods = [:public_watchful_method]
+    @advice = proc {|jp, obj, *args| "advice"}
+    @expected_methods = [:public_test_method]
   end
   after :each do
     @aspect1.unadvise
@@ -913,30 +1041,30 @@ describe Aspect, "#new with a :object(s) parameter and a :method(s) parameter or
   end
 
   it "should advise equivalent join points when :object => o and :method => m is used or :pointcut =>{:object => o, :method => m} is used." do
-    watchful = Watchful.new
-    @aspect1 = Aspect.new :after, :object => watchful, :method => :public_watchful_method, &@advice
-    @aspect2 = Aspect.new :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &@advice
+    object = Aquarium::AspectInvocationTestClass.new
+    @aspect1 = Aspect.new :after, :object => object, :method => :public_test_method, &@advice
+    @aspect2 = Aspect.new :after, :pointcut => {:object => object, :method => :public_test_method}, &@advice
     aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise equivalent join points when :object => o and :method => m is used or :pointcut => pointcut is used, where pointcut matches :object => o and :method => m." do
-    watchful = Watchful.new
-    @aspect1 = Aspect.new :after, :object => watchful, :method => :public_watchful_method, &@advice
-    pointcut = Aquarium::Aspects::Pointcut.new :object => watchful, :method => :public_watchful_method
+    object = Aquarium::AspectInvocationTestClass.new
+    @aspect1 = Aspect.new :after, :object => object, :method => :public_test_method, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :object => object, :method => :public_test_method
     @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
     aspects_should_be_equal 1, @aspect1, @aspect2
   end
 
   it "should advise equivalent join points when :pointcut =>{:object => o, :method => m} is used or :pointcut => pointcut is used, where pointcut matches :object => o and :method => m." do
-    watchful = Watchful.new
-    @aspect1 = Aspect.new :after, :pointcut => {:object => watchful, :method => :public_watchful_method}, &@advice
-    pointcut = Aquarium::Aspects::Pointcut.new :object => watchful, :method => :public_watchful_method
+    object = Aquarium::AspectInvocationTestClass.new
+    @aspect1 = Aspect.new :after, :pointcut => {:object => object, :method => :public_test_method}, &@advice
+    pointcut = Aquarium::Aspects::Pointcut.new :object => object, :method => :public_test_method
     @aspect2 = Aspect.new :after, :pointcut => pointcut, &@advice
     aspects_should_be_equal 1, @aspect1, @aspect2
   end
 end
 
-describe Aspect, "#new with a :object(s) parameter and an :attributes(s) parameter or one of several equivalent :pointcut parameters" do
+describe Aspect, ".new with a :object(s) parameter and an :attributes(s) parameter or one of several equivalent :pointcut parameters" do
   class ClassWithAttrib2
     def initialize *args
       @state = args
@@ -946,7 +1074,7 @@ describe Aspect, "#new with a :object(s) parameter and an :attributes(s) paramet
   end
   
   before :each do
-    @advice = proc {|jp,*args| "advice"}
+    @advice = proc {|jp, obj, *args| "advice"}
     @object = ClassWithAttrib2.new
     @expected_methods = [:state, :state=]
   end
@@ -997,111 +1125,137 @@ describe Aspect, "#new with a :object(s) parameter and an :attributes(s) paramet
   end
 end
 
-describe Aspect, "#new block for advice" do  
+describe Aspect, ".new block for advice" do  
   it "should accept a block as the advice to use." do
-    watchful = Watchful.new
+    object = Aquarium::AspectInvocationTestClass.new
     advice_called = false
-    aspect = Aspect.new :before, :object => watchful, :methods => :public_watchful_method do |jp, *args|
+    aspect = Aspect.new :before, :object => object, :methods => :public_test_method do |jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
-    watchful.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    object.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should accept an :advice => Proc parameter indicating the advice to use." do
-    watchful = Watchful.new
+    object = Aquarium::AspectInvocationTestClass.new
     advice_called = false
-    advice = Proc.new {|jp, *args|
+    advice = Proc.new {|jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     }
-    aspect = Aspect.new :before, :object => watchful, :methods => :public_watchful_method, :advice => advice
-    watchful.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    aspect = Aspect.new :before, :object => object, :methods => :public_test_method, :advice => advice
+    object.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should be_true
     aspect.unadvise
   end
   
   it "should accept a :call => Proc parameter as a synonym for :advice." do
-    watchful = Watchful.new
+    object = Aquarium::AspectInvocationTestClass.new
     advice_called = false
-    advice = Proc.new {|jp, *args|
+    advice = Proc.new {|jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     }
-    aspect = Aspect.new :before, :object => watchful, :methods => :public_watchful_method, :call => advice
-    watchful.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    aspect = Aspect.new :before, :object => object, :methods => :public_test_method, :call => advice
+    object.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should accept a :invoke => Proc parameter as a synonym for :advice." do
-    watchful = Watchful.new
+    object = Aquarium::AspectInvocationTestClass.new
     advice_called = false
-    advice = Proc.new {|jp, *args|
+    advice = Proc.new {|jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     }
-    aspect = Aspect.new :before, :object => watchful, :methods => :public_watchful_method, :invoke => advice
-    watchful.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    aspect = Aspect.new :before, :object => object, :methods => :public_test_method, :invoke => advice
+    object.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should accept a :advise_with => Proc parameter as a synonym for :advice." do
-    watchful = Watchful.new
+    object = Aquarium::AspectInvocationTestClass.new
     advice_called = false
-    advice = Proc.new {|jp, *args|
+    advice = Proc.new {|jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     }
-    aspect = Aspect.new :before, :object => watchful, :methods => :public_watchful_method, :advise_with => advice
-    watchful.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    aspect = Aspect.new :before, :object => object, :methods => :public_test_method, :advise_with => advice
+    object.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should ignore all other advice parameters if a block is given." do
-    watchful = Watchful.new
+    object = Aquarium::AspectInvocationTestClass.new
     advice_called = false
-    advice1 = Proc.new {|jp, *args| fail "advice1"}
-    advice2 = Proc.new {|jp, *args| fail "advice2"}
-    aspect = Aspect.new :before, :object => watchful, :methods => :public_watchful_method, :advice => advice1, :invoke => advice2 do |jp, *args|
+    advice1 = Proc.new {|jp, obj, *args| fail "advice1"}
+    advice2 = Proc.new {|jp, obj, *args| fail "advice2"}
+    aspect = Aspect.new :before, :object => object, :methods => :public_test_method, :advice => advice1, :invoke => advice2 do |jp, obj, *args|
       advice_called = true
     end
-    watchful.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    object.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should be_true
     aspect.unadvise
   end
 
   it "should ignore all but the last advice parameter, using any synonym, if there is no advice block." do
-    watchful = Watchful.new
+    object = Aquarium::AspectInvocationTestClass.new
     advice_called = false
-    advice1 = Proc.new {|jp, *args|
+    advice1 = Proc.new {|jp, obj, *args|
       advice_called = true
       jp.should_not be_nil
       args.size.should == 4
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     }
-    advice2 = Proc.new {|jp, *args| raise "should not be called"}
-    aspect = Aspect.new :before, :object => watchful, :methods => :public_watchful_method, :advice => advice2, :advice => advice1
-    watchful.public_watchful_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
+    advice2 = Proc.new {|jp, obj, *args| raise "should not be called"}
+    aspect = Aspect.new :before, :object => object, :methods => :public_test_method, :advice => advice2, :advice => advice1
+    object.public_test_method :a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2'
     advice_called.should be_true
     aspect.unadvise
   end
 end
 
+describe Aspect, ".new advice block or proc parameter list" do  
+  it "should raise if obsolete |jp, *args| list is used." do
+    lambda { Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method do |jp, *args|; end }.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+
+  it "should accept an argument list matching |jp, object, *args|." do
+    lambda { Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method, :noop => true do |jp, object, *args|; end }.should_not raise_error(Exception)
+  end
+
+  it "should accept an argument list matching |jp, object|." do
+    lambda { Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method, :noop => true do |jp, object|; end }.should_not raise_error(Exception)
+  end
+
+  it "should accept an argument list matching |jp|." do
+    lambda { Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method, :noop => true do |jp|; end }.should_not raise_error(Exception)
+  end
+
+  it "should accept an argument list matching ||." do
+    lambda { Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method, :noop => true do ||; end }.should_not raise_error(Exception)
+  end
+
+  it "should accept no argument list." do
+    lambda { Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method, :noop => true do; end }.should_not raise_error(Exception)
+  end
+end
+
 
 class ExcludeBase
   def doit; end
@@ -1128,13 +1282,13 @@ class Exclude1c < Exclude1
   def doit3; end
 end  
 
-describe Aspect, "#new with a :type(s) parameter and an :exclude_type(s) parameter" do  
+describe Aspect, ".new with a :type(s) parameter and an :exclude_type(s), and :exclude_type(s)_and_ancestors, or an :exclude_type(s)_and_descendents parameter" do  
   def do_exclude_types exclude_type_sym
     included_types = [DontExclude1, DontExclude2]
     excluded_types = [Exclude1, Exclude2]
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :types => (included_types + excluded_types), exclude_type_sym => excluded_types, :methods => :doit do |jp, *args|
+    aspect = Aspect.new :before, :types => (included_types + excluded_types), exclude_type_sym => excluded_types, :methods => :doit do |jp, obj, *args|
       advice_called = true
       excluded_types.should_not include(jp.target_type)
     end 
@@ -1151,17 +1305,33 @@ describe Aspect, "#new with a :type(s) parameter and an :exclude_type(s) paramet
     aspect.unadvise
   end
   
-  it "should accept :type(s) => [T1, ...], :exclude_type(s) => [T2, ...] and exclude join points in the excluded types" do  
+  it "should accept :type(s) => [T1, ...], :exclude_types => [T2, ...] and exclude join points in the excluded types" do  
     do_exclude_types :exclude_types
   end
   
   it "should accept :exclude_type as a synonym for :exclude_types" do  
     do_exclude_types :exclude_type
   end
+
+  it "should accept :type(s) => [T1, ...], :exclude_types_and_ancestors => [T2, ...] and exclude join points in the excluded types" do  
+    do_exclude_types :exclude_types_and_ancestors
+  end
+  
+  it "should accept :exclude_type_and_ancestors as a synonym for :exclude_types_and_ancestors" do  
+    do_exclude_types :exclude_type_and_ancestors
+  end
+
+  it "should accept :type(s) => [T1, ...], :exclude_types_and_descendents => [T2, ...] and exclude join points in the excluded types" do  
+    do_exclude_types :exclude_types_and_descendents
+  end
+  
+  it "should accept :exclude_type_and_descendents as a synonym for :exclude_types_and_descendents" do  
+    do_exclude_types :exclude_type_and_descendents
+  end
 end
 
 
-describe Aspect, "#new with a :object(s) parameter and an :exclude_object(s) parameter" do  
+describe Aspect, ".new with a :object(s) parameter and an :exclude_object(s) parameter" do  
   def do_exclude_objects exclude_object_sym
     dontExclude1 = DontExclude1.new(1)
     dontExclude2 = DontExclude1.new(2)
@@ -1171,9 +1341,9 @@ describe Aspect, "#new with a :object(s) parameter and an :exclude_object(s) par
     excluded_objects = [exclude1, exclude2]
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :objects => (included_objects + excluded_objects), exclude_object_sym => excluded_objects, :methods => :doit do |jp, *args|
+    aspect = Aspect.new :before, :objects => (included_objects + excluded_objects), exclude_object_sym => excluded_objects, :methods => :doit do |jp, obj, *args|
       advice_called = true
-      excluded_objects.should_not include(jp.context.advised_object)
+      excluded_objects.should_not include(obj)
     end 
     included_objects.each do |object|
       advice_called = false
@@ -1198,7 +1368,7 @@ describe Aspect, "#new with a :object(s) parameter and an :exclude_object(s) par
 end
 
 
-describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s) parameter and an :exclude_join_point(s) parameter" do  
+describe Aspect, ".new with a :pointcut(s), :type(s), :type(s)_with_ancestors, :type(s)_with_descendents, :object(s), and :method(s) parameter and an :exclude_join_point(s) parameter" do  
   def do_exclude_join_points exclude_join_points_sym
     dontExclude1 = DontExclude1.new(1)
     dontExclude2 = DontExclude1.new(2)
@@ -1211,9 +1381,9 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
     excluded_join_points = [excluded_join_point1, excluded_join_point2]
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :objects => (included_objects + excluded_objects), exclude_join_points_sym => excluded_join_points, :methods => :doit do |jp, *args|
+    aspect = Aspect.new :before, :objects => (included_objects + excluded_objects), exclude_join_points_sym => excluded_join_points, :methods => :doit do |jp, obj, *args|
       advice_called = true
-      excluded_objects.should_not include(jp.context.advised_object)
+      excluded_objects.should_not include(obj)
     end 
 
     included_objects.each do |object|
@@ -1245,7 +1415,7 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
     excluded_join_points = [excluded_join_point1, excluded_join_point2]
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :types => (included_types + excluded_types), :exclude_join_points => excluded_join_points, :methods => :doit do |jp, *args|
+    aspect = Aspect.new :before, :types => (included_types + excluded_types), :exclude_join_points => excluded_join_points, :methods => :doit do |jp, obj, *args|
       advice_called = true
       excluded_types.should_not include(jp.target_type)
     end 
@@ -1263,6 +1433,42 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
     aspect.unadvise
   end
 
+  it "should accept :type(s)_with_ancestors => [T1, ...], :exclude_join_point(s) => [jps], where [jps] are the list of join points for the types and methods to exclude" do  
+    included_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
+    excluded_join_point1 = JoinPoint.new :type => ClassWithPublicInstanceMethod, :method => :public_instance_test_method
+    excluded_join_point2 = JoinPoint.new :type => ModuleWithPublicInstanceMethod, :method => :public_instance_module_test_method
+    excluded_join_points = [excluded_join_point1, excluded_join_point2]
+    aspect = nil
+    advice_called = false
+    aspect = Aspect.new :before, :types_and_ancestors => included_types, :exclude_join_points => excluded_join_points, :methods => :doit do |jp, obj, *args|; advice_called = true; end 
+
+    advice_called = false
+    ClassWithPublicInstanceMethod.new.public_instance_test_method
+    advice_called.should be_false
+    advice_called = false
+    ClassIncludingModuleWithPublicInstanceMethod.new.public_instance_module_test_method
+    advice_called.should be_false
+    aspect.unadvise
+  end
+
+  it "should accept :type(s)_with_descendents => [T1, ...], :exclude_join_point(s) => [jps], where [jps] are the list of join points for the types and methods to exclude" do  
+    included_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
+    excluded_join_point1 = JoinPoint.new :type => ClassWithPublicInstanceMethod, :method => :public_instance_test_method
+    excluded_join_point2 = JoinPoint.new :type => ModuleWithPublicInstanceMethod, :method => :public_instance_module_test_method
+    excluded_join_points = [excluded_join_point1, excluded_join_point2]
+    aspect = nil
+    advice_called = false
+    aspect = Aspect.new :before, :types_and_descendents => included_types, :exclude_join_points => excluded_join_points, :methods => :doit do |jp, obj, *args|; advice_called = true; end
+
+    advice_called = false
+    ClassWithPublicInstanceMethod.new.public_instance_test_method
+    advice_called.should be_false
+    advice_called = false
+    ClassIncludingModuleWithPublicInstanceMethod.new.public_instance_module_test_method
+    advice_called.should be_false
+    aspect.unadvise
+  end
+
   it "should accept :pointcut(s) => [P1, ...], :exclude_join_point(s) => [jps], where [jps] are the list of join points for the types and methods to exclude" do  
     included_types = [DontExclude1, DontExclude2]
     excluded_types = [Exclude1, Exclude2]
@@ -1273,7 +1479,7 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
     pointcut2 = Pointcut.new :types => excluded_types, :method => :doit
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_join_points => excluded_join_points do |jp, *args|
+    aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_join_points => excluded_join_points do |jp, obj, *args|
       advice_called = true
       excluded_types.should_not include(jp.target_type)
     end 
@@ -1291,7 +1497,7 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
   end
 end
 
-describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s) parameter and an :exclude_pointcut(s) parameter" do  
+describe Aspect, ".new with a :pointcut(s), :type(s), :object(s), and :method(s) parameter and an :exclude_pointcut(s) parameter" do  
   def do_exclude_pointcuts exclude_pointcuts_sym
     dontExclude1 = DontExclude1.new(1)
     dontExclude2 = DontExclude1.new(2)
@@ -1304,9 +1510,9 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
     excluded_pointcuts = [excluded_pointcut1, excluded_pointcut2]
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :objects => (included_objects + excluded_objects), exclude_pointcuts_sym => excluded_pointcuts, :methods => :doit do |jp, *args|
+    aspect = Aspect.new :before, :objects => (included_objects + excluded_objects), exclude_pointcuts_sym => excluded_pointcuts, :methods => :doit do |jp, obj, *args|
       advice_called = true
-      excluded_objects.should_not include(jp.context.advised_object)
+      excluded_objects.should_not include(obj)
     end 
 
     included_objects.each do |object|
@@ -1338,7 +1544,7 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
     excluded_pointcuts = [excluded_pointcut1, excluded_pointcut2]
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :types => (included_types + excluded_types), :exclude_pointcuts => excluded_pointcuts, :methods => :doit do |jp, *args|
+    aspect = Aspect.new :before, :types => (included_types + excluded_types), :exclude_pointcuts => excluded_pointcuts, :methods => :doit do |jp, obj, *args|
       advice_called = true
       excluded_types.should_not include(jp.target_type)
     end 
@@ -1366,7 +1572,7 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
     pointcut2 = Pointcut.new :types => excluded_types, :method => :doit
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_pointcuts => excluded_pointcuts do |jp, *args|
+    aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_pointcuts => excluded_pointcuts do |jp, obj, *args|
       advice_called = true
       excluded_types.should_not include(jp.target_type)
     end 
@@ -1384,8 +1590,7 @@ describe Aspect, "#new with a :pointcut(s), :type(s), :object(s), and :method(s)
   end
 end
 
-describe Aspect, "#new with type-based :pointcut(s) and :exclude_type(s) parameter" do  
-
+describe Aspect, ".new with type-based :pointcut(s) and :exclude_type(s) parameter" do  
   it "should accept :pointcut(s) => [P1, ...], :exclude_type(s) => [types], where join points with [types] are excluded" do  
     included_types = [DontExclude1, DontExclude2]
     excluded_types = [Exclude1, Exclude2]
@@ -1393,7 +1598,7 @@ describe Aspect, "#new with type-based :pointcut(s) and :exclude_type(s) paramet
     pointcut2 = Pointcut.new :types => excluded_types, :method => :doit
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_types => excluded_types do |jp, *args|
+    aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_types => excluded_types do |jp, obj, *args|
       advice_called = true
       excluded_types.should_not include(jp.target_type)
     end 
@@ -1412,8 +1617,36 @@ describe Aspect, "#new with type-based :pointcut(s) and :exclude_type(s) paramet
   end
 end
 
+describe Aspect, ".new with type-based :pointcut(s) and :exclude_type(s)_and_ancestors parameter" do  
+  it "should accept :pointcut(s) => [P1, ...], :exclude_type(s)_and_ancestors => [types], where join points with [types] are excluded" do  
+    excluded_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
+    types = excluded_types + [ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod]
+    pointcut1 = Pointcut.new :types => types, :method => :all, :method_options => [:exclude_ancestor_methods]
+    advice_called = false
+    aspect = Aspect.new :before, :pointcuts => pointcut1, :exclude_types_and_ancestors => excluded_types do |jp, obj, *args|; end
+    aspect.pointcuts.each do |pc|
+      pc.join_points_matched.each do |jp|
+        jp.target_type.should == ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod
+      end
+    end
+    aspect.unadvise
+  end
+end
+
+describe Aspect, ".new with type-based :pointcut(s) and :exclude_type(s)_and_descendents parameter" do  
+  it "should accept :pointcut(s) => [P1, ...], :exclude_type(s)_and_descendents => [types], where join points with [types] are excluded" do  
+    excluded_types = [ClassWithPublicInstanceMethod, ModuleWithPublicInstanceMethod]
+    types = excluded_types + [ClassDerivedFromClassIncludingModuleWithPublicInstanceMethod]
+    pointcut1 = Pointcut.new :types => types, :method => :all, :method_options => [:exclude_ancestor_methods]
+    advice_called = false
+    aspect = Aspect.new :before, :pointcuts => pointcut1, :exclude_types_and_descendents => excluded_types do |jp, obj, *args|; end
+    aspect.pointcuts.size.should == 0
+    aspect.unadvise
+  end
+end
+
 
-describe Aspect, "#new with object-based :pointcut(s) and :exclude_object(s) or :exclude_method(s) parameter" do  
+describe Aspect, ".new with object-based :pointcut(s) and :exclude_object(s) or :exclude_method(s) parameter" do  
 
   it "should accept :pointcut(s) => [P1, ...], :exclude_object(s) => [objects], where join points with [objects] are excluded" do  
     dontExclude1 = DontExclude1.new(1)
@@ -1426,9 +1659,9 @@ describe Aspect, "#new with object-based :pointcut(s) and :exclude_object(s) or
     pointcut2 = Pointcut.new :objects => excluded_objects, :method => :doit
     aspect = nil
     advice_called = false
-    aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_objects => excluded_objects do |jp, *args|
+    aspect = Aspect.new :before, :pointcuts => [pointcut1, pointcut2], :exclude_objects => excluded_objects do |jp, obj, *args|
       advice_called = true
-      excluded_objects.should_not include(jp.context.advised_object)
+      excluded_objects.should_not include(obj)
     end 
     included_objects.each do |object|
       advice_called = false
@@ -1444,7 +1677,7 @@ describe Aspect, "#new with object-based :pointcut(s) and :exclude_object(s) or
   end
 end
 
-describe Aspect, "#new with :method(s) and :exclude_method(s) parameter" do  
+describe Aspect, ".new with :method(s) and :exclude_method(s) parameter" do  
   before :each do
     @dontExclude1 = DontExclude1.new(1)
     @dontExclude2 = DontExclude1.new(2)
@@ -1467,7 +1700,7 @@ describe Aspect, "#new with :method(s) and :exclude_method(s) parameter" do
     parameter_hash[:exclude_method] = :doit3    
     aspect = nil
     advice_called = false
-    aspect = Aspect.new parameter_hash do |jp, *args|
+    aspect = Aspect.new parameter_hash do |jp, obj, *args|
       advice_called = true
       @excluded_methods.should_not include(jp.method_name)
     end 
@@ -1525,7 +1758,7 @@ describe Aspect, "#new with :method(s) and :exclude_method(s) parameter" do
   #   parameter_hash[:method] = /doit/  
   #   aspect = nil
   #   advice_called = false
-  #   aspect = Aspect.new parameter_hash do |jp, *args|
+  #   aspect = Aspect.new parameter_hash do |jp, obj, *args|
   #     advice_called = true
   #     @excluded_methods.should_not include(jp.method_name)
   #   end 
@@ -1540,7 +1773,7 @@ describe Aspect, "#new with :method(s) and :exclude_method(s) parameter" do
   # def buggy parameter_hash
   #   parameter_hash[:before] = ''
   #   parameter_hash[:exclude_method] = :doit3  
-  #   aspect = Aspect.new parameter_hash do |jp, *args|
+  #   aspect = Aspect.new parameter_hash do |jp, obj, *args|
   #   end 
   #   @excluded_objects.each do |object|
   #     object.doit