assay 0.2.0 → 0.3.0

data/HISTORY.rdoc

@@ -1,5 +1,16 @@
 = HISTORY
 
+== 0.3.0 | 2011-05-07
+
+This release fix the interface of the assertive methods so they accept
+a message argument, like the original testunit.
+
+Changes:
+
+* Fix assertive methods to take message argument.
+* Fix Assertion class to store message.
+
+
 == 0.2.0 | 2011-05-05
 
 This release of Assay is in good working order and can now be used

data/README.rdoc

@@ -18,7 +18,7 @@ TestUnit, MiniTest, RSpec and other test frameworks.
 * Assertions get their own specialized error messages.
 
 
-= RESOURCES
+== RESOURCES
 
 * home: http://rubyworks.github.com/assay
 * code: http://github.com/rubyworks/assay

data/lib/assay/assertion.rb

@@ -79,6 +79,7 @@ module Assay
     def initialize(message=nil, *arguments, &block)
       message ? super(message % arguments) : super()
 
+      @mesg      = message  # why isn't this in @mesg from super()?
       @arguments = arguments
       @block     = block
 

data/lib/assay/assertions/compare_failure.rb

@@ -18,6 +18,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 2
 
       iexp = @arguments[0].inspect

data/lib/assay/assertions/delta_failure.rb

@@ -22,6 +22,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 3
 
       exp   = @arguments[0].inspect
@@ -43,18 +44,17 @@ module Assay
     #
     #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
     #
-    def assert_in_delta(exp, act, delta, opts={})
-      opts[:backtrace] ||= caller
-      DeltaFailure.assert(exp, act, delta, opts)
+    def assert_in_delta(exp, act, delta, msg=nil)
+      DeltaFailure.assert(exp, act, delta, :message=>msg, :backtrace=>caller)
     end
 
     # Passes if expected and actual are equal not within delta tolerance.
     #
     #   assert_not_in_delta 0.05, (50000.0 / 10**6), 0.00001
     #
-    def self.not_in_delta(exp, act, delta, opts)
+    def self.not_in_delta(exp, act, delta, msg=nil)
       opts[:backtrace] ||= caller
-      DeltaFailure.refute(exp, act, delta, opts)
+      DeltaFailure.refute(exp, act, delta, :message=>msg, :backtrace=>caller)
     end
   end
 

data/lib/assay/assertions/empty_failure.rb

@@ -19,6 +19,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 1
 
       exp = @arguments.first.inspect
@@ -36,18 +37,17 @@ module Assay
   module Assertives
     # Passed if object is +true+.
     #
-    def assert_empty(exp, opts={})
-      opts[:backtrace] ||= caller
-      EmptyFailure.assert(exp, opts)
+    def assert_empty(exp, msg=nil)
+      EmptyFailure.assert(exp, :message=>msg, :backtrace=>caller)
     end
 
     # Passed if object is not +true+.
     #
     #   assert_not_true(false)
     #
-    def refute_empty(exp, opts={})
+    def refute_empty(exp, msg=nil)
       opts[:backtrace] ||= caller
-      EmptyFailure.refute(exp, opts)
+      EmptyFailure.refute(exp, :message=>msg, :backtrace=>caller)
     end
 
     alias_method :assert_not_empty, :refute_empty

data/lib/assay/assertions/equality_failure.rb

@@ -27,6 +27,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 2
 
       oper = @_negated ? "!=" : "=="
@@ -53,22 +54,16 @@ module Assay
     #
     #   assert_equal 'MY STRING', 'my string'.upcase
     #
-    def assert_equal(exp, act, opts={})
-      opts[:backtrace] ||= caller
-      #message   = opts[:message]
-      EqualityFailure.assert(exp, act, opts)
-      #err = EqualityFailure.new(message, exp, act)
-      #err.set_backtrace(backtrace)
-      #err.assert(opts)
+    def assert_equal(exp, act, msg=nil)
+      EqualityFailure.assert(exp, act, :message=>msg, :backtrace=>caller)
     end
 
     # Passes if expected != actual
     #
     #  assert_not_equal 'some string', 5
     #
