renvy 0.1.1 → 0.2.1

data/HISTORY.md

@@ -0,0 +1,25 @@
+v0.2.1 - May 17, 2011
+---------------------
+
+Massive API overhaul to match Test::Spec API.
+
+v0.1.3 - May 17, 2011
+---------------------
+
+### Fixed:
+  * Fixed operations (`a.should < b` and so on)
+
+v0.1.2 - May 17, 2011
+---------------------
+
+### Added:
+  * Added `in_delta?` and `in_eplison?` for floats.
+
+### Changed:
+  * Doing `include?`, `instance_of?`, `equal?` and so on will use the 
+  appropriate MiniTest matchers instead of generic asserts.
+
+v0.1.1 - May 17, 2011
+---------------------
+
+Initial version.

data/README.md

@@ -13,27 +13,53 @@ Then you may use it as so:
 
 ```ruby
 obj.should == 2                    # => assert_equal 2, obj
-obj.should ~= /regex/              # => assert_match /regex/, obj
+obj.should =~ /regex/              # => assert_match /regex/, obj
 obj.should != 3                    # => assert_not_equal 3, obj
-obj.should.be.true!                # => assert obj
-obj.should.be.false!
+obj.should.nil                     # => assert_nil obj
+obj.should.respond_to(:freeze)     # => assert_respond_to obj, :freeze 
 
-# Anything else will just pass thru (.be is optional):
-obj.should.nil?                    # => assert obj.nil?
-obj.should.be.nil?                 # => assert obj.nil?
-obj.should.respond_to?(:freeze)    # => assert obj.respond_to?(:freeze)
+# Note that .be, .a and .an are optional.
+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:
 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" }
 ```
 
-### Extending
+## Wrapped assertions
+
+These are based from Test::Spec.
+
+| assert_equal                | should.equal, should ==               |
+| assert_not_equal            | should.not.equal, should.not ==       |
+| assert_same                 | should.be                             |
+| assert_not_same             | should.not.be                         |
+| assert_nil                  | should.be.nil                         |
+| assert_not_nil              | should.not.be.nil                     |
+| assert_in_delta             | should.be.close                       |
+| assert_match                | should.match, should =~               |
+| assert_no_match             | should.not.match, should.not =~       |
+| assert_instance_of          | should.be.an.instance_of              |
+| assert_kind_of              | should.be.a.kind_of                   |
+| assert_respond_to           | should.respond_to                     |
+| assert_raise                | should.raise                          |
+| assert_nothing_raised       | should.not.raise                      |
+| assert_throws               | should.throw                          |
+| assert_nothing_thrown       | should.not.throw                      |
+| assert_block                | should.satisfy                        |
+
+## Extending
 
-Create your new matcher in a module, then use `REnvy::Should.add`.
+Need to create your own matchers? Create your new matcher in a module, then 
+use `REnvy::Should.add`.
 
 ```ruby
 module DanceMatcher
@@ -52,5 +78,16 @@ REnvy::Should.add DanceMatcher
 dancer.should.boogie_all_night!
 ```
 
