aquarium 0.3.1 → 0.4.0

data/lib/aquarium/utils/method_utils.rb

@@ -20,13 +20,13 @@ module Aquarium
 
       def self.visibility type_or_instance, method_sym, class_or_instance_only = nil, include_ancestors = true
         find_method(type_or_instance, method_sym, class_or_instance_only, include_ancestors) do |t_or_o, msym, protection| 
-          return protection
+          protection
         end
       end
       
       def self.has_method type_or_instance, method_sym, class_or_instance_only = nil, include_ancestors = true
         found = find_method(type_or_instance, method_sym, class_or_instance_only, include_ancestors) do |t_or_o, msym, protection| 
-          return true
+          true
         end 
         found ? true : false   # found could be nil; return false, if so
       end
@@ -36,8 +36,8 @@ module Aquarium
         meta_method_suffixes.each do |suffix|
           %w[public protected private].each do |protection|
             meta_method = "#{protection}_#{suffix}"
-            methods = type_or_instance.send(meta_method, include_ancestors)
-            if methods.include?(method_sym.to_s)
+            found_methods = type_or_instance.send(meta_method, include_ancestors)
+            if found_methods.include?(method_sym.to_s)
               return yield(type_or_instance, method_sym, protection.intern)
             end
           end

data/lib/aquarium/utils/name_utils.rb

@@ -6,7 +6,7 @@ module Aquarium
   module Utils
     module NameUtils
 
