rspec-expectations 3.0.0.beta2 → 3.0.0.rc1

data/features/custom_matchers/define_matcher_outside_rspec.feature

@@ -1,34 +0,0 @@
-Feature: define matcher outside rspec
-
-  In order to express my domain clearly in my code examples
-  As a non-rspec user
-  I want a shortcut to define custom matchers
-
-  Scenario: define a matcher with default messages
-    Given a file named "test_multiples.rb" with:
-      """ruby
-      require "minitest/autorun"
-      require "rspec/expectations/minitest_integration"
-
-      RSpec::Matchers.define :be_a_multiple_of do |expected|
-        match do |actual|
-          actual % expected == 0
-        end
-      end
-
-      class TestMultiples < Minitest::Test
-
-        def test_9_should_be_a_multiple_of_3
-          expect(9).to be_a_multiple_of(3)
-        end
-
-        def test_9_should_be_a_multiple_of_4
-          expect(9).to be_a_multiple_of(4)
-        end
-
-      end
-      """
-    When I run `ruby test_multiples.rb`
-    Then the exit status should not be 0
-    And the output should contain "expected 9 to be a multiple of 4"
-    And the output should contain "2 runs, 2 assertions, 1 failures, 0 errors"

data/features/custom_matchers/define_matcher_with_fluent_interface.feature

@@ -1,24 +0,0 @@
-Feature: define matcher with fluent interface
-
-  Use the chain() method to define matchers with a fluent interface.
-
-  Scenario: chained method with argument
-    Given a file named "between_spec.rb" with:
-      """ruby
-      RSpec::Matchers.define :be_bigger_than do |first|
-        match do |actual|
-          (actual > first) && (actual < @second)
-        end
-
-        chain :but_smaller_than do |second|
-          @second = second
-        end
-      end
-
-      describe 5 do
-        it { should be_bigger_than(4).but_smaller_than(6) }
-      end
-      """
-    When I run `rspec between_spec.rb --format documentation`
-    Then the output should contain "1 example, 0 failures"
-    And  the output should contain "should be bigger than 4"

data/features/customized_message.feature

@@ -1,39 +0,0 @@
-Feature: customized message
-
-  RSpec tries to provide useful failure messages, but for cases in which you
-  want more specific information, you can define your own message right in the
-  example. This works for any matcher _other than the operator matchers_.
-
-  Scenario: customize failure message
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe Array do
-        context "when created with `new`" do
-          it "is empty" do
-            array = Array.new
-            array << 1 # trigger a failure to demonstrate the message
-            expect(array).to be_empty, "expected empty array, got #{array.inspect}"
-          end
-        end
-      end
-
-      """
-    When I run `rspec example_spec.rb --format documentation`
-    Then the output should contain "expected empty array, got [1]"
-
-  Scenario: customize failure message with a proc
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe Array do
-        context "when created with `new`" do
-          it "is empty" do
-            array = Array.new
-            array << 1 # trigger a failure to demonstrate the message
-            expect(array).to be_empty, lambda { "expected empty array, got #{array.inspect}" }
-          end
-        end
-      end
-
-      """
-    When I run `rspec example_spec.rb --format documentation`
-    Then the output should contain "expected empty array, got [1]"

data/features/diffing.feature

@@ -1,85 +0,0 @@
-Feature: diffing
-
-  When appropriate, failure messages will automatically include a diff.
-
-  Scenario: diff for a multiline string
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a multiline string" do
-        it "is like another string" do
-          expected = <<-EXPECTED
-      this is the
-        expected
-          string
-      EXPECTED
-          actual = <<-ACTUAL
-      this is the
-        actual
-          string
-      ACTUAL
-          expect(actual).to eq(expected)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain:
-      """
-             Diff:
-             @@ -1,4 +1,4 @@
-              this is the
-             -  expected
-             +  actual
-                  string
-      """
-
-  Scenario: diff for a multiline string and a regexp
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a multiline string" do
-        it "is like another string" do
-          expected = /expected/m
-          actual = <<-ACTUAL
-      this is the
-        actual
-          string
-      ACTUAL
-          expect(actual).to match expected
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should contain:
-      """
-             Diff:
-             @@ -1,2 +1,4 @@
-             -/expected/m
-             +this is the
-             +  actual
-             +    string
-      """
-
-  Scenario: no diff for a single line strings
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a single line string" do
-        it "is like another string" do
-          expected = "this string"
-          actual   = "that string"
-          expect(actual).to eq(expected)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should not contain "Diff:"
-
-  Scenario: no diff for numbers
-    Given a file named "example_spec.rb" with:
-      """ruby
-      describe "a number" do
-        it "is like another number" do
-          expect(1).to eq(2)
-        end
-      end
-      """
-    When I run `rspec example_spec.rb`
-    Then the output should not contain "Diff:"

