rspec-expectations 2.11.3 → 3.11.0

data/lib/rspec/matchers/matcher.rb

@@ -1,299 +0,0 @@
-require 'set'
-
-module RSpec
-  module Matchers
-    module DSL
-      # Provides the context in which the block passed to RSpec::Matchers.define
-      # will be evaluated.
-      class Matcher
-        include RSpec::Matchers::Extensions::InstanceEvalWithArgs
-        include RSpec::Matchers::Pretty
-        include RSpec::Matchers
-
-        attr_reader :expected, :actual, :rescued_exception
-        attr_accessor :matcher_execution_context
-
-        # @api private
-        def initialize(name, &declarations)
-          @name         = name
-          @declarations = declarations
-          @actual       = nil
-          @diffable     = false
-          @expected_exception, @rescued_exception = nil, nil
-          @match_for_should_not_block = nil
-          @messages = {}
-        end
-
-        PERSISTENT_INSTANCE_VARIABLES = [
-          :@name, :@declarations, :@diffable, :@messages,
-          :@match_block, :@match_for_should_not_block,
-          :@expected_exception
-        ].to_set
-
-        # @api private
-        def for_expected(*expected)
-          @expected = expected
-          dup.instance_eval do
-            instance_variables.map {|ivar| ivar.intern}.each do |ivar|
-              instance_variable_set(ivar, nil) unless (PERSISTENT_INSTANCE_VARIABLES + [:@expected]).include?(ivar)
-            end
-            making_declared_methods_public do
-              instance_eval_with_args(*@expected, &@declarations)
-            end
-            self
-          end
-        end
-
-        # @api private
-        # Used internally by +should+ and +should_not+.
-        def matches?(actual)
-          @actual = actual
-          if @expected_exception
-            begin
-              instance_eval_with_args(actual, &@match_block)
-              true
-            rescue @expected_exception => @rescued_exception
-              false
-            end
-          else
-            begin
-              instance_eval_with_args(actual, &@match_block)
-            rescue RSpec::Expectations::ExpectationNotMetError
-              false
-            end
-          end
-        end
-
-        # Stores the block that is used to determine whether this matcher passes
-        # or fails. The block should return a boolean value. When the matcher is
-        # passed to `should` and the block returns `true`, then the expectation
-        # passes. Similarly, when the matcher is passed to `should_not` and the
-        # block returns `false`, then the expectation passes.
-        #
-        # Use `match_for_should` when used in conjuntion with
-        # `match_for_should_not`.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :be_even do
-        #       match do |actual|
-        #         actual.even?
-        #       end
-        #     end
-        #
-        #     4.should be_even     # passes
-        #     3.should_not be_even # passes
-        #     3.should be_even     # fails
-        #     4.should_not be_even # fails
-        #
-        # @yield [Object] actual the actual value (or receiver of should)
-        def match(&block)
-          @match_block = block
-        end
-
-        alias_method :match_for_should, :match
-
-        # Use this to define the block for a negative expectation (`should_not`)
-        # when the positive and negative forms require different handling. This
-        # is rarely necessary, but can be helpful, for example, when specifying
-        # asynchronous processes that require different timeouts.
-        #
-        # @yield [Object] actual the actual value (or receiver of should)
-        def match_for_should_not(&block)
-          @match_for_should_not_block = block
-        end
-
-        # Use this instead of `match` when the block will raise an exception
-        # rather than returning false to indicate a failure.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :accept_as_valid do |candidate_address|
-        #       match_unless_raises ValidationException do |validator|
-        #         validator.validate(candidate_address)
-        #       end
-        #     end
-        #
-        #     email_validator.should accept_as_valid("person@company.com")
-        def match_unless_raises(exception=Exception, &block)
-          @expected_exception = exception
-          match(&block)
-        end
-
-        # Customize the failure messsage to use when this matcher is invoked with
-        # `should`. Only use this when the message generated by default doesn't
-        # suit your needs.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :have_strength do |expected|
-        #       match { ... }
-        #
-        #       failure_message_for_should do |actual|
-        #         "Expected strength of #{expected}, but had #{actual.strength}"
-        #       end
-        #     end
-        #
-        # @yield [Object] actual the actual object
-        def failure_message_for_should(&block)
-          cache_or_call_cached(:failure_message_for_should, &block)
-        end
-
-        # Customize the failure messsage to use when this matcher is invoked with
-        # `should_not`. Only use this when the message generated by default
-        # doesn't suit your needs.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :have_strength do |expected|
-        #       match { ... }
-        #
-        #       failure_message_for_should_not do |actual|
-        #         "Expected not to have strength of #{expected}, but did"
-        #       end
-        #     end
-        #
-        # @yield [Object] actual the actual object
-        # @yield [Object] actual the actual object
-        def failure_message_for_should_not(&block)
-          cache_or_call_cached(:failure_message_for_should_not, &block)
-        end
-
-
-        # Customize the description to use for one-liners.  Only use this when
-        # the description generated by default doesn't suit your needs.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :qualify_for do |expected|
-        #       match { ... }
-        #
-        #       description do
-        #         "qualify for #{expected}"
-        #       end
-        #     end
-        def description(&block)
-          cache_or_call_cached(:description, &block)
-        end
-
-        # Tells the matcher to diff the actual and expected values in the failure
-        # message.
-        def diffable
-          @diffable = true
-        end
-
-        # Convenience for defining methods on this matcher to create a fluent
-        # interface. The trick about fluent interfaces is that each method must
-        # return self in order to chain methods together. `chain` handles that
-        # for you.
-        #
-        # @example
-        #
-        #     RSpec::Matchers.define :have_errors_on do |key|
-        #       chain :with do |message|
-        #         @message = message
-        #       end
-        #
-        #       match do |actual|
-        #         actual.errors[key] == @message
-        #       end
-        #     end
-        #
-        #     minor.should have_errors_on(:age).with("Not old enough to participate")
-        def chain(method, &block)
-          define_method method do |*args|
-            block.call(*args)
-            self
-          end
-        end
-
-        # @api private
-        # Used internally by objects returns by +should+ and +should_not+.
-        def diffable?
-          @diffable
-        end
-
-        # @api private
-        # Used internally by +should_not+
-        def does_not_match?(actual)
-          @actual = actual
-          @match_for_should_not_block ?
-            instance_eval_with_args(actual, &@match_for_should_not_block) :
-            !matches?(actual)
-        end
-
-        def respond_to?(method, include_private=false)
-          super || matcher_execution_context.respond_to?(method, include_private)
-        end
-
-        private
-
-        def method_missing(method, *args, &block)
-          if matcher_execution_context.respond_to?(method)
-            matcher_execution_context.send method, *args, &block
-          else
-            super(method, *args, &block)
-          end
-        end
-
-        def include(*args)
-          singleton_class.__send__(:include, *args)
-        end
-
-        def define_method(name, &block)
-          singleton_class.__send__(:define_method, name, &block)
-        end
-
-        def making_declared_methods_public
-          # 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 RSpec::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
-          (private_methods - orig_private_methods).each {|m| singleton_class.__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)
-          if @messages.has_key?(key)
-            @messages[key].arity == 1 ? @messages[key].call(@actual) : @messages[key].call
-          else
-            send("default_#{key}")
-          end
-        end
-
-        def default_description
-          "#{name_to_sentence}#{expected_to_sentence}"
-        end
-
-        def default_failure_message_for_should
-          "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
-        end
-
-        def default_failure_message_for_should_not
-          "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
-        end
-
-        unless method_defined?(:singleton_class)
-          def singleton_class
-            class << self; self; end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/rspec/matchers/method_missing.rb

