bacon-expect 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 05eb77e0be35a5f75668dea3a280d7c092c0f3af
+  data.tar.gz: ce71a32ac878eada88cf6a9a663c7112e62e7319
+SHA512:
+  metadata.gz: bb866f01221e58378e2b17d0b861eefc27bab43271c2b40e6d738c981bc91fd831e190cc8ee26dcce4ab9eed4dffc182a86c9a7558c8b0395a411987505238e5
+  data.tar.gz: 94cd5f2aca9adb79aa019303f6eb99a3319a07462951ca896ab6fefc8091964877c9b712d213a2373b7c29fab66faec49b6be075f2e5e7307420b265764cd40a

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec_app/build/*

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bacon-expect-wizard.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ignacio Piantanida
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,12 @@
+# BaconExpect
+
+Bring RSpec 3.0 expect syntax to MacBacon
+
+#Installation
+```
+gem install bacon-expect
+
+# or in Gemfile
+gem 'bacon-expect'
+```
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bacon-expect.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "bacon-expect"
+  spec.version       = "0.1"
+  spec.authors       = ["Ignacio Piantanida"]
+  spec.email         = ["ijpiantanida@gmail.com"]
+  spec.description   = "RSpec's expect syntax in MacBacon"
+  spec.summary       = "Bring RSpec 3.0 expect syntax to MacBacon"
+  spec.homepage      = "https://github.com/ijpiantanida/bacon-expect"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/bacon-expect.rb

@@ -0,0 +1,9 @@
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'bacon-expect/**/*.rb')).reverse.each do |file|
+    app.spec_files << file
+  end
+end

data/lib/bacon-expect/bacon_context.rb

@@ -0,0 +1,4 @@
+class Bacon::Context
+  include BaconExpect::Expectation::BaconContext
+  include BaconExpect::Matcher::BaconContext
+end

data/lib/bacon-expect/expectation.rb

@@ -0,0 +1,39 @@
+module BaconExpect
+  class Expectation
+    module BaconContext
+      def expect(subject = nil, &block)
+        Expectation.new(subject, &block)
+      end
+    end
+
+    def initialize(subject, &subject_block)
+      @subject = subject
+      @subject_block = subject_block
+    end
+
+    def to(matcher)
+      unless matcher.matches?(@subject, &@subject_block)
+        raise matcher.fail!(@subject, &@subject_block)
+      end
+      assert
+    end
+
+    def not_to(matcher)
+      if matcher.matches?(@subject, &@subject_block)
+        raise matcher.fail!(@subject, &@subject_block)
+      end
+      assert
+    end
+    alias_method :to_not, :not_to
+
+    def assert
+      true.should == true
+    end
+  end
+end
+
+module Spector
+
+
+
+end

data/lib/bacon-expect/failed_expectation.rb

@@ -0,0 +1,3 @@
+module BaconExpect
+  class FailedExpectation < RuntimeError; end
+end

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

@@ -0,0 +1,11 @@
+module BaconExpect; module Matcher
+  class BeFalse
+    def matches?(value)
+      !value
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("#{subject} expected to be false but wasn't")
+    end
+  end
+end; end

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

@@ -0,0 +1,19 @@
+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)
+    end
+  end
+end; end

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

@@ -0,0 +1,11 @@
+module BaconExpect; module Matcher
+  class BeNil
+    def matches?(value)
+      value == nil
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("#{subject} expected to be nil but wasn't")
+    end
+  end
+end; end

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

@@ -0,0 +1,11 @@
+module BaconExpect; module Matcher
+  class BeTrue
+    def matches?(value)
+      value == true
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("#{subject} expected to be true but wasn't")
+    end
+  end
+end; end

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

@@ -0,0 +1,29 @@
+module BaconExpect; module Matcher
+  class Change
+    def initialize(change_block)
+      @change_block = change_block
+    end
+
+    def by(amount)
+      @change_amount = amount
+      self
+    end
+
+    def matches?(subject, &expectation_block)
+      old_value = @change_block.call
+      expectation_block.call
+      new_value = @change_block.call
+      if @change_amount
+        new_value - @change_amount == old_value
+      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)
+    end
+  end
+end; end

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

@@ -0,0 +1,15 @@
+module BaconExpect; module Matcher
+  class EndWith
+    def initialize(end_string)
+      @end_string = end_string
+    end
+
+    def matches?(subject)
+      subject[-@end_string.size..-1] == @end_string
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("#{subject} expected to end with #{@start_string}")
+    end
+  end
+end; end

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

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

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

