aquarium 0.3.0 → 0.3.1

data/spec/aquarium/aspects/aspect_spec.rb

@@ -1,12 +1,13 @@
 
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/aspects'
+require 'logger'
 
 include Aquarium::Aspects
 
 
-describe "Aspects that specify the private implementation methods inserted by other aspects" do  
+describe Aspect, " cannot advise the private implementation methods inserted by other aspects" do  
   it "should have no affect." do
     class WithAspectLikeMethod
       def _aspect_foo; end
@@ -17,7 +18,7 @@ describe "Aspects that specify the private implementation methods inserted by ot
   end
 end
 
-describe "When an aspect advises a type" do  
+describe Aspect, " when advising a type" do  
   before(:all) do
     @advice = Proc.new {}
   end
@@ -38,7 +39,7 @@ describe "When an aspect advises a type" do
   end
 end
 
-describe "When an aspect advises an object" do  
+describe Aspect, " when advising an object" do  
   before(:all) do
     @advice = Proc.new {}
   end
@@ -61,7 +62,7 @@ describe "When an aspect advises an object" do
   end
 end
 
-describe "Aspects with :before advice" do
+describe Aspect, " with :before advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
   end
@@ -90,7 +91,7 @@ describe "Aspects with :before advice" do
   end
 end
 
-describe "Aspects with :after advice" do
+describe Aspect, " with :after advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
   end
@@ -162,7 +163,7 @@ describe "Aspects with :after advice" do
   end
 end
 
-describe "Aspects with :after_returning advice" do
+describe Aspect, " with :after_returning advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
   end
@@ -219,7 +220,7 @@ describe "Aspects with :after_returning advice" do
   end
 end
 
-describe "Aspects with :after_raising advice" do
+describe Aspect, " with :after_raising advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
   end
@@ -288,7 +289,7 @@ describe "Aspects with :after_raising advice" do
   end
 end
 
-describe "Aspects with :before and :after advice" do
+describe Aspect, " with :before and :after advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
   end
@@ -329,7 +330,7 @@ describe "Aspects with :before and :after advice" do
   end
 end
 
-describe "Aspects with :before and :after_returning advice" do
+describe Aspect, " with :before and :after_returning advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
   end
@@ -363,7 +364,7 @@ describe "Aspects with :before and :after_returning advice" do
   end
 end
 
-describe "Aspects with :before and :after_raising advice" do
+describe Aspect, " with :before and :after_raising advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
   end
@@ -397,7 +398,7 @@ describe "Aspects with :before and :after_raising advice" do
   end
 end
 
-describe "Aspects with :around advice" do
+describe Aspect, " with :around advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
   end
@@ -624,7 +625,7 @@ describe Aspect, "#unadvise for 'empty' aspects" do
   
   it "should do nothing for unadvised types." do
     expected_methods = (Watchful.private_methods + Watchful.private_instance_methods).sort
-    aspect = Aspect.new :around, :type => Watchful, :method => /does_not_exist/, :advice => @advice
+    aspect = Aspect.new :around, :type => Watchful, :method => /does_not_exist/, :advice => @advice, :severity => Logger::Severity::ERROR
     ((Watchful.private_methods + Watchful.private_instance_methods).sort - expected_methods).should == []
     aspect.unadvise
     ((Watchful.private_methods + Watchful.private_instance_methods).sort - expected_methods).should == []
@@ -635,7 +636,7 @@ describe Aspect, "#unadvise for 'empty' aspects" do
   it "should do nothing for unadvised objects." do
     @watchful = Watchful.new
     expected_methods = @watchful.private_methods.sort
-    aspect = Aspect.new :around, :object => @watchful, :method => /does_not_exist/, :advice => @advice
+    aspect = Aspect.new :around, :object => @watchful, :method => /does_not_exist/, :advice => @advice, :severity => Logger::Severity::ERROR
     (@watchful.private_methods.sort - expected_methods).should == []
     aspect.unadvise
     (@watchful.private_methods.sort - expected_methods).should == []
@@ -757,13 +758,13 @@ describe Aspect, "#unadvise for removes all traces of the aspect" do
   end
 end
 
-describe "invariant protection level of methods under advising and unadvising", :shared => true do
-  it "should keep the protection level of an advised methods unchanged." do
-    %w[public protected private].each do |protection|
+%w[public protected private].each do |protection|
+  describe Aspect, " when advising and unadvising #{protection} methods" do
+    it "should keep the protection level of the advised methods unchanged." do
       meta   = "#{protection}_instance_methods"
       method = "#{protection}_watchful_method"
       Watchful.send(meta).should include(method)
-      aspect = Aspect.new(:after, :type => Watchful, :method => method.intern) {|jp, obj, *args| true }
+      aspect = Aspect.new(:after, :type => Watchful, :method => method.intern, :method_options => [protection.intern]) {|jp, obj, *args| true }
       Watchful.send(meta).should include(method)
       aspect.unadvise
       Watchful.send(meta).should include(method)
@@ -771,14 +772,8 @@ describe "invariant protection level of methods under advising and unadvising",
   end  
 end
 