@@ -1,12 +0,0 @@
-module RSpec
-  module Matchers
-
-    private
-
-    def method_missing(method, *args, &block)
-      return Matchers::BuiltIn::BePredicate.new(method, *args, &block) if method.to_s =~ /^be_/
-      return Matchers::BuiltIn::Has.new(method, *args, &block) if method.to_s =~ /^have_/
-      super
-    end
-  end
-end

data/lib/rspec/matchers/operator_matcher.rb

@@ -1,84 +0,0 @@
-module RSpec
-  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)
-          registry[klass] && registry[klass][operator]
-        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(::RSpec::Matchers.last_should, matcher.new(expected))
-          else
-            eval_match(@actual, operator, expected)
-          end
-        end
-
-        negative_operator = operator.sub(/^=/, '!')
-        if negative_operator != operator && respond_to?(negative_operator)
-          define_method(negative_operator) do |expected|
-            opposite_should = ::RSpec::Matchers.last_should == :should ? :should_not : :should
-            raise "RSpec does not support `#{::RSpec::Matchers.last_should} #{negative_operator} expected`.  " +
-              "Use `#{opposite_should} #{operator} expected` instead."
-          end
-        end
-      end
-
-      ['==', '===', '=~', '>', '>=', '<', '<='].each do |operator|
-        use_custom_matcher_or_delegate operator
-      end
-
-      def fail_with_message(message)
-        RSpec::Expectations.fail_with(message, @expected, @actual)
-      end
-
-      def description
-        "#{@operator} #{@expected.inspect}"
-      end
-
-      private
-
-      def eval_match(actual, operator, expected)
-        ::RSpec::Matchers.last_matcher = self
-        @operator, @expected = operator, expected
-        __delegate_operator(actual, operator, expected)
-      end
-    end
-
-    module BuiltIn
-      class PositiveOperatorMatcher < OperatorMatcher
-        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
-        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
-end

