motion-spec 0.2.0 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ODlmZDBkZDQ2ODE2ODhiMzBmZGZiNzM5NmNmMTZlM2NmYmFhYTJiMA==
+    MDBmZjcyMjlmMTg2NDcyMWVjN2Q5NDJmZGE3MGZlYzAzMGY1MDhhMA==
   data.tar.gz: !binary |-
-    ODIyMWE2MTExNjU3ZGQ4N2FhZjVlZDE5ZjI2ODdkOTBlMDcxNTFkOA==
+    M2ExODNlMzdhZWE2YmYwODY5OTBiY2ZhODVjNjg3ZGI1MDdmY2JjNg==
 SHA512:
   metadata.gz: !binary |-
-    Y2Y5NmUzYzE5NDgzZGE5MDljMDE1MGE0Zjg0OTEyMDQ0NTZlNTk5YTFhYjIy
-    NTNhNjdmNTA1YjQxZTkzNWNkMDdkZTAzOTkxMjRhM2ZmZTQ1Y2Y2ZTNiOWVj
-    ODRhNjNmNTc5MDg5OGEyY2M0YTE2YjQ2ZjM0NjUyMWIzMjE1M2U=
+    YWVjYjI1YTNhMDQxZmMwMDY3OGIzYTkyNjYzZjIzYWY5Nzk4ZjlhZDI2MjQ5
+    ZDhhOTZhNzkwMDMwNGQ0YjlkZTI2NWQ0YmI4NzI3ZjhjY2RmNWYzMjM1MGNk
+    MzU0OTA3YmNhOTM3MmE0OTI4MjJjNmVmNmQ5ZDQzODM4NmQzMWI=
   data.tar.gz: !binary |-
-    NTY2NTUzNmNlM2M3MDIyMjRlYTU5YjUwMTgyNGZhYzcwMDgxOTNjNmQ2Njky
-    OTUyZjg5MGE2YWQxMWE5MTk4OWNjY2Q4OWUxYzllZjlhY2JhYTYzZmUyOTZm
-    NzA1NTgyYjg1YjkzNWFmMzIzYjEwZjQ4ZDAxMjAxN2Q5ZDhiMGI=
+    MTg0YzkzNGYwZDZlYWYwNTlmMGNlYmQyODYwNTI5ZmVmYmM2YmQ5NWVlZWI1
+    MGExNWNlNmQyNmM4ZGQ5MDgwMTNlMzNjYzZlOTViZGU1ZTQ5ZmExNWZjZGFk
+    M2ZjZmMxY2U3ZjY5OTJkN2ZhMWZiN2NjNjJmMDk0MWQ5OWEwNzI=

data/.hound.yml

@@ -0,0 +1,2 @@
+ruby:
+  config_file: .rubocop.yml

data/.rubocop.yml

@@ -27,6 +27,9 @@ Metrics/ClassLength:
   Enabled: true
   Max: 100
 
+Metrics/LineLength:
+  Max: 120
+
 Metrics/ModuleLength:
   Description: 'Avoid modules longer than 100 lines of code.'
   Enabled: true

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    motion-spec (0.2.0)
+    motion-spec (0.3.0)
       motion-require (>= 0.0.6)
 
 GEM

data/lib/motion-spec/context.rb

@@ -1,6 +1,10 @@
 # -*- encoding : utf-8 -*-
 module MotionSpec
   class Context
+    include ContextHelper::Matchers
+    include ContextHelper::Should
+    include ContextHelper::Expectation
+
     attr_reader :name, :block
 
     def initialize(name, before = nil, after = nil, &block)

data/lib/motion-spec/context_helper/expectation.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  module ContextHelper
+    module Expectation
+      def expect(subject = nil, &block)
+        MotionSpec::Expectation.new(subject, &block)
+      end
+    end
+  end
+end

data/lib/motion-spec/context_helper/matchers.rb

