aquarium 0.4.0 → 0.4.1

data/lib/aquarium/utils/set_utils.rb

@@ -6,14 +6,19 @@ module Aquarium
 
       # Return a set containing the input item or list of items. If the input
       # is a set or an array, it is returned. In all cases, the constructed set is a
-      # flattened version of the input and any nil elements are removed by #strip_nils.
+      # flattened version of the input and any nil elements are removed by #strip_set_nils.
       # Note that this behavior effectively converts +nil+ to +[]+.
       def make_set *value_or_set_or_array
-        strip_nils(convert_to_set(*value_or_set_or_array))
+        strip_set_nils(convert_to_set(*value_or_set_or_array))
       end
 
       # Return a new set that is a copy of the input set with all nils removed.
-      def strip_nils set
+      def strip_set_nils set
+        set.delete_if {|x| x.nil?}
+      end
+  
+      # Return a new set that is a copy of the input set with all nils removed.
+      def self.strip_set_nils set
         set.delete_if {|x| x.nil?}
       end
   

data/lib/aquarium/version.rb

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

data/spec/aquarium/aspects/aspect_invocation_spec.rb

@@ -31,7 +31,7 @@ end
 
 module Aquarium
   class AspectInvocationTestClass
-    include Aquarium::Aspects::DSL::AspectDSL
+    include Aquarium::DSL
     attr_accessor :public_test_method_args
     def public_test_method *args; @args=args; end
     protected
@@ -42,6 +42,16 @@ module Aquarium
     def self.private_class_test_method *args; end
     private_class_method :private_class_test_method
   end
+  class AspectInvocationTestClass2
+    include Aquarium::DSL
+    attr_accessor :public_test_method_args
+    def public_test_method *args; @args=args; end
+  end
+  class AspectInvocationTestClass3
+    attr_accessor :public_test_method_args
+    attr_accessor :public_test_method_args2
+    def public_test_method *args; @args=args; end
+  end
 end
 
 describe Aspect, "methods" do
@@ -60,15 +70,15 @@ describe Aspect, "methods" do
     end
   
     it "should warn about no join point matches if the :ignore_no_matching_join_points is not specified." do