data/lib/rspec/matchers/pretty.rb

@@ -1,60 +0,0 @@
-module RSpec
-  module Matchers
-    module Pretty
-      def split_words(sym)
-        sym.to_s.gsub(/_/,' ')
-      end
-
-      def to_sentence(words)
-        return "" unless words
-        words = Array(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
-
-      def name_to_sentence
-        split_words(name)
-      end
-
-      def expected_to_sentence
-        to_sentence(@expected) if defined?(@expected)
-      end
-
-      def name
-        defined?(@name) ? @name : underscore(self.class.name.split("::").last)
-      end
-
-      # Borrowed from ActiveSupport
-      def underscore(camel_cased_word)
-        word = camel_cased_word.to_s.dup
-        word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-        word.tr!("-", "_")
-        word.downcase!
-        word
-      end
-    end
-  end
-end

data/lib/rspec-expectations.rb

@@ -1 +0,0 @@
-require "rspec/expectations"

data/spec/rspec/expectations/differ_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-require 'ostruct'
-
-module RSpec
-  module Expectations
-    describe Differ do
-      let(:differ) { RSpec::Expectations::Differ.new }
-
-      describe '#diff_as_string' do
-        it "outputs unified diff of two strings" do
-          expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
-          actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
-          expected_diff= <<'EOD'
-
-
-@@ -1,6 +1,6 @@
- foo
--zap
- bar
-+zap
- this
- is
- soo
-@@ -9,6 +9,5 @@
- equal
- insert
- a
--another
- line
-EOD
-
-          diff = differ.diff_as_string(expected, actual)
-          diff.should eql(expected_diff)
-        end
-      end
-
-      describe '#diff_as_object' do
-        it "outputs unified diff message of two objects" do
-          animal_class = Class.new do
-            def initialize(name, species)
-              @name, @species = name, species
-            end
-
-            def inspect
-              <<-EOA
-<Animal
-  name=#{@name},
-  species=#{@species}
->
-              EOA
-            end
-          end
-
-          expected = animal_class.new "bob", "giraffe"
-          actual   = animal_class.new "bob", "tortoise"
-
-          expected_diff = <<'EOD'
-
-@@ -1,5 +1,5 @@
- <Animal
-   name=bob,
--  species=tortoise
-+  species=giraffe
- >
-EOD
-
-          diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
-        end
-
-        it "outputs a message if the diff is empty" do
-          diff = differ.diff_as_object('foo', 'foo')
-          diff.should eq(
-            "foo.==(foo) returned false even though the diff between " \
-            "foo and foo is empty. Check the implementation of foo.==."
-          )
-        end
-
-        it "outputs unified diff message of two arrays" do
-          expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
-          actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
-
-          expected_diff = <<'EOD'
-
-
-@@ -5,7 +5,7 @@
-  :metasyntactic,
-  "variable",
-  :delta,
-- "tango",
-+ "charlie",
-  :width,
-- "very wide"]
-+ "quite wide"]
-EOD
-
-          diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
-        end
-
-        it "outputs unified diff message of two hashes" do
-          expected = { :foo => 'bar', :baz => 'quux', :metasyntactic => 'variable', :delta => 'charlie', :width =>'quite wide' }
-          actual   = { :foo => 'bar', :metasyntactic => 'variable', :delta => 'charlotte', :width =>'quite wide' }
-
-          expected_diff = <<'EOD'
-
-@@ -1,4 +1,5 @@
--:delta => "charlotte",
-+:baz => "quux",
-+:delta => "charlie",
- :foo => "bar",
- :metasyntactic => "variable",
- :width => "quite wide"
-EOD
-
-          diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
-        end
-
-        it "outputs unified diff of single line strings" do
-          expected = "this is one string"
-          actual   = "this is another string"
-
-          expected_diff = <<'EOD'
-
-@@ -1,2 +1,2 @@
--"this is another string"
-+"this is one string"
-EOD
-
-          diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
-        end
-
-        it "outputs unified diff of multi line strings" do
-          expected = "this is:\n  one string"
-          actual   = "this is:\n  another string"
-
-          expected_diff = <<'EOD'
-
-@@ -1,3 +1,3 @@
- this is:
--  another string
-+  one string
-EOD
-
-          diff = differ.diff_as_object(expected,actual)
-          diff.should == expected_diff
-        end
-      end
-    end
-  end
-end

