aquarium 0.5.1 → 0.7.1

data/spec/aquarium/aspects/aspect_spec.rb

@@ -97,7 +97,7 @@ describe Aspect, " with :before advice" do
     block_called = 0
     watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 
   it "should evaluate the advice before the method body and its block (if any)." do
@@ -127,7 +127,7 @@ describe Aspect, " with :after advice" do
     block_called = 0
     watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 
   it "should pass the context information to the advice, including self, the method parameters, and the rescued exception when an exception is raised." do
@@ -137,14 +137,14 @@ describe Aspect, " with :after advice" do
       context = jp.context
     end 
     block_called = 0
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') do |*args| 
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') do |*args| 
       block_called += 1 
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
-    end }.should raise_error(Watchful::WatchfulError)
+    end }.to raise_error(Watchful::WatchfulError)
     block_called.should == 1
     context.advised_object.should == watchful
     context.returned_value.should == nil
-    context.raised_exception.kind_of?(Watchful::WatchfulError).should be_true
+    context.raised_exception.kind_of?(Watchful::WatchfulError).should be_truthy
   end
 
   it "should evaluate the advice after the method body and its block (if any)." do
@@ -187,10 +187,10 @@ describe Aspect, " with :after advice" do
       aspect_advice_invoked = true
       jp.context.raised_exception = MyError1
     end 
-    aspect_advice_invoked.should be_false
+    aspect_advice_invoked.should be_falsey
     ctr = ClassThatRaises.new
-    lambda {ctr.raises}.should raise_error(MyError1)
-    aspect_advice_invoked.should be_true
+    expect {ctr.raises}.to raise_error(MyError1)
+    aspect_advice_invoked.should be_truthy
   end
 end
 
@@ -213,7 +213,7 @@ describe Aspect, " with :after_returning advice" do
     block_called = 0
     watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 
   it "should evaluate the advice after the method body and its block (if any)." do
@@ -265,12 +265,12 @@ describe Aspect, " with :after_raising advice" do
       jp.context.advised_object.should == watchful
       jp.context.advice_kind.should == :after_raising
       jp.context.returned_value.should == nil
-      jp.context.raised_exception.kind_of?(Watchful::WatchfulError).should be_true
+      jp.context.raised_exception.kind_of?(Watchful::WatchfulError).should be_truthy
     end 
     block_called = 0
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }}.should raise_error(Watchful::WatchfulError)
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }}.to raise_error(Watchful::WatchfulError)
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 
   it "should evaluate the advice after the method body and its block (if any)." do
