aquarium 0.4.0 → 0.4.1

data/spec/aquarium/finders/type_finder_spec.rb

@@ -7,6 +7,7 @@ class Outside
     class ReallyInside; end
   end
 end
+class SubOutside < Outside; end
 
 describe Aquarium::Finders::TypeFinder, "#find invocation parameters" do
 
@@ -18,16 +19,18 @@ describe Aquarium::Finders::TypeFinder, "#find invocation parameters" do
     lambda { Aquarium::Finders::TypeFinder.new.find "foo" }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
   
-  it "should raise if the input type value is nil." do
-    lambda { Aquarium::Finders::TypeFinder.new.find :type => nil }.should raise_error(Aquarium::Utils::InvalidOptions)
-  end
-  
   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 types and no unmatched type expressions if nil is specified for the types." do
+    actual = Aquarium::Finders::TypeFinder.new.find :type => nil
+    actual.matched.should == {}
+    actual.not_matched.should == {}
+  end
+  
   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 == {}
@@ -62,51 +65,33 @@ describe Aquarium::Finders::TypeFinder, "#find invocation parameters" do
   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
-
-
-describe Aquarium::Finders::TypeFinder, "#find with :type or :name used to specify a single type" do
+describe Aquarium::Finders::TypeFinder, "#find with :types used to specify a single type" 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 = Aquarium::Finders::TypeFinder.new.find :types => :Object
     actual.matched_keys.should == [Object]
     actual.not_matched.should == {}
   end
   
   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 = Aquarium::Finders::TypeFinder.new.find :types => :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 = Aquarium::Finders::TypeFinder.new.find :types => :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 = Aquarium::Finders::TypeFinder.new.find :types => "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" do
+
+describe Aquarium::Finders::TypeFinder, "#find with :types 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]
@@ -124,7 +109,7 @@ describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :
   end
 end
   
-describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :name used to specify one or more regular expressions" do
+describe Aquarium::Finders::TypeFinder, "#find with :types 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/]
@@ -172,6 +157,16 @@ describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :
   end
 end
 
+describe Aquarium::Finders::TypeFinder, "#find with :types" do
+  Aquarium::Finders::TypeFinder::CANONICAL_OPTIONS["types"].reject{|key| key.eql?("types")}.each do |key|
+    it "should accept :#{key} as a synonym for :types." do
+      actual = Aquarium::Finders::TypeFinder.new.find key.intern => "Outside::Inside1"
+      actual.matched_keys.should == [Outside::Inside1]
+      actual.not_matched.should == {}
+    end
+  end  
+end
+  
 describe Aquarium::Finders::TypeFinder, "#find with :exclude_types" do
   it "should exclude types specified with a regular expression." do
     expected_found_types  = [Class, Module, Object]
@@ -193,35 +188,45 @@ describe Aquarium::Finders::TypeFinder, "#find with :exclude_types" do
     actual.not_matched.size.should == 0
   end
 
-  it "should be a synonym for :exclude_type." do
-    expected_found_types  = [Class, Module]
-    actual = Aquarium::Finders::TypeFinder.new.find :types => [/K.+l/, /^Mod.+e$/, /^Object$/, /^Clas{2}$/], :exclude_type => [Kernel, Object]
+  Aquarium::Finders::TypeFinder::CANONICAL_OPTIONS["exclude_types"].reject{|key| key.eql?("exclude_types")}.each do |key|
+    it "should accept :#{key} as a synonym for :exclude_types." do
+      expected_found_types  = [Class, Module]
+      actual = Aquarium::Finders::TypeFinder.new.find :types => [/K.+l/, /^Mod.+e$/, /^Object$/, /^Clas{2}$/], key.intern => [Kernel, Object]
+      actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
+      actual.not_matched.size.should == 0
+    end
+  end  
+end
+  
+describe Aquarium::Finders::TypeFinder, "#find with :types_and_descendents" do
+  it "should find the types and their descendents." do
+    expected_found_types  = [Outside, SubOutside]
+    actual = Aquarium::Finders::TypeFinder.new.find :types_and_descendents => Outside
     actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
     actual.not_matched.size.should == 0
   end
 
-  it "should be a synonym for :exclude_names." do
-    expected_found_types  = [Class, Module]
-    actual = Aquarium::Finders::TypeFinder.new.find :types => [/K.+l/, /^Mod.+e$/, /^Object$/, /^Clas{2}$/], :exclude_names => [Kernel, Object]
-    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
-    actual.not_matched.size.should == 0
-  end
+  Aquarium::Finders::TypeFinder::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 {actual = Aquarium::Finders::TypeFinder.new.find key.intern => Outside, :noop => true}.should_not raise_error
+    end
+  end  
+end
 
