ramcrest 0.1.0

data/lib/ramcrest.rb

@@ -0,0 +1,20 @@
+module Ramcrest
+  require 'ramcrest/minitest_assert'
+  require 'ramcrest/rspec'
+  require 'ramcrest/equal_to'
+  require 'ramcrest/comparable'
+  require 'ramcrest/is'
+  require 'ramcrest/aint'
+  require 'ramcrest/anything'
+  require 'ramcrest/has_attribute'
+  require 'ramcrest/has_size'
+  require 'ramcrest/includes'
+  require 'ramcrest/includes_exactly'
+  require 'ramcrest/includes_in_any_order_exactly'
+  require 'ramcrest/such_that'
+  require 'ramcrest/matcher_matcher'
+
+  def self.is_matcher?(possible_matcher)
+    possible_matcher.respond_to?(:matches?) && possible_matcher.respond_to?(:description)
+  end
+end

data/lib/ramcrest/aint.rb

@@ -0,0 +1,30 @@
+require 'ramcrest/matcher'
+
+module Ramcrest
+  module Aint
+  module_function
+    def aint(expected)
+      Matcher.new(Ramcrest::EqualTo.to_matcher(expected))
+    end
+
+    class Matcher
+      include Ramcrest::Matcher
+
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def do_match(expected, actual)
+        super.negate
+      end
+
+      def mismatch_message(actual, match)
+        "<#{actual}>"
+      end
+
+      def description
+        "not #{@expected.description}"
+      end
+    end
+  end
+end

data/lib/ramcrest/anything.rb

@@ -0,0 +1,23 @@
+require 'ramcrest/matcher'
+
+module Ramcrest
+  module Anything
+    module_function
+
+    def anything
+      Matcher.new
+    end
+
+    class Matcher
+      include Ramcrest::Matcher
+
+      def matches?(actual)
+        success
+      end
+
+      def description
+        "anything"
+      end
+    end
+  end
+end

data/lib/ramcrest/assertion.rb

@@ -0,0 +1,10 @@
+module Ramcrest
+  module Assertion
+    def self.assert_match(actual, matcher, &failure_handler)
+      match = matcher.matches?(actual)
+      if not match.matched?
+        failure_handler.call("expected: #{matcher.description}\nbut: #{match.description}")
+      end
+    end
+  end
+end

data/lib/ramcrest/base_enumerable_matcher.rb

@@ -0,0 +1,47 @@
+require 'ramcrest/matcher'
+
+module Ramcrest
+  module Enumerable
+    class BaseEnumerableMatcher
+      include Ramcrest::Matcher
+
+      def initialize(match_type_description, expected, size_matcher)
+        @match_type_description = match_type_description
+        @expected = expected
+        @size_matcher = Ramcrest::HasSize.has_size(size_matcher)
+      end
+
+      def matches?(actual)
+        size_match = @size_matcher.matches?(actual)
+        if !size_match.matched?
+          return mismatch("an enumerable of #{size_match.description}. Enumerable was #{show(actual)}.")
+        end
+
+        unmatched = unmatched_expectations_from(actual)
+        if unmatched.empty?
+          success
+        else
+          mismatch("an enumerable that does not include #{describe(unmatched)}. Enumerable was #{show(actual)}.")
+        end
+      end
+
+      def description
+        "an enumerable #{@match_type_description} #{description_of_expecteds}"
+      end
+
+    private
+
+      def show(array)
+        "[#{array.join(', ')}]"
+      end
+
+      def description_of_expecteds
+        describe(@expected)
+      end
+
+      def describe(matchers)
+        show(matchers.collect(&:description))
+      end
+    end
+  end
+end

data/lib/ramcrest/comparable.rb

@@ -0,0 +1,45 @@
+require 'ramcrest/matcher'
+
+module Ramcrest
+  module Comparable
+  module_function
+
+    def greater_than(expected)
+      Matcher.new("greater than", :>, expected)
+    end
+
+    def greater_or_equal_to(expected)
+      Matcher.new("greater than or equal to", :>=, expected)
+    end
+
+    def less_than(expected)
+      Matcher.new("less than", :<, expected)
+    end
+
+    def less_or_equal_to(expected)
+      Matcher.new("less than or equal to", :<=, expected)
+    end
+
+    class Matcher
+      include Ramcrest::Matcher
+
+      def initialize(name, operator, expected)
+        @name = name
+        @operator = operator
+        @expected = expected
+      end
+
+      def matches?(actual)
+        if actual.send(@operator, @expected)
+          success
+        else
+          mismatch("was <#{actual}>")
+        end
+      end
+
+      def description
+        "#{@name} <#{@expected}>"
+      end
+    end
+  end
+end

