aquarium 0.5.1 → 0.7.1

data/spec/aquarium/aspects/pointcut_and_composition_spec.rb

@@ -45,8 +45,8 @@ describe Pointcut, "#and (when both pointcuts are not empty)" do
     pc1 = Pointcut.new :types => [ClassWithAttribs, ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod], :attributes => [/^attr/], :attribute_options => [:readers]
     pc2 = Pointcut.new :types => [ClassWithAttribs, ClassWithPublicInstanceMethod, ClassWithProtectedInstanceMethod], :attributes => :attrRW_ClassWithAttribs, :attribute_options => [:exclude_ancestor_methods]
     pc = pc1.and pc2
-    expected_jp = JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs
-    pc.join_points_matched.should == Set.new([expected_jp])
+    lambdaed_jp = JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs
+    pc.join_points_matched.should == Set.new([lambdaed_jp])
     pc.join_points_not_matched.should == @empty_set
   end
   
@@ -58,8 +58,8 @@ describe Pointcut, "#and (when both pointcuts are not empty)" do
     pc1 = Pointcut.new :objects => [cwa, pub, pri], :attributes => [/^attr/], :attribute_options => [:readers, :exclude_ancestor_methods]
     pc2 = Pointcut.new :objects => [cwa, pub, pro], :attributes => :attrRW_ClassWithAttribs
     pc = pc1.and pc2
-    expected_jp = JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs
-    pc.join_points_matched.should == Set.new([expected_jp])
+    lambdaed_jp = JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs
+    pc.join_points_matched.should == Set.new([lambdaed_jp])
     pc.join_points_not_matched.should == @empty_set
   end
    
@@ -67,8 +67,8 @@ describe Pointcut, "#and (when both pointcuts are not empty)" do
     pc1 = Pointcut.new :types => "ClassWithAttribs", :attributes => [/^attr/], :attribute_options => [:readers]
     pc2 = Pointcut.new :types => "ClassWithAttribs", :attributes => :attrRW_ClassWithAttribs
     pc = pc1.and pc2
-    expected_jp = JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs
-    pc.join_points_matched.should == Set.new([expected_jp])
+    lambdaed_jp = JoinPoint.new :type => ClassWithAttribs, :method => :attrRW_ClassWithAttribs
+    pc.join_points_matched.should == Set.new([lambdaed_jp])
     pc.join_points_not_matched.should == @empty_set
   end
   
@@ -77,8 +77,8 @@ describe Pointcut, "#and (when both pointcuts are not empty)" do
     pc1 = Pointcut.new :object => cwa, :attributes => [/^attr/], :attribute_options => [:readers]
     pc2 = Pointcut.new :object => cwa, :attributes => :attrRW_ClassWithAttribs
     pc = pc1.and pc2
-    expected_jp = JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs
-    pc.join_points_matched.should == Set.new([expected_jp])
+    lambdaed_jp = JoinPoint.new :object => cwa, :method => :attrRW_ClassWithAttribs
+    pc.join_points_matched.should == Set.new([lambdaed_jp])
     pc.join_points_not_matched.should == @empty_set
   end
 end

data/spec/aquarium/aspects/pointcut_spec.rb

@@ -117,7 +117,7 @@ describe Pointcut, "methods" do
     
   describe Pointcut, ".new (invalid arguments)" do
     it "should raise if an unknown argument is specified" do
-      lambda { Pointcut.new :foo => :bar }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :foo => :bar }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   end
 
@@ -309,13 +309,13 @@ describe Pointcut, "methods" do
     
     Aspect::CANONICAL_OPTIONS["types_and_ancestors"].reject{|key| key.eql?("types_and_ancestors")}.each do |key|
       it "should accept :#{key} as a synonym for :types_and_ancestors." do
