bacon-expect 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc5cacf63327158e64370a0bf0b59175b23f9f19
-  data.tar.gz: fd37fa78e8247be2d729564a724826ee41a240bb
+  metadata.gz: 2711107918bcdc5c0561e919905602d4aebd88ef
+  data.tar.gz: 06d592a99720bd98c0752ba34ebb69f704952fba
 SHA512:
-  metadata.gz: 1d33f8128f35925f2b4a511ac1c9ef9bb23ce367ae90a74ce5b9413e3d9f686539436d4be12762b4ca072369cbfdf86534f9f760922aa8a323a713877f67250f
-  data.tar.gz: ed8b806dbcbe20d5d87c16f59db77b93678e9328c157ba93f7c513bdda72a0106396f742f37927f75c13d9072576957080833deb572b6db83c874718e0491883
+  metadata.gz: 6d2c39d6619c345d9655f997158e3b56b5b8741c3323a1915023770976bf843b3e03f29d55d19cb126e48c1e44d802bd8f770b12fd694b77a70c51f763be85ea
+  data.tar.gz: d3291d91ccee3cfe7b9328f6b264b3a83dc12710510e6409443a7b0d219c165f8f250d66a2470de4fc589a6851be5d83a42a164aa80d450e752b1bb83267ccfe

data/.travis.yml

@@ -0,0 +1,8 @@
+language: objective-c
+before_install:
+    - (ruby --version)
+    - (motion --version)
+    - sudo chown -R travis ~/Library/RubyMotion
+    - mkdir -p ~/Library/RubyMotion/build
+    - sudo motion update
+script: "./run-tests.sh"

data/README.md