@@ -0,0 +1,19 @@
+module BaconExpect; module Matcher
+  class HaveGeneric
+    def initialize(method_name, *args)
+      @method_name = method_name
+      @args = args
+    end
+
+    def matches?(subject)
+      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)
+    end
+  end
+end; end

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

@@ -0,0 +1,22 @@
+module BaconExpect; module Matcher
+  class HaveItems
+    def initialize(number_of_items)
+      @number_of_items = number_of_items
+    end
+
+    def matches?(value)
+      value.size == @number_of_items
+    end
+
+    def items
+      self
+    end
+
+    alias_method :keys, :items
+    alias_method :values, :items
+
+    def fail!(subject)
+      raise FailedExpectation.new("#{subject} expected to have #{@number_of_items} items")
+    end
+  end
+end; end

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

@@ -0,0 +1,15 @@
+module BaconExpect; module Matcher
+  class Include
+    def initialize(*values)
+      @values = *values
+    end
+
+    def matches?(subject)
+      @values.all?{|v| subject.include?(v)}
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("\"#{subject}\" expected to include #{@values}")
+    end
+  end
+end; end

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

@@ -0,0 +1,15 @@
+module BaconExpect; module Matcher
+  class Match
+    def initialize(regex)
+      @regex = regex
+    end
+
+    def matches?(subject)
+      subject.match(@regex)
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("\"#{subject}\" expected to match #{@regex}")
+    end
+  end
+end; end

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

@@ -0,0 +1,21 @@
+module BaconExpect; module Matcher
+  class MatchArray
+    def initialize(array)
+      @array = array
+    end
+
+    def matches?(subject_array)
+      return false unless subject_array.size == @array.size
+      array_copy = subject_array.dup
+      @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}")
+    end
+  end
+end; end

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

@@ -0,0 +1,78 @@
+module BaconExpect
+  module Matcher
+    module BaconContext
+      def be_nil
+        BeNil.new
+      end
+
+      def be_true
+        BeTrue.new
+      end
+
+      def be_false
+        BeFalse.new
+      end
+
+      def raise_error(exception_class = Exception, message = "")
+        RaiseError.new(exception_class, message)
+      end
+
+      def eql(value)
+        Eql.new(value)
+      end
+      alias_method :be, :eql
+
+      def match(regex)
+        Match.new(regex)
+      end
+
+      def match_array(array)
+        MatchArray.new(array)
+      end
+      alias_method :contain_exactly, :match_array
+
+      def include(*values)
+        Include.new(*values)
+      end
+
+      def have(number)
+        HaveItems.new(number)
+      end
+
+      def satisfy(&block)
+        Satisfy.new(&block)
+      end
+
+      def respond_to(method_name)
+        RespondTo.new(method_name)
+      end
+
+      def start_with(substring)
+        StartWith.new(substring)
+      end
+
+      def end_with(substring)
+        EndWith.new(substring)
+      end
+
+      def change(&change_block)
+        Change.new(change_block)
+      end
+
+      def method_missing(method_name, *args, &block)
+        string_method_name = method_name.to_s
+        match_be = string_method_name.match(/^be_(.*)/)
+        if match_be
+          BeGeneric.new(match_be[1], *args)
+        else
+          match_have = string_method_name.match(/^have_(.*)/)
+          if match_have
+            HaveGeneric.new(match_have[1], *args)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module BaconExpect; module Matcher
+  class RaiseError
+    def initialize(error_class = Exception, message = "")
+      @error_class = error_class.is_a?(Class) ? error_class : Exception
+      @error_message = (error_class.is_a?(String) || error_class.is_a?(Regexp)) ? error_class : message
+    end
+
+    def matches?(value, &block)
+      begin
+        block.call
+        false
+      rescue Exception => e
+        @rescued_exception = e
+        exception_matches(e)
+      end
+    end
+
+    def exception_matches(e)
+      e.is_a?(@error_class) && (
+        (@error_message.is_a?(String) && e.message.include?(@error_message)) ||
+            (@error_message.is_a?(Regexp) && @error_message.match(e.message))
+      )
+    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)
+    end
+  end
+end; end

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

@@ -0,0 +1,28 @@
+module BaconExpect; module Matcher
+  class RespondTo
+    def initialize(method_name)
+      @method_name = method_name
+    end
+
+    def with(number_of_args)
+      @number_of_args = number_of_args
+      self
+    end
+
+    def arguments
+      self
+    end
+    alias_method :argument, :arguments
+
+    def matches?(subject)
+      valid = true
+      valid &&= subject.respond_to?(@method_name)
+      valid &&= subject.method(@method_name).arity == @number_of_args if valid && @number_of_args
+      valid
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("\"#{subject}\" expected to respond_to? #{@method_name}")
+    end
+  end
+end; end

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

