aquarium 0.1.7 → 0.1.8

data/spec/aquarium/aspects/concurrent_aspects_with_objects_and_types_spec.rb

@@ -20,13 +20,14 @@ describe "Advising an object join point and then the corresponding type join poi
     @aspects = []
     @invoked = []
     @accessed = ConcurrentlyAccessed.new
+    @accessed2 = ConcurrentlyAccessed.new
   end
   after :each do
     @aspects.each {|a| a.unadvise}
   end
   
   Aquarium::Aspects::Advice.kinds.each do |advice_kind|
-    it "should invoke only the advice on the object join point for :#{advice_kind} advice" do
+    it "should invoke both the :#{advice_kind} advices when the object join point is invoked" do
       method = advice_kind == :after_raising ? :invoke_raises : :invoke
       @aspects << make_aspect(method, advice_kind, :object, @accessed)
       @aspects << make_aspect(method, advice_kind, :type,   ConcurrentlyAccessed)
@@ -36,7 +37,22 @@ describe "Advising an object join point and then the corresponding type join poi
       rescue ConcurrentlyAccessed::Error
         fail unless advice_kind == :after_raising 
       end
-      @invoked.should == [:object]
+      @invoked.sort.should == [:object, :type]
+    end
+  end  
+  
+  Aquarium::Aspects::Advice.kinds.each do |advice_kind|
+    it "should invoke only the :#{advice_kind} type advice when a different object is invoked" do
+      method = advice_kind == :after_raising ? :invoke_raises : :invoke
+      @aspects << make_aspect(method, advice_kind, :object, @accessed2)
+      @aspects << make_aspect(method, advice_kind, :type,   ConcurrentlyAccessed)
+      begin
+        @accessed.method(method).call :a1, :a2
+        fail if advice_kind == :after_raising 
+      rescue ConcurrentlyAccessed::Error
+        fail unless advice_kind == :after_raising 
+      end
+      @invoked.should == [:type]
     end
   end  
 end

data/spec/aquarium/aspects/join_point_spec.rb

@@ -265,14 +265,56 @@ describe Aquarium::Aspects::JoinPoint, "#<=>" do
     @jp3 = Aquarium::Aspects::JoinPoint.new :type => Array, :method_name => :size
     @jp4 = Aquarium::Aspects::JoinPoint.new :object => [],  :method_name => :size
     @jp5 = Aquarium::Aspects::JoinPoint.new :object => [],  :method_name => :size
+    dummy = Dummy.new
+    @jp6 = Aquarium::Aspects::JoinPoint.new :object => dummy,  :method_name => :size
+    @jp7 = Aquarium::Aspects::JoinPoint.new :object => dummy,  :method_name => :size
+    context_opts = {
+      :advice_kind => :before, 
+      :advised_object => dummy, 
+      :parameters => [], 
+      :block_for_method => nil, 
+      :returned_value => nil, 
+      :raised_exception => nil, 
+      :proceed_proc => nil
+    }
+    @jp1b = @jp1.make_current_context_join_point context_opts
+    @jp2b = @jp2.make_current_context_join_point context_opts
+    @jp6b = @jp6.make_current_context_join_point context_opts
+    @jp7b = @jp7.make_current_context_join_point context_opts
   end
   
-  it "should sort return 0 for the same join points" do
-    (@jp1.<=>@jp1).should == 0
+  it "should return 1 of the second object is nil" do
+    (@jp1 <=> nil).should == 1
   end
   
