aquarium 0.1.5 → 0.1.6

data/spec/aquarium/aspects/join_point_spec.rb

@@ -9,6 +9,17 @@ class Dummy
   def count; 0; end
 end
 
+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
+
 describe Aquarium::Aspects::JoinPoint, "#initialize with invalid parameters" do
   
   it "should require either a :type or an :object parameter when creating." do
@@ -29,48 +40,44 @@ describe Aquarium::Aspects::JoinPoint, "#initialize with parameters that specify
   it "should assume the :method_name refers to an instance method, by default." do
     jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split
     jp.instance_method?.should be_true
+    jp.class_method?.should be_false
   end
   
   it "should treat the :method_name as refering to an instance method if :instance_method is specified as true." do
     jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :instance_method => true
     jp.instance_method?.should be_true
+    jp.class_method?.should be_false
   end
   
   it "should treat the :method_name as refering to a class method if :instance_method is specified as false." do
     jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :instance_method => false
     jp.instance_method?.should be_false
+    jp.class_method?.should be_true
   end
 
   it "should treat the :method_name as refering to an instance method if :class_method is specified as false." do
     jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :class_method => false
     jp.instance_method?.should be_true
+    jp.class_method?.should be_false
   end
   
   it "should treat the :method_name as refering to a class method if :class_method is specified as true." do
     jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :class_method => true
     jp.instance_method?.should be_false
+    jp.class_method?.should be_true
   end
   
   it "should treat give precedence to :instance_method if appears with :class_method." do
     jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :instance_method => false, :class_method => true
     jp.instance_method?.should be_false
+    jp.class_method?.should be_true
     jp = Aquarium::Aspects::JoinPoint.new :type => String, :method => :split, :instance_method => true, :class_method => false
     jp.instance_method?.should be_true
+    jp.class_method?.should be_false
   end
 end
   
 describe Aquarium::Aspects::JoinPoint, "#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 instance methods." do
     jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :public_instance_m
     jp.visibility.should == :public
@@ -159,6 +166,21 @@ describe Aquarium::Aspects::JoinPoint, "#visibility" do
     jp.visibility.should == nil
   end
 end
+
+describe Aquarium::Aspects::JoinPoint, "#target_type" do
+  it "should return the type at the JoinPoint" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method => :foo
+    jp.target_type.should be_eql(ProtectionExample)
+  end
+end
+  
+describe Aquarium::Aspects::JoinPoint, "#target_object" do
+  it "should return the object at the JoinPoint" do
+    example = ProtectionExample.new
+    jp = Aquarium::Aspects::JoinPoint.new :object => example, :method => :foo
+    jp.target_object.should be_eql(example)
+  end
+end
   
 describe Aquarium::Aspects::JoinPoint, "#dup" do
   it "should duplicate the fields in the join point." do
@@ -274,6 +296,67 @@ describe Aquarium::Aspects::JoinPoint, "#make_current_context_join_point when th
   end
 end
 
