ae 1.7.4 → 1.8.0

data/lib/ae/basic_object.rb

@@ -16,7 +16,6 @@ else
     #
     # Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
     # All rights reserved.
-
     class BasicObject #:nodoc:
 
       # Hide the method named +name+ in the BlankSlate class.  Don't

data/lib/ae/check.rb

@@ -1,23 +1,151 @@
 module AE
 
-  module CheckOK
-    def check(&block)
-      @_check = block
+  # The Ok mixin is a reusable assertion helper that
+  # makes it easy to construct parameterized assertions
+  # with an elegant syntax.
+  #
+  module Check
+
+    # The Check::Proc class encapsulates a labeled procedure 
+    # for making assertions using the `ok`/`no` methods.
+    #
+    class Proc
+      # Setup new check procedure.
+      def initialize(options={}, &check)
+        @name    = options[:name]
+        @message = options[:message] || @name
+        @check   = check
+      end
+
+      #
+      def message(&block)
+        if block
+          @message = message
+        end
+        @message
+      end
+    
+      #
+      def message=(msg)
+        @message = msg
+      end
+
+      # Call check procedure.
+      def call(*args)
+        @check.call(*args)
+      end
+
+      #
+      def to_s(*args)
+        case @message
+        when nil
+          @name.to_s
+        when ::Proc
+          @message.call(*args)
+        else
+          # TODO: count %\S and apply `% args.map{|a|a.inspect}[0,count]`
+          @message.to_s
+        end
+      end
+
+      #
+      def ok!(*args)
+        assert(call(*args), to_s(*args))
+      end
+
+      #
+      def no!(*args)
+        refute(call(*args), to_s(*args))
+      end
     end
 
+    # TODO: Better way to customize error message so it can have
+    # arguments in the messages ?
+
+    # Built-in check procedures.
+    TABLE = {
+      :equality       => Check::Proc.new(:message=>"should be equal"){|h| h.any?{|a,b| b==a}},
+      :case_equality  => Check::Proc.new(:message=>"should be equal"){|h| h.any?{|a,b| b===a}}
+    }
+
+    #
+    def self.table
+      @table ||= TABLE.dup
+    end
+
+    # Define a univerally available ok/no check.
+    #
+    #   AE::Check.define(:palindrome) do |x|
+    #     x.reverse == x
+    #   end
+    #
+    def self.define(name, &block)
+      table[name] = Check::Proc.new(name, &block)
+    end
+
+    #
+    def check_table
+      Check.table
+    end
+
+    # Define an ok/no check procedure. A one-off procedure is defined
+    # with a block.
+    #
+    #   check do |x, y|
+    #     x == y
+    #   end
+    #
+    #   ok 1,1
+    #   no 1,2
+    #
+    # The check method can also be used to define reusable checks.
+    #
+    #   check(:palindrome) do |x|
+    #     x.reverse == x
+    #   end
+    #
+    # This will also cause the current check to be set.
+    # Later in the code, the check procedure can be restored
+    # by just passing the symbolic name.
+    #
+    #   check :palindrome
+    #
+    #   ok 'abracarba'
+    #   no 'foolishness'
+    #
+    def check(name=nil, &block)
+      if name
+        if block
+          check_table[name] = Check::Proc.new(:name=>name, &block)
+        end
+        @__check__ = check_table[name]
+      else
+        #raise ArgumentError if block.arity == 0
+        @__check__ = Check::Proc.new(&block)
+      end
+    end
+
+    #
     def ok(*args)
-      @_check.call(*args)
+      __check__.ok!(*args)
     end
 
-    #def no(*args)
-    #  @_check.call(*args)
-    #end
-  end
+    #
+    def no(*args)
+      __check__.no!(*args)
+    end
+
+    # Returns the current check.
+    def __check__
+      @__check__ || check_table[:equality]
+    end
 
-  module World
-    include CheckOK
   end
 
 end
 
+module AE::World
+  # It's upto the test framework to include where needed.
+  include AE::Check
+end
 

data/lib/ae/expect.rb

@@ -1,6 +1,5 @@
-require 'ae/assertor'
-
 module AE