-  it "should sort return 0 for equivalent join points" do
-    (@jp1.<=>@jp2).should == 0
+  it "should return 0 for the same join point with no context" do
+    (@jp1 <=> @jp1).should == 0
+    (@jp6 <=> @jp6).should == 0
+  end
+  
+  it "should return 0 for the same join point with equivalent contexts" do
+    (@jp1b <=> @jp1b).should == 0
+    (@jp6b <=> @jp6b).should == 0
+  end
+  
+  it "should return 0 for equivalent join points with no context" do
+    (@jp1 <=>@jp2).should == 0
+    (@jp6 <=>@jp7).should == 0
+  end
+  
+  it "should return 0 for equivalent join points with equivalent contexts" do
+    (@jp1b <=> @jp2b).should == 0
+    (@jp6b <=> @jp7b).should == 0
+  end
+  
+  it "should return +1 for join points that equivalent except for the context, where the first join point has a context and the second does not" do
+    (@jp1b <=> @jp2).should == 1
+    (@jp6b <=> @jp7).should == 1
+  end
+  
+  it "should return -1 for join points that equivalent except for the context, where the second join point has a context and the first does not" do
+    (@jp1 <=> @jp2b).should == -1
+    (@jp6 <=> @jp6b).should == -1
   end
   
   it "should sort by type name first" do

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -6,22 +6,6 @@ require 'aquarium/aspects/join_point'
 require 'aquarium/aspects/pointcut'
 require 'aquarium/utils'
 
-class ExcludeTestOne
-  def method11; end
-  def method12; end
-  def method13; end
-end
-class ExcludeTestTwo
-  def method21; end
-  def method22; end
-  def method23; end
-end
-class ExcludeTestThree
-  def method31; end
-  def method32; end
-  def method33; end
-end
-
 def before_exclude_spec
   @jp11  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestOne,   :method_name => :method11
   @jp12  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestOne,   :method_name => :method12
@@ -371,28 +355,25 @@ describe Aquarium::Aspects::Pointcut, " (:exclude_join_points => join_points spe
 
   it "should remove from a list of explicitly-specified join points the set of explicitly-specified excluded join points." do
     excluded = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
+    expected = [@jp11, @jp13, @jp21, @jp22, @jp23, @jp31, @jp32, @ojp12, @ojp21, @ojp22, @ojp31, @ojp32, @ojp33]
     pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_join_points => excluded
-    pc.join_points_matched.should == Set.new(@all_jps - excluded)
+    pc.join_points_matched.should == Set.new(expected)
     pc.join_points_not_matched.size.should == 0
   end
   
   it "should remove from the list of generated, type-based join points the set of explicitly-specified excluded join points." do
-    jp11  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestOne,   :method_name => :method11
-    jp22  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestTwo,   :method_name => :method22
-    jp33  = Aquarium::Aspects::JoinPoint.new :type   => ExcludeTestThree, :method_name => :method33
-    excluded = [jp11, jp22, jp33]
+    excluded = [@jp11, @jp22, @jp33]
+    expected = [@jp12, @jp13, @jp21, @jp23, @jp31, @jp32]
     pc = Aquarium::Aspects::Pointcut.new :types => /ExcludeTest/, :exclude_join_points => excluded, :method_options => :exclude_ancestor_methods
-    pc.join_points_matched.should == Set.new(@all_type_jps - excluded)
+    pc.join_points_matched.should == Set.new(expected)
     pc.join_points_not_matched.size.should == 0
   end
 
   it "should remove from the list of generated, object-based join points the set of explicitly-specified excluded join points." do
-    ojp12 = Aquarium::Aspects::JoinPoint.new :object => @et1, :method_name => :method12
-    ojp23 = Aquarium::Aspects::JoinPoint.new :object => @et2, :method_name => :method23
-    ojp31 = Aquarium::Aspects::JoinPoint.new :object => @et3, :method_name => :method31
-    excluded = [ojp12, ojp23, ojp31]  
+    excluded = [@ojp12, @ojp23, @ojp31]  
+    expected = [@ojp11, @ojp13, @ojp21, @ojp22, @ojp32, @ojp33]
     pc = Aquarium::Aspects::Pointcut.new :objects => [@et1, @et2, @et3], :exclude_join_points => excluded, :method_options => :exclude_ancestor_methods
-    pc.join_points_matched.should == Set.new(@all_object_jps - excluded)
+    pc.join_points_matched.should == Set.new(expected)
     pc.join_points_not_matched.size.should == 0
   end
   
@@ -404,8 +385,66 @@ describe Aquarium::Aspects::Pointcut, " (:exclude_join_points => join_points spe
   
   it "should be a synonym for :exclude_join_point." do
     excluded = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
+    expected = [@jp11, @jp13, @jp21, @jp22, @jp23, @jp31, @jp32, @ojp12, @ojp21, @ojp22, @ojp31, @ojp32, @ojp33]
     pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_join_point => excluded
