renvy 0.1.1

data/README.md

@@ -0,0 +1,56 @@
+# REnvy
+#### Rspec-like matching for Test::Unit.
+
+REnvy lets you use a syntax similar to RSpec on your Test::Unit tests. It 
+monkey-patches Object to translate RSpec-like sugar into plain Test::Unit 
+`assert` matchers.
+
+```
+$ gem install renvy
+```
+
+Then you may use it as so:
+
+```ruby
+obj.should == 2                    # => assert_equal 2, 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!
+
+# 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)
+
+# You can also use should_not:
+obj.should_not == 3
+obj.should_not.be.nil?
+
+should.raise(Error) { lol }
+should_not.raise { puts "hi" }
+```
+
+### Extending
+
+Create your new matcher in a module, then use `REnvy::Should.add`.
+
+```ruby
+module DanceMatcher
+  def boogie_all_night!
+    if positive?
+      test.assert left.respond_to?(:dance)
+    else
+      test.assert ! left.respond_to?(:dance)
+    end
+  end
+end
+
+REnvy::Should.add DanceMatcher
+
+# Then in your tests, use:
+dancer.should.boogie_all_night!
+```
+
+(You may also use `REnvy::Should::Be.add` to restrict it to the `.should.be` 
+ context.)

data/Rakefile

@@ -0,0 +1,3 @@
+task(:test) {
+  Dir['./test/*.rb'].each { |f| load f }
+}

data/lib/renvy.rb

@@ -0,0 +1,141 @@
+require 'test/unit'
+
+# Rspec-like matching for Test::Unit.
+#
+# == Usage
+#
+#   obj.should == 2
+#   obj.should ~= /regex/
+#   obj.should != 3
+#   obj.should.be.true!
+#   obj.should.be.false!
+#
+#   # Anything else will just pass thru:
+#   obj.should.nil?     # same as: assert obj.nil?
+#   obj.should.be.nil?  # same as: assert obj.nil?
+#   obj.should.respond_to?(:freeze)
+#
+#   # You can also use should_not:
+#   obj.should_not == 3
+#   obj.should_not.be.nil?
+#
+#   should.raise(Error) { lol }
+#   should_not.raise { puts "hi" }
+#
+module REnvy
+  VERSION = "0.1.1"
+
+  def self.version
+    VERSION
+  end
+
+  class Should
+    attr_reader :left
+
+    def self.init(test)
+      @@test = test
+    end
+
+    def self.add(extension)
+      self.send :include, extension
+    end
+
+    def initialize(left, neg=false)
+      @left = left
+      @neg  = neg
+    end
+
+    def negative?
+      @neg
+    end
+
+    def positive?
+      !@neg
+    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)
+      if positive?
+        test.send :assert_not_equal, right, left
+      else
+        test.send :assert_equal, right, left
+      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
+      else
+        test.send :assert_nothing_raised, &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
+    end
+  end
+
+  class Should::Be < Should
+    def true!
+      if positive?
+        test.send :assert, left
+      else
+        test.send :assert, ! left
+      end
+    end
+
+    def false!
+      if positive?
+        test.send :assert, ! left
+      else
+        test.send :assert, left
+      end
+    end
+  end
+end
+
+class Object
+  def should
+    REnvy::Should.new(self)
+  end
+
+  def should_not
+    REnvy::Should.new(self, true)
+  end
+end
+
+class Test::Unit::TestCase
+  alias old_setup setup
+  def setup(&blk)
+    old_setup &blk
+    REnvy::Should.init self
+  end
+end

data/test/extension_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../../lib/renvy', __FILE__)
+
+module REnvy::ArrayMatcher
+  def like(right)
+    super  unless left.is_a?(Array) && right.is_a?(Array)
+    if positive?
+      test.assert_equal left.sort, right.sort
+    else
+      test.assert_not_equal left.sort, right.sort
+    end
+  end
+end
+
+REnvy::Should.add REnvy::ArrayMatcher
+
+class ExtensionTest < Test::Unit::TestCase
+  def test_extension
+    a = %w(a b c)
+    b = %w(b c a)
+
+    a.should.be.like b
+  end
+
+  def test_extension_2
+    a = %w(a b c)
+    b = %w(b c A)
+
+    a.shouldnt.be.like b
+  end
+
+  def test_extension_3
+    a = %w(a b c)
+    b = 2
+
+    should.raise(NoMethodError) { a.should.be.like b }
+  end
+end

data/test/renvy_test.rb

@@ -0,0 +1,30 @@
+require File.expand_path('../../lib/renvy', __FILE__)
+
+class REnvyTest < Test::Unit::TestCase
+  def test_should
+    2.should   == 2
+    2.shouldnt == 3
+
+    2.should   != 3
+    2.shouldnt != 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!
+
+    @foo.should.be.nil?
+    1000.shouldnt.be.nil?
+
+    "".should.respond_to?(:empty?)
+    "".shouldnt.respond_to?(:lolwhat)
+
+    shouldnt.raise { 2 + 2 }
+    should.raise(ZeroDivisionError) { 2 / 0 }
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: renvy
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Rico Sta. Cruz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-17 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: REnvy lets you use a syntax similar to RSpec on your Test::Unit tests.
+email: 
+- rico@sinefunc.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/renvy.rb
+- test/extension_test.rb
+- test/renvy_test.rb
+- README.md
+- Rakefile
+has_rdoc: true
+homepage: http://github.com/rstacruz/renvy
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: RSpec-like syntax for Test::Unit.
+test_files: []
+