-describe "Aspects advising methods should keep the protection level of an advised methods unchanged." do
-  it_should_behave_like("invariant protection level of methods under advising and unadvising")
-end
-describe "Aspects unadvising methods should restore the original protection level of the methods." do
-  it_should_behave_like("invariant protection level of methods under advising and unadvising")
-end
 
-describe "Aspects unadvising methods for instance-type pointcuts for type-defined methods" do
+describe Aspect, " when unadvising methods for instance-type pointcuts for type-defined methods" do
   class TypeDefinedMethodClass
     def inititalize; @called = false; end
     def m; @called = true; end
@@ -794,7 +789,7 @@ describe "Aspects unadvising methods for instance-type pointcuts for type-define
   end
 end
 
-describe "Aspects unadvising methods for instance-type pointcuts for instance-defined methods" do
+describe Aspect, " when unadvising methods for instance-type pointcuts for instance-defined methods" do
   class InstanceDefinedMethodClass
     def inititalize; @called = false; end
     attr_reader :called
@@ -810,7 +805,7 @@ describe "Aspects unadvising methods for instance-type pointcuts for instance-de
   end
 end
 
-describe "Aspects advising methods with non-alphanumeric characters" do
+describe Aspect, " when advising methods with non-alphanumeric characters" do
   module Aquarium::Aspects
     class ClassWithMethodNamesContainingOddChars
       @@method_names = []

data/spec/aquarium/aspects/aspect_with_nested_types_spec.rb

@@ -1,6 +1,6 @@
 
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/aspects'
 
 include Aquarium::Aspects

data/spec/aquarium/aspects/aspect_with_subtypes_spec.rb

@@ -1,6 +1,6 @@
 
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require 'aquarium/aspects'
 
 include Aquarium::Aspects

data/spec/aquarium/aspects/concurrent_aspects_spec.rb

@@ -1,7 +1,7 @@
 # Specifically tests behavior when two or more advices apply to the same join point(s).
 
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require File.dirname(__FILE__) + '/concurrently_accessed'
 require 'aquarium/aspects'
 

data/spec/aquarium/aspects/concurrent_aspects_with_objects_and_types_spec.rb

@@ -2,7 +2,7 @@
 # where one advice is for the type and the other is for an object of the type.
 
 require File.dirname(__FILE__) + '/../spec_helper'
-require File.dirname(__FILE__) + '/../spec_example_classes'
+require File.dirname(__FILE__) + '/../spec_example_types'
 require File.dirname(__FILE__) + '/concurrently_accessed'
 require 'aquarium/aspects'
 

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

@@ -1,529 +1,539 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../spec_example_classes'
+require File.dirname(__FILE__) + '/../../spec_example_types'
 require 'aquarium/aspects/dsl/aspect_dsl'
 
 class DSLClass
   include Aquarium::Aspects::DSL::AspectDSL
 end
 
-describe "DSL method #before" do  
-  before :each do
+describe "Aquarium::Aspects::DSL::AspectDSL" do
+  before :all do
     @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
+    @pointcut_opts = {:calls_to => :public_watchful_method, :in_type => Watchful}
   end
   
