rspec-expectations 2.8.0 → 2.9.0.rc2

data/lib/rspec/matchers/built_in.rb

@@ -0,0 +1,33 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      require 'rspec/matchers/built_in/base_matcher'
+      autoload :BeAnInstanceOf, 'rspec/matchers/built_in/be_instance_of'
+      autoload :Be,             'rspec/matchers/built_in/be'
+      autoload :BeTrue,         'rspec/matchers/built_in/be'
+      autoload :BeFalse,        'rspec/matchers/built_in/be'
+      autoload :BeNil,          'rspec/matchers/built_in/be'
+      autoload :BeComparedTo,   'rspec/matchers/built_in/be'
+      autoload :BePredicate,    'rspec/matchers/built_in/be'
+      autoload :BeAKindOf,      'rspec/matchers/built_in/be_kind_of'
+      autoload :BeWithin,       'rspec/matchers/built_in/be_within'
+      autoload :Change,         'rspec/matchers/built_in/change'
+      autoload :Cover,          'rspec/matchers/built_in/cover' if (1..2).respond_to?(:cover?)
+      autoload :Eq,             'rspec/matchers/built_in/eq'
+      autoload :Eql,            'rspec/matchers/built_in/eql'
+      autoload :Equal,          'rspec/matchers/built_in/equal'
+      autoload :Exist,          'rspec/matchers/built_in/exist'
+      autoload :Has,            'rspec/matchers/built_in/has'
+      autoload :Have,           'rspec/matchers/built_in/have'
+      autoload :Include,        'rspec/matchers/built_in/include'
+      autoload :Match,          'rspec/matchers/built_in/match'
+      autoload :MatchArray,     'rspec/matchers/built_in/match_array'
+      autoload :RaiseError,     'rspec/matchers/built_in/raise_error'
+      autoload :RespondTo,      'rspec/matchers/built_in/respond_to'
+      autoload :Satisfy,        'rspec/matchers/built_in/satisfy'
+      autoload :ThrowSymbol,    'rspec/matchers/built_in/throw_symbol'
+    end
+  end
+end
+
+

data/lib/rspec/matchers/built_in/base_matcher.rb

@@ -0,0 +1,58 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      #
+      # Used _internally_ as a base class for matchers that ship with
+      # rspec-expectations.
+      #
+      # ### Warning:
+      #
+      # This class is for internal use, and subject to change without notice.  We
+      # strongly recommend that you do not base your custom matchers on this
+      # class. If/when this changes, we will announce it and remove this warning.
+      module BaseMatcher
+        include RSpec::Matchers::Pretty
+
+        attr_reader :actual, :expected, :rescued_exception
+
+        def initialize(expected=nil)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+        end
+
+        def match_unless_raises(exception=Exception)
+          begin
+            yield
+            true
+          rescue exception => @rescued_exception
+            false
+          end
+        end
+
+        def failure_message_for_should
+          "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def description
+          expected ? "#{name_to_sentence} #{expected.inspect}" : name_to_sentence
+        end
+
+        def diffable?
+          false
+        end
+
+        def ==(other)
+          matches?(other)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/be.rb

@@ -0,0 +1,183 @@
+require 'rspec/matchers/dsl'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeTrue
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual)
+        end
+      end
+
+      class BeFalse
+        include BaseMatcher
+
+        def matches?(actual)
+          !super(actual)
+        end
+      end
+
+      class BeNil
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual).nil?
+        end
+
+        def failure_message_for_should
+          "expected: nil\n     got: #{actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected: not nil\n     got: nil"
+        end
+      end
+
+      class Be
+        include RSpec::Matchers::Pretty
+
+        def initialize(*args, &block)
+          @args = args
+        end
+
+        def matches?(actual)
+          @actual = actual
+          !!@actual
+        end
+
+        def failure_message_for_should
+          "expected #{@actual.inspect} to evaluate to true"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual.inspect} to evaluate to false"
+        end
+
+        def description
+          "be"
+        end
+
+        [:==, :<, :<=, :>=, :>, :===].each do |operator|
+          define_method operator do |operand|
+            BeComparedTo.new(operand, operator)
+          end
+        end
+
+        private
+
+        def args_to_s
+          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
+        end
+
+        def parenthesize(string)
+          "(#{string})"
+        end
+
+        def inspected_args
+          @args.collect{|a| a.inspect}
+        end
+
+        def expected_to_sentence
+          split_words(@expected)
+        end
+
+        def args_to_sentence
+          to_sentence(@args)
+        end
+      end
+
+      class BeComparedTo < Be
+        def initialize(operand, operator)
+          @expected, @operator = operand, operator
+            @args = []
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @actual.__send__(@operator, @expected)
+        end
+
+        def failure_message_for_should
+          "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          message = <<-MESSAGE
+'should_not be #{@operator} #{@expected}' not only FAILED,
+it is a bit confusing.
+          MESSAGE
+
+          raise message << ([:===,:==].include?(@operator) ?
+                            "It might be more clearly expressed without the \"be\"?" :
+                            "It might be more clearly expressed in the positive?")
+        end
+
+        def description
+          "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
+        end
+      end
+
+      class BePredicate < Be
+        def initialize(*args, &block)
+          @expected = parse_expected(args.shift)
+          @args = args
+          @block = block
+        end
+
+        def matches?(actual)
+          @actual = actual
+          begin
+            return @result = actual.__send__(predicate, *@args, &@block)
+          rescue NameError => predicate_missing_error
+            "this needs to be here or rcov will not count this branch even though it's executed in a code example"
+          end
+
+          begin
+            return @result = actual.__send__(present_tense_predicate, *@args, &@block)
+          rescue NameError
+            raise predicate_missing_error
+          end
+        end
+
+        def failure_message_for_should
+          "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+        end
+
+        def description
+          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
+        end
+
+        private
+
+        def predicate
+          "#{@expected}?".to_sym
+        end
+
+        def present_tense_predicate
+          "#{@expected}s?".to_sym
+        end
+
+        def parse_expected(expected)
+          @prefix, expected = prefix_and_expected(expected)
+          expected
+        end
+
+        def prefix_and_expected(symbol)
+          symbol.to_s =~ /^(be_(an?_)?)(.*)/
+          return $1, $3
+        end
+
+        def prefix_to_sentence
+          split_words(@prefix)
+        end
+      end
+    end
+
+  end
+end