data/lib/ramcrest/equal_to.rb

@@ -0,0 +1,36 @@
+require 'ramcrest/matcher'
+
+module Ramcrest
+  module EqualTo
+    def self.to_matcher(possible_matcher)
+      return possible_matcher if Ramcrest.is_matcher?(possible_matcher)
+      Ramcrest::EqualTo.equal_to(possible_matcher)
+    end
+
+  module_function
+
+    def equal_to(expected)
+      Matcher.new(expected)
+    end
+
+    class Matcher
+      include Ramcrest::Matcher
+
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def do_match(expected, actual)
+        MatchResult.new(expected == actual)
+      end
+
+      def mismatch_message(actual, match)
+        "#{actual}"
+      end
+
+      def description
+        "#{@expected}"
+      end
+    end
+  end
+end

data/lib/ramcrest/has_attribute.rb

@@ -0,0 +1,38 @@
+require 'ramcrest/matcher'
+require 'ramcrest/anything'
+
+module Ramcrest
+  module HasAttribute
+    module_function
+
+    def has_attribute(attribute_name, value_matcher = Ramcrest::Anything.anything())
+      Matcher.new(attribute_name, value_matcher)
+    end
+
+    class Matcher
+      include Ramcrest::Matcher
+
+      def initialize(attribute_name, value_matcher)
+        @attribute_name = attribute_name
+        @value_matcher = value_matcher
+      end
+
+      def matches?(actual)
+        if actual.respond_to?(@attribute_name)
+          match = @value_matcher.matches?(actual.send(@attribute_name))
+          if match.matched?
+            return success
+          else
+            return mismatch("object <#{actual}> attribute '#{@attribute_name}' #{match.description}")
+          end
+        else
+          return mismatch("object <#{actual}> was missing attribute '#{@attribute_name}'")
+        end
+      end
+
+      def description
+        "an object with an attribute named '#{@attribute_name}' and value #{@value_matcher.description}"
+      end
+    end
+  end
+end

data/lib/ramcrest/has_size.rb

@@ -0,0 +1,31 @@
+require 'ramcrest/matcher'
+require 'ramcrest/is'
+
+module Ramcrest
+  module HasSize
+  module_function
+    def has_size(expected)
+      Matcher.new(Ramcrest::Is.to_matcher(expected))
+    end
+
+    class Matcher
+      include Ramcrest::Matcher
+
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def do_match(expected, actual)
+        super expected, actual.size
+      end
+
+      def mismatch_message(actual, match)
+        "size #{match.description}"
+      end
+
+      def description
+        "an enumerable of size #{@expected.description}"
+      end
+    end
+  end
+end

data/lib/ramcrest/includes.rb

@@ -0,0 +1,37 @@
+require 'ramcrest/base_enumerable_matcher'
+
+module Ramcrest
+  module Includes
+  module_function
+
+    def includes(*expected)
+      expected_matchers = expected.collect(&Ramcrest::EqualTo.method(:to_matcher))
+      Matcher.new(expected_matchers)
+    end
+
+    class Matcher < Ramcrest::Enumerable::BaseEnumerableMatcher
+      def initialize(expected)
+        super("including",
+              expected,
+              Ramcrest::Comparable.greater_or_equal_to(expected.size))
+      end
+
+    protected
+
+      def unmatched_expectations_from(actual)
+        actual.inject(@expected) do |left_to_expect, value|
+          matched = matcher_that_matches(value, left_to_expect)
+          no_longer_expect(matched, left_to_expect)
+        end
+      end
+
+      def matcher_that_matches(value, expected)
+        expected.find { |expect| expect.matches?(value).matched? }
+      end
+
+      def no_longer_expect(matched, expected)
+        expected.reject { |expect| expect == matched }
+      end
+    end
+  end
+end

data/lib/ramcrest/includes_exactly.rb

@@ -0,0 +1,29 @@
+require 'ramcrest/base_enumerable_matcher'
+
+module Ramcrest
+  module IncludesExactly
+  module_function
+
+    def includes_exactly(*expected)
+      expected_matchers = expected.collect(&Ramcrest::EqualTo.method(:to_matcher))
+      Matcher.new(expected_matchers)
+    end
+
+    class Matcher < Ramcrest::Enumerable::BaseEnumerableMatcher
+      def initialize(expected)
+        super("including exactly",
+              expected,
+              Ramcrest::EqualTo.equal_to(expected.size))
+      end
+
+    protected
+
+      def unmatched_expectations_from(actual)
+        unmatched = actual.zip(@expected).drop_while do |pair|
+          pair[1].matches?(pair[0]).matched?
+        end
+        unmatched.collect { |pair| pair[1] }
+      end
+    end
+  end
+end