@@ -0,0 +1,15 @@
+module BaconExpect; module Matcher
+  class Satisfy
+    def initialize(&condition_block)
+      @condition_block = condition_block
+    end
+
+    def matches?(*values)
+      @condition_block.call(*values)
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("\"#{subject}\" expected to satisfy condition")
+    end
+  end
+end; end

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

@@ -0,0 +1,15 @@
+module BaconExpect; module Matcher
+  class StartWith
+    def initialize(start_string)
+      @start_string = start_string
+    end
+
+    def matches?(subject)
+      subject[0...@start_string.size] == @start_string
+    end
+
+    def fail!(subject)
+      raise FailedExpectation.new("#{subject} expected to start with #{@start_string}")
+    end
+  end
+end; end

data/spec_app/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+# Add your dependencies here:
+gem 'bacon-expect', :path => ".."

data/spec_app/Rakefile

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project/template/ios'
+
+begin
+  require 'bundler'
+  Bundler.require
+rescue LoadError
+end
+
+Motion::Project::App.setup do |app|
+  # Use `rake config' to see complete project settings.
+  app.name = 'sample'
+end

data/spec_app/app/app_delegate.rb

@@ -0,0 +1,5 @@
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    true
+  end
+end

data/spec_app/spec/helpers/bacon_context.rb

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

data/spec_app/spec/matchers/be_false_spec.rb

@@ -0,0 +1,21 @@
+describe "Matcher::BeFalse" do
+  it 'be_false passes when value is false' do
+    expect(false).to be_false
+  end
+
+  it "be_false fails when value is true" do
+    expect_failure{ expect(true).to be_false }
+  end
+
+  it "be_false fails when value is an Object" do
+    expect_failure{ expect(Object.new).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 }
+  end
+
+  it "be_false passes when value is true but asked for not_to" do
+    expect(true).not_to be_false
+  end
+end

data/spec_app/spec/matchers/be_generic_spec.rb

@@ -0,0 +1,27 @@
+describe "Matcher::BeGeneric" do
+  it 'be_empty passes when value is empty' do
+    expect([]).to be_empty
+  end
+
+  it "be_empty fails when value is not empty" do
+    expect_failure{ expect([2, 3]).to be_empty }
+  end
+
+  it "be_kind_of passes when value is of the given type" do
+    expect("i'm a string").to be_kind_of(String)
+  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) }
+  end
+
+  it "be_amazing passes when the value responds to amazing? and returns true" do
+    class TestClass; def amazing?; true; end; end
+    expect(TestClass.new).to be_amazing
+  end
+
+  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 }
+  end
+end

data/spec_app/spec/matchers/be_nil_spec.rb

@@ -0,0 +1,17 @@
+describe "Matcher::BeNil" do
+  it 'be_nil passes when value is nil' do
+    expect(nil).to be_nil
+  end
+
+  it "be_nil fails when value is true" do
+    expect_failure{ expect(true).to be_nil }
+  end
+
+  it "be_nil fails when value is false" do
+    expect_failure{ expect(false).to be_nil }
+  end
+
+  it "be_nil fails when value is an Object" do
+    expect_failure{ expect(Object.new).to be_nil }
+  end
+end

data/spec_app/spec/matchers/be_true_spec.rb

@@ -0,0 +1,21 @@
+describe "Matcher::BeTrue" do
+  it 'be_true passes when value is true' do
+    expect(true).to be_true
+  end
+
+  it "be_true fails when value is false" do
+    expect_failure{ expect(false).to be_true }
+  end
+
+  it "be_true fails when value is an Object" do
+    expect_failure{ expect(Object.new).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 }
+  end
+
+  it "be_true passes when value is false but asked for not_to" do
+    expect(false).to_not be_true
+  end
+end

data/spec_app/spec/matchers/change_spec.rb

@@ -0,0 +1,39 @@
+describe "Matcher::Change" do
+  class TestClass
+    attr_reader :counter
+    def initialize
+      @counter = 0
+    end
+
+    def add
+      @counter += 1
+    end
+
+    def dont_add; end
+  end
+
+  it 'change passes when the expected block changes the result of the argument block' do
+    test_object = TestClass.new
+    expect{ test_object.add }.to change{ test_object.counter }
+  end
+
+  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 } }
+  end
+
+  it "change passes when the expected block doesn't change the result of the argument block but asked not_to" do
+    test_object = TestClass.new
+    expect{ test_object.dont_add }.not_to change{ test_object.counter }
+  end
+
+  it "change when specified 'by' passes when the expected block changes the result of the argument block by the given amount" do
+    test_object = TestClass.new
+    expect{ test_object.add; test_object.add }.to change{ test_object.counter }.by(2)
+  end
+
+  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) }
+  end
+end

