aquarium 0.1.8 → 0.2.0

data/spec/aquarium/utils/type_utils_spec.rb

@@ -1,6 +1,6 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
-require File.dirname(__FILE__) + '/../spec_example_classes'
 require 'aquarium/utils/type_utils'
+require File.dirname(__FILE__) + '/../utils/type_utils_sample_classes'
 
 describe Aquarium::Utils::TypeUtils, ".is_type?" do
   it "should be true for a class" do
@@ -14,4 +14,50 @@ describe Aquarium::Utils::TypeUtils, ".is_type?" do
   it "should be false for an Object" do
     Aquarium::Utils::TypeUtils.is_type?("Object").should be_false
   end
+end
+
+# We don't compare the sizes, because RSpec will add some classes that we don't care about...
+def check_descendent_array clazz, expected
+  actual = Aquarium::Utils::TypeUtils.descendents(clazz)
+  expected.each {|c| actual.should include(c)}
+end
+
+describe Aquarium::Utils::TypeUtils, ".descendents called with a class" do
+  it "should return the class itself in the result" do
+    Aquarium::Utils::TypeUtils.descendents(BaseForDescendents).should include(BaseForDescendents)
+  end
+
+  it "should return just the class if it has no descendents" do
+    Aquarium::Utils::TypeUtils.descendents(D11ForDescendents).should eql([D11ForDescendents])
+    Aquarium::Utils::TypeUtils.descendents(D2ForDescendents).should  eql([D2ForDescendents])
+    Aquarium::Utils::TypeUtils.descendents(Aquarium::ForDescendents::NestedD11ForDescendents).should  eql([Aquarium::ForDescendents::NestedD11ForDescendents])
+    Aquarium::Utils::TypeUtils.descendents(Aquarium::ForDescendents::NestedD2ForDescendents).should   eql([Aquarium::ForDescendents::NestedD2ForDescendents])
+    Aquarium::Utils::TypeUtils.descendents(Aquarium::ForDescendents::NestedD3ForDescendents).should   eql([Aquarium::ForDescendents::NestedD3ForDescendents])
+    Aquarium::Utils::TypeUtils.descendents(Aquarium::ForDescendents::NestedD4ForDescendents).should   eql([Aquarium::ForDescendents::NestedD4ForDescendents])
+    Aquarium::Utils::TypeUtils.descendents(Aquarium::ForDescendents::NestedD31ForDescendents).should  eql([Aquarium::ForDescendents::NestedD31ForDescendents])
+  end
+
+  it "should return all classes and their descendents that derive from a class" do
+    Aquarium::Utils::TypeUtils.sample_classes.each do |t|
+      check_descendent_array t, Aquarium::Utils::TypeUtils.sample_classes_descendents[t]
+    end 
+  end
+end
+
+describe Aquarium::Utils::TypeUtils, ".descendents called with a module" do
+  it "should return the module itself in the result" do
+    Aquarium::Utils::TypeUtils.descendents(ModuleForDescendents).should include(ModuleForDescendents)
+    Aquarium::Utils::TypeUtils.descendents(Aquarium::ForDescendents::NestedModuleForDescendents).should include(Aquarium::ForDescendents::NestedModuleForDescendents)
+  end
+
+  it "should return all classes and their descendents that include a module" do
+    Aquarium::Utils::TypeUtils.sample_modules.each do |t|
+      check_descendent_array t, Aquarium::Utils::TypeUtils.sample_modules_descendents[t]
+    end 
+  end
+  
+  it "should return all modules that include a module" do
+    Aquarium::Utils::TypeUtils.descendents(ModuleForDescendents).should include(ModuleForDescendents)
+    Aquarium::Utils::TypeUtils.descendents(ModuleForDescendents).should include(Aquarium::ForDescendents::Nested2ModuleForDescendents)
+  end
 end

metadata

@@ -1,33 +1,29 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: aquarium
 version: !ruby/object:Gem::Version 
-  version: 0.1.8
-date: 2007-11-03 00:00:00 -05:00
-summary: Aquarium-0.1.8 (r7) - Aspect-Oriented Programming toolkit for Ruby http://aquarium.rubyforge.org
-require_paths: 
-- lib
-email: aquarium-devel@rubyforge.org
-homepage: http://aquarium.rubyforge.org
-rubyforge_project: aquarium
-description: Aquarium is a full-featured Aspect-Oriented Programming (AOP) framework for Ruby that is  designed to provide an intuitive syntax and support for large-scale, dynamic aspects.
-autorequire: aquarium
-default_executable: ""
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
-platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
+  version: 0.2.0
+platform: ""
 authors: 
 - - Aquarium Development Team
+autorequire: aquarium
+bindir: bin
+cert_chain: []
+
+date: 2007-11-24 00:00:00 -06:00
+default_executable: ""
+dependencies: []
+
+description: Aquarium is a full-featured Aspect-Oriented Programming (AOP) framework for Ruby that is  designed to provide an intuitive syntax and support for large-scale, dynamic aspects.
+email: aquarium-devel@rubyforge.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- CHANGES
+- MIT-LICENSE
+- UPGRADE
 files: 
 - CHANGES
 - EXAMPLES.rd
@@ -57,13 +53,13 @@ files:
 - lib/aquarium/extras.rb
 - lib/aquarium/finders/finder_result.rb
 - lib/aquarium/finders/method_finder.rb
-- lib/aquarium/finders/object_finder.rb
 - lib/aquarium/finders/type_finder.rb
 - lib/aquarium/finders.rb
 - lib/aquarium/utils/array_utils.rb
 - lib/aquarium/utils/hash_utils.rb
 - lib/aquarium/utils/html_escaper.rb
 - lib/aquarium/utils/invalid_options.rb
