minitest-should_syntax 1.0.0

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1 @@
+gemspec

data/HISTORY.md

@@ -0,0 +1,4 @@
+v1.0.0 - Jan 13, 2013
+---------------------
+
+First release.

data/README.md

@@ -0,0 +1,129 @@
+# minitest-should_syntax
+
+Rspec-like matching for MiniTest.
+
+*minitest-should_syntax* lets you use a syntax similar to RSpec on your MiniTest 
+tests.  It monkey-patches Object to translate RSpec-like sugar into plain 
+MiniTest `assert` matchers.
+
+```
+$ gem install minitest-should_syntax
+```
+
+## Basic usage
+
+``` ruby
+require 'minitest/autorun'
+require 'minitest/should_syntax'
+
+describe "Books" do
+  it "should work" do
+    book = Book.new title: "Revolution"
+
+    book.title.should == "Revolution"
+  end
+end
+
+```
+
+## Should
+
+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.nil                     # => assert_nil obj
+obj.should.respond_to(:freeze)     # => assert_respond_to obj, :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, or should.not:
+obj.should_not == 3
+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 MiniTest::Assertions.
+
+| Test::Unit                  | MiniTest::ShouldSyntax                |
+|-----------------------------|---------------------------------------|
+| 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_block                | should.satisfy                        |
+
+## Messages
+
+Use the `msg` helper:
+
+``` ruby
+it "should work" do
+  book = Book.new title: "Pride & Prejudice"
+
+  msg "The title should've been set on constructor."
+  book.title.should == "Pride & Prejudice"
+end
+```
+
+Or you can use `.blaming` which does the same thing (with a more cumbersome 
+    syntax):
+
+``` ruby
+it "should work" do
+  book = Book.new title: "Pride & Prejudice"
+
+  message = "The title should've been set on constructor."
+  book.title.should.blaming(message) == "Pride & Prejudice"
+end
+```
+
+## Extending
+
+Need to create your own matchers? Create your new matcher in a module, then use 
+`MiniTest::ShouldSyntax.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
+
+MiniTest::ShouldSyntax.add DanceMatcher
+
+# Then in your tests, use:
+dancer.should.boogie_all_night!
+```
+

data/Rakefile

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

data/lib/minitest/should_syntax/version.rb

@@ -0,0 +1,7 @@
+module MiniTest
+  class ShouldSyntax
+    def self.version
+      "1.0.0"
+    end
+  end
+end

data/lib/minitest/should_syntax.rb

@@ -0,0 +1,162 @@
+require 'minitest/unit'
+
+# Rspec-like matching for MiniTest.
+#
+# == Usage
+#
+#   # All objects get .should:
+#     obj.should == 2
+#     obj.should ~= /regex/
+#     obj.should != 3
+#     obj.should.be.true    # Truthy
+#     obj.should.be.false   # Falsy
+#
+#   # 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?
+#
+#   # Errors and throws
+#     should.raise(Error) { lol }
+#     should.throw(:x) { lol }
+#
+#   # Messages
+#     msg "Age must be set properly"
+#     age.should == 18
+#
+module MiniTest
+  class ShouldSyntax
+    require File.expand_path('../should_syntax/version', __FILE__)
+
+    attr_reader :left
+    attr_reader :msg
+
+    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
+
+    def initialize(left, neg=false)
+      @left = left
+      @neg  = neg
+      if test.msg
+        blaming test.msg
+        test.msg = nil
+      end
+    end
+
+    def be(right=nil) self.same(right)  if right; 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 true()    true_or_false(true); end
+    def false()   true_or_false(false); end
+
+    def true_or_false(bool)
+      val = !! left
+      val = !val  if bool == false
+      method = (positive? ? :"assert" : :"refute")
+      test.send method, val, [msg, 'Expected to be falsy'].compact.join("\n")
+    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)             refute_or_assert :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, msg, &blk
+    end
+
+    def refute_or_assert(what, *args)
+      test.send (negative? ? :"assert_#{what}" : :"refute_#{what}"), *args, msg
+    end
+
+    def throw(what=nil, &blk)
+      if positive?
+        test.send :assert_throws, what, msg, &blk
+      else
+        warn "ShouldSyntax: should.not.throw is not supported"
+      end
+    end
+
+    def raise(ex=StandardError, &blk)
+      if positive?
+        test.send :assert_raises, ex, msg, &blk
+      else
+        warn "ShouldSyntax: should.not.raise is not supported"
+      end
+    end
+
+    def method_missing(meth, *args, &blk)
+      result = left.send(:"#{meth}?", *args, &blk)
+      method = positive? ? :assert : :refute
+
+      args = [result]
+      args << msg  if msg
+
+      test.send method, *args
+    end
+  end
+end
+
+class Object
+  def should
+    MiniTest::ShouldSyntax.new(self)
+  end
+
+  def should_not
+    MiniTest::ShouldSyntax.new(self, true)
+  end
+end
+
+class MiniTest::Unit::TestCase
+  alias :mts_before_setup :before_setup
+
+  def before_setup(*a, &block)
+    MiniTest::ShouldSyntax.init self
+    mts_before_setup(*a, &block)
+  end
+
+  def msg(string=nil)
+    self.msg = string if string
+    @msg
+  end
+
+  def msg=(string)
+    @msg = string
+  end
+end

data/minitest-should_syntax.gemspec