-        lambda {Pointcut.new key.intern => /^Module.*Method/, :methods => :all, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+        expect {Pointcut.new key.intern => /^Module.*Method/, :methods => :all, :noop => true}.not_to raise_error
       end
     end
   
     Aspect::CANONICAL_OPTIONS["types_and_descendents"].reject{|key| key.eql?("types_and_descendents")}.each do |key|
       it "should accept :#{key} as a synonym for :types_and_descendents." do
-        lambda {Pointcut.new key.intern => /^Module.*Method/, :methods => :all, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+        expect {Pointcut.new key.intern => /^Module.*Method/, :methods => :all, :noop => true}.not_to raise_error
       end
     end
   end
@@ -337,7 +337,7 @@ describe Pointcut, "methods" do
 
     Aspect::CANONICAL_OPTIONS["types_and_nested_types"].reject{|key| key.eql?("types_and_nested_types")}.each do |key|
       it "should accept :#{key} as a synonym for :types_and_nested_types." do
-        lambda {Pointcut.new key.intern => /^Module.*Method/, :methods => :all, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+        expect {Pointcut.new key.intern => /^Module.*Method/, :methods => :all, :noop => true}.not_to raise_error
       end
     end
   end
@@ -385,12 +385,12 @@ describe Pointcut, "methods" do
   
     it "does confuse strings specified with :objects as type names." do
       string = "mystring"
-      lambda { Pointcut.new :object => string, :methods => :capitalize }.should raise_error(NameError)
+      expect { Pointcut.new :object => string, :methods => :capitalize }.to raise_error(NameError)
     end  
   
     it "does confuse symbols specified with :objects as type names." do
       symbol = :mystring
-      lambda { Pointcut.new :object => symbol, :methods => :capitalize }.should raise_error(NameError)
+      expect { Pointcut.new :object => symbol, :methods => :capitalize }.to raise_error(NameError)
     end  
   end
 
@@ -667,13 +667,13 @@ describe Pointcut, "methods" do
 
     Aspect::CANONICAL_OPTIONS["exclude_types_and_descendents"].reject{|key| key.eql?("exclude_types_and_descendents")}.each do |key|
       it "should accept :#{key} as a synonym for :exclude_types_and_descendents." do
-        lambda {Pointcut.new :types => /ExcludeTest/, key.intern => [ExcludeTestTwo, ExcludeTestThree], :method_options => :exclude_ancestor_methods, :noop => true}.should_not raise_error
+        expect {Pointcut.new :types => /ExcludeTest/, key.intern => [ExcludeTestTwo, ExcludeTestThree], :method_options => :exclude_ancestor_methods, :noop => true}.not_to raise_error
       end
     end  
 
     Aspect::CANONICAL_OPTIONS["exclude_types_and_ancestors"].reject{|key| key.eql?("exclude_types_and_ancestors")}.each do |key|
       it "should accept :#{key} as a synonym for :exclude_types_and_ancestors." do
-        lambda {Pointcut.new :types => /ExcludeTest/, key.intern => [ExcludeTestTwo, ExcludeTestThree], :method_options => :exclude_ancestor_methods, :noop => true}.should_not raise_error
+        expect {Pointcut.new :types => /ExcludeTest/, key.intern => [ExcludeTestTwo, ExcludeTestThree], :method_options => :exclude_ancestor_methods, :noop => true}.not_to raise_error
       end
     end  
   end
@@ -1282,7 +1282,7 @@ describe Pointcut, "methods" do
     end
   
     it "should only allow :reading and :writing options together if they specify the same attributes." do
-      lambda {Pointcut.new :types => "ClassWithAttribs", :reading => [/^attrRW_ClassWithAttribs/], :writing => [/^attr.*ClassWithAttribs/]}.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect {Pointcut.new :types => "ClassWithAttribs", :reading => [/^attrRW_ClassWithAttribs/], :writing => [/^attr.*ClassWithAttribs/]}.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   
     it "should match public attribute readers and writers for types when both the :reading and :writing options are specified." do
@@ -1479,63 +1479,63 @@ describe Pointcut, "methods" do
 
       it "should match the #{method} instance method for types when using a regular expressions, if you don't suppress ancestor methods, even if the method is defined in the class!" do
         pc = Pointcut.new :types => ClassWithFunkyMethodNames, :methods => /#{Regexp.escape(char)}$/, :method_options => [:instance]
-        pc.join_points_matched.any? {|jp| jp.method_name == method}.should be_true
+        pc.join_points_matched.any? {|jp| jp.method_name == method}.should be_truthy
       end
 
       it "should match the #{method} instance method for objects when using a regular expressions, if you don't suppress ancestor methods, even if the method is defined in the class!" do
         pc = Pointcut.new :object => @funky, :methods => /#{Regexp.escape(char)}$/, :method_options => [:instance]
-        pc.join_points_matched.any? {|jp| jp.method_name == method}.should be_true
+        pc.join_points_matched.any? {|jp| jp.method_name == method}.should be_truthy
       end
     end
   end
   
   describe Pointcut, ".new (:attributes => :all option not yet supported)" do
     it "should raise if :all is used for types (not yet supported)." do
-      lambda { Pointcut.new :types => "ClassWithAttribs", :attributes => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => "ClassWithAttribs", :attributes => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   
     it "should raise if :all is used for objects (not yet supported)." do
-      lambda { Pointcut.new :object => ClassWithAttribs.new, :attributes => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :object => ClassWithAttribs.new, :attributes => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   end
 
   describe Pointcut, ".new (:accessing => :all option not yet supported)" do
     it "should raise if :all is used for types (not yet supported)." do
-      lambda { Pointcut.new :types => "ClassWithAttribs", :accessing => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => "ClassWithAttribs", :accessing => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   
     it "should raise if :all is used for objects (not yet supported)." do
-      lambda { Pointcut.new :object => ClassWithAttribs.new, :accessing => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :object => ClassWithAttribs.new, :accessing => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   end
 
   describe Pointcut, ".new (:changing => :all option not yet supported)" do
     it "should raise if :all is used for types (not yet supported)." do
-      lambda { Pointcut.new :types => "ClassWithAttribs", :changing => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => "ClassWithAttribs", :changing => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   
     it "should raise if :all is used for objects (not yet supported)." do
-      lambda { Pointcut.new :object => ClassWithAttribs.new, :changing => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :object => ClassWithAttribs.new, :changing => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   end
 
   describe Pointcut, ".new (:reading => :all option not yet supported)" do
     it "should raise if :all is used for types (not yet supported)." do
-      lambda { Pointcut.new :types => "ClassWithAttribs", :reading => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => "ClassWithAttribs", :reading => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   
     it "should raise if :all is used for objects (not yet supported)." do
-      lambda { Pointcut.new :object => ClassWithAttribs.new, :reading => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :object => ClassWithAttribs.new, :reading => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   end
 
   describe Pointcut, ".new (:writing => :all option not yet supported)" do
     it "should raise if :all is used for types (not yet supported)." do
-      lambda { Pointcut.new :types => "ClassWithAttribs", :writing => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => "ClassWithAttribs", :writing => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   
     it "should raise if :all is used for objects (not yet supported)." do
-      lambda { Pointcut.new :object => ClassWithAttribs.new, :writing => :all }.should raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :object => ClassWithAttribs.new, :writing => :all }.to raise_error(Aquarium::Utils::InvalidOptions)
     end
   end
 
@@ -1572,10 +1572,10 @@ describe Pointcut, "methods" do
     end
   
     it "should raise when specifying method options :singleton with :class, :public, :protected, or :private." do
-      lambda { Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :class]}.should     raise_error(Aquarium::Utils::InvalidOptions)
-      lambda { Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :public]}.should    raise_error(Aquarium::Utils::InvalidOptions)
-      lambda { Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :protected]}.should raise_error(Aquarium::Utils::InvalidOptions)
-      lambda { Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :private]}.should    raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :class]}.to     raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :public]}.to    raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :protected]}.to raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Pointcut.new :types => [NotQuiteEmpty, Empty], :methods => :all, :method_options => [:singleton, :private]}.to    raise_error(Aquarium::Utils::InvalidOptions)
     end    
   end
   