data/lib/rspec/matchers/built_in/be_instance_of.rb

@@ -0,0 +1,13 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeAnInstanceOf
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual).instance_of?(expected)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/be_kind_of.rb

@@ -0,0 +1,13 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeAKindOf
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual).kind_of?(expected)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/be_within.rb

@@ -0,0 +1,39 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeWithin
+        include BaseMatcher
+
+        attr_reader :delta
+
+        def initialize(delta)
+          @delta = delta
+        end
+
+        def matches?(actual)
+          unless defined?(@expected)
+            raise ArgumentError.new("You must set an expected value using #of: be_within(#{delta}).of(expected_value)")
+          end
+          (super(actual) - expected).abs < delta
+        end
+
+        def of(expected)
+          @expected = expected
+          self
+        end
+
+        def failure_message_for_should
+          "expected #{actual} to #{description}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{actual} not to #{description}"
+        end
+
+        def description
+          "be within #{delta} of #{expected}"
+        end
+      end
+    end
+  end
+end

data/lib/rspec/matchers/built_in/change.rb

@@ -0,0 +1,132 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class Change
+        def initialize(receiver=nil, message=nil, &block)
+          @message = message
+          @value_proc = block || lambda {receiver.__send__(message)}
+          @expected_after = @expected_before = @minimum = @maximum = @expected_delta = nil
+          @eval_before = @eval_after = false
+        end
+
+        def matches?(event_proc)
+          raise_block_syntax_error if block_given?
+
+          @actual_before = evaluate_value_proc
+          event_proc.call
+          @actual_after = evaluate_value_proc
+
+          (!change_expected? || changed?) && matches_before? && matches_after? && matches_expected_delta? && matches_min? && matches_max?
+        end
+
+        def raise_block_syntax_error
+          raise SyntaxError.new(<<-MESSAGE)
+block passed to should or should_not change must use {} instead of do/end
+MESSAGE
+        end
+
+        def evaluate_value_proc
+          case val = @value_proc.call
+          when Enumerable
+            val.dup
+          else
+            val
+          end
+        end
+
+        def failure_message_for_should
+          if @eval_before && !expected_matches_actual?(@expected_before, @actual_before)
+            "#{message} should have initially been #{@expected_before.inspect}, but was #{@actual_before.inspect}"
+          elsif @eval_after && !expected_matches_actual?(@expected_after, @actual_after)
+            "#{message} should have been changed to #{@expected_after.inspect}, but is now #{@actual_after.inspect}"
+          elsif @expected_delta
+            "#{message} should have been changed by #{@expected_delta.inspect}, but was changed by #{actual_delta.inspect}"
+          elsif @minimum
+            "#{message} should have been changed by at least #{@minimum.inspect}, but was changed by #{actual_delta.inspect}"
+          elsif @maximum
+            "#{message} should have been changed by at most #{@maximum.inspect}, but was changed by #{actual_delta.inspect}"
+          else
+            "#{message} should have changed, but is still #{@actual_before.inspect}"
+          end
+        end
+
+        def actual_delta
+          @actual_after - @actual_before
+        end
+
+        def failure_message_for_should_not
+          "#{message} should not have changed, but did change from #{@actual_before.inspect} to #{@actual_after.inspect}"
+        end
+
+        def by(expected_delta)
+          @expected_delta = expected_delta
+          self
+        end
+
+        def by_at_least(minimum)
+          @minimum = minimum
+          self
+        end
+
+        def by_at_most(maximum)
+          @maximum = maximum
+          self
+        end      
+
+        def to(to)
+          @eval_after = true
+          @expected_after = to
+          self
+        end
+
+        def from (before)
+          @eval_before = true
+          @expected_before = before
+          self
+        end
+
+        def description
+          "change ##{message}"
+        end
+
+        private
+
+        def message
+          @message || "result"
+        end
+
+        def change_expected?
+          @expected_delta != 0
+        end
+
+        def changed?
+          @actual_before != @actual_after
+        end
+
+        def matches_before?
+          @eval_before ? expected_matches_actual?(@expected_before, @actual_before) : true
+        end
+
+        def matches_after?
+          @eval_after ? expected_matches_actual?(@expected_after, @actual_after) : true
+        end
+
+        def matches_expected_delta?
+          @expected_delta ? (@actual_before + @expected_delta == @actual_after) : true
+        end
+
+        def matches_min?
+          @minimum ? (@actual_after - @actual_before >= @minimum) : true
+        end
+
+        def matches_max?
+          @maximum ? (@actual_after - @actual_before <= @maximum) : true
+        end
+
+        def expected_matches_actual?(expected, actual)
+          expected === actual
+        end
+      end
+    end
+  end
+end