rspec-instructure 1.3.3

data/lib/spec/matchers/match_array.rb

@@ -0,0 +1,71 @@
+module Spec
+  module Matchers
+
+    class MatchArray #:nodoc:
+      include Spec::Matchers::Pretty
+      
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual        
+        @extra_items = difference_between_arrays(@actual, @expected)
+        @missing_items = difference_between_arrays(@expected, @actual)
+        @extra_items.empty? & @missing_items.empty?
+      end
+
+      def failure_message_for_should
+        message =  "expected collection contained:  #{safe_sort(@expected).inspect}\n"
+        message += "actual collection contained:    #{safe_sort(@actual).inspect}\n"
+        message += "the missing elements were:      #{safe_sort(@missing_items).inspect}\n" unless @missing_items.empty?
+        message += "the extra elements were:        #{safe_sort(@extra_items).inspect}\n"   unless @extra_items.empty?
+        message
+      end
+      
+      def failure_message_for_should_not
+        "Matcher does not support should_not"
+      end
+      
+      def description
+        "contain exactly #{_pretty_print(@expected)}"
+      end
+
+      private
+
+        def safe_sort(array)
+          array.all?{|item| item.respond_to?(:<=>)} ? array.sort : array
+        end
+
+        def difference_between_arrays(array_1, array_2)
+          difference = array_1.dup
+          array_2.each do |element|
+            if index = difference.index(element)
+              difference.delete_at(index)
+            end
+          end
+          difference
+        end
+
+
+    end
+
+    # :call-seq:
+    #   should =~ expected
+    #
+    # Passes if actual contains all of the expected regardless of order. 
+    # This works for collections. Pass in multiple args  and it will only 
+    # pass if all args are found in collection.
+    #
+    # NOTE: there is no should_not version of array.should =~ other_array
+    # 
+    # == Examples
+    #
+    #   [1,2,3].should   =~ [1,2,3]   # => would pass
+    #   [1,2,3].should   =~ [2,3,1]   # => would pass
+    #   [1,2,3,4].should =~ [1,2,3]   # => would fail
+    #   [1,2,2,3].should =~ [1,2,3]   # => would fail
+    #   [1,2,3].should   =~ [1,2,3,4] # => would fail
+    OperatorMatcher.register(Array, '=~', Spec::Matchers::MatchArray)
+  end
+end

data/lib/spec/matchers/matcher.rb

@@ -0,0 +1,132 @@
+module Spec
+  module Matchers
+    class Matcher
+      include Spec::Matchers::InstanceExec
+      include Spec::Matchers::Pretty
+      include Spec::Matchers
+
+      attr_reader :expected, :actual
+
+      def initialize(name, *expected, &declarations)
+        @name     = name
+        @expected = expected
+        @actual   = nil
+        @diffable = false
+        @expected_exception = nil
+        @messages = {
+          :description => lambda {"#{name_to_sentence}#{expected_to_sentence}"},
+          :failure_message_for_should => lambda {|actual| "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"},
+          :failure_message_for_should_not => lambda {|actual| "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"}
+        }
+        making_declared_methods_public do
+          instance_exec(*@expected, &declarations)
+        end
+      end
+
+      #Used internally by objects returns by +should+ and +should_not+.
+      def matches?(actual)
+        @actual = actual
+        if @expected_exception
+          begin
+            instance_exec(actual, &@match_block)
+            true
+          rescue @expected_exception
+            false
+          end
+        else
+          begin
+            instance_exec(actual, &@match_block)
+          rescue Spec::Expectations::ExpectationNotMetError
+            false
+          end
+        end
+      end
+
+      # See Spec::Matchers
+      def match(&block)
+        @match_block = block
+      end
+
+      # See Spec::Matchers
+      def match_unless_raises(exception=Exception, &block)
+        @expected_exception = exception
+        match(&block)
+      end
+
+      # See Spec::Matchers
+      def failure_message_for_should(&block)
+        cache_or_call_cached(:failure_message_for_should, &block)
+      end
+
+      # See Spec::Matchers
+      def failure_message_for_should_not(&block)
+        cache_or_call_cached(:failure_message_for_should_not, &block)
+      end
+
+      # See Spec::Matchers
+      def description(&block)
+        cache_or_call_cached(:description, &block)
+      end
+
+      #Used internally by objects returns by +should+ and +should_not+.
+      def diffable?
+        @diffable
+      end
+
+      # See Spec::Matchers
+      def diffable
+        @diffable = true
+      end
+      
+      # See Spec::Matchers
+      def chain(method, &block)
+        self.class.class_eval do
+          define_method method do |*args|
+            block.call(*args)
+            self
+          end
+        end
+      end
+
+    private
+
+      def making_declared_methods_public # :nodoc:
+        # Our home-grown instance_exec in ruby 1.8.6 results in any methods
+        # declared in the block eval'd by instance_exec in the block to which we
+        # are yielding here are scoped private. This is NOT the case for Ruby
+        # 1.8.7 or 1.9.
+        #
+        # Also, due some crazy scoping that I don't understand, these methods
+        # are actually available in the specs (something about the matcher being
+        # defined in the scope of Spec::Matchers or within an example), so not
+        # doing the following will not cause specs to fail, but they *will*
+        # cause features to fail and that will make users unhappy. So don't.
+        orig_private_methods = private_methods
+        yield
+        st = (class << self; self; end)
+        (private_methods - orig_private_methods).each {|m| st.__send__ :public, m}
+      end
+
+      def cache_or_call_cached(key, &block)
+        block ? cache(key, &block) : call_cached(key)
+      end
+
+      def cache(key, &block)
+        @messages[key] = block
+      end
+
+      def call_cached(key)
+        @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
+      end
+
+      def name_to_sentence
+        split_words(@name)
+      end
+
+      def expected_to_sentence
+        to_sentence(@expected)
+      end
+
+    end
+  end
+end