+describe Aquarium::Aspects::JoinPoint, "#type_or_object" do
+  it "should return the type if the object is nil" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method_name => :split
+    jp.type_or_object.should eql(String)
+  end
+
+  it "should return the object if the type is nil" do
+    jp = Aquarium::Aspects::JoinPoint.new :object => String.new, :method_name => :split
+    jp.type_or_object.should eql("")
+  end
+end
+
+describe Aquarium::Aspects::JoinPoint, "#exists?" do
+  it "should return false if the join point represents a non-existent join point for an instance method in the runtime environment" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method_name => :foo
+    jp.exists?.should be_false
+  end
+
+  it "should return false if the join point represents a non-existent join point for a class method in the runtime environment" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method_name => :foo, :class_method => true
+    jp.exists?.should be_false
+  end
+
+  it "should return true if the join point represents a real join point for a public instance method in the runtime environment" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method_name => :public_instance_m
+    jp.exists?.should be_true
+  end
+
+  it "should return true if the join point represents a real join point for a protected instance method in the runtime environment" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method_name => :protected_instance_m
+    jp.exists?.should be_true
+  end
+
+  it "should return true if the join point represents a real join point for a private instance method in the runtime environment" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method_name => :private_instance_m
+    jp.exists?.should be_true
+  end
+
+  it "should return true if the join point represents a real join point for a public class method in the runtime environment" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method_name => :public_class_m, :class_method => true
+    jp.exists?.should be_true
+  end
+
+  it "should return true if the join point represents a real join point for a private class method in the runtime environment" do
+    jp = Aquarium::Aspects::JoinPoint.new :type => ProtectionExample, :method_name => :private_class_m, :class_method => true
+    jp.exists?.should be_true
+  end
+
+  class ProtectionExample2
+    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
+  
+end
+
 describe Aquarium::Aspects::JoinPoint, "#make_current_context_join_point when the Aquarium::Aspects::JoinPoint::Context object is not nil" do
   it "should return a new join_point that contains the non-context information of the advised_object plus an updated Aquarium::Aspects::JoinPoint::Context with the specified context information." do
     jp  = Aquarium::Aspects::JoinPoint.new :type => String, :method_name => :split
@@ -296,18 +379,6 @@ describe Aquarium::Aspects::JoinPoint, "#make_current_context_join_point when th
   end
 end
 
-describe Aquarium::Aspects::JoinPoint, "#type_or_object" do
-  it "should return the type if the object is nil" do
-    jp = Aquarium::Aspects::JoinPoint.new :type => String, :method_name => :split
-    jp.type_or_object.should eql(String)
-  end
-
-  it "should return the object if the type is nil" do
-    jp = Aquarium::Aspects::JoinPoint.new :object => String.new, :method_name => :split
-    jp.type_or_object.should eql("")
-  end
-end
-
 describe Aquarium::Aspects::JoinPoint::Context, "#initialize" do
   it "should require :advice_kind, :advised_object and :parameters arguments." do
     lambda { Aquarium::Aspects::JoinPoint::Context.new :advised_object => "object", :parameters => [","]}.should raise_error(Aquarium::Utils::InvalidOptions)

data/spec/aquarium/aspects/pointcut_or_composition_spec.rb

@@ -32,12 +32,14 @@ describe "Aquarium::Aspects::Pointcut#and" do
    
   it "should return a new Aquarium::Aspects::Pointcut whose join points are the union of the left- and right-hand side Aquarium::Aspects::Pointcuts for type-based Aquarium::Aspects::Pointcuts." do
     pc1 = Aquarium::Aspects::Pointcut.new :types => ClassWithAttribs, :attributes => [/^attr/], :attribute_options => [:writers, :suppress_ancestor_methods]
-    pc2 = Aquarium::Aspects::Pointcut.new :types => /Class.*Method/, :method_options => :suppress_ancestor_methods
+    # "[^F]" excludes the ClassWithFunkyMethodNames...
+    pc2 = Aquarium::Aspects::Pointcut.new :types => /Class[^F]+Method/, :method_options => :suppress_ancestor_methods
     pc = pc1.or pc2
     jp1 = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs=
     jp2 = Aquarium::Aspects::JoinPoint.new :type => ClassWithAttribs, :method => :attrW_ClassWithAttribs=
-    jp3 = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod, :method => :public_instance_test_method
-    pc.join_points_matched.should == Set.new([jp1, jp2, jp3])
+    jp3 = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod,  :method => :public_instance_test_method
+    jp4 = Aquarium::Aspects::JoinPoint.new :type => ClassWithPublicInstanceMethod2, :method => :public_instance_test_method2
+    pc.join_points_matched.should == Set.new([jp1, jp2, jp3, jp4])
     pc.join_points_not_matched.should == @not_matched_jps
   end
    

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -1,6 +1,8 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 require File.dirname(__FILE__) + '/../spec_example_classes'
+require 'aquarium/utils/invalid_options'
 require 'aquarium/extensions/hash'
