qed 1.0.0 → 1.1.0

data/lib/qed/grammar/assert.rb

@@ -1,104 +0,0 @@
-module QED
-
-  require 'qed/expectation'
-
-  module Grammar
-
-    # = Assert Nomenclature
-    #
-    module Assert
-
-      # Assert a operational relationship.
-      #
-      #   4.assert == 3
-      #
-      # If only a single test argument is given then
-      # #assert simple validates that it evalutate to true.
-      # An optional message argument can be given in this
-      # case which will be used instead of the deafult message.
-      #
-      #   assert(4==3, "not the same thing")
-      #
-      # In block form, #assert ensures the block evalutes
-      # truthfully, i.e. not as nil or false.
-      #
-      #   assert{ 4==3 }
-      #
-      # If an argument is given with a block, #assert compares
-      # the argument to the result of evaluating the block.
-      #
-      #   assert(4){ 3 }
-      #
-      # #assert compares the expected value and the actual
-      # value with regular equality <code>#==</code>.
-      #
-      def assert(test=Exception, msg=nil, &block)
-        if block
-          act = block.call
-          if test == Exception
-            raise Assertion.new(msg, caller) unless act
-          else
-            yes = (test == act)
-            msg = "#{exp}.equate? #{act}" unless msg
-            raise Assertion.new(msg, caller) unless yes
-          end
-        elsif test != Exception
-          msg = "failed assertion (no message given)" unless msg
-          raise Assertion.new(msg, caller) unless test
-        else
-          return Expectation.new(self, :backtrace=>caller)
-        end
-      end
-
-      # Assert not an operational relationship.
-      # Read it as "assert not".
-      #
-      #   4.assert! == 4
-      #
-      # See #assert.
-      #
-      # AUHTOR'S NOTE: This method would not be necessary
-      # if Ruby would allow +!=+ to be define as a method,
-      # or at least +!+ as a unary method.
-      #
-      def assert!(test=Exception, msg=nil, &block)
-        if block
-          act = block.call
-          if test == Exception
-            raise Assertion.new(msg, caller) if act
-          else
-            yes = (test == act)
-            msg = "#{exp}.equate? #{act}" unless msg
-            raise Assertion.new(msg, caller) if yes
-          end
-        elsif test != Exception
-          msg = "failed assertion (no message given)" unless msg
-          raise Assertion.new(msg, caller) if test
-        else
-          return Expectation.new(self, :negate=>true, :backtrace=>caller)
-        end
-
-        if test
-          msg = "failed assertion (no message given)" unless msg
-          raise Assertion.new(msg, caller) if test
-        else
-          return Expectation.new(self, :negate=>true, :backtrace=>caller)
-        end
-      end
-
-      # Same as #assert!.
-      #
-      # 4.refute == 4  #=> Assertion Error
-      #
-      alias_method :refute, :assert!
-
-    end
-
-  end
-
-  class ::Object #:nodoc:
-    include Grammar::Assert
-  end
-
-end
-

data/lib/qed/grammar/expect.rb

@@ -1,121 +0,0 @@
-module QED
-
-  require 'qed/expectation'
-
-  module Grammar
-
-    # = Expect Nomenclature
-    #
-    # Provides expect nomenclature. This is Quarry's "standard"
-    # nomenclature.
-    #
-    module Expect
-
-      # The +expect+ method is a powerful tool for defining
-      # expectations in your specifications.
-      #
-      # Like #should it can be used to designate an expectation
-      # via a *functor*.
-      #
-      #   4.expect == 3
-      #
-      # Or it can be used in block form.
-      #
-      #   expect(4){ 3 }
-      #
-      # This compares the expected value and the actual
-      # value with <i>broad equality</i>. This is similar to
-      # case equality (#===) but also checks other forms of
-      # equality. See the #equate method.
-      #
-      # Of particluar utility is that #expect allows one to
-      # specify if the block raises the error.
-      #
-      #   expect NoMethodError do
-      #     not_a_method
-      #   end
-      #
-      def expect(exp=Expectation, &block)
-        if exp == Expectation
-          Expectation.new(self, :backtrace=>caller)
-        elsif Exception >= exp
-          begin
-            act  = block.call
-            test = exp.equate?(act)
-            msg  = "#{exp}.equate? #{act}"
-          rescue exp => error
-            test = true
-            #msg  = "#{exp} expected to be raised"
-          rescue Exception => error
-            test = false
-            msg  = "#{exp} expected but #{error.class} was raised"
-          end
-          raise Assertion.new(msg, caller) unless test
-        else
-          act  = block.call
-          test = exp.equate?(act)
-          msg  = "#{exp}.equate? #{act}"
-          raise Assertion.new(msg, caller) unless test
-        end
-      end
-
-      # Designate a negated expectation. Read this as
-      # "expect not".
-      #
-      #   4.expect! == 4  #=> Expectation Error
-      #
-      # See #expect.
-      #
-      # Note that this method would not be necessary if
-      # Ruby would allow +!=+ to be defined as a method,
-      # or perhaps +!+ as a unary method.
-      #
-      def expect!(exp=Expectation, &block)
-        if exp == Expectation
-          Expectation.new(self, :negate=>true, :backtrace=>caller)
-        elsif Exception >= exp
-          begin
-            act  = block.call
-            test = !exp.equate?(act)
-            msg  = "! #{exp}.equate? #{act}"
-          rescue exp => error
-            test = false
-            msg  = "#{exp} raised"
-          rescue Exception => error
-            test = true
-            #msg  = "#{exp} expected but was #{error.class}"
-          end
-          raise Assertion.new(msg, caller) unless test
-        else
-          act  = block.call
-          test = !exp.equate?(act)
-          msg  = "! #{exp}.equate? #{act}"
-          raise Assertion.new(msg, caller) unless test
-        end
-      end
-
-      # See #expect! method.
-      #
-      alias_method :expect_not, :expect!
-
-    end
-
-  end
-
-  class ::Object #:nodoc:
-    include Grammar::Expect
-  end
-
-  module ::Kernel
-    # Broad equality.
-    #
-    def equate?(actual)
-      self.equal?(actual) ||
-      self.eql?(actual)   ||
-      self == actual      ||
-      self === actual
-    end
-  end
-
-end
-

