aquarium 0.1.0

data/spec/aquarium/finders/method_sorting_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+
+describe "Method Extension" do
+  it "should compare methods by type and name." do
+    actual = %w[send nil? clone gsub! ].map {|m| Kernel.method(m)} 
+    actual << Module.method(:nesting)
+    sorted = actual.sort_by {|method| method.to_s}
+    sorted.should == [
+      Kernel.method(:gsub!),
+      Kernel.method(:clone),
+      Kernel.method(:nil?),
+      Kernel.method(:send),
+      Module.method(:nesting)
+    ]
+  end
+end

data/spec/aquarium/finders/object_finder_spec.rb

@@ -0,0 +1,230 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'aquarium/finders/object_finder'
+
+# :stopdoc:
+class OBase
+  attr_reader :name
+  def initialize name; @name = name; end
+  def == other
+    name == other.name
+  end
+end
+
+class ODerived < OBase
+  def initialize name; super; end
+end
+
+module Mod; end
+
+class IncludesMod
+  include Mod
+  attr_reader :name
+  def initialize name; @name = name; end
+  def == other
+    name == other.name
+  end
+end
+  
+class ClassNotInstantiated; end
+class ClassNotInstantiated2; end
+# :startdoc:
+
+b1 = OBase.new "b1"
+b2 = OBase.new "b2"
+d1 = ODerived.new "d1"
+d2 = ODerived.new "d2"
+m1 = IncludesMod.new "m1"
+m2 = IncludesMod.new "m2"
+
+def space_of_objects
+end
+
+# Running the tests with the real Aquarium::Finders::ObjectFinder is too slow when looking
+# for "objects" of type Class or Module, i.e., to retrieve classes and modules.
+class MockObjectSpace
+  @@space_of_objects = [OBase, ODerived, String, IncludesMod, Mod, Kernel, Class]
+  
+  def self.each_object type
+    @@space_of_objects.each do |object|
+      yield(object) if (object.kind_of?(type) and block_given?)
+    end
+  end
+end
+
+class TestObjectFinder < Aquarium::Finders::ObjectFinder
+  def initialize
+    super MockObjectSpace
+  end
+end
+
+describe Aquarium::Finders::ObjectFinder, "#find_all_by_types" do
+  it "should return an empty FinderResult#matched hash and FinderResult#not_matched list if no types are specified." do
+    actual = Aquarium::Finders::ObjectFinder.new.find_all_by_types
+    actual.matched.should == {}
+    actual.not_matched == []
+  end
+
+  it "should return the input types in the FinderResult#not_matched list if the specified types have no instances." do
+    actual = Aquarium::Finders::ObjectFinder.new.find_all_by_types ClassNotInstantiated
+    actual.matched_keys.should == []
+    actual.not_matched == [ClassNotInstantiated]
+  end
+end
+
+describe Aquarium::Finders::ObjectFinder, ".find_all_by_types" do
+  
+  it "should return all objects of a specified base type and its derivatives." do
+    actual = Aquarium::Finders::ObjectFinder.new.find_all_by_types(OBase)
+    actual.matched.size.should == 1
+    actual.matched[OBase].sort_by {|o| o.name}.should == [b1, b2, d1, d2]
+    actual.not_matched.should == {}
+  end
+  
+  it "should return all objects of a specified derived type." do
+    actual = Aquarium::Finders::ObjectFinder.new.find_all_by_types(ODerived)
+    actual.matched.size.should == 1
+    actual.matched[ODerived].sort_by {|o| o.name}.should == [d1, d2]
+    actual.not_matched.should == {}
+  end
+  
+  it "should return all objects of a specified module." do
+    actual = Aquarium::Finders::ObjectFinder.new.find_all_by_types(Mod)
+    actual.matched.size.should == 1
+    actual.matched[Mod].sort_by {|o| o.name}.should == [m1, m2]
+    actual.not_matched.should == {}
+  end
+  
+  it "should return all objects of a list of types." do
+    actual = Aquarium::Finders::ObjectFinder.new.find_all_by_types(ODerived, Mod)
+    actual.matched.size.should == 2
+    actual.matched[ODerived].sort_by {|o| o.name}.should == [d1, d2]
+    actual.matched[Mod].sort_by {|o| o.name}.should == [m1, m2]
+    actual.not_matched.should == {}
+  end
+  
+  it "should return all objects of an array of types." do
+    actual = Aquarium::Finders::ObjectFinder.new.find_all_by_types([ODerived, Mod])
+    actual.matched.size.should == 2
+    actual.matched[ODerived].sort_by {|o| o.name}.should == [d1, d2]
+    actual.matched[Mod].sort_by {|o| o.name}.should == [m1, m2]
+    actual.not_matched.should == {}
+  end
+  
+end
+
+describe Aquarium::Finders::ObjectFinder, "#find" do
+  
+  it "should return all objects of a specified base type and its derivatives." do
+    actual = Aquarium::Finders::ObjectFinder.new.find :type => OBase
+    actual.matched.size.should == 1
+    actual.matched[OBase].sort_by {|o| o.name}.should == [b1, b2, d1, d2]
+    actual.not_matched.should == {}
+  end
+  
+  it "should return all objects of a specified derived type." do
+    actual = Aquarium::Finders::ObjectFinder.new.find :types => ODerived
+    actual.matched.size.should == 1
+    actual.matched[ODerived].sort_by {|o| o.name}.should == [d1, d2]
+    actual.not_matched.should == {}
+  end
+  
+  it "should return all objects of a specified module." do
+    actual = Aquarium::Finders::ObjectFinder.new.find :type => Mod
+    actual.matched.size.should == 1
+    actual.matched[Mod].sort_by {|o| o.name}.should == [m1, m2]
+    actual.not_matched.should == {}
+  end
+  
+  it "should return all objects of a list of types." do
+    actual = Aquarium::Finders::ObjectFinder.new.find :type => [ODerived, Mod]
+    actual.matched.size.should == 2
+    actual.matched[ODerived].sort_by {|o| o.name}.should == [d1, d2]
+    actual.matched[Mod].sort_by {|o| o.name}.should == [m1, m2]
+    actual.not_matched.should == {}
+  end
+  
+  it "should accept an array of one type or the type itself as the value for the :type key." do
+    actual1 = Aquarium::Finders::ObjectFinder.new.find :type => Mod
+    actual2 = Aquarium::Finders::ObjectFinder.new.find :type => [Mod]
+    actual1.matched.should == actual2.matched
+    actual1.matched.should == actual2.matched
+  end
+  
+  it "should accept :type as a synonym for the :types key." do
+    actual1 = Aquarium::Finders::ObjectFinder.new.find :types => Mod
+    actual2 = Aquarium::Finders::ObjectFinder.new.find :type => Mod
+    actual1.matched.should == actual2.matched
+    actual1.matched.should == actual2.matched
+  end
+  
+
+  it "should behave as find_all_by with a different invocation syntax." do
+    actual1 = Aquarium::Finders::ObjectFinder.new.find :types => Mod
+    actual2 = Aquarium::Finders::ObjectFinder.new.find :type => Mod
+    actual1.matched.should == actual2.matched
+    actual1.matched.should == actual2.matched
+  end
+end
+
+describe Aquarium::Finders::ObjectFinder, "#find" do
+  it "should return an empty FinderResult#matched hash and FinderResult#not_matched list if no types are specified." do
+    actual = Aquarium::Finders::ObjectFinder.new.find
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+
+  it "should return the input types in the FinderResult#not_matched list if the types have no instances." do
+    actual = Aquarium::Finders::ObjectFinder.new.find :type => "ClassNotInstantiated"
+    actual.matched_keys.should == []
+    actual.not_matched_keys.should == [ClassNotInstantiated]
+  end
+  
+  it "should accept a single type name as the value for the key :type." do
+    actual = Aquarium::Finders::ObjectFinder.new.find :type => "ClassNotInstantiated"
+    actual.matched_keys.should == []
+    actual.not_matched_keys.should == [ClassNotInstantiated]
+  end
+
+  it "should accept an array of type names as the value for the key :types." do
+    actual = Aquarium::Finders::ObjectFinder.new.find :type => ["ClassNotInstantiated", "ClassNotInstantiated2"]
+    actual.matched_keys.should == []
+    actual.not_matched_keys.size.should == 2
+    actual.not_matched_keys.should include(ClassNotInstantiated)
+    actual.not_matched_keys.should include(ClassNotInstantiated2)
+  end
+
+  it "should return the input types in the FinderResult#not_matched list if the types do not exist." do
+    type_list = [/^NeverBeforeSeen/, "NotLikelyToExistClass"]
+    actual = Aquarium::Finders::ObjectFinder.new.find :type => type_list
+    actual.matched_keys.should == []
+    actual.not_matched_keys.should == type_list
+  end
+  
+  it "should accept :type and :types as synonyms for type name hash keys." do
+    type_list = [/^NeverBeforeSeen/, "NotLikelyToExistClass"]
+    actual1 = Aquarium::Finders::ObjectFinder.new.find :type => type_list
+    actual2 = Aquarium::Finders::ObjectFinder.new.find :types => type_list
+    actual1.matched.should == actual2.matched
+    actual1.not_matched.should  == actual2.not_matched
+  end
+end
+
+describe Aquarium::Finders::ObjectFinder, "#find" do 
+  it "should return classes, not objects, when given Class as the type." do
+    # Uses Test override for faster test execution.
+    actual = TestObjectFinder.new.find :type => Class
+    actual.matched[Class].should include(OBase)
+    actual.matched[Class].should include(ODerived)
+    actual.matched[Class].should include(String)
+    actual.not_matched_keys.should == []
+  end
+
+  it "should return modules, not objects, when given Module as the type." do
+    # Uses Test override for faster test execution.
+    actual = TestObjectFinder.new.find :type => Module
+    actual.matched[Module].should include(Mod)
+    actual.matched[Module].should include(Kernel)
+    actual.matched[Module].should include(Class)
+    actual.not_matched_keys.should == []
+  end
+end

