rspec-expectations 2.8.0 → 2.9.0.rc2

data/lib/rspec/matchers/match.rb

@@ -1,21 +0,0 @@
-module RSpec
-  module Matchers
-    class Match
-      include BaseMatcher
-
-      def matches?(actual)
-        super(actual).match(expected)
-      end
-    end
-
-    # Given a Regexp or String, passes if actual.match(pattern)
-    #
-    # @example
-    #
-    #   email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
-    #   email.should match("@example.com")
-    def match(expected)
-      Match.new(expected)
-    end
-  end
-end

data/lib/rspec/matchers/match_array.rb

@@ -1,65 +0,0 @@
-module RSpec
-  module Matchers
-    class MatchArray
-      include RSpec::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.sort rescue 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
-
-    # 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
-    # 
-    # @example
-    #
-    #   [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, '=~', RSpec::Matchers::MatchArray)
-  end
-end

data/lib/rspec/matchers/raise_error.rb

@@ -1,116 +0,0 @@
-module RSpec
-  module Matchers
-    class RaiseError
-      def initialize(expected_error_or_message=Exception, expected_message=nil, &block)
-        @block = block
-        @actual_error = nil
-        case expected_error_or_message
-        when String, Regexp
-          @expected_error, @expected_message = Exception, expected_error_or_message
-        else
-          @expected_error, @expected_message = expected_error_or_message, expected_message
-        end
-      end
-
-      def matches?(given_proc)
-        @raised_expected_error = false
-        @with_expected_message = false
-        @eval_block = false
-        @eval_block_passed = false
-        begin
-          given_proc.call
-        rescue @expected_error => @actual_error
-          @raised_expected_error = true
-          @with_expected_message = verify_message
-        rescue Exception => @actual_error
-          # This clause should be empty, but rcov will not report it as covered
-          # unless something (anything) is executed within the clause
-          "http://eigenclass.org/hiki.rb?rcov-0.8.0"
-        end
-
-        unless negative_expectation?
-          eval_block if @raised_expected_error && @with_expected_message && @block
-        end
-      ensure
-        return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
-      end
-      
-      def eval_block
-        @eval_block = true
-        begin
-          @block[@actual_error]
-          @eval_block_passed = true
-        rescue Exception => err
-          @actual_error = err
-        end
-      end
-
-      def verify_message
-        case @expected_message
-        when nil
-          true
-        when Regexp
-          @expected_message =~ @actual_error.message
-        else
-          @expected_message == @actual_error.message
-        end
-      end
-      
-      def failure_message_for_should
-        @eval_block ? @actual_error.message : "expected #{expected_error}#{given_error}"
-      end
-
-      def failure_message_for_should_not
-        "expected no #{expected_error}#{given_error}"
-      end
-      
-      def description
-        "raise #{expected_error}"
-      end
-      
-      private
-        def expected_error
-          case @expected_message
-          when nil
-            @expected_error
-          when Regexp
-            "#{@expected_error} with message matching #{@expected_message.inspect}"
-          else
-            "#{@expected_error} with #{@expected_message.inspect}"
-          end
-        end
-
-        def given_error
-          @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.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
-    
-    # With no args, matches if any error is raised.
-    # With a named error, matches only if that specific error is raised.
-    # With a named error and messsage specified as a String, matches only if both match.
-    # With a named error and messsage specified as a Regexp, matches only if both match.
-    # Pass an optional block to perform extra verifications on the exception matched
-    #
-    # @example
-    #
-    #   lambda { do_something_risky }.should raise_error
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError) { |error| error.data.should == 42 }
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
-    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
-    #
-    #   lambda { do_something_risky }.should_not raise_error
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
-    #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
-    def raise_error(error=Exception, message=nil, &block)
-      Matchers::RaiseError.new(error, message, &block)
-    end
-    alias_method :raise_exception, :raise_error
-  end
-end

data/lib/rspec/matchers/respond_to.rb

@@ -1,80 +0,0 @@
-module RSpec
-  module Matchers
-    class RespondTo
-      def initialize(*names)
-        @names = names
-        @expected_arity = nil
-      end
-      
-      def matches?(actual)
-        find_failing_method_names(actual, :reject).empty?
-      end
-
-      def does_not_match?(actual)
-        find_failing_method_names(actual, :select).empty?
-      end
-      
-      def failure_message_for_should
-        "expected #{@actual.inspect} to respond to #{@failing_method_names.collect {|name| name.inspect }.join(', ')}#{with_arity}"
-      end
-      
-      def failure_message_for_should_not
-        failure_message_for_should.sub(/to respond to/, 'not to respond to')
-      end
-      
-      def description
-        "respond to #{pp_names}#{with_arity}"
-      end
-      
-      def with(n)
-        @expected_arity = n
-        self
-      end
-      
-      def argument
-        self
-      end
-      alias :arguments :argument
-      
-    private
-
-      def find_failing_method_names(actual, filter_method)
-        @actual = actual
-        @failing_method_names = @names.send(filter_method) do |name|
-          @actual.respond_to?(name) && matches_arity?(actual, name)
-        end
-      end
-      
-      def matches_arity?(actual, name)
-        return true unless @expected_arity
-
-        actual_arity = actual.method(name).arity
-        if actual_arity < 0
-          # ~ inverts the one's complement and gives us the number of required args
-          ~actual_arity <= @expected_arity
-        else
-          actual_arity == @expected_arity
-        end
-      end
-      
-      def with_arity
-        @expected_arity.nil?? "" :
-          " with #{@expected_arity} argument#{@expected_arity == 1 ? '' : 's'}"
-      end
-      
-      def pp_names
-        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
-        @names.length == 1 ? "##{@names.first}" : @names.inspect
-      end
-    end
-    
-    # Matches if the target object responds to all of the names
-    # provided. Names can be Strings or Symbols.
-    #
-    # @example
-    # 
-    def respond_to(*names)
-      Matchers::RespondTo.new(*names)
-    end
-  end
-end

