rspec-expectations 3.0.0.beta2 → 3.0.0.rc1

data/lib/rspec/expectations/differ.rb

@@ -1,44 +0,0 @@
-module RSpec
-  module Expectations
-    class Differ
-      def initialize(actual, expected)
-        @actual = actual
-        @expected = expected
-      end
-
-      def hunks
-        @file_length_difference = 0
-        @hunks ||= diffs.map do |piece|
-          build_hunk(piece)
-        end
-      end
-
-    private
-
-      def diffs
-        Diff::LCS.diff(expected_lines, actual_lines)
-      end
-
-      def expected_lines
-        @expected.split("\n").map! { |e| e.chomp }
-      end
-
-      def actual_lines
-        @actual.split("\n").map! { |e| e.chomp }
-      end
-
-      def build_hunk(piece)
-        Diff::LCS::Hunk.new(
-          expected_lines, actual_lines, piece, context_lines, @file_length_difference
-        ).tap do |h|
-          @file_length_difference = h.file_length_difference
-        end
-      end
-
-      def context_lines
-        3
-      end
-
-    end
-  end
-end

data/lib/rspec/expectations/encoded_string.rb

@@ -1,56 +0,0 @@
-require "delegate"
-
-module RSpec
-  module Expectations
-    class EncodedString < SimpleDelegator
-
-      def initialize(string, encoding = nil)
-        @encoding = encoding
-        @source_encoding = detect_source_encoding(string)
-        @string = matching_encoding(string)
-        super(@string)
-      end
-      attr_reader :source_encoding
-
-      def <<(string)
-        @string << matching_encoding(string)
-      end
-
-      def split(regex_or_string)
-        @string.split(matching_encoding(regex_or_string))
-      end
-
-    private
-
-      if String.method_defined?(:encoding)
-        def matching_encoding(string)
-          string.encode(@encoding)
-        rescue Encoding::UndefinedConversionError, Encoding::InvalidByteSequenceError
-          normalize_missing(string.encode(@encoding, :invalid => :replace, :undef => :replace))
-        rescue Encoding::ConverterNotFoundError
-          normalize_missing(string.force_encoding(@encoding).encode(:invalid => :replace))
-        end
-
-        def normalize_missing(string)
-          if @encoding.to_s == "UTF-8"
-            string.gsub("\xEF\xBF\xBD".force_encoding(@encoding), "?")
-          else
-            string
-          end
-        end
-
-        def detect_source_encoding(string)
-          string.encoding
-        end
-      else
-        def matching_encoding(string)
-          string
-        end
-
-        def detect_source_encoding(string)
-          'US-ASCII'
-        end
-      end
-    end
-  end
-end

data/spec/rspec/expectations/diff_presenter_spec.rb