-      @@char_map = {
+      @@char_expr_map = {
         '='  => '_equal_',
         '?'  => '_questionmark_',
         '!'  => '_exclamationmark_',
@@ -51,8 +51,8 @@ module Aquarium
 
       def self.make_valid_attr_name_from_method_name method_name
         new_name = method_name.to_s
-        @@char_map.each do |char, substitute|
-          new_name.gsub! char, substitute
+        @@char_expr_map.keys.sort{|x,y| y.length <=> x.length}.each do |expr|
+          new_name.gsub! expr, @@char_expr_map[expr]
         end
         new_name.intern
       end

data/lib/aquarium/utils/type_utils.rb

@@ -6,31 +6,46 @@ module Aquarium
       end
 
       def self.descendents clazz
-        visited_types = [Class, Object, Module, clazz]
-        result = Module.constants.inject([clazz]) do |result, const|
+        visited = [Class, Object, Module, clazz]
+        result = [clazz]
+        Module.constants.each do |const|
           mod = Module.class_eval(const)
           if mod.respond_to?(:ancestors)
             result << mod if mod.ancestors.include?(clazz)
-            do_descendents clazz, mod, visited_types, result
+            do_descendents clazz, mod, visited, result
           end
-          result
         end
         result.uniq
       end
       
       protected
       
+      # For JRuby classes, we have to "__x__" forms of the reflection methods that don't end in '?'. 
+      # That includes "send", so we do some ugly switching, rather than call "mod.send(method_name)"
+      # or "mod.__send__(method_name)"!
       def self.do_descendents clazz, visiting_module, visited, result
         visited << visiting_module
-        visiting_module.constants.each do |const|
+        use_underscore_methods = use_underscore_methods? visiting_module
+        nested_constants = use_underscore_methods ? visiting_module.__constants__ : visiting_module.constants
+        nested_constants.each do |const|
           next unless visiting_module.const_defined?(const)
-          clazz2 = visiting_module.const_get(const)
-          next if visited.include?(clazz2) or not clazz2.respond_to?(:ancestors)
-          visited << clazz2
-          result << clazz2 if clazz2.ancestors.include?(clazz)
-          do_descendents clazz, clazz2, visited, result 
+          nested_module = use_underscore_methods ? visiting_module.__const_get__(const) : visiting_module.const_get(const)
+          next if visited.include?(nested_module)
+          next unless responds_to_ancestors?(nested_module)
+          use_underscore_methods2 = use_underscore_methods? nested_module
+          modules_ancestors = use_underscore_methods2 ? nested_module.__ancestors__ : nested_module.ancestors
+          result << nested_module if modules_ancestors.include?(clazz)
+          do_descendents clazz, nested_module, visited, result 
         end
       end
+      
+      def self.use_underscore_methods? mod
+        mod.respond_to?(:__constants__)
+      end
+
+      def self.responds_to_ancestors? mod
+        mod.respond_to?(:ancestors) or mod.respond_to?(:__ancestors__)
+      end
     end
   end
 end

data/lib/aquarium/version.rb

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

data/spec/aquarium/aspects/advice_spec.rb

@@ -25,7 +25,7 @@ describe Advice, "#invoke_original_join_point" do
     def counter; @counter; end
   end
   
-  it "should invoke the original join_point" do
+  it "should invoke the original join_point with multiple advices" do
     aspect1 = Aspect.new :before, :type => InvocationCounter, :method => :increment do |jp, o|
       jp.invoke_original_join_point
     end
@@ -39,6 +39,18 @@ describe Advice, "#invoke_original_join_point" do
     aspect1.unadvise
     aspect2.unadvise
   end
+  
+  Advice.kinds.each do |kind|
+    it "should invoke the original join_point with #{kind} advice" do
+      aspect = Aspect.new kind, :type => InvocationCounter, :method => :increment do |jp, o|
+        jp.invoke_original_join_point
+      end
+      ic = InvocationCounter.new
+      ic.increment
+      ic.counter == 1
+      aspect.unadvise
+    end
+  end
 end
 
 describe Advice, "that raises an exception" do

data/spec/aquarium/aspects/aspect_spec.rb

@@ -618,6 +618,19 @@ describe Aspect, " with advice that calls JoinPoint#invoke_original_join_point"
   end
 end
 
+describe Aspect, "#unadvise called more than once on the same aspect" do
+  before(:all) do
+    @advice = Proc.new {}
+  end
+  
+  it "should do nothing on the second invocation." do
+    aspect = Aspect.new :around, :type => Watchful, :method => /does_not_exist/, :advice => @advice, :severity => Logger::Severity::ERROR
+    aspect.unadvise
+    lambda {aspect.unadvise}.should_not raise_error
+    lambda {aspect.unadvise}.should_not raise_error
+  end
+end
+
 describe Aspect, "#unadvise for 'empty' aspects" do
   before(:all) do
     @advice = Proc.new {}
@@ -645,7 +658,7 @@ describe Aspect, "#unadvise for 'empty' aspects" do
   end
 end
 
-describe Aspect, "#unadvise for removes all traces of the aspect" do
+describe Aspect, "#unadvise clean up" do
   before(:all) do
     @advice = Proc.new {}
     @watchful = Watchful.new
@@ -704,57 +717,63 @@ describe Aspect, "#unadvise for removes all traces of the aspect" do
   it "should remove all advice added by an object-based aspect." do
     do_unadvise_spec({:object => @watchful, :method_options => :exclude_ancestor_methods}, :get_object_methods)
   end
+end  
+
+module Aquarium
+  class FooForPrivateCheck
+    def bar; end
+  end
+end
+
+describe Aspect, "#unadvise clean up when all advices have been removed" do
+  before(:all) do
+    @advice = Proc.new {}
+    @aspect1 = @aspect2 = nil
+  end
+
+  def check_cleanup before_methods, before_class_variables
+    after  = yield
+    (after[0] - before_methods).should_not == []
+    (after[1] - before_class_variables).should_not == []
+    @aspect1.unadvise
+    after  = yield
+    (after[0] - before_methods).should_not == []
+    (after[1] - before_class_variables).should_not == []
+    @aspect2.unadvise
+    after  = yield
+    (after[0] - before_methods).should == []
+    (after[1] - before_class_variables).should == []
+  end
   
-  it "should remove all advice overhead if all advices are removed for pointcut-based aspects." do
-    class Foo
-      def bar; end
+  it "should remove all advice overhead for pointcut-based aspects." do
+    before_methods = Aquarium::FooForPrivateCheck.private_instance_methods.sort
+    before_class_variables = Aquarium::FooForPrivateCheck.class_variables.sort
+    @aspect1 = Aspect.new(:before, :pointcut => {:type => Aquarium::FooForPrivateCheck, :method_options => :exclude_ancestor_methods}) {|jp, obj, *args| true}
+    @aspect2 = Aspect.new(:after,  :pointcut => {:type => Aquarium::FooForPrivateCheck, :method_options => :exclude_ancestor_methods}) {|jp, obj, *args| true}
+    check_cleanup(before_methods, before_class_variables) do
+      [Aquarium::FooForPrivateCheck.private_instance_methods.sort, Aquarium::FooForPrivateCheck.class_variables.sort]
     end
-    before = Foo.private_instance_methods.sort
-    aspect1 = Aspect.new(:before, :pointcut => {:type => Foo, :method_options => :exclude_ancestor_methods}) {|jp, obj, *args| true}
-    aspect2 = Aspect.new(:after,  :pointcut => {:type => Foo, :method_options => :exclude_ancestor_methods}) {|jp, obj, *args| true}
-    after  = Foo.private_instance_methods
-    (after - before).should_not == []
-    aspect1.unadvise
-    after  = Foo.private_instance_methods
-    (after - before).should_not == []
-    aspect2.unadvise
-    after  = Foo.private_instance_methods
-    (after - before).should == []
   end
   
-  it "should remove all advice overhead if all advices are removed for type-based aspects." do
-    class Foo
-      def bar; end
+  it "should remove all advice overhead for type-based aspects." do
+    before_methods = Aquarium::FooForPrivateCheck.private_instance_methods.sort
+    before_class_variables = Aquarium::FooForPrivateCheck.class_variables.sort
+    @aspect1 = Aspect.new(:before, :type => Aquarium::FooForPrivateCheck, :method_options => :exclude_ancestor_methods) {|jp, obj, *args| true}
+    @aspect2 = Aspect.new(:after,  :type => Aquarium::FooForPrivateCheck, :method_options => :exclude_ancestor_methods) {|jp, obj, *args| true}
+    check_cleanup(before_methods, before_class_variables) do
+      [Aquarium::FooForPrivateCheck.private_instance_methods.sort, Aquarium::FooForPrivateCheck.class_variables.sort]
     end
-    before = Foo.private_instance_methods.sort
-    aspect1 = Aspect.new(:before, :type => Foo, :method_options => :exclude_ancestor_methods) {|jp, obj, *args| true}
-    aspect2 = Aspect.new(:after,  :type => Foo, :method_options => :exclude_ancestor_methods) {|jp, obj, *args| true}
-    after  = Foo.private_instance_methods
-    (after - before).should_not == []
-    aspect1.unadvise
-    after  = Foo.private_instance_methods
-    (after - before).should_not == []
-    aspect2.unadvise
-    after  = Foo.private_instance_methods
-    (after - before).should == []
   end
 
-  it "should remove all advice overhead if all advices are removed for object-based aspects." do
-    class Overhead
-      def over; end
+  it "should remove all advice overhead for object-based aspects." do
+    object = Aquarium::FooForPrivateCheck.new
+    before_methods = object.private_methods.sort
+    before_class_variables = (class << object; self.class_variables.sort; end)
+    @aspect1 = Aspect.new(:before, :object => object, :method_options => :exclude_ancestor_methods) {|jp, obj, *args| true}
+    @aspect2 = Aspect.new(:after,  :object => object, :method_options => :exclude_ancestor_methods) {|jp, obj, *args| true}
+    check_cleanup(before_methods, before_class_variables) do
+      [object.private_methods.sort, (class << object; self.class_variables.sort; end)]
     end
-    overhead = Overhead.new
-    before = overhead.private_methods.sort
-    aspect1 = Aspect.new(:before, :object => overhead, :method_options => :exclude_ancestor_methods) {|jp, obj, *args| true}
-    aspect2 = Aspect.new(:after,  :object => overhead, :method_options => :exclude_ancestor_methods) {|jp, obj, *args| true}
-    after  = overhead.private_methods
-    (after - before).should_not == []
-    aspect1.unadvise
-    after  = overhead.private_methods
-    (after - before).should_not == []
-    aspect2.unadvise
-    after  = overhead.private_methods
-    (after - before).should == []
   end
 end
 

data/spec/aquarium/aspects/join_point_spec.rb

@@ -275,7 +275,7 @@ describe Aquarium::Aspects::JoinPoint, "#invoke_original_join_point" do
       :advice_kind => :around, 
       :advised_object => ioc, 
       :parameters => [],
-      :proceed_proc => Aquarium::Aspects::NoAdviceChainNode.new({:alias_method_name => :invoke})
+      :current_advice_node => Aquarium::Aspects::NoAdviceChainNode.new({:alias_method_name => :invoke})
     }
     jp2 = jp.make_current_context_join_point context_opts
     jp2.invoke_original_join_point

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -300,13 +300,13 @@ describe Pointcut, "methods" do
       pc.join_points_not_matched.should == @expected_modules_not_matched_jps
     end
     
-    Aspect::CANONICAL_OPTIONS["types_and_ancestors"].each do |key|
+    Aspect::CANONICAL_OPTIONS["types_and_ancestors"].reject{|key| key.eql?("types_and_ancestors")}.each do |key|
       it "should accept :#{key} as a synonym for :types_and_ancestors." do
         lambda {Pointcut.new key.intern => /^Module.*Method/, :methods => :all, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
       end
     end
   
-    Aspect::CANONICAL_OPTIONS["types_and_descendents"].each do |key|
+    Aspect::CANONICAL_OPTIONS["types_and_descendents"].reject{|key| key.eql?("types_and_descendents")}.each do |key|
       it "should accept :#{key} as a synonym for :types_and_descendents." do
         lambda {Pointcut.new key.intern => /^Module.*Method/, :methods => :all, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
       end
@@ -342,7 +342,7 @@ describe Pointcut, "methods" do
           JoinPoint.new(:object => pub, :method_name => :public_instance_test_method)])
     end  
   
-    Aspect::CANONICAL_OPTIONS["objects"].each do |key|
+    Aspect::CANONICAL_OPTIONS["objects"].reject{|key| key.eql?("objects")}.each do |key|
       it "should accept :#{key} as a synonym for :objects." do
         pub, pro = ClassWithPublicInstanceMethod.new, ClassWithProtectedInstanceMethod.new
         pc = Pointcut.new key.intern => [pub, pro], :methods => :all, :method_options => [:public, :protected, :exclude_ancestor_methods]
@@ -448,7 +448,7 @@ describe Pointcut, "methods" do
       pc.join_points_not_matched.size.should == 0
     end
   
-    Aspect::CANONICAL_OPTIONS["exclude_types"].each do |key|
+    Aspect::CANONICAL_OPTIONS["exclude_types"].reject{|key| key.eql?("exclude_types")}.each do |key|
       it "should accept :#{key} as a synonym for :exclude_types." do
         pc = Pointcut.new :types => /ExcludeTest/, key.intern => [ExcludeTestTwo, ExcludeTestThree], :method_options => :exclude_ancestor_methods
         actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
@@ -575,6 +575,18 @@ describe Pointcut, "methods" do
       :exclude_types_and_descendents => ClassIncludingModuleWithPublicInstanceMethod, :methods => :all, :method_options => :exclude_ancestor_methods
       check_class_descendents pc
     end
+
+    Aspect::CANONICAL_OPTIONS["exclude_types_and_descendents"].reject{|key| key.eql?("exclude_types_and_descendents")}.each do |key|
+      it "should accept :#{key} as a synonym for :exclude_types_and_descendents." do
+        lambda {Pointcut.new :types => /ExcludeTest/, key.intern => [ExcludeTestTwo, ExcludeTestThree], :method_options => :exclude_ancestor_methods, :noop => true}.should_not raise_error
+      end
+    end  
+
+    Aspect::CANONICAL_OPTIONS["exclude_types_and_ancestors"].reject{|key| key.eql?("exclude_types_and_ancestors")}.each do |key|
+      it "should accept :#{key} as a synonym for :exclude_types_and_ancestors." do
+        lambda {Pointcut.new :types => /ExcludeTest/, key.intern => [ExcludeTestTwo, ExcludeTestThree], :method_options => :exclude_ancestor_methods, :noop => true}.should_not raise_error
+      end
+    end  
   end
   
   describe Pointcut, ".new (:exclude_objects => objects specified)" do
@@ -615,7 +627,7 @@ describe Pointcut, "methods" do
       pc.join_points_not_matched.size.should == 0
     end
   
-    Aspect::CANONICAL_OPTIONS["exclude_objects"].each do |key|
+    Aspect::CANONICAL_OPTIONS["exclude_objects"].reject{|key| key.eql?("exclude_objects")}.each do |key|
       it "should accept :#{key} as a synonym for :exclude_objects." do
         pc = Pointcut.new :objects => @objects, key.intern => @e22, :method_options => :exclude_ancestor_methods
         actual = pc.join_points_matched.collect {|jp| jp.type_or_object}.uniq
@@ -661,7 +673,7 @@ describe Pointcut, "methods" do
       pc.join_points_not_matched.size.should == 0
     end
   
-    Aspect::CANONICAL_OPTIONS["exclude_join_points"].each do |key|
+    Aspect::CANONICAL_OPTIONS["exclude_join_points"].reject{|key| key.eql?("exclude_join_points")}.each do |key|
       it "should accept :#{key} as a synonym for :exclude_join_points." do
         excluded = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
         expected = [@jp11, @jp13, @jp21, @jp22, @jp23, @jp31, @jp32, @ojp12, @ojp21, @ojp22, @ojp31, @ojp32, @ojp33]
@@ -718,7 +730,7 @@ describe Pointcut, "methods" do
       pc.join_points_not_matched.size.should == 0
     end
   
-    Aspect::CANONICAL_OPTIONS["exclude_pointcuts"].each do |key|
+    Aspect::CANONICAL_OPTIONS["exclude_pointcuts"].reject{|key| key.eql?("exclude_pointcuts")}.each do |key|
       it "should accept :#{key} as a synonym for :exclude_pointcuts." do
         excluded_jps = [@jp12, @jp33, @ojp11, @ojp13, @ojp23]
         excluded = Pointcut.new :join_points => excluded_jps
@@ -735,7 +747,7 @@ describe Pointcut, "methods" do
       before_pointcut_class_spec
     end
 
-    Aspect::CANONICAL_OPTIONS["method_options"].each do |key|
+    Aspect::CANONICAL_OPTIONS["method_options"].reject{|key| key.eql?("method_options")}.each do |key|
       it "should accept :#{key} as a synonym for :method_options." do
         pc = Pointcut.new :types => ClassWithPublicInstanceMethod, key.intern => [:public, :instance, :exclude_ancestor_methods]
         pc.join_points_matched.should be_eql(Set.new([@pub_jp]))
@@ -888,7 +900,7 @@ describe Pointcut, "methods" do
       @expected_for_objects = Set.new([@jp_rw_o, @jp_rwe_o, @jp_r_o, @jp_we_o])
     end
   
-    Aspect::CANONICAL_OPTIONS["methods"].each do |key|
+    Aspect::CANONICAL_OPTIONS["methods"].reject{|key| key.eql?("methods")}.each do |key|
       it "should accept :#{key} as a synonym for :methods." do
         pc = Pointcut.new :types => "ClassWithAttribs", key.intern => [/^attr/]
         pc.join_points_matched.should == @expected_for_types
@@ -943,7 +955,7 @@ describe Pointcut, "methods" do
       pc.join_points_not_matched.size.should == 0
     end
   
-    Aspect::CANONICAL_OPTIONS["exclude_methods"].each do |key|
+    Aspect::CANONICAL_OPTIONS["exclude_methods"].reject{|key| key.eql?("exclude_methods")}.each do |key|
       it "should accept :#{key} as a synonym for :exclude_methods." do
         pc = Pointcut.new :join_points => @all_jps, key.intern => /method[12][13]/, :method_options => :exclude_ancestor_methods
         pc.join_points_matched.size.should == 10

data/spec/aquarium/finders/method_finder_spec.rb

@@ -324,9 +324,10 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)"
   end
   
   it "should find all class methods specified by regular expression for types when :class is used." do