-      lambda {Aspect.new(:after, :logger_stream => @log_stream) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+      lambda {Aspect.new(:after, :logger_stream => @log_stream) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
       @log_stream.string.should_not be_empty
     end
     it "should warn about no join point matches if :ignore_no_matching_join_points => false is specified." do
-      lambda {Aspect.new(:after, :logger_stream => @log_stream, :ignore_no_matching_join_points => false) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+      lambda {Aspect.new(:after, :logger_stream => @log_stream, :ignore_no_matching_join_points => false) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
       @log_stream.string.should_not be_empty
     end
     it "should not warn about no join point matches if :ignore_no_matching_join_points => true is specified." do
-      lambda {Aspect.new(:after, :logger_stream => @log_stream, :ignore_no_matching_join_points => true) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+      lambda {Aspect.new(:after, :logger_stream => @log_stream, :ignore_no_matching_join_points => true) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
       @log_stream.string.should be_empty
     end
   end
@@ -111,10 +121,18 @@ describe Aspect, "methods" do
       lambda { Aspect.new :before, :after_raising => Exception, :pointcut => @pointcut_opts, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
     end
   
-    it "should accept a a list of exceptions specified with :after_raising." do
+    it "should accept a list of exceptions specified with :after_raising." do
       lambda { Aspect.new :before, :after_raising => [Exception, String], :pointcut => @pointcut_opts, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
     end
-  end
+
+    it "should accept a separate :exceptions => list of exceptions specified with :after_raising." do
+      lambda { Aspect.new :before, :after_raising, :exceptions => [Exception, String], :pointcut => @pointcut_opts, :noop => true }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    end
+
+    it "should reject the :exceptions argument unless specified with :after_raising." do
+      lambda { Aspect.new :before, :after, :exceptions => [Exception, String], :pointcut => @pointcut_opts, :noop => true }.should raise_error(Aquarium::Utils::InvalidOptions)
+    end
+end
 
   describe Aspect, ".new (parameters that specify pointcuts)" do
     before :all do
@@ -122,22 +140,83 @@ describe Aspect, "methods" do
     end
     
     it "should contain at least one of :method(s), :pointcut(s), :type(s), or :object(s)." do
-      lambda {Aspect.new(:after, :ignore_no_matching_join_points => true) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+      lambda {Aspect.new(:after, :ignore_no_matching_join_points => true) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
     end
 
     it "should contain at least one of :pointcut(s), :type(s), or :object(s) unless :default_objects => object is given." do
-      aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass.new, :methods => :public_test_method, :noop => true) {|jp, obj, *args| true}
+      aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass.new, :method => :public_test_method, :noop => true) {true}
+    end
+
+    it "should ignore the :default_objects if at least one other :object is given and the :default_objects are objects." do
+      object1 = Aquarium::AspectInvocationTestClass.new
+      object2 = Aquarium::AspectInvocationTestClass2.new
+      aspect = Aspect.new(:after, :default_objects => object1, :object => object2, :method => :public_test_method) {true}
+      aspect.join_points_matched.size.should == 1
+      aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == object1}
+    end
+
+    it "should ignore the :default_objects if at least one other :object is given and the :default_objects are types." do
+      object = Aquarium::AspectInvocationTestClass2.new
+      aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass, 
+        :object => object, :method => :public_test_method) {true}
+      aspect.join_points_matched.size.should == 1
+      aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == Aquarium::AspectInvocationTestClass}
+    end
+
+    it "should ignore the :default_objects if at least one :pointcut is given and the :default_objects are objects." do
+      object = Aquarium::AspectInvocationTestClass.new
+      aspect = Aspect.new(:after, :default_objects => object, 
+        :pointcut => {:type => Aquarium::AspectInvocationTestClass2, :method => :public_test_method}, :method => :public_test_method) {true}
+      aspect.join_points_matched.size.should == 1
+      aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == object}
+    end
+
+    it "should ignore the :default_objects if at least one :pointcut is given and the :default_objects are types." do
+      aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass, 
+        :pointcut => {:type => Aquarium::AspectInvocationTestClass2, :method => :public_test_method}, :method => :public_test_method) {true}
+      aspect.join_points_matched.size.should == 1
+      aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == Aquarium::AspectInvocationTestClass}
+    end
+
+    it "should ignore the :default_objects if at least one :join_point is given and the :default_objects are objects." do
+      join_point = JoinPoint.new :type => Aquarium::AspectInvocationTestClass2, :method => :public_test_method
+      object = Aquarium::AspectInvocationTestClass.new
+      aspect = Aspect.new(:after, :default_objects => object, :join_point => join_point, :method => :public_test_method) {true}
+      aspect.join_points_matched.size.should == 1
+      aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == object}
+    end
+
+    it "should ignore the :default_objects if at least one :join_point is given and the :default_objects are types." do
+      join_point = JoinPoint.new :type => Aquarium::AspectInvocationTestClass2, :method => :public_test_method
+      aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass, :join_point => join_point, :method => :public_test_method) {true}
+      aspect.join_points_matched.size.should == 1
+      aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == Aquarium::AspectInvocationTestClass}
+    end
+
+    [:type, :type_and_descendents, :type_and_ancestors].each do |type_key|
+      it "should ignore the :default_objects if at least one :#{type_key} is given and the :default_objects are objects." do
+        object = Aquarium::AspectInvocationTestClass.new
+        aspect = Aspect.new(:after, :default_objects => object, type_key => Aquarium::AspectInvocationTestClass2, :method => :public_test_method, :method => :public_test_method) {true}
+        aspect.join_points_matched.size.should == 1
+        aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == object}
+      end
+
+      it "should ignore the :default_objects if at least one :#{type_key} is given and the :default_objects are types." do
+        aspect = Aspect.new(:after, :default_objects => Aquarium::AspectInvocationTestClass, type_key => Aquarium::AspectInvocationTestClass2, :method => :public_test_method, :method => :public_test_method) {true}
+        aspect.join_points_matched.size.should == 1
+        aspect.join_points_matched.each {|jp| jp.type_or_object.should_not == Aquarium::AspectInvocationTestClass}
+      end
     end
 
     Aspect::CANONICAL_OPTIONS["default_objects"].each do |key|
       it "should accept :#{key} as a synonym for :default_objects." do