data/spec_app/spec/matchers/end_with_spec.rb

@@ -0,0 +1,9 @@
+describe "Matcher::EndWith" do
+  it 'end_with passes when the subject ends with the given string' do
+    expect("super").to end_with("per")
+  end
+
+  it "end_with fails when the subject doesn't end with the given string" do
+    expect_failure{ expect("super").to end_with("key") }
+  end
+end

data/spec_app/spec/matchers/eql_spec.rb

@@ -0,0 +1,19 @@
+describe "Matcher::Eql" do
+  it 'eql passes when value is == to subject' do
+    obj = Object.new
+    expect(obj).to eql(obj)
+  end
+
+  it "eql fails when value is not == subject" do
+    expect_failure{ expect(Object.new).to eql(Object.new) }
+  end
+
+  it "eql fails when value is nil and subject an Object" do
+    expect_failure{ expect(Object.new).to eql(nil) }
+  end
+
+  it "be is an alias of eql" do
+    obj = Object.new
+    expect(obj).to be(obj)
+  end
+end

data/spec_app/spec/matchers/have_generic_spec.rb

@@ -0,0 +1,19 @@
+describe "Matcher::HaveGeneric" do
+  it "have_key passes if the hash includes the given key" do
+    expect({a: 1, b: 2, c: 3}).to have_key(:c)
+  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) }
+  end
+
+  it "have_color passes when the value responds to has_color? and returns true" do
+    class TestClass; def has_color?(color); color == :red; end; end
+    expect(TestClass.new).to have_color(:red)
+  end
+
+  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) }
+  end
+end

data/spec_app/spec/matchers/have_items_spec.rb

@@ -0,0 +1,9 @@
+describe "Matcher::HaveItems" do
+  it 'have passes when subject has the same number of items' do
+    expect([1,2,3]).to have(3).items
+  end
+
+  it 'have fails when subject has the a different number of items' do
+    expect_failure{ expect([1,2,3]).to have(10).items }
+  end
+end

data/spec_app/spec/matchers/include_spec.rb

@@ -0,0 +1,27 @@
+describe "Matcher::Include" do
+  it 'include passes when subject include? responds true' do
+    expect([1,2,3,4]).to include(4)
+  end
+
+  it 'include fails when subject include? responds false' do
+    expect_failure{ expect([1,2,3,4]).to include("asd") }
+  end
+
+  it 'include passes when an object responds true to include?' do
+    class TestClass; def include?(value); true; end; end
+    expect(TestClass.new).to include(3)
+  end
+
+  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) }
+  end
+
+  it "include passes when all values are included in subject" do
+    expect([1,2,3,4]).to include(2,3,4)
+  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) }
+  end
+end

data/spec_app/spec/matchers/match_array_spec.rb

@@ -0,0 +1,17 @@
+describe "Matcher::MatchArray" do
+  it 'match_array passes when subject has the same items as value' do
+    expect([1,2,3,4]).to match_array([4,2,1,3])
+  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]) }
+  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]) }
+  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]) }
+  end
+end

data/spec_app/spec/matchers/match_spec.rb

@@ -0,0 +1,17 @@
+describe "Matcher::Match" do
+  it 'match passes when subject is a string and matches the regex' do
+    expect("asd asd asd").to match(/asd/)
+  end
+
+  it "match fails when subject is a string and doesn't match the regex" do
+    expect_failure{ expect("qwerty qwerty").to match(/asd/) }
+  end
+
+  it "match passes when subject is a regex and matches the given string" do
+    expect(/foo/).to match("food")
+  end
+
+  it "match fails when subject is a regex and doesn't matche the given string" do
+    expect_failure{ expect(/foo/).to match("drink") }
+  end
+end

data/spec_app/spec/matchers/raise_error_spec.rb

@@ -0,0 +1,57 @@
+describe "Matcher::RaiseError" do
+  it 'raise_error without argument passes when the block raises any exception' do
+    expect{ 1/0 }.to raise_error
+  end
+
+  it "raise_error without argument failes when the block doesn't raise any exception" do
+    expect_failure{ 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
+    expect{ 1/0 }.to raise_error(ZeroDivisionError)
+  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) }
+  end
+
+  it "raise_error with a string argument passes when the block raises an exception with a message that includes the string" do
+    expect{ raise "one message" }.to raise_error("one message")
+  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") }
+  end
+
+  it "raise_error with a Regex argument passes when the block raises an exception with a message that matches the Regex" do
+    expect{ raise "one message" }.to raise_error(/message/)
+  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/) }
+  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
+    expect{ raise ArgumentError.new("with a message") }.to raise_error(ArgumentError, "message")
+  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") }
+  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") }
+  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
+    expect{ raise ArgumentError.new("with a message") }.to raise_error(ArgumentError, /message/)
+  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/) }
+  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/) }
+  end
+end

