aquarium 0.1.0 → 0.1.5

data/spec/aquarium/aspects/concurrent_aspects_spec.rb

@@ -5,6 +5,8 @@ require File.dirname(__FILE__) + '/../spec_example_classes'
 require File.dirname(__FILE__) + '/concurrently_accessed'
 require 'aquarium/aspects'
 
+include Aquarium::Aspects
+
 module ConcurrentAspectsSpecSupport
   def add_m_then_remove_n_aspects_and_run iteration, for_type
     reset_attrs
@@ -69,11 +71,11 @@ module ConcurrentAspectsSpecSupport
     method = @advice_kinds[n] == :after_raising ? :invoke_raises : :invoke
     @advice_invocation_counts[n] = 0
     if for_type 
-      pointcut = Aquarium::Aspects::Pointcut.new(:methods => method, :type => ConcurrentlyAccessed)
+      pointcut = Pointcut.new(:methods => method, :type => ConcurrentlyAccessed)
     else
-      pointcut = Aquarium::Aspects::Pointcut.new(:methods => method, :object => @accessed)
+      pointcut = Pointcut.new(:methods => method, :object => @accessed)
     end
-    @aspects[n] = advise @advice_kinds[n], :pointcut => pointcut do |jp, *args|
+    @aspects[n] = Aspect.new @advice_kinds[n], :pointcut => pointcut do |jp, *args|
       @contexts[n] = jp.context
       @argss[n]    = *args
       @advice_invocation_counts[n] += 1

data/spec/aquarium/aspects/concurrent_aspects_with_objects_and_types_spec.rb

@@ -6,8 +6,10 @@ require File.dirname(__FILE__) + '/../spec_example_classes'
 require File.dirname(__FILE__) + '/concurrently_accessed'
 require 'aquarium/aspects'
 
+include Aquarium::Aspects
+
 def make_aspect method, advice_kind, type_or_object_key, type_or_object
-  advise(advice_kind, :pointcut => {type_or_object_key => type_or_object, :method => method}) do |jp, *args|
+  Aspect.new advice_kind, :pointcut => {type_or_object_key => type_or_object, :method => method} do |jp, *args|
     @invoked << type_or_object_key
     jp.proceed if advice_kind == :around
   end

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

@@ -2,7 +2,11 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 require File.dirname(__FILE__) + '/../../spec_example_classes'
 require 'aquarium/aspects/dsl/aspect_dsl'
 
-describe Object, "#before" do  
+class DSLClass
+  include Aquarium::Aspects::DSL::AspectDSL
+end
+
+describe "DSL method #before" do  
   before :each do
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
@@ -12,13 +16,13 @@ describe Object, "#before" do
   end
   
   it "should be equivalent to advise :before." do