@@ -285,9 +285,9 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new(:after_raising => Watchful::WatchfulError, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
-    aspect_advice_invoked.should be_true
-    block_invoked.should be_true
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.to raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_truthy
+    block_invoked.should be_truthy
   end
   
   it "should invoke advice when exceptions of the specified type are raised, which were specified with :exceptions => ..." do
@@ -295,9 +295,9 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new(:after_raising, :exceptions => Watchful::WatchfulError, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
-    aspect_advice_invoked.should be_true
-    block_invoked.should be_true
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.to raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_truthy
+    block_invoked.should be_truthy
   end
   
   it "should not invoke advice when exceptions of types that don't match the specified exception type are raised" do
@@ -305,9 +305,9 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new(:after_raising => MyError1, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
-    aspect_advice_invoked.should be_false
-    block_invoked.should be_true
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.to raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_falsey
+    block_invoked.should be_truthy
   end
   
   it "should not invoke advice when exceptions of types that don't match the specified exception type are raised, which were specified with :exceptions => ..." do
@@ -315,9 +315,9 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new(:after_raising, :exceptions => MyError1, :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
-    aspect_advice_invoked.should be_false
-    block_invoked.should be_true
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.to raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_falsey
+    block_invoked.should be_truthy
   end
   
   it "should invoke advice when one exception in the list of the specified types is raised" do
@@ -325,17 +325,17 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new(:after_raising => [Watchful::WatchfulError, MyError1], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
-    aspect_advice_invoked.should be_true
-    block_invoked.should be_true
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.to raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_truthy
+    block_invoked.should be_truthy
   end
   
   it "should invoke advice when an exception that subclasses a specified exception type is raised" do
     aspect_advice_invoked = false
     @aspect = Aspect.new(:after_raising => StandardError, :pointcut => {:type => ClassThatRaises, :methods => :raises}) {|jp, obj, *args| aspect_advice_invoked = true}
     ctr = ClassThatRaises.new
-    lambda {ctr.raises}.should raise_error(ClassThatRaises::CTRException)
-    aspect_advice_invoked.should be_true
+    expect {ctr.raises}.to raise_error(ClassThatRaises::CTRException)
+    aspect_advice_invoked.should be_truthy
   end
   
   it "should not invoke advice when exceptions of types that don't match the specified list of exception types are raised" do
@@ -343,9 +343,9 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new(:after_raising => [MyError1, MyError2], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
-    aspect_advice_invoked.should be_false
-    block_invoked.should be_true
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.to raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_falsey
+    block_invoked.should be_truthy
   end
   
   it "should not invoke advice when exceptions of types that don't match the specified list of exception types are raised, which were specified with :exceptions => ..." do
@@ -353,9 +353,9 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new(:after_raising, :exceptions => [MyError1, MyError2], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
-    aspect_advice_invoked.should be_false
-    block_invoked.should be_true
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.to raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_falsey
+    block_invoked.should be_truthy
   end
   
   it "should treat :exception as a synonym for :exceptions" do
@@ -363,9 +363,9 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new(:after_raising, :exception => [MyError1, MyError2], :pointcut => {:type => Watchful, :methods => /public_watchful_method/}) {|jp, obj, *args| aspect_advice_invoked = true}
     block_invoked = false
     watchful = Watchful.new
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.should raise_error(Watchful::WatchfulError)
-    aspect_advice_invoked.should be_false
-    block_invoked.should be_true
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3) {|*args| block_invoked = true}}.to raise_error(Watchful::WatchfulError)
+    aspect_advice_invoked.should be_falsey
+    block_invoked.should be_truthy
   end
   
   it "should merge exceptions specified with :exception(s) and :after_raising" do
@@ -379,10 +379,10 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new :after_raising, :pointcut => {:type => ClassThatRaises, :methods => :raises} do |jp, obj, *args|
       aspect_advice_invoked = true
     end 
-    aspect_advice_invoked.should be_false
+    aspect_advice_invoked.should be_falsey
     ctr = ClassThatRaises.new
-    lambda {ctr.raises}.should raise_error(ClassThatRaises::CTRException)
-    aspect_advice_invoked.should be_true
+    expect {ctr.raises}.to raise_error(ClassThatRaises::CTRException)
+    aspect_advice_invoked.should be_truthy
   end
 
   it "should advise all methods that raise strings (which are converted to RuntimeError) when no specific exceptions are specified" do
@@ -390,10 +390,10 @@ describe Aspect, " with :after_raising advice" do
     @aspect = Aspect.new :after_raising, :pointcut => {:type => ClassThatRaisesString, :methods => :raises} do |jp, obj, *args|
       aspect_advice_invoked = true
     end 
-    aspect_advice_invoked.should be_false
+    aspect_advice_invoked.should be_falsey
     ctr = ClassThatRaisesString.new
-    lambda {ctr.raises}.should raise_error(RuntimeError)
-    aspect_advice_invoked.should be_true
+    expect {ctr.raises}.to raise_error(RuntimeError)
+    aspect_advice_invoked.should be_truthy
   end
 
   it "should allow advice to change the exception raised" do
@@ -402,10 +402,10 @@ describe Aspect, " with :after_raising advice" do
       aspect_advice_invoked = true
       jp.context.raised_exception = MyError1
     end 
-    aspect_advice_invoked.should be_false
+    aspect_advice_invoked.should be_falsey
     ctr = ClassThatRaises.new
-    lambda {ctr.raises}.should raise_error(MyError1)
-    aspect_advice_invoked.should be_true
+    expect {ctr.raises}.to raise_error(MyError1)
+    aspect_advice_invoked.should be_truthy
   end
 end
 
@@ -517,13 +517,13 @@ describe Aspect, " with :before and :after_raising advice" do
       args.should == [:a1, :a2, :a3, {:h1 => 'h1', :h2 => 'h2'}]
     end 
     block_called = 0
-    lambda {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }}.should raise_error(Watchful::WatchfulError)
+    expect {watchful.public_watchful_method_that_raises(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }}.to raise_error(Watchful::WatchfulError)
     block_called.should == 1
     contexts.size.should == 2
     advice_kinds[0].should == :before
     advice_kinds[1].should == :after_raising
     raised_exceptions[0].should == nil
-    raised_exceptions[1].kind_of?(Watchful::WatchfulError).should be_true
+    raised_exceptions[1].kind_of?(Watchful::WatchfulError).should be_truthy
     contexts.each do |context|
       context.advised_object.should == watchful
       context.returned_value.should == nil
@@ -560,10 +560,10 @@ describe Aspect, " with :around advice" do
     watchful.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| public_block_called = true }
     watchful.send(:protected_watchful_method, :b1, :b2, :b3) {|*args| protected_block_called = true}
     watchful.send(:private_watchful_method, :c1, :c2, :c3) {|*args| private_block_called = true}
-    public_block_called.should be_false  # proceed is never called!
-    protected_block_called.should be_true
-    private_block_called.should be_true
-    advice_called.should be_true
+    public_block_called.should be_falsey  # proceed is never called!
+    protected_block_called.should be_truthy
+    private_block_called.should be_truthy
+    advice_called.should be_truthy
   end
 
   module AdvisingSuperClass
@@ -601,10 +601,10 @@ describe Aspect, " with :around advice" do
     child.public_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| fail }
     child.send(:protected_method, :b1, :b2, :b3) {|*args| protected_block_called = true}
     child.send(:private_method, :c1, :c2, :c3) {|*args| private_block_called = true}
-    public_block_called.should be_false  # proceed is never called!
-    protected_block_called.should be_true
-    private_block_called.should be_true
-    advice_called.should be_true
+    public_block_called.should be_falsey  # proceed is never called!
+    protected_block_called.should be_truthy
+    private_block_called.should be_truthy
+    advice_called.should be_truthy
   end
 
   module AdvisingSubClass
@@ -642,10 +642,10 @@ describe Aspect, " with :around advice" do
     child.public_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| fail }
     child.send(:protected_method, :b1, :b2, :b3) {|*args| protected_block_called = true}
     child.send(:private_method, :c1, :c2, :c3) {|*args| private_block_called = true}
-    public_block_called.should be_false  # proceed is never called!
-    protected_block_called.should be_true
-    private_block_called.should be_true
-    advice_called.should be_true
+    public_block_called.should be_falsey  # proceed is never called!
+    protected_block_called.should be_truthy
+    private_block_called.should be_truthy
+    advice_called.should be_truthy
   end
 
   class WatchfulChild2 < Watchful
@@ -665,7 +665,7 @@ describe Aspect, " with :around advice" do
     child = WatchfulChild2.new
     public_block_called = false
     child.public_watchful_method(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| public_block_called = true }
-    public_block_called.should be_true  # advice never called
+    public_block_called.should be_truthy  # advice never called
   end
 
   it "should evaluate the advice and only evaluate the method body and its block (if any) when JoinPoint#proceed is called." do
@@ -692,8 +692,8 @@ describe Aspect, " with :around advice" do
     watchful = Watchful.new
     orig_block_called = false
     watchful.public_watchful_method(:a1, :a2, :a3) {|*args| orig_block_called = true}
-    override_block_called.should be_true
-    orig_block_called.should be_false
+    override_block_called.should be_truthy
+    orig_block_called.should be_falsey
     watchful.public_watchful_method_args.should == [:a4, :a5, :a6]
   end
   
@@ -765,8 +765,8 @@ describe Aspect, "#unadvise called more than once on the same aspect" do
   it "should do nothing on the second invocation." do
     aspect = Aspect.new :around, :type => Watchful, :method => /does_not_exist/, :advice => @advice, :severity => Logger::Severity::ERROR
     aspect.unadvise
-    lambda {aspect.unadvise}.should_not raise_error
-    lambda {aspect.unadvise}.should_not raise_error
+    expect {aspect.unadvise}.not_to raise_error
+    expect {aspect.unadvise}.not_to raise_error
   end
 end
 
@@ -817,9 +817,9 @@ describe Aspect, "#unadvise clean up" do
     [public_methods, protected_methods, private_methods]
   end
   
-  def diff_methods actual, expected, private_should_not_be_equal = false
+  def diff_methods actual, expected, private_not_to_be_equal = false
     3.times do |i|
-      if i==2 && private_should_not_be_equal
+      if i==2 && private_not_to_be_equal
         actual[i].should_not == expected[i] 
       else
         actual[i].should == expected[i] 
@@ -840,8 +840,8 @@ describe Aspect, "#unadvise clean up" do
       advice_called = false
       block_called = false
       @watchful.send("#{protection}_watchful_method".intern, :a1, :a2, :a3) {|*args| block_called = true}
-      advice_called.should be_false
-      block_called.should be_true
+      advice_called.should be_falsey
+      block_called.should be_truthy
     end
   end
   
@@ -949,7 +949,7 @@ describe Aspect, " when unadvising methods for instance-type pointcuts for type-
     aspect = Aspect.new(:before, :object => object, :method => :m) {true}
     aspect.unadvise
     object.m
-    object.called.should be_true
+    object.called.should be_truthy
   end
 end
 
@@ -960,7 +960,7 @@ describe Aspect, " when unadvising methods for instance-type pointcuts for insta
     aspect = Aspect.new(:before, :object => object, :method => :m) {true}
     aspect.unadvise
     object.m
-    object.called.should be_true
+    object.called.should be_truthy
   end
 end
 
@@ -1079,7 +1079,7 @@ def do_watchful_spec protection, raises, expected_advice_called_value, args_pass
   @advice_called = 0
   block_called = 0
   if raises
-    lambda {watchful.send("#{protection}_watchful_method#{suffix}".intern, :a1, :a2, :a3) {|*args| block_called += 1}}.should raise_error(Watchful::WatchfulError)
+    expect {watchful.send("#{protection}_watchful_method#{suffix}".intern, :a1, :a2, :a3) {|*args| block_called += 1}}.to raise_error(Watchful::WatchfulError)
   else
     watchful.send("#{protection}_watchful_method#{suffix}".intern, :a1, :a2, :a3) {|*args| block_called += 1}
   end

data/spec/aquarium/aspects/aspect_with_nested_types_spec.rb

@@ -42,7 +42,7 @@ describe Aspect, ".new when advising methods in a nested class" do
     block_called = 0
     myclass.do1(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 
   it "should correctly advise methods in an instance of the nested class." do
@@ -59,7 +59,7 @@ describe Aspect, ".new when advising methods in a nested class" do
     block_called = 0
     myclass.do1(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 end
 
@@ -86,7 +86,7 @@ describe Aspect, ".new when advising methods in a nested module included by a cl
     block_called = 0
     myclass.do2(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 
   it "should correctly advise the module's methods when the class is specified." do
@@ -107,7 +107,7 @@ describe Aspect, ".new when advising methods in a nested module included by a cl
     block_called = 0
     myclass.do2(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 
   it "should correctly advise the module's methods when an instance of the class is specified." do
@@ -129,7 +129,7 @@ describe Aspect, ".new when advising methods in a nested module included by a cl
     block_called = 0
     myclass.do2(:a1, :a2, :a3, :h1 => 'h1', :h2 => 'h2') { |*args| block_called += 1 }
     block_called.should == 1
-    advice_called.should be_true
+    advice_called.should be_truthy
   end
 end
 

data/spec/aquarium/aspects/concurrent_aspects_spec.rb

@@ -39,7 +39,7 @@ module ConcurrentAspectsSpecSupport
   end
     
   def do_invoke_raises accessed
-    lambda {accessed.invoke_raises :a1, :a2}.should raise_error(ConcurrentlyAccessed::Error)
+    expect {accessed.invoke_raises :a1, :a2}.to raise_error(ConcurrentlyAccessed::Error)
   end
 
   def do_invoke accessed

data/spec/aquarium/aspects/default_objects_handler_spec.rb

@@ -45,31 +45,31 @@ end
 
 describe Aquarium::Aspects::DefaultObjectsHandler, "#default_objects_given?" do
   it "should return false if the specification contains no :default_object or :default_objects key." do
-    Aquarium::DefaultObjectsClass.new.default_objects_given?.should be_false
+    Aquarium::DefaultObjectsClass.new.default_objects_given?.should be_falsey
   end
 
   it "should return true if one or more objects were specified with the :default_object key." do
     defaults = ["1", "2"]
     doc = Aquarium::DefaultObjectsClass.new :default_object => defaults
-    doc.default_objects_given?.should be_true
+    doc.default_objects_given?.should be_truthy
   end
   
   it "should return true if one or more objects were specified with the :default_objects key." do
     defaults = ["1", "2"]
     doc = Aquarium::DefaultObjectsClass.new :default_objects => defaults
-    doc.default_objects_given?.should be_true
+    doc.default_objects_given?.should be_truthy
   end
 
   it "should return true if a single objects was specified with the :default_object key." do
     default = "1"
     doc = Aquarium::DefaultObjectsClass.new :default_object => default
-    doc.default_objects_given?.should be_true
+    doc.default_objects_given?.should be_truthy
   end
 
   it "should return true if a single objects was specified with the :default_objects key." do
     default = "1"
     doc = Aquarium::DefaultObjectsClass.new :default_objects => default
-    doc.default_objects_given?.should be_true
+    doc.default_objects_given?.should be_truthy
   end
 end
 

data/spec/aquarium/aspects/join_point_spec.rb

@@ -26,80 +26,80 @@ include Aquarium::Aspects
 describe JoinPoint, "#initialize with invalid parameters" do
   
   it "should require either a :type or an :object parameter, but not both." do
-    lambda { JoinPoint.new :method_name => :count }.should raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { JoinPoint.new :type => String, :object => "", :method_name => :count }.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :method_name => :count }.to raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :type => String, :object => "", :method_name => :count }.to raise_error(Aquarium::Utils::InvalidOptions)
   end
   
   it "should require a :method_name." do
-    lambda { JoinPoint.new :type => String }.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :type => String }.to raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should except :method as a synonym for :method_name." do
-    lambda { JoinPoint.new :type => String, :method => :split }.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :type => String, :method => :split }.not_to raise_error
   end
 
   it "should require a valid type name if a name is specified." do
-    lambda { JoinPoint.new :type => "String", :method => :split }.should_not raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { JoinPoint.new :type => "Stringgy", :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :type => "String", :method => :split }.not_to raise_error
+    expect { JoinPoint.new :type => "Stringgy", :method => :split }.to raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should require a valid type name symbol if a name is specified." do
-    lambda { JoinPoint.new :type => :String, :method => :split }.should_not raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { JoinPoint.new :type => :Stringgy, :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :type => :String, :method => :split }.not_to raise_error
+    expect { JoinPoint.new :type => :Stringgy, :method => :split }.to raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should require a valid type name regular expression if one is specified." do
-    lambda { JoinPoint.new :type => /^String$/, :method => :split }.should_not raise_error(Aquarium::Utils::InvalidOptions)
-    lambda { JoinPoint.new :type => /^Stringgy$/, :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :type => /^String$/, :method => :split }.not_to raise_error
+    expect { JoinPoint.new :type => /^Stringgy$/, :method => :split }.to raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should reject a regular expression that matches no types." do
-    lambda { JoinPoint.new :type => /^Stringgy$/, :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :type => /^Stringgy$/, :method => :split }.to raise_error(Aquarium::Utils::InvalidOptions)
   end
 
   it "should reject a regular expression that matches more than one type." do
-    lambda { JoinPoint.new :type => /^M/, :method => :split }.should raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint.new :type => /^M/, :method => :split }.to raise_error(Aquarium::Utils::InvalidOptions)
   end
 end
   
 describe JoinPoint, "#initialize with parameters that specify class vs. instance methods" do
   it "should assume the :method_name refers to an instance method, by default." do
     jp = JoinPoint.new :type => String, :method => :split