-  it "should be equivalent to advise :before." do
-    @aspects << DSLClass.advise(:before, :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.before(         :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+  describe "DSL method #before" do  
+    before :each do
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
+  
+    it "should be equivalent to advise :before." do
+      @aspects << DSLClass.advise(:before, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.before(         :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #after" do    
-  before :each do
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #after" do    
+    before :each do
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :after." do
-    @aspects << DSLClass.advise(:after, :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.after(         :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :after." do
+      @aspects << DSLClass.advise(:after, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.after(         :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #after_raising_within_or_returning_from" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #after_raising_within_or_returning_from" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :after." do
-    @aspects << DSLClass.after(                                 :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.after_raising_within_or_returning_from(:noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :after." do
+      @aspects << DSLClass.after(                                 :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.after_raising_within_or_returning_from(:noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #after_returning" do      
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #after_returning" do      
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :after_returning." do
-    @aspects << DSLClass.advise(:after_returning, :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.after_returning(         :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :after_returning." do
+      @aspects << DSLClass.advise(:after_returning, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.after_returning(         :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #after_returning_from" do      
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #after_returning_from" do      
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :after_returning." do
-    @aspects << DSLClass.advise(:after_returning, :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.after_returning_from(    :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :after_returning." do
+      @aspects << DSLClass.advise(:after_returning, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.after_returning_from(    :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #after_raising" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #after_raising" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :after_raising." do
-    class ThrowsUp
-      def tosses_cookies *args; raise Exception.new(args.inspect); end
+    it "should be equivalent to advise :after_raising." do
+      class ThrowsUp
+        def tosses_cookies *args; raise Exception.new(args.inspect); end
+      end
+      @aspects << DSLClass.advise(:after_raising, :noop => true, :pointcut => {:sending_messages_to => :tosses_cookies, :in_type => ThrowsUp}, &@advice)
+      @aspects << DSLClass.after_raising(         :noop => true, :pointcut => {:sending_messages_to => :tosses_cookies, :in_type => ThrowsUp}, &@advice)
+      @aspects[1].should == @aspects[0]
     end
-    @aspects << DSLClass.advise(:after_raising, :noop, :pointcut => {:sending_messages_to => :tosses_cookies, :in_type => ThrowsUp}, &@advice)
-    @aspects << DSLClass.after_raising(         :noop, :pointcut => {:sending_messages_to => :tosses_cookies, :in_type => ThrowsUp}, &@advice)
-    @aspects[1].should == @aspects[0]
   end
-end
 
-describe "DSL method #after_raising_within" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #after_raising_within" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :after_raising." do
-    class ThrowsUp
-      def tosses_cookies *args; raise Exception.new(args.inspect); end
+    it "should be equivalent to advise :after_raising." do
+      class ThrowsUp
+        def tosses_cookies *args; raise Exception.new(args.inspect); end
+      end
+      @aspects << DSLClass.advise(:after_raising, :noop => true, :pointcut => {:sending_messages_to => :tosses_cookies, :in_type => ThrowsUp}, &@advice)
+      @aspects << DSLClass.after_raising_within(  :noop => true, :pointcut => {:sending_messages_to => :tosses_cookies, :in_type => ThrowsUp}, &@advice)
+      @aspects[1].should == @aspects[0]
     end
-    @aspects << DSLClass.advise(:after_raising, :noop, :pointcut => {:sending_messages_to => :tosses_cookies, :in_type => ThrowsUp}, &@advice)
-    @aspects << DSLClass.after_raising_within(  :noop, :pointcut => {:sending_messages_to => :tosses_cookies, :in_type => ThrowsUp}, &@advice)
-    @aspects[1].should == @aspects[0]
   end
-end
 
-describe "DSL method #before_and_after" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #before_and_after" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :before, :after." do
-    @aspects << DSLClass.advise(:before, :after,  :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.before_and_after(        :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :before, :after." do
+      @aspects << DSLClass.advise(:before, :after,  :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.before_and_after(        :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #before_and_after_raising_within_or_returning_from" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #before_and_after_raising_within_or_returning_from" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :before and advise :after." do
-    @aspects << DSLClass.advise(:before, :after,                           :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.before_and_after_raising_within_or_returning_from(:noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :before and advise :after." do
+      @aspects << DSLClass.advise(:before, :after,                           :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.before_and_after_raising_within_or_returning_from(:noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #before_and_after_returning" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #before_and_after_returning" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :before and advise :after_returning." do
-    @aspects << DSLClass.advise(:before, :after_returning, :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.before_and_after_returning(       :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :before and advise :after_returning." do
+      @aspects << DSLClass.advise(:before, :after_returning, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.before_and_after_returning(       :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #before_and_after_returning_from" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #before_and_after_returning_from" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :before and advise :after_returning." do
-    @aspects << DSLClass.advise(:before, :after_returning, :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.before_and_after_returning_from(  :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :before and advise :after_returning." do
+      @aspects << DSLClass.advise(:before, :after_returning, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.before_and_after_returning_from(  :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #before_and_after_raising" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #before_and_after_raising" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :before and advise :after_raising." do
-    @aspects << DSLClass.advise(:before, :after_raising, :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.before_and_after_raising(       :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :before and advise :after_raising." do
+      @aspects << DSLClass.advise(:before, :after_raising, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.before_and_after_raising(       :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #around" do    
-  before :each do
-    @dsl = DSLClass.new
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #around" do    
+    before :each do
+      @dsl = DSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should be equivalent to advise :around." do
-    @aspects << DSLClass.advise(:around, :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects << DSLClass.around(         :noop, :pointcut => {:calls_to => :public_watchful_method, :in_type => Watchful}, &@advice)
-    @aspects[1].should == @aspects[0]
+    it "should be equivalent to advise :around." do
+      @aspects << DSLClass.advise(:around, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.around(         :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
   end
-end
 
-describe "DSL method #advise, when determining the \"self\" to advise," do    
-  before :each do
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #advise, when determining the \"self\" to advise," do    
+    before :each do
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
   
-  it "should ignore the default object \"self\" when an :object is specified." do
-    class Watchful1
-      include Aquarium::Aspects::DSL::AspectDSL
-      @@watchful = Watchful1.new
-      @@aspect = after(:invoking => :public_watchful_method, :on_object => @@watchful) {|jp, obj, *args|}
-      def self.watchful; @@watchful; end
-      def self.aspect; @@aspect; end
+    it "should ignore the default object \"self\" when an :object is specified." do
+      class Watchful1
+        include Aquarium::Aspects::DSL::AspectDSL
+        def public_watchful_method; end
+        @@watchful = Watchful1.new
+        @@aspect = after(:invoking => :public_watchful_method, :on_object => @@watchful) {|jp, obj, *args|}
+        def self.watchful; @@watchful; end
+        def self.aspect; @@aspect; end
+      end
+      @aspects << Watchful1.after(:invoking => :public_watchful_method, :on_object => Watchful1.watchful) {|jp, obj, *args|}
+      @aspects << Watchful1.aspect
+      @aspects[0].join_points_matched.should_not be_empty
+      @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
+      @aspects[1].pointcuts.should == @aspects[0].pointcuts
     end
-    @aspects << Watchful1.after(:invoking => :public_watchful_method, :on_object => Watchful1.watchful) {|jp, obj, *args|}
-    @aspects << Watchful1.aspect
-    @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
-    @aspects[1].pointcuts.should == @aspects[0].pointcuts
-  end
 
-  it "should ignore the default object \"self\" when a :type is specified." do
-    class Watchful2
-      include Aquarium::Aspects::DSL::AspectDSL
-      @@aspect = after(:calls_to => :public_watchful_method, :in_type => Watchful2) {|jp, obj, *args|}
-      def self.aspect; @@aspect; end
+    it "should ignore the default object \"self\" when a :type is specified." do
+      class Watchful2
+        include Aquarium::Aspects::DSL::AspectDSL
+        def public_watchful_method; end
+        @@aspect = after(:calls_to => :public_watchful_method, :in_type => Watchful2) {|jp, obj, *args|}
+        def self.aspect; @@aspect; end
+      end
+      @aspects << Watchful2.after(:calls_to => :public_watchful_method, :in_type => Watchful2) {|jp, obj, *args|}
+      @aspects << Watchful2.aspect
+      @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
+      @aspects[1].pointcuts.should == @aspects[0].pointcuts
     end
-    @aspects << Watchful2.after(:calls_to => :public_watchful_method, :in_type => Watchful2) {|jp, obj, *args|}
-    @aspects << Watchful2.aspect
-    @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
-    @aspects[1].pointcuts.should == @aspects[0].pointcuts
   end
-end
 
-describe "DSL method #advise, when determining the type or object to advise," do    
-  before :each do
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
-
-  class WatchfulSelf
-    include Aquarium::Aspects::DSL::AspectDSL
-    @@aspect = nil
-    def self.aspect; @@aspect; end
-    def public_watchful_method; "public_watchful_method"; end
-  end
+  describe "DSL method #advise, when determining the type or object to advise," do    
+    before :each do
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  it "should infer the type as \"self\" when no :object, :type, or :pointcut is specified." do
-    @aspects << WatchfulSelf.after(:calls_to => :public_watchful_method, :in_type => WatchfulSelf) {|jp, obj, *args|}
     class WatchfulSelf
-      @@aspect = after(:method => :public_watchful_method) {|jp, obj, *args|}
+      include Aquarium::Aspects::DSL::AspectDSL
+      @@aspect = nil
+      def self.aspect; @@aspect; end
+      def public_watchful_method; "public_watchful_method"; end
     end
-    @aspects << WatchfulSelf.aspect
-    @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
-    @aspects[1].pointcuts.should == @aspects[0].pointcuts
-  end
 
-  it "should infer the object as \"self\" when no :object, :type, or :pointcut is specified." do
-    watchful_self = WatchfulSelf.new
-    watchful_self.extend Aquarium::Aspects::DSL::AspectDSL
-    @aspects << WatchfulSelf.advise(:after, :pointcut => {:invoking => :public_watchful_method, :on_object => watchful_self}) {|jp, obj, *args|}
-    @aspects << watchful_self.after(:method => :public_watchful_method)  {|jp, obj, *args|}
-    @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
-  end
+    it "should infer the type as \"self\" when no :object, :type, or :pointcut is specified." do
+      @aspects << WatchfulSelf.after(:calls_to => :public_watchful_method, :in_type => WatchfulSelf) {|jp, obj, *args|}
+      class WatchfulSelf
+        @@aspect = after(:method => :public_watchful_method) {|jp, obj, *args|}
+      end
+      @aspects << WatchfulSelf.aspect
+      @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
+      @aspects[1].pointcuts.should == @aspects[0].pointcuts
+    end
 
-  it "should infer no types or objects if a :pointcut => {...} parameter is used and it does not specify a type or object." do
-    @aspects << DSLClass.after(:pointcut => {:method => /method/}) {|jp, obj, *args|}
-    @aspects[0].join_points_matched.size.should == 0 
-  end
-end
+    it "should infer the object as \"self\" when no :object, :type, or :pointcut is specified." do
+      watchful_self = WatchfulSelf.new
+      watchful_self.extend Aquarium::Aspects::DSL::AspectDSL
+      @aspects << WatchfulSelf.advise(:after, :pointcut => {:invoking => :public_watchful_method, :on_object => watchful_self}) {|jp, obj, *args|}
+      @aspects << watchful_self.after(:method => :public_watchful_method)  {|jp, obj, *args|}
+      @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
+    end
 
-describe "DSL method #advise, when parsing the parameter list," do    
-  class Watchful3
-    include Aquarium::Aspects::DSL::AspectDSL
-    def public_watchful_method; "public_watchful_method"; end
+    it "should infer no types or objects if a :pointcut => {...} parameter is used and it does not specify a type or object." do
+      @aspects << DSLClass.after(:pointcut => {:method => /method/}, :ignore_no_matching_join_points=>true) {|jp, obj, *args|}
+      @aspects[0].join_points_matched.size.should == 0 
+    end
   end
 
-  before :each do
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+  describe "DSL method #advise, when parsing the parameter list," do    
+    class Watchful3
+      include Aquarium::Aspects::DSL::AspectDSL
+      def public_watchful_method; "public_watchful_method"; end
+    end
 
-  it "should infer the first symbol parameter after the advice kind parameter to be the method name to advise if no other :method => ... parameter is used." do
-    @aspects << Watchful3.after(:public_watchful_method) {|jp, obj, *args|}
-    @aspects.each do |aspect|
-      aspect.join_points_matched.size.should == 1 
-      aspect.specification[:methods].should == Set.new([:public_watchful_method])
+    before :each do
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
     end
-  end
-end
 
-describe "DSL method #advise, when determining instance or class methods to advise," do    
-  before :each do
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
+    it "should infer the first symbol parameter after the advice kind parameter to be the method name to advise if no other :method => ... parameter is used." do
+      @aspects << Watchful3.after(:public_watchful_method) {|jp, obj, *args|}
+      @aspects.each do |aspect|
+        aspect.join_points_matched.size.should == 1 
+        aspect.specification[:methods].should == Set.new([:public_watchful_method])
+      end
+    end
   end
 
-  it "should treat \"ClassName.advise\" as advising instance methods, by default." do
-    class WatchfulExampleWithSeparateAdviseCall
-      include Aquarium::Aspects::DSL::AspectDSL
-      def public_watchful_method *args; end
+  describe "DSL method #advise, when determining instance or class methods to advise," do    
+    before :each do
+      @aspects = []
     end
-    advice_called = 0
-    WatchfulExampleWithSeparateAdviseCall.advise :before, :public_watchful_method do |jp, obj, *args|
-      advice_called += 1
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
+
+    it "should treat \"ClassName.advise\" as advising instance methods, by default." do
+      class WatchfulExampleWithSeparateAdviseCall
+        include Aquarium::Aspects::DSL::AspectDSL
+        def public_watchful_method *args; end
+      end
+      advice_called = 0
+      WatchfulExampleWithSeparateAdviseCall.advise :before, :public_watchful_method do |jp, obj, *args|
+        advice_called += 1
+      end
+      WatchfulExampleWithSeparateAdviseCall.new.public_watchful_method :a1, :a2
+      WatchfulExampleWithSeparateAdviseCall.new.public_watchful_method :a3, :a4
+      advice_called.should == 2
     end
-    WatchfulExampleWithSeparateAdviseCall.new.public_watchful_method :a1, :a2
-    WatchfulExampleWithSeparateAdviseCall.new.public_watchful_method :a3, :a4
-    advice_called.should == 2
-  end
   
-  it "should treat \"ClassName.advise\" as advising instance methods when the :instance method option is specified." do
-    class WatchfulExampleWithSeparateAdviseCall2
-      include Aquarium::Aspects::DSL::AspectDSL
-      def self.class_public_watchful_method *args; end
-      def public_watchful_method *args; end
-    end
-    advice_called = 0
-    WatchfulExampleWithSeparateAdviseCall2.advise :before, :sending_messages_to => /public_watchful_method/, :on_types => WatchfulExampleWithSeparateAdviseCall2, :restricting_methods_to =>[:instance_methods] do |jp, obj, *args|
-      advice_called += 1
-    end
-    WatchfulExampleWithSeparateAdviseCall2.class_public_watchful_method :a1, :a2
-    WatchfulExampleWithSeparateAdviseCall2.class_public_watchful_method :a3, :a4
-    advice_called.should == 0
-    WatchfulExampleWithSeparateAdviseCall2.new.public_watchful_method :a1, :a2
-    WatchfulExampleWithSeparateAdviseCall2.new.public_watchful_method :a3, :a4
-    advice_called.should == 2
-  end
+    it "should treat \"ClassName.advise\" as advising instance methods when the :instance method option is specified." do
+      class WatchfulExampleWithSeparateAdviseCall2
+        include Aquarium::Aspects::DSL::AspectDSL
+        def self.class_public_watchful_method *args; end
+        def public_watchful_method *args; end
+      end
+      advice_called = 0
+      WatchfulExampleWithSeparateAdviseCall2.advise :before, :sending_messages_to => /public_watchful_method/, :on_types => WatchfulExampleWithSeparateAdviseCall2, :restricting_methods_to =>[:instance_methods] do |jp, obj, *args|
+        advice_called += 1
+      end
+      WatchfulExampleWithSeparateAdviseCall2.class_public_watchful_method :a1, :a2
+      WatchfulExampleWithSeparateAdviseCall2.class_public_watchful_method :a3, :a4
+      advice_called.should == 0
+      WatchfulExampleWithSeparateAdviseCall2.new.public_watchful_method :a1, :a2
+      WatchfulExampleWithSeparateAdviseCall2.new.public_watchful_method :a3, :a4
+      advice_called.should == 2
+    end
   
-  it "should treat \"ClassName.advise\" as advising class methods when the :class method option is specified." do
-    class WatchfulExampleWithSeparateAdviseCall3
-      include Aquarium::Aspects::DSL::AspectDSL
-      def self.class_public_watchful_method *args; end
-      def public_watchful_method *args; end
-    end
-    advice_called = 0
-    WatchfulExampleWithSeparateAdviseCall3.advise :before, :calling => /public_watchful_method/, :restricting_methods_to =>[:class_methods] do |jp, obj, *args|
-      advice_called += 1
-    end
-    WatchfulExampleWithSeparateAdviseCall3.class_public_watchful_method :a1, :a2
-    WatchfulExampleWithSeparateAdviseCall3.class_public_watchful_method :a3, :a4
-    advice_called.should == 2
-    WatchfulExampleWithSeparateAdviseCall3.new.public_watchful_method :a1, :a2
-    WatchfulExampleWithSeparateAdviseCall3.new.public_watchful_method :a3, :a4
-    advice_called.should == 2
-  end
+    it "should treat \"ClassName.advise\" as advising class methods when the :class method option is specified." do
+      class WatchfulExampleWithSeparateAdviseCall3
+        include Aquarium::Aspects::DSL::AspectDSL
+        def self.class_public_watchful_method *args; end
+        def public_watchful_method *args; end
+      end
+      advice_called = 0
+      WatchfulExampleWithSeparateAdviseCall3.advise :before, :calling => /public_watchful_method/, :restricting_methods_to =>[:class_methods] do |jp, obj, *args|
+        advice_called += 1
+      end
+      WatchfulExampleWithSeparateAdviseCall3.class_public_watchful_method :a1, :a2
+      WatchfulExampleWithSeparateAdviseCall3.class_public_watchful_method :a3, :a4
+      advice_called.should == 2
+      WatchfulExampleWithSeparateAdviseCall3.new.public_watchful_method :a1, :a2
+      WatchfulExampleWithSeparateAdviseCall3.new.public_watchful_method :a3, :a4
+      advice_called.should == 2
+    end
   
-  it "should invoke the type-based advise for all objects when the aspect is defined by calling #advise within the class definition." do
-    class WatchfulExampleWithBeforeAdvice
-      include Aquarium::Aspects::DSL::AspectDSL
-      @@advice_called = 0
-      def public_watchful_method *args; end
-      before :public_watchful_method do |jp, obj, *args|
-        @@advice_called += 1
+    it "should invoke the type-based advise for all objects when the aspect is defined by calling #advise within the class definition." do
+      class WatchfulExampleWithBeforeAdvice
+        include Aquarium::Aspects::DSL::AspectDSL
+        @@advice_called = 0
+        def public_watchful_method *args; end
+        before :public_watchful_method do |jp, obj, *args|
+          @@advice_called += 1
+        end
+        def self.advice_called; @@advice_called; end
       end
-      def self.advice_called; @@advice_called; end
+      WatchfulExampleWithBeforeAdvice.new.public_watchful_method :a1, :a2
+      WatchfulExampleWithBeforeAdvice.new.public_watchful_method :a3, :a4
+      WatchfulExampleWithBeforeAdvice.advice_called.should == 2
     end
-    WatchfulExampleWithBeforeAdvice.new.public_watchful_method :a1, :a2
-    WatchfulExampleWithBeforeAdvice.new.public_watchful_method :a3, :a4
-    WatchfulExampleWithBeforeAdvice.advice_called.should == 2
   end
-end
 
-describe "DSL methods for the advice kind, when determining instance or class methods to advise," do    
-  class Watchful4
-    include Aquarium::Aspects::DSL::AspectDSL
-    def public_watchful_method; "public_watchful_method"; end
-  end
+  describe "DSL methods for the advice kind, when determining instance or class methods to advise," do    
+    class Watchful4
+      include Aquarium::Aspects::DSL::AspectDSL
+      def public_watchful_method; "public_watchful_method"; end
+    end
 
-  before :each do
-    @advice = proc {|jp, obj, *args| "advice"}
-    @aspects = []
-  end
-  after :each do
-    @aspects.each {|a| a.unadvise}
-  end
+    before :each do
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
 
-  (Aquarium::Aspects::Advice.kinds + [:after_raising_within_or_returning_from]).each do |advice_kind|
-    it "##{advice_kind} method should infer the first symbol parameter as the method name to advise if no other :method => ... parameter is used." do
-      @aspects << Watchful4.method(advice_kind).call(:public_watchful_method, &@advice)
-      @aspects.each do |aspect|
-        aspect.join_points_matched.size.should == 1 
-        aspect.specification[:methods].should == Set.new([:public_watchful_method])
+    (Aquarium::Aspects::Advice.kinds + [:after_raising_within_or_returning_from]).each do |advice_kind|
+      it "##{advice_kind} method should infer the first symbol parameter as the method name to advise if no other :method => ... parameter is used." do
+        @aspects << Watchful4.method(advice_kind).call(:public_watchful_method, &@advice)
+        @aspects.each do |aspect|
+          aspect.join_points_matched.size.should == 1 
+          aspect.specification[:methods].should == Set.new([:public_watchful_method])
+        end
       end
     end
   end
-end
 
-describe "Synonyms for :types" do
-  Aquarium::Aspects::Aspect::CANONICAL_OPTIONS["types"].each do |key|
-    it "should accept :#{key} as a synonym for :types." do
-      advice = proc {|jp, obj, *args| "advice"}
-      aspect1 = DSLClass.after :noop, :calls_to => :public_watchful_method, :types     => Watchful, &advice
-      aspect2 = DSLClass.after :noop, :calls_to => :public_watchful_method, key.intern => Watchful, &advice
-      aspect2.should == aspect1
-      aspect1.unadvise
-      aspect2.unadvise
+  describe "Synonyms for :types" do
+    Aquarium::Aspects::Aspect::CANONICAL_OPTIONS["types"].each do |key|
+      it "should accept :#{key} as a synonym for :types." do
+        advice = proc {|jp, obj, *args| "advice"}
+        aspect1 = DSLClass.after :noop => true, :calls_to => :public_watchful_method, :types     => Watchful, &advice
+        aspect2 = DSLClass.after :noop => true, :calls_to => :public_watchful_method, key.intern => Watchful, &advice
+        aspect2.should == aspect1
+        aspect1.unadvise
+        aspect2.unadvise
+      end
     end
   end
-end
 
-describe "Synonyms for :objects" do
-  Aquarium::Aspects::Aspect::CANONICAL_OPTIONS["objects"].each do |key|
-    it "should accept :#{key} as a synonym for :objects." do
-      advice = proc {|jp, obj, *args| "advice"}
-      aspect1 = DSLClass.after :noop, :calls_to => :public_watchful_method, :objects   => @watchful, &advice
-      aspect2 = DSLClass.after :noop, :calls_to => :public_watchful_method, key.intern => @watchful, &advice
-      aspect2.should == aspect1
-      aspect1.unadvise
-      aspect2.unadvise
+  describe "Synonyms for :objects" do
+    Aquarium::Aspects::Aspect::CANONICAL_OPTIONS["objects"].each do |key|
+      it "should accept :#{key} as a synonym for :objects." do
+        watchful = Watchful.new
+        advice = proc {|jp, obj, *args| "advice"}
+        aspect1 = DSLClass.after :noop => true, :calls_to => :public_watchful_method, :objects   => watchful, &advice
+        aspect2 = DSLClass.after :noop => true, :calls_to => :public_watchful_method, key.intern => watchful, &advice
+        aspect2.should == aspect1
+        aspect1.unadvise
+        aspect2.unadvise
+      end
     end
   end
-end
 
-describe "Synonyms for :methods" do
-  Aquarium::Aspects::Aspect::CANONICAL_OPTIONS["methods"].each do |key|
-    it "should accept :#{key} as a synonym for :methods." do
-      advice = proc {|jp, obj, *args| "advice"}
-      aspect1 = DSLClass.after :noop, :methods   => :public_watchful_method, :in_types => Watchful, &advice
-      aspect2 = DSLClass.after :noop, key.intern => :public_watchful_method, :in_types => Watchful, &advice
-      aspect2.should == aspect1
-      aspect1.unadvise
-      aspect2.unadvise
+  describe "Synonyms for :methods" do
+    Aquarium::Aspects::Aspect::CANONICAL_OPTIONS["methods"].each do |key|
+      it "should accept :#{key} as a synonym for :methods." do
+        advice = proc {|jp, obj, *args| "advice"}
+        aspect1 = DSLClass.after :noop => true, :methods   => :public_watchful_method, :in_types => Watchful, &advice
+        aspect2 = DSLClass.after :noop => true, key.intern => :public_watchful_method, :in_types => Watchful, &advice
+        aspect2.should == aspect1
+        aspect1.unadvise
+        aspect2.unadvise
+      end
     end
   end
-end
 
-describe "Synonyms for :pointcuts" do
-  Aquarium::Aspects::Aspect::CANONICAL_OPTIONS["pointcuts"].each do |key|
-    it "should accept :#{key} as a synonym for :pointcuts." do
-      advice = proc {|jp, obj, *args| "advice"}
-      aspect1 = DSLClass.after :noop, :pointcuts => {:calls_to => :public_watchful_method, :within_objects => @watchful}, &advice
-      aspect2 = DSLClass.after :noop, key.intern => {:calls_to => :public_watchful_method, :within_objects => @watchful}, &advice
-      aspect2.should == aspect1
-      aspect1.unadvise
-      aspect2.unadvise
+  describe "Synonyms for :pointcuts" do
+    Aquarium::Aspects::Aspect::CANONICAL_OPTIONS["pointcuts"].each do |key|
+      it "should accept :#{key} as a synonym for :pointcuts." do
+        watchful = Watchful.new
+        advice = proc {|jp, obj, *args| "advice"}
+        aspect1 = DSLClass.after :noop => true, :pointcuts => {:calls_to => :public_watchful_method, :within_objects => watchful}, &advice
+        aspect2 = DSLClass.after :noop => true, key.intern => {:calls_to => :public_watchful_method, :within_objects => watchful}, &advice
+        aspect2.should == aspect1
+        aspect1.unadvise
+        aspect2.unadvise
+      end
     end
   end
-end
 
-describe "DSL method #advise (or synonyms) called within a type body" do
-  it "will not advise a method whose definition hasn't been seen yet in the type body." do
-    class WatchfulWithMethodAlreadyDefined
-      include Aquarium::Aspects::DSL::AspectDSL
-      @@advice_called = 0
-      def public_watchful_method *args; end
-      before :public_watchful_method do |jp, obj, *args|
-        @@advice_called += 1
+  describe "DSL method #advise (or synonyms) called within a type body" do
+    it "will not advise a method whose definition hasn't been seen yet in the type body." do
+      class WatchfulWithMethodAlreadyDefined
+        include Aquarium::Aspects::DSL::AspectDSL
+        @@advice_called = 0
+        def public_watchful_method *args; end
+        before :public_watchful_method do |jp, obj, *args|
+          @@advice_called += 1
+        end
+        def self.advice_called; @@advice_called; end
+      end
+      WatchfulWithMethodAlreadyDefined.new.public_watchful_method :a1, :a2
+      WatchfulWithMethodAlreadyDefined.new.public_watchful_method :a3, :a4
+      WatchfulWithMethodAlreadyDefined.advice_called.should == 2
+      class WatchfulWithMethodNotYetDefined
+        include Aquarium::Aspects::DSL::AspectDSL
+        @@advice_called = 0
+        before(:public_watchful_method, :ignore_no_matching_join_points=>true) {|jp, obj, *args| @@advice_called += 1}
+        def public_watchful_method *args; end
+        def self.advice_called; @@advice_called; end
       end
-      def self.advice_called; @@advice_called; end
+      WatchfulWithMethodNotYetDefined.new.public_watchful_method :a1, :a2
+      WatchfulWithMethodNotYetDefined.new.public_watchful_method :a3, :a4
+      WatchfulWithMethodNotYetDefined.advice_called.should == 0
     end
-    WatchfulWithMethodAlreadyDefined.new.public_watchful_method :a1, :a2
-    WatchfulWithMethodAlreadyDefined.new.public_watchful_method :a3, :a4
-    WatchfulWithMethodAlreadyDefined.advice_called.should == 2
-    class WatchfulWithMethodNotYetDefined
-      include Aquarium::Aspects::DSL::AspectDSL
-      @@advice_called = 0
-      before(:public_watchful_method) {|jp, obj, *args| @@advice_called += 1}
-      def public_watchful_method *args; end
-      def self.advice_called; @@advice_called; end
-    end
-    WatchfulWithMethodNotYetDefined.new.public_watchful_method :a1, :a2
-    WatchfulWithMethodNotYetDefined.new.public_watchful_method :a3, :a4
-    WatchfulWithMethodNotYetDefined.advice_called.should == 0
   end
-end
 
-describe "DSL method #pointcut" do
-  class PC1; 
-    def doit; end
-  end
+  describe "DSL method #pointcut" do
+    class PC1; 
+      def doit; end
+    end
   
-  it "should match equivalent join points as Pointcut.new" do
-    pointcut1 = DSLClass.pointcut :type => PC1, :method => :doit
-    pointcut2 = Aquarium::Aspects::Pointcut.new :type => PC1, :method => :doit
-    pointcut1.join_points_matched.should     == pointcut2.join_points_matched
-    pointcut1.join_points_not_matched.should == pointcut2.join_points_not_matched
-  end
+    it "should match equivalent join points as Pointcut.new" do
+      pointcut1 = DSLClass.pointcut :type => PC1, :method => :doit
+      pointcut2 = Aquarium::Aspects::Pointcut.new :type => PC1, :method => :doit
+      pointcut1.join_points_matched.should     == pointcut2.join_points_matched
+      pointcut1.join_points_not_matched.should == pointcut2.join_points_not_matched
+    end
   
-  it "should use self as the object if no object or type is specified." do
-    class PC2
-      include Aquarium::Aspects::DSL::AspectDSL
-      POINTCUT = pointcut :method => :doit
+    it "should use self as the object if no object or type is specified." do
+      class PC2
+        include Aquarium::Aspects::DSL::AspectDSL
+        POINTCUT = pointcut :method => :doit
+      end
+      pointcut2 = Aquarium::Aspects::Pointcut.new :type => PC2, :method => :doit
+      PC2::POINTCUT.join_points_matched.should     == pointcut2.join_points_matched
+      PC2::POINTCUT.join_points_not_matched.should == pointcut2.join_points_not_matched
     end
-    pointcut2 = Aquarium::Aspects::Pointcut.new :type => PC2, :method => :doit
-    PC2::POINTCUT.join_points_matched.should     == pointcut2.join_points_matched
-    PC2::POINTCUT.join_points_not_matched.should == pointcut2.join_points_not_matched
   end
 end