data/spec/aquarium/extensions/regex_spec.rb

@@ -4,18 +4,18 @@ require 'aquarium/extensions/regexp'
 describe Regexp, "#empty?" do
   
   it "should return true for an empty regular expression" do
-    //.empty?.should be_true
-    Regexp.new("").empty?.should be_true
+    //.empty?.should be_truthy
+    Regexp.new("").empty?.should be_truthy
   end
   
   it "should return true for an empty regular expression with whitespace" do
-    /   /.empty?.should be_true
-    Regexp.new("   ").empty?.should be_true
+    /   /.empty?.should be_truthy
+    Regexp.new("   ").empty?.should be_truthy
   end
   
   it "should return false for a non-empty regular expression" do
-    /x/.empty?.should be_false
-    Regexp.new("x").empty?.should be_false
+    /x/.empty?.should be_falsey
+    Regexp.new("x").empty?.should be_falsey
   end
 end
 

data/spec/aquarium/extras/design_by_contract_spec.rb

@@ -13,7 +13,7 @@ describe Aquarium::Extras::DesignByContract, "precondition" do
   end
   
   it "should add advice that raises if the precondition is not satisfied" do
-    lambda {PreCond.new.action}.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
+    expect {PreCond.new.action}.to raise_error(Aquarium::Extras::DesignByContract::ContractError)
   end
   
   it "should add advice that does not raise if the precondition is satisfied" do