-    @aspects << advise(:before, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << before(         :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:before, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.before(         :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#after" do    
+describe "DSL method #after" do    
   before :each do
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
@@ -28,14 +32,15 @@ describe Object, "#after" do
   end
 
   it "should be equivalent to advise :after." do
-    @aspects << advise(:after, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << after(         :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:after, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.after(         :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#after_raising_within_or_returning_from" do    
+describe "DSL method #after_raising_within_or_returning_from" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -44,14 +49,15 @@ describe Object, "#after_raising_within_or_returning_from" do
   end
 
   it "should be equivalent to advise :after." do
-    @aspects << after(                                 :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << after_raising_within_or_returning_from(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.after(                                 :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.after_raising_within_or_returning_from(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#after_returning" do      
+describe "DSL method #after_returning" do      
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -60,14 +66,15 @@ describe Object, "#after_returning" do
   end
 
   it "should be equivalent to advise :after_returning." do
-    @aspects << advise(:after_returning, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << after_returning(         :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:after_returning, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.after_returning(         :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#after_returning_from" do      
+describe "DSL method #after_returning_from" do      
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -76,14 +83,15 @@ describe Object, "#after_returning_from" do
   end
 
   it "should be equivalent to advise :after_returning." do
-    @aspects << advise(:after_returning, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << after_returning_from(    :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:after_returning, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.after_returning_from(    :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#after_raising" do    
+describe "DSL method #after_raising" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -95,14 +103,15 @@ describe Object, "#after_raising" do
     class ThrowsUp
       def tosses_cookies *args; raise Exception.new(args.inspect); end
     end
-    @aspects << advise(:after_raising, :noop, :pointcut => {:type => ThrowsUp, :methods => :tosses_cookies}, &@advice)
-    @aspects << after_raising(         :noop, :pointcut => {:type => ThrowsUp, :methods => :tosses_cookies}, &@advice)
+    @aspects << DSLClass.advise(:after_raising, :noop, :pointcut => {:type => ThrowsUp, :methods => :tosses_cookies}, &@advice)
+    @aspects << DSLClass.after_raising(         :noop, :pointcut => {:type => ThrowsUp, :methods => :tosses_cookies}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#after_raising_within" do    
+describe "DSL method #after_raising_within" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -114,14 +123,15 @@ describe Object, "#after_raising_within" do
     class ThrowsUp
       def tosses_cookies *args; raise Exception.new(args.inspect); end
     end
-    @aspects << advise(:after_raising, :noop, :pointcut => {:type => ThrowsUp, :methods => :tosses_cookies}, &@advice)
-    @aspects << after_raising_within(  :noop, :pointcut => {:type => ThrowsUp, :methods => :tosses_cookies}, &@advice)
+    @aspects << DSLClass.advise(:after_raising, :noop, :pointcut => {:type => ThrowsUp, :methods => :tosses_cookies}, &@advice)
+    @aspects << DSLClass.after_raising_within(  :noop, :pointcut => {:type => ThrowsUp, :methods => :tosses_cookies}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#before_and_after" do    
+describe "DSL method #before_and_after" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -130,14 +140,15 @@ describe Object, "#before_and_after" do
   end
 
   it "should be equivalent to advise :before, :after." do
-    @aspects << advise(:before, :after,  :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << before_and_after(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:before, :after,  :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.before_and_after(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#before_and_after_raising_within_or_returning_from" do    
+describe "DSL method #before_and_after_raising_within_or_returning_from" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -146,14 +157,15 @@ describe Object, "#before_and_after_raising_within_or_returning_from" do
   end
 
   it "should be equivalent to advise :before and advise :after." do
-    @aspects << advise(:before, :after,  :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << before_and_after_raising_within_or_returning_from(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:before, :after,  :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.before_and_after_raising_within_or_returning_from(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#before_and_after_returning" do    
+describe "DSL method #before_and_after_returning" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -162,14 +174,15 @@ describe Object, "#before_and_after_returning" do
   end
 
   it "should be equivalent to advise :before and advise :after_returning." do
-    @aspects << advise(:before, :after_returning, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << before_and_after_returning(       :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:before, :after_returning, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.before_and_after_returning(       :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#before_and_after_returning_from" do    
+describe "DSL method #before_and_after_returning_from" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -178,14 +191,15 @@ describe Object, "#before_and_after_returning_from" do
   end
 
   it "should be equivalent to advise :before and advise :after_returning." do
-    @aspects << advise(:before, :after_returning, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << before_and_after_returning_from(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:before, :after_returning, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.before_and_after_returning_from(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#before_and_after_raising" do    
+describe "DSL method #before_and_after_raising" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -194,14 +208,15 @@ describe Object, "#before_and_after_raising" do
   end
 
   it "should be equivalent to advise :before and advise :after_raising." do
-    @aspects << advise(:before, :after_raising, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << before_and_after_raising(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:before, :after_raising, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.before_and_after_raising(:noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#around" do    
+describe "DSL method #around" do    
   before :each do
+    @dsl = DSLClass.new
     @advice = proc {|jp,*args| "advice"}
     @aspects = []
   end
@@ -210,15 +225,14 @@ describe Object, "#around" do
   end
 
   it "should be equivalent to advise :around." do
-    @aspects << advise(:around, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
-    @aspects << around(         :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.advise(:around, :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.around(         :noop, :pointcut => {:type => Watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#advise (inferred arguments)" do    
+describe "DSL method #advise, when determining the \"self\" to advise," do    
   before :each do
-    @watchful = Watchful.new
     @aspects = []
   end
   after :each do
@@ -226,46 +240,109 @@ describe Object, "#advise (inferred arguments)" do
   end
   
   it "should ignore the default object \"self\" when an :object is specified." do
-    class Watchful
-      @@watchful = Watchful.new
+    class Watchful1
+      include Aquarium::Aspects::DSL::AspectDSL
+      @@watchful = Watchful1.new
       @@aspect = after(:object => @@watchful, :method => :public_watchful_method) {|jp,*args|}
       def self.watchful; @@watchful; end
       def self.aspect; @@aspect; end
     end
-    @aspects << after(:object => Watchful.watchful, :method => :public_watchful_method) {|jp,*args|}
-    @aspects << Watchful.aspect
+    @aspects << DSLClass.after(:object => Watchful1.watchful, :method => :public_watchful_method) {|jp,*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 Watchful
-      @@aspect = after(:type => Watchful, :method => :public_watchful_method) {|jp,*args|}
+    class Watchful2
+      include Aquarium::Aspects::DSL::AspectDSL
+      @@aspect = after(:type => Watchful2, :method => :public_watchful_method) {|jp,*args|}
       def self.aspect; @@aspect; end
     end
-    @aspects << after(:type => Watchful, :method => :public_watchful_method) {|jp,*args|}
-    @aspects << Watchful.aspect
+    @aspects << DSLClass.after(:type => Watchful2, :method => :public_watchful_method) {|jp,*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
 
-  it "should infer the type to advise as \"self\" when no :object, :type, or :pointcut is specified." do
-    @aspects << after(:type => Watchful, :method => :public_watchful_method) {|jp,*args|}
-    class Watchful
+  it "should infer the type as \"self\" when no :object, :type, or :pointcut is specified." do
+    @aspects << DSLClass.after(:type => WatchfulSelf, :method => :public_watchful_method) {|jp,*args|}
+    class WatchfulSelf
       @@aspect = after(:method => :public_watchful_method) {|jp,*args|}
-      def self.aspect; @@aspect; end
     end
-    @aspects << Watchful.aspect
+    @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 << watchful_self.after(:method => :public_watchful_method)  {|jp,*args|}
+    @aspects << DSLClass.advise(         :after, :pointcut => {:object => watchful_self, :method => :public_watchful_method}) {|jp,*args|}
     @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
     @aspects[1].pointcuts.should == @aspects[0].pointcuts
   end
 
+  it "should infer no types or objects if a :pointcut => {...} parameter is used and it does not specify a type or object." do
+    @aspects << DSLClass.after(:pointcut => {:method => /method/}) {|jp,*args|}
+    @aspects[0].join_points_matched.size.should == 0 
+  end
+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
+
+  before :each do
+    @aspects = []
+  end
+  after :each do
+    @aspects.each {|a| a.unadvise}
+  end
+
+  it "should infer the first symbol parameter after the advice kind parameter to be the method name to advise if no other :method => ... parameter is used." do
+    @aspects << Watchful3.after(:public_watchful_method) {|jp,*args|}
+    @aspects.each do |aspect|
+      aspect.join_points_matched.size.should == 1 
+      aspect.specification[:methods].should == Set.new([:public_watchful_method])
+    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}
+  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.before :public_watchful_method do |jp, *args|
+    WatchfulExampleWithSeparateAdviseCall.advise :before, :public_watchful_method do |jp, *args|
       advice_called += 1
     end
     WatchfulExampleWithSeparateAdviseCall.new.public_watchful_method :a1, :a2
@@ -275,11 +352,12 @@ describe Object, "#advise (inferred arguments)" do
   
   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
-    Aquarium::Aspects::Aspect.new :before, :type => WatchfulExampleWithSeparateAdviseCall2, :methods => /public_watchful_method/, :method_options =>[:instance] do |jp, *args|
+    WatchfulExampleWithSeparateAdviseCall2.advise :before, :type => WatchfulExampleWithSeparateAdviseCall2, :methods => /public_watchful_method/, :method_options =>[:instance] do |jp, *args|
       advice_called += 1
     end
     WatchfulExampleWithSeparateAdviseCall2.class_public_watchful_method :a1, :a2
@@ -291,24 +369,26 @@ describe Object, "#advise (inferred arguments)" do
   end
   
   it "should treat \"ClassName.advise\" as advising class methods when the :class method option is specified." do
-    class WatchfulExampleWithSeparateAdviseCall
+    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
-    WatchfulExampleWithSeparateAdviseCall.before :methods => /public_watchful_method/, :method_options =>[:class] do |jp, *args|
+    WatchfulExampleWithSeparateAdviseCall3.advise :before, :methods => /public_watchful_method/, :method_options =>[:class] do |jp, *args|
       advice_called += 1
     end
-    WatchfulExampleWithSeparateAdviseCall.class_public_watchful_method :a1, :a2
-    WatchfulExampleWithSeparateAdviseCall.class_public_watchful_method :a3, :a4
+    WatchfulExampleWithSeparateAdviseCall3.class_public_watchful_method :a1, :a2
+    WatchfulExampleWithSeparateAdviseCall3.class_public_watchful_method :a3, :a4
     advice_called.should == 2
-    WatchfulExampleWithSeparateAdviseCall.new.public_watchful_method :a1, :a2
-    WatchfulExampleWithSeparateAdviseCall.new.public_watchful_method :a3, :a4
+    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, *args|
@@ -320,32 +400,16 @@ describe Object, "#advise (inferred arguments)" do
     WatchfulExampleWithBeforeAdvice.new.public_watchful_method :a3, :a4
     WatchfulExampleWithBeforeAdvice.advice_called.should == 2
   end
+end
 
-  it "should infer the object to advise as \"self\" when no :object, :type, or :pointcut is specified." do
-    @aspects << @watchful.after(:method => :public_watchful_method)  {|jp,*args|}
-    @aspects << advise(         :after, :pointcut => {:object => @watchful, :method => :public_watchful_method}) {|jp,*args|}
-    @aspects[1].join_points_matched.should == @aspects[0].join_points_matched
-    @aspects[1].pointcuts.should == @aspects[0].pointcuts
-  end
-
-  it "should infer no types or objects if a :pointcut => {...} parameter is used and it does not specify a type or object." do
-    @aspects << after(:pointcut => {:method => /method/}) {|jp,*args|}
-    @aspects[0].join_points_matched.size.should == 0 
-  end
-
-  it "should infer the first symbol parameter after the advice kind parameter is the method name to advise if no other :method => ... parameter is used." do
-    @aspects << @watchful.after( :public_watchful_method) {|jp,*args|}
-    @aspects.each do |aspect|
-      aspect.join_points_matched.size.should == 1 
-      aspect.specification[:methods].should == Set.new([:public_watchful_method])
-    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
-end
 
-describe Object, "advice kind convenience methods (inferred arguments)" do    
   before :each do
     @advice = proc {|jp,*args| "advice"}
-    @watchful = Watchful.new
     @aspects = []
   end
   after :each do
@@ -354,7 +418,7 @@ describe Object, "advice kind convenience methods (inferred arguments)" do
 
   (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 << @watchful.method(advice_kind).call(:public_watchful_method, &@advice)
+      @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])
@@ -366,24 +430,24 @@ end
 describe "Synonyms for :types" do
   before :each do
     @advice = proc {|jp,*args| "advice"}
-    @aspects = [after(:noop, :types => Watchful, :methods => :public_watchful_method, &@advice)]
+    @aspects = [DSLClass.after(:noop, :types => Watchful, :methods => :public_watchful_method, &@advice)]
   end
   after :each do
     @aspects.each {|a| a.unadvise}
   end
 
   it ":type is a synonym for :types" do
-    @aspects << after(:noop, :type => Watchful, :methods => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :type => Watchful, :methods => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 
   it ":within_types is a synonym for :types" do
-    @aspects << after(:noop, :within_type => Watchful, :methods => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :within_type => Watchful, :methods => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 
   it ":within_types is a synonym for :types" do
-    @aspects << after(:noop, :within_types => Watchful, :methods => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :within_types => Watchful, :methods => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
@@ -391,25 +455,24 @@ end
 describe "Synonyms for :objects" do
   before :each do
     @advice = proc {|jp,*args| "advice"}
-    @watchful = Watchful.new
-    @aspects = [after(:noop, :objects => @watchful, :methods => :public_watchful_method, &@advice)]
+    @aspects = [DSLClass.after(:noop, :objects => @watchful, :methods => :public_watchful_method, &@advice)]
   end
   after :each do
     @aspects.each {|a| a.unadvise}
   end
 
   it ":object is a synonym for :objects" do
-    @aspects << after(:noop, :object => @watchful, :methods => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :object => @watchful, :methods => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 
   it ":within_objects is a synonym for :objects" do
-    @aspects << after(:noop, :within_object => @watchful, :methods => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :within_object => @watchful, :methods => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 
   it ":within_objects is a synonym for :objects" do
-    @aspects << after(:noop, :within_objects => @watchful, :methods => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :within_objects => @watchful, :methods => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
@@ -417,25 +480,24 @@ end
 describe "Synonyms for :methods" do
   before :each do
     @advice = proc {|jp,*args| "advice"}
-    @watchful = Watchful.new
-    @aspects = [after(:noop, :objects => @watchful, :methods => :public_watchful_method, &@advice)]
+    @aspects = [DSLClass.after(:noop, :objects => @watchful, :methods => :public_watchful_method, &@advice)]
   end
   after :each do
     @aspects.each {|a| a.unadvise}
   end
 
   it ":method is a synonym for :methods" do
-    @aspects << after(:noop, :object => @watchful, :method => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :object => @watchful, :method => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 
   it ":within_methods is a synonym for :methods" do
-    @aspects << after(:noop, :within_object => @watchful, :within_methods => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :within_object => @watchful, :within_methods => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 
   it ":within_methods is a synonym for :methods" do
-    @aspects << after(:noop, :within_objects => @watchful, :within_method => :public_watchful_method, &@advice)
+    @aspects << DSLClass.after(:noop, :within_objects => @watchful, :within_method => :public_watchful_method, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
@@ -443,32 +505,32 @@ end
 describe "Synonyms for :pointcut" do
   before :each do
     @advice = proc {|jp,*args| "advice"}
-    @watchful = Watchful.new
-    @aspects = [after(:noop, :pointcut => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)]
+    @aspects = [DSLClass.after(:noop, :pointcut => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)]
   end
   after :each do
     @aspects.each {|a| a.unadvise}
   end
 
   it ":pointcuts is a synonym for :pointcut" do
-    @aspects << after(:noop, :pointcuts => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.after(:noop, :pointcuts => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
   
   it "should accept :within_pointcuts as a synonym for :pointcut." do
-    @aspects << after(:noop, :within_pointcuts => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.after(:noop, :within_pointcuts => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 
   it "should accept :within_pointcut as a synonym for :pointcut." do
-    @aspects << after(:noop, :within_pointcut => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)
+    @aspects << DSLClass.after(:noop, :within_pointcut => {:objects => @watchful, :methods => :public_watchful_method}, &@advice)
     @aspects[1].should == @aspects[0]
   end
 end
 
-describe Object, "#advise (or synonyms) called within a type body" do
+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, *args|
@@ -480,6 +542,7 @@ describe Object, "#advise (or synonyms) called within a type body" do
     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, *args| @@advice_called += 1}
       def public_watchful_method *args; end
@@ -491,24 +554,25 @@ describe Object, "#advise (or synonyms) called within a type body" do
   end
 end
 
-describe Object, "#pointcut" do
+describe "DSL method #pointcut" do
   class PC1; 
     def doit; end
   end
   
   it "should match equivalent join points as Pointcut.new" do
-    pointcut1 = pointcut :type => PC1, :method => :doit
+    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 PC1
+    class PC2
+      include Aquarium::Aspects::DSL::AspectDSL
       POINTCUT = pointcut :method => :doit
     end
-    pointcut2 = Aquarium::Aspects::Pointcut.new :type => PC1, :method => :doit
-    PC1::POINTCUT.join_points_matched.should     == pointcut2.join_points_matched
-    PC1::POINTCUT.join_points_not_matched.should == pointcut2.join_points_not_matched
+    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