-    def assert_not_equal(exp, act, opts)
-       opts[:backtrace] ||= caller
-       EqualityFailure.refute(exp, act, opts)
+    def assert_not_equal(exp, act, msg=nil)
+       EqualityFailure.refute(exp, act, :message=>msg, :backtrace=>caller)
     end
   end
 

data/lib/assay/assertions/execution_failure.rb

@@ -34,6 +34,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       if @_negated
         "Expected procedure to raise an exception"
       else
@@ -51,9 +52,8 @@ module Assay
     #   do_the_thing
     # end
     #
-    def assert_executes(opts={}, &blk)
-      opts[:backtrace] ||= caller
-      ExecutionFailure.assert(opts, &blk)
+    def assert_executes(msg=nil, &blk)
+      ExecutionFailure.assert(:message=>msg, :backtrace=>caller, &blk)
     end
 
     # Passes if the block does not yield successfully.
@@ -62,9 +62,8 @@ module Assay
     #   do_the_thing
     # end
     #
-    def assert_not_executes(opts={}, &blk)
-      opts[:backtrace] ||= caller
-      ExecutionFailure.refute(opts, &blk)
+    def assert_not_executes(msg=nil, &blk)
+      ExecutionFailure.refute(:message=>msg, :backtrace=>caller, &blk)
     end
   end
 

data/lib/assay/assertions/false_failure.rb

@@ -19,6 +19,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 1
 
       exp = @arguments[0].inspect
@@ -36,18 +37,16 @@ module Assay
   module Assertives
     # Passed if object is +false+.
     #
-    def assert_false(exp, opts={})
-      opts[:backtrace] ||= caller
-      FalseFailure.assert(exp, opts)
+    def assert_false(exp, msg=nil)
+      FalseFailure.assert(exp, :message=>msg, :backtrace=>caller)
     end
 
     # Passed if object is not +false+.
     #
     #   assert_not_false(false)
     #
-    def assert_not_false(exp, opts={})
-      opts[:backtrace] ||= caller
-      FalseFailure.refute(exp, opts)
+    def assert_not_false(exp, msg=nil)
+      FalseFailure.refute(exp, :message=>msg, :backtrace=>caller)
     end
   end
 

data/lib/assay/assertions/identity_failure.rb

@@ -27,6 +27,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 2
 
       iexp = @arguments[0].inspect
@@ -48,18 +49,16 @@ module Assay
     #   o = Object.new
     #   assert_identical(o, o)
     #
-    def assert_identical(exp, act, opts={})
-      opts[:backtrace] ||= caller
-      IdentityFailure.assert(exp, act, opts)
+    def assert_identical(exp, act, msg=nil)
+      IdentityFailure.assert(exp, act, :message=>msg, :backtrace=>caller)
     end
 
     # Passes if ! actual .equal? expected
     #
     #   assert_not_identical(Object.new, Object.new)
     #
-    def assert_not_identical(exp, act, opts={})
-      opts[:backtrace] ||= caller
-      IdentityFailure.refute(exp, act, opts)
+    def assert_not_identical(exp, act, msg=nil)
+      IdentityFailure.refute(exp, act, :message=>msg, :backtrace=>caller)
     end
   end
 

data/lib/assay/assertions/instance_failure.rb

@@ -19,6 +19,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 2
 
       exp = @arguments[0].inspect
@@ -38,18 +39,16 @@ module Assay
     #
     #   assert_instance_of(String, 'foo')
     #
-    def assert_instance_of(cls, obj, opts={})
-      opts[:backtrace] ||= caller
-      InstanceFailure.assert(cls, obj, opts)
+    def assert_instance_of(cls, obj, msg=nil)
+      InstanceFailure.assert(cls, obj, :message=>msg, :backtrace=>caller)
     end
 
     # Passes if object .instance_of? klass
     #
     #   assert_instance_of(String, 'foo')
     #