@@ -33,8 +33,8 @@ describe Aquarium::Extras::DesignByContract, "postcondition" do
   end
   
   it "should add advice that raises if the postcondition is not satisfied" do
-    lambda {PostCond.new.action}.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
-    lambda {PostCond.new.action("")}.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
+    expect {PostCond.new.action}.to raise_error(Aquarium::Extras::DesignByContract::ContractError)
+    expect {PostCond.new.action("")}.to raise_error(Aquarium::Extras::DesignByContract::ContractError)
   end
   
   it "should add advice that does not raise if the postcondition is satisfied" do
@@ -64,7 +64,7 @@ describe Aquarium::Extras::DesignByContract, "invariant" do
   end
   
   it "should add advice that raises if the invariant is not satisfied" do
-    lambda {InvarCond.new.bad_action}.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
+    expect {InvarCond.new.bad_action}.to raise_error(Aquarium::Extras::DesignByContract::ContractError)
   end
   
   it "should add advice that does not raise if the invariant is satisfied" do
@@ -90,7 +90,7 @@ describe Aquarium::Extras::DesignByContract, "global enable/disable option" do
   it "should disable creation of the contract aspects when the contracts are disabled" do
     begin
       Aquarium::Extras::DesignByContract.disable_all
-      lambda { ContractEnablement.new.action }.should_not raise_error(Aquarium::Extras::DesignByContract::ContractError)
+      expect { ContractEnablement.new.action }.not_to raise_error
     ensure
       Aquarium::Extras::DesignByContract.enable_all
     end
@@ -98,6 +98,6 @@ describe Aquarium::Extras::DesignByContract, "global enable/disable option" do
   
   it "should enable creation of the contract aspects when the contracts are enabled" do
     Aquarium::Extras::DesignByContract.enable_all
-    lambda { ContractEnablement.new.action }.should raise_error(Aquarium::Extras::DesignByContract::ContractError)
+    expect { ContractEnablement.new.action }.to raise_error(Aquarium::Extras::DesignByContract::ContractError)
   end
 end

data/spec/aquarium/finders/finder_result_spec.rb

@@ -37,7 +37,7 @@ describe Aquarium::Finders::FinderResult, "#empty?" do
     result = Aquarium::Finders::FinderResult.new
     result.matched.should == {}
     result.not_matched.should == {}
-    result.empty?.should be_true
+    result.empty?.should be_truthy
   end
 
   it "should be true if there are no matches, even if there are not_matched values." do
@@ -45,7 +45,7 @@ describe Aquarium::Finders::FinderResult, "#empty?" do
     result.matched.should == {}
     empty_set = Set.new
     result.not_matched.should == {:a => empty_set, :b => empty_set}
-    result.empty?.should be_true
+    result.empty?.should be_truthy
   end
 end
 

data/spec/aquarium/finders/method_finder_spec.rb

@@ -74,7 +74,7 @@ def before_method_finder_spec
   @cpri = ClassWithPrivateClassMethod.new
   @test_objects = [@pub, @pro, @pri, @cpub, @cpri]
 
-  @other_methods_expected = []
+  @other_methods_lambdaed = []
   @empty_set = Set.new
 end
 