+require 'aquarium/aspects/join_point'
 require 'aquarium/aspects/pointcut'
 require 'aquarium/utils'
 
@@ -21,7 +23,13 @@ def common_setup
   @expected_not_matched_jps = Set.new [@apro_jp, @apri_jp, @acpub_jp, @acpri_jp]
 end
 
-describe Aquarium::Aspects::Pointcut, " (empty)" do
+describe Aquarium::Aspects::Pointcut, "#new (invalid arguments)" do
+  it "should raise if an unknown argument is specified" do
+    lambda { Aquarium::Aspects::Pointcut.new :foo => :bar }.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+end
+
+describe Aquarium::Aspects::Pointcut, "#new (empty)" do
   it "should match no join points by default." do
     pc = Aquarium::Aspects::Pointcut.new
     pc.should be_empty
@@ -51,6 +59,16 @@ describe Aquarium::Aspects::Pointcut, " (empty)" do
     pc = Aquarium::Aspects::Pointcut.new :objects => nil
     pc.should be_empty
   end
+  
+  it "should match no join points if join_points = nil specified." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => nil
+    pc.should be_empty
+  end
+  
+  it "should match no join points if join_points = [] specified." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => []
+    pc.should be_empty
+  end
 end
 
 describe Aquarium::Aspects::Pointcut, "#empty?" do
@@ -81,11 +99,17 @@ describe Aquarium::Aspects::Pointcut, " (types specified using regular expressio
     common_setup
   end
 
-  it "should match multiple classes using regular expressions." do
-    pc = Aquarium::Aspects::Pointcut.new :types => /Class.*Method/, :method_options => :suppress_ancestor_methods
+  it "should match multiple classes using regular expressions that cover the full class names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /Class.*Method\Z/, :method_options => :suppress_ancestor_methods
     pc.join_points_matched.should == @expected_matched_jps
     pc.join_points_not_matched.should == @expected_not_matched_jps
   end
+
+  it "should match classes using regular expressions that only cover partial class names." do
+    pc = Aquarium::Aspects::Pointcut.new :types => /lass.*Pro.*Inst.*Met/, :method_options => [:public, :protected, :suppress_ancestor_methods]
+    pc.join_points_matched.should == Set.new([@pro_jp])
+    pc.join_points_not_matched.size.should == 0
+  end
 end
 
 describe Aquarium::Aspects::Pointcut, " (types specified using names)" do
@@ -438,6 +462,35 @@ describe Aquarium::Aspects::Pointcut, " (types or objects specified with attribu
   end  
 end
 
+describe Aquarium::Aspects::Pointcut, " (join points specified)" do
+  setup do
+    common_setup
+    @anClassWithPublicInstanceMethod = ClassWithPublicInstanceMethod.new
+    @expected_matched = [@pub_jp, @pro_jp, @pri_jp, @cpub_jp, @cpri_jp,
+        Aquarium::Aspects::JoinPoint.new(:object => @anClassWithPublicInstanceMethod, :method => :public_instance_test_method)]
+    @expected_not_matched = [
+      Aquarium::Aspects::JoinPoint.new(:type   => ClassWithPublicInstanceMethod,    :method => :foo),
+      Aquarium::Aspects::JoinPoint.new(:object => @anClassWithPublicInstanceMethod, :method => :foo)]
+  end
+
+  it "should return matches only for existing join points." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => (@expected_matched + @expected_not_matched)
+    pc.join_points_matched.should == Set.new(@expected_matched)
+  end
+
+  it "should return non-matches for non-existing join points." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => (@expected_matched + @expected_not_matched)
+    pc.join_points_not_matched.should == Set.new(@expected_not_matched)
+  end
+
+  it "should ignore :methods, :attributes, :method_options, and :attribute_options for the join points specified." do
+    pc = Aquarium::Aspects::Pointcut.new :join_points => (@expected_matched + @expected_not_matched),
+      :methods => :kind_of?, :attributes => :name, :method_options => [:class], :attribute_options => [:readers]
+    pc.join_points_matched.should == Set.new(@expected_matched)
+    pc.join_points_not_matched.should == Set.new(@expected_not_matched)
+  end
+end
+
 describe Aquarium::Aspects::Pointcut, " (methods that end in non-alphanumeric characters)" do
   class ClassWithFunkyMethodNames
     def huh?; true; end
