rspec-expectations 3.0.0.beta1 → 3.0.0.beta2

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,99 +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 unregister(klass, operator)
-          registry[klass] && registry[klass].delete(operator)
-        end
-
-        def get(klass, operator)
-          klass.ancestors.each { |ancestor|
-            matcher = registry[ancestor] && registry[ancestor][operator]
-            return matcher if matcher
-          }
-
-          nil
-        end
-      end
-
-      def initialize(actual)
-        @actual = actual
-      end
-
-      def self.use_custom_matcher_or_delegate(operator)
-        define_method(operator) do |expected|
-          if uses_generic_implementation_of?(operator) && 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 uses_generic_implementation_of?(op)
-        Expectations.method_handle_for(@actual, op).owner == ::Kernel
-      rescue NameError
-        false
-      end
-
-      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/test_unit_integration.rb

@@ -1,11 +0,0 @@
-# Include Matchers for other test frameworks.  Note that MiniTest _must_
-# come before TU because on ruby 1.9, T::U::TC is a subclass of MT::U::TC
-# and a 1.9 bug can lead to infinite recursion from the `super` call in our
-# method_missing hook.  See this gist for more info:
-# https://gist.github.com/845896
-if defined?(MiniTest::Unit::TestCase)
-  MiniTest::Unit::TestCase.send(:include, RSpec::Matchers)
-end
-if defined?(Test::Unit::TestCase)
-  Test::Unit::TestCase.send(:include, RSpec::Matchers)
-end

data/spec/rspec/matchers/eq_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Matchers
-    describe "eq" do
-      it_behaves_like "an RSpec matcher", :valid_value => 1, :invalid_value => 2 do
-        let(:matcher) { eq(1) }
-      end
-
-      it "is diffable" do
-        expect(eq(1)).to be_diffable
-      end
-
-      it "matches when actual == expected" do
-        expect(1).to eq(1)
-      end
-
-      it "does not match when actual != expected" do
-        expect(1).not_to eq(2)
-      end
-
-      it "compares by sending == to actual (not expected)" do
-        called = false
-        actual = Class.new do
-          define_method :== do |other|
-            called = true
-          end
-        end.new
-
-        expect(actual).to eq :anything # to trigger the matches? method
-        expect(called).to be_truthy
-      end
-
-      it "describes itself" do
-        matcher = eq(1)
-        matcher.matches?(1)
-        expect(matcher.description).to eq "eq 1"
-      end
-
-      it "provides message, expected and actual on #failure_message" do
-        matcher = eq("1")
-        matcher.matches?(1)
-        expect(matcher.failure_message_for_should).to eq "\nexpected: \"1\"\n     got: 1\n\n(compared using ==)\n"
-      end
-
-      it "provides message, expected and actual on #negative_failure_message" do
-        matcher = eq(1)
-        matcher.matches?(1)
-        expect(matcher.failure_message_for_should_not).to eq "\nexpected: value != 1\n     got: 1\n\n(compared using ==)\n"
-      end
-
-      it 'fails properly when the actual is an array of multiline strings' do
-        expect {
-          expect(["a\nb", "c\nd"]).to eq([])
-        }.to fail_matching("expected: []")
-      end
-    end
-  end
-end
-