-    # Have to add some rspec methods to the expected lists!
+    # NOTE: The list of methods defined by Kernel is different for MRI and JRuby!
     expected = {}
-    expected[Kernel] = [:chomp!, :chop!, :respond_to?]
+    expected[Kernel] = [:respond_to?]
+    expected[Kernel] += [:chomp!, :chop!] unless Object.const_defined?('JRUBY_VERSION')
     [Object, Module, Class].each do |clazz|
       expected[clazz] = [:respond_to?]
     end

data/spec/aquarium/finders/type_finder_spec.rb

@@ -54,7 +54,7 @@ describe Aquarium::Finders::TypeFinder, "#find invocation parameters" do
 
   it "should accept a hash and treat it as equivalent to an explicit list parameters." do
     expected_found_types  = [Outside::Inside1, Outside::Inside2]
-    expected_unfound_exps = %w[Foo::Bar::Baz]
+    expected_unfound_exps = %w[NonExistent::SubNonExistent::SubSubNonExistent]
     hash = {:names => (expected_found_types.map {|t| t.to_s} + expected_unfound_exps)}
     actual = Aquarium::Finders::TypeFinder.new.find hash
     actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
@@ -117,7 +117,7 @@ describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :
 
   it "should find types with :: namespace delimiters using their names." do
     expected_found_types  = [Outside::Inside1, Outside::Inside2]