-    pc.join_points_matched.should == Set.new(@all_jps - excluded)
+    pc.join_points_matched.should == Set.new(expected)
+    pc.join_points_not_matched.size.should == 0
+  end
+end
+
+
+describe Aquarium::Aspects::Pointcut, " (:exclude_pointcuts => pointcuts specified)" do
+  before(:each) do
+    before_exclude_spec
+  end
+
+  it "should remove from a list of explicitly-specified join points the set of explicitly-specified excluded pointcuts." do
+    excluded_jps = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
+    excluded = Aquarium::Aspects::Pointcut.new :join_points => excluded_jps
+    expected = [@jp11, @jp13, @jp21, @jp22, @jp23, @jp31, @jp32, @ojp12, @ojp21, @ojp22, @ojp31, @ojp32, @ojp33]
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_pointcuts => excluded
+    pc.join_points_matched.should == Set.new(expected)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from the list of generated, type-based join points the set of explicitly-specified excluded pointcuts." do
+    excluded_jps = [@jp11, @jp22, @jp33]
+    excluded = Aquarium::Aspects::Pointcut.new :join_points => excluded_jps
+    expected = [@jp12, @jp13, @jp21, @jp23, @jp31, @jp32]
+    pc = Aquarium::Aspects::Pointcut.new :types => /ExcludeTest/, :exclude_pointcuts => excluded, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == Set.new(expected)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should remove from the list of generated, object-based join points the set of explicitly-specified excluded pointcuts." do
+    excluded_jps = [@ojp12, @ojp23, @ojp31]  
+    excluded = Aquarium::Aspects::Pointcut.new :join_points => excluded_jps
+    expected = [@ojp11, @ojp13, @ojp21, @ojp22, @ojp32, @ojp33]
+    pc = Aquarium::Aspects::Pointcut.new :objects => [@et1, @et2, @et3], :exclude_pointcuts => excluded, :method_options => :exclude_ancestor_methods
+    pc.join_points_matched.should == Set.new(expected)
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should not add excluded types to the #not_matched results." do
+    excluded_jps = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
+    excluded = Aquarium::Aspects::Pointcut.new :join_points => excluded_jps
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_pointcuts => excluded
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should result in an empty pointcut if the join points in the :exclude_pointcuts are a superset of the matched join points." do
+    excluded = Aquarium::Aspects::Pointcut.new :join_points => @all_jps
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_pointcut => excluded
+    pc.join_points_matched.size.should == 0
+    pc.join_points_not_matched.size.should == 0
+  end
+  
+  it "should be a synonym for :exclude_pointcut." do
+    excluded_jps = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
+    excluded = Aquarium::Aspects::Pointcut.new :join_points => excluded_jps
+    expected = [@jp11, @jp13, @jp21, @jp22, @jp23, @jp31, @jp32, @ojp12, @ojp21, @ojp22, @ojp31, @ojp32, @ojp33]
+    pc = Aquarium::Aspects::Pointcut.new :join_points => @all_jps, :exclude_pointcut => excluded
+    pc.join_points_matched.should == Set.new(expected)
     pc.join_points_not_matched.size.should == 0
   end
 end
@@ -898,7 +937,7 @@ describe Aquarium::Aspects::Pointcut, "#eql?" do
     pc1.should be_eql(pc2)
   end
   
-  it "should return false for Aquarium::Aspects::Pointcuts that specify different types." do
+  it "should return false if the matched types are different." do
     pc1 = Aquarium::Aspects::Pointcut.new  :types => /ClassWithPublicMethod/
     pc2 = Aquarium::Aspects::Pointcut.new  :types => /Class.*Method/
     pc1.should_not eql(pc2)
@@ -928,18 +967,19 @@ describe Aquarium::Aspects::Pointcut, "#eql?" do
     pc1.should_not eql(pc2)
   end
   