@@ -1,4 +1,4 @@
-# BaconExpect
+# BaconExpect [![Build Status](https://travis-ci.org/ijpiantanida/bacon-expect.svg?branch=master)](https://travis-ci.org/ijpiantanida/bacon-expect) [![Code Climate](https://codeclimate.com/github/ijpiantanida/bacon-expect.png)](https://codeclimate.com/github/ijpiantanida/bacon-expect)
 
 Bring [RSpec 3.0 expect syntax](https://www.relishapp.com/rspec/rspec-expectations/v/3-0/docs/built-in-matchers) to RubyMotion's MacBacon.
 ```ruby

data/bacon-expect.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "bacon-expect"
-  spec.version       = "1.0.2"
+  spec.version       = "1.0.3"
   spec.authors       = ["Ignacio Piantanida"]
   spec.email         = ["ijpiantanida@gmail.com"]
   spec.description   = "RSpec's expect syntax in MacBacon"

data/lib/bacon-expect/expectation.rb

@@ -12,12 +12,12 @@ module BaconExpect
     end
 
     def to(matcher)
-      fail(matcher) unless matcher_passes(matcher)
+      fail(matcher, false) unless matcher_passes(matcher)
       assert
     end
 
     def not_to(matcher)
-      fail(matcher) if matcher_passes(matcher)
+      fail(matcher, true) if matcher_passes(matcher)
       assert
     end
     alias_method :to_not, :not_to
@@ -26,8 +26,8 @@ module BaconExpect
       matcher.matches?(@subject, &@subject_block)
     end
 
-    def fail(matcher)
-      raise matcher.fail!(@subject, &@subject_block)
+    def fail(matcher, negated)
+      raise matcher.fail!(@subject, negated, &@subject_block)
     end
 
     def assert

data/lib/bacon-expect/fail_message_renderer.rb

@@ -0,0 +1,100 @@
+module BaconExpect
+  class FailMessageRenderer
+    def self.expectation(negated)
+      "#{negated ? " not" : ""} expected"
+    end
+
+    def self.message_for_be_false(negated, subject)
+      "#{subject.inspect}#{expectation(negated)} to be false"
+    end
+
+    def self.message_for_be_true(negated, subject)
+      "#{subject.inspect}#{expectation(negated)} to be true"
+    end
+
+    def self.message_for_be_nil(negated, subject)
+      "#{subject.inspect}#{expectation(negated)} to be nil"
+    end
+
+    def self.message_for_be(negated, subject, method_name, values)
+      message = "#{subject.inspect} ##{method_name}"
+      message += "(#{values.map(&:inspect).join(', ')})" unless values.empty?
+      message += "#{expectation(negated)} to return true"
+      message
+    end
+
+    def self.message_for_be_within(negated, subject, range, center_value)
+      "#{subject.inspect}#{expectation(negated)} to be within #{range} of #{center_value}"
+    end
+
+    def self.message_for_change(negated, change_amount, value_diff)
+      message = "Block#{expectation(negated)} to change value"
+      message += " by #{change_amount}" if change_amount
+      message += " but changed by #{value_diff}" if change_amount && !negated
+      message
+    end
+
+    def self.message_for_end_with(negated, subject, end_string)
+      "#{subject.inspect}#{expectation(negated)} to end with #{end_string.inspect}"
+    end
+
+    def self.message_for_start_with(negated, subject, start_string)
+      "#{subject.inspect}#{expectation(negated)} to start with #{start_string.inspect}"
+    end
+
+    def self.message_for_be_equal(negated, subject, value)
+      "#{subject.inspect}#{expectation(negated)} to be same object as #{value.inspect}"
+    end
+
+    def self.message_for_be_eq(negated, subject, value)
+      "#{subject.inspect}#{expectation(negated)} to be == to #{value.inspect}"
+    end
+    
+    def self.message_for_have_generic(negated, subject, method_name, values)
+      message = "#{subject.inspect} #has_#{method_name}?"
+      message += "(#{values.map(&:inspect).join(', ')})" unless values.empty?
+      message += "#{expectation(negated)} to return true"
+      message
+    end
+
+    def self.message_for_have_items(negated, subject, expected_number_of_items, actual_number_of_items, key_type_name)
+      message = "#{subject.inspect}#{expectation(negated)} to have #{expected_number_of_items} #{key_type_name}"
+      message += " but had #{actual_number_of_items}" unless negated
+      message
+    end
+
+    def self.message_for_include(negated, subject, values)
+      values_message = values.size == 1 ? values.first : values
+      message = "#{subject.inspect}#{expectation(negated)} to include #{values_message.inspect}"
+      message
+    end
+
+    def self.message_for_match_array(negated, subject_array, expected_array)
+      message = "#{subject_array.inspect}#{expectation(negated)} to match array"
+      message += " #{expected_array.inspect}"
+      message
+    end
+
+    def self.message_for_match(negated, subject, match)
+      "#{subject.inspect}#{expectation(negated)} to match #{match.inspect}"
+    end
+
+    def self.message_for_raise_error(negated, show_class, error_class, show_message, error_message, rescued_exception)
+      message = "Block#{expectation(negated)} to raise error"
+      message += " of type #{error_class}" if show_class
+      message += " with message matching #{error_message.inspect}" if show_message
+      message += " but was #{rescued_exception.inspect}" if rescued_exception && !negated
+      message
+    end
+
+    def self.message_for_respond_to(negated, subject, method_name, number_of_args)
+      message = "#{subject.inspect}#{expectation(negated)} to respond to ##{method_name}"
+      message += " with #{number_of_args} arguments" if number_of_args
+      message
+    end
+
+    def self.message_for_satisfy(negated)
+      "Block#{expectation(negated)} to satisfy condition"
+    end
+  end
+end

data/lib/bacon-expect/matchers/be.rb

@@ -1,15 +1,11 @@
 module BaconExpect; module Matcher
-  class Be
+  class Be < SingleMethod
     def initialize(value)
-      @value = value
+      super(:equal?, value)
     end
 
-    def matches?(subject)
-      subject.equal?(@value)
-    end
-
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to be equal? to #{@value}")
+    def fail_message(subject, negated)
+      FailMessageRenderer.message_for_be_equal(negated, subject, @values.first)
     end
   end
 end; end

data/lib/bacon-expect/matchers/be_false.rb

@@ -4,8 +4,9 @@ module BaconExpect; module Matcher
       !value
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to be false but wasn't")
+    def fail!(subject, negated)
+      message = FailMessageRenderer.message_for_be_false(negated, subject)
+      raise FailedExpectation.new(message)
     end
   end
 end; end

data/lib/bacon-expect/matchers/be_generic.rb

@@ -1,19 +1,7 @@
 module BaconExpect; module Matcher
-  class BeGeneric
-    def initialize(method_name, *args)
-      @method_name = method_name
-      @args = args
-    end
-
-    def matches?(value)
-      value.send("#{@method_name}?", *@args)
-    end
-
-    def fail!(subject)
-      message = "#{subject} expected to be #{@method_name}"
-      message += " with #{@args}" unless @args.empty?
-      message += " to return true"
-      raise FailedExpectation.new(message)
+  class BeGeneric < SingleMethod
+    def initialize(method_name, *values)
+      super("#{method_name}?", *values)
     end
   end
 end; end

data/lib/bacon-expect/matchers/be_nil.rb

@@ -4,8 +4,8 @@ module BaconExpect; module Matcher
       value == nil
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to be nil but wasn't")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_be_nil(negated, subject))
     end
   end
 end; end

data/lib/bacon-expect/matchers/be_true.rb

@@ -4,8 +4,8 @@ module BaconExpect; module Matcher
       value == true
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to be true but wasn't")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_be_true(negated, subject))
     end
   end
 end; end

data/lib/bacon-expect/matchers/be_within.rb

@@ -14,8 +14,8 @@ module BaconExpect; module Matcher
       (subject - @center_value).abs <= @range
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to be within #{@range} of #{@center_value}")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_be_within(negated, subject, @range, @center_value))
     end
   end
 end; end

data/lib/bacon-expect/matchers/change.rb

@@ -14,16 +14,15 @@ module BaconExpect; module Matcher
       expectation_block.call
       new_value = @change_block.call
       if @change_amount
-        new_value - @change_amount == old_value
+        @value_diff = new_value - old_value
+        @value_diff == @change_amount
       else
         new_value != old_value
       end
     end
 
-    def fail!(subject)
-      message = "Block expected to change value"
-      message += " by #{@change_amount}" if @change_amount
-      raise FailedExpectation.new(message)
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_change(negated, @change_amount, @value_diff))
     end
   end
 end; end

data/lib/bacon-expect/matchers/end_with.rb

@@ -8,8 +8,8 @@ module BaconExpect; module Matcher
       subject[-@end_string.size..-1] == @end_string
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to end with #{@start_string}")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_end_with(negated, subject, @end_string))
     end
   end
 end; end

data/lib/bacon-expect/matchers/eq.rb

@@ -1,15 +1,11 @@
 module BaconExpect; module Matcher
-  class Eq
+  class Eq < SingleMethod
     def initialize(value)
-      @value = value
+      super(:==, value)
     end
 
-    def matches?(subject)
-      subject == @value
-    end
-
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to be == to #{@value}")
+    def fail_message(subject, negated)
+      FailMessageRenderer.message_for_be_eq(negated, subject, @values.first)
     end
   end
 end; end

data/lib/bacon-expect/matchers/eql.rb

@@ -1,15 +1,7 @@
 module BaconExpect; module Matcher
-  class Eql
+  class Eql < SingleMethod
     def initialize(value)
-      @value = value
-    end
-
-    def matches?(subject)
-      subject.eql?(@value)
-    end
-
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to be eql? to #{@value}")
+      super(:eql?, value)
     end
   end
 end; end

data/lib/bacon-expect/matchers/have_generic.rb

@@ -9,11 +9,8 @@ module BaconExpect; module Matcher
       subject.send("has_#{@method_name}?", *@args)
     end
 
-    def fail!(subject)
-      message = "#{subject} has_#{@method_name}?"
-      message += " with #{@args}" unless @args.empty?
-      message += " to return true"
-      raise FailedExpectation.new(message)
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_have_generic(negated, subject, @method_name, @args))
     end
   end
 end; end

data/lib/bacon-expect/matchers/have_items.rb

@@ -8,15 +8,15 @@ module BaconExpect; module Matcher
       value.size == @number_of_items
     end
 
-    def items
-      self
+    [:items, :item, :keys, :values].each do |key_type_name|
+      define_method(key_type_name) do
+        @key_type_name = key_type_name
+        self
+      end
     end
 
-    alias_method :keys, :items
-    alias_method :values, :items
-
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to have #{@number_of_items} items")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_have_items(negated, subject, @number_of_items, subject.size, @key_type_name))
     end
   end
 end; end

data/lib/bacon-expect/matchers/include.rb

@@ -8,8 +8,8 @@ module BaconExpect; module Matcher
       @values.all?{|v| subject.include?(v)}
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("\"#{subject}\" expected to include #{@values}")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_include(negated, subject, @values))
     end
   end
 end; end

data/lib/bacon-expect/matchers/match.rb

@@ -1,15 +1,11 @@
 module BaconExpect; module Matcher
-  class Match
-    def initialize(regex)
-      @regex = regex
+  class Match < SingleMethod
+    def initialize(value)
+      super(:match, value)
     end
 
-    def matches?(subject)
-      subject.match(@regex)
-    end
-
-    def fail!(subject)
-      raise FailedExpectation.new("\"#{subject}\" expected to match #{@regex}")
+    def fail_message(subject, negated)
+      FailMessageRenderer.message_for_match(negated, subject, @values.first)
     end
   end
 end; end

data/lib/bacon-expect/matchers/match_array.rb

@@ -1,21 +1,21 @@
 module BaconExpect; module Matcher
   class MatchArray
-    def initialize(array)
-      @array = array
+    def initialize(expected_array)
+      @expected_array = expected_array
     end
 
     def matches?(subject_array)
-      return false unless subject_array.size == @array.size
+      return false unless subject_array.size == @expected_array.size
       array_copy = subject_array.dup
-      @array.all? do |item|
+      @expected_array.all? do |item|
         has = array_copy.include?(item)
         array_copy.delete(item) if has
         has
       end
     end
 
-    def fail!(subject_array)
-      raise FailedExpectation.new("\"#{subject_array}\" expected to have same items as #{@array}")
+    def fail!(subject_array, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_match_array(negated, subject_array, @expected_array))
     end
   end
 end; end

data/lib/bacon-expect/matchers/raise_error.rb

@@ -22,10 +22,10 @@ module BaconExpect; module Matcher
       )
     end
 
-    def fail!(subject)
-      message = "Block expected to raise exception of type #{@error_class}"
-      message += " but was #{@rescued_exception.class} #{@rescued_exception}" if @rescued_exception
-      raise FailedExpectation.new(message)
+    def fail!(subject, negated)
+      show_class = @error_class != Exception
+      show_message = !@error_message.is_a?(String) || !@error_message.empty?
+      raise FailedExpectation.new(FailMessageRenderer.message_for_raise_error(negated, show_class, @error_class, show_message, @error_message, @rescued_exception))
     end
   end
 end; end

data/lib/bacon-expect/matchers/respond_to.rb

@@ -21,8 +21,8 @@ module BaconExpect; module Matcher
       valid
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("\"#{subject}\" expected to respond_to? #{@method_name}")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_respond_to(negated, subject, @method_name, @number_of_args))
     end
   end
 end; end

data/lib/bacon-expect/matchers/satisfy.rb

@@ -8,8 +8,8 @@ module BaconExpect; module Matcher
       @condition_block.call(*values)
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("\"#{subject}\" expected to satisfy condition")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_satisfy(negated))
     end
   end
 end; end

data/lib/bacon-expect/matchers/single_method.rb

@@ -0,0 +1,20 @@
+module BaconExpect; module Matcher
+  class SingleMethod
+    def initialize(method_name, *values)
+      @values = values
+      @method_name = method_name
+    end
+
+    def matches?(subject)
+      subject.send(@method_name, *@values)
+    end
+
+    def fail!(subject, negated)
+      raise FailedExpectation.new(self.fail_message(subject, negated))
+    end
+
+    def fail_message(subject, negated = false)
+      FailMessageRenderer.message_for_be(negated, subject, @method_name, @values)
+    end
+  end
+end; end

data/lib/bacon-expect/matchers/start_with.rb

@@ -8,8 +8,8 @@ module BaconExpect; module Matcher
       subject[0...@start_string.size] == @start_string
     end
 
-    def fail!(subject)
-      raise FailedExpectation.new("#{subject} expected to start with #{@start_string}")
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_start_with(negated, subject, @start_string))
     end
   end
 end; end

data/run-tests.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env sh
+cd spec_app
+rake spec

data/spec_app/spec/helpers/bacon_context.rb

@@ -1,5 +1,5 @@
 class Bacon::Context
-  def expect_failure(&block)
-    expect(&block).to raise_error(BaconExpect::FailedExpectation)
+  def expect_failure(fail_message = "", &block)
+    expect(&block).to raise_error(BaconExpect::FailedExpectation, fail_message)
   end
 end

data/spec_app/spec/matchers/be_false_spec.rb

@@ -4,15 +4,16 @@ describe "Matcher::BeFalse" do
   end
 
   it "be_false fails when value is true" do
-    expect_failure{ expect(true).to be_false }
+    expect_failure("true expected to be false"){ expect(true).to be_false }
   end
 
   it "be_false fails when value is an Object" do
-    expect_failure{ expect(Object.new).to be_false }
+    object = Object.new
+    expect_failure("#{object} expected to be false"){ expect(object).to be_false }
   end
 
   it "be_false fails when value is false but asked for not_to" do
-    expect_failure{ expect(false).not_to be_false }
+    expect_failure("false not expected to be false"){ expect(false).not_to be_false }
   end
 
   it "be_false passes when value is true but asked for not_to" do

data/spec_app/spec/matchers/be_generic_spec.rb

@@ -4,7 +4,7 @@ describe "Matcher::BeGeneric" do
   end
 
   it "be_empty fails when value is not empty" do
-    expect_failure{ expect([2, 3]).to be_empty }
+    expect_failure("[2, 3] #empty? expected to return true"){ expect([2, 3]).to be_empty }
   end
 
   it "be_kind_of passes when value is of the given type" do
@@ -12,7 +12,7 @@ describe "Matcher::BeGeneric" do
   end
 
   it "be_kind_of fails when value is not of the given type" do
-    expect_failure{ expect("i'm a string").to be_kind_of(TrueClass) }
+    expect_failure("\"i'm a string\" #kind_of?(TrueClass) expected to return true"){ expect("i'm a string").to be_kind_of(TrueClass) }
   end
 
   it "be_amazing passes when the value responds to amazing? and returns true" do
@@ -22,6 +22,7 @@ describe "Matcher::BeGeneric" do
 
   it "be_amazing fails when the value responds to amazing? and returns false" do
     class TestClass; def amazing?; false; end; end
-    expect_failure{ expect(TestClass.new).to be_amazing }
+    object = TestClass.new
+    expect_failure("#{object.inspect} #amazing? expected to return true"){ expect(object).to be_amazing }
   end
 end

data/spec_app/spec/matchers/be_nil_spec.rb

@@ -4,14 +4,19 @@ describe "Matcher::BeNil" do
   end
 
   it "be_nil fails when value is true" do
-    expect_failure{ expect(true).to be_nil }
+    expect_failure("true expected to be nil"){ expect(true).to be_nil }
   end
 
   it "be_nil fails when value is false" do
-    expect_failure{ expect(false).to be_nil }
+    expect_failure("false expected to be nil"){ expect(false).to be_nil }
   end
 
   it "be_nil fails when value is an Object" do
-    expect_failure{ expect(Object.new).to be_nil }
+    object = Object.new
+    expect_failure("#{object} expected to be nil"){ expect(object).to be_nil }
+  end
+
+  it "be_nil fails when value is nil but asked not to" do
+    expect_failure("nil not expected to be nil"){ expect(nil).not_to be_nil }
   end
 end

data/spec_app/spec/matchers/be_true_spec.rb

@@ -4,15 +4,16 @@ describe "Matcher::BeTrue" do
   end
 
   it "be_true fails when value is false" do
-    expect_failure{ expect(false).to be_true }
+    expect_failure("false expected to be true"){ expect(false).to be_true }
   end
 
   it "be_true fails when value is an Object" do
-    expect_failure{ expect(Object.new).to be_true }
+    object = Object.new
+    expect_failure("#{object} expected to be true"){ expect(object).to be_true }
   end
 
   it "be_true fails when value is true but asked for not_to" do
-    expect_failure{ expect(true).not_to be_true }
+    expect_failure("true not expected to be true"){ expect(true).not_to be_true }
   end
 
   it "be_true passes when value is false but asked for not_to" do

data/spec_app/spec/matchers/be_within_spec.rb

@@ -9,10 +9,10 @@ describe "Matcher::BeWithin" do
   end
 
   it "fails when subject is not within range" do
-    expect_failure{ expect(27.5).not_to be_within(0.5).of(28) }
-    expect_failure{ expect(27.5).not_to be_within(0.5).of(27) }
-    expect_failure{ expect(27.5).to be_within(0.5).of(28.1) }
-    expect_failure{ expect(27.5).to be_within(0.5).of(26.9) }
+    expect_failure("27.5 not expected to be within 0.5 of 28"){ expect(27.5).not_to be_within(0.5).of(28) }
+    expect_failure("27.5 not expected to be within 0.5 of 27"){ expect(27.5).not_to be_within(0.5).of(27) }
+    expect_failure("27.5 expected to be within 0.5 of 28.5"){ expect(27.5).to be_within(0.5).of(28.5) }
+    expect_failure("27.5 expected to be within 0.5 of 26.5"){ expect(27.5).to be_within(0.5).of(26.5) }
   end
 
   it "raises an exception when the matcher is not complete" do

data/spec_app/spec/matchers/change_spec.rb

@@ -19,7 +19,7 @@ describe "Matcher::Change" do
 
   it "change fails when the expected block doesn't change the result of the argument block" do
     test_object = TestClass.new
-    expect_failure{ expect{ test_object.dont_add }.to change{ test_object.counter } }
+    expect_failure("Block expected to change value"){ expect{ test_object.dont_add }.to change{ test_object.counter } }
   end
 
   it "change passes when the expected block doesn't change the result of the argument block but asked not_to" do
@@ -34,6 +34,11 @@ describe "Matcher::Change" do
 
   it "change when specified 'by' fails when the expected block changes the result of the argument block by a different amount" do
     test_object = TestClass.new
-    expect_failure{ expect{ test_object.add; test_object.add }.to change{ test_object.counter }.by(6) }
+    expect_failure("Block expected to change value by 6 but changed by 2"){ expect{ test_object.add; test_object.add }.to change{ test_object.counter }.by(6) }
+  end
+
+  it "change when specified 'by' fails when the expected block changes the result of the argument block by the given amount but asked not to" do
+    test_object = TestClass.new
+    expect_failure("Block not expected to change value by 2"){ expect{ test_object.add; test_object.add }.not_to change{ test_object.counter }.by(2) }
   end
 end

data/spec_app/spec/matchers/end_with_spec.rb

@@ -4,6 +4,10 @@ describe "Matcher::EndWith" do
   end
 
   it "end_with fails when the subject doesn't end with the given string" do
-    expect_failure{ expect("super").to end_with("key") }
+    expect_failure("\"super\" expected to end with \"key\""){ expect("super").to end_with("key") }
+  end
+
+  it "end_with fails when the subject ends with the given string but asked to not" do
+    expect_failure("\"super\" not expected to end with \"per\""){ expect("super").not_to end_with("per") }
   end
 end

data/spec_app/spec/matchers/equality_spec.rb

@@ -4,7 +4,7 @@ describe "Matcher::Equality" do
   end
 
   it "eql fails when value is not eql? subject" do
-    expect_failure{ expect(1).to eql(1.0) }
+    expect_failure("1 #eql?(1.0) expected to return true"){ expect(1).to eql(1.0) }
   end
 
   it "eq passes if value is == to subject" do
@@ -12,7 +12,7 @@ describe "Matcher::Equality" do
   end
 
   it "eq fails if value is == to subject" do
-    expect_failure{ expect(1).to eq(2.0) }
+    expect_failure("1 expected to be == to 2.0"){ expect(1).to eq(2.0) }
   end
 
   it "be passes if value is same object as subject" do
@@ -21,10 +21,17 @@ describe "Matcher::Equality" do
   end
 
   it "be fails if value is not the same object as subject" do
-    expect_failure{ expect("super").to be("super") }
+    expect_failure("\"super\" expected to be same object as \"super\""){ expect("super").to be("super") }
   end
 
   it "equal fails if value is not the same object as subject" do
-    expect_failure{ expect("super").to equal("super") }
+    expect_failure("\"super\" expected to be same object as \"super\""){ expect("super").to equal("super") }
+  end
+
+  it "equal fails if value is the same object as subject but asked not to" do
+    expect_failure("\"super\" not expected to be same object as \"super\"") do
+      string = "super"
+      expect(string).not_to equal(string)
+    end
   end
 end

data/spec_app/spec/matchers/have_generic_spec.rb

@@ -4,7 +4,7 @@ describe "Matcher::HaveGeneric" do
   end
 
   it "have_key fails if the hash doesn't include the given key" do
-    expect_failure{ expect({a: 1, b: 2, c: 3}).to have_key(:h) }
+    expect_failure("{:a=>1, :b=>2, :c=>3} #has_key?(:h) expected to return true"){ expect({a: 1, b: 2, c: 3}).to have_key(:h) }
   end
 
   it "have_color passes when the value responds to has_color? and returns true" do
@@ -14,6 +14,13 @@ describe "Matcher::HaveGeneric" do
 
   it "have_color fails when the value responds to has_color? and returns false" do
     class TestClass; def has_color?(color); color == :red; end; end
-    expect_failure{ expect(TestClass.new).to have_color(:blue) }
+    object = TestClass.new
+    expect_failure("#{object.inspect} #has_color?(:blue) expected to return true"){ expect(object).to have_color(:blue) }
+  end
+
+  it "have_color fails when the value responds to has_color? and returns true but asked not to" do
+    class TestClass; def has_color?(color); color == :red; end; end
+    object = TestClass.new
+    expect_failure("#{object.inspect} #has_color?(:red) not expected to return true"){ expect(object).to_not have_color(:red) }
   end
 end

data/spec_app/spec/matchers/have_items_spec.rb

@@ -4,6 +4,14 @@ describe "Matcher::HaveItems" do
   end
 
   it 'have fails when subject has the a different number of items' do
-    expect_failure{ expect([1,2,3]).to have(10).items }
+    expect_failure("[1, 2, 3] expected to have 10 items but had 3"){ expect([1,2,3]).to have(10).items }
+  end
+
+  it 'have fails when subject has the same number of items but asked not to' do
+    expect_failure("[1, 2, 3] not expected to have 3 items"){ expect([1,2,3]).not_to have(3).items }
+  end
+
+  it 'have failure message changes when sending #keys instead of #items' do
+    expect_failure("[1, 2, 3] not expected to have 3 keys"){ expect([1,2,3]).not_to have(3).keys }
   end
 end

data/spec_app/spec/matchers/include_spec.rb

@@ -4,7 +4,7 @@ describe "Matcher::Include" do
   end
 
   it 'include fails when subject include? responds false' do
-    expect_failure{ expect([1,2,3,4]).to include("asd") }
+    expect_failure("[1, 2, 3, 4] expected to include \"asd\""){ expect([1,2,3,4]).to include("asd") }
   end
 
   it 'include passes when an object responds true to include?' do
@@ -14,7 +14,8 @@ describe "Matcher::Include" do
 
   it 'include passes when an object responds false to include?' do
     class TestClass; def include?(value); false; end; end
-    expect_failure{ expect(TestClass.new).to include(3) }
+    test_object = TestClass.new
+    expect_failure("#{test_object.inspect} expected to include 3"){ expect(test_object).to include(3) }
   end
 
   it "include passes when all values are included in subject" do
@@ -22,6 +23,10 @@ describe "Matcher::Include" do
   end
 
   it "include fails when some values are not included in subject" do
-    expect_failure{ expect([1,2,3,4]).to include(2,3,4, 6) }
+    expect_failure("#{[1,2,3,4]} expected to include #{[2, 3, 4, 6]}"){ expect([1,2,3,4]).to include(2, 3, 4, 6) }
+  end
+
+  it "include fails when all values are included but asked not to" do
+    expect_failure("#{[1,2,3,4,5,6]} not expected to include #{[3, 4, 6]}"){ expect([1,2,3,4,5,6]).not_to include(3, 4, 6) }
   end
 end

data/spec_app/spec/matchers/match_array_spec.rb

@@ -4,14 +4,19 @@ describe "Matcher::MatchArray" do
   end
 
   it "match_array fails when subject has less items than value" do
-    expect_failure{ expect([1,2,3]).to match_array([1,2,3,4]) }
+    expect_failure("#{[1,2,3]} expected to match array #{[1,2,3,4]}"){ expect([1,2,3]).to match_array([1,2,3,4]) }
   end
 
   it "match_array fails when subject has more items than value" do
-    expect_failure{ expect([1,2,3,4]).to match_array([1,2,4,4,3]) }
+    expect_failure("#{[1,2,3, 4]} expected to match array #{[1,2,4,4,3]}"){ expect([1,2,3,4]).to match_array([1,2,4,4,3]) }
   end
 
   it "match_array fails when subject has different items" do
-    expect_failure{ expect([1,2,3,4]).to match_array([Object.new, "a", 2, 3]) }
+    expected_array = [Object.new, "a", 2, 3]
+    expect_failure("#{[1,2,3,4]} expected to match array #{expected_array}"){ expect([1,2,3,4]).to match_array(expected_array) }
+  end
+
+  it 'match_array fails when subject matches the array but asked not to' do
+    expect_failure("#{[1,2,3,4]} not expected to match array"){ expect([1,2,3,4]).to_not match_array([4,2,1,3]) }
   end
 end

data/spec_app/spec/matchers/match_spec.rb

@@ -4,7 +4,7 @@ describe "Matcher::Match" do
   end
 
   it "match fails when subject is a string and doesn't match the regex" do
-    expect_failure{ expect("qwerty qwerty").to match(/asd/) }
+    expect_failure("\"qwerty qwerty\" expected to match /asd/"){ expect("qwerty qwerty").to match(/asd/) }
   end
 
   it "match passes when subject is a regex and matches the given string" do
@@ -12,6 +12,10 @@ describe "Matcher::Match" do
   end
 
   it "match fails when subject is a regex and doesn't matche the given string" do
-    expect_failure{ expect(/foo/).to match("drink") }
+    expect_failure("/foo/ expected to match \"drink\""){ expect(/foo/).to match("drink") }
+  end
+
+  it 'match fails when subject is a string and matches the regex but asked not to' do
+    expect_failure("\"asd asd asd\" not expected to match /asd/"){ expect("asd asd asd").to_not match(/asd/) }
   end
 end

data/spec_app/spec/matchers/raise_error_spec.rb

@@ -4,7 +4,7 @@ describe "Matcher::RaiseError" do
   end
 
   it "raise_error without argument failes when the block doesn't raise any exception" do
-    expect_failure{ expect{ Object.new }.to raise_error }
+    expect_failure("Block expected to raise error"){ expect{ Object.new }.to raise_error }
   end
 
   it "raise_error with a class argument passes when the block raises an exception of the argument class" do
@@ -12,7 +12,7 @@ describe "Matcher::RaiseError" do
   end
 
   it "raise_error with a class argument fails when the block raises an exception of a different class" do
-    expect_failure{ expect{ 1/0 }.to raise_error(ArgumentError) }
+    expect_failure("Block expected to raise error of type ArgumentError"){ expect{ 1/0 }.to raise_error(ArgumentError) }
   end
 
   it "raise_error with a string argument passes when the block raises an exception with a message that includes the string" do
@@ -20,7 +20,7 @@ describe "Matcher::RaiseError" do
   end
 
   it "raise_error with a string argument fails when the block raises an exception with a message that doesn't include the string" do
-    expect_failure{ expect{ raise "one message" }.to raise_error("different") }
+    expect_failure("Block expected to raise error with message matching \"different\" but was #<RuntimeError: one message>"){ expect{ raise "one message" }.to raise_error("different") }
   end
 
   it "raise_error with a Regex argument passes when the block raises an exception with a message that matches the Regex" do
@@ -28,7 +28,7 @@ describe "Matcher::RaiseError" do
   end
 
   it "raise_error with a Regex argument fails when the block raises an exception with a message that doesn't match the Regex" do
-    expect_failure{ expect{ raise "one message" }.to raise_error(/different/) }
+    expect_failure("Block expected to raise error with message matching #{/different/.inspect} but was #<RuntimeError: one message>"){ expect{ raise "one message" }.to raise_error(/different/) }
   end
 
   it "raise_error with a class and a string argument passes if the block raises an exception of the same class and includes the string in its message" do
@@ -36,11 +36,11 @@ describe "Matcher::RaiseError" do
   end
 
   it "raise_error with a class and a string argument fails if the block raises an exception of the same class and but doesn't include the string in its message" do
-    expect_failure{ expect{ raise ArgumentError.new("with a message") }.to raise_error(ArgumentError, "different") }
+    expect_failure("Block expected to raise error of type ArgumentError with message matching #{"different".inspect}"){ expect{ raise ArgumentError.new("with a message") }.to raise_error(ArgumentError, "different") }
   end
 
   it "raise_error with a class and a string argument fails if the block raises an exception of a different class" do
-    expect_failure{ expect{ raise ArgumentError.new("with a message") }.to raise_error(ZeroDivisionError, "message") }
+    expect_failure("Block expected to raise error of type ZeroDivisionError with message matching #{"message".inspect}"){ expect{ raise ArgumentError.new("with a message") }.to raise_error(ZeroDivisionError, "message") }
   end
 
   it "raise_error with a class and a regex argument passes if the block raises an exception of the same class and includes the string in its message" do
@@ -48,14 +48,18 @@ describe "Matcher::RaiseError" do
   end
 
   it "raise_error with a class and a regex argument fails if the block raises an exception of the same class and but doesn't include the string in its message" do
-    expect_failure{ expect{ raise ArgumentError.new("with a message") }.to raise_error(ArgumentError, /different/) }
+    expect_failure("Block expected to raise error of type ArgumentError with message matching #{/different/.inspect}"){ expect{ raise ArgumentError.new("with a message") }.to raise_error(ArgumentError, /different/) }
   end
 
   it "raise_error with a class and a regex argument fails if the block raises an exception of a different class" do
-    expect_failure{ expect{ raise ArgumentError.new("with a message") }.to raise_error(ZeroDivisionError, /message/) }
+    expect_failure("Block expected to raise error of type ZeroDivisionError with message matching #{/message/.inspect} but was "){ expect{ raise ArgumentError.new("with a message") }.to raise_error(ZeroDivisionError, /message/) }
   end
 
   it "raise_exception is an alias of raise_error " do
     expect{ 1/0 }.to raise_exception(ZeroDivisionError)
   end
+
+  it "raise_error with a class argument fails when the block raises an exception of the argument class but asked not to" do
+    expect_failure("Block not expected to raise error of type ZeroDivisionError"){ expect{ 1/0 }.not_to raise_error(ZeroDivisionError) }
+  end
 end

data/spec_app/spec/matchers/respond_to_spec.rb

@@ -4,11 +4,11 @@ describe "Matcher::RespondTo" do
   end
 
   it "respond_to fails when subject doesn't respond to method name" do
-    expect_failure{ expect("string").to respond_to(:floor) }
+    expect_failure("\"string\" expected to respond to #floor"){ expect("string").to respond_to(:floor) }
   end
 
   it "respond_to when given number of arguments fails when subject doesn't respond to method name" do
-    expect_failure{ expect("string").to respond_to(:floor).with(2).arguments }
+    expect_failure("\"string\" expected to respond to #floor with 2 arguments"){ expect("string").to respond_to(:floor).with(2).arguments }
   end
 
   it "respond_to when given number of arguments passes when subject responds to method name with exactly the same number of arguments" do
@@ -18,6 +18,13 @@ describe "Matcher::RespondTo" do
 
   it "respond_to when given number of arguments fails when subject responds to method name with different number of arguments" do
     class TestCase; def call_me(a,b,c); end; end
-    expect_failure{ expect(TestCase.new).to respond_to(:call_me).with(1).argument }
+    test_object = TestCase.new
+    expect_failure("#{test_object.inspect} expected to respond to #call_me with 1 arguments"){ expect(test_object).to respond_to(:call_me).with(1).argument }
+  end
+
+  it "respond_to when given number of arguments fails when subject responds to method name with exactly the same number of arguments but asked not to" do
+    class TestCase; def call_me(a,b,c); end; end
+    test_object = TestCase.new
+    expect_failure("#{test_object.inspect} not expected to respond to #call_me with 3 arguments"){ expect(test_object).not_to respond_to(:call_me).with(3).arguments }
   end
 end

data/spec_app/spec/matchers/satisfy_spec.rb

@@ -4,10 +4,14 @@ describe "Matcher::Satisfy" do
   end
 
   it 'satisfy fails when the block returns false' do
-    expect_failure{ expect(1).to satisfy{|v| v == 3} }
+    expect_failure("Block expected to satisfy condition"){ expect(1).to satisfy{|v| v == 3} }
   end
 
   it 'satisfy fails when the block raises an exception' do
     expect{ expect(1).to satisfy{|v| 1/0 } }.to raise_error(ZeroDivisionError)
   end
+
+  it 'satisfy fails when the block returns true but asked not to' do
+    expect_failure("Block not expected to satisfy condition"){ expect(1).not_to satisfy{|v| v == 1} }
+  end
 end

data/spec_app/spec/matchers/start_with_spec.rb

@@ -4,6 +4,10 @@ describe "Matcher::StartWith" do
   end
 
   it "start_with fails when the subject doesn't start with the given string" do
-    expect_failure{ expect("super").to start_with("key") }
+    expect_failure("\"super\" expected to start with \"key\""){ expect("super").to start_with("key") }
+  end
+
+  it 'start_with fails when the subject starts with the given string but asked not to' do
+    expect_failure("\"super\" not expected to start with \"sup\""){ expect("super").to_not start_with("sup") }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bacon-expect
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 platform: ruby
 authors:
 - Ignacio Piantanida
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-15 00:00:00.000000000 Z
+date: 2014-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -46,6 +46,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -55,6 +56,7 @@ files:
 - lib/bacon-expect/bacon_context.rb
 - lib/bacon-expect/exceptions.rb
 - lib/bacon-expect/expectation.rb
+- lib/bacon-expect/fail_message_renderer.rb
 - lib/bacon-expect/matchers/be.rb
 - lib/bacon-expect/matchers/be_false.rb
 - lib/bacon-expect/matchers/be_generic.rb
@@ -74,7 +76,9 @@ files:
 - lib/bacon-expect/matchers/raise_error.rb
 - lib/bacon-expect/matchers/respond_to.rb
 - lib/bacon-expect/matchers/satisfy.rb
+- lib/bacon-expect/matchers/single_method.rb
 - lib/bacon-expect/matchers/start_with.rb
+- run-tests.sh
 - spec_app/.repl_history
 - spec_app/Gemfile
 - spec_app/Rakefile