-    expected_unfound_exps = %w[Foo::Bar::Baz]
+    expected_unfound_exps = %w[NonExistent::SubNonExistent::SubSubNonExistent]
     actual = Aquarium::Finders::TypeFinder.new.find :names => (expected_found_types.map {|t| t.to_s} + expected_unfound_exps)
     actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
     actual.not_matched_keys.sort.should == expected_unfound_exps.sort

data/spec/aquarium/finders/type_finder_with_descendents_and_ancestors_spec.rb

@@ -11,7 +11,7 @@ def purge_actuals actuals
   end
 end
 
-describe "#find types and their descendents, using :types_and_descendents" do
+describe TypeUtils, "#find types and their descendents, using :types_and_descendents" do
   it "should find the matching types and their descendent subclasses, even in different nested modules." do
     TypeUtils.sample_types.each do |t|
       actual = Aquarium::Finders::TypeFinder.new.find :types_and_descendents => (t.name)
@@ -28,7 +28,7 @@ describe "#find types and their descendents, using :types_and_descendents" do
   end
 end
 
-describe "#find types subtracting out excluded types and descendents, using :exclude_types_and_descendents" do
+describe TypeUtils, "#find types subtracting out excluded types and descendents, using :exclude_types_and_descendents" do
   it "should find the matching types and their descendent subclasses, minus the excluded type hierarchies." do
     actual = Aquarium::Finders::TypeFinder.new.find :types_and_descendents => ModuleForDescendents, :exclude_types_and_descendents => D1ForDescendents
     actual_keys = purge_actuals actual
