motion-expect 2.0.0

data/lib/motion-expect/matcher/include.rb

@@ -0,0 +1,15 @@
+module MotionExpect; module Matcher
+  class Include
+    def initialize(*values)
+      @values = *values
+    end
+
+    def matches?(subject)
+      @values.all?{|v| subject.include?(v)}
+    end
+
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_include(negated, subject, @values))
+    end
+  end
+end; end

data/lib/motion-expect/matcher/match.rb

@@ -0,0 +1,11 @@
+module MotionExpect; module Matcher
+  class Match < SingleMethod
+    def initialize(value)
+      super(:match, value)
+    end
+
+    def fail_message(subject, negated)
+      FailMessageRenderer.message_for_match(negated, subject, @values.first)
+    end
+  end
+end; end

data/lib/motion-expect/matcher/match_array.rb

@@ -0,0 +1,21 @@
+module MotionExpect; module Matcher
+  class MatchArray
+    def initialize(expected_array)
+      @expected_array = expected_array
+    end
+
+    def matches?(subject_array)
+      return false unless subject_array.size == @expected_array.size
+      array_copy = subject_array.dup
+      @expected_array.all? do |item|
+        has = array_copy.include?(item)
+        array_copy.delete(item) if has
+        has
+      end
+    end
+
+    def fail!(subject_array, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_match_array(negated, subject_array, @expected_array))
+    end
+  end
+end; end

data/lib/motion-expect/matcher/matchers.rb

@@ -0,0 +1,91 @@
+module MotionExpect
+  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
+      alias_method :raise_exception, :raise_error
+
+      def eql(value)
+        Eql.new(value)
+      end
+
+      def be(value)
+        Be.new(value)
+      end
+      alias_method :equal, :be
+
+      def eq(value)
+        Eq.new(value)
+      end
+
+      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 be_within(range)
+        BeWithin.new(range)
+      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/motion-expect/matcher/raise_error.rb

@@ -0,0 +1,31 @@
+module MotionExpect; 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, 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/motion-expect/matcher/respond_to.rb

@@ -0,0 +1,28 @@
+module MotionExpect; 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, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_respond_to(negated, subject, @method_name, @number_of_args))
+    end
+  end
+end; end

data/lib/motion-expect/matcher/satisfy.rb

@@ -0,0 +1,15 @@
+module MotionExpect; module Matcher
+  class Satisfy
+    def initialize(&condition_block)
+      @condition_block = condition_block
+    end
+
+    def matches?(*values)
+      @condition_block.call(*values)
+    end
+
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_satisfy(negated))
+    end
+  end
+end; end

data/lib/motion-expect/matcher/single_method.rb

@@ -0,0 +1,22 @@
+module MotionExpect
+  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/motion-expect/matcher/start_with.rb

@@ -0,0 +1,15 @@
+module MotionExpect; 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, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_start_with(negated, subject, @start_string))
+    end
+  end
+end; end

data/motion-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          = "motion-expect"
+  spec.version       = "2.0.0"
+  spec.authors       = ["Ignacio Piantanida", "Lori Olson"]
+  spec.email         = ["lori@wndx.com"]
+  spec.description   = "RSpec's expect syntax in MacBacon"
+  spec.summary       = "Bring RSpec 3.0 expect syntax to MacBacon"
+  spec.homepage      = "https://github.com/rubymotion-community/motion-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/run-tests.sh

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

data/spec_app/Gemfile

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

data/spec_app/Rakefile

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+$:.unshift("/Library/RubyMotion/lib")
+$:.unshift("~/.rubymotion/rubymotion-templates")
+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(fail_message = "", &block)
+    expect(&block).to raise_error(MotionExpect::FailedExpectation, fail_message)
+  end
+end

data/spec_app/spec/matchers/be_false_spec.rb

@@ -0,0 +1,22 @@
+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("true expected to be false"){ expect(true).to be_false }
+  end
+
+  it "be_false fails when value is an Object" do
+    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("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
+    expect(true).not_to be_false
+  end
+end

data/spec_app/spec/matchers/be_generic_spec.rb

@@ -0,0 +1,28 @@
+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("[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
+    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("\"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
+    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
+    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

@@ -0,0 +1,22 @@
+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("true expected to be nil"){ expect(true).to be_nil }
+  end
+
+  it "be_nil fails when value is false" do
+    expect_failure("false expected to be nil"){ expect(false).to be_nil }
+  end
+
+  it "be_nil fails when value is an Object" do
+    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

@@ -0,0 +1,22 @@
+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("false expected to be true"){ expect(false).to be_true }
+  end
+
+  it "be_true fails when value is an Object" do
+    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("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
+    expect(false).to_not be_true
+  end
+end

data/spec_app/spec/matchers/be_within_spec.rb

@@ -0,0 +1,21 @@
+describe "Matcher::BeWithin" do
+  it "passes when subject is within range" do
+    expect(27.5).to be_within(0.5).of(27.9)
+    expect(27.5).to be_within(0.5).of(28.0)
+    expect(27.5).to be_within(0.5).of(27.1)
+    expect(27.5).to be_within(0.5).of(27.0)
+    expect(27.5).not_to be_within(0.5).of(28.1)
+    expect(27.5).not_to be_within(0.5).of(26.9)
+  end
+
+  it "fails when subject is not within range" do
+    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
+    expect{ expect(1).to be_within(10) }.to raise_error(MotionExpect::InvalidMatcher)
+  end
+end