data/lib/ramcrest/includes_in_any_order_exactly.rb

@@ -0,0 +1,37 @@
+require 'ramcrest/base_enumerable_matcher'
+
+module Ramcrest
+  module IncludesInAnyOrderExactly
+  module_function
+
+    def includes_in_any_order_exactly(*expected)
+      expected_matchers = expected.collect(&Ramcrest::EqualTo.method(:to_matcher))
+      Matcher.new(expected_matchers)
+    end
+
+    class Matcher < Ramcrest::Enumerable::BaseEnumerableMatcher
+      def initialize(expected)
+        super("including in any order exactly",
+              expected,
+              Ramcrest::EqualTo.equal_to(expected.size))
+      end
+
+    protected
+
+      def unmatched_expectations_from(actual)
+        actual.inject(@expected) do |left_to_expect, value|
+          matched = matcher_that_matches(value, left_to_expect)
+          no_longer_expect(matched, left_to_expect)
+        end
+      end
+
+      def matcher_that_matches(value, expected)
+        expected.find { |expect| expect.matches?(value).matched? }
+      end
+
+      def no_longer_expect(matched, expected)
+        expected.reject { |expect| expect == matched }
+      end
+    end
+  end
+end

data/lib/ramcrest/is.rb

@@ -0,0 +1,43 @@
+require 'ramcrest/matcher'
+
+module Ramcrest
+  module Is
+    def self.to_matcher(possible_matcher)
+      return possible_matcher if Ramcrest.is_matcher?(possible_matcher)
+      Ramcrest::Is.is(possible_matcher)
+    end
+
+  module_function
+
+    def is(expected)
+      Matcher.new(Ramcrest::EqualTo.to_matcher(expected), Ramcrest.is_matcher?(expected))
+    end
+
+    class Matcher
+      include Ramcrest::Matcher
+
+      def initialize(expected, was_originally_matcher)
+        @expected = expected
+        @was_originally_matcher = was_originally_matcher
+      end
+
+      def mismatch_message(actual, match)
+        "was #{show match.description}"
+      end
+
+      def description
+        "is #{show @expected.description}"
+      end
+
+    private
+
+      def show(text)
+        if @was_originally_matcher
+          text
+        else
+          "<#{text}>"
+        end
+      end
+    end
+  end
+end

data/lib/ramcrest/matcher.rb

@@ -0,0 +1,60 @@
+module Ramcrest
+  module Matcher
+
+    def do_match(expected, actual)
+      expected.matches?(actual)
+    end
+
+    def matches?(actual)
+      match = do_match(@expected, actual)
+      if match.matched?
+        success
+      else
+        mismatch(mismatch_message(actual, match))
+      end
+    end
+
+    def success
+      MatchResult::SUCCESS
+    end
+
+    def mismatch(description)
+      MatchResult.new(false, description)
+    end
+
+    class MatchResult
+      attr_reader :description
+
+      def initialize(matched, description = nil)
+        @matched = matched
+        @description = description
+      end
+
+      def negate
+        MatchResult.new(!@matched, @description)
+      end
+
+      def or_else(&mismatch_block)
+        if matched?
+          self
+        else
+          yield self
+        end
+      end
+
+      def and_also(&continue_block)
+        if matched?
+          yield
+        else
+          self
+        end
+      end
+
+      def matched?
+        @matched
+      end
+
+      SUCCESS = MatchResult.new(true)
+    end
+  end
+end

data/lib/ramcrest/matcher_matcher.rb