@@ -47,7 +47,7 @@ describe "#find types subtracting out excluded types and descendents, using :exc
 end
 
 
-describe "#find types and their ancestors, using :types_and_ancestors" do
+describe TypeUtils, "#find types and their ancestors, using :types_and_ancestors" do
   it "should find the matching types and their ancestors, even in different nested modules." do
     TypeUtils.sample_types.each do |t|
       actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => (t.name)
@@ -65,7 +65,7 @@ describe "#find types and their ancestors, using :types_and_ancestors" do
 end
 
 
-describe "#find types subtracting out excluded types and ancestors, using :exclude_types_and_ancestors" do
+describe TypeUtils, "#find types subtracting out excluded types and ancestors, using :exclude_types_and_ancestors" do
   it "should find the matching types and their ancestors, minus the excluded types and ancestors." do
     actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => D1ForDescendents, :exclude_types_and_ancestors => ModuleForDescendents
     actual_keys = purge_actuals actual
@@ -84,7 +84,7 @@ describe "#find types subtracting out excluded types and ancestors, using :exclu
 end
 
 
-describe "#find types and their descendents and ancestors" do
+describe TypeUtils, "#find types and their descendents and ancestors" do
   it "should find the matching types and their descendents and ancestors, even in different nested modules." do
     TypeUtils.sample_types.each do |t|
       actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => (t.name), :types_and_descendents => (t.name)