@@ -86,34 +86,34 @@ describe Aquarium::Finders::MethodFinder, "#find (synonymous input parameters)"
   
   Aquarium::Finders::MethodFinder::CANONICAL_OPTIONS["types"].each do |key|
     it "should accept :#{key} as a synonym for :types." do
-      expected = Aquarium::Finders::MethodFinder.new.find :types     => Derived, :methods => [/^mbase/, /^mmodule/]
+      lambdaed = Aquarium::Finders::MethodFinder.new.find :types     => Derived, :methods => [/^mbase/, /^mmodule/]
       actual   = Aquarium::Finders::MethodFinder.new.find key.intern => Derived, :methods => [/^mbase/, /^mmodule/]
-      actual.should == expected
+      actual.should == lambdaed
     end
   end
   
   Aquarium::Finders::MethodFinder::CANONICAL_OPTIONS["objects"].each do |key|
     it "should accept :#{key} as a synonym for :objects." do
       child = Derived.new
-      expected = Aquarium::Finders::MethodFinder.new.find :objects   => child, :methods => [/^mbase/, /^mmodule/]
+      lambdaed = Aquarium::Finders::MethodFinder.new.find :objects   => child, :methods => [/^mbase/, /^mmodule/]
       actual   = Aquarium::Finders::MethodFinder.new.find key.intern => child, :methods => [/^mbase/, /^mmodule/]
-      actual.should == expected
+      actual.should == lambdaed
     end
   end
   
   Aquarium::Finders::MethodFinder::CANONICAL_OPTIONS["methods"].each do |key|
     it "should accept :#{key} as a synonym for :methods." do
-      expected = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods   => [/^mbase/, /^mmodule/]
+      lambdaed = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods   => [/^mbase/, /^mmodule/]
       actual   = Aquarium::Finders::MethodFinder.new.find :types => Derived, key.intern => [/^mbase/, /^mmodule/]
-      actual.should == expected
+      actual.should == lambdaed
     end
   end
   
   Aquarium::Finders::MethodFinder::CANONICAL_OPTIONS["method_options"].each do |key|
     it "should accept :#{key} as a synonym for :method_options." do
-      expected = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mder/, /^mmod/], :method_options => [:exclude_ancestor_methods], :logger_stream => @logger_stream
+      lambdaed = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mder/, /^mmod/], :method_options => [:exclude_ancestor_methods], :logger_stream => @logger_stream
       actual   = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mder/, /^mmod/], key.intern => [:exclude_ancestor_methods], :logger_stream => @logger_stream
-      actual.should == expected
+      actual.should == lambdaed
     end
   end
 end
@@ -322,24 +322,24 @@ end
 describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)" do
   before(:each) do
     before_method_finder_spec
-    @expected_ClassWithPUblicClassMethod = Set.new(ClassWithPublicClassMethod.public_methods.reject{|m| m =~ /^__/}.sort.map{|m| m.intern})
-    @expected_ClassWithPrivateClassMethod = Set.new(ClassWithPrivateClassMethod.public_methods.reject{|m| m =~ /^__/}.sort.map{|m| m.intern})
+    @lambdaed_ClassWithPUblicClassMethod = Set.new(ClassWithPublicClassMethod.public_methods.reject{|m| m =~ /^__/}.sort.map{|m| m.intern})
+    @lambdaed_ClassWithPrivateClassMethod = Set.new(ClassWithPrivateClassMethod.public_methods.reject{|m| m =~ /^__/}.sort.map{|m| m.intern})
   end
   
   it "should find all class methods specified by regular expression for types when :class is used." do
     # NOTE: The list of methods defined by Kernel is different for Ruby 1.8 and 1.9.
-    expected = {}
-    expected[Kernel] = [:respond_to?]
+    lambdaed = {}
+    lambdaed[Kernel] = [:respond_to?]
     if RUBY_VERSION.index("1.8")
-      expected[Kernel] += [:chomp!, :chop!] 
+      lambdaed[Kernel] += [:chomp!, :chop!] 
     end
     [Object, Module, Class].each do |clazz|
-      expected[clazz] = [:respond_to?]
+      lambdaed[clazz] = [:respond_to?]
     end
     class_array = [Kernel, Module, Object, Class]
     actual = Aquarium::Finders::MethodFinder.new.find :types => class_array, :methods => [/^resp.*to\?$/, /^ch.*\!$/], :method_options => :class
     class_array.each do |c|