@@ -0,0 +1,15 @@
+require "./lib/minitest/should_syntax/version"
+Gem::Specification.new do |s|
+  s.name = "minitest-should_syntax"
+  s.version = MiniTest::ShouldSyntax.version
+  s.summary = "RSpec-like syntax for MiniTest."
+  s.description = "Lets you use a syntax similar to RSpec on your MiniTest tests."
+  s.authors = ["Rico Sta. Cruz"]
+  s.email = ["rico@sinefunc.com"]
+  s.homepage = "http://github.com/rstacruz/minitest-should_syntax"
+  s.files = `git ls-files`.strip.split("\n")
+
+  s.add_dependency "minitest"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "rake"
+end

data/test/extension_test.rb

@@ -0,0 +1,37 @@
+require File.expand_path('../helper', __FILE__)
+
+module MiniTest::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.refute_equal left.sort, right.sort
+    end
+  end
+end
+
+MiniTest::ShouldSyntax.add MiniTest::ArrayMatcher
+
+class ExtensionTest < UnitTest
+  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.should_not.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/helper.rb

@@ -0,0 +1,8 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+require 'minitest/autorun'
+require 'minitest/should_syntax'
+require 'mocha/setup'
+
+class UnitTest < MiniTest::Unit::TestCase
+end

data/test/include_test.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../helper', __FILE__)
+
+class IncludeTest < UnitTest
+  def test_should_include
+    "abc".should.include "b"
+  end
+
+  def test_should_include_fail
+    self.expects(:assert_includes).with { |a, b| a == "axxc" && b == "b" }
+    "axxc".should.include "b"
+  end
+end

data/test/should_test.rb

@@ -0,0 +1,142 @@
+require File.expand_path('../helper', __FILE__)
+
+class Foo
+  def get_true?
+    true
+  end
+
+  def get_false?
+    false
+  end
+end
+
+class ShouldTest < UnitTest
+  describe "should" do
+    it ".should ==" do
+      2.should     == 2
+      2.should_not == 3
+      2.should.not == 3
+    end
+
+    it ".should !=" do
+      2.should     != 3
+      2.should_not != 2
+      2.should.not != 2
+    end
+
+    it ".should.match" do
+      "hi".should =~ /hi/
+      "hi".should.match /hi/
+      "hi".should_not =~ /HI/
+      "hi".should.not.match /HI/
+    end
+
+    it ".should.be.nil?" do
+      @foo.should.be.nil?
+      1000.should_not.be.nil?
+    end
+
+    it ".should.respond_to" do
+      "".should.respond_to(:empty?)
+      "".should_not.respond_to(:lolwhat)
+    end
+
+    it ".should.raise" do
+      should.raise(ZeroDivisionError) { 2 / 0 }
+      # should_not.raise { 2 + 2 }
+    end
+
+    it ".should.be.empty" do
+      [].should.be.empty
+      [].should.empty
+    end
+
+    it ".should.not.be.empty" do
+      [1].should_not.be.empty
+      [1].should.include(1)
+    end
+
+    it ".should <" do
+      2.should < 3
+      1.should < 2
+      2.should <= 2
+      2.should <= 4
+      4.should >= 4
+      4.should >= 3
+    end
+
+    it ".should.be.kind_of" do
+      Object.new.should.respond_to(:freeze)
+      Object.new.should.be.kind_of(Object)
+      Object.new.should.be.an.instance_of(Object)
+    end
+
+    it "should.be.equal again" do
+      a = Object.new
+      b = a
+      a.should.be.equal(b)
+      a.should.be(b)
+      a.should_not.be.equal(Object.new)
+    end
+
+
+    it ".should.be.close" do
+      Math::PI.should.be.close(22.0/7, 0.1)
+    end
+
+    it ".should.throw" do
+      should.throw(:x) { throw :x }
+      # should.not.throw { 2 + 2 }
+    end
+
+    it ".should.not.method_missing" do
+      Foo.new.should.not.get_false
+      Foo.new.should.get_true
+    end
+
+    it ".should.be" do
+      a = Object.new
+      b = a
+
+      expects(:assert_same).with(a, b, nil)
+      a.should.be(b)
+    end
+
+    it ".should.include" do
+      expects(:assert_includes).with([], 2, nil)
+      [].should.include 2
+    end
+
+    it ".should.not.include" do
+      expects(:refute_includes).with([], 2, nil)
+      [].should.not.include 2
+    end
+
+    it ".should.blaming" do
+      expects(:assert_equal).with(4, 3, 'lol')
+      3.should.blaming('lol') == 4
+    end
+
+    it ".msg" do
+      expects(:assert_equal).with(4, 3, 'oh no')
+
+      msg "oh no"
+      3.should == 4
+    end
+
+    it ".should.blaming again" do
+      object = Object.new
+
+      expects(:assert).with(true).at_least_once # Because minitest does this
+      expects(:assert).with(true, 'he cant dance')
+      object.expects(:dance?).returns(true)
+
+      object.should.blaming('he cant dance').dance
+    end
+
+    it ".should.satisfy" do
+      expects :assert_block
+      should.satisfy { false }
+    end
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: minitest-should_syntax
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors:
+- Rico Sta. Cruz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  name: minitest
+  type: :runtime
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  name: mocha
+  type: :development
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  name: rake
+  type: :development
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: Lets you use a syntax similar to RSpec on your MiniTest tests.
+email:
+- rico@sinefunc.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- HISTORY.md
+- README.md
+- Rakefile
+- lib/minitest/should_syntax.rb
+- lib/minitest/should_syntax/version.rb
+- minitest-should_syntax.gemspec
+- test/extension_test.rb
+- test/helper.rb
+- test/include_test.rb
+- test/should_test.rb
+homepage: http://github.com/rstacruz/minitest-should_syntax
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: RSpec-like syntax for MiniTest.
+test_files: []