-    jp.instance_method?.should be_true
-    jp.class_method?.should be_false
+    jp.instance_method?.should be_truthy
+    jp.class_method?.should be_falsey
   end
   
   it "should treat the :method_name as refering to an instance method if :instance_method is specified as true." do
     jp = JoinPoint.new :type => String, :method => :split, :instance_method => true
-    jp.instance_method?.should be_true
-    jp.class_method?.should be_false
+    jp.instance_method?.should be_truthy
+    jp.class_method?.should be_falsey
   end
   
   it "should treat the :method_name as refering to a class method if :instance_method is specified as false." do
     jp = JoinPoint.new :type => String, :method => :split, :instance_method => false
-    jp.instance_method?.should be_false
-    jp.class_method?.should be_true
+    jp.instance_method?.should be_falsey
+    jp.class_method?.should be_truthy
   end
 
   it "should treat the :method_name as refering to an instance method if :class_method is specified as false." do
     jp = JoinPoint.new :type => String, :method => :split, :class_method => false
-    jp.instance_method?.should be_true
-    jp.class_method?.should be_false
+    jp.instance_method?.should be_truthy
+    jp.class_method?.should be_falsey
   end
   
   it "should treat the :method_name as refering to a class method if :class_method is specified as true." do
     jp = JoinPoint.new :type => String, :method => :split, :class_method => true
