rspec-expectations 2.8.0 → 2.9.0.rc2

data/lib/rspec/matchers/be.rb

@@ -1,232 +0,0 @@
-require 'rspec/matchers/dsl'
-
-module RSpec
-  module Matchers
-    class BeTrue
-      include BaseMatcher
-
-      def matches?(actual)
-        super(actual)
-      end
-    end
-
-    # Passes if actual is truthy (anything but false or nil)
-    def be_true
-      BeTrue.new
-    end
-
-    class BeFalse
-      include BaseMatcher
-
-      def matches?(actual)
-        !super(actual)
-      end
-    end
-
-    # Passes if actual is falsy (false or nil)
-    def be_false
-      BeFalse.new
-    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
-
-    # Passes if actual is nil
-    def be_nil
-      BeNil.new
-    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
-
-    # @example
-    #   actual.should be_true
-    #   actual.should be_false
-    #   actual.should be_nil
-    #   actual.should be_[arbitrary_predicate](*args)
-    #   actual.should_not be_nil
-    #   actual.should_not be_[arbitrary_predicate](*args)
-    #
-    # Given true, false, or nil, will pass if actual value is true, false or
-    # nil (respectively). Given no args means the caller should satisfy an if
-    # condition (to be or not to be). 
-    #
-    # Predicates are any Ruby method that ends in a "?" and returns true or
-    # false.  Given be_ followed by arbitrary_predicate (without the "?"),
-    # RSpec will match convert that into a query against the target object.
-    #
-    # The arbitrary_predicate feature will handle any predicate prefixed with
-    # "be_an_" (e.g. be_an_instance_of), "be_a_" (e.g. be_a_kind_of) or "be_"
-    # (e.g. be_empty), letting you choose the prefix that best suits the
-    # predicate.
-    def be(*args)
-      args.empty? ?
-        Matchers::Be.new : equal(*args)
-    end
-
-    # passes if target.kind_of?(klass)
-    def be_a(klass)
-      be_a_kind_of(klass)
-    end
-    
-    alias_method :be_an, :be_a
-  end
-end

data/lib/rspec/matchers/be_instance_of.rb

@@ -1,24 +0,0 @@
-module RSpec
-  module Matchers
-    class BeAnInstanceOf
-      include BaseMatcher
-
-      def matches?(actual)
-        super(actual).instance_of?(expected)
-      end
-    end
-
-    # Passes if actual.instance_of?(expected)
-    #
-    # @example
-    #
-    #   5.should be_instance_of(Fixnum)
-    #   5.should_not be_instance_of(Numeric)
-    #   5.should_not be_instance_of(Float)
-    def be_an_instance_of(expected)
-      BeAnInstanceOf.new(expected)
-    end
-    
-    alias_method :be_instance_of, :be_an_instance_of
-  end
-end

data/lib/rspec/matchers/be_kind_of.rb

@@ -1,24 +0,0 @@
-module RSpec
-  module Matchers
-    class BeAKindOf
-      include BaseMatcher
-
-      def matches?(actual)
-        super(actual).kind_of?(expected)
-      end
-    end
-
-    # Passes if actual.kind_of?(expected)
-    #
-    # @example
-    #
-    #   5.should be_kind_of(Fixnum)
-    #   5.should be_kind_of(Numeric)
-    #   5.should_not be_kind_of(Float)
-    def be_a_kind_of(expected)
-      BeAKindOf.new(expected)
-    end
-    
-    alias_method :be_kind_of, :be_a_kind_of
-  end
-end

data/lib/rspec/matchers/be_within.rb

@@ -1,47 +0,0 @@
-module RSpec
-  module Matchers
-    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
-
-    # Passes if actual == expected +/- delta
-    #
-    # @example
-    #
-    #   result.should be_within(0.5).of(3.0)
-    #   result.should_not be_within(0.5).of(3.0)
-    def be_within(delta)
-      BeWithin.new(delta)
-    end
-  end
-end

data/lib/rspec/matchers/change.rb

@@ -1,197 +0,0 @@
-module RSpec
-  module Matchers
-    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 MatcherError.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
-    
-    # Applied to a proc, specifies that its execution will cause some value to
-    # change.
-    #
-    # @param [Object] receiver
-    # @param [Symbol] message the message to send the receiver
-    #
-    # You can either pass <tt>receiver</tt> and <tt>message</tt>, or a block,
-    # but not both.
-    #
-    # When passing a block, it must use the <tt>{ ... }</tt> format, not
-    # do/end, as <tt>{ ... }</tt> binds to the +change+ method, whereas do/end
-    # would errantly bind to the +should+ or +should_not+ method.
-    #
-    # @example
-    #
-    #   lambda {
-    #     team.add_player(player) 
-    #   }.should change(roster, :count)
-    #
-    #   lambda {
-    #     team.add_player(player) 
-    #   }.should change(roster, :count).by(1)
-    #
-    #   lambda {
-    #     team.add_player(player) 
-    #   }.should change(roster, :count).by_at_least(1)
-    #
-    #   lambda {
-    #     team.add_player(player)
-    #   }.should change(roster, :count).by_at_most(1)    
-    #
-    #   string = "string"
-    #   lambda {
-    #     string.reverse!
-    #   }.should change { string }.from("string").to("gnirts")
-    #
-    #   lambda {
-    #     person.happy_birthday
-    #   }.should change(person, :birthday).from(32).to(33)
-    #       
-    #   lambda {
-    #     employee.develop_great_new_social_networking_app
-    #   }.should change(employee, :title).from("Mail Clerk").to("CEO")
-    #
-    #   lambda {
-    #     doctor.leave_office
-    #   }.should change(doctor, :sign).from(/is in/).to(/is out/)
-    #
-    #   user = User.new(:type => "admin")
-    #   lambda {
-    #     user.symbolize_type
-    #   }.should change(user, :type).from(String).to(Symbol)
-    #
-    # == Notes
-    #
-    # Evaluates <tt>receiver.message</tt> or <tt>block</tt> before and after it
-    # evaluates the proc object (generated by the lambdas in the examples
-    # above).
-    #
-    # <tt>should_not change</tt> only supports the form with no subsequent
-    # calls to <tt>by</tt>, <tt>by_at_least</tt>, <tt>by_at_most</tt>,
-    # <tt>to</tt> or <tt>from</tt>.
-    def change(receiver=nil, message=nil, &block)
-      Matchers::Change.new(receiver, message, &block)
-    end
-  end
-end