+  require 'ae/assertor'
 
   # = Expect
   #
@@ -57,6 +56,7 @@ module AE
     # Like #expect but uses the reciever as the object
     # of expectation.
     #
+    # @example
     #   /x/.expected do
     #     "oooxooo"
     #   end
@@ -69,7 +69,4 @@ module AE
 
 end
 
-class ::Object #:nodoc:
-  include AE::Expect
-end
-
+# Copyright (c) 2008 Thomas Sawyer

data/lib/ae/legacy.rb

@@ -2,7 +2,7 @@ module AE
 
   module Legacy #:nodoc:
 
-    # = Test::Unit Legacy Assertions
+    # Test::Unit Legacy Assertions
     #
     # This module provides a compatibility layer for Test::Unit.
     # This is an optional module and is intended for providing
@@ -16,21 +16,26 @@ module AE
       # Private method upon which all of the legacy assertions are based
       # (except for #assert itself).
       #
+      # @raise [Assertion] If test fails.
+      #
+      # @return nothing
       def __assert__(test, msg=nil)
         msg = "failed assertion (no message given)" unless msg
-        raise Assertion.new(msg, caller[1..-1]) unless test
+        raise Assertion.new(msg, :backtrace=>caller[1..-1]) unless test
       end
 
       private :__assert__
 
       # The assertion upon which all other assertions are based.
       #
+      # @example
       #   assert [1, 2].include?(5)
       #
+      # @return [Assertor] if `test` not given
       def assert(test=nil, msg=nil)
         if test
           msg = "failed assertion (no message given)" unless msg
-          raise Assertion.new(msg, caller) unless test
+          raise Assertion.new(msg, :backtrace=>caller) unless test
         else
           Assertor.new(self, :backtrace=>caller)  # TODO: Probably remove this!
         end
@@ -38,10 +43,14 @@ module AE
 
       # Passes if the block yields true.
       #
-      # assert_block "Couldn't do the thing" do
-      #   do_the_thing
-      # end
+      # @example
+      #   assert_block "Couldn't do the thing" do
+      #     do_the_thing
+      #   end
+      #
+      # @raise [Assertion] if test fails
       #
+      # @return nothing
       def assert_block(msg=nil) # :yields:
         test = ! yield
         msg = "assertion failed" unless msg
@@ -54,8 +63,12 @@ module AE
       # since a helpful error message is generated when this
       # one fails that tells you the values of expected and actual.
       #
+      # @example
       #   assert_equal 'MY STRING', 'my string'.upcase
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_equal(exp, act, msg=nil)
         test = (exp == act)
         msg  = "Expected #{act.inspect} to be equal to #{exp.inspect}" unless msg
@@ -64,8 +77,12 @@ module AE
 
       # Passes if expected_float and actual_float are equal within delta tolerance.
       #
+      # @example
       #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_in_delta(exp, act, delta, msg=nil)
         test = (exp.to_f - act.to_f).abs <= delta.to_f
         msg  = "Expected #{exp} to be within #{delta} of #{act}" unless msg
@@ -74,8 +91,12 @@ module AE
 
       # Passes if object .instance_of? klass
       #
+      # @example
       #   assert_instance_of String, 'foo'
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_instance_of(cls, obj, msg=nil)
         test = (cls === obj)
         msg  = "Expected #{obj} to be a #{cls}" unless msg
@@ -84,8 +105,12 @@ module AE
 
       # Passes if object .kind_of? klass
       #
+      # @example
       #   assert_kind_of Object, 'foo'
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_kind_of(cls, obj, msg=nil)
         test = obj.kind_of?(cls)
         msg  = "Expected #{obj.inspect} to be a kind of #{cls}" unless msg
@@ -94,8 +119,12 @@ module AE
 
       # Passes if string =~ pattern.
       #
+      # @example
       #   assert_match(/\d+/, 'five, 6, seven')
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_match(exp, act, msg=nil)
         test = (act =~ exp)
         msg  = "Expected #{act.inspect} to match #{exp.inspect}" unless msg
@@ -104,8 +133,12 @@ module AE
 
       # Passes if object is nil.
       #