data/lib/qed/grammar/legacy/assert.rb

@@ -1,291 +0,0 @@
-module QED
-
-  module Grammar #:nodoc:
-
-    module Legacy #:nodoc:
-
-      # = Test::Unit Legacy Assertions
-      #
-      # This module provides a compatibility layer for Test::Unit.
-      # This is an optional module and is intended for providing
-      # an easier transition from Test::Unit::TestCase to Quarry
-      # Specifications.
-      #
-      # Note that two methods are not provided, +#assert_nothing_raised+,
-      # and +#assert_nothing_thrown+.
-      #
-      module Assertions
-
-        # Private method upon which all of the legacy assertions are based
-        # (except for #assert itself).
-        #
-        def __assert__(test, msg=nil)
-          msg = "failed assertion (no message given)" unless msg
-          raise Assertion.new(msg, caller[1..-1]) unless test
-        end
-
-        private :__assert__
-
-        # The assertion upon which all other assertions are based.
-        #
-        #   assert [1, 2].include?(5)
-        #
-        def assert(test=nil, msg=nil)
-          if test
-            msg = "failed assertion (no message given)" unless msg
-            raise Assertion.new(msg, caller) unless test
-          else
-            Expectation.new(self, :backtrace=>caller)
-          end
-        end
-
-        # Passes if the block yields true.
-        #
-        # assert_block "Couldn't do the thing" do
-        #   do_the_thing
-        # end
-        #
-        def assert_block(msg=nil) # :yields:
-          test = ! yield
-          msg = "assertion failed" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if expected == +actual.
-        #
-        # Note that the ordering of arguments is important,
-        # since a helpful error message is generated when this
-        # one fails that tells you the values of expected and actual.
-        #
-        #   assert_equal 'MY STRING', 'my string'.upcase
-        #
-        def assert_equal(exp, act, msg=nil)
-          test = (exp == act)
-          msg  = "Expected #{act.inspect} to be equal to #{exp.inspect}" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if expected_float and actual_float are equal within delta tolerance.
-        #
-        #   assert_in_delta 0.05, (50000.0 / 10**6), 0.00001
-        #
-        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
-          __assert__(test, msg)
-        end
-
-        # Passes if object .instance_of? klass
-        #
-        #   assert_instance_of String, 'foo'
-        #
-        def assert_instance_of(cls, obj, msg=nil)
-          test = (cls === obj)
-          msg  = "Expected #{obj} to be a #{cls}" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if object .kind_of? klass
-        #
-        #   assert_kind_of Object, 'foo'
-        #
-        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
-          __assert__(test, msg)
-        end
-
-        # Passes if string =~ pattern.
-        #
-        #   assert_match(/\d+/, 'five, 6, seven')
-        #
-        def assert_match(exp, act, msg=nil)
-          test = (act =~ exp)
-          msg  = "Expected #{act.inspect} to match #{exp.inspect}" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if object is nil.
-        #
-        #   assert_nil [1, 2].uniq!
-        #
-        def assert_nil(obj, msg=nil)
-          test = obj.nil?
-          msg  = "Expected #{obj.inspect} to be nil" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if regexp !~ string
-        #
-        #   assert_no_match(/two/, 'one 2 three')
-        #
-        def assert_no_match(exp, act, msg=nil)
-          test = (act !~ exp)
-          msg  = "Expected #{act.inspect} to match #{exp.inspect}" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if expected != actual
-        #
-        #  assert_not_equal 'some string', 5
-        #
-        def assert_not_equal(exp, act, msg=nil)
-          test = (exp != act)
-          msg  = "Expected #{act.inspect} to not be equal to #{exp.inspect}" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if ! object .nil?
-        #
-        #   assert_not_nil '1 two 3'.sub!(/two/, '2')
-        #
-        def assert_not_nil(obj, msg=nil)
-          test = ! obj.nil?
-          msg  = "Expected #{obj.inspect} to not be nil" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if ! actual .equal? expected
-        #
-        #   assert_not_same Object.new, Object.new
-        #
-        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
-          __assert__(test, msg)
-        end
-
-        # Compares the +object1+ with +object2+ using operator.
-        #
-        # Passes if object1.send(operator, object2) is true.
-        #
-        #   assert_operator 5, :>=, 4
-        #
-        def assert_operator(o1, op, o2, msg="")
-          test = o1.__send__(op, o2)
-          msg = "Expected #{o1}.#{op}(#{o2}) to be true" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if the block raises one of the given exceptions.
-        #
-        #   assert_raise RuntimeError, LoadError do
-        #     raise 'Boom!!!'
-        #   end
-        #
-        def assert_raises(*args)
-          if msg = (Module === args.last ? nil : args.pop)
-          begin
-            yield
-            msg = "Expected #{exp} to be raised" unless msg
-            __assert__(false, msg)
-          rescue Exception => e
-            test = (exp === e)
-            msg  = "Expected #{exp} to be raised, but got #{e.class}" unless msg
-            __assert__(test, msg)
-            return e
-          end
-        end
-
-        alias_method :assert_raise, :assert_raises
-
-        # Provides a way to assert that a procedure
-        # <i>does not</i> raise an exception.
-        #
-        #   refute_raises(StandardError){ raise }
-        #
-        #def assert_raises!(exception, &block)
-        #  begin
-        #    block.call(*a)
-        #  rescue exception
-        #    raise Assertion
-        #  end
-        #end
-        #alias_method :refute_raises, :assert_raises!
-
-        # Passes if +object+ respond_to? +method+.
-        #
-        #   assert_respond_to 'bugbear', :slice
-        #
-        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
-          #obj, meth = meth, obj if flip
-          test = obj.respond_to?(meth)
-          __assert__(test, msg)
-        end
-
-        # Passes if +actual+ .equal? +expected+ (i.e. they are the same instance).
-        #
-        #   o = Object.new
-        #   assert_same(o, o)
-        #
-        def assert_same(exp, act, msg=nil)
-          msg  = "Expected #{act.inspect} to be the same as #{exp.inspect}" unless msg
-          test = exp.equal?(act)
-          __assert__(test, msg)
-        end
-
-        # Passes if the method send returns a true value.
-        # The parameter +send_array+ is composed of:
-        #
-        # * A receiver
-        # * A method
-        # * Arguments to the method
-        #
-        # Example:
-        #
-        #   assert_send [[1, 2], :include?, 4]
-        #
-        def assert_send(send_array, msg=nil)
-          r, m, *args = *send_array
-          test = r.__send__(m, *args)
-          msg  = "Expected #{r}.#{m}(*#{args.inspect}) to return true" unless msg
-          __assert__(test, msg)
-        end
-
-        # Passes if the block throws expected_symbol
-        #
-        #   assert_throws :done do
-        #     throw :done
-        #   end
-        #
-        def assert_throws(sym, msg=nil)
-          msg  = "Expected #{sym} to have been thrown" unless msg
-          test = true
-          catch(sym) do
-            begin
-              yield
-            rescue ArgumentError => e     # 1.9 exception
-              default += ", not #{e.message.split(/ /).last}"
-            rescue NameError => e         # 1.8 exception
-              default += ", not #{e.name.inspect}"
-            end
-            test = false
-          end
-          __assert__(test, msg)
-        end
-
-        # Flunk always fails.
-        #
-        #   flunk 'Not done testing yet.'
-        #
-        def flunk(msg=nil)
-          __assert__(false, msg)
-        end
-
-      end #module Assertions
-
-    end #module Legacy
-
-  end #module Grammar
-
-  # This could be in Object, but since they will only be needed in
-  # the context of a, well, Context...
-  #
-  class Context #:nodoc:
-    include Grammar::Legacy::Assertions
-  end
-
-end #module Quarry
-