motion-expect 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 31eee27b240ba338e3267efd2a74d3080f28d4d4
+  data.tar.gz: 0f4b4aba9cdc883561ec08a601d0594a34e9755e
+SHA512:
+  metadata.gz: 3205d44d297e65cb9eec6d8359b6947dd77fe26c6804d8e23f63767f021760232da6dfeb0fe401b8a64d76ef5400a826adcaefbc855d9df18f46d6f6b6f6e972
+  data.tar.gz: 19428d3b5ee5a9afa6b06f814e52d4acee7a19948cac739ca177feee50e56454136b85701378ed02336efc3d96d18eaa140f6ea58dd8906f6252f082a13d0d2e

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/.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/CHANGELOG.md

@@ -0,0 +1,4 @@
+[2.0.0]
+
+- Renamed gem to motion-expect (based on discussion with original owner - https://github.com/ijpiantanida/bacon-expect/issues/4)
+- Updated for RubyMotion 6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in motion-expect.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,34 @@
+# MotionExpect [![Build Status](https://travis-ci.org/rubymotion-community/motion-expect.svg?branch=master)](https://travis-ci.org/rubymotion-community/motion-expect) [![Code Climate](https://codeclimate.com/github/rubymotion-community/motion-expect.png)](https://codeclimate.com/github/rubymotion-community/motion-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
+expect(view("Tap me")).not_to be_hidden
+```
+
+Expect syntax allows a cleaner implementation because it doesn't need to monkey-patch the Object class to install the `should` method.
+
+ # Installation
+```
+gem install motion-expect
+
+# or in Gemfile
+gem 'motion-expect'
+```
+
+# Usage
+This gem ports most of the built-in matchers found in [RSpec 3.0](https://www.relishapp.com/rspec/rspec-expectations/v/3-0/docs/built-in-matchers)
+
+**A full list of matchers examples can be found in the [sample app specs.](spec_app/spec/matchers)**
+
+Examples:
+```ruby
+expect(nil).to be_nil
+expect(true).not_to be_false
+
+expect("super").to end_with("per")
+expect{ 1/0 }.to raise_error(ZeroDivisionError)
+expect{ raise ArgumentError.new("with a message") }.to raise_error(ArgumentError, /message/)
+expect([1,2,3]).to have(3).items
+expect("string").to respond_to(:upcase)
+```
+

data/Rakefile

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

data/lib/motion-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__), 'motion-expect/**/*.rb')).sort.reverse.each do |file|
+    app.spec_files << file
+  end
+end

data/lib/motion-expect/bacon_context.rb

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

data/lib/motion-expect/exceptions.rb

@@ -0,0 +1,4 @@
+module MotionExpect
+  class FailedExpectation < RuntimeError; end
+  class InvalidMatcher < RuntimeError; end
+end

data/lib/motion-expect/expectation.rb

@@ -0,0 +1,37 @@
+module MotionExpect
+  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)
+      fail(matcher, false) unless matcher_passes(matcher)
+      assert
+    end
+
+    def not_to(matcher)
+      fail(matcher, true) if matcher_passes(matcher)
+      assert
+    end
+    alias_method :to_not, :not_to
+
+    def matcher_passes(matcher)
+      matcher.matches?(@subject, &@subject_block)
+    end
+
+    def fail(matcher, negated)
+      raise matcher.fail!(@subject, negated, &@subject_block)
+    end
+
+    def assert
+      true.should == true
+    end
+  end
+end

data/lib/motion-expect/fail_message_renderer.rb

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

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

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

@@ -0,0 +1,12 @@
+module MotionExpect; module Matcher
+  class BeFalse
+    def matches?(value)
+      !value
+    end
+
+    def fail!(subject, negated)
+      message = FailMessageRenderer.message_for_be_false(negated, subject)
+      raise FailedExpectation.new(message)
+    end
+  end
+end; end

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

@@ -0,0 +1,7 @@
+module MotionExpect; module Matcher
+  class BeGeneric < SingleMethod
+    def initialize(method_name, *values)
+      super("#{method_name}?", *values)
+    end
+  end
+end; end

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

@@ -0,0 +1,11 @@
+module MotionExpect; module Matcher
+  class BeNil
+    def matches?(value)
+      value == nil
+    end
+
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_be_nil(negated, subject))
+    end
+  end
+end; end

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

@@ -0,0 +1,11 @@
+module MotionExpect; module Matcher
+  class BeTrue
+    def matches?(value)
+      value == true
+    end
+
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_be_true(negated, subject))
+    end
+  end
+end; end

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

@@ -0,0 +1,21 @@
+module MotionExpect; module Matcher
+  class BeWithin
+    def initialize(range)
+      @range = range
+    end
+
+    def of(center_value)
+      @center_value = center_value
+      self
+    end
+
+    def matches?(subject)
+      raise InvalidMatcher.new("be_within matcher incomplete. Missing .of value") unless @center_value
+      (subject - @center_value).abs <= @range
+    end
+
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_be_within(negated, subject, @range, @center_value))
+    end
+  end
+end; end

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

@@ -0,0 +1,28 @@
+module MotionExpect; 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
+        @value_diff = new_value - old_value
+        @value_diff == @change_amount
+      else
+        new_value != old_value
+      end
+    end
+
+    def fail!(subject, negated)
+      raise FailedExpectation.new(FailMessageRenderer.message_for_change(negated, @change_amount, @value_diff))
+    end
+  end
+end; end

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

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

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

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

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

@@ -0,0 +1,9 @@
+module MotionExpect
+  module Matcher
+    class Eql < SingleMethod
+      def initialize(value)
+        super(:eql?, value)
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+module MotionExpect; 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
+
+    [:items, :item, :keys, :values].each do |key_type_name|
+      define_method(key_type_name) do
+        @key_type_name = key_type_name
+        self
+      end
+    end
+
+    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