-    def refute_instance_of(cls, obj, opts={})
-      opts[:backtrace] ||= caller
-      InstanceFailure.refute(cls, obj, opts)
+    def refute_instance_of(cls, obj, msg=nil)
+      InstanceFailure.refute(cls, obj, :message=>msg, :backtrace=>caller)
     end
 
     alias_method :assert_not_instance_of, :refute_instance_of

data/lib/assay/assertions/kind_failure.rb

@@ -24,6 +24,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 2
 
       exp = @arguments[0].inspect
@@ -43,17 +44,16 @@ module Assay
     #
     #   assert_kind_of(Object, 'foo')
     #
-    def assert_kind_of(cls, obj, opts={})
-      opts[:backtrace] ||= caller
-      KindFailure.assert(cls, obj, opts)
+    def assert_kind_of(cls, obj, msg=nil)
+      KindFailure.assert(cls, obj, :message=>msg, :backtrace=>caller)
     end
 
     # Passes if object .kind_of? klass
     #
     #   assert_not_kind_of(Object, 'foo')
     #
-    def refute_kind_of(cls, obj, opts={})
-      KindFailure.refute(cls, obj, opts)
+    def refute_kind_of(cls, obj, msg=nil)
+      KindFailure.refute(cls, obj, :message=>msg, :backtrace=>caller)
     end
     alias_method :assert_not_kind_of, :refute_kind_of
   end

data/lib/assay/assertions/match_failure.rb

@@ -29,6 +29,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 2
 
       exp = @arguments[0].inspect
@@ -49,18 +50,16 @@ module Assay
     #
     #   assert_match(/\d+/, 'five, 6, seven')
     #
-    def assert_match(exp, act, opts={})
-      opts[:backtrace] ||= caller
-      MatchFailure.assert(exp, act, opts)
+    def assert_match(exp, act, msg=nil)
+      MatchFailure.assert(exp, act, :message=>msg, :backtrace=>caller)
     end
 
     # Passes if regexp !~ string
     #
     #   refute_match(/two/, 'one 2 three')
     #
-    def refute_match(exp, act, opts={})
-      opts[:backtrace] ||= caller
-      MatchFailure.refute(exp, act, opts)
+    def refute_match(exp, act, msg=nil)
+      MatchFailure.refute(exp, act, :message=>msg, :backtrace=>caller)
     end
   end
 

data/lib/assay/assertions/nil_failure.rb

@@ -19,6 +19,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 1
 
       exp = @arguments[0].inspect
@@ -36,18 +37,17 @@ module Assay
   module Assertives
     # Passed if object is +nil+.
     #
-    def assert_nil(exp, opts={})
-      opts[:backtrace] ||= caller
-      NilFailure.assert(exp, opts)
+    def assert_nil(exp, msg=nil)
+      NilFailure.assert(exp, :message=>msg, :backtrace=>caller)
     end
 
     # Passed if object is not +nil+.
     #
     #   assert_not_nil(true)
     #
-    def assert_not_nil(exp, opts={})
+    def assert_not_nil(exp, msg=nil)
       opts[:backtrace] ||= caller
-      NilFailure.refute(exp, opts)
+      NilFailure.refute(exp, :message=>msg, :backtrace=>caller)
     end
   end
 

data/lib/assay/assertions/raise_failure.rb

@@ -74,6 +74,7 @@ module Assay
 
     # TODO: how to add `but got class` instead.
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 1
 
       exp = @arguments[0].inspect
@@ -90,7 +91,7 @@ module Assay
 
 
   module Assertives
-    # Passes if the block raises a given exceptions.
+    # Passes if the block raises a given exception.
     #
     #   assert_raises RuntimeError do
     #     raise 'Boom!!!'

data/lib/assay/assertions/response_failure.rb

@@ -26,6 +26,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 2
 
       reciever = @arguments[0].inspect
@@ -46,9 +47,8 @@ module Assay
     #
     #   assert_respond_to 'bugbear', :slice
     #