data/spec/rspec/expectations/expectation_target_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Expectations
-    # so our examples below can set expectations about the target
-    ExpectationTarget.send(:attr_reader, :target)
-
-    describe ExpectationTarget do
-      context 'when constructed via #expect' do
-        it 'constructs a new instance targetting the given argument' do
-          expect(7).target.should eq(7)
-        end
-
-        it 'constructs a new instance targetting the given block' do
-          block = lambda {}
-          expect(&block).target.should be(block)
-        end
-
-        it 'raises an ArgumentError when given an argument and a block' do
-          lambda { expect(7) { } }.should raise_error(ArgumentError)
-        end
-
-        it 'raises an ArgumentError when given neither an argument nor a block' do
-          lambda { expect }.should raise_error(ArgumentError)
-        end
-
-        it 'can be passed nil' do
-          expect(nil).target.should be_nil
-        end
-
-        it 'passes a valid positive expectation' do
-          expect(5).to eq(5)
-        end
-
-        it 'passes a valid negative expectation' do
-          expect(5).to_not eq(4)
-          expect(5).not_to eq(4)
-        end
-
-        it 'fails an invalid positive expectation' do
-          lambda { expect(5).to eq(4) }.should fail_with(/expected: 4.*got: 5/m)
-        end
-
-        it 'fails an invalid negative expectation' do
-          message = /expected 5 not to be a kind of Fixnum/
-          lambda { expect(5).to_not be_a(Fixnum) }.should fail_with(message)
-          lambda { expect(5).not_to be_a(Fixnum) }.should fail_with(message)
-        end
-
-        it 'does not support operator matchers from #to' do
-          expect {
-            expect(3).to == 3
-          }.to raise_error(ArgumentError)
-        end
-
-        it 'does not support operator matchers from #not_to' do
-          expect {
-            expect(3).not_to == 4
-          }.to raise_error(ArgumentError)
-        end
-      end
-    end
-  end
-end
-