data/spec/rspec/matchers/equal_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-module RSpec
-  module Matchers
-    describe "equal" do
-      it_behaves_like "an RSpec matcher", :valid_value => :a, :invalid_value => :b do
-        let(:matcher) { equal(:a) }
-      end
-
-      def inspect_object(o)
-        "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
-      end
-
-      it "matches when actual.equal?(expected)" do
-        expect(1).to equal(1)
-      end
-
-      it "does not match when !actual.equal?(expected)" do
-        expect("1").not_to equal("1")
-      end
-
-      it "describes itself" do
-        matcher = equal(1)
-        matcher.matches?(1)
-        expect(matcher.description).to eq "equal 1"
-      end
-
-      it "suggests the `eq` matcher on failure" do
-        expected, actual = "1", "1"
-        expect {
-          expect(actual).to equal(expected)
-        }.to fail_with <<-MESSAGE
-
-expected #{inspect_object(expected)}
-     got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity,
-but expected and actual are not the same object. Use
-`expect(actual).to eq(expected)` if you don't care about
-object identity in this example.
-
-MESSAGE
-      end
-
-      context "when using only `should`", :uses_only_should do
-        it "suggests the `eq` matcher on failure" do
-          expected, actual = "1", "1"
-          lambda {
-            actual.should equal(expected)
-          }.should fail_with <<-MESSAGE
-
-expected #{inspect_object(expected)}
-     got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity,
-but expected and actual are not the same object. Use
-`actual.should eq(expected)` if you don't care about
-object identity in this example.
-
-MESSAGE
-        end
-      end
-
-      it "provides message on #negative_failure_message" do
-        expected = actual = "1"
-        matcher = equal(expected)
-        matcher.matches?(actual)
-        expect(matcher.failure_message_for_should_not).to eq <<-MESSAGE
-
-expected not #{inspect_object(expected)}
-         got #{inspect_object(actual)}
-
-Compared using equal?, which compares object identity.
-
-MESSAGE
-      end
-    end
-  end
-end

data/spec/rspec/matchers/include_matcher_integration_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Matchers
-    describe "include() interaction with built-in matchers" do
-      it "works with be_within(delta).of(expected)" do
-        expect([10, 20, 30]).to include( be_within(5).of(24) )
-        expect([10, 20, 30]).not_to include( be_within(3).of(24) )
-      end
-
-      it "works with be_instance_of(klass)" do
-        expect(["foo", 123, {:foo => "bar"}]).to include( be_instance_of(Hash) )
-        expect(["foo", 123, {:foo => "bar"}]).not_to include( be_instance_of(Range) )
-      end
-
-      it "works with be_kind_of(klass)" do
-        class StringSubclass < String; end
-        class NotHashSubclass; end
-
-        expect([StringSubclass.new("baz")]).to include( be_kind_of(String) )
-        expect([NotHashSubclass.new]).not_to include( be_kind_of(Hash) )
-      end
-
-      it "works with be_[some predicate]" do
-        expect([double("actual", :happy? => true)]).to include( be_happy )
-        expect([double("actual", :happy? => false)]).not_to include( be_happy )
-      end
-    end
-  end
-end

data/spec/rspec/matchers/match_array_spec.rb