-  it "should return false if the matched types are different." do
-    pc1 = Aquarium::Aspects::Pointcut.new  :types => /ClassWithPublicMethod/
-    pc2 = Aquarium::Aspects::Pointcut.new  :types => /Class.*Method/
-    pc1.should_not eql(pc2)
-  end
-  
-  it "should return false if the matched objects are different." do
+  it "should return false if the matched objects are different objects." do
     pc1 = Aquarium::Aspects::Pointcut.new  :object => ClassWithPublicClassMethod.new, :methods => /_test_method$/
     pc2 = Aquarium::Aspects::Pointcut.new  :object => ClassWithPrivateClassMethod.new, :methods => /_test_method$/
     pc1.should_not eql(pc2)
   end
 
+  it "should return true if the matched objects are the same object." do
+    object = ClassWithPublicClassMethod.new
+    pc1 = Aquarium::Aspects::Pointcut.new  :object => object, :methods => /_test_method$/
+    pc2 = Aquarium::Aspects::Pointcut.new  :object => object, :methods => /_test_method$/
+    pc1.should eql(pc2)
+  end
+
   it "should return false if the not_matched types are different." do
     pc1 = Aquarium::Aspects::Pointcut.new  :types => :UnknownFoo
     pc2 = Aquarium::Aspects::Pointcut.new  :types => :UnknownBar
@@ -1100,8 +1140,9 @@ describe Aquarium::Aspects::Pointcut, "#specification" do
       :exclude_types => @empty_set,
       :exclude_objects => @empty_set,
       :exclude_join_points => @empty_set,
+      :exclude_pointcuts => @empty_set,
       :exclude_methods => @empty_set,
-      :default_object => @empty_set} 
+      :default_objects => @empty_set} 
     @default_specification_all_methods = { :methods => Set.new([:all]) } | @default_specification
   end
 
@@ -1130,13 +1171,13 @@ describe Aquarium::Aspects::Pointcut, "#specification" do
   it "should return the input :method_options verbatim." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :methods => /^get/, :method => "dup", :method_options => [:instance, :public]
     pc.specification.should == { :types => Set.new(@example_types), :methods => Set.new([/^get/, "dup"]), 
-        :method_options => Set.new([:instance, :public]), :default_object => @empty_set } | @default_specification
+        :method_options => Set.new([:instance, :public]), :default_objects => @empty_set } | @default_specification
   end
   
   it "should return the input :methods and :method arguments combined into an array keyed by :methods." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :attributes => /^state/, :attribute => "name"
     pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :join_points => @empty_set,
-      :methods => @empty_set, :method_options => Set.new([]), :default_object => @empty_set,
+      :methods => @empty_set, :method_options => Set.new([]), :default_objects => @empty_set,
       :attributes => Set.new([/^state/, "name"]), :attribute_options => @empty_set } | @default_specification
   end
   

data/spec/aquarium/finders/method_finder_spec.rb

@@ -294,6 +294,12 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for instance methods
     actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => /instance_test_method/
     actual.matched.size.should == 1
     actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+    actual2 = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => /instance_test/
+    actual2.matched.size.should == 1
+    actual2.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
+    actual3 = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => /test_method/
+    actual3.matched.size.should == 1
+    actual3.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
   end
   
   it "should find only one instance method for an object when searching with a regexp matching one method." do
@@ -443,7 +449,15 @@ describe Aquarium::Finders::MethodFinder, "#find for types (using :exclude_metho
     actual.not_matched.size.should == 0
   end
   
-  it "should remove excluded methods from the result where the excluded methods are specified by name." do
+  it "should remove excluded methods from the result where a single excluded methods is specified by name." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_method => :method1, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[ExcludeMethodTester].size.should == 2
+    actual.matched[ExcludeMethodTester].should == Set.new([:method2, :method3])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should remove excluded methods from the result where the excluded methods are specified by an array of names." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_methods => [:method1, :method2], :options => :exclude_ancestor_methods
     actual.matched.size.should == 1
     actual.matched[ExcludeMethodTester].size.should == 1
@@ -480,7 +494,16 @@ describe Aquarium::Finders::MethodFinder, "#find for objects (using :exclude_met
     actual.not_matched.size.should == 0
   end
   