@@ -0,0 +1,85 @@
+require 'ramcrest/matcher'
+
+module Ramcrest
+  module MatcherMatcher
+  module_function
+    def a_matcher_that_matches(value)
+      MatcherThatMatchesMatcher.new(value)
+    end
+
+    def a_matcher_described_as(description)
+      MatcherDescribedAsMatcher.new(description)
+    end
+
+    def a_matcher_that_mismatches(value, description)
+      MatcherThatMismatchesMatcher.new(value, description)
+    end
+
+    class MatcherThatMatchesMatcher
+      include Ramcrest::Matcher
+
+      def initialize(value)
+        @value = value
+      end
+
+      def matches?(matcher)
+        match = matcher.matches?(@value)
+        if match.matched?
+          success
+        else
+          mismatch("a matcher describing itself as <#{matcher.description}> that mismatched with <#{match.description}>")
+        end
+      end
+
+      def description
+        "a matcher that matches <#{@value}>"
+      end
+    end
+
+    class MatcherDescribedAsMatcher
+      include Ramcrest::Matcher
+
+      def initialize(description)
+        @description = description
+      end
+
+      def matches?(matcher)
+        if matcher.description == @description
+          success
+        else
+          mismatch("a matcher that described itself as \"#{matcher.description}\"")
+        end
+      end
+
+      def description
+        "a matcher described as \"#{@description}\""
+      end
+    end
+
+    class MatcherThatMismatchesMatcher
+      include Ramcrest::Matcher
+
+      def initialize(value, description)
+        @value = value
+        @description = description
+      end
+
+      def matches?(matcher)
+        match = matcher.matches?(@value)
+        if match.matched?
+          mismatch("the matcher matched")
+        else
+          if match.description == @description
+            success
+          else
+            mismatch("the mismatch description was \"#{match.description}\"")
+          end
+        end
+      end
+
+      def description
+        "a matcher that mismatches <#{@value}> explained by \"#{@description}\""
+      end
+    end
+  end
+end

data/lib/ramcrest/minitest_assert.rb

@@ -0,0 +1,11 @@
+require 'ramcrest/assertion'
+
+module MiniTest
+  module Assertions
+    def assert_that(object, matcher)
+      Ramcrest::Assertion.assert_match(object, matcher) do |description|
+        assert false, description
+      end
+    end
+  end
+end

data/lib/ramcrest/rspec.rb

@@ -0,0 +1,14 @@
+require 'ramcrest/assertion'
+
+module RSpec
+  module Expectations
+    class ExpectationTarget
+      def that(matcher)
+        Ramcrest::Assertion.assert_match(@target, matcher) do |description|
+          ::RSpec::Expectations.fail_with(description)
+        end
+      end
+    end
+  end
+end
+

data/lib/ramcrest/such_that.rb

@@ -0,0 +1,23 @@
+require 'ramcrest/matcher'
+
+module Ramcrest
+  module SuchThat
+  module_function
+
+    def such_that(description = "<anonymous such_that>", &matcher_block)
+      Matcher.new(description, matcher_block)
+    end
+
+    class Matcher
+      include Ramcrest::Matcher
+
+      attr_reader :description
+
+      def initialize(description, matcher_block)
+        singleton = class << self; self; end
+        singleton.send(:define_method, :matches?, matcher_block)
+        @description = description
+      end
+    end
+  end
+end

data/test/aint_test.rb

@@ -0,0 +1,24 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::Aint do
+  include Ramcrest::Aint
+  include Ramcrest::Is
+  include Ramcrest::MatcherMatcher
+
+  it "matches objects that are the different" do
+    assert_that aint(is(1)), a_matcher_that_matches(2)
+  end
+
+  it "coerces values into an is() matcher" do
+    assert_that aint(1), a_matcher_that_matches(2)
+  end
+
+  it "matches objects that are the different" do
+    assert_that aint(is(1)), a_matcher_described_as("not is <1>")
+  end
+
+  it "does not match objects that are the same" do
+    assert_that aint(is(1)), a_matcher_that_mismatches(1, "<1>")
+  end
+end

data/test/anything_test.rb

@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::Anything do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::Anything
+
+  it "always matches" do
+    assert_that anything(), a_matcher_that_matches(nil)
+    assert_that anything(), a_matcher_that_matches({})
+  end
+
+  it "describes itself" do
+    assert_that anything(), a_matcher_described_as("anything")
+  end
+end
+

data/test/assert_that_test.rb

@@ -0,0 +1,19 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe "assert_that" do
+  include Ramcrest::Is
+
+  it "passes when the match succeeds" do
+    assert_that nil, is(nil)
+  end
+
+  it "raises when the match fails" do
+    assert_raises(MiniTest::Assertion) { assert_that 1, is(2) }
+  end
+
+  it "combines the mismatch description with the matchers description for the message" do
+    exception = assert_raises(MiniTest::Assertion) { assert_that 1, is(2) }
+    assert_equal "expected: is <2>\nbut: was <1>", exception.message
+  end
+end