@@ -1,194 +0,0 @@
-require 'spec_helper'
-
-class UnsortableObject
-  def initialize(id)
-    @id = id
-  end
-
-  def inspect
-    @id.to_s
-  end
-
-  def ==(other)
-    false
-  end
-end
-
-describe "should =~ array", :uses_should do
-  it "passes a valid positive expectation" do
-    [1, 2].should =~ [2, 1]
-  end
-
-  it "fails an invalid positive expectation" do
-    expect {
-      [1, 2, 3].should =~ [2, 1]
-    }.to fail_with(/expected collection contained/)
-  end
-
-  context "when the array defines a `=~` method" do
-    it 'delegates to that method rather than using the match_array matcher' do
-      array = []
-      def array.=~(other)
-        other == :foo
-      end
-
-      array.should =~ :foo
-      expect {
-        array.should =~ :bar
-      }.to fail_with(/expected: :bar/)
-    end
-  end
-
-  context 'when the array defines a `send` method' do
-    it 'still works' do
-      array = [1, 2]
-      def array.send; :sent; end
-
-      array.should =~ array
-    end
-  end
-end
-
-describe "should_not =~ [:with, :multiple, :args]", :uses_should do
-  it "is not supported" do
-    expect {
-      [1,2,3].should_not =~ [1,2,3]
-    }.to fail_with(/Matcher does not support should_not/)
-  end
-end
-
-describe "using match_array with expect" do
-  it "passes a valid positive expectation" do
-    expect([1, 2]).to match_array [2, 1]
-  end
-
-  it "fails an invalid positive expectation" do
-    expect {
-      expect([1, 2, 3]).to match_array [2, 1]
-    }.to fail_with(/expected collection contained/)
-  end
-end
-
-describe "expect(array).to match_array other_array" do
-  it_behaves_like "an RSpec matcher", :valid_value => [1, 2], :invalid_value => [1] do
-    let(:matcher) { match_array([2, 1]) }
-  end
-
-  it "passes if target contains all items" do
-    expect([1,2,3]).to match_array [1,2,3]
-  end
-
-  it "passes if target contains all items out of order" do
-    expect([1,3,2]).to match_array [1,2,3]
-  end
-
-  it "fails if target includes extra items" do
-    expect {
-      expect([1,2,3,4]).to match_array [1,2,3]
-    }.to fail_with(<<-MESSAGE)
-expected collection contained:  [1, 2, 3]
-actual collection contained:    [1, 2, 3, 4]
-the extra elements were:        [4]
-MESSAGE
-  end
-
-  it "fails if target is missing items" do
-    expect {
-      expect([1,2]).to match_array [1,2,3]
-    }.to fail_with(<<-MESSAGE)
-expected collection contained:  [1, 2, 3]
-actual collection contained:    [1, 2]
-the missing elements were:      [3]
-MESSAGE
-  end
-
-  it "fails if target is missing items and has extra items" do
-    expect {
-      expect([1,2,4]).to match_array [1,2,3]
-    }.to fail_with(<<-MESSAGE)
-expected collection contained:  [1, 2, 3]
-actual collection contained:    [1, 2, 4]
-the missing elements were:      [3]
-the extra elements were:        [4]
-MESSAGE
-  end
-
-  it "sorts items in the error message if they all respond to <=>" do
-    expect {
-      expect([6,2,1,5]).to match_array [4,1,2,3]
-    }.to fail_with(<<-MESSAGE)
-expected collection contained:  [1, 2, 3, 4]
-actual collection contained:    [1, 2, 5, 6]
-the missing elements were:      [3, 4]
-the extra elements were:        [5, 6]
-MESSAGE
-  end
-
-    it "does not sort items in the error message if they don't all respond to <=>" do
-      expect {
-        expect([UnsortableObject.new(2), UnsortableObject.new(1)]).to match_array [UnsortableObject.new(4), UnsortableObject.new(3)]
-      }.to fail_with(<<-MESSAGE)
-expected collection contained:  [4, 3]
-actual collection contained:    [2, 1]
-the missing elements were:      [4, 3]
-the extra elements were:        [2, 1]
-MESSAGE
-    end
-
-  it "accurately reports extra elements when there are duplicates" do
-    expect {
-      expect([1,1,1,5]).to match_array [1,5]
-    }.to fail_with(<<-MESSAGE)
-expected collection contained:  [1, 5]
-actual collection contained:    [1, 1, 1, 5]
-the extra elements were:        [1, 1]
-MESSAGE
-  end
-
-  it "accurately reports missing elements when there are duplicates" do
-    expect {
-      expect([1,5]).to match_array [1,1,5]
-    }.to fail_with(<<-MESSAGE)
-expected collection contained:  [1, 1, 5]
-actual collection contained:    [1, 5]
-the missing elements were:      [1]
-MESSAGE
-  end
-end
-
-describe "expect(...).not_to match_array [:with, :multiple, :args]" do
-  it "is not supported" do
-    expect {
-      expect([1,2,3]).not_to match_array [1,2,3]
-    }.to fail_with(/Matcher does not support should_not/)
-  end
-end
-
-describe "matching against things that aren't arrays" do
-  it "fails with nil and the expected error message is given" do
-    expect {
-      expect(nil).to match_array([1,2,3])
-    }.to fail_with(/expected an array/)
-  end
-
-  it "fails with a float and the expected error message is given" do
-    expect {
-      expect((3.7)).to match_array([1,2,3])
-    }.to fail_with(/expected an array/)
-  end
-
-  it "fails with a string and the expected error message is given" do
-    expect {
-      expect("I like turtles").to match_array([1,2,3])
-    }.to fail_with(/expected an array/)
-  end
-
-  context "when using the `should =~` syntax", :uses_should do
-    it 'fails with a clear message when given a hash' do
-      expect {
-        {}.should =~ {}
-      }.to fail_with(/expected an array/)
-    end
-  end
-end
-