-  it "should remove excluded methods from the result where the excluded methods are specified by name." do
+  it "should remove excluded methods from the result where a single excluded methods is specified by name." do
+    emt = ExcludeMethodTester.new
+    actual = Aquarium::Finders::MethodFinder.new.find :object => emt, :methods => :all, :exclude_method => :method1, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 1
+    actual.matched[emt].size.should == 2
+    actual.matched[emt].should == Set.new([:method2, :method3])
+    actual.not_matched.size.should == 0
+  end
+  
+  it "should remove excluded methods from the result where the excluded methods are specified by an array of names." do
     emt = ExcludeMethodTester.new
     actual = Aquarium::Finders::MethodFinder.new.find :object => emt, :methods => :all, :exclude_methods => [:method1, :method2], :options => :exclude_ancestor_methods
     actual.matched.size.should == 1

data/spec/aquarium/finders/type_finder_spec.rb

@@ -289,7 +289,7 @@ describe Aquarium::Finders::TypeFinder, "#find_by_type" do
   end
 end
 
-# TODO refactor this protected method into a new class.
+# This is a spec for a protected method.
 describe Aquarium::Finders::TypeFinder, "#get_type_from_parent should" do
   it "should raise if a type doesn't exist that matches the constant" do
     lambda {Aquarium::Finders::TypeFinder.new.send(:get_type_from_parent, Aquarium::Finders, "Nonexistent", /Non/)}.should raise_error(NameError)

data/spec/aquarium/spec_example_classes.rb

@@ -119,3 +119,20 @@ class Watchful
 end
 
 class WatchfulChild < Watchful; end
+
+class ExcludeTestOne
+  def method11; end
+  def method12; end
+  def method13; end
+end
+class ExcludeTestTwo
+  def method21; end
+  def method22; end
+  def method23; end
+end
+class ExcludeTestThree
+  def method31; end
+  def method32; end
+  def method33; end
+end
+

data/spec/aquarium/utils/method_utils_spec.rb

@@ -45,129 +45,353 @@ describe Aquarium::Utils::MethodUtils, ".method_args_to_hash" do
     
   it "should return a hash with the non-hash arguments mapped to key-value pairs with value specified by the input block (or null) and the input unchanged." do
     Aquarium::Utils::MethodUtils.method_args_to_hash(:x, :y, :a =>'a', :b => 'b'){|a| a.to_s.capitalize}.should == {:a => 'a', :b => 'b', :x => 'X', :y => 'Y'}
-  end
-    
+  end    
+end
+
+class MethodUtilsSpecProtectionExample
+  def public_instance_m; end
+  protected
+  def protected_instance_m; end
+  private
+  def private_instance_m; end
+  def self.public_class_m; end
+  def self.private_class_m; end
+  private_class_method :private_class_m
+end
+class MethodUtilsSpecProtectionExample2 < MethodUtilsSpecProtectionExample
 end
 
 describe Aquarium::Utils::MethodUtils, ".visibility" do