@@ -0,0 +1,95 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  module ContextHelper
+    module Matchers
+      def be_nil
+        MotionSpec::Matcher::BeNil.new
+      end
+
+      def be_true
+        MotionSpec::Matcher::BeTrue.new
+      end
+
+      def be_false
+        MotionSpec::Matcher::BeFalse.new
+      end
+
+      def raise_error(exception_class = Exception, message = '')
+        MotionSpec::Matcher::RaiseError.new(exception_class, message)
+      end
+      alias_method :raise_exception, :raise_error
+
+      def eql(value)
+        MotionSpec::Matcher::Eql.new(value)
+      end
+
+      def be(value)
+        MotionSpec::Matcher::Be.new(value)
+      end
+      alias_method :equal, :be
+
+      def eq(value)
+        MotionSpec::Matcher::Eq.new(value)
+      end
+
+      def match(regex)
+        MotionSpec::Matcher::Match.new(regex)
+      end
+
+      def match_array(array)
+        MotionSpec::Matcher::MatchArray.new(array)
+      end
+      alias_method :contain_exactly, :match_array
+
+      def include(*values)
+        MotionSpec::Matcher::Include.new(*values)
+      end
+
+      def have(number)
+        MotionSpec::Matcher::HaveItems.new(number)
+      end
+
+      def satisfy(&block)
+        MotionSpec::Matcher::Satisfy.new(&block)
+      end
+
+      def respond_to(method_name)
+        MotionSpec::Matcher::RespondTo.new(method_name)
+      end
+
+      def start_with(substring)
+        MotionSpec::Matcher::StartWith.new(substring)
+      end
+
+      def end_with(substring)
+        MotionSpec::Matcher::EndWith.new(substring)
+      end
+
+      def change(&change_block)
+        MotionSpec::Matcher::Change.new(change_block)
+      end
+
+      def be_within(range)
+        MotionSpec::Matcher::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
+          return MotionSpec::Matcher::BeGeneric.new(match_be[1], *args)
+        end
+
+        match_have = string_method_name.match(/^have_(.*)/)
+
+        if match_have
+          return MotionSpec::Matcher::HaveGeneric.new(match_have[1], *args)
+        end
+
+        super
+        # raise "method name not found #{method_name}"
+      end
+    end
+  end
+end

data/lib/motion-spec/context_helper/should.rb

@@ -0,0 +1,12 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  module ContextHelper
+    module Should
+      def should(*args, &block)
+        return it('should ' + args.first, &block) if Counter[:depth] == 0
+
+        super(*args, &block)
+      end
+    end
+  end
+end

data/lib/motion-spec/error.rb

@@ -8,4 +8,8 @@ module MotionSpec
       super message
     end
   end
+
+  class FailedExpectation < RuntimeError; end
+
+  class InvalidMatcher < RuntimeError; end
 end

data/lib/motion-spec/expectation.rb

@@ -0,0 +1,32 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  class Expectation
+    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-spec/fail_message_renderer.rb

@@ -0,0 +1,101 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/be.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/be_false.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/be_generic.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  module Matcher
+    class BeGeneric < SingleMethod
+      def initialize(method_name, *values)
+        super("#{method_name}?", *values)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/be_true.rb

@@ -0,0 +1,16 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/be_within.rb

@@ -0,0 +1,30 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  module Matcher
+    class BeWithin
+      INVALID_MATCH_ERROR = 'be_within matcher incomplete. Missing .of value'
+
+      def initialize(range)
+        @range = range
+      end
+
+      def of(center_value)
+        @center_value = center_value
+        self
+      end
+
+      def matches?(subject)
+        raise InvalidMatcher.new(INVALID_MATCH_ERROR) 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-spec/matcher/change.rb

@@ -0,0 +1,35 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/end_with.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/eq.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/eql.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  module Matcher
+    class Eql < SingleMethod
+      def initialize(value)
+        super(:eql?, value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/have_items.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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

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

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/match.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/match_array.rb

@@ -0,0 +1,28 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/raise_error.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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)
+        block.call
+        false
+      rescue Exception => e
+        @rescued_exception = e
+        exception_matches(e)
+      end
+
+      def exception_matches(exception)
+        return false unless exception.is_a?(@error_class)
+
+        is_match = case @error_message
+                    when String
+                      exception.message.include?(@error_message)
+                    when Regexp
+                      @error_message.match(exception.message)
+                    else
+                      false
+                    end
+
+        return false unless is_match
+
+        true
+      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-spec/matcher/respond_to.rb

@@ -0,0 +1,40 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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)
+
+        if valid && @number_of_args
+          valid &&= subject.method(@method_name).arity == @number_of_args
+        end
+
+        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-spec/matcher/satisfy.rb

