assay 0.3.0 → 0.4.0

data/lib/assay/assertions/response_failure.rb

@@ -1,86 +0,0 @@
-require 'assay/assertion'
-
-module Assay
-
-  # Does an object #respond_to? a method call.
-  class ResponseFailure < Assertion
-
-    def self.assertion_name
-      :respond_to
-    end
-
-    def self.assertion_name!
-      :not_respond_to
-    end
-
-    def self.operator_name
-      :respond_to?
-    end
-
-    # Check assertion.
-    def self.pass?(reciever, method)
-      #flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
-      #obj, meth = meth, obj if flip
-      reciever.respond_to?(method)
-    end
-
-    #
-    def to_s
-      return @mesg if @mesg
-      return super unless @arguments.size == 2
-
-      reciever = @arguments[0].inspect
-      method   = @arguments[1].inspect
-
-      if @_negated
-        "Expected #{reciever} (#{reciever.class}) to NOT respond to ##{method}"
-      else
-        "Expected #{reciever} (#{reciever.class}) to respond to ##{method}"
-      end
-    end
-
-  end
-
-
-  module Assertives
-    # Passes if +object+ respond_to? +methods+.
-    #
-    #   assert_respond_to 'bugbear', :slice
-    #
-    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
-
-    # Passes if +object+ does not respond_to? +methods+.
-    #
-    #   assert_not_respond_to 'bugbear', :slice
-    #
-    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
-  end
-
-
-  module Matchers
-    #
-    #
-    #   object.assert is_responsive_to(:method_symbol)
-    #
-    def is_responsive_to(method)
-      ResponseFailure.to_matcher(method)
-    end
-
-    #
-    #
-    #   object.should be_responsive_to(:method_symbol)
-    #
-    def be_responsive_to(method)
-      ResponseFailure.to_matcher(method)
-    end
-  end
-
-end
-

data/lib/assay/assertions/same_failure.rb

@@ -1,82 +0,0 @@
-require 'assay/assertions/compare_failure'
-
-module Assay
-
-  # Comparison assertion for the #eql? method.
-  class SameFailure < CompareFailure
-
-    def self.assertion_name
-      :same
-    end
-
-    def self.assertion_operator
-      :eql?
-    end
-
-    # Check assertion.
-    def self.pass?(exp, act)
-      exp.eql?(act)
-    end
-
-    #
-    def to_s
-      return @mesg if @mesg
-      return super unless @arguments.size == 2
-
-      exp = @arguments[0].inspect
-      act = @arguments[1].inspect
-
-      if @_negated
-        "Expected #{act} to NOT be the same as #{exp}"
-      else
-        "Expected #{act} to be the same as #{exp}"
-      end
-    end
-
-  end
-
-
-  module Assertives
-    # Passes if +expected+ .eq? +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_same 'MY STRING', 'my string'.upcase
-    #
-    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, msg=nil)
-      SameFailure.refute(exp, act, :message=>msg, :backtrace=>caller)
-    end
-
-    alias_method :assert_not_same, :refute_same
-  end
-
-
-  module Matchers
-    #
-    #
-    #   object1.assert is_same_as(object2)
-    #
-    def is_same_as(obj)
-      SameFailure.to_matcher(obj)
-    end
-
-    #
-    #
-    #   object1.should be_same_as(object2)
-    #
-    def be_same_as(obj)
-      SameFailure.to_matcher(obj)
-    end
-  end
-
-end

data/lib/assay/assertions/throw_failure.rb

@@ -1,122 +0,0 @@
-require 'assay/assertions/execution_failure'
-
-module Assay
-
-  #
-  class ThrowFailure < ExecutionFailure
-
-    def self.assertion_name
-      :throws
-    end
-
-    def self.assertion_name!
-      :not_thrown
-    end
-
-    # Passes if the block throws expected_symbol
-    #
-    #   assert_throws :done do
-    #     throw :done
-    #   end
-    #
-    def self.pass?(sym, &block)
-      pass = true
-      catch(sym) do
-        begin
-          block.call
-        rescue ArgumentError => err     # 1.9 exception
-          #msg += ", not #{err.message.split(/ /).last}"
-          pass = false
-        rescue NameError => err         # 1.8 exception
-          #msg += ", not #{err.name.inspect}"
-          pass = false
-        end
-      end
-      pass
-    end
-
-    # Passes if the block throws expected_symbol
-    #
-    #   assert_not_thrown :done do
-    #     throw :chimp
-    #   end
-    #
-    # FIXME: Is this correct?
-    def self.fail?(sym, &block)
-      pass = false
-      catch(sym) do
-        begin
-          block.call
-        rescue ArgumentError => err     # 1.9 exception
-          #msg += ", not #{err.message.split(/ /).last}"
-          pass = true
-        rescue NameError => err         # 1.8 exception
-          #msg += ", not #{err.name.inspect}"
-          pass = true
-        end
-      end
-      pass
-    end
-
-    #
-    def to_s
-      return @mesg if @mesg
-      return super unless @arguments.size == 1
-
-      sym = @arguments[0].inspect
-
-      if @_negated
-        "Expected #{sym} to have been thrown"
-      else
-        "Expected #{sym} NOT to have been thrown"
-      end
-    end
-
-  end
-
-
-  module Assertives
-    # Passes if the block throws expected_symbol
-    #
-    #   assert_throws :done do
-    #     throw :done
-    #   end
-    #
-    def assert_throws(sym, msg=nil, &blk)
-      ThrowFailure.assert(sym, :message=>msg, :backtrace=>caller, &blk)
-    end
-
-    # Passes if the block throws expected_symbol
-    #
-    #   refute_throws :done do
-    #     throw :chimp
-    #   end
-    #
-    def refute_throws(sym, msg=nil, &blk)
-      ThrowFailure.refute(sym, :message=>msg, :backtrace=>caller, &blk)
-    end
-
-    alias_method :assert_not_thrown, :refute_throws
-  end
-
-
-  module Matchers
-    #
-    #
-    #   :symbol.assert is_thrown{ ... }
-    #
-    def is_thrown(&blk)
-      ThrowFailure.to_matcher(&blk)
-    end
-
-    #
-    #
-    #   :symbol.should be_thrown{ ... }
-    #
-    def be_thrown(&blk)
-      ThrowFailure.to_matcher(&blk)
-    end
-  end
-
-end
-