@@ -611,8 +664,8 @@ describe Aquarium::Aspects::Pointcut, "#eql?" do
   end
 
   it "should return false if the not_matched types are different." do
-    pc1 = Aquarium::Aspects::Pointcut.new  :types => /Foo/
-    pc2 = Aquarium::Aspects::Pointcut.new  :types => /Bar/
+    pc1 = Aquarium::Aspects::Pointcut.new  :types => :UnknownFoo
+    pc2 = Aquarium::Aspects::Pointcut.new  :types => :UnknownBar
     pc1.should_not eql(pc2)
   end
 
@@ -685,7 +738,7 @@ describe "Aquarium::Aspects::Pointcut#eql?" do
   end
 end
 
-describe "Aquarium::Aspects::Pointcut#candidate_types" do
+describe Aquarium::Aspects::Pointcut, "#candidate_types" do
   setup do
     common_setup
   end
@@ -715,7 +768,7 @@ describe "Aquarium::Aspects::Pointcut#candidate_types" do
   end
 end
 
-describe "Aquarium::Aspects::Pointcut#candidate_objects" do
+describe Aquarium::Aspects::Pointcut, "#candidate_objects" do
   setup do
     common_setup
   end
@@ -730,7 +783,36 @@ describe "Aquarium::Aspects::Pointcut#candidate_objects" do
   end
 end
 