@@ -96,7 +96,7 @@ describe "#find types and their descendents and ancestors" do
   end
 end
 
-describe "#find types subtracting out excluded types and their descendents and ancestors" do
+describe TypeUtils, "#find types subtracting out excluded types and their descendents and ancestors" do
   it "should find the matching types and their descendents and ancestors, minus the excluded types and their descendents and ancestors." do
     actual = Aquarium::Finders::TypeFinder.new.find \
       :types_and_ancestors => Aquarium::ForDescendents::NestedD1ForDescendents, 
@@ -110,7 +110,7 @@ describe "#find types subtracting out excluded types and their descendents and a
   end
 end
 
-describe "#find types and their descendents and ancestors, specified with regular expressions" do
+describe TypeUtils, "#find types and their descendents and ancestors, specified with regular expressions" do
   it "should find the matching types and their descendents and ancestors, even in different nested modules." do
     regexs = [/ForDescendents$/, /Aquarium::ForDescendents::.*ForDescendents/]
     actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => regexs, :types_and_descendents => regexs
@@ -125,7 +125,7 @@ describe "#find types and their descendents and ancestors, specified with regula
   end
 end
 
-describe "#find types and their descendents and ancestors, subtracting out excluded types and their descendents and ancestors, specified using regular expressions" do
+describe TypeUtils, "#find types and their descendents and ancestors, subtracting out excluded types and their descendents and ancestors, specified using regular expressions" do
   it "should find the matching types and their descendents and ancestors, minus the excluded types and their descendents and ancestors." do
     actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => /Aquarium::ForDescendents::.*D1ForDescendents/, 
       :types_and_descendents => /Aquarium::ForDescendents::.*D1ForDescendents/, 