data/test/comparable_test.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::Comparable do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::Comparable
+
+  it "matches greater than" do
+    assert_that greater_than(1), a_matcher_that_matches(2)
+    assert_that greater_than(1), a_matcher_that_mismatches(1, "was <1>")
+    assert_that greater_than(1), a_matcher_described_as("greater than <1>")
+  end
+
+  it "matches less than" do
+    assert_that less_than(1), a_matcher_that_matches(0)
+    assert_that less_than(1), a_matcher_that_mismatches(1, "was <1>")
+    assert_that less_than(1), a_matcher_described_as("less than <1>")
+  end
+
+  it "matches greater than or equal" do
+    assert_that greater_or_equal_to(1), a_matcher_that_matches(2)
+    assert_that greater_or_equal_to(1), a_matcher_that_matches(1)
+    assert_that greater_or_equal_to(1), a_matcher_that_mismatches(0, "was <0>")
+    assert_that greater_or_equal_to(1), a_matcher_described_as("greater than or equal to <1>")
+  end
+
+  it "matches less than or equal" do
+    assert_that less_or_equal_to(1), a_matcher_that_matches(0)
+    assert_that less_or_equal_to(1), a_matcher_that_matches(1)
+    assert_that less_or_equal_to(1), a_matcher_that_mismatches(2, "was <2>")
+    assert_that less_or_equal_to(1), a_matcher_described_as("less than or equal to <1>")
+  end
+end

data/test/has_attribute_test.rb

@@ -0,0 +1,59 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::HasAttribute do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::HasAttribute
+  include Ramcrest::Is
+
+  describe "when not matching the value" do
+    it "matches an object with the attribute" do
+      obj = an_object_with_attribute(:foo)
+
+      assert_that has_attribute(:foo), a_matcher_that_matches(obj)
+    end
+
+    it "does not match an object that does not have the attribute" do
+      obj = an_object_with_attribute(:different)
+
+      assert_that has_attribute(:foo),
+        a_matcher_that_mismatches(obj, "object <#{obj}> was missing attribute 'foo'")
+    end
+
+    it "describes itself" do
+      assert_that has_attribute(:foo),
+        a_matcher_described_as("an object with an attribute named 'foo' and value anything")
+    end
+  end
+
+  describe "when matching the value" do
+    it "matches an object with the attribute and the value" do
+      obj = an_object_with_attribute(:foo, 1)
+
+      assert_that has_attribute(:foo, is(1)), a_matcher_that_matches(obj)
+    end
+
+    it "does not match an object that does not have the attribute" do
+      obj = an_object_with_attribute(:different)
+
+      assert_that has_attribute(:foo, is(1)),
+        a_matcher_that_mismatches(obj, "object <#{obj}> was missing attribute 'foo'")
+    end
+
+    it "does not match an object that has a different value" do
+      obj = an_object_with_attribute(:foo, 2)
+
+      assert_that has_attribute(:foo, is(1)),
+        a_matcher_that_mismatches(obj, "object <#{obj}> attribute 'foo' was <2>")
+    end
+
+    it "describes itself" do
+      assert_that has_attribute(:foo, is(1)),
+        a_matcher_described_as("an object with an attribute named 'foo' and value is <1>")
+    end
+  end
+
+  def an_object_with_attribute(name, value = nil)
+    Struct.new(name).new(value)
+  end
+end

data/test/has_size_test.rb

@@ -0,0 +1,26 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::HasSize do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::Is
+  include Ramcrest::HasSize
+
+  it "matches objects with a matching size" do
+    assert_that has_size(1), a_matcher_that_matches([1])
+    assert_that has_size(1), a_matcher_that_matches({ :a => 1 })
+  end
+
+  it "matches using other matchers" do
+    assert_that has_size(Ramcrest::SuchThat.such_that { |size| success }),
+      a_matcher_that_matches([2, 3])
+  end
+
+  it "does not match objects that are different size" do
+    assert_that has_size(1), a_matcher_that_mismatches([1, 2], "size was <2>")
+  end
+
+  it "describes itself" do
+    assert_that has_size(1), a_matcher_described_as("an enumerable of size is <1>")
+  end
+end

data/test/includes_exactly_test.rb