-      actual.matched[c].should == Set.new(expected[c])
+      actual.matched[c].should == Set.new(lambdaed[c])
     end
   end
   
@@ -347,8 +347,8 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)"
     actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicClassMethod, ClassWithPrivateClassMethod], :methods => :all, :method_options => :class
     actual.matched.size.should == 2
     actual.not_matched.size.should == 0
-    actual.matched[ClassWithPublicClassMethod].should == @expected_ClassWithPUblicClassMethod
-    actual.matched[ClassWithPrivateClassMethod].should == @expected_ClassWithPrivateClassMethod 
+    actual.matched[ClassWithPublicClassMethod].should == @lambdaed_ClassWithPUblicClassMethod
+    actual.matched[ClassWithPrivateClassMethod].should == @lambdaed_ClassWithPrivateClassMethod 
   end
   
   it "should find any methods that start with double underscores '__' with the :include_system_methods option." do
@@ -356,23 +356,23 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)"
       def self.__foo__; end
     end
     actual = Aquarium::Finders::MethodFinder.new.find :types => [WithUnderScores], :methods => :all, :method_options => [:class, :include_system_methods]
-    actual.matched[WithUnderScores].include?(:__foo__).should be_true
+    actual.matched[WithUnderScores].include?(:__foo__).should be_truthy
   end
   
   it "should find all public class methods in types when searching with the :all method specification and the :class option." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicClassMethod, ClassWithPrivateClassMethod], :methods => :all, :method_options => :class
     actual.matched.size.should == 2
     actual.not_matched.size.should == 0
-    actual.matched[ClassWithPublicClassMethod].should == @expected_ClassWithPUblicClassMethod
-    actual.matched[ClassWithPrivateClassMethod].should == @expected_ClassWithPrivateClassMethod 
+    actual.matched[ClassWithPublicClassMethod].should == @lambdaed_ClassWithPUblicClassMethod
+    actual.matched[ClassWithPrivateClassMethod].should == @lambdaed_ClassWithPrivateClassMethod 
   end
   
   it "should accept :all_methods as a synonym for :all." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicClassMethod, ClassWithPrivateClassMethod], :methods => :all_methods, :method_options => :class
     actual.matched.size.should == 2
     actual.not_matched.size.should == 0
-    actual.matched[ClassWithPublicClassMethod].should == @expected_ClassWithPUblicClassMethod
-    actual.matched[ClassWithPrivateClassMethod].should == @expected_ClassWithPrivateClassMethod 
+    actual.matched[ClassWithPublicClassMethod].should == @lambdaed_ClassWithPUblicClassMethod
+    actual.matched[ClassWithPrivateClassMethod].should == @lambdaed_ClassWithPrivateClassMethod 
   end
   
   it "should find all public class methods in types, but not ancestors, when searching with the :all method specification and the :class and :exclude_ancestor_methods options." do
@@ -450,7 +450,7 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for instance methods
       def __foo__; end
     end
     actual = Aquarium::Finders::MethodFinder.new.find :types => [WithUnderScores], :methods => :all, :method_options => [:include_system_methods]
-    actual.matched[WithUnderScores].include?(:__foo__).should be_true
+    actual.matched[WithUnderScores].include?(:__foo__).should be_truthy
   end
   
   it "should find all public instance methods in classes when searching with the :all method specification." do

data/spec/aquarium/finders/pointcut_finder_spec.rb

@@ -5,26 +5,26 @@ require File.dirname(__FILE__) + '/pointcut_finder_spec_test_classes'
 
 describe Aquarium::Finders::PointcutFinder, "#find with invalid invocation parameters" do
   it "should raise if no options are specified." do
-    lambda { Aquarium::Finders::PointcutFinder.new.find}.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { Aquarium::Finders::PointcutFinder.new.find}.to raise_error(Aquarium::Utils::InvalidOptions)
   end
   it "should raise if no type options are specified." do