-  class ProtectionExample
-    def public_instance_m; end
-    protected
-    def protected_instance_m; end
-    private
-    def private_instance_m; end
-    def self.public_class_m; end
-    def self.private_class_m; end
-    private_class_method :private_class_m
-  end
-  
   it "should return :public for public class methods on a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_class_m).should == :public
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :public_class_m).should == :public
   end
   it "should return :public for public class methods on a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_class_m, :class_method_only).should == :public
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :public_class_m, :class_method_only).should == :public
   end
   it "should return nil for public class methods on a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_class_m, :instance_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :public_class_m, :instance_method_only).should be_nil
   end
 
   it "should return :public for public instance methods on a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_instance_m).should == :public
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :public_instance_m).should == :public
   end
   it "should return nil for public instance methods on a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_instance_m, :class_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :public_instance_m, :class_method_only).should be_nil
   end
   it "should return :public for public instance methods on a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :public_instance_m, :instance_method_only).should == :public
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :public_instance_m, :instance_method_only).should == :public
   end
 
   it "should return nil for public class methods on an instance of a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_class_m).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :public_class_m).should be_nil
   end
   it "should return nil for public class methods on an instance of a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_class_m, :class_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :public_class_m, :class_method_only).should be_nil
   end
   it "should return nil for public class methods on an instance of a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_class_m, :instance_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :public_class_m, :instance_method_only).should be_nil
   end
 
   it "should return :public for public instance methods on an instance of a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_instance_m).should == :public    
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :public_instance_m).should == :public    
   end
   it "should return nil for public instance methods on an instance of a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_instance_m, :class_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :public_instance_m, :class_method_only).should be_nil
   end
   it "should return :public for public instance methods on an instance of a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :public_instance_m, :instance_method_only).should == :public    
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :public_instance_m, :instance_method_only).should == :public    
   end
   
   it "should return :protected for protected instance methods on a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :protected_instance_m).should == :protected
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :protected_instance_m).should == :protected
   end
   it "should return nil for protected instance methods on a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :protected_instance_m, :class_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :protected_instance_m, :class_method_only).should be_nil
   end
   it "should return :protected for protected instance methods on a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :protected_instance_m, :instance_method_only).should == :protected
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :protected_instance_m, :instance_method_only).should == :protected
   end
 
   it "should return :protected for protected instance methods on an instance of a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :protected_instance_m).should == :protected    
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :protected_instance_m).should == :protected    
   end
   it "should return nil for protected instance methods on an instance of a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :protected_instance_m, :class_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :protected_instance_m, :class_method_only).should be_nil
   end
   it "should return :protected for protected instance methods on an instance of a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :protected_instance_m, :instance_method_only).should == :protected
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :protected_instance_m, :instance_method_only).should == :protected
   end
   
   it "should return :private for private class methods on a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_class_m).should == :private #expected_private
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :private_class_m).should == :private #expected_private
   end
   it "should return :private for private class methods on a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_class_m, :class_method_only).should == :private #expected_private
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :private_class_m, :class_method_only).should == :private #expected_private
   end
   it "should return nil for private class methods on a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_class_m, :instance_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :private_class_m, :instance_method_only).should be_nil
   end
 
   it "should return :private for private instance methods on a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_instance_m).should == :private
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :private_instance_m).should == :private
   end
   it "should return nil for private instance methods on a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_instance_m, :class_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :private_instance_m, :class_method_only).should be_nil
   end
   it "should return :private for private instance methods on a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample, :private_instance_m, :instance_method_only).should == :private
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample, :private_instance_m, :instance_method_only).should == :private
   end
 
   it "should return nil for private class methods on an instance of a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_class_m).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :private_class_m).should be_nil
   end
   it "should return nil for private class methods on an instance of a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_class_m, :class_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :private_class_m, :class_method_only).should be_nil
   end
   it "should return nil for private class methods on an instance of a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_class_m, :instance_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :private_class_m, :instance_method_only).should be_nil
   end
 
   it "should return :private for private instance methods on an instance of a class" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_instance_m).should == :private    
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :private_instance_m).should == :private    
   end
   it "should return nil for private instance methods on an instance of a class when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_instance_m, :class_method_only).should == nil
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :private_instance_m, :class_method_only).should be_nil
   end
   it "should return :private for private instance methods on an instance of a class when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :private_instance_m, :instance_method_only).should == :private    
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :private_instance_m, :instance_method_only).should == :private    
   end
   
+  it "should ignore whether the exclude_ancestors flag is true or false for class methods" do
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample2, :public_class_m,  :class_method_only, false).should == :public
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample2, :private_class_m, :class_method_only, false).should == :private
+  end
+  it "should return nil for public instance methods on a subclass when the exclude_ancestors flag is false" do
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample2, :public_instance_m, :instance_method_only, false).should == nil
+  end
+  it "should return nil for protected instance methods on a subclass when the exclude_ancestors flag is false" do
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample2, :protected_instance_m, :instance_method_only, false).should == nil
+  end
+  it "should return nil for private instance methods on a subclass when the exclude_ancestors flag is false" do
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample2, :private_instance_m, :instance_method_only, false).should == nil
+  end
+    
   it "should return nil for an unknown method" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :nonexistent_method).should == nil    
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :nonexistent_method).should be_nil    
   end
   it "should return nil for an unknown method when only class methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :nonexistent_method, :class_method_only).should == nil    
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :nonexistent_method, :class_method_only).should be_nil    
   end
   it "should return nil for an unknown method when only instance methods are specified" do