-  it "should be a synonym for :exclude_name." do
-    expected_found_types  = [Class, Module]
-    actual = Aquarium::Finders::TypeFinder.new.find :types => [/K.+l/, /^Mod.+e$/, /^Object$/, /^Clas{2}$/], :exclude_name => [Kernel, Object]
-    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
+describe Aquarium::Finders::TypeFinder, "#find with :types_and_ancestors" do
+  it "should find the types and their ancestors." do
+    actual = Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => SubOutside
+    [Outside, SubOutside, Kernel, Object].each do |x| 
+      actual.matched_keys.should include(x)
+    end
     actual.not_matched.size.should == 0
   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
+
+  Aquarium::Finders::TypeFinder::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 {actual = Aquarium::Finders::TypeFinder.new.find key.intern => SubOutside, :noop => true}.should_not raise_error
+    end
+  end  
 end
 
 

data/spec/aquarium/finders/type_finder_with_descendents_and_ancestors_spec.rb

@@ -21,9 +21,9 @@ describe TypeUtils, "#find types and their descendents, using :types_and_descend
     end
   end
 
-  Aquarium::Finders::TypeFinder::TYPES_SYNONYMS.reject{|t| t == :types}.each do |n|
-    it "should accept :#{n}_and_descendents as a synonym for :types_and_descendents" do
-      lambda {Aquarium::Finders::TypeFinder.new.find "#{n}_and_descendents".intern => TypeUtils.sample_types, :noop => true}.should_not raise_error(InvalidOptions)
+  Aquarium::Finders::TypeFinder::CANONICAL_OPTIONS["types_and_descendents"].each do |synonym|
+    it "should accept :#{synonym} as a synonym for :types_and_descendents" do
+      lambda {Aquarium::Finders::TypeFinder.new.find synonym.intern => TypeUtils.sample_types, :noop => true}.should_not raise_error(InvalidOptions)
     end
   end
 end
@@ -39,9 +39,9 @@ describe TypeUtils, "#find types subtracting out excluded types and descendents,
     actual.not_matched_keys.should == []
   end
 
-  Aquarium::Finders::TypeFinder::TYPES_SYNONYMS.reject{|t| t == :types}.each do |n|
-    it "should accept :exclude_#{n}_and_descendents as a synonym for :exclude_types_and_descendents" do
-      lambda {Aquarium::Finders::TypeFinder.new.find :types_and_descendents => ModuleForDescendents, "exclude_#{n}_and_descendents".intern => D1ForDescendents, :noop => true}.should_not raise_error(InvalidOptions)
+  Aquarium::Finders::TypeFinder::CANONICAL_OPTIONS["exclude_types_and_descendents"].each do |synonym|
+    it "should accept :#{synonym} as a synonym for :exclude_types_and_descendents" do
+      lambda {Aquarium::Finders::TypeFinder.new.find :types_and_descendents => ModuleForDescendents, synonym.intern => D1ForDescendents, :noop => true}.should_not raise_error(InvalidOptions)
     end
   end
 end
@@ -57,9 +57,9 @@ describe TypeUtils, "#find types and their ancestors, using :types_and_ancestors
     end
   end
 
-  Aquarium::Finders::TypeFinder::TYPES_SYNONYMS.reject{|t| t == :types}.each do |n|
-    it "should accept :#{n}_and_ancestors as a synonym for :types_and_ancestors" do
-      lambda {Aquarium::Finders::TypeFinder.new.find "#{n}_and_ancestors".intern => TypeUtils.sample_types, :noop => true}.should_not raise_error(InvalidOptions)
+  Aquarium::Finders::TypeFinder::CANONICAL_OPTIONS["types_and_ancestors"].each do |synonym|
+    it "should accept :#{synonym} as a synonym for :types_and_ancestors" do
+      lambda {Aquarium::Finders::TypeFinder.new.find synonym.intern => TypeUtils.sample_types, :noop => true}.should_not raise_error(InvalidOptions)
     end
   end
 end
@@ -76,9 +76,9 @@ describe TypeUtils, "#find types subtracting out excluded types and ancestors, u
     actual.not_matched_keys.should == []
   end
 