-    jp.instance_method?.should be_false
-    jp.class_method?.should be_true
+    jp.instance_method?.should be_falsey
+    jp.class_method?.should be_truthy
   end
   
   it "should treat give precedence to :instance_method if appears with :class_method." do
     jp = JoinPoint.new :type => String, :method => :split, :instance_method => false, :class_method => true
-    jp.instance_method?.should be_false
-    jp.class_method?.should be_true
+    jp.instance_method?.should be_falsey
+    jp.class_method?.should be_truthy
     jp = JoinPoint.new :type => String, :method => :split, :instance_method => true, :class_method => false
-    jp.instance_method?.should be_true
-    jp.class_method?.should be_false
+    jp.instance_method?.should be_truthy
+    jp.class_method?.should be_falsey
   end
 end
   
@@ -221,7 +221,7 @@ describe JoinPoint, "#proceed" do
     jp.context.advised_object = ioc
     jp.context.parameters = []
     jp.context.proceed_proc = nil
-    lambda { jp.proceed }.should raise_error(JoinPoint::ProceedMethodNotAvailable)
+    expect { jp.proceed }.to raise_error(JoinPoint::ProceedMethodNotAvailable)
   end
 
   it "should not raise when the advice is :around advice" do
@@ -231,7 +231,7 @@ describe JoinPoint, "#proceed" do
     jp.context.advised_object = ioc 
     jp.context.parameters = []
     jp.context.proceed_proc = Aquarium::Aspects::NoAdviceChainNode.new(:alias_method_name => :invoke)