-    Aquarium::Utils::MethodUtils.visibility(ProtectionExample.new, :nonexistent_method, :instance_method_only).should == nil    
+    Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample.new, :nonexistent_method, :instance_method_only).should be_nil    
+  end
+end
+
+describe Aquarium::Utils::MethodUtils, ".has_method" do
+  it "should return true for public class methods on a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :public_class_m).should be_true
+  end
+  it "should return true for public class methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :public_class_m, :class_method_only).should be_true
+  end
+  it "should return false for public class methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :public_class_m, :instance_method_only).should be_false
+  end
+
+  it "should return true for public instance methods on a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :public_instance_m).should be_true
+  end
+  it "should return false for public instance methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :public_instance_m, :class_method_only).should be_false
+  end
+  it "should return true for public instance methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :public_instance_m, :instance_method_only).should be_true
+  end
+
+  it "should return false for public class methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :public_class_m).should be_false
+  end
+  it "should return false for public class methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :public_class_m, :class_method_only).should be_false
+  end
+  it "should return false for public class methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :public_class_m, :instance_method_only).should be_false
+  end
+
+  it "should return true for public instance methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :public_instance_m).should be_true    
+  end
+  it "should return false for public instance methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :public_instance_m, :class_method_only).should be_false
+  end
+  it "should return true for public instance methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :public_instance_m, :instance_method_only).should be_true    
+  end
+  
+  it "should return true for protected instance methods on a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :protected_instance_m).should be_true
+  end
+  it "should return false for protected instance methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :protected_instance_m, :class_method_only).should be_false
+  end
+  it "should return true for protected instance methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :protected_instance_m, :instance_method_only).should be_true
+  end
+
+  it "should return true for protected instance methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :protected_instance_m).should be_true    
+  end
+  it "should return false for protected instance methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :protected_instance_m, :class_method_only).should be_false
+  end
+  it "should return true for protected instance methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :protected_instance_m, :instance_method_only).should be_true
+  end
+  
+  it "should return true for private class methods on a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :private_class_m).should be_true #expected_private
+  end
+  it "should return true for private class methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :private_class_m, :class_method_only).should be_true 
+  end
+  it "should return false for private class methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :private_class_m, :instance_method_only).should be_false
+  end
+
+  it "should return true for private instance methods on a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :private_instance_m).should be_true
+  end
+  it "should return false for private instance methods on a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :private_instance_m, :class_method_only).should be_false
+  end
+  it "should return true for private instance methods on a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample, :private_instance_m, :instance_method_only).should be_true
+  end
+
+  it "should return false for private class methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :private_class_m).should be_false
+  end
+  it "should return false for private class methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :private_class_m, :class_method_only).should be_false
+  end
+  it "should return false for private class methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :private_class_m, :instance_method_only).should be_false
+  end
+
+  it "should return true for private instance methods on an instance of a class" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :private_instance_m).should be_true    
+  end
+  it "should return false for private instance methods on an instance of a class when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :private_instance_m, :class_method_only).should be_false
+  end
+  it "should return true for private instance methods on an instance of a class when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :private_instance_m, :instance_method_only).should be_true    
+  end
+  
+  it "should ignore whether the exclude_ancestors flag is true or false for class methods" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample2, :public_class_m,  :class_method_only, false).should be_true
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample2, :private_class_m, :class_method_only, false).should be_true
+  end
+  it "should return false for public instance methods on a subclass when the exclude_ancestors flag is false" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample2, :public_instance_m, :instance_method_only, false).should be_false
+  end
+  it "should return false for protected instance methods on a subclass when the exclude_ancestors flag is false" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample2, :protected_instance_m, :instance_method_only, false).should be_false
+  end
+  it "should return false for private instance methods on a subclass when the exclude_ancestors flag is false" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample2, :private_instance_m, :instance_method_only, false).should be_false
+  end
+    
+  it "should return false for an unknown method" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :nonexistent_method).should be_false    
+  end
+  it "should return false for an unknown method when only class methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :nonexistent_method, :class_method_only).should be_false    
+  end
+  it "should return false for an unknown method when only instance methods are specified" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample.new, :nonexistent_method, :instance_method_only).should be_false    
+  end
+end
+
+module DefinerModule1
+  def m1; end
+end
+module DefinerModule2
+  def m2; end
+end
+class DefinerClass1
+  include DefinerModule1
+  def c1; end
+end
+class DefinerClass2 < DefinerClass1
+  include DefinerModule2
+  def c2; end
+end
+class DefinerClass2b < DefinerClass1
+  include DefinerModule2
+end
+
+describe Aquarium::Utils::MethodUtils, ".definer" do
+  it "should return the type that defines the method, when given a type" do
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2b, :c1).should == DefinerClass1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2b, :m1).should == DefinerModule1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2b, :m2).should == DefinerModule2
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2,  :c2).should == DefinerClass2
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2,  :c1).should == DefinerClass1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2,  :m1).should == DefinerModule1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2,  :m2).should == DefinerModule2
+    Aquarium::Utils::MethodUtils.definer(DefinerClass1,  :c1).should == DefinerClass1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass1,  :m1).should == DefinerModule1
+    Aquarium::Utils::MethodUtils.definer(DefinerModule2, :m2).should == DefinerModule2
+    Aquarium::Utils::MethodUtils.definer(DefinerModule1, :m1).should == DefinerModule1
+  end
+  
+  it "should return the type that defines the method, when given an object" do
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2b.new, :c1).should == DefinerClass1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2b.new, :m1).should == DefinerModule1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2b.new, :m2).should == DefinerModule2
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2.new,  :c2).should == DefinerClass2
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2.new,  :c1).should == DefinerClass1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2.new,  :m1).should == DefinerModule1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2.new,  :m2).should == DefinerModule2
+    Aquarium::Utils::MethodUtils.definer(DefinerClass1.new,  :c1).should == DefinerClass1
+    Aquarium::Utils::MethodUtils.definer(DefinerClass1.new,  :m1).should == DefinerModule1
+  end
+  
+  it "should return the eigenclass/singleton of an object when the method is defined on the object" do
+    dc = DefinerClass2.new
+    eigen = (class << dc; self; end)
+    def dc.dc1; end
+    Aquarium::Utils::MethodUtils.definer(dc, :dc1).should == eigen
+  end
+
+  it "should return the class of an object when the method is defined on the type or ancestor type, even if the eigenclass has been used to define an instance-only type" do
+    dc = DefinerClass2.new
+    eigen = (class << dc; self; end)
+    def dc.dc2; end
+    Aquarium::Utils::MethodUtils.definer(dc, :c2).should == DefinerClass2
+    Aquarium::Utils::MethodUtils.definer(dc, :m1).should == DefinerModule1
+    Aquarium::Utils::MethodUtils.definer(dc, :m2).should == DefinerModule2
+  end
+
+  it "should return nil if the specified method is defined by a subtype of the specified type" do
+    Aquarium::Utils::MethodUtils.definer(DefinerClass1,  :c2).should be_nil
+    Aquarium::Utils::MethodUtils.definer(DefinerModule1, :c2).should be_nil
+    Aquarium::Utils::MethodUtils.definer(DefinerModule2, :c2).should be_nil
+  end
+
+  it "should return nil if the specified method is defined by a subtype of the specified object's type" do
+    Aquarium::Utils::MethodUtils.definer(DefinerClass1.new,  :c2).should be_nil
+    Aquarium::Utils::MethodUtils.definer(DefinerClass2b.new, :c2).should be_nil
+  end
+
+  it "should return nil if nil is specified for the type or object" do
+    Aquarium::Utils::MethodUtils.definer(nil, :ignored).should be_nil
+  end
+
+  it "should return nil if nil is specified for the method" do
+    Aquarium::Utils::MethodUtils.definer(DefinerModule1,    nil).should be_nil
+    Aquarium::Utils::MethodUtils.definer(DefinerClass1,     nil).should be_nil
+    Aquarium::Utils::MethodUtils.definer(DefinerClass1.new, nil).should be_nil
   end
 end