data/lib/spec/matchers/method_missing.rb

@@ -0,0 +1,9 @@
+module Spec
+  module Matchers
+    def method_missing(sym, *args, &block) # :nodoc:
+      return Matchers::BePredicate.new(sym, *args, &block) if sym.to_s =~ /^be_/
+      return Matchers::Has.new(sym, *args, &block) if sym.to_s =~ /^have_/
+      super
+    end
+  end
+end

data/lib/spec/matchers/operator_matcher.rb

@@ -0,0 +1,83 @@
+module Spec
+  module Matchers
+
+    class OperatorMatcher
+      class << self
+        def registry
+          @registry ||= {}
+        end
+
+        def register(klass, operator, matcher)
+          registry[klass] ||= {}
+          registry[klass][operator] = matcher
+        end
+
+        def get(klass, operator)
+          matcher = registry[klass] && registry[klass][operator]
+          unless matcher
+            parent_class = registry.keys.detect {|pc| klass <= pc }
+            matcher = registry[parent_class] && registry[parent_class][operator]
+          end
+          matcher
+        end
+      end
+
+      def initialize(actual)
+        @actual = actual
+      end
+
+      def self.use_custom_matcher_or_delegate(operator)
+        define_method(operator) do |expected|
+          if matcher = OperatorMatcher.get(@actual.class, operator)
+            @actual.send(::Spec::Matchers.last_should, matcher.new(expected))
+          else
+            eval_match(@actual, operator, expected)
+          end
+        end
+      end
+
+      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
+        use_custom_matcher_or_delegate operator
+      end
+
+      def fail_with_message(message)
+        Spec::Expectations.fail_with(message, @expected, @actual)
+      end
+
+      def description
+        "#{@operator} #{@expected.inspect}"
+      end
+      
+    private
+      
+      def eval_match(actual, operator, expected)
+        ::Spec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
+      end
+
+    end
+
+    class PositiveOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        if actual.__send__(operator, expected)
+          true
+        elsif ['==','===', '=~'].include?(operator)
+          fail_with_message("expected: #{expected.inspect},\n     got: #{actual.inspect} (using #{operator})") 
+        else
+          fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+        end
+      end
+
+    end
+
+    class NegativeOperatorMatcher < OperatorMatcher #:nodoc:
+      def __delegate_operator(actual, operator, expected)
+        return false unless actual.__send__(operator, expected)
+        return fail_with_message("expected not: #{operator} #{expected.inspect},\n         got: #{operator.gsub(/./, ' ')} #{actual.inspect}")
+      end
+
+    end
+
+  end
+end

data/lib/spec/matchers/pretty.rb

@@ -0,0 +1,37 @@
+module Spec
+  module Matchers
+    module Pretty
+      def split_words(sym)
+        sym.to_s.gsub(/_/,' ')
+      end
+
+      def to_sentence(words=[])
+        words = words.map{|w| w.inspect}
+        case words.length
+          when 0
+            ""
+          when 1
+            " #{words[0]}"
+          when 2
+            " #{words[0]} and #{words[1]}"
+          else
+            " #{words[0...-1].join(', ')}, and #{words[-1]}"
+        end
+      end
+
+      def _pretty_print(array)
+        result = ""
+        array.each_with_index do |item, index|
+          if index < (array.length - 2)
+            result << "#{item.inspect}, "
+          elsif index < (array.length - 1)
+            result << "#{item.inspect} and "
+          else
+            result << "#{item.inspect}"
+          end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/spec/matchers/raise_exception.rb