-    def assert_respond_to(reciever, method, opts={})
-      opts[:backtrace] ||= caller
-      ResponseFailure.assert(reciever, method, opts)
+    def assert_respond_to(reciever, method, msg=nil)
+      ResponseFailure.assert(reciever, method, :message=>msg, :backtrace=>caller)
     end
     alias_method :assert_responds_to, :assert_respond_to
 
@@ -56,9 +56,8 @@ module Assay
     #
     #   assert_not_respond_to 'bugbear', :slice
     #
-    def assert_not_respond_to(reciever, method, opts={})
-      opts[:backtrace] ||= caller
-      ResponseFailure.refute(reciever, method, opts)
+    def assert_not_respond_to(reciever, method, msg=nil)
+      ResponseFailure.refute(reciever, method, :message=>msg, :backtrace=>caller)
     end
 
     alias_method :assert_not_responds_to, :assert_not_respond_to

data/lib/assay/assertions/same_failure.rb

@@ -20,6 +20,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 2
 
       exp = @arguments[0].inspect
@@ -44,18 +45,16 @@ module Assay
     #
     #   assert_same 'MY STRING', 'my string'.upcase
     #
-    def assert_same(exp, act, opts={})
-      opts[:backtrace] ||= caller
-      SameFailure.assert(exp, act, opts)
+    def assert_same(exp, act, msg=nil)
+      SameFailure.assert(exp, act, :message=>msg, :backtrace=>caller)
     end
 
     # Passes if not +expected+ .eq? +actual+.
     #
     #  assert_not_the_same 'some string', 5
     #
-    def refute_same(exp, act, opts={})
-      opts[:backtrace] ||= caller
-      SameFailure.refute(exp, act, opts)
+    def refute_same(exp, act, msg=nil)
+      SameFailure.refute(exp, act, :message=>msg, :backtrace=>caller)
     end
 
     alias_method :assert_not_same, :refute_same

data/lib/assay/assertions/throw_failure.rb

@@ -60,6 +60,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 1
 
       sym = @arguments[0].inspect
@@ -81,9 +82,8 @@ module Assay
     #     throw :done
     #   end
     #
-    def assert_throws(sym, opts={}, &blk)
-      opts[:backtrace] ||= caller
-      ThrowFailure.assert(sym, opts, &blk)
+    def assert_throws(sym, msg=nil, &blk)
+      ThrowFailure.assert(sym, :message=>msg, :backtrace=>caller, &blk)
     end
 
     # Passes if the block throws expected_symbol
@@ -92,9 +92,8 @@ module Assay
     #     throw :chimp
     #   end
     #
-    def refute_throws(sym, opts={}, &blk)
-      opts[:backtrace] ||= caller
-      ThrowFailure.refute(sym, opts, &blk)
+    def refute_throws(sym, msg=nil, &blk)
+      ThrowFailure.refute(sym, :message=>msg, :backtrace=>caller, &blk)
     end
 
     alias_method :assert_not_thrown, :refute_throws

data/lib/assay/assertions/true_failure.rb

@@ -25,6 +25,7 @@ module Assay
 
     #
     def to_s
+      return @mesg if @mesg
       return super unless @arguments.size == 1
 
       exp = @arguments[0].inspect
@@ -42,18 +43,16 @@ module Assay
   module Assertives
     # Passed if object is +true+.
     #
-    def assert_true(exp, opts={})
-      opts[:backtrace] ||= caller
-      TrueFailure.assert(exp, opts)
+    def assert_true(exp, msg=nil)
+      TrueFailure.assert(exp, :message=>msg, :backtrace=>caller)
     end
 
     # Passed if object is not +true+.
     #
     #   assert_not_true(false)
     #
-    def assert_not_true(exp, opts={})
-      opts[:backtrace] ||= caller
-      TrueFailure.refute(exp, opts)
+    def assert_not_true(exp, msg=nil)
+      TrueFailure.refute(exp, :message=>msg, :backtrace=>caller)
     end
   end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assay
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Thomas Sawyer