@@ -0,0 +1,41 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::IncludesExactly do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::Is
+  include Ramcrest::IncludesExactly
+
+  it "matches enumerables that have all of the elements in order" do
+    assert_that includes_exactly(is(1), is(2)), a_matcher_that_matches([1, 2])
+  end
+
+  it "coerces values into equality matches" do
+    assert_that includes_exactly(1, 2), a_matcher_that_matches([1, 2])
+  end
+
+  it "does not match when the elements are out of order" do
+    assert_that includes_exactly(is(1), is(2)),
+      a_matcher_that_mismatches([2, 1], "an enumerable that does not include [is <1>, is <2>]. Enumerable was [2, 1].")
+  end
+
+  it "does not match when there is an unexpected element" do
+    assert_that includes_exactly(is(1), is(2)),
+      a_matcher_that_mismatches([1, 3], "an enumerable that does not include [is <2>]. Enumerable was [1, 3].")
+  end
+
+  it "does not match when there are fewer elements than expected" do
+    assert_that includes_exactly(is(1), is(2)),
+      a_matcher_that_mismatches([1], "an enumerable of size 1. Enumerable was [1].")
+  end
+
+  it "does not match when there are more elements than expected" do
+    assert_that includes_exactly(is(1), is(2)),
+      a_matcher_that_mismatches([1, 2, 3], "an enumerable of size 3. Enumerable was [1, 2, 3].")
+  end
+
+  it "describes itself" do
+    assert_that includes_exactly(is(1), is(2)),
+      a_matcher_described_as("an enumerable including exactly [is <1>, is <2>]")
+  end
+end

data/test/includes_in_any_order_exactly_test.rb

@@ -0,0 +1,36 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::IncludesInAnyOrderExactly do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::Is
+  include Ramcrest::IncludesInAnyOrderExactly
+
+  it "matches enumerables that have all of the elements" do
+    assert_that includes_in_any_order_exactly(is(1), is(2)), a_matcher_that_matches([2, 1])
+  end
+
+  it "coerces values into equality matches" do
+    assert_that includes_in_any_order_exactly(1, 2), a_matcher_that_matches([2, 1])
+  end
+
+  it "does not match when there is an unexpected element" do
+    assert_that includes_in_any_order_exactly(is(1), is(2)),
+      a_matcher_that_mismatches([1, 3], "an enumerable that does not include [is <2>]. Enumerable was [1, 3].")
+  end
+
+  it "does not match when there are fewer elements than expected" do
+    assert_that includes_in_any_order_exactly(is(1), is(2)),
+      a_matcher_that_mismatches([1], "an enumerable of size 1. Enumerable was [1].")
+  end
+
+  it "does not match when there are more elements than expected" do
+    assert_that includes_in_any_order_exactly(is(1), is(2)),
+      a_matcher_that_mismatches([1, 2, 3], "an enumerable of size 3. Enumerable was [1, 2, 3].")
+  end
+
+  it "describes itself" do
+    assert_that includes_in_any_order_exactly(is(1), is(2)),
+      a_matcher_described_as("an enumerable including in any order exactly [is <1>, is <2>]")
+  end
+end

data/test/includes_test.rb

@@ -0,0 +1,31 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::Includes do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::Is
+  include Ramcrest::Includes
+
+  it "matches enumerables that have all of the elements" do
+    assert_that includes(is(1), is(2)), a_matcher_that_matches([1, 3, 2])
+  end
+
+  it "coerces values into equality matches" do
+    assert_that includes(1, 2), a_matcher_that_matches([1, 3, 2])
+  end
+
+  it "does not match when there is an unexpected element" do
+    assert_that includes(is(1), is(2)),
+      a_matcher_that_mismatches([1, 3], "an enumerable that does not include [is <2>]. Enumerable was [1, 3].")
+  end
+
+  it "does not match when there are fewer elements than expected" do
+    assert_that includes(is(1), is(2)),
+      a_matcher_that_mismatches([1], "an enumerable of size was <1>. Enumerable was [1].")
+  end
+
+  it "describes itself" do
+    assert_that includes(is(1), is(2)),
+      a_matcher_described_as("an enumerable including [is <1>, is <2>]")
+  end
+end

data/test/is_test.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::Is do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::Is
+
+  it "matches objects that are the same" do
+    assert_that is(1), a_matcher_that_matches(1)
+  end
+
+  it "matches using other matchers" do
+    assert_that is(is(1)), a_matcher_that_matches(1)
+  end
+
+  it "does not match objects that are different" do
+    assert_that is(1), a_matcher_that_mismatches(2, "was <2>")
+  end
+
+  it "describes itself" do
+    assert_that is(1), a_matcher_described_as("is <1>")
+  end
+
+  describe "when composed with another matcher" do
+    it "describes itself without extra marks" do
+      assert_that is(is(1)), a_matcher_described_as("is is <1>")
+    end
+
+    it "does not describe a mismatch with extra marks" do
+      assert_that is(is(1)), a_matcher_that_mismatches(2, "was was <2>")
+    end
+  end
+end