-describe "Aquarium::Aspects::Pointcut#specification" do
+describe Aquarium::Aspects::Pointcut, "#candidate_join_points" do
+  setup do
+    common_setup
+  end
+  
+  it "should return only candidate non-matching join points for the input join points that do not exist." do
+    anClassWithPublicInstanceMethod = ClassWithPublicInstanceMethod.new
+    example_jps = [
+      Aquarium::Aspects::JoinPoint.new(:type   => ClassWithPublicInstanceMethod,   :method => :foo),
+      Aquarium::Aspects::JoinPoint.new(:object => anClassWithPublicInstanceMethod, :method => :foo)]
+    pc = Aquarium::Aspects::Pointcut.new :join_points => example_jps
+    pc.candidate_join_points.matched.size.should == 0
+    pc.candidate_join_points.not_matched[example_jps[0]].should_not be_nil
+    pc.candidate_join_points.not_matched[example_jps[1]].should_not be_nil
+  end
+  
+  it "should return only candidate matching join points for the input join points that do exist." do
+    anClassWithPublicInstanceMethod = ClassWithPublicInstanceMethod.new
+    example_jps = [
+      Aquarium::Aspects::JoinPoint.new(:type   => ClassWithPublicInstanceMethod,   :method => :public_instance_test_method),
+      Aquarium::Aspects::JoinPoint.new(:object => anClassWithPublicInstanceMethod, :method => :public_instance_test_method)]
+    pc = Aquarium::Aspects::Pointcut.new :join_points => example_jps
+    pc.candidate_join_points.matched.size.should == 2
+    pc.candidate_join_points.matched[example_jps[0]].should_not be_nil
+    pc.candidate_join_points.matched[example_jps[1]].should_not be_nil
+    pc.candidate_join_points.not_matched.size.should == 0
+  end
+end
+
+describe Aquarium::Aspects::Pointcut, "#specification" do
   setup do
     common_setup
     @expected_specification_subset = {
@@ -741,15 +823,15 @@ describe "Aquarium::Aspects::Pointcut#specification" do
 
   it "should return ':attribute_options => []', by default, if no arguments are given." do
     pc = Aquarium::Aspects::Pointcut.new
-    pc.specification.should == { :types => @empty_set, :objects => @empty_set, :default_object => @empty_set,
-      :methods => Set.new([:all]), :method_options => Set.new([]), 
+    pc.specification.should == { :types => @empty_set, :objects => @empty_set, :join_points => @empty_set,
+      :methods => Set.new([:all]), :method_options => Set.new([]), :default_object => @empty_set,
       :attributes => @empty_set, :attribute_options => @empty_set }
   end
 
   it "should return the input :types and :type arguments combined into an array keyed by :types." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :type => String
-    pc.specification.should == { :types => Set.new(@example_types + [String]), :objects => @empty_set, :default_object => @empty_set,
-      :methods => Set.new([:all]), :method_options => Set.new([]), 
+    pc.specification.should == { :types => Set.new(@example_types + [String]), :objects => @empty_set, :join_points => @empty_set,
+      :methods => Set.new([:all]), :method_options => Set.new([]), :default_object => @empty_set,
       :attributes => @empty_set, :attribute_options => @empty_set } 
   end
   
@@ -757,36 +839,36 @@ describe "Aquarium::Aspects::Pointcut#specification" do
     example_objs = @example_types.map {|t| t.new}
     s1234 = "1234"
     pc = Aquarium::Aspects::Pointcut.new :objects => example_objs, :object => s1234
-    pc.specification.should == { :types => @empty_set, :objects => Set.new(example_objs + [s1234]), :default_object => @empty_set,
-      :methods => Set.new([:all]), :method_options => Set.new([]), 
+    pc.specification.should == { :types => @empty_set, :objects => Set.new(example_objs + [s1234]), :join_points => @empty_set,
+      :methods => Set.new([:all]), :method_options => Set.new([]), :default_object => @empty_set,
       :attributes => @empty_set, :attribute_options => @empty_set } 
   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, :methods => /^get/, :method => "dup"
-    pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :default_object => @empty_set,
-      :methods => Set.new([/^get/, "dup"]), :method_options => Set.new([]), 
+    pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :join_points => @empty_set,
+      :methods => Set.new([/^get/, "dup"]), :method_options => Set.new([]), :default_object => @empty_set,
       :attributes => @empty_set, :attribute_options => @empty_set } 
   end
   
   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), :objects => @empty_set, :default_object => @empty_set,
-      :methods => Set.new([/^get/, "dup"]), :method_options => Set.new([:instance, :public]), 
+    pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :join_points => @empty_set,
+      :methods => Set.new([/^get/, "dup"]), :method_options => Set.new([:instance, :public]), :default_object => @empty_set,
       :attributes => @empty_set, :attribute_options => @empty_set } 
   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, :default_object => @empty_set,
-      :methods => @empty_set, :method_options => Set.new([]), 
+    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,
       :attributes => Set.new([/^state/, "name"]), :attribute_options => @empty_set } 
   end
   
   it "should return the input :attributes, :attribute and :attribute_options arguments, verbatim." do
     pc = Aquarium::Aspects::Pointcut.new :types => @example_types, :attributes => /^state/, :attribute => "name", :attribute_options => :reader
-    pc.specification.should == { :types => Set.new(@example_types), :objects => @empty_set, :default_object => @empty_set,
-      :methods => @empty_set, :method_options => Set.new([]), 
+    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,
       :attributes => Set.new([/^state/, "name"]), :attribute_options => Set.new([:reader]) } 
   end
 end

data/spec/aquarium/extras/design_by_contract_spec.rb

@@ -51,9 +51,11 @@ describe Aquarium::Extras::DesignByContract, "invariant" do
     end
     attr_reader :invar
     def good_action