data/features/implicit_docstrings.feature

@@ -1,52 +0,0 @@
-Feature: implicit docstrings
-
-  As an RSpec user
-  I want examples to generate their own names
-  So that I can reduce duplication between example names and example code
-
-  Scenario: run passing examples
-    Given a file named "implicit_docstrings_spec.rb" with:
-    """ruby
-    describe "Examples with no docstrings generate their own:" do
-
-      specify { expect(3).to be < 5 }
-
-      specify { expect([1,2,3]).to include(2) }
-
-      specify { expect([1,2,3]).to respond_to(:size) }
-
-    end
-    """
-
-    When I run `rspec ./implicit_docstrings_spec.rb -fdoc`
-
-    Then the output should contain "should be < 5"
-    And the output should contain "should include 2"
-    And the output should contain "should respond to #size"
-
-  Scenario: run failing examples
-    Given a file named "failing_implicit_docstrings_spec.rb" with:
-    """ruby
-    describe "Failing examples with no descriptions" do
-
-      # description is auto-generated as "to equal(5)" based on the last #expect
-      it do
-        expect(3).to equal(2)
-        expect(5).to equal(5)
-      end
-
-      it { expect(3).to be > 5 }
-
-      it { expect([1,2,3]).to include(4) }
-
-      it { expect([1,2,3]).not_to respond_to(:size) }
-
-    end
-    """
-
-    When I run `rspec ./failing_implicit_docstrings_spec.rb -fdoc`
-
-    Then the output should contain "should equal 2"
-    And the output should contain "should be > 5"
-    And the output should contain "should include 4"
-    And the output should contain "should not respond to #size"

data/features/step_definitions/additional_cli_steps.rb