-    lambda { jp.proceed }.should_not raise_error(JoinPoint::ProceedMethodNotAvailable)
+    expect { jp.proceed }.not_to raise_error
   end
   
   it "should invoke the actual join point" do
@@ -242,7 +242,7 @@ describe JoinPoint, "#proceed" do
     jp.context.parameters = []
     jp.context.proceed_proc = Aquarium::Aspects::NoAdviceChainNode.new(:alias_method_name => :invoke)
     jp.proceed
-    ioc.called.should be_true
+    ioc.called.should be_truthy
   end
 end
 
@@ -254,7 +254,7 @@ end
 describe JoinPoint, "#invoke_original_join_point" do
   it "should raise when the join point has an empty context" do
     jp = JoinPoint.new :type => InvokeOriginalClass, :method => :invoke
-    lambda { jp.invoke_original_join_point }.should raise_error(JoinPoint::ContextNotCorrectlyDefined)
+    expect { jp.invoke_original_join_point }.to raise_error(JoinPoint::ContextNotCorrectlyDefined)
   end
 
   it "should invoke the original join point" do
@@ -265,7 +265,7 @@ describe JoinPoint, "#invoke_original_join_point" do
     jp.context.parameters = []
     jp.context.current_advice_node = Aquarium::Aspects::NoAdviceChainNode.new(:alias_method_name => :invoke)
     jp.invoke_original_join_point