data/lib/rspec/matchers/satisfy.rb

@@ -1,46 +0,0 @@
-module RSpec
-  module Matchers
-    class Satisfy
-      def initialize(&block)
-        @block = block
-      end
-      
-      def matches?(actual, &block)
-        @block = block if block
-        @actual = actual
-        @block.call(actual)
-      end
-      
-      def failure_message_for_should
-        "expected #{@actual} to satisfy block"
-      end
-
-      def failure_message_for_should_not
-        "expected #{@actual} not to satisfy block"
-      end
-
-      def description
-        "satisfy block"
-      end
-    end
-    
-    # Passes if the submitted block returns true. Yields target to the
-    # block.
-    #
-    # Generally speaking, this should be thought of as a last resort when
-    # you can't find any other way to specify the behaviour you wish to
-    # specify.
-    #
-    # If you do find yourself in such a situation, you could always write
-    # a custom matcher, which would likely make your specs more expressive.
-    #
-    # @example
-    #
-    #   5.should satisfy { |n|
-    #     n > 3
-    #   }
-    def satisfy(&block)
-      Matchers::Satisfy.new(&block)
-    end
-  end
-end

data/lib/rspec/matchers/throw_symbol.rb

@@ -1,112 +0,0 @@
-module RSpec
-  module Matchers
-    class ThrowSymbol
-      def initialize(expected_symbol = nil, expected_arg=nil)
-        @expected_symbol = expected_symbol
-        @expected_arg = expected_arg
-        @caught_symbol = @caught_arg = nil
-      end
-      
-      def matches?(given_proc)
-        begin
-          if @expected_symbol.nil?
-            given_proc.call
-          else
-            @caught_arg = catch :proc_did_not_throw_anything do
-              catch @expected_symbol do
-                given_proc.call
-                throw :proc_did_not_throw_anything, :nothing_thrown
-              end
-            end
-
-            if @caught_arg == :nothing_thrown
-              @caught_arg = nil
-            else
-              @caught_symbol = @expected_symbol
-            end
-          end
-
-        # Ruby 1.8 uses NameError with `symbol'
-        # Ruby 1.9 uses ArgumentError with :symbol
-        rescue NameError, ArgumentError => e
-          unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
-            other_exception = e
-            raise
-          end
-          @caught_symbol = $2.to_sym
-        rescue => other_exception
-          raise
-        ensure
-          unless other_exception
-            if @expected_symbol.nil?
-              return !@caught_symbol.nil?
-            else
-              if @expected_arg.nil?
-                return @caught_symbol == @expected_symbol
-              else
-                return (@caught_symbol == @expected_symbol) & (@caught_arg == @expected_arg)
-              end
-            end
-          end
-        end
-      end
-
-      def failure_message_for_should
-        "expected #{expected} to be thrown, got #{caught}"
-      end
-      
-      def failure_message_for_should_not
-        "expected #{expected('no Symbol')}#{' not' if @expected_symbol} to be thrown, got #{caught}"
-      end
-      
-      def description
-        "throw #{expected}"
-      end
-      
-      private
-
-        def expected(symbol_desc = 'a Symbol')
-          throw_description(@expected_symbol || symbol_desc, @expected_arg)
-        end
-
-        def caught
-          throw_description(@caught_symbol || 'nothing', @caught_arg)
-        end
-
-        def throw_description(symbol, arg)
-          symbol_description = symbol.is_a?(String) ? symbol : symbol.inspect
-
-          arg_description = if arg
-            " with #{arg.inspect}"
-          elsif @expected_arg && @caught_symbol == @expected_symbol
-            " with no argument"
-          else
-            ""
-          end
-
-          symbol_description + arg_description
-        end
-
-    end
- 
-    # Given no argument, matches if a proc throws any Symbol.
-    #
-    # Given a Symbol, matches if the given proc throws the specified Symbol.
-    #
-    # Given a Symbol and an arg, matches if the given proc throws the
-    # specified Symbol with the specified arg.
-    #
-    # @example
-    #
-    #   lambda { do_something_risky }.should throw_symbol
-    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
-    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky, culprit)
-    #
-    #   lambda { do_something_risky }.should_not throw_symbol
-    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
-    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky, culprit)
-    def throw_symbol(expected_symbol=nil, expected_arg=nil)
-      Matchers::ThrowSymbol.new(expected_symbol, expected_arg)
-    end
-  end
-end