data/spec_app/spec/matchers/respond_to_spec.rb

@@ -0,0 +1,23 @@
+describe "Matcher::RespondTo" do
+  it 'respond_to passes when subject responds to method name' do
+    expect("string").to respond_to(:upcase)
+  end
+
+  it "respond_to fails when subject doesn't respond to method name" do
+    expect_failure{ 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 }
+  end
+
+  it "respond_to when given number of arguments passes when subject responds to method name with exactly the same number of arguments" do
+    class TestCase; def call_me(a,b,c); end; end
+    expect(TestCase.new).to respond_to(:call_me).with(3).arguments
+  end
+
+  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 }
+  end
+end

data/spec_app/spec/matchers/satisfy_spec.rb

@@ -0,0 +1,13 @@
+describe "Matcher::Satisfy" do
+  it 'satisfy passes when the block returns true' do
+    expect(1).to satisfy{|v| v == 1}
+  end
+
+  it 'satisfy fails when the block returns false' do
+    expect_failure{ 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
+end

data/spec_app/spec/matchers/start_with_spec.rb

@@ -0,0 +1,9 @@
+describe "Matcher::StartWith" do
+  it 'start_with passes when the subject starts with the given string' do
+    expect("super").to start_with("sup")
+  end
+
+  it "start_with fails when the subject doesn't start with the given string" do
+    expect_failure{ expect("super").to start_with("key") }
+  end
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: bacon-expect
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Ignacio Piantanida
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RSpec's expect syntax in MacBacon
+email:
+- ijpiantanida@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bacon-expect.gemspec
+- lib/bacon-expect.rb
+- lib/bacon-expect/bacon_context.rb
+- lib/bacon-expect/expectation.rb
+- lib/bacon-expect/failed_expectation.rb
+- lib/bacon-expect/matchers/be_false.rb
+- lib/bacon-expect/matchers/be_generic.rb
+- lib/bacon-expect/matchers/be_nil.rb
+- lib/bacon-expect/matchers/be_true.rb
+- lib/bacon-expect/matchers/change.rb
+- lib/bacon-expect/matchers/end_with.rb
+- lib/bacon-expect/matchers/eql.rb
+- lib/bacon-expect/matchers/have_generic.rb
+- lib/bacon-expect/matchers/have_items.rb
+- lib/bacon-expect/matchers/include.rb
+- lib/bacon-expect/matchers/match.rb
+- lib/bacon-expect/matchers/match_array.rb
+- lib/bacon-expect/matchers/matchers.rb
+- lib/bacon-expect/matchers/raise_error.rb
+- lib/bacon-expect/matchers/respond_to.rb
+- lib/bacon-expect/matchers/satisfy.rb
+- lib/bacon-expect/matchers/start_with.rb
+- spec_app/.repl_history
+- spec_app/Gemfile
+- spec_app/Rakefile
+- spec_app/app/app_delegate.rb
+- spec_app/resources/Default-568h@2x.png
+- spec_app/spec/helpers/bacon_context.rb
+- spec_app/spec/matchers/be_false_spec.rb
+- spec_app/spec/matchers/be_generic_spec.rb
+- spec_app/spec/matchers/be_nil_spec.rb
+- spec_app/spec/matchers/be_true_spec.rb
+- spec_app/spec/matchers/change_spec.rb
+- spec_app/spec/matchers/end_with_spec.rb
+- spec_app/spec/matchers/eql_spec.rb
+- spec_app/spec/matchers/have_generic_spec.rb
+- spec_app/spec/matchers/have_items_spec.rb
+- spec_app/spec/matchers/include_spec.rb
+- spec_app/spec/matchers/match_array_spec.rb
+- spec_app/spec/matchers/match_spec.rb
+- spec_app/spec/matchers/raise_error_spec.rb
+- spec_app/spec/matchers/respond_to_spec.rb
+- spec_app/spec/matchers/satisfy_spec.rb
+- spec_app/spec/matchers/start_with_spec.rb
+homepage: https://github.com/ijpiantanida/bacon-expect
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.5
+signing_key: 
+specification_version: 4
+summary: Bring RSpec 3.0 expect syntax to MacBacon
+test_files: []