-    ioc.called.should be_true
+    ioc.called.should be_truthy
   end
 end
 
@@ -423,37 +423,37 @@ end
 describe JoinPoint, "#exists?" do
   it "should return false if the join point represents a non-existent join point for an instance method in the runtime environment" do
     jp = JoinPoint.new :type => ProtectionExample, :method_name => :foo
-    jp.exists?.should be_false
+    jp.exists?.should be_falsey
   end
 
   it "should return false if the join point represents a non-existent join point for a class method in the runtime environment" do
     jp = JoinPoint.new :type => ProtectionExample, :method_name => :foo, :class_method => true
-    jp.exists?.should be_false
+    jp.exists?.should be_falsey
   end
 
   it "should return true if the join point represents a real join point for a public instance method in the runtime environment" do
     jp = JoinPoint.new :type => ProtectionExample, :method_name => :public_instance_m
-    jp.exists?.should be_true
+    jp.exists?.should be_truthy
   end
 
   it "should return true if the join point represents a real join point for a protected instance method in the runtime environment" do
     jp = JoinPoint.new :type => ProtectionExample, :method_name => :protected_instance_m
-    jp.exists?.should be_true
+    jp.exists?.should be_truthy
   end
 
   it "should return true if the join point represents a real join point for a private instance method in the runtime environment" do
     jp = JoinPoint.new :type => ProtectionExample, :method_name => :private_instance_m