@@ -0,0 +1,131 @@
+module Spec
+  module Matchers
+    class RaiseException #:nodoc:
+      def initialize(expected_exception_or_message=Exception, expected_message=nil, &block)
+        @block = block
+        @actual_exception = nil
+        case expected_exception_or_message
+        when String, Regexp
+          @expected_exception, @expected_message = Exception, expected_exception_or_message
+        else
+          @expected_exception, @expected_message = expected_exception_or_message, expected_message
+        end
+      end
+
+      def matches?(given_proc)
+        @raised_expected_exception = false
+        @with_expected_message = false
+        @eval_block = false
+        @eval_block_passed = false
+        begin
+          given_proc.call
+        rescue @expected_exception => @actual_exception
+          @raised_expected_exception = true
+          @with_expected_message = verify_message
+        rescue Exception => @actual_exception
+          # This clause should be empty, but rcov will not report it as covered
+          # unless something (anything) is executed within the clause
+          rcov_exception_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+        end
+
+        unless negative_expectation?
+          eval_block if @raised_expected_exception && @with_expected_message && @block
+        end
+
+        (@raised_expected_exception & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+      end
+
+      def eval_block
+        @eval_block = true
+        begin
+          @block[@actual_exception]
+          @eval_block_passed = true
+        rescue Exception => err
+          @actual_exception = err
+        end
+      end
+
+      def verify_message
+        case @expected_message
+        when nil
+          true
+        when Regexp
+          @expected_message =~ @actual_exception.message
+        else
+          @expected_message == @actual_exception.message
+        end
+      end
+
+      def failure_message_for_should
+        @eval_block ? @actual_exception.message : "expected #{expected_exception}#{given_exception}"
+      end
+
+      def failure_message_for_should_not
+        "expected no #{expected_exception}#{given_exception}"
+      end
+
+      def description
+        "raise #{expected_exception}"
+      end
+
+      private
+        def expected_exception
+          case @expected_message
+          when nil
+            @expected_exception
+          when Regexp
+            "#{@expected_exception} with message matching #{@expected_message.inspect}"
+          else
+            "#{@expected_exception} with #{@expected_message.inspect}"
+          end
+        end
+
+        def given_exception
+          @actual_exception.nil? ? " but nothing was raised" : ", got #{@actual_exception.inspect}"
+        end
+
+        def negative_expectation?
+          # YES - I'm a bad person... help me find a better way - ryand
+          caller.first(3).find { |s| s =~ /should_not/ }
+        end
+    end
+
+    # :call-seq:
+    #   should raise_exception()
+    #   should raise_exception(NamedError)
+    #   should raise_exception(NamedError, String)
+    #   should raise_exception(NamedError, Regexp)
+    #   should raise_exception() { |exception| ... }
+    #   should raise_exception(NamedError) { |exception| ... }
+    #   should raise_exception(NamedError, String) { |exception| ... }
+    #   should raise_exception(NamedError, Regexp) { |exception| ... }
+    #   should_not raise_exception()
+    #   should_not raise_exception(NamedError)
+    #   should_not raise_exception(NamedError, String)
+    #   should_not raise_exception(NamedError, Regexp)
+    #
+    # With no args, matches if any exception is raised.
+    # With a named exception, matches only if that specific exception is raised.
+    # With a named exception and messsage specified as a String, matches only if both match.
+    # With a named exception and messsage specified as a Regexp, matches only if both match.
+    # Pass an optional block to perform extra verifications on the exception matched
+    #
+    # == Examples
+    #
+    #   lambda { do_something_risky }.should raise_exception
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError) { |exception| exception.data.should == 42 }
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError, "that was too risky")
+    #   lambda { do_something_risky }.should raise_exception(PoorRiskDecisionError, /oo ri/)
+    #
+    #   lambda { do_something_risky }.should_not raise_exception
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError, "that was too risky")
+    #   lambda { do_something_risky }.should_not raise_exception(PoorRiskDecisionError, /oo ri/)
+    def raise_exception(exception=Exception, message=nil, &block)
+      Matchers::RaiseException.new(exception, message, &block)
+    end
+
+    alias_method :raise_error, :raise_exception
+  end
+end