-  Aquarium::Finders::TypeFinder::TYPES_SYNONYMS.reject{|t| t == :types}.each do |n|
-    it "should accept :exclude_#{n}_and_ancestors as a synonym for :exclude_types_and_ancestors" do
-      lambda {Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => D1ForDescendents, "exclude_#{n}_and_ancestors".intern => ModuleForDescendents, :noop => true}.should_not raise_error(InvalidOptions)
+  Aquarium::Finders::TypeFinder::CANONICAL_OPTIONS["exclude_types_and_ancestors"].each do |synonym|
+    it "should accept :#{synonym} as a synonym for :exclude_types_and_ancestors" do
+      lambda {Aquarium::Finders::TypeFinder.new.find :types_and_ancestors => D1ForDescendents, synonym.intern => ModuleForDescendents, :noop => true}.should_not raise_error(InvalidOptions)
     end
   end
 end

data/spec/aquarium/spec_example_types.rb

@@ -1,6 +1,6 @@
 # :enddoc:
 
-require 'aquarium/aspects/dsl/aspect_dsl'
+require 'aquarium/dsl/aspect_dsl'
 
 # Declares classes, etc. that support several different module specs.
 class ExampleParentClass
@@ -101,7 +101,7 @@ class ClassWithAttribs < ExampleParentClass
 end
 
 class Watchful 
-  include Aquarium::Aspects::DSL::AspectDSL
+  include Aquarium::DSL
   class WatchfulError < Exception
     def initialize message = nil
       super
@@ -225,7 +225,8 @@ module Aquarium
     include SpecExampleTypes
     
     def stub_type_utils_descendents
-  	  @stubbed_type_utils_descendents = Aspect.new :around, :calls_to => :descendents, :on_type => Aquarium::Utils::TypeUtils, :restricting_methods_to => :class_methods do |jp, object, *args|
+  	  @stubbed_type_utils_descendents = Aspect.new :around, :calls_to => :descendents, :on_type => Aquarium::Utils::TypeUtils, 
+  	      :restricting_methods_to => :class_methods do |jp, object, *args|
         descendents[args[0]]
       end
     end

data/spec/aquarium/utils/array_utils_spec.rb

@@ -49,24 +49,26 @@ describe Aquarium::Utils::ArrayUtils, "#make_array" do
   end
 end
 
-describe Aquarium::Utils::ArrayUtils, "#strip_nils" do
+describe Aquarium::Utils::ArrayUtils, "#strip_array_nils" do
   it "should return an empty array if an input array contains all nils." do
-    strip_nils([nil, nil]).should == []
+    strip_array_nils([nil, nil]).should == []
   end
   
   it "should return an empty array if an input Set contains all nils." do
-    strip_nils(Set.new([nil, nil])).should == []
+    strip_array_nils(Set.new([nil, nil])).should == []
   end
   
   it "should return an array with all nils removed from the input array." do
-    strip_nils([nil, 1, 2, nil, 3, 4]).should == [1, 2, 3, 4]
+    strip_array_nils([nil, 1, 2, nil, 3, 4]).should == [1, 2, 3, 4]
   end
 
   it "should return an array with all nils removed from the input Set." do
-    strip_nils(Set.new([nil, 1, 2, nil, 3, 4])).should == [1, 2, 3, 4]
+    strip_array_nils(Set.new([nil, 1, 2, nil, 3, 4])).should == [1, 2, 3, 4]
   end
+end
 
-  it "should be accessible as a class method." do
-    Aquarium::Utils::ArrayUtils.strip_nils(Set.new([nil, 1, 2, nil, 3, 4])).should == [1, 2, 3, 4]
+describe Aquarium::Utils::ArrayUtils, ".strip_array_nils" do
+  it "should work like the instance method." do
+    Aquarium::Utils::ArrayUtils.strip_array_nils(Set.new([nil, 1, 2, nil, 3, 4])).should == [1, 2, 3, 4]
   end
 end

data/spec/aquarium/utils/options_utils_spec.rb

@@ -8,10 +8,7 @@ module Aquarium
   class OptionsUtilsUser
     include OptionsUtils
     def initialize hash = {}
-      init_specification hash, {}
-    end
-    def all_allowed_option_symbols
-      []
+      init_specification hash, {}, []
     end
   end
 end
@@ -119,4 +116,108 @@ describe OptionsUtils, "#noop=" do
     object.noop = false
     object.noop.should be_false
   end