@@ -1,22 +0,0 @@
-# Useful for when the output is slightly different on different versions of ruby
-Then /^the output should contain "([^"]*)" or "([^"]*)"$/ do |string1, string2|
-  unless [string1, string2].any? { |s| all_output =~ regexp(s) }
-    fail %Q{Neither "#{string1}" or "#{string2}" were found in:\n#{all_output}}
-  end
-end
-
-Then /^the output should contain all of these:$/ do |table|
-  table.raw.flatten.each do |string|
-    assert_partial_output(string, all_output)
-  end
-end
-
-Then /^the example(?:s)? should(?: all)? pass$/ do
-  step %q{the output should contain "0 failures"}
-  step %q{the exit status should be 0}
-end
-
-Then /^the example should fail$/ do
-  step %q{the output should contain "1 failure"}
-  step %q{the exit status should not be 0}
-end

data/features/support/env.rb

@@ -1,21 +0,0 @@
-require 'aruba/cucumber'
-
-Before do
-  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
-    @aruba_timeout_seconds = 60
-  else
-    @aruba_timeout_seconds = 10
-  end
-end
-
-Aruba.configure do |config|
-  config.before_cmd do |cmd|
-    set_env('JRUBY_OPTS', "-X-C #{ENV['JRUBY_OPTS']}") # disable JIT since these processes are so short lived
-  end
-end if RUBY_PLATFORM == 'java'
-
-Aruba.configure do |config|
-  config.before_cmd do |cmd|
-    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
-  end
-end if defined?(Rubinius)

data/features/support/rubinius.rb

@@ -1,6 +0,0 @@
-# Required until https://github.com/rubinius/rubinius/issues/2430 is resolved
-ENV['RBXOPT'] = "#{ENV["RBXOPT"]} -Xcompiler.no_rbc"
-
-Around "@unsupported-on-rbx" do |scenario, block|
-  block.call unless defined?(Rubinius)
-end

data/features/syntax_configuration.feature

@@ -1,71 +0,0 @@
-Feature: Syntax Configuration
-
-  In addition to the long-supported `should` syntax, rspec-expectations
-  supports an alternate `expect` syntax. If you want your project to
-  only use one syntax, you can configure the available syntaxes.
-
-  Background:
-    Given a file named "syntaxes_spec.rb" with:
-      """ruby
-      describe "using the should syntax" do
-        specify { 3.should eq(3) }
-        specify { 3.should_not eq(4) }
-        specify { lambda { raise "boom" }.should raise_error("boom") }
-        specify { lambda { }.should_not raise_error }
-      end
-
-      describe "using the expect syntax" do
-        specify { expect(3).to eq(3) }
-        specify { expect(3).not_to eq(4) }
-        specify { expect { raise "boom" }.to raise_error("boom") }
-        specify { expect { }.not_to raise_error }
-      end
-      """
-
-  Scenario: Both syntaxes are available by default
-    When I run `rspec syntaxes_spec.rb`
-    Then the examples should all pass
-
-  Scenario: Disable should syntax
-    Given a file named "disable_should_syntax.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec do |c|
-          c.syntax = :expect
-        end
-      end
-      """
-    When I run `rspec disable_should_syntax.rb syntaxes_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures    |
-      | undefined method `should' |
-
-  Scenario: Disable expect syntax
-    Given a file named "disable_expect_syntax.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec do |c|
-          c.syntax = :should
-        end
-        config.mock_with :rspec do |c|
-          c.syntax = :should
-        end
-      end
-      """
-    When I run `rspec disable_expect_syntax.rb syntaxes_spec.rb`
-    Then the output should contain all of these:
-      | 8 examples, 4 failures    |
-      | undefined method `expect' |
-
-  Scenario: Explicitly enable both syntaxes
-    Given a file named "enable_both_syntaxes.rb" with:
-      """ruby
-      RSpec.configure do |config|
-        config.expect_with :rspec do |c|
-          c.syntax = [:should, :expect]
-        end
-      end
-      """
-    When I run `rspec enable_both_syntaxes.rb syntaxes_spec.rb`
-    Then the examples should all pass
-

data/features/test_frameworks/minitest.feature

@@ -1,44 +0,0 @@
-Feature: Minitest integration
-
-  rspec-expectations is a stand-alone gem that can be used without the rest of
-  RSpec. If you like minitest as your test runner, but prefer RSpec's
-  approach to expressing expectations, you can have both.
-
-  To integrate rspec-expectations with minitest, require `rspec/expectations/minitest_integration`.
-
-  Scenario: use rspec/expectations with minitest
-    Given a file named "rspec_expectations_test.rb" with:
-      """ruby
-      require 'minitest/autorun'
-      require 'rspec/expectations/minitest_integration'
-
-      class RSpecExpectationsTest < Minitest::Test
-        RSpec::Matchers.define :be_an_integer do
-          match { |actual| Integer === actual }
-        end
-
-        def be_an_int
-          # This is actually an internal rspec-expectations API, but is used
-          # here to demonstrate that deprecation warnings from within
-          # rspec-expectations work correcty without depending on rspec-core
-          RSpec.deprecate(:be_an_int, :replacement => :be_an_integer)
-          be_an_integer
-        end
-
-        def test_passing_expectation
-          expect(1 + 3).to eq 4
-        end
-
-        def test_failing_expectation
-          expect([1, 2]).to be_empty
-        end
-
-        def test_custom_matcher_with_deprecation_warning
-          expect(1).to be_an_int
-        end
-      end
-      """
-     When I run `ruby rspec_expectations_test.rb`
-     Then the output should contain "3 runs, 3 assertions, 1 failures, 0 errors"
-      And the output should contain "expected empty? to return true, got false"
-      And the output should contain "be_an_int is deprecated"

data/lib/rspec-expectations.rb

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

data/lib/rspec/expectations/diff_presenter.rb

@@ -1,141 +0,0 @@
-require 'diff/lcs'
-require "rspec/expectations/encoded_string"
-require "rspec/expectations/differ"
-require 'diff/lcs/hunk'
-require 'pp'
-
-module RSpec
-  module Expectations
-    class DiffPresenter
-      def diff_as_string(actual, expected)
-        @encoding = pick_encoding actual, expected
-
-        @actual   = EncodedString.new(actual, @encoding)
-        @expected = EncodedString.new(expected, @encoding)
-
-        output = EncodedString.new("\n", @encoding)
-
-        hunks.each_cons(2) do |prev_hunk, current_hunk|
-          begin
-            if current_hunk.overlaps?(prev_hunk)
-              add_old_hunk_to_hunk(current_hunk, prev_hunk)
-            else
-              add_to_output(output, prev_hunk.diff(format).to_s)
-            end
-          ensure
-            add_to_output(output, "\n")
-          end
-        end
-
-        if hunks.last
-          finalize_output(output, hunks.last.diff(format).to_s)
-        end
-
-        color_diff output
-      rescue Encoding::CompatibilityError
-        handle_encoding_errors
-      end
-
-      def diff_as_object(actual, expected)
-        actual_as_string = object_to_string(actual)
-        expected_as_string = object_to_string(expected)
-        diff_as_string(actual_as_string, expected_as_string)
-      end
-
-    private
-
-      def hunks
-        @hunks ||= Differ.new(@actual, @expected).hunks
-      end
-
-      def finalize_output(output, final_line)
-        add_to_output(output, final_line)
-        add_to_output(output, "\n")
-      end
-
-      def add_to_output(output, string)
-        output << string
-      end
-
-      def add_old_hunk_to_hunk(hunk, oldhunk)
-        hunk.merge(oldhunk)
-      end
-
-      def format
-        :unified
-      end
-
-      def color(text, color_code)
-        "\e[#{color_code}m#{text}\e[0m"
-      end
-
-      def red(text)
-        color(text, 31)
-      end
-
-      def green(text)
-        color(text, 32)
-      end
-
-      def blue(text)
-        color(text, 34)
-      end
-
-      def normal(text)
-        color(text, 0)
-      end
-
-      def color_diff(diff)
-        return diff unless RSpec::Matchers.configuration.color?
-
-        diff.lines.map { |line|
-          case line[0].chr
-          when "+"
-            green line
-          when "-"
-            red line
-          when "@"
-            line[1].chr == "@" ? blue(line) : normal(line)
-          else
-            normal(line)
-          end
-        }.join
-      end
-
-      def object_to_string(object)
-        object = Matchers::Composable.surface_descriptions_in(object)
-        case object
-        when Hash
-          object.keys.sort_by { |k| k.to_s }.map do |key|
-            pp_key   = PP.singleline_pp(key, "")
-            pp_value = PP.singleline_pp(object[key], "")
-
-            "#{pp_key} => #{pp_value},"
-          end.join("\n")
-        when String
-          object =~ /\n/ ? object : object.inspect
-        else
-          PP.pp(object,"")
-        end
-      end
-
-      if String.method_defined?(:encoding)
-        def pick_encoding(source_a, source_b)
-          Encoding.compatible?(source_a, source_b) || Encoding.default_external
-        end
-      else
-        def pick_encoding(source_a, source_b)
-        end
-      end
-
-      def handle_encoding_errors
-        if @actual.source_encoding != @expected.source_encoding
-          "Could not produce a diff because the encoding of the actual string (#{@actual.source_encoding}) "+
-            "differs from the encoding of the expected string (#{@expected.source_encoding})"
-        else
-          "Could not produce a diff because of the encoding of the string (#{@expected.source_encoding})"
-        end
-      end
-    end
-  end
-end