data/spec/aquarium/utils/method_utils_spec.rb

@@ -162,10 +162,19 @@ describe Aquarium::Utils::MethodUtils, ".visibility" do
     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
+  it "should ignore whether the exclude_ancestors flag is true or false for class methods when running under MRI" do
+    unless Object.const_defined?('JRUBY_VERSION')
+      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
+  end
+  it "should NOT ignore whether the exclude_ancestors flag is true or false for class methods when running under JRuby" do
+    if Object.const_defined?('JRUBY_VERSION')
+      Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample2, :public_class_m,  :class_method_only, false).should == nil
+      Aquarium::Utils::MethodUtils.visibility(MethodUtilsSpecProtectionExample2, :private_class_m, :class_method_only, false).should == nil
+    end
   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
@@ -288,10 +297,12 @@ describe Aquarium::Utils::MethodUtils, ".has_method" 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
+  not_string, true_or_false, ruby_name = Object.const_defined?('JRUBY_VERSION') ? ['NOT ', false, 'JRuby'] : ['', true, 'MRI'] 
+  it "should #{not_string}ignore whether the exclude_ancestors flag is true or false for class methods when running under #{ruby_name}" do
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample2, :public_class_m,  :class_method_only, false).should == true_or_false
+    Aquarium::Utils::MethodUtils.has_method(MethodUtilsSpecProtectionExample2, :private_class_m, :class_method_only, false).should == true_or_false
   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