data/test/matcher_matcher_test.rb

@@ -0,0 +1,78 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::MatcherMatcher do
+  include Ramcrest::MatcherMatcher
+
+  INCORRECT_VALUE = 2
+  INCORRECT_DESCRIPTION = "wrong description"
+  CORRECT_VALUE = 1
+
+  MATCHER = Ramcrest::Is.is(CORRECT_VALUE)
+  MATCHER_DESCRIPTION = MATCHER.description
+  MISMATCH_DESCRIPTION = MATCHER.matches?(INCORRECT_VALUE).description
+
+  describe "#a_matcher_that_matches" do
+    it "matches when the tested matcher matches" do
+      assert_that MATCHER, a_matcher_that_matches(CORRECT_VALUE)
+    end
+
+    it "mismatches when the tested matcher does not match" do
+      match = a_matcher_that_matches(INCORRECT_VALUE).matches?(MATCHER)
+
+      assert !match.matched?
+    end
+
+    it "describes itself" do
+      assert_equal "a matcher that matches <#{CORRECT_VALUE}>", a_matcher_that_matches(CORRECT_VALUE).description
+    end
+
+    it "describes the mismatch when the matcher does not match" do
+      assert_equal "a matcher describing itself as <#{MATCHER_DESCRIPTION}> that mismatched with <#{MISMATCH_DESCRIPTION}>", a_matcher_that_matches(INCORRECT_VALUE).matches?(MATCHER).description
+    end
+  end
+
+  describe "#a_matcher_described_as" do
+    it "matches when the matcher's description matches" do
+      assert_that MATCHER, a_matcher_described_as(MATCHER_DESCRIPTION)
+    end
+
+    it "mismatches when the matcher's description does not match" do
+      match = a_matcher_described_as(INCORRECT_DESCRIPTION).matches?(MATCHER)
+
+      assert !match.matched?
+    end
+
+    it "describes itself" do
+      assert_equal "a matcher described as \"#{MATCHER_DESCRIPTION}\"", a_matcher_described_as(MATCHER_DESCRIPTION).description
+    end
+
+    it "describes the mismatch when the matcher does not match" do
+      assert_equal "a matcher that described itself as \"#{MATCHER_DESCRIPTION}\"", a_matcher_described_as(INCORRECT_DESCRIPTION).matches?(MATCHER).description
+    end
+  end
+
+  describe "#a_matcher_that_mismatches" do
+    it "matches when the matcher mismatches with the wanted description" do
+      assert_that MATCHER, a_matcher_that_mismatches(INCORRECT_VALUE, MISMATCH_DESCRIPTION)
+    end
+
+    it "mismatches when the matcher matches" do
+      match = a_matcher_that_mismatches(CORRECT_VALUE, MISMATCH_DESCRIPTION).matches?(MATCHER)
+
+      assert !match.matched?
+      assert_equal "the matcher matched", match.description
+    end
+
+    it "mismatches when the matcher mismatched but provided the wrong mismatch description" do
+      match = a_matcher_that_mismatches(INCORRECT_VALUE, "wrong mismatch desc").matches?(MATCHER)
+
+      assert !match.matched?
+      assert_equal "the mismatch description was \"#{MISMATCH_DESCRIPTION}\"", match.description
+    end
+
+    it "describes itself" do
+      assert_equal "a matcher that mismatches <#{INCORRECT_VALUE}> explained by \"#{MISMATCH_DESCRIPTION}\"", a_matcher_that_mismatches(INCORRECT_VALUE, MISMATCH_DESCRIPTION).description
+    end
+  end
+end

data/test/matcher_test.rb

