renvy 0.2.1 → 0.2.2

data/HISTORY.md

@@ -1,3 +1,9 @@
+v0.2.2 - May 17, 2011
+---------------------
+
+### Added:
+  * Messages (#blaming and #messaging)
+
 v0.2.1 - May 17, 2011
 ---------------------
 

data/README.md

@@ -23,21 +23,27 @@ obj.should.nil                     # => assert_nil obj
 obj.should.be.nil                  # => assert_nil obj
 obj.should.be.a.nil                # => assert_nil obj
 
-# You can also use should_not:
+# You can also use should_not, or should.not:
 obj.should_not == 3
-obj.should_not.be.nil?
+obj.should.not == 3
+obj.should_not.be.nil
 
 # Anything else will pass through with a ?:
 obj.should.be.good_looking         # => assert obj.good_looking?
 
 should.raise(Error) { lol }
 should_not.raise { puts "hi" }
+
+# You may add messages to your asserts with #blaming or #messaging.
+(2 + 2).should.blaming("weird math") == 4
 ```
 
 ## Wrapped assertions
 
 These are based from Test::Spec.
 
+| Test::Unit                  | REnvy                                 |
+|-----------------------------|---------------------------------------|
 | assert_equal                | should.equal, should ==               |
 | assert_not_equal            | should.not.equal, should.not ==       |
 | assert_same                 | should.be                             |

data/lib/renvy.rb

@@ -23,7 +23,7 @@ require 'test/unit'
 #   should_not.raise { puts "hi" }
 #
 module REnvy
-  VERSION = "0.2.1"
+  VERSION = "0.2.2"
 
   def self.version
     VERSION
@@ -31,6 +31,7 @@ module REnvy
 
   class Should
     attr_reader :left
+    attr_reader :msg
 
     def self.init(test) # :nodoc:
       @@test = test
@@ -46,7 +47,7 @@ module REnvy
       @neg  = neg
     end
 
-    def be() self; end
+    def be(right=nil) self.same(right)  if right; self; end
     def a()  self; end
     def an() self; end
 
@@ -55,6 +56,9 @@ module REnvy
     def test()      @@test; end
     def not()       @neg = true; self; end
 
+    def blaming(msg);   @msg = msg; self; end
+    def messaging(msg); @msg = msg; self; end
+
     def ==(right)             assert_or_refute :equal, right, left; end
     def !=(right)             assert_or_refute_not :equal, right, left; end
     def =~(right)             assert_or_refute :match, right, left; end
@@ -78,36 +82,37 @@ module REnvy
     def in_epsilon(right, d=0.001)  assert_or_refute :in_epsilon, right, left, d; end
 
     def assert_or_refute(what, *args, &blk)
-      test.send (positive? ? :"assert_#{what}" : :"refute_#{what}"), *args, &blk
+      test.send (positive? ? :"assert_#{what}" : :"refute_#{what}"), *args, msg, &blk
     end
 
     def assert_or_refute_not(what, *args)
-      test.send (negative? ? :"assert_#{what}" : :"refute_#{what}"), *args
+      test.send (negative? ? :"assert_#{what}" : :"refute_#{what}"), *args, msg
     end
 
     def throw(what=nil, &blk)
       if positive?
-        test.send :assert_throws, what, &blk
+        test.send :assert_throws, what, msg, &blk
       else
-        test.send :assert_nothing_thrown, &blk
+        test.send :assert_nothing_thrown, msg, &blk
       end
     end
 
     def raise(ex=StandardError, &blk)
       if positive?
-        test.send :assert_raises, ex, &blk
+        test.send :assert_raises, ex, msg, &blk
       else
-        test.send :assert_nothing_raised, &blk
+        test.send :assert_nothing_raised, msg, &blk
       end
     end
 
     def method_missing(meth, *args, &blk)
       result = left.send(:"#{meth}?", *args, &blk)
-      if positive?
-        test.send :assert, result
-      else
-        test.send :assert, ! result
-      end
+      method = positive? ? :assert : :refute
+
+      args = [result]
+      args << msg  if msg
+
+      test.send method, *args
     end
   end
 end

data/test/renvy_test.rb

@@ -54,8 +54,9 @@ class REnvyTest < Test::Unit::TestCase
 
     a = Object.new
     b = a
-    a.should.be.equal?(b)
-    a.should_not.be.equal?(Object.new)
+    a.should.be.equal(b)
+    a.should.be(b)
+    a.should_not.be.equal(Object.new)
 
     Math::PI.should.be.close(22.0/7, 0.1)
 
@@ -66,16 +67,38 @@ class REnvyTest < Test::Unit::TestCase
     Foo.new.should.get_true
   end
 
+  def test_should_be
+    a = Object.new
+    b = a
+
+    expects(:assert_same).with(a, b, nil)
+    a.should.be(b)
+  end
+
   def test_include
-    expects(:assert_includes).with([], 2)
+    expects(:assert_includes).with([], 2, nil)
     [].should.include 2
   end
 
   def test_include_not
-    expects(:refute_includes).with([], 2)
+    expects(:refute_includes).with([], 2, nil)
     [].should.not.include 2
   end
 
+  def test_message
+    expects(:assert_equal).with(4, 3, 'lol')
+    3.should.blaming('lol') == 4
+  end
+
+  def test_message_2
+    object = Object.new
+
+    expects(:assert).with('grape', 'lol')
+    object.expects(:boo?).returns('grape')
+
+    object.should.blaming('lol').boo
+  end
+
   def test_assert_block
     expects :assert_block
     should.satisfy { false }

metadata

@@ -2,7 +2,7 @@
 name: renvy
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors: 
 - Rico Sta. Cruz