+      "good"
     end
     def bad_action
       @invar = 1
+      "bad"
     end
     
     invariant :methods => /action$/, :message => "Must not change the @invar value." do |jp, *args|
@@ -68,4 +70,8 @@ describe Aquarium::Extras::DesignByContract, "invariant" do
   it "should add advice that does not raise if the invariant is satisfied" do
     InvarCond.new.good_action
   end
+  
+  it "should return the value returned by the checked method when the invariant is satisfied" do
+    InvarCond.new.good_action.should == "good"
+  end
 end

data/spec/aquarium/finders/type_finder_spec.rb

@@ -11,13 +11,13 @@ describe Aquarium::Finders::TypeFinder, "#find" do
     lambda { Aquarium::Finders::TypeFinder.new.find "foo" }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
   
-  it "should return no matched and no unmatched expressions by default (i.e., the input is empty)." do
+  it "should return no matched types and no unmatched type expressions by default (i.e., the input is empty)." do
     actual = Aquarium::Finders::TypeFinder.new.find
     actual.matched.should == {}
     actual.not_matched.should == {}
   end
   
-  it "should return no matched and no unmatched expressions if the input hash is empty." do
+  it "should return no matched types and no unmatched type expressions if the input hash is empty." do
     actual = Aquarium::Finders::TypeFinder.new.find {}
     actual.matched.should == {}
     actual.not_matched.should == {}
@@ -61,17 +61,25 @@ end
 
 class Outside
   class Inside1; end
-  class Inside2; end
+  class Inside2
+    class ReallyInside; end
+  end
 end
 
 describe Aquarium::Finders::TypeFinder, "#find with :type or :name used to specify a single type" do
-  it "should find a type matching a simple name (without :: namespace delimiters) using its name." do
+  it "should find a type matching a simple name (without :: namespace delimiters) using its name and the :type option." do
     actual = Aquarium::Finders::TypeFinder.new.find :type => :Object
     actual.matched_keys.should == [Object]
     actual.not_matched.should == {}
   end
   
-  it "should return an empty match for a simple name (without :: namespace delimiters) that doesn't match an existing class." do
+  it "should find a type matching a simple name (without :: namespace delimiters) using its name and the :name option." do
+    actual = Aquarium::Finders::TypeFinder.new.find :name => :Object
+    actual.matched_keys.should == [Object]
+    actual.not_matched.should == {}
+  end
+  
+  it "should return an empty match for a simple name (without :: namespace delimiters) that doesn't match an existing type." do
     actual = Aquarium::Finders::TypeFinder.new.find :name => :Unknown
     actual.matched.should == {}
     actual.not_matched_keys.should == [:Unknown]
@@ -84,7 +92,7 @@ describe Aquarium::Finders::TypeFinder, "#find with :type or :name used to speci
   end
 end
   
-describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :name used to specify one or more names and/or regular expressions" do
+describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :name used to specify one or more names" do
   it "should find types matching simple names (without :: namespace delimiters) using their names." do
     expected_found_types  = [Class, Kernel, Module, Object]
     expected_unfound_exps = %w[TestCase Unknown1 Unknown2]
@@ -92,30 +100,61 @@ describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :
     actual.matched_keys.sort.should == expected_found_types.sort
     actual.not_matched_keys.should == expected_unfound_exps
   end
+
+  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]
+    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
+  end
+end
   
+describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :name used to specify one or more regular expressions" do
   it "should find types matching simple names (without :: namespace delimiters) using lists of regular expressions." do
     expected_found_types  = [Class, Kernel, Module, Object]
     expected_unfound_exps = [/Unknown2/, /^.*TestCase.*$/, /^Unknown1/]