@@ -0,0 +1,65 @@
+require 'minitest/autorun'
+require 'ramcrest/matcher'
+
+describe Ramcrest::Matcher do
+  include Ramcrest::Matcher
+
+  it "a successful match is equivalent to true" do
+    assert_equal true, success.matched?
+  end
+
+  it "an unsuccessful match is equivalent to false" do
+    assert_equal false, mismatch("description").matched?
+  end
+
+  it "an unsuccessful match has a description" do
+    assert_equal "description", mismatch("description").description
+  end
+
+  it "a successful match has no description" do
+    assert_nil success.description
+  end
+
+  describe "#negate" do
+    it "inverts the result" do
+      assert_equal false, success.negate.matched?
+      assert_equal true, mismatch("description").negate.matched?
+    end
+
+    it "does not change the original match" do
+      original = mismatch("description")
+
+      original.negate
+
+      assert_equal false, original.matched?
+    end
+  end
+
+  describe "when results are converted with #or_else" do
+    it "returns success from #or_else when it matches" do
+      assert_equal true, success.or_else { raise "not reached" }.matched?
+    end
+
+    it "calls the else block when it is a mismatch" do
+      assert_raises(RuntimeError, "mismatch discription from block") do
+        mismatch("mismatch description").or_else do |mismatch|
+          raise RuntimeError, "#{mismatch.description} from block"
+        end
+      end
+    end
+  end
+  
+  describe "when chained with another match result via #and_also" do
+    it "propogates successful matches" do
+      assert_equal true, success.and_also { success }.matched?
+    end
+
+    it "short-circuits on a mismatch" do
+      assert_equal false, mismatch("stop").and_also { raise "not reached" }.matched?
+    end
+
+    it "returns the result of the also" do
+      assert_equal "the second step", success.and_also { mismatch("the second step") }.description
+    end
+  end
+end

data/test/such_that_test.rb

@@ -0,0 +1,32 @@
+require 'minitest/autorun'
+require 'ramcrest'
+
+describe Ramcrest::SuchThat do
+  include Ramcrest::MatcherMatcher
+  include Ramcrest::SuchThat
+
+  it "matches when the such that block returns success" do
+    assert_that such_that { |value| success }, a_matcher_that_matches(nil)
+  end
+
+  it "mismatches when the such that block returns mismatch" do
+    assert_that such_that { |value| mismatch("wrong") }, a_matcher_that_mismatches(nil, "wrong")
+  end
+
+  it "describes itself by default as an anonymous matcher" do
+    assert_that such_that { |value| }, a_matcher_described_as("<anonymous such_that>")
+  end
+
+  it "allows for composing with other such_that matchers" do
+    base = such_that { |value| if value > 2 then success else mismatch("no") end }
+    delegating = such_that { |value| base.matches?(value) }
+
+    assert_that delegating, a_matcher_that_matches(3)
+    assert_that delegating, a_matcher_that_mismatches(2, "no")
+  end
+
+  it "can have a description provided" do
+    assert_that such_that("something is true") { |value| },
+      a_matcher_described_as("something is true")
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: ramcrest
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Andrew Parker
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-29 00:00:00.000000000 Z
+dependencies: []
+description: ! 'Ramcrest is an implementation of Hamcrest for Ruby. It integrates
+  with
+
+  MinitTest and RSpec. Writing new matchers is easy! Why not give it a try?
+
+'
+email:
+- aparker42@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ramcrest/aint.rb
+- lib/ramcrest/anything.rb
+- lib/ramcrest/assertion.rb
+- lib/ramcrest/base_enumerable_matcher.rb
+- lib/ramcrest/comparable.rb
+- lib/ramcrest/equal_to.rb
+- lib/ramcrest/has_attribute.rb
+- lib/ramcrest/has_size.rb
+- lib/ramcrest/includes.rb
+- lib/ramcrest/includes_exactly.rb
+- lib/ramcrest/includes_in_any_order_exactly.rb
+- lib/ramcrest/is.rb
+- lib/ramcrest/matcher.rb
+- lib/ramcrest/matcher_matcher.rb
+- lib/ramcrest/minitest_assert.rb
+- lib/ramcrest/rspec.rb
+- lib/ramcrest/such_that.rb
+- lib/ramcrest.rb
+- test/aint_test.rb
+- test/anything_test.rb
+- test/assert_that_test.rb
+- test/comparable_test.rb
+- test/has_attribute_test.rb
+- test/has_size_test.rb
+- test/includes_exactly_test.rb
+- test/includes_in_any_order_exactly_test.rb
+- test/includes_test.rb
+- test/is_test.rb
+- test/matcher_matcher_test.rb
+- test/matcher_test.rb
+- test/such_that_test.rb
+homepage: https://github.com/hamcrest/ramcrest
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Powerful, composable matchers for Ruby
+test_files:
+- test/aint_test.rb
+- test/anything_test.rb
+- test/assert_that_test.rb
+- test/comparable_test.rb
+- test/has_attribute_test.rb
+- test/has_size_test.rb
+- test/includes_exactly_test.rb
+- test/includes_in_any_order_exactly_test.rb
+- test/includes_test.rb
+- test/is_test.rb
+- test/matcher_matcher_test.rb
+- test/matcher_test.rb
+- test/such_that_test.rb