assay 0.2.0

data/lib/assay/assertions/true_failure.rb

@@ -0,0 +1,80 @@
+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 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, opts={})
+      opts[:backtrace] ||= caller
+      TrueFailure.assert(exp, opts)
+    end
+
+    # Passed if object is not +true+.
+    #
+    #   assert_not_true(false)
+    #
+    def assert_not_true(exp, opts={})
+      opts[:backtrace] ||= caller
+      TrueFailure.refute(exp, opts)
+    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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,75 @@
+= 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 }
+

data/qed/02_assertives.rdoc

@@ -0,0 +1,118 @@
+= Assertion Methods
+
+  require 'assay'
+
+  include Assay::Assertives
+
+== EqualityFailure
+
+  assert_equal(1,1)
+
+  expect Assay::EqualityFailure do
+    assert_equal(1,2)
+  end
+
+== TrueFailure
+
+  assert_true(true)
+
+  expect Assay::TrueFailure do
+    assert_true(false)
+  end
+
+== FalseFailure
+
+  assert_false(false)
+
+  expect Assay::FalseFailure do
+    assert_false(true)
+  end
+
+== NilFailure
+
+  assert_nil(nil)
+
+  expect Assay::NilFailure do
+    assert_nil(true)
+  end
+
+== DeltaFailure
+
+  assert_in_delta(1, 1.5, 2)
+
+  expect Assay::DeltaFailure do
+    assert_in_delta(1, 2.5, 1)
+  end
+
+== MatchFailure
+
+  assert_match(/a/, "abc")
+
+  expect Assay::MatchFailure do
+    assert_match(/x/, "abc")
+  end
+
+== SameFailure
+
+  assert_same(1, 1)
+
+  expect Assay::SameFailure do
+    assert_same(1, 1.0)
+  end
+
+== IdentityFailure
+
+  assert_identical(:a, :a)
+
+  expect Assay::IdentityFailure do
+    assert_identical("a", "a")
+  end
+
+== InstanceFailure
+
+  assert_instance_of(1, Fixnum)
+
+  expect Assay::InstanceFailure do
+    assert_instance_of(1, String)
+  end
+
+== KindFailure
+
+  assert_kind_of(1, Integer)
+
+  expect Assay::KindFailure do
+    assert_kind_of(1, String)
+  end
+
+== RaiseFailure
+
+  assert_raises(ArgumentError){ raise ArgumentError }
+
+  expect Assay::RaiseFailure do
+    assert_raises(ArgumentError){ raise TypeError }
+  end
+
+== ResponseFailure
+
+  assert_responds_to("string", :upcase)
+
+  expect Assay::ResponseFailure do
+    assert_responds_to("string", :not_a_method)
+  end
+
+== Executionfailure
+
+  assert_executes{ :ok }
+
+  expect Assay::ExecutionFailure do
+    assert_executes{ raise }
+  end
+
+== ThrowFailure
+
+  assert_throws(:foo){ throw :foo }
+
+  expect Assay::ThrowFailure do
+    assert_throws(:foo){ throw :bar }
+  end
+

data/qed/03_matchers.rdoc

@@ -0,0 +1,118 @@
+= Matchers
+
+  require 'assay'
+
+  include Assay::Matchers
+
+== EqualityFailure
+
+  1.assert is_equal_to(1)
+
+  expect Assay::EqualityFailure do
+    1.assert is_equal_to(2)
+  end
+
+== TrueFailure
+
+  true.assert is_true
+
+  expect Assay::TrueFailure do
+    false.assert is_true
+  end
+
+== FalseFailure
+
+  false.assert is_false
+
+  expect Assay::FalseFailure do
+    true.assert is_false
+  end
+
+== NilFailure
+
+  nil.assert is_nil
+
+  expect Assay::NilFailure do
+    true.assert is_nil
+  end
+
+== DeltaFailure
+
+  1.assert is_within(1.5, 2)
+
+  expect Assay::DeltaFailure do
+    1.assert is_within(0.5, 2)
+  end
+
+== MatchFailure
+
+  "abc".assert is_match_for(/a/)
+
+  expect Assay::MatchFailure do
+    "abc".assert is_match_for(/x/)
+  end
+
+== SameFailure
+
+  1.assert is_same_as(1)
+
+  expect Assay::SameFailure do
+    1.assert is_same_as(1.0)
+  end
+
+== IdentityFailure
+
+  :a.assert is_identical_to(:a)
+
+  expect Assay::IdentityFailure do
+    "a".assert is_identical_to("a")
+  end
+
+== InstanceFailure
+
+  1.assert is_instance_of(Fixnum)
+
+  expect Assay::InstanceFailure do
+    1.assert is_instance_of(String)
+  end
+
+== KindFailure
+
+  1.assert is_kind_of(Integer)
+
+  expect Assay::KindFailure do
+    1.assert is_kind_of(String)
+  end
+
+== RaiseFailure
+
+  ArgumentError.assert is_raised{ raise ArgumentError }
+
+  expect Assay::RaiseFailure do
+    ArgumentError.assert is_raised{ raise TypeError }
+  end
+
+== ResponseFailure
+
+  "string".assert is_responsive_to(:upcase)
+
+  expect Assay::ResponseFailure do
+    "string".assert is_responsive_to(:not_a_method)
+  end
+
+== ExecutionFailure
+
+  assert is_executed{ :foo }
+
+  expect Assay::ExecutionFailure do
+    assert is_executed{ raise }
+  end
+
+== ThrowFailure
+
+  :foo.assert is_thrown{ throw :foo }
+
+  expect Assay::ThrowFailure do
+    :foo.assert is_thrown{ throw :bar }
+  end
+

data/qed/04_lookup.rdoc

@@ -0,0 +1,10 @@
+= Lookup
+
+Assay can be used to look up failure classes by associated opearators.
+
+  require 'assay'
+
+  Assay.lookup(:==)     #=> ::Assay::EqualityFailure
+
+  Assay.lookup(:empty?) #=> ::Assay::EmptyFailure
+