-(You may also use `REnvy::Should::Be.add` to restrict it to the `.should.be` 
- context.)
+## REnvy vs. Test::Spec
+
+[Test-Spec](http://test-spec.rubyforge.org/test-spec/) accomplishes roughly 
+the same thing as REnvy, but:
+
+ * REnvy does it with lean <4kb code.
+
+ * REnvy can play alongside with other Test::Unit wrappers. In fact, is made 
+to be used with gems like Contest, Shoulda, and other similar tools.
+
+ * REnvy does not provide contexts or 'should'-like syntax like Test::Spec 
+ does.  For that, I suggest using REnvy alongside 
+ [Contest](http://github.com/citrusbyte/contest).

data/lib/renvy.rb

@@ -23,7 +23,7 @@ require 'test/unit'
 #   should_not.raise { puts "hi" }
 #
 module REnvy
-  VERSION = "0.1.1"
+  VERSION = "0.2.1"
 
   def self.version
     VERSION
@@ -32,10 +32,11 @@ module REnvy
   class Should
     attr_reader :left
 
-    def self.init(test)
+    def self.init(test) # :nodoc:
       @@test = test
     end
 
+    # Includes a module to extend .should with more matchers.
     def self.add(extension)
       self.send :include, extension
     end
@@ -45,46 +46,53 @@ module REnvy
       @neg  = neg
     end
 
-    def negative?
-      @neg
+    def be() self; end
+    def a()  self; end
+    def an() self; end
+
+    def negative?() @neg; end
+    def positive?() !@neg; end
+    def test()      @@test; end
+    def not()       @neg = true; 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
+    def >(right)              assert_or_refute :operator, left, :>,  right; end
+    def <(right)              assert_or_refute :operator, left, :<,  right; end
+    def >=(right)             assert_or_refute :operator, left, :>=, right; end
+    def <=(right)             assert_or_refute :operator, left, :<=, right; end
+    def include(right)        assert_or_refute :includes, left, right; end
+    def instance_of(right)    assert_or_refute :instance_of, right, left; end
+    def kind_of(right)        assert_or_refute :kind_of, right, left; end
+    def nil()                 assert_or_refute :nil, left; end
+    def same(right)           assert_or_refute :same, right, left; end
+    def respond_to(right)     assert_or_refute :respond_to, left, right; end
+    def empty()               assert_or_refute :empty, left; end
+    def satisfy(&blk)         assert_or_refute :block, &blk; end
+
+    def match(right)          self =~ right; end
+    def equal(right)          self == right; end
+
+    def close(right, d=0.001)       assert_or_refute :in_delta, right, left, d; end
+    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
     end
 
-    def positive?
-      !@neg
+    def assert_or_refute_not(what, *args)
+      test.send (negative? ? :"assert_#{what}" : :"refute_#{what}"), *args
     end
 
-    def test
-      @@test
-    end
-
-    def ==(right)
-      if positive?
-        test.send :assert_equal, right, left
-      else
-        test.send :assert_not_equal, right, left
-      end
-    end
-
-    def !=(right)
+    def throw(what=nil, &blk)
       if positive?
-        test.send :assert_not_equal, right, left
+        test.send :assert_throws, what, &blk
       else
-        test.send :assert_equal, right, left
+        test.send :assert_nothing_thrown, &blk
       end
     end
 
-    def =~(right)
-      if positive?
-        test.send :assert_match, right, left
-      else
-        test.send :assert, ! (left =~ right)
-      end
-    end
-
-    def be
-      Be.new(left, @neg)
-    end
-
     def raise(ex=StandardError, &blk)
       if positive?
         test.send :assert_raises, ex, &blk
@@ -94,29 +102,11 @@ module REnvy
     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
-    end
-  end
-
-  class Should::Be < Should
-    def true!
-      if positive?
-        test.send :assert, left
-      else
-        test.send :assert, ! left
-      end
-    end
-
-    def false!
+      result = left.send(:"#{meth}?", *args, &blk)
       if positive?
-        test.send :assert, ! left
+        test.send :assert, result
       else
-        test.send :assert, left
+        test.send :assert, ! result
       end
     end
   end

data/test/extension_test.rb

@@ -25,7 +25,7 @@ class ExtensionTest < Test::Unit::TestCase
     a = %w(a b c)
     b = %w(b c A)
 
-    a.shouldnt.be.like b
+    a.should_not.be.like b
   end
 
   def test_extension_3

data/test/renvy_test.rb

@@ -1,30 +1,83 @@
 require File.expand_path('../../lib/renvy', __FILE__)
+require 'mocha'
+
+class Foo
+  def get_true?
+    true
+  end
+
+  def get_false?
+    false
+  end
+end
 
 class REnvyTest < Test::Unit::TestCase
   def test_should
-    2.should   == 2
-    2.shouldnt == 3
+    2.should     == 2
+    2.should_not == 3
+    2.should.not == 3
 
-    2.should   != 3
-    2.shouldnt != 2
+    2.should     != 3
+    2.should_not != 2
+    2.should.not != 2
 
     "hi".should =~ /hi/
-    "hi".shouldnt =~ /HI/
-
-    true.should.be.true!
-    "ye".should.be.true!
-    true.shouldnt.be.false!
-
-    false.should.be.false!
-    false.shouldnt.be.true!
+    "hi".should.match /hi/
+    "hi".should_not =~ /HI/
+    "hi".should.not.match /HI/
 
     @foo.should.be.nil?
-    1000.shouldnt.be.nil?
+    1000.should_not.be.nil?
 
-    "".should.respond_to?(:empty?)
-    "".shouldnt.respond_to?(:lolwhat)
+    "".should.respond_to(:empty?)
+    "".should_not.respond_to(:lolwhat)
 
-    shouldnt.raise { 2 + 2 }
+    should_not.raise { 2 + 2 }
     should.raise(ZeroDivisionError) { 2 / 0 }
+
+    [].should.be.empty
+    [].should.empty
+
+    [1].should_not.be.empty
+    [1].should.include(1)
+
+    2.should < 3
+    1.should < 2
+    2.should <= 2
+    2.should <= 4
+    4.should >= 4
+    4.should >= 3
+
+    Object.new.should.respond_to(:freeze)
+    Object.new.should.be.kind_of(Object)
+    Object.new.should.be.an.instance_of(Object)
+
+    a = Object.new
+    b = a
+    a.should.be.equal?(b)
+    a.should_not.be.equal?(Object.new)
+
+    Math::PI.should.be.close(22.0/7, 0.1)
+
+    should.throw(:x) { throw :x }
+    should.not.throw { 2 + 2 }
+
+    Foo.new.should.not.get_false
+    Foo.new.should.get_true
+  end
+
+  def test_include
+    expects(:assert_includes).with([], 2)
+    [].should.include 2
+  end
+
+  def test_include_not
+    expects(:refute_includes).with([], 2)
+    [].should.not.include 2
+  end
+
+  def test_assert_block
+    expects :assert_block
+    should.satisfy { false }
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: renvy
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors: 
 - Rico Sta. Cruz
@@ -37,6 +37,7 @@ files:
 - lib/renvy.rb
 - test/extension_test.rb
 - test/renvy_test.rb
+- HISTORY.md
 - README.md
 - Rakefile
 has_rdoc: true