@@ -0,0 +1,20 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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-spec/matcher/single_method.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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(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-spec/matcher/start_with.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+module MotionSpec
+  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/lib/motion-spec/version.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
 
 module MotionSpec
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/motion-spec.rb

@@ -7,16 +7,16 @@ require 'motion-require'
 
 # Proper load order of all the classes/modules
 ###
-def require_lib_file(file)
-  case file
+def require_lib_files(files)
+  case files
   when String
-    files = expanded_file_path(file)
-    files = Dir.glob(files) if file.include? '*'
+    file_paths = expanded_file_path(files)
+    file_paths = Dir.glob(file_paths) if files.include? '*'
   when Array
-    files = file.map { |f| expanded_file_path(f) }
+    file_paths = files.map { |f| expanded_file_path(f) }
   end
 
-  Motion::Require.all(files)
+  Motion::Require.all(file_paths)
 end
 
 def expanded_file_path(file)
@@ -24,16 +24,26 @@ def expanded_file_path(file)
 end
 
 # Let's start off with what version we're running
-require_lib_file('version')
+require_lib_files('version')
 
 # Load the output before the core so the core knows how to print
-require_lib_file('output/*')
+require_lib_files('output/*')
+
+# Add on to the context of specs
+require_lib_files('context_helper/*')
 
 # All the other core modules in the proper order
-require_lib_file(%w(core error specification platform context should))
+require_lib_files(%w(
+  core error specification platform context should expectation
+  fail_message_renderer
+))
+
+# Load expectation matchers
+require_lib_files('matcher/single_method')
+require_lib_files('matcher/*')
 
 # Monkeypatch core objects to respond to test methods
-require_lib_file('extensions/*')
+require_lib_files('extensions/*')
 
 # FIXME : Need better detection for iPhone Simulator
 if defined?(UIDevice) &&

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motion-spec
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jonathan Bender
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-04 00:00:00.000000000 Z
+date: 2015-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: motion-require
@@ -47,6 +47,7 @@ extra_rdoc_files: []
 files:
 - .codeclimate.yml
 - .gitignore
+- .hound.yml
 - .rubocop.yml
 - .travis.yml
 - Gemfile
@@ -57,14 +58,39 @@ files:
 - app/app_delegate.rb
 - lib/motion-spec.rb
 - lib/motion-spec/context.rb
+- lib/motion-spec/context_helper/expectation.rb
+- lib/motion-spec/context_helper/matchers.rb
+- lib/motion-spec/context_helper/should.rb
 - lib/motion-spec/core.rb
 - lib/motion-spec/error.rb
+- lib/motion-spec/expectation.rb
 - lib/motion-spec/extensions/boolean.rb
 - lib/motion-spec/extensions/exception.rb
 - lib/motion-spec/extensions/kernel.rb
 - lib/motion-spec/extensions/numeric.rb
 - lib/motion-spec/extensions/object.rb
 - lib/motion-spec/extensions/proc.rb
+- lib/motion-spec/fail_message_renderer.rb
+- lib/motion-spec/matcher/be.rb
+- lib/motion-spec/matcher/be_false.rb
+- lib/motion-spec/matcher/be_generic.rb
+- lib/motion-spec/matcher/be_nil.rb
+- lib/motion-spec/matcher/be_true.rb
+- lib/motion-spec/matcher/be_within.rb
+- lib/motion-spec/matcher/change.rb
+- lib/motion-spec/matcher/end_with.rb
+- lib/motion-spec/matcher/eq.rb
+- lib/motion-spec/matcher/eql.rb
+- lib/motion-spec/matcher/have_generic.rb
+- lib/motion-spec/matcher/have_items.rb
+- lib/motion-spec/matcher/include.rb
+- lib/motion-spec/matcher/match.rb
+- lib/motion-spec/matcher/match_array.rb
+- lib/motion-spec/matcher/raise_error.rb
+- lib/motion-spec/matcher/respond_to.rb
+- lib/motion-spec/matcher/satisfy.rb
+- lib/motion-spec/matcher/single_method.rb
+- lib/motion-spec/matcher/start_with.rb
 - lib/motion-spec/output/colorized.rb
 - lib/motion-spec/output/fast.rb
 - lib/motion-spec/output/knock.rb