-    jp.exists?.should be_true
+    jp.exists?.should be_truthy
   end
 
   it "should return true if the join point represents a real join point for a public class method in the runtime environment" do
     jp = JoinPoint.new :type => ProtectionExample, :method_name => :public_class_m, :class_method => true
-    jp.exists?.should be_true
+    jp.exists?.should be_truthy
   end
 
   it "should return true if the join point represents a real join point for a private class method in the runtime environment" do
     jp = JoinPoint.new :type => ProtectionExample, :method_name => :private_class_m, :class_method => true
-    jp.exists?.should be_true
+    jp.exists?.should be_truthy
   end
 
   class ProtectionExample2
@@ -486,11 +486,11 @@ describe JoinPoint::Context, "#initialize" do
   end
 
   it "should accept a :returned_value argument." do
-    lambda { JoinPoint::Context.new :advice_kind => :before, :advised_object => "object", :parameters => [","], :returned_value => ["12", "34"]}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint::Context.new :advice_kind => :before, :advised_object => "object", :parameters => [","], :returned_value => ["12", "34"]}.not_to raise_error
   end
 
   it "should accept a :raised_exception argument." do
-    lambda { JoinPoint::Context.new :advice_kind => :before, :advised_object => "object", :parameters => [","], :raised_exception => NameError.new}.should_not raise_error(Aquarium::Utils::InvalidOptions)
+    expect { JoinPoint::Context.new :advice_kind => :before, :advised_object => "object", :parameters => [","], :raised_exception => NameError.new}.not_to raise_error
   end
   
 end