@@ -1,249 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'ostruct'
-
-module RSpec
-  module Expectations
-    describe DiffPresenter do
-      let(:differ) { RSpec::Expectations::DiffPresenter.new }
-      context "without --color" do
-
-      before { allow(RSpec::Matchers.configuration).to receive_messages(:color? => false) }
-
-      describe '#diff_as_string' do
-        subject { differ.diff_as_string(@actual, @expected) }
-
-        it "outputs unified diff of two strings" do
-          @expected = "foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
-          @actual   = "foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
-          expect(subject).to eq(<<-'EOD')
-
-
-@@ -1,6 +1,6 @@
- foo
--zap
- bar
-+zap
- this
- is
- soo
-@@ -9,6 +9,5 @@
- equal
- insert
- a
--another
- line
-EOD
-
-        end
-
-        if String.method_defined?(:encoding)
-          it 'copes with encoded strings' do
-            @expected = "Tu avec carte {count} item has".encode('UTF-16LE')
-            @actual   = "Tu avec carté {count} itém has".encode('UTF-16LE')
-            expect(subject).to eql(<<-EOD.encode('UTF-16LE'))
-
-@@ -1,2 +1,2 @@
--Tu avec carte {count} item has
-+Tu avec carté {count} itém has
-EOD
-          end
-
-          it 'handles differently encoded strings that are compatible' do
-            @expected = "abc".encode('us-ascii')
-            @actual   = "강인철".encode('UTF-8')
-            expect(subject).to eql "\n@@ -1,2 +1,2 @@\n-abc\n+강인철\n"
-          end
-
-          it 'uses the default external encoding when the two strings have incompatible encodings' do
-            @expected = "Tu avec carte {count} item has"
-            @actual   = "Tu avec carté {count} itém has".encode('UTF-16LE')
-            expect(subject).to eq("\n@@ -1,2 +1,2 @@\n-Tu avec carte {count} item has\n+Tu avec carté {count} itém has\n")
-            expect(subject.encoding).to eq(Encoding.default_external)
-          end
-
-          it 'handles any encoding error that occurs with a helpful error message' do
-            expect(Differ).to receive(:new).and_raise(Encoding::CompatibilityError)
-            @expected = "Tu avec carte {count} item has".encode('us-ascii')
-            @actual   = "Tu avec carté {count} itém has"
-            expect(subject).to match(/Could not produce a diff/)
-            expect(subject).to match(/actual string \(UTF-8\)/)
-            expect(subject).to match(/expected string \(US-ASCII\)/)
-          end
-        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)
-          expect(diff).to eq expected_diff
-        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)
-          expect(diff).to eq 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)
-          expect(diff).to eq expected_diff
-        end
-
-        it 'outputs unified diff message of two hashes with differing encoding' do
-          expected_diff = %Q{
-@@ -1,2 +1,2 @@
--"a" => "a",
-#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+"ö" => "ö"} : '+"\303\266" => "\303\266"' },
-}
-
-          diff = differ.diff_as_object({'ö' => 'ö'}, {'a' => 'a'})
-          expect(diff).to eq expected_diff
-        end
-
-        it 'outputs unified diff message of two hashes with encoding different to key encoding' do
-          expected_diff = %Q{
-@@ -1,2 +1,2 @@
--:a => "a",
-#{ (RUBY_VERSION.to_f > 1.8) ?  %Q{+\"한글\" => \"한글2\"} : '+"\355\225\234\352\270\200" => "\355\225\234\352\270\2002"' },
-}
-
-          diff = differ.diff_as_object({ "한글" => "한글2"}, { :a => "a"})
-          expect(diff).to eq expected_diff
-        end
-
-        it "outputs unified diff message of two hashes with object keys" do
-          expected_diff = %Q{
-@@ -1,2 +1,2 @@
--["a", "c"] => "b",
-+["d", "c"] => "b",
-}
-
-          diff = differ.diff_as_object({ ['d','c'] => 'b'}, { ['a','c'] => 'b' })
-          expect(diff).to eq 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)
-          expect(diff).to eq 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)
-          expect(diff).to eq expected_diff
-        end
-
-        it "uses matcher descriptions in place of matchers in diffs" do
-          expected = [a_string_matching(/foo/), a_string_matching(/bar/)]
-          actual   = ["poo", "car"]
-
-          expected_diff = dedent(<<-EOS)
-            |
-            |@@ -1,2 +1,2 @@
-            |-["poo", "car"]
-            |+[(a string matching /foo/), (a string matching /bar/)]
-            |
-          EOS
-
-          diff = differ.diff_as_object(expected,actual)
-          expect(diff).to eq expected_diff
-        end
-      end
-    end
-
-    context "with --color" do
-      before { allow(RSpec::Matchers.configuration).to receive_messages(:color? => true) }
-
-      it "outputs colored diffs" do
-        expected = "foo bar baz"
-        actual = "foo bang baz"
-        expected_diff = "\e[0m\n\e[0m\e[34m@@ -1,2 +1,2 @@\n\e[0m\e[31m-foo bang baz\n\e[0m\e[32m+foo bar baz\n\e[0m"
-
-
-        diff = differ.diff_as_string(expected,actual)
-        expect(diff).to eq expected_diff
-      end
-    end
-
-    end
-  end
-end