+- lib/aquarium/utils/logic_error.rb
 - lib/aquarium/utils/method_utils.rb
 - lib/aquarium/utils/name_utils.rb
 - lib/aquarium/utils/nil_object.rb
@@ -94,17 +90,19 @@ files:
 - spec/aquarium/extras/design_by_contract_spec.rb
 - spec/aquarium/finders/finder_result_spec.rb
 - spec/aquarium/finders/method_finder_spec.rb
-- spec/aquarium/finders/object_finder_spec.rb
 - spec/aquarium/finders/type_finder_spec.rb
+- spec/aquarium/finders/type_finder_with_descendents_and_ancestors_spec.rb
 - spec/aquarium/spec_example_classes.rb
 - spec/aquarium/spec_helper.rb
 - spec/aquarium/utils/array_utils_spec.rb
 - spec/aquarium/utils/hash_utils_spec.rb
 - spec/aquarium/utils/html_escaper_spec.rb
+- spec/aquarium/utils/logic_error_spec.rb
 - spec/aquarium/utils/method_utils_spec.rb
 - spec/aquarium/utils/name_utils_spec.rb
 - spec/aquarium/utils/nil_object_spec.rb
 - spec/aquarium/utils/set_utils_spec.rb
+- spec/aquarium/utils/type_utils_sample_classes.rb
 - spec/aquarium/utils/type_utils_spec.rb
 - examples/aspect_design_example.rb
 - examples/aspect_design_example_spec.rb
@@ -118,8 +116,9 @@ files:
 - rake_tasks/examples_specdoc.rake
 - rake_tasks/examples_with_rcov.rake
 - rake_tasks/verify_rcov.rake
-test_files: []
-
+has_rdoc: true
+homepage: http://aquarium.rubyforge.org
+post_install_message: 
 rdoc_options: 
 - --title
 - Aquarium
@@ -127,16 +126,26 @@ rdoc_options:
 - --inline-source
 - --main
 - README
-extra_rdoc_files: 
-- README
-- CHANGES
-- MIT-LICENSE
-- UPGRADE
-executables: []
-
-extensions: []
-
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: []
+rubyforge_project: aquarium
+rubygems_version: 0.9.5
+signing_key: 
+specification_version: 2
+summary: Aquarium-0.2.0 (r7) - Aspect-Oriented Programming toolkit for Ruby http://aquarium.rubyforge.org
+test_files: []
 

data/lib/aquarium/finders/object_finder.rb

@@ -1,75 +0,0 @@
-require 'set'
-require File.dirname(__FILE__) + '/../utils/array_utils'
-require File.dirname(__FILE__) + '/type_finder'
-
-
-# Queries the ObjectSpace, so "immediate" objects are never returned.
-# Uses Aquarium::Finders::TypeFinder to map type name regular expressions to types.
-
-module Aquarium
-  module Finders
-    # Deprecated - Will be removed in a future release!
-    class ObjectFinder
-      include Aquarium::Utils::ArrayUtils
-
-      # finder_result = ObjectFinder.new.find [:types => [type_names_and_regexps] | :type => type_name_or_regexp]
-      # where the input types are regular expressions, there may be 0 to
-      # many matching types that appear in the returned hash.
-      # Use #find_all_by_types to find objects matching actual types, not just
-      # names or regular expressions.
-      # <tt>:types => type_names_and_regexps</tt>::
-      #   One or an array of type names and regular expessions to match. 
-      #
-      # <tt>:type => type_name_or_regexp</tt>::
-      #   A type name or regular expession to match. 
-      #
-      # Actually, there is effectively no difference between <tt>:types</tt> and
-      # <tt>:type</tt>. The singular form is "sugar"...
-      def find options = {}
-        type_regexpes_or_names  = make_array options[:types]
-        type_regexpes_or_names += make_array options[:type]
-        if type_regexpes_or_names.empty?
-          return Aquarium::Finders::FinderResult.new
-        end
-        self.find_all_by type_regexpes_or_names
-      end
-  
-      # Input is a list or array object with names and/or regular expressions.  
-      def find_all_by *possible_type_regexpes_or_names
-        raise "Input name or name array can't be nil!" if possible_type_regexpes_or_names.nil?
-        result = Aquarium::Finders::FinderResult.new
-        make_array(*possible_type_regexpes_or_names).each do |expression|
-          found_types = Aquarium::Finders::TypeFinder.new.find :types => expression 
-          found_types.matched_keys.each do |type| 
-            result << find_all_by_types(type)
-          end
-          found_types.not_matched_keys.each do |type| 
-            result.append_not_matched({type => Set.new([])})
-          end
-        end
-        result
-      end
-  
-      # Return the objects in ObjectSpace for the input classes and modules.
-      def find_all_by_types *types
-        result = Aquarium::Finders::FinderResult.new
-        make_array(*types).each do |type|
-          object_space.each_object(type) do |obj|
-            result.append_matched type => obj
-          end
-          result.append_not_matched type => [] unless result.matched[type]
-        end
-        result
-      end
-  
-      def initialize object_space = ObjectSpace
-        @object_space = object_space
-      end
-  
-      protected
-  
-      attr_reader :object_space
-
-    end
-  end
-end

data/spec/aquarium/finders/object_finder_spec.rb

@@ -1,231 +0,0 @@
-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.matched[OBase].each {|o| [b1, b2, d1, d2].include?(o)}
-    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