+      # @example
       #   assert_nil [1, 2].uniq!
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_nil(obj, msg=nil)
         test = obj.nil?
         msg  = "Expected #{obj.inspect} to be nil" unless msg
@@ -114,8 +147,12 @@ module AE
 
       # Passes if regexp !~ string
       #
+      # @example
       #   assert_no_match(/two/, 'one 2 three')
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_no_match(exp, act, msg=nil)
         test = (act !~ exp)
         msg  = "Expected #{act.inspect} to match #{exp.inspect}" unless msg
@@ -124,8 +161,12 @@ module AE
 
       # Passes if expected != actual
       #
+      # @example
       #  assert_not_equal 'some string', 5
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_not_equal(exp, act, msg=nil)
         test = (exp != act)
         msg  = "Expected #{act.inspect} to not be equal to #{exp.inspect}" unless msg
@@ -134,8 +175,12 @@ module AE
 
       # Passes if ! object .nil?
       #
+      # @example
       #   assert_not_nil '1 two 3'.sub!(/two/, '2')
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_not_nil(obj, msg=nil)
         test = ! obj.nil?
         msg  = "Expected #{obj.inspect} to not be nil" unless msg
@@ -144,8 +189,12 @@ module AE
 
       # Passes if ! actual .equal? expected
       #
+      # @example
       #   assert_not_same Object.new, Object.new
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_not_same(exp, act, msg=nil)
         test = ! exp.equal?(act)
         msg  = "Expected #{act.inspect} to not be the same as #{exp.inspect}" unless msg
@@ -156,8 +205,12 @@ module AE
       #
       # Passes if object1.send(operator, object2) is true.
       #
+      # @example
       #   assert_operator 5, :>=, 4
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_operator(o1, op, o2, msg="")
         test = o1.__send__(op, o2)
         msg = "Expected #{o1}.#{op}(#{o2}) to be true" unless msg
@@ -166,10 +219,14 @@ module AE
 
       # Passes if the block raises one of the given exceptions.
       #
+      # @example
       #   assert_raise RuntimeError, LoadError do
       #     raise 'Boom!!!'
       #   end
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_raises(*args)
         msg = (Module === args.last ? nil : args.pop)
         begin
@@ -189,6 +246,7 @@ module AE
       # Provides a way to assert that a procedure
       # <i>does not</i> raise an exception.
       #
+      # @example
       #   refute_raises(StandardError){ raise }
       #
       #def assert_raises!(exception, &block)
@@ -202,8 +260,12 @@ module AE
 
       # Passes if +object+ respond_to? +method+.
       #
+      # @example
       #   assert_respond_to 'bugbear', :slice
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_respond_to(obj, meth, msg=nil)
         msg  = "Expected #{obj} (#{obj.class}) to respond to ##{meth}" unless msg
         #flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
@@ -214,9 +276,13 @@ module AE
 
       # Passes if +actual+ .equal? +expected+ (i.e. they are the same instance).
       #
+      # @example
       #   o = Object.new
       #   assert_same(o, o)
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_same(exp, act, msg=nil)
         msg  = "Expected #{act.inspect} to be the same as #{exp.inspect}" unless msg
         test = exp.equal?(act)
@@ -230,10 +296,12 @@ module AE
       # * A method
       # * Arguments to the method
       #
-      # Example:
-      #
+      # @example
       #   assert_send [[1, 2], :include?, 4]
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_send(send_array, msg=nil)
         r, m, *args = *send_array
         test = r.__send__(m, *args)
@@ -243,10 +311,14 @@ module AE
 
       # Passes if the block throws expected_symbol
       #
+      # @example
       #   assert_throws :done do
       #     throw :done
       #   end
       #
+      # @raise [Assertion] if test fails
+      #
+      # @return nothing
       def assert_throws(sym, msg=nil)
         msg  = "Expected #{sym} to have been thrown" unless msg
         test = true
@@ -265,8 +337,12 @@ module AE
 
       # Flunk always fails.
       #
+      # @example
       #   flunk 'Not done testing yet.'
       #
+      # @raise [Assertion] always
+      #
+      # @return nothing
       def flunk(msg=nil)
         __assert__(false, msg)
       end