data/spec/rspec/expectations/encoded_string_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Expectations
-  describe EncodedString do
-    let(:target_encoding) { 'UTF-8' }
-
-    if String.method_defined?(:encoding)
-
-      describe '#source_encoding' do
-        it 'knows the original encoding of the string' do
-          str = EncodedString.new("abc".encode('ASCII-8BIT'), "UTF-8")
-          expect( str.source_encoding.to_s ).to eq('ASCII-8BIT')
-        end
-      end
-
-      describe '#<<' do
-        context 'with strings that can be converted to the target encoding' do
-          it 'encodes and appends the string' do
-            valid_ascii_string = "abc".force_encoding("ASCII-8BIT")
-            valid_unicode_string = "\xE2\x82\xAC".force_encoding('UTF-8')
-
-            resulting_string = build_encoded_string(valid_unicode_string, target_encoding) << valid_ascii_string
-            expect(resulting_string).to eq "\xE2\x82\xACabc".force_encoding('UTF-8')
-          end
-        end
-
-        context 'with a string that cannot be converted to the target encoding' do
-          it 'replaces undefined characters with either a ? or a unicode ?' do
-            ascii_string = "\xAE".force_encoding("ASCII-8BIT")
-            valid_unicode_string = "\xE2\x82\xAC".force_encoding('UTF-8')
-
-            resulting_string = build_encoded_string(valid_unicode_string, target_encoding) << ascii_string
-            expected_bytes = [226, 130, 172, "?".unpack("c").first]
-            actual_bytes = resulting_string.each_byte.to_a
-
-            expect(actual_bytes).to eq(expected_bytes)
-          end
-        end
-
-        context 'with two ascii strings with a target encoding of UTF-8 ' do
-          it 'has an encoding of UTF-8' do
-            ascii_string = 'abc'.force_encoding("ASCII-8BIT")
-            other_ascii_string = '123'.force_encoding("ASCII-8BIT")
-
-            resulting_string = build_encoded_string(ascii_string, target_encoding) << other_ascii_string
-            expect(resulting_string.encoding.to_s).to eq 'UTF-8'
-          end
-        end
-      end
-
-      describe '#split' do
-        it 'splits the string based on the delimiter accounting for encoding' do
-          wrapped_string = "aaaaaaaaaaa\xAEaaaaa".force_encoding("ASCII-8BIT")
-
-          expect {
-            build_encoded_string(wrapped_string, target_encoding).split("\xE2\x82\xAC".force_encoding("UTF-8"))
-          }.not_to raise_error
-        end
-      end
-
-      def build_encoded_string(string, target_encoding)
-        EncodedString.new(string, target_encoding)
-      end
-    else
-
-      describe '#source_encoding' do
-        it 'defaults to US-ASCII' do
-          str = EncodedString.new("abc", "UTF-8")
-          expect( str.source_encoding ).to eq('US-ASCII')
-        end
-      end
-    end
-  end
-end

data/spec/rspec/expectations/expectation_target_spec.rb

@@ -1,82 +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(expect(7).target).to eq(7)
-        end
-
-        it 'constructs a new instance targetting the given block' do
-          block = lambda {}
-          expect(expect(&block).target).to be(block)
-        end
-
-        it 'raises an ArgumentError when given an argument and a block' do
-          expect {
-            expect(7) { }
-          }.to raise_error(ArgumentError)
-        end
-
-        it 'raises an ArgumentError when given neither an argument nor a block' do
-          expect {
-            expect
-          }.to raise_error(ArgumentError)
-        end
-
-        it 'can be passed nil' do
-          expect(expect(nil).target).to 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).not_to eq(4)
-        end
-
-        it 'passes a valid negative expectation with a split infinitive' do
-          expect(5).to_not eq(4)
-        end
-
-        it 'fails an invalid positive expectation' do
-          expect {
-            expect(5).to eq(4)
-          }.to 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/
-          expect {
-            expect(5).not_to be_a(Fixnum)
-          }.to fail_with(message)
-        end
-
-        it 'fails an invalid negative expectation with a split infinitive' do
-          message = /expected 5 not to be a kind of Fixnum/
-          expect {
-            expect(5).to_not be_a(Fixnum)
-          }.to 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
-