data/spec/aquarium/finders/type_finder_spec.rb

@@ -0,0 +1,210 @@
+require File.dirname(__FILE__) + '/../spec_helper.rb'
+require 'aquarium/finders/type_finder'
+
+describe Aquarium::Finders::TypeFinder, "#find" do
+
+  it "should raise if an uknown option is specified." do
+    lambda { Aquarium::Finders::TypeFinder.new.find :foo => 'bar', :baz => ''}.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+  
+  it "should raise if the input parameters do not form a hash." 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
+    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
+    actual = Aquarium::Finders::TypeFinder.new.find {}
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+  
+  it "should trim leading and trailing whitespace in the specified types." do
+    actual = Aquarium::Finders::TypeFinder.new.find :type => ["  \t ", "\t \n"]
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+  
+  it "should ignore an empty string as the specified type." do
+    actual = Aquarium::Finders::TypeFinder.new.find :type => "  \t "
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+  
+  it "should ignore empty strings as the specified types in an array of types." do
+    actual = Aquarium::Finders::TypeFinder.new.find :types => ["  \t ", "\t \n"]
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+end
+
+describe Aquarium::Finders::TypeFinder, "#is_recognized_option" do
+  
+  it "should be true for :names, :types, :name, :type (synonyms), as strings or symbols." do
+    %w[name type names types].each do |s|
+      Aquarium::Finders::TypeFinder.is_recognized_option(s).should == true
+      Aquarium::Finders::TypeFinder.is_recognized_option(s.to_sym).should == true
+    end
+  end  
+  
+  it "should be false for unknown options." do
+    %w[public2 wierd unknown string method object].each do |s|
+      Aquarium::Finders::TypeFinder.is_recognized_option(s).should == false
+      Aquarium::Finders::TypeFinder.is_recognized_option(s.to_sym).should == false
+    end
+  end
+end
+
+class Outside
+  class Inside1; end
+  class Inside2; 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
+    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
+    actual = Aquarium::Finders::TypeFinder.new.find :name => :Unknown
+    actual.matched.should == {}
+    actual.not_matched_keys.should == [:Unknown]
+  end
+  
+  it "should find a type matching a name with :: namespace delimiters using its name." do
+    actual = Aquarium::Finders::TypeFinder.new.find :name => "Outside::Inside1"
+    actual.matched_keys.should == [Outside::Inside1]
+    actual.not_matched.should == {}
+  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
+  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]
+    actual = Aquarium::Finders::TypeFinder.new.find :types=> %w[Kernel Module Object Class TestCase Unknown1 Unknown2]
+    actual.matched_keys.sort.should == expected_found_types.sort
+    actual.not_matched_keys.should == expected_unfound_exps
+  end
+  
+  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.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)
+    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_unfound_exps = [/^.*Fo+::.*Bar+::Baz.$/]
+    actual = Aquarium::Finders::TypeFinder.new.find :types => [/^.*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
+end
+
+describe Aquarium::Finders::TypeFinder, "#find" do
+  it "should find types when types given." do
+    expected_found_types  = [Outside::Inside1, Outside::Inside2]
+    actual = Aquarium::Finders::TypeFinder.new.find :names => expected_found_types
+    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
+    actual.not_matched_keys.should == []
+  end
+end
+
+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.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 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_all_by(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.should == expected_unfound_exps
+  end
+
+  it "should find types when types given." do
+    expected_found_types  = [Outside::Inside1, Outside::Inside2]
+    actual = Aquarium::Finders::TypeFinder.new.find_all_by expected_found_types
+    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
+    actual.not_matched_keys.should == []
+  end
+end
+
+describe Aquarium::Finders::TypeFinder, "#find_by_name" do
+  it "should find a single type when given a single type name." do
+    tf = Aquarium::Finders::TypeFinder.new
+    actual = tf.find_by_name("String")
+    actual.matched_keys.should == [String]
+    actual.not_matched_keys.should == []
+    actual = tf.find_by_name("Kernel")
+    actual.matched_keys.should == [Kernel]
+    actual.not_matched_keys.should == []
+    actual = tf.find_by_name("Module")
+    actual.matched_keys.should == [Module]
+    actual.not_matched_keys.should == []
+  end
+
+  it "should find a single type when given a valid type name with :: separators." do
+    tf = Aquarium::Finders::TypeFinder.new
+    actual = tf.find_by_name "Outside::Inside1"
+    actual.matched_keys.should == [Outside::Inside1]
+    actual.not_matched_keys.should == []
+  end
+
+  it "should find a single type when given that type." do
+    tf = Aquarium::Finders::TypeFinder.new
+    actual = tf.find_by_name Outside::Inside1
+    actual.matched_keys.should == [Outside::Inside1]
+    actual.not_matched_keys.should == []
+  end
+
+  it "should return no matches if the type can't be found." do
+    tf = Aquarium::Finders::TypeFinder.new
+    actual = tf.find_by_name "UnknownClass1::UnknownClass2"
+    actual.matched_keys.should == []
+    actual.not_matched_keys.should == ["UnknownClass1::UnknownClass2"]
+  end
+
+  it "should return no matches if the type name is invalid." do
+    tf = Aquarium::Finders::TypeFinder.new
+    actual = tf.find_by_name "$foo:bar"
+    actual.matched_keys.should == []
+    actual.not_matched_keys.should == ["$foo:bar"]
+  end
+end
+
+describe Aquarium::Finders::TypeFinder, "#find_by_type" do
+  it "is synonymous with find_by_name." do
+    tf = Aquarium::Finders::TypeFinder.new
+    actual = tf.find_by_name "Outside::Inside1"
+    actual.matched_keys.should == [Outside::Inside1]
+    actual.not_matched_keys.should == []
+    actual = tf.find_by_name Outside::Inside1
+    actual.matched_keys.should == [Outside::Inside1]
+    actual.not_matched_keys.should == []
+  end
+end
+ 
+