opal-rspec 0.8.0 → 1.0.0.alpha1

data/rspec-expectations/upstream/features/built_in_matchers/satisfy.feature

@@ -1,6 +1,6 @@
 Feature: `satisfy` matcher
 
-  The satisfy matcher is extremely flexible and can handle almost anything you want to
+  The `satisfy` matcher is extremely flexible and can handle almost anything you want to
   specify. It passes if the block you provide returns true:
 
     ```ruby
@@ -8,10 +8,16 @@ Feature: `satisfy` matcher
     expect(7).not_to satisfy { |v| v % 5 == 0 }
     ```
 
-  This flexibility comes at a cost, however: the failure message ("expected [actual] to satisfy
-  block") is not very descriptive or helpful.  You will usually be better served by using one of
-  the other built-in matchers, or writing a custom matcher.
+  The default failure message ("expected [actual] to satisfy block") is not very descriptive or helpful.
+  To add clarification, you can provide your own description as an argument:
 
+    ```ruby
+    expect(10).to satisfy("be a multiple of 5") do |v|
+      v % 5 == 0
+    end
+    ```
+
+  @skip-when-ripper-unsupported
   Scenario: basic usage
     Given a file named "satisfy_matcher_spec.rb" with:
       """ruby
@@ -22,11 +28,14 @@ Feature: `satisfy` matcher
         # deliberate failures
         it { is_expected.not_to satisfy { |v| v > 5 } }
         it { is_expected.to satisfy { |v| v > 15 } }
+        it { is_expected.to_not satisfy("be greater than 5") { |v| v > 5 } }
+        it { is_expected.to satisfy("be greater than 15") { |v| v > 15 } }
       end
       """
     When I run `rspec satisfy_matcher_spec.rb`
     Then the output should contain all of these:
-      | 4 examples, 2 failures           |
-      | expected 10 not to satisfy block |
-      | expected 10 to satisfy block     |
-
+      | 6 examples, 4 failures                        |
+      | expected 10 not to satisfy expression `v > 5` |
+      | expected 10 to satisfy expression `v > 15`    |
+      | expected 10 not to be greater than 5          |
+      | expected 10 to be greater than 15             |

data/rspec-expectations/upstream/features/built_in_matchers/throw_symbol.feature

@@ -1,6 +1,6 @@
 Feature: `throw_symbol` matcher
 
-  The throw_symbol matcher is used to specify that a block of code throws a symbol. The most
+  The `throw_symbol` matcher is used to specify that a block of code throws a symbol. The most
   basic form passes if any symbol is thrown:
 
     ```ruby

data/rspec-expectations/upstream/features/built_in_matchers/types.feature

@@ -22,20 +22,20 @@ Feature: Type matchers
       """ruby
       module MyModule; end
 
-      class Fixnum
+      class Float
         include MyModule
       end
 
-      RSpec.describe 17 do
+      RSpec.describe 17.0 do
         # the actual class
-        it { is_expected.to be_kind_of(Fixnum) }
-        it { is_expected.to be_a_kind_of(Fixnum) }
-        it { is_expected.to be_a(Fixnum) }
+        it { is_expected.to be_kind_of(Float) }
+        it { is_expected.to be_a_kind_of(Float) }
+        it { is_expected.to be_a(Float) }
 
         # the superclass
-        it { is_expected.to be_kind_of(Integer) }
-        it { is_expected.to be_a_kind_of(Integer) }
-        it { is_expected.to be_an(Integer) }
+        it { is_expected.to be_kind_of(Numeric) }
+        it { is_expected.to be_a_kind_of(Numeric) }
+        it { is_expected.to be_an(Numeric) }
 
         # an included module
         it { is_expected.to be_kind_of(MyModule) }
@@ -48,12 +48,12 @@ Feature: Type matchers
         it { is_expected.not_to be_a(String) }
 
         # deliberate failures
-        it { is_expected.not_to be_kind_of(Fixnum) }
-        it { is_expected.not_to be_a_kind_of(Fixnum) }
-        it { is_expected.not_to be_a(Fixnum) }
-        it { is_expected.not_to be_kind_of(Integer) }
-        it { is_expected.not_to be_a_kind_of(Integer) }
-        it { is_expected.not_to be_an(Integer) }
+        it { is_expected.not_to be_kind_of(Float) }
+        it { is_expected.not_to be_a_kind_of(Float) }
+        it { is_expected.not_to be_a(Float) }
+        it { is_expected.not_to be_kind_of(Numeric) }
+        it { is_expected.not_to be_a_kind_of(Numeric) }
+        it { is_expected.not_to be_an(Numeric) }
         it { is_expected.not_to be_kind_of(MyModule) }
         it { is_expected.not_to be_a_kind_of(MyModule) }
         it { is_expected.not_to be_a(MyModule) }
@@ -64,29 +64,29 @@ Feature: Type matchers
       """
     When I run `rspec be_kind_of_matcher_spec.rb`
     Then the output should contain all of these:
-      | 24 examples, 12 failures                 |
-      | expected 17 not to be a kind of Fixnum   |
-      | expected 17 not to be a kind of Integer  |
-      | expected 17 not to be a kind of MyModule |
-      | expected 17 to be a kind of String       |
+      | 24 examples, 12 failures                   |
+      | expected 17.0 not to be a kind of Float    |
+      | expected 17.0 not to be a kind of Numeric  |
+      | expected 17.0 not to be a kind of MyModule |
+      | expected 17.0 to be a kind of String       |
 
   Scenario: be_(an_)instance_of matcher
     Given a file named "be_instance_of_matcher_spec.rb" with:
       """ruby
       module MyModule; end
 
-      class Fixnum
+      class Float
         include MyModule
       end
 
-      RSpec.describe 17 do
+      RSpec.describe 17.0 do
         # the actual class
-        it { is_expected.to be_instance_of(Fixnum) }
-        it { is_expected.to be_an_instance_of(Fixnum) }
+        it { is_expected.to be_instance_of(Float) }
+        it { is_expected.to be_an_instance_of(Float) }
 
         # the superclass
-        it { is_expected.not_to be_instance_of(Integer) }
-        it { is_expected.not_to be_an_instance_of(Integer) }
+        it { is_expected.not_to be_instance_of(Numeric) }
+        it { is_expected.not_to be_an_instance_of(Numeric) }
 
         # an included module
         it { is_expected.not_to be_instance_of(MyModule) }
@@ -97,10 +97,10 @@ Feature: Type matchers
         it { is_expected.not_to be_an_instance_of(String) }
 
         # deliberate failures
-        it { is_expected.not_to be_instance_of(Fixnum) }
-        it { is_expected.not_to be_an_instance_of(Fixnum) }
-        it { is_expected.to be_instance_of(Integer) }
-        it { is_expected.to be_an_instance_of(Integer) }
+        it { is_expected.not_to be_instance_of(Float) }
+        it { is_expected.not_to be_an_instance_of(Float) }
+        it { is_expected.to be_instance_of(Numeric) }
+        it { is_expected.to be_an_instance_of(Numeric) }
         it { is_expected.to be_instance_of(MyModule) }
         it { is_expected.to be_an_instance_of(MyModule) }
         it { is_expected.to be_instance_of(String) }
@@ -109,8 +109,8 @@ Feature: Type matchers
       """
     When I run `rspec be_instance_of_matcher_spec.rb`
     Then the output should contain all of these:
-      | 16 examples, 8 failures                     |
-      | expected 17 not to be an instance of Fixnum |
-      | expected 17 to be an instance of Integer    |
-      | expected 17 to be an instance of MyModule   |
-      | expected 17 to be an instance of String     |
+      | 16 examples, 8 failures                       |
+      | expected 17.0 not to be an instance of Float  |
+      | expected 17.0 to be an instance of Numeric    |
+      | expected 17.0 to be an instance of MyModule   |
+      | expected 17.0 to be an instance of String     |

data/rspec-expectations/upstream/features/built_in_matchers/yield.feature

@@ -139,13 +139,13 @@ Feature: `yield` matchers
       RSpec.describe "yield_successive_args matcher" do
         specify { expect { |b| array.each(&b) }.to yield_successive_args(1, 2, 3) }
         specify { expect { |b| array_of_tuples.each(&b) }.to yield_successive_args([:a, :b], [:c, :d]) }
-        specify { expect { |b| array.each(&b) }.to yield_successive_args(Fixnum, Fixnum, Fixnum) }
+        specify { expect { |b| array.each(&b) }.to yield_successive_args(Integer, Integer, Integer) }
         specify { expect { |b| array.each(&b) }.not_to yield_successive_args(1, 2) }
 
         # deliberate failures
         specify { expect { |b| array.each(&b) }.not_to yield_successive_args(1, 2, 3) }
         specify { expect { |b| array_of_tuples.each(&b) }.not_to yield_successive_args([:a, :b], [:c, :d]) }
-        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(Fixnum, Fixnum, Fixnum) }
+        specify { expect { |b| array.each(&b) }.not_to yield_successive_args(Integer, Integer, Integer) }
         specify { expect { |b| array.each(&b) }.to yield_successive_args(1, 2) }
       end
       """

data/rspec-expectations/upstream/features/composing_matchers.feature

@@ -54,7 +54,7 @@ Feature: Composing Matchers
             by( a_value_within(0.1).of(1.0) )
         end
 
-        specify "you can pass matchers to `from` and `to" do
+        specify "you can pass matchers to `from` and `to`" do
           s = "food"
           expect { s = "barn" }.to change { s }.
             from( a_string_matching(/foo/) ).
@@ -98,7 +98,7 @@ Feature: Composing Matchers
   Scenario: Composing matchers with `include`
     Given a file named "include_spec.rb" with:
       """ruby
-      RSpec.describe "Passing matchers to `contain_exactly`" do
+      RSpec.describe "Passing matchers to `include`" do
         specify "you can use matchers in place of array values" do
           expect(["barn", 2.45]).to include( a_string_starting_with("bar") )
         end
@@ -122,7 +122,7 @@ Feature: Composing Matchers
         specify "you can match nested data structures against matchers" do
           hash = {
             :a => {
-              :b => ["foo", 5],
+              :b => ["foo", 5.0],
               :c => { :d => 2.05 }
             }
           }
@@ -131,7 +131,7 @@ Feature: Composing Matchers
             :a => {
               :b => a_collection_containing_exactly(
                 a_string_starting_with("f"),
-                an_instance_of(Fixnum)
+                an_instance_of(Float)
               ),
               :c => { :d => (a_value < 3) }
             }

data/rspec-expectations/upstream/features/custom_matchers/define_block_matcher.feature

@@ -0,0 +1,78 @@
+Feature: define a matcher supporting block expectations
+
+  When you wish to support block expectations (e.g. `expect { ... }.to matcher`) with
+  your custom matchers you must specify this. You can do this manually (or determinately
+  based on some logic) by defining a `supports_block_expectation?` method or by using
+  the DSL's `supports_block_expectations` shortcut method.
+
+  Scenario: define a block matcher manually
+    Given a file named "block_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :support_blocks do
+        match do |actual|
+          actual.is_a? Proc
+        end
+
+        def supports_block_expectations?
+          true # or some logic
+        end
+      end
+
+      RSpec.describe "a custom block matcher" do
+        specify { expect { }.to support_blocks }
+      end
+      """
+    When I run `rspec ./block_matcher_spec.rb`
+    Then the example should pass
+
+  Scenario: define a block matcher using shortcut
+    Given a file named "block_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :support_blocks do
+        match do |actual|
+          actual.is_a? Proc
+        end
+
+        supports_block_expectations
+      end
+
+      RSpec.describe "a custom block matcher" do
+        specify { expect { }.to support_blocks }
+      end
+      """
+    When I run `rspec ./block_matcher_spec.rb`
+    Then the example should pass
+
+  Scenario: define a block matcher using shortcut
+    Given a file named "block_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :support_blocks_with_errors do
+        match(:notify_expectation_failures => true) do |actual|
+          actual.call
+          true
+        end
+
+        supports_block_expectations
+      end
+
+      RSpec.describe "a custom block matcher" do
+        specify do
+          expect {
+            expect(true).to eq false
+          }.to support_blocks_with_errors
+        end
+      end
+      """
+    When I run `rspec ./block_matcher_spec.rb`
+    Then it should fail with:
+      """
+      Failures:
+
+        1) a custom block matcher is expected to support blocks with errors
+           Failure/Error: expect(true).to eq false
+
+             expected: false
+                  got: true
+
+             (compared using ==)
+      """

data/rspec-expectations/upstream/features/custom_matchers/define_diffable_matcher.feature

@@ -1,9 +1,34 @@
 Feature: define diffable matcher
 
-  When a matcher is defined as diffable, the output will include a diff of the submitted
-  objects when the objects are more than simple primitives.
+  When a matcher is defined as diffable, the output will include a diff of the submitted objects when the objects are more than simple primitives.
 
-  Scenario: define a diffable matcher
+  @skip-when-diff-lcs-1.3
+  Scenario: define a diffable matcher (with diff-lcs 1.4)
+    Given a file named "diffable_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :be_just_like do |expected|
+        match do |actual|
+          actual == expected
+        end
+
+        diffable
+      end
+
+      RSpec.describe "two\nlines" do
+        it { is_expected.to be_just_like("three\nlines") }
+      end
+      """
+    When I run `rspec ./diffable_matcher_spec.rb`
+    Then it should fail with:
+      """
+             Diff:
+             @@ -1 +1 @@
+             -three
+             +two
+      """
+
+  @skip-when-diff-lcs-1.4
+  Scenario: define a diffable matcher (with diff-lcs 1.3)
     Given a file named "diffable_matcher_spec.rb" with:
       """ruby
       RSpec::Matchers.define :be_just_like do |expected|
@@ -27,3 +52,90 @@ Feature: define diffable matcher
              +two
               lines
       """
+
+  @skip-when-diff-lcs-1.3 @skip-when-diff-lcs-1.4.3
+  Scenario: Redefine actual (with diff-lcs 1.4.4)
+
+    Sometimes is neccessary to overwrite actual to make diffing work, e.g. if `actual` is a name of a file you want to read from. For this to work you need to overwrite `@actual` in your matcher.
+
+    Given a file named "redefine_actual_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :have_content do |expected|
+        match do |actual|
+          @actual = File.read(actual).chomp
+
+          values_match? expected, @actual
+        end
+
+        diffable
+      end
+
+      RSpec.describe 'Compare files' do
+        context 'when content is equal' do
+          it { expect('data.txt').to have_content 'Data' }
+        end
+
+        context 'when files are different' do
+          it { expect('data.txt').to have_content "No\nData\nhere" }
+        end
+      end
+      """
+    And a file named "data.txt" with:
+    """
+    Data
+    """
+    When I run `rspec ./redefine_actual_matcher_spec.rb --format documentation`
+    Then the exit status should not be 0
+    And the output should contain:
+    """
+    2 examples, 1 failure
+    """
+    And the output should contain:
+    """
+           @@ -1,4 +1,2 @@
+           -No
+            Data
+           -here
+    """
+
+  @skip-when-diff-lcs-1.4
+  Scenario: Redefine actual (with diff-lcs 1.3)
+    Given a file named "redefine_actual_matcher_spec.rb" with:
+      """ruby
+      RSpec::Matchers.define :have_content do |expected|
+        match do |actual|
+          @actual = File.read(actual).chomp
+
+          values_match? expected, @actual
+        end
+
+        diffable
+      end
+
+      RSpec.describe 'Compare files' do
+        context 'when content is equal' do
+          it { expect('data.txt').to have_content 'Data' }
+        end
+
+        context 'when files are different' do
+          it { expect('data.txt').to have_content "No\nData\nhere" }
+        end
+      end
+      """
+    And a file named "data.txt" with:
+    """
+    Data
+    """
+    When I run `rspec ./redefine_actual_matcher_spec.rb --format documentation`
+    Then the exit status should not be 0
+    And the output should contain:
+    """
+    2 examples, 1 failure
+    """
+    And the output should contain:
+    """
+           @@ -1,4 +1,2 @@
+           -No
+            Data
+           -here
+    """