-    actual = Aquarium::Finders::TypeFinder.new.find :types => [/K.+l/, /^Mod.+e$/, /^Object$/, /Clas{2}/, /^.*TestCase.*$/, /^Unknown1/, /Unknown2/]
+    actual = Aquarium::Finders::TypeFinder.new.find :types => [/K.+l/, /^Mod.+e$/, /^Object$/, /^Clas{2}$/, /^.*TestCase.*$/, /^Unknown1/, /Unknown2/]
     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
   end
   
-  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]
-    actual = Aquarium::Finders::TypeFinder.new.find :names => (expected_found_types.map {|t| t.to_s} + expected_unfound_exps)
+  it "should find types matching simple names (without :: namespace delimiters) using regular expressions that match parts of the names." do
+    expected_found_types  = [FalseClass, Module, TrueClass]
+    expected_unfound_exps = []
+    actual = Aquarium::Finders::TypeFinder.new.find :types => [/eClass$/, /^Modu/]
     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
   end
   
   it "should find types with :: namespace delimiters using lists of regular expressions." do
-    expected_found_types  = [Outside::Inside1, Outside::Inside2]
+    expected_found_types  = [Outside::Inside1, Outside::Inside2, Outside::Inside2::ReallyInside]
     expected_unfound_exps = [/^.*Fo+::.*Bar+::Baz.$/]
-    actual = Aquarium::Finders::TypeFinder.new.find :types => [/^.*Fo+::.*Bar+::Baz.$/, /Outside::.*1$/, "Out.*::In.*2"]
+    actual = Aquarium::Finders::TypeFinder.new.find :types => [/^.*Fo+::.*Bar+::Baz.$/, /Outside::.*1$/, /Out.*::In.*2/, /Out.*::In.*2::R.*/]
     actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
     actual.not_matched_keys.should == expected_unfound_exps
   end
+  
+  it "should allow a partial trailing name before the first :: namespace delimiter in a regular expression." do
+    expected_found_types  = [Outside::Inside1, Outside::Inside2]
+    actual = Aquarium::Finders::TypeFinder.new.find :types => [/side::In.*/]
+    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
+    actual.not_matched_keys.size.should == 0
+  end
+  
+  it "should allow a partial leading name after the last :: namespace delimiter in a regular expression." do
+    expected_found_types  = [Outside::Inside1, Outside::Inside2, Outside::Inside2::ReallyInside]
+    actual = Aquarium::Finders::TypeFinder.new.find :types => [/side::In/, /side::Inside2::Real/]
+    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
+    actual.not_matched_keys.size.should == 0
+  end
+  
+  it "should require a full name-matching regular expression between :: namespace delimiters." do
+    expected_found_types  = [Outside::Inside2::ReallyInside]
+    actual = Aquarium::Finders::TypeFinder.new.find :types => [/side::In::Real/]
+    actual.matched_keys.size.should == 0
+    actual.not_matched_keys.should == [/side::In::Real/]
+  end
 end
 
 describe Aquarium::Finders::TypeFinder, "#find" do
@@ -131,7 +170,7 @@ describe Aquarium::Finders::TypeFinder, "#find_all_by" do
   it "should find types with :: namespace delimiters using lists of regular expressions." do
     expected_found_types  = [Outside::Inside1, Outside::Inside2]
     expected_unfound_exps = [/^.*Fo+::.*Bar+::Baz.$/]
-    actual = Aquarium::Finders::TypeFinder.new.find_all_by [/^.*Fo+::.*Bar+::Baz.$/, /Outside::.*1$/, "Out.*::In.*2"]
+    actual = Aquarium::Finders::TypeFinder.new.find_all_by [/^.*Fo+::.*Bar+::Baz.$/, /Outside::.*1$/, /Out.*::In.*2/]
     actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
     actual.not_matched_keys.should == expected_unfound_exps
   end
@@ -206,5 +245,12 @@ describe Aquarium::Finders::TypeFinder, "#find_by_type" do
     actual.not_matched_keys.should == []
   end
 end
+
+# TODO refactor this protected method into a new class.
+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)
+  end
+end