data/lib/assay/assertions/true_failure.rb

@@ -1,79 +0,0 @@
-require 'assay/assertions/compare_failure'
-
-module Assay
-
-  # Comparison assertion for TrueClass.
-  #
-  #   TrueFailure.pass?(true) #=> true
-  #   TrueFailure.fail?(true) #=> false
-  #   TrueFailure.pass?(1)    #=> false
-  #
-  class TrueFailure < CompareFailure
-
-    def self.assertion_name
-      :true
-    end
-
-    def self.assertion_operator
-      :true?
-    end
-
-    # Check assertion.
-    def self.pass?(exp)
-      TrueClass === exp
-    end
-
-    #
-    def to_s
-      return @mesg if @mesg
-      return super unless @arguments.size == 1
-
-      exp = @arguments[0].inspect
-
-      if @_negated
-        "Expected #{exp} to NOT be true"
-      else
-        "Expected #{exp} to be true"
-      end
-    end
-
-  end
-
-
-  module Assertives
-    # Passed if object is +true+.
-    #
-    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, msg=nil)
-      TrueFailure.refute(exp, :message=>msg, :backtrace=>caller)
-    end
-  end
-
-
-  module Matchers
-    # True?
-    #
-    #   value.assert is_true
-    #
-    def is_true
-      TrueFailure.to_matcher
-    end
-
-    # True?
-    #
-    #   value.should be_true
-    #
-    def be_true
-      TrueFailure.to_matcher
-    end
-  end
-
-end
-

data/lib/assay/matcher.rb

@@ -1,48 +0,0 @@
-module Assay
-
-  #
-  class Matcher
-    def initialize(fail_class, *arguments, &block)
-      @fail_class = fail_class
-      @arguments  = arguments
-      @block      = block
-    end
-
-    #
-    def fail_class
-      @fail_class
-    end
-
-    #
-    def matches?(target)
-      @exception = nil
-      @target    = target
-
-      @fail_class.pass?(target, *@arguments, &@block)
-    end
-
-    # Returns Exception class.
-    def exception(message=nil)
-      @exception ||= fail_class.new(message, @target, *@arguments, &@block)     
-      #  :negated   => options[:negated],
-      #  :backtrace => options[:backtrace] || caller,
-    end
-
-    # This is just for RSpec matcher compatability.
-    def fail_message
-      exception.to_s
-    end
-
-    # This is just for RSpec matcher compatability.
-    def negative_fail_message
-      #exception.set_negative(true)
-      exception.to_s
-    end
-
-    #
-    def fail(backtrace=nil)
-      super exception #(backtrace || caller)
-    end
-  end
-
-end

data/qed/01_failure_classes.rdoc

@@ -1,75 +0,0 @@
-= Failure Classes
-
-  require 'assay'
-
-== EqualityFailure
-
-  assert Assay::EqualityFailure.pass?(1,1)
-  refute Assay::EqualityFailure.pass?(1,2)
-
-== TrueFailure
-
-  assert Assay::TrueFailure.pass?(true)
-  refute Assay::TrueFailure.pass?(false)
-
-== FalseFailure
-
-  assert Assay::FalseFailure.pass?(false)
-  refute Assay::FalseFailure.pass?(true)
-
-== NilFailure
-
-  assert Assay::NilFailure.pass?(nil)
-  refute Assay::NilFailure.pass?(true)
-  refute Assay::NilFailure.pass?(false)
-
-== DeltaFailure
-
-  assert Assay::DeltaFailure.pass?(1, 1.5, 2)
-  refute Assay::DeltaFailure.pass?(1, 2.5, 1)
-
-== MatchFailure
-
-  assert Assay::MatchFailure.pass?(/a/, "abc")
-  refute Assay::MatchFailure.pass?(/x/, "abc")
-
-== SameFailure
-
-  assert Assay::SameFailure.pass?(1, 1)
-  refute Assay::SameFailure.pass?(1, 1.0)
-
-== IdentityFailure
-
-  assert Assay::IdentityFailure.pass?(:a, :a)
-  refute Assay::IdentityFailure.pass?("a", "a")
-
-== InstanceFailure
-
-  assert Assay::InstanceFailure.pass?(1, Fixnum)
-  refute Assay::InstanceFailure.pass?(1, String)
-
-== KindFailure
-
-  assert Assay::KindFailure.pass?(1, Integer)
-  refute Assay::KindFailure.pass?(1, String)
-
-== RaiseFailure
-
-  assert Assay::RaiseFailure.pass?(ArgumentError){ raise ArgumentError }
-  refute Assay::RaiseFailure.pass?(ArgumentError){ raise TypeError }
-
-== ResponseFailure
-
-  assert Assay::ResponseFailure.pass?("string", :upcase)
-  refute Assay::ResponseFailure.pass?("string", :not_a_method)
-
-== ExecutionFailure
-
-  assert Assay::ExecutionFailure.pass?(){ nil }
-  refute Assay::ExecutionFailure.pass?(){ raise }
-
-== ThrowFailure
-
-  assert Assay::ThrowFailure.pass?(:foo){ throw :foo }
-  refute Assay::ThrowFailure.pass?(:foo){ throw :bar }
-