-        aspect = Aspect.new(:after, key.intern => Aquarium::AspectInvocationTestClass.new, :methods => :public_test_method, :noop => true) {|jp, obj, *args| true}
+        aspect = Aspect.new(:after, key.intern => Aquarium::AspectInvocationTestClass.new, :method => :public_test_method, :noop => true) {true}
       end
     end
   
     it "should not contain :pointcut(s) and either :type(s) or :object(s)." do
-      lambda {Aspect.new(:after, :pointcuts => @pointcut_opts, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
-      lambda {Aspect.new(:after, :pointcuts => @pointcut_opts, :object => Aquarium::AspectInvocationTestClass.new, :methods => :public_test_method) {|jp, obj, *args| true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+      lambda {Aspect.new(:after, :pointcuts => @pointcut_opts, :type => Aquarium::AspectInvocationTestClass, :method => :public_test_method) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
+      lambda {Aspect.new(:after, :pointcuts => @pointcut_opts, :object => Aquarium::AspectInvocationTestClass.new, :method => :public_test_method) {true}}.should raise_error(Aquarium::Utils::InvalidOptions)
     end
   end
 
@@ -218,6 +297,18 @@ describe Aspect, "methods" do
       end
     end
 
+    it "should require the values for :reading => ... and :writing => ... to be equal if both are specified." do
+      @advice = Proc.new {}
+      lambda {Aspect.new :before, :type => Aquarium::AspectInvocationTestClass3, 
+        :reading => :public_test_method_args, :writing => :public_test_method_args2, :advice => @advice}.should raise_error(Aquarium::Utils::InvalidOptions)
+    end
+
+    it "should require the values for :reading => ... and :changing => ... to be equal if both are specified." do
+      @advice = Proc.new {}
+      lambda {Aspect.new :before, :type => Aquarium::AspectInvocationTestClass3, 
+        :reading => :public_test_method_args, :changing => :public_test_method_args2, :advice => @advice}.should raise_error(Aquarium::Utils::InvalidOptions)
+    end
+
     it "should accept :reading => ... as a synonym for :attributes => ..., :attribute_options => [:readers]." do
       @advice = Proc.new {}
       @expected_methods = [:public_test_method_args]
@@ -1283,12 +1374,11 @@ describe Aspect, "methods" do
       advice_called.should be_true
       aspect.unadvise
     end
-
   end
 
   describe Aspect, ".new (advice block or proc parameter list)" do  
     it "should raise unless an advice block or :advice => advice parameter is specified." do
-      lambda {Aspect.new(:after, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_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
 
     it "should raise if obsolete |jp, *args| list is used." do
@@ -1315,7 +1405,14 @@ describe Aspect, "methods" do
       lambda { Aspect.new :before, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method, :noop => true do; end }.should_not raise_error(Exception)
     end
   end
-
+  
+  describe Aspect, ".new (advice block to around advice with just the join_point parameter - Bug #19262)" do  
+    it "should work not raise an error" do
+      aspect = Aspect.new :around, :type => Aquarium::AspectInvocationTestClass, :methods => :public_test_method do |jp|; jp.proceed; end
+      Aquarium::AspectInvocationTestClass.new.public_test_method
+      aspect.unadvise
+    end
+  end
 
   class ExcludeBase
     def doit; end

data/spec/aquarium/aspects/aspect_spec.rb

@@ -220,6 +220,10 @@ describe Aspect, " with :after_returning advice" do
   end
 end
 
+class MyError1 < StandardError; end
+class MyError2 < StandardError; end
+class MyError3 < StandardError; end
+
 describe Aspect, " with :after_raising advice" do  
   after(:each) do
     @aspect.unadvise if @aspect
@@ -248,10 +252,39 @@ describe Aspect, " with :after_raising advice" do
     do_watchful_public_protected_private true
   end
   
-  it "should not advise rescue clauses for raised exceptions of types that don't match the specified exception" do
-    class MyError < StandardError; end
+  it "should invoke advice when exceptions of the specified type are raised" do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new(:after_raising => Watchful::WatchfulError, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
+    block_invoked = false
+    watchful = Watchful.new
+    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_true
+    block_invoked.should be_true
+  end
+  
+  it "should invoke advice when exceptions of the specified type are raised, which were specified with :exceptions => ..." do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new(:after_raising, :exceptions => Watchful::WatchfulError, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
+    block_invoked = false
+    watchful = Watchful.new
+    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_true
+    block_invoked.should be_true
+  end
+  
+  it "should not invoke advice when exceptions of types that don't match the specified exception type are raised" do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new(:after_raising => MyError1, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
+    block_invoked = false
+    watchful = Watchful.new
+    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_false
+    block_invoked.should be_true
+  end
+  
+  it "should not invoke advice when exceptions of types that don't match the specified exception type are raised, which were specified with :exceptions => ..." do
     aspect_advice_invoked = false
-    @aspect = Aspect.new(:after_raising => MyError, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
+    @aspect = Aspect.new(:after_raising, :exceptions => MyError1, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
     lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
@@ -259,9 +292,17 @@ describe Aspect, " with :after_raising advice" do
     block_invoked.should be_true
   end
   
-  it "should not advise rescue clauses for raised exceptions of types that don't match the list of specified exceptions" do
-    class MyError1 < StandardError; end
-    class MyError2 < StandardError; end
+  it "should invoke advice when one exception in the list of the specified types is raised" do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new(:after_raising => [Watchful::WatchfulError, MyError1], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
+    block_invoked = false
+    watchful = Watchful.new
+    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_true
+    block_invoked.should be_true
+  end
+  
+  it "should not invoke advice when exceptions of types that don't match the specified list of exception types are raised" do
     aspect_advice_invoked = false
     @aspect = Aspect.new(:after_raising => [MyError1, MyError2], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
@@ -271,7 +312,33 @@ describe Aspect, " with :after_raising advice" do
     block_invoked.should be_true
   end
   
-  it "should advise all rescue clauses in the matched methods, if no specific exceptions are specified" do
+  it "should not invoke advice when exceptions of types that don't match the specified list of exception types are raised, which were specified with :exceptions => ..." do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new(:after_raising, :exceptions => [MyError1, MyError2], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
+    block_invoked = false
+    watchful = Watchful.new
+    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_false
+    block_invoked.should be_true
+  end
+  
+  it "should treat :exception as a synonym for :exceptions" do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new(:after_raising, :exception => [MyError1, MyError2], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
+    block_invoked = false
+    watchful = Watchful.new
+    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_false
+    block_invoked.should be_true
+  end
+  
+  it "should merge exceptions specified with :exception(s) and :after_raising" do
+    aspect_advice_invoked = false
+    @aspect = Aspect.new(:after_raising => MyError1, :exception => [MyError2, MyError3], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
+    @aspect.specification[:after_raising].should eql(Set.new([MyError1, MyError2, MyError3]))
+  end
+  
+  it "should advise all methods that raise exceptions when no specific exceptions are specified" do
     class ClassThatRaises
       class CTRException < Exception; end
       def raises
@@ -287,6 +354,23 @@ describe Aspect, " with :after_raising advice" do
     lambda {ctr.raises}.should raise_error(ClassThatRaises::CTRException)
     aspect_advice_invoked.should be_true
   end
+
+  it "should advise all methods that raise strings (which are converted to RuntimeError) when no specific exceptions are specified" do
+    class ClassThatRaisesString
+      class CTRException < Exception; end
+      def raises
+        raise "A string exception."
+      end
+    end
+    aspect_advice_invoked = false
+    @aspect = Aspect.new :after_raising, :pointcut => {:type => ClassThatRaisesString, :methods => :raises} do |jp, obj, *args|
+      aspect_advice_invoked = true
+    end 
+    aspect_advice_invoked.should be_false
+    ctr = ClassThatRaisesString.new
+    lambda {ctr.raises}.should raise_error(RuntimeError)
+    aspect_advice_invoked.should be_true
+  end
 end
 
 describe Aspect, " with :before and :after advice" do  

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -365,6 +365,67 @@ describe Pointcut, "methods" do
     end  
   end
 
+  describe Pointcut, ".new (default_objects specified)" do
+    it "should use the :default_objects if specified and no other :join_point, :type, or :object is given." do
+      object1 = ClassWithPublicInstanceMethod.new
+      pc = Pointcut.new :default_objects => object1, :method => :public_instance_test_method
+      pc.join_points_matched.size.should == 1
+      pc.join_points_matched.each {|jp| jp.type_or_object.should == object1}
+    end
+
+    it "should ignore the :default_objects if at least one other :object is given and the :default_objects are objects." do
+      object1 = ClassWithPublicInstanceMethod.new
+      object2 = ClassWithPublicInstanceMethod.new
+      pc = Pointcut.new :default_objects => object1, :object => object2, :method => :public_instance_test_method
+      pc.join_points_matched.size.should == 1
+      pc.join_points_matched.each {|jp| jp.type_or_object.should == object2}
+    end
+
+    it "should ignore the :default_objects if at least one other :object is given and the :default_objects are types." do
+      object = ClassWithProtectedInstanceMethod.new
+      pc = Pointcut.new :default_objects => ClassWithPublicInstanceMethod, :object => object, :method => /_instance_test_method/, :method_options => [:public, :protected, :exclude_ancestor_methods]
+      pc.join_points_matched.size.should == 1
+      pc.join_points_matched.each {|jp| jp.type_or_object.should_not == ClassWithPublicInstanceMethod}
+    end
+
+    it "should ignore the :default_objects if at least one :join_point is given and the :default_objects are objects." do
+      join_point = JoinPoint.new :type => ClassWithProtectedInstanceMethod, :method => :protected_instance_test_method
+      object = ClassWithProtectedInstanceMethod.new
+      pc = Pointcut.new :default_objects => object, :join_point => join_point, :method => /_instance_test_method/, :method_options => [:public, :protected, :exclude_ancestor_methods]
+      pc.join_points_matched.size.should == 1
+      pc.join_points_matched.each {|jp| jp.type_or_object.should_not == ClassWithPublicInstanceMethod}
+    end
+
+    it "should ignore the :default_objects if at least one :pointcut is given and the :default_objects are types." do
+      join_point = JoinPoint.new :type => ClassWithProtectedInstanceMethod, :method => :protected_instance_test_method
+      object = ClassWithProtectedInstanceMethod.new
+      pc = Pointcut.new :default_objects => ClassWithPublicInstanceMethod, :join_point => join_point, :method => /_instance_test_method/, :method_options => [:public, :protected, :exclude_ancestor_methods]
+      pc.join_points_matched.size.should == 1
+      pc.join_points_matched.each {|jp| jp.type_or_object.should_not == ClassWithPublicInstanceMethod}
+    end
+
+    [:type, :type_and_descendents, :type_and_ancestors].each do |type_key|
+      it "should ignore the :default_objects if at least one :#{type_key} is given and the :default_objects are objects." do
+        object = ClassWithPublicInstanceMethod.new
+        pc = Pointcut.new :default_objects => object, type_key => ClassWithProtectedInstanceMethod, :method => /_instance_test_method/, :method_options => [:public, :protected, :exclude_ancestor_methods]
+        pc.join_points_matched.size.should == 1
+        pc.join_points_matched.each {|jp| jp.type_or_object.should_not == ClassWithPublicInstanceMethod}
+      end
+
+      it "should ignore the :default_objects if at least one :#{type_key} is given and the :default_objects are types." do
+        pc = Pointcut.new :default_objects => ClassWithPublicInstanceMethod, type_key => ClassWithProtectedInstanceMethod, :method => /_instance_test_method/, :method_options => [:public, :protected, :exclude_ancestor_methods]
+        pc.join_points_matched.size.should == 1
+        pc.join_points_matched.each {|jp| jp.type_or_object.should_not == ClassWithPublicInstanceMethod}
+      end
+    end
+
+    Aspect::CANONICAL_OPTIONS["default_objects"].each do |key|
+      it "should accept :#{key} as a synonym for :default_objects." do
+        pc = Pointcut.new key.intern => ClassWithPublicInstanceMethod.new, :method => :public_instance_test_method
+      end
+    end
+  end
+
   describe Pointcut, ".new (:exclude_types => types specified)" do
     before(:each) do
       before_exclude_spec

data/spec/aquarium/{aspects/dsl → dsl}/aspect_dsl_spec.rb

@@ -1,12 +1,12 @@
-require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../spec_example_types'
-require 'aquarium/aspects/dsl/aspect_dsl'
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/../spec_example_types'
+require 'aquarium/dsl/aspect_dsl'
 
 class DSLClass
-  include Aquarium::Aspects::DSL::AspectDSL
+  include Aquarium::DSL
 end
 
-describe "Aquarium::Aspects::DSL::AspectDSL" do
+describe "Aquarium::DSL" do
   before :all do
     @advice = proc {|jp, obj, *args| "advice"}
     @pointcut_opts = {:calls_to => :public_watchful_method, :in_type => Watchful}
@@ -20,7 +20,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
   
-    it "should be equivalent to advise :before." do
+    it "should be equivalent to advice kind :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]
@@ -35,13 +35,36 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :after." do
+    it "should be equivalent to advice kind :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
 
+  describe "DSL method #after_raising" do    
+    before :each do
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
+
+    it "should be equivalent to advice kind :after_raising." do
+      @aspects << DSLClass.advise(:after_raising, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.after_raising(         :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
+
+    it "should be equivalent to advice kind :after_raising => exceptions, when used with the :exceptions argument." do
+      @aspects << DSLClass.advise(:after_raising, :exceptions => [StandardError], :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << DSLClass.after_raising(         :exceptions => [StandardError], :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << Aquarium::Aspects::Aspect.new(:after_raising => [StandardError], :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+      @aspects[2].specification[:after_raising].should == @aspects[0].specification[:after_raising]
+    end
+  end
+
   describe "DSL method #after_raising_within_or_returning_from" do    
     before :each do
       @dsl = DSLClass.new
@@ -52,7 +75,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :after." do
+    it "should be equivalent to advice kind :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]
@@ -69,7 +92,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :after_returning." do
+    it "should be equivalent to advice kind :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]
@@ -86,7 +109,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :after_returning." do
+    it "should be equivalent to advice kind :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]
@@ -103,7 +126,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :after_raising." do
+    it "should be equivalent to advice kind :after_raising." do
       class ThrowsUp
         def tosses_cookies *args; raise Exception.new(args.inspect); end
       end
@@ -123,7 +146,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :after_raising." do
+    it "should be equivalent to advice kind :after_raising." do
       class ThrowsUp
         def tosses_cookies *args; raise Exception.new(args.inspect); end
       end
@@ -143,7 +166,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :before, :after." do
+    it "should be equivalent to advice kind :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]
@@ -160,7 +183,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :before and advise :after." do
+    it "should be equivalent to advice kind :before and advice :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]
@@ -177,7 +200,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :before and advise :after_returning." do
+    it "should be equivalent to advice kind :before and advice :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]
@@ -194,7 +217,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :before and advise :after_returning." do
+    it "should be equivalent to advice kind :before and advice :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]
@@ -211,7 +234,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :before and advise :after_raising." do
+    it "should be equivalent to advice kind :before and advice :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]
@@ -228,7 +251,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       @aspects.each {|a| a.unadvise}
     end
 
-    it "should be equivalent to advise :around." do
+    it "should be equivalent to advice kind :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]
@@ -245,7 +268,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
   
     it "should ignore the default object \"self\" when an :object is specified." do
       class Watchful1
-        include Aquarium::Aspects::DSL::AspectDSL
+        include Aquarium::DSL
         def public_watchful_method; end
         @@watchful = Watchful1.new
         @@aspect = after(:invoking => :public_watchful_method, :on_object => @@watchful) {|jp, obj, *args|}
@@ -261,7 +284,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
 
     it "should ignore the default object \"self\" when a :type is specified." do
       class Watchful2
-        include Aquarium::Aspects::DSL::AspectDSL
+        include Aquarium::DSL
         def public_watchful_method; end
         @@aspect = after(:calls_to => :public_watchful_method, :in_type => Watchful2) {|jp, obj, *args|}
         def self.aspect; @@aspect; end
@@ -282,7 +305,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
     end
 
     class WatchfulSelf
-      include Aquarium::Aspects::DSL::AspectDSL
+      include Aquarium::DSL
       @@aspect = nil
       def self.aspect; @@aspect; end
       def public_watchful_method; "public_watchful_method"; end
@@ -300,7 +323,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
 
     it "should infer the object as \"self\" when no :object, :type, or :pointcut is specified." do
       watchful_self = WatchfulSelf.new
-      watchful_self.extend Aquarium::Aspects::DSL::AspectDSL
+      watchful_self.extend Aquarium::DSL
       @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
@@ -314,7 +337,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
 
   describe "DSL method #advise, when parsing the parameter list," do    
     class Watchful3
-      include Aquarium::Aspects::DSL::AspectDSL
+      include Aquarium::DSL
       def public_watchful_method; "public_watchful_method"; end
     end
 
@@ -344,7 +367,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
 
     it "should treat \"ClassName.advise\" as advising instance methods, by default." do
       class WatchfulExampleWithSeparateAdviseCall
-        include Aquarium::Aspects::DSL::AspectDSL
+        include Aquarium::DSL
         def public_watchful_method *args; end
       end
       advice_called = 0
@@ -358,7 +381,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" 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
+        include Aquarium::DSL
         def self.class_public_watchful_method *args; end
         def public_watchful_method *args; end
       end
@@ -376,7 +399,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
   
     it "should treat \"ClassName.advise\" as advising class methods when the :class method option is specified." do
       class WatchfulExampleWithSeparateAdviseCall3
-        include Aquarium::Aspects::DSL::AspectDSL
+        include Aquarium::DSL
         def self.class_public_watchful_method *args; end
         def public_watchful_method *args; end
       end
@@ -394,7 +417,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
   
     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
+        include Aquarium::DSL
         @@advice_called = 0
         def public_watchful_method *args; end
         before :public_watchful_method do |jp, obj, *args|
@@ -410,7 +433,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
 
   describe "DSL methods for the advice kind, when determining instance or class methods to advise," do    
     class Watchful4
-      include Aquarium::Aspects::DSL::AspectDSL
+      include Aquarium::DSL
       def public_watchful_method; "public_watchful_method"; end
     end
 
@@ -490,7 +513,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" 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
+        include Aquarium::DSL
         @@advice_called = 0
         def public_watchful_method *args; end
         before :public_watchful_method do |jp, obj, *args|
@@ -502,7 +525,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       WatchfulWithMethodAlreadyDefined.new.public_watchful_method :a3, :a4
       WatchfulWithMethodAlreadyDefined.advice_called.should == 2
       class WatchfulWithMethodNotYetDefined
-        include Aquarium::Aspects::DSL::AspectDSL
+        include Aquarium::DSL
         @@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
@@ -528,7 +551,7 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
   
     it "should use self as the object if no object or type is specified." do
       class PC2
-        include Aquarium::Aspects::DSL::AspectDSL
+        include Aquarium::DSL
         POINTCUT = pointcut :method => :doit
       end
       pointcut2 = Aquarium::Aspects::Pointcut.new :type => PC2, :method => :doit
@@ -536,4 +559,25 @@ describe "Aquarium::Aspects::DSL::AspectDSL" do
       PC2::POINTCUT.join_points_not_matched.should == pointcut2.join_points_not_matched
     end
   end
-end
+  
+  class OldDSLClass
+    include Aquarium::Aspects::DSL::AspectDSL
+  end
+  describe "DSL methods available through the old package Aquarium::Aspects::DSL::AspectDSL" do    
+    before :each do
+      @dsl = OldDSLClass.new
+      @advice = proc {|jp, obj, *args| "advice"}
+      @aspects = []
+    end
+    after :each do
+      @aspects.each {|a| a.unadvise}
+    end
+
+    it "should be equivalent to advice kind :around." do
+      @aspects << OldDSLClass.advise(:around, :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects << OldDSLClass.around(         :noop => true, :pointcut => @pointcut_opts, &@advice)
+      @aspects[1].should == @aspects[0]
+    end
+  end
+end
+