-    lambda { Aquarium::Finders::PointcutFinder.new.find :matching => :foo}.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { Aquarium::Finders::PointcutFinder.new.find :matching => :foo}.to raise_error(Aquarium::Utils::InvalidOptions)
   end
 end
 
 describe Aquarium::Finders::PointcutFinder, "#find with valid type invocation parameters" do
   it "should accept :types with a single type." do
-    lambda { Aquarium::Finders::PointcutFinder.new.find :types => Aquarium::PointcutFinderTestClasses::PointcutConstantHolder1, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    expect { Aquarium::Finders::PointcutFinder.new.find :types => Aquarium::PointcutFinderTestClasses::PointcutConstantHolder1, :noop => true}.not_to raise_error
   end
   it "should accept :types with an array of types." do
-    lambda { Aquarium::Finders::PointcutFinder.new.find :types => [Aquarium::PointcutFinderTestClasses::PointcutConstantHolder1, Aquarium::PointcutFinderTestClasses::PointcutConstantHolder2], :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    expect { Aquarium::Finders::PointcutFinder.new.find :types => [Aquarium::PointcutFinderTestClasses::PointcutConstantHolder1, Aquarium::PointcutFinderTestClasses::PointcutConstantHolder2], :noop => true}.not_to raise_error
   end
   it "should accept :types with a regular expression for types." do
-    lambda { Aquarium::Finders::PointcutFinder.new.find :types => /Aquarium::PointcutFinderTestClasses::PointcutConstantHolder/, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    expect { Aquarium::Finders::PointcutFinder.new.find :types => /Aquarium::PointcutFinderTestClasses::PointcutConstantHolder/, :noop => true}.not_to raise_error
   end
   Aquarium::Finders::PointcutFinder::CANONICAL_OPTIONS["types"].each do |synonym|
     it "should accept :#{synonym} as a synonym for :types." do
-      lambda { Aquarium::Finders::PointcutFinder.new.find synonym.intern => /Aquarium::PointcutFinderTestClasses::PointcutConstantHolder/, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Aquarium::Finders::PointcutFinder.new.find synonym.intern => /Aquarium::PointcutFinderTestClasses::PointcutConstantHolder/, :noop => true}.not_to raise_error
     end
   end
 end
@@ -51,17 +51,17 @@ variants = {'constant and class variable ' => '', 'constant ' => 'constants_', '
       Aquarium::PointcutFinderTestClasses.found_pointcuts_should_match found, eval("Aquarium::PointcutFinderTestClasses.all_#{prefix}pointcuts")
     end
     it "should accept :#{prefix}matching with a single pointcut name." do
-      lambda { Aquarium::Finders::PointcutFinder.new.find "#{prefix}matching".intern => :POINTCUT1, :types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Aquarium::Finders::PointcutFinder.new.find "#{prefix}matching".intern => :POINTCUT1, :types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes, :noop => true}.not_to raise_error
     end
     it "should accept :#{prefix}matching with an array of pointcut names." do
-      lambda { Aquarium::Finders::PointcutFinder.new.find "#{prefix}matching".intern => [:POINTCUT1, :POINTCUT2], :types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Aquarium::Finders::PointcutFinder.new.find "#{prefix}matching".intern => [:POINTCUT1, :POINTCUT2], :types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes, :noop => true}.not_to raise_error
     end
     it "should accept :#{prefix}matching with a regular expression for pointcut names." do
-      lambda { Aquarium::Finders::PointcutFinder.new.find "#{prefix}matching".intern => /POINTCUT/, :types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+      expect { Aquarium::Finders::PointcutFinder.new.find "#{prefix}matching".intern => /POINTCUT/, :types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes, :noop => true}.not_to raise_error
     end
     Aquarium::Finders::PointcutFinder::CANONICAL_OPTIONS["#{prefix}matching"].each do |synonym|
       it "should accept :#{synonym} as a synonym for :#{prefix}matching." do
-        lambda { Aquarium::Finders::PointcutFinder.new.find synonym.intern => /POINTCUT/, :types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes, :noop => true}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+        expect { Aquarium::Finders::PointcutFinder.new.find synonym.intern => /POINTCUT/, :types => Aquarium::PointcutFinderTestClasses.all_pointcut_classes, :noop => true}.not_to raise_error
       end
     end
   end