-end
+end
+
+module Aquarium
+  class OptionsUtilsExample
+    include OptionsUtils
+    CANONICAL_OPTIONS = {
+      "foos" => %w[foo foo1 foo2],
+      "bars" => %w[bar bar1 bar2]
+    }
+    def initialize options = {}
+      init_specification options, CANONICAL_OPTIONS
+    end
+  end
+  
+  class OptionsUtilsExampleWithCanonicalOptionsAccessors < OptionsUtilsExample
+    canonical_option_accessor CANONICAL_OPTIONS
+  end
+  class OptionsUtilsExampleWithAccessors < OptionsUtilsExample
+    canonical_option_accessor :foos, :bars
+  end
+  class OptionsUtilsExampleWithReaders < OptionsUtilsExample
+    canonical_option_reader :foos, :bars
+  end
+  class OptionsUtilsExampleWithWriters < OptionsUtilsExample
+    canonical_option_writer :foos, :bars
+  end
+  class OptionsUtilsExampleWithAdditionalAllowedOptions
+    include OptionsUtils
+    CANONICAL_OPTIONS = {
+      "foos" => %w[foo foo1 foo2],
+      "bars" => %w[bar bar1 bar2]
+    }
+    canonical_option_writer :foos, :bars
+    def initialize options = {}
+      init_specification options, CANONICAL_OPTIONS, [:baz, :bbb]
+    end
+  end
+end
+
+describe OptionsUtils, ".canonical_option_accessor" do
+  it "should create a reader and writer method for each option" do
+    Aquarium::OptionsUtilsExampleWithAccessors.instance_methods.should include("foos")
+    Aquarium::OptionsUtilsExampleWithAccessors.instance_methods.should include("bars")
+    Aquarium::OptionsUtilsExampleWithAccessors.instance_methods.should include("foos=")
+    Aquarium::OptionsUtilsExampleWithAccessors.instance_methods.should include("bars=")
+  end
+  it "should accept individual options" do
+    Aquarium::OptionsUtilsExampleWithAccessors.instance_methods.should include("foos")
+    Aquarium::OptionsUtilsExampleWithAccessors.instance_methods.should include("bars")
+    Aquarium::OptionsUtilsExampleWithAccessors.instance_methods.should include("foos=")
+    Aquarium::OptionsUtilsExampleWithAccessors.instance_methods.should include("bars=")
+  end
+  it "should accept the CANONICAL_OPTIONS as an argument" do
+    Aquarium::OptionsUtilsExampleWithCanonicalOptionsAccessors.instance_methods.should include("foos")
+    Aquarium::OptionsUtilsExampleWithCanonicalOptionsAccessors.instance_methods.should include("bars")
+    Aquarium::OptionsUtilsExampleWithCanonicalOptionsAccessors.instance_methods.should include("foos=")
+    Aquarium::OptionsUtilsExampleWithCanonicalOptionsAccessors.instance_methods.should include("bars=")
+  end
+end
+describe OptionsUtils, ".canonical_option_reader" do
+  it "creates a reader method for each option" do
+    Aquarium::OptionsUtilsExampleWithReaders.instance_methods.should include("foos")
+    Aquarium::OptionsUtilsExampleWithReaders.instance_methods.should include("bars")
+    Aquarium::OptionsUtilsExampleWithReaders.instance_methods.should_not include("foos=")
+    Aquarium::OptionsUtilsExampleWithReaders.instance_methods.should_not include("bars=")
+  end
+  it "should create readers that return set values" do
+    object = Aquarium::OptionsUtilsExampleWithReaders.new
+    object.foos.class.should == Set
+  end
+end
+describe OptionsUtils, ".canonical_option_writer" do
+  it "creates a writer method for each option" do
+    Aquarium::OptionsUtilsExampleWithWriters.instance_methods.should_not include("foos")
+    Aquarium::OptionsUtilsExampleWithWriters.instance_methods.should_not include("bars")
+    Aquarium::OptionsUtilsExampleWithWriters.instance_methods.should include("foos=")
+    Aquarium::OptionsUtilsExampleWithWriters.instance_methods.should include("bars=")
+  end
+  it "should create writers that convert the input values to sets, if they aren't already sets" do
+    object = Aquarium::OptionsUtilsExampleWithAccessors.new
+    object.foos = "bar"
+    object.foos.class.should == Set
+  end
+  it "should create writers that leave the input sets unchanged" do
+    expected = Set.new([:b1, :b2])
+    object = Aquarium::OptionsUtilsExampleWithAccessors.new
+    object.foos = expected
+    object.foos.should == expected
+  end
+end
+
+describe OptionsUtils, "and options handling" do
+  it "should raise if an unknown option is specified" do
+    lambda {Aquarium::OptionsUtilsExampleWithAdditionalAllowedOptions.new :unknown => true}.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+  it "should not raise if a known canonical option is specified" do
+    lambda {Aquarium::OptionsUtilsExampleWithAdditionalAllowedOptions.new :foos => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+  end
+  it "should not raise if a known canonical option synonym is specified" do
+    lambda {Aquarium::OptionsUtilsExampleWithAdditionalAllowedOptions.new :foo1 => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+  end
+  it "should not raise if an known additional allowed option is specified" do
+    lambda {Aquarium::OptionsUtilsExampleWithAdditionalAllowedOptions.new :baz => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+  end
+end

data/spec/aquarium/utils/set_utils_spec.rb

@@ -58,3 +58,17 @@ describe Aquarium::Utils::SetUtils, "make_set" do
     make_set(Set.new([nil, 1, 2, nil, 3, 4])).should == Set.new([1, 2, 3, 4])
   end
 end
+
+describe Aquarium::Utils::SetUtils, "strip_set_nils" do
+  it "should return an empty set if an empty set is specified" do
+    strip_set_nils(Set.new([])).should == Set.new([])
+  end
+
+  it "should return an empty set if a set of only nil values is specified" do
+    strip_set_nils(Set.new([nil, nil])).should == Set.new([])
+  end
+
+  it "should return a set will all nil values removed" do
+    strip_set_nils(Set.new([nil, :a, nil, :b])).should == Set.new([:a, :b])
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aquarium
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors: 
 - Aquarium Development Team
@@ -9,7 +9,7 @@ autorequire: aquarium
 bindir: bin
 cert_chain: []
 
-date: 2008-02-25 00:00:00 -06:00
+date: 2008-04-15 00:00:00 -05:00
 default_executable: ""
 dependencies: []
 
@@ -33,18 +33,19 @@ files:
 - Rakefile
 - README
 - RELEASE-PLAN
+- TODO.rb
 - UPGRADE
 - lib/aquarium/aspects/advice.rb
 - lib/aquarium/aspects/aspect.rb
 - lib/aquarium/aspects/default_objects_handler.rb
-- lib/aquarium/aspects/dsl/aspect_dsl.rb
-- lib/aquarium/aspects/dsl/object_dsl.rb
-- lib/aquarium/aspects/dsl.rb
 - lib/aquarium/aspects/exclusion_handler.rb
 - lib/aquarium/aspects/join_point.rb
 - lib/aquarium/aspects/pointcut.rb
 - lib/aquarium/aspects/pointcut_composition.rb
 - lib/aquarium/aspects.rb
+- lib/aquarium/dsl/aspect_dsl.rb
+- lib/aquarium/dsl/object_dsl.rb
+- lib/aquarium/dsl.rb
 - lib/aquarium/extensions/hash.rb
 - lib/aquarium/extensions/regexp.rb
 - lib/aquarium/extensions/set.rb
@@ -82,11 +83,11 @@ files:
 - spec/aquarium/aspects/concurrent_aspects_with_objects_and_types_spec.rb
 - spec/aquarium/aspects/concurrently_accessed.rb
 - spec/aquarium/aspects/default_objects_handler_spec.rb
-- spec/aquarium/aspects/dsl/aspect_dsl_spec.rb
 - spec/aquarium/aspects/join_point_spec.rb
 - spec/aquarium/aspects/pointcut_and_composition_spec.rb
 - spec/aquarium/aspects/pointcut_or_composition_spec.rb
 - spec/aquarium/aspects/pointcut_spec.rb
+- spec/aquarium/dsl/aspect_dsl_spec.rb
 - spec/aquarium/extensions/hash_spec.rb
 - spec/aquarium/extensions/regex_spec.rb
 - spec/aquarium/extensions/set_spec.rb
@@ -115,10 +116,14 @@ files:
 - examples/aspect_design_example_spec.rb
 - examples/design_by_contract_example.rb
 - examples/design_by_contract_example_spec.rb
+- examples/exception_wrapping_example.rb
+- examples/exception_wrapping_example_spec.rb
 - examples/method_missing_example.rb
 - examples/method_missing_example_spec.rb
 - examples/method_tracing_example.rb
 - examples/method_tracing_example_spec.rb
+- examples/reusable_aspect_hack_example.rb
+- examples/reusable_aspect_hack_example_spec.rb
 - rake_tasks/examples.rake
 - rake_tasks/examples_specdoc.rake
 - rake_tasks/examples_with_rcov.rake
@@ -153,6 +158,6 @@ rubyforge_project: aquarium
 rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2
-summary: Aquarium-0.4.0 (r7) - Aspect-Oriented Programming toolkit for Ruby http://aquarium.rubyforge.org
+summary: Aquarium-0.4.1 (r7) - Aspect-Oriented Programming toolkit for Ruby http://aquarium.rubyforge.org
 test_files: []