opal-rspec 0.8.0 → 1.0.0.alpha1

data/rspec-expectations/upstream/benchmarks/include_matcher.rb

@@ -0,0 +1,249 @@
+require 'benchmark/ips'
+require 'rspec/expectations'
+
+include RSpec::Matchers
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      class OldInclude < BaseMatcher
+        def initialize(*expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+          perform_match(:all?, :all?)
+        end
+
+        def does_not_match?(actual)
+          @actual = actual
+          perform_match(:none?, :any?)
+        end
+
+        def description
+          described_items = surface_descriptions_in(expected)
+          item_list = EnglishPhrasing.list(described_items)
+          improve_hash_formatting "include#{item_list}"
+        end
+
+        def failure_message
+          improve_hash_formatting(super) + invalid_object_message
+        end
+
+        def failure_message_when_negated
+          improve_hash_formatting(super) + invalid_object_message
+        end
+
+        def diffable?
+          !diff_would_wrongly_highlight_matched_item?
+        end
+
+      private
+
+        def invalid_object_message
+          return '' if actual.respond_to?(:include?)
+          ", but it does not respond to `include?`"
+        end
+
+        def perform_match(predicate, hash_subset_predicate)
+          return false unless actual.respond_to?(:include?)
+
+          expected.__send__(predicate) do |expected_item|
+            if comparing_hash_to_a_subset?(expected_item)
+              expected_item.__send__(hash_subset_predicate) do |(key, value)|
+                actual_hash_includes?(key, value)
+              end
+            elsif comparing_hash_keys?(expected_item)
+              actual_hash_has_key?(expected_item)
+            else
+              actual_collection_includes?(expected_item)
+            end
+          end
+        end
+
+        def comparing_hash_to_a_subset?(expected_item)
+          actual.is_a?(Hash) && expected_item.is_a?(Hash)
+        end
+
+        def actual_hash_includes?(expected_key, expected_value)
+          actual_value = actual.fetch(expected_key) { return false }
+          values_match?(expected_value, actual_value)
+        end
+
+        def comparing_hash_keys?(expected_item)
+          actual.is_a?(Hash) && !expected_item.is_a?(Hash)
+        end
+
+        def actual_hash_has_key?(expected_key)
+          actual.key?(expected_key) ||
+          actual.keys.any? { |key| values_match?(expected_key, key) }
+        end
+
+        def actual_collection_includes?(expected_item)
+          return true if actual.include?(expected_item)
+
+          return false unless actual.respond_to?(:any?)
+
+          actual.any? { |value| values_match?(expected_item, value) }
+        end
+
+        def diff_would_wrongly_highlight_matched_item?
+          return false unless actual.is_a?(String) && expected.is_a?(Array)
+
+          lines = actual.split("\n")
+          expected.any? do |str|
+            actual.include?(str) && lines.none? { |line| line == str }
+          end
+        end
+      end
+    end
+
+    def old_include(*expected)
+      BuiltIn::OldInclude.new(*expected)
+    end
+  end
+end
+
+array_sizes = [10, 50, 100, 500]
+
+# *maniacal laugh*
+class << self; alias_method :inc, :include; remove_method :include; end
+
+Benchmark.ips do |x|
+  x.report("Old `to include` successes") do
+    array_sizes.each do |n|
+      expect([*1..n]).to old_include(*n/2..n)
+    end
+  end
+
+  x.report("New `to include` successes") do
+    array_sizes.each do |n|
+      expect([*1..n]).to include(*n/2..n)
+    end
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("Old `to include` failures") do
+    array_sizes.each do |n|
+      begin
+        expect([*1..n]).to old_include(*n+1..n*1.5)
+      rescue RSpec::Expectations::ExpectationNotMetError
+      end
+    end
+  end
+
+  x.report("New `to include` failures") do
+    array_sizes.each do |n|
+      begin
+        expect([*1..n]).to include(*n+1..n*1.5)
+      rescue RSpec::Expectations::ExpectationNotMetError
+      end
+    end
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("Old `to not include` successes") do
+    array_sizes.each do |n|
+      expect([*1..n]).to_not old_include(*n+1..n*1.5)
+    end
+  end
+
+  x.report("New `to not include` successes") do
+    array_sizes.each do |n|
+      expect([*1..n]).to_not include(*n+1..n*1.5)
+    end
+  end
+
+  x.compare!
+end
+
+Benchmark.ips do |x|
+  x.report("Old `to not include` failures") do
+    array_sizes.each do |n|
+      begin
+        expect([*1..n]).to_not old_include(*n/2..n)
+      rescue RSpec::Expectations::ExpectationNotMetError
+      end
+    end
+  end
+
+  x.report("New `to not include` failures") do
+    array_sizes.each do |n|
+      begin
+        expect([*1..n]).to_not include(*n/2..n)
+      rescue RSpec::Expectations::ExpectationNotMetError
+      end
+    end
+  end
+
+  x.compare!
+end
+
+__END__
+
+Calculating -------------------------------------
+Old `to include` successes
+                        30.000  i/100ms
+New `to include` successes
+                        28.000  i/100ms
+-------------------------------------------------
+Old `to include` successes
+                        307.740  (± 4.2%) i/s -      1.560k
+New `to include` successes
+                        299.321  (± 2.7%) i/s -      1.512k
+
+Comparison:
+Old `to include` successes:      307.7 i/s
+New `to include` successes:      299.3 i/s - 1.03x slower
+
+Calculating -------------------------------------
+Old `to include` failures
+                         2.000  i/100ms
+New `to include` failures
+                         1.000  i/100ms
+-------------------------------------------------
+Old `to include` failures
+                         20.611  (± 4.9%) i/s -    104.000
+New `to include` failures
+                          2.990  (± 0.0%) i/s -     15.000
+
+Comparison:
+Old `to include` failures:       20.6 i/s
+New `to include` failures:        3.0 i/s - 6.89x slower
+
+Calculating -------------------------------------
+Old `to not include` successes
+                         1.000  i/100ms
+New `to not include` successes
+                         1.000  i/100ms
+-------------------------------------------------
+Old `to not include` successes
+                          3.505  (± 0.0%) i/s -     18.000
+New `to not include` successes
+                          3.475  (± 0.0%) i/s -     18.000
+
+Comparison:
+Old `to not include` successes:        3.5 i/s
+New `to not include` successes:        3.5 i/s - 1.01x slower
+
+Calculating -------------------------------------
+Old `to not include` failures
+                         2.000  i/100ms
+New `to include` failures
+                         1.000  i/100ms
+-------------------------------------------------
+Old `to not include` failures
+                         21.187  (± 4.7%) i/s -    106.000
+New `to include` failures
+                         19.899  (± 5.0%) i/s -    100.000
+
+Comparison:
+Old `to not include` failures:       21.2 i/s
+New `to include` failures:       19.9 i/s - 1.06x slower

data/rspec-expectations/upstream/benchmarks/include_v_superclass.rb

@@ -5,7 +5,6 @@ n = 10_000
 class  Foo; end
 module Bar; end
 
-
 Benchmark.benchmark do |bm|
   puts "Class.new(Foo)"
 

data/rspec-expectations/upstream/benchmarks/match_array/failing_with_duplicate_items.rb

@@ -17,7 +17,7 @@ Benchmark.benchmark do |bm|
     actual    = Array.new(size) { rand(size / 2) }
     expecteds = Array.new(3) do
       array = actual.shuffle
-      array[rand(array.length)] = 9999999
+      array[rand(array.length)] = 9_999_999
       array
     end
 

data/rspec-expectations/upstream/benchmarks/output_stringio_vs_tempfile.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'benchmark'
+require 'rspec/expectations'
+include RSpec::Matchers
+
+n = 100_000
+
+Benchmark.bm(25) do |bm|
+  bm.report("to_stdout with StringIO") do
+    n.times { expect {}.not_to output('foo').to_stdout }
+  end
+
+  bm.report("to_stdout with Tempfile") do
+    n.times { expect {}.not_to output('foo').to_stdout_from_any_process }
+  end
+
+  bm.report("to_stderr with StringIO") do
+    n.times { expect {}.not_to output('foo').to_stderr }
+  end
+
+  bm.report("to_stderr with Tempfile") do
+    n.times { expect {}.not_to output('foo').to_stderr_from_any_process }
+  end
+end
+
+#                                 user     system      total        real
+# to_stdout with StringIO     0.470000   0.010000   0.480000 (  0.467317)
+# to_stdout with Tempfile     8.920000   7.420000  16.340000 ( 16.355174)
+# to_stderr with StringIO     0.460000   0.000000   0.460000 (  0.454059)
+# to_stderr with Tempfile     8.930000   7.560000  16.490000 ( 16.494696)

data/rspec-expectations/upstream/benchmarks/set_vs_array_include.rb

@@ -1,7 +1,7 @@
 require 'benchmark'
 require 'set'
 
-n = 10000000
+n = 10_000_000
 
 array = [
   :@name, :@declarations, :@diffable, :@messages,
@@ -60,9 +60,7 @@ end
 # array.include?(item 6)     3.800000   0.010000   3.810000 (  3.810014)
 # ================================================================================
 
-
 # Negative examples:
 #            user     system      total        real
 # set    1.940000   0.000000   1.940000 (  1.941780)
 # array  4.240000   0.010000   4.250000 (  4.238137)
-

data/rspec-expectations/upstream/cucumber.yml

@@ -1,10 +1,15 @@
 <%
-def tags(tag)
+
+USE_TILDE_TAGS = !defined?(::RUBY_ENGINE_VERSION) || (::RUBY_ENGINE_VERSION < '2.0.0')
+NOT_WIP_TAG = USE_TILDE_TAGS ? '~@wip' : '"not @wip"'
+NOT_RUBY_1_9_TAG = USE_TILDE_TAGS ? '~@ruby-1.9' : '"not @ruby-1.9"'
+
+def tags(tag = NOT_WIP_TAG)
   tags = [tag]
-  tags << "~@ruby-1.9" if RUBY_VERSION.to_f < 1.9
+  tags << NOT_RUBY_1_9_TAG if RUBY_VERSION.to_f < 1.9
   tags.join(" --tags ")
 end
 %>
 
-default: --require features --tags <%= tags("~@wip") %> --format progress
-wip: --require features --tags <%= tags("@wip:3") --wip features
+default: --require features --tags <%= tags %> --format progress
+wip: --require features --tags @wip:3 --wip features

data/rspec-expectations/upstream/features/.nav

@@ -29,6 +29,7 @@
   - define_matcher_with_fluent_interface.feature
   - access_running_example.feature
   - define_matcher_outside_rspec.feature
+- aggregating_failures.feature
 - composing_matchers.feature
 - compound_expectations.feature
 - define_negated_matcher.feature

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

@@ -0,0 +1,56 @@
+Feature: Aggregating Failures
+
+  Normally, an expectation failure causes the example to immediately abort.  When you have multiple independent expectations, it's nice to be able to see all of the failures rather than just the first.  One solution is to split off a separate example for each expectation, but if the setup for the examples is slow, that's going to take extra time and slow things down.  `aggregate_failures` provides an alternate solution.  It wraps a set of expectations with a block.  Within the block, expectation failures will not immediatly abort like normal; instead, the failures will be aggregated into a single exception that is raised at the end of the block, allowing you to see all expectations that failed.
+
+  `aggregate_failures` takes an optional string argument that will be used in the aggregated failure message as a label.
+
+  RSpec::Core expands this feature a bit; see [the rspec-core docs](https://relishapp.com/rspec/rspec-core/docs/expectation-framework-integration/aggregating-failures) for more detail.
+
+  Note: The implementation of `aggregate_failures` uses a thread-local variable, which means that if you have an expectation failure in another thread, it'll abort like normal.
+
+  Scenario: Multiple expectation failures within `aggregate_failures` are all reported
+    Given a file named "spec/aggregated_failure_spec.rb" with:
+      """ruby
+      require 'rspec/expectations'
+      include RSpec::Matchers
+
+      Response = Struct.new(:status, :headers, :body)
+      response = Response.new(404, { "Content-Type" => "text/plain" }, "Not Found")
+
+      begin
+        aggregate_failures "testing response" do
+          expect(response.status).to eq(200)
+          expect(response.headers["Content-Type"]).to eq("application/json")
+          expect(response.body).to eq('{"message":"Success"}')
+        end
+      rescue RSpec::Expectations::MultipleExpectationsNotMetError => e
+        puts e.message.gsub(/(:in).+/, '')
+        exit(1)
+      end
+      """
+    When I run `ruby spec/aggregated_failure_spec.rb`
+    Then it should fail with:
+      """
+      Got 3 failures from failure aggregation block "testing response":
+
+        1) expected: 200
+                got: 404
+
+           (compared using ==)
+
+           spec/aggregated_failure_spec.rb:9
+
+        2) expected: "application/json"
+                got: "text/plain"
+
+           (compared using ==)
+
+           spec/aggregated_failure_spec.rb:10
+
+        3) expected: "{"message":"Success"}"
+                got: "Not Found"
+
+           (compared using ==)
+
+           spec/aggregated_failure_spec.rb:11
+      """

data/rspec-expectations/upstream/features/built_in_matchers/README.md

@@ -1,7 +1,7 @@
 rspec-expectations ships with a number of built-in matchers. Each matcher can be used
 with `expect(..).to` or `expect(..).not_to` to define positive and negative expectations
 respectively on an object. Most matchers can also be accessed using the `(...).should` and
-`(...).should_not` syntax; see [using should syntax](https://github.com/rspec/rspec-expectations/blob/master/Should.md) for why we recommend using `expect`.
+`(...).should_not` syntax; see [using should syntax](https://github.com/rspec/rspec-expectations/blob/main/Should.md) for why we recommend using `expect`.
 
 e.g.
 
@@ -94,7 +94,7 @@ e.g.
     expect([1, 2, 3]).to     contain_exactly(2, 1, 3)
     expect([1, 2, 3]).to     match_array([3, 2, 1])
 
-## Ranges (1.9 only)
+## Ranges (1.9+ only)
 
     expect(1..10).to cover(3)
 
@@ -133,5 +133,5 @@ e.g.
     expect { |b| User.transaction(&b) }.to yield_with_no_args
     expect { |b| 5.tap(&b)            }.not_to yield_with_no_args         # because it yields with `5`
     expect { |b| 5.tap(&b)            }.to yield_with_args(5)             # because 5 == 5
-    expect { |b| 5.tap(&b)            }.to yield_with_args(Fixnum)        # because Fixnum === 5
+    expect { |b| 5.tap(&b)            }.to yield_with_args(Integer)       # because Integer === 5
     expect { |b| [1, 2, 3].each(&b)   }.to yield_successive_args(1, 2, 3)

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

@@ -1,7 +1,6 @@
 Feature: `all` matcher
 
-  Use the `all` matcher to specify that a collection's objects all pass an expected matcher.
-  This works on any enumerable object.
+  Use the `all` matcher to specify that a collection's objects all pass an expected matcher. This works on any enumerable object.
 
     ```ruby
     expect([1, 3, 5]).to all( be_odd )
@@ -17,6 +16,8 @@ Feature: `all` matcher
     expect([1, 4, 21]).to all( be_odd.or be < 10 )
     ```
 
+  If you are looking for "any" member of a collection that passes an expectation, look at the `include`-matcher.
+
   Scenario: array usage
     Given a file named "array_all_matcher_spec.rb" with:
       """ruby

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

@@ -10,7 +10,7 @@ Feature: `be_within` matcher
       > area_of_circle == 28.2743338823081
         => false
 
-  Instead, you should use the be_within matcher to check that the value is within a delta of
+  Instead, you should use the `be_within` matcher to check that the value is within a delta of
   your expected value:
 
     ```ruby

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

@@ -26,6 +26,7 @@ Feature: `change` matcher
       end
       """
 
+  @skip-when-ripper-unsupported
   Scenario: expect change
     Given a file named "spec/example_spec.rb" with:
       """ruby
@@ -33,19 +34,20 @@ Feature: `change` matcher
 
       RSpec.describe Counter, "#increment" do
         it "should increment the count" do
-          expect { Counter.increment }.to change{Counter.count}.from(0).to(1)
+          expect { Counter.increment }.to change { Counter.count }.from(0).to(1)
         end
 
         # deliberate failure
         it "should increment the count by 2" do
-          expect { Counter.increment }.to change{Counter.count}.by(2)
+          expect { Counter.increment }.to change { Counter.count }.by(2)
         end
       end
       """
     When I run `rspec spec/example_spec.rb`
     Then the output should contain "1 failure"
-    Then the output should contain "expected result to have changed by 2, but was changed by 1"
+    Then the output should contain "expected `Counter.count` to have changed by 2, but was changed by 1"
 
+  @skip-when-ripper-unsupported
   Scenario: expect no change
     Given a file named "spec/example_spec.rb" with:
       """ruby
@@ -53,14 +55,14 @@ Feature: `change` matcher
 
       RSpec.describe Counter, "#increment" do
         it "should not increment the count by 1 (using not_to)" do
-          expect { Counter.increment }.not_to change{Counter.count}
+          expect { Counter.increment }.not_to change { Counter.count }
         end
 
         it "should not increment the count by 1 (using to_not)" do
-          expect { Counter.increment }.to_not change{Counter.count}
+          expect { Counter.increment }.to_not change { Counter.count }
         end
       end
       """
     When I run `rspec spec/example_spec.rb`
     Then the output should contain "2 failures"
-    Then the output should contain "expected result not to have changed, but did change from 1 to 2"
+    Then the output should contain "expected `Counter.count` not to have changed, but did change from 1 to 2"

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

@@ -7,6 +7,7 @@ Feature: Comparison matchers
     expect(9).to be > 6
     expect(3).to be <= 3
     expect(1).to be < 6
+    expect('a').to be < 'b'
     ```
 
   Scenario: numeric operator matchers
@@ -23,34 +24,61 @@ Feature: Comparison matchers
         it { is_expected.to be > 20 }
         it { is_expected.to be <= 17 }
         it { is_expected.to be >= 19 }
+        it { is_expected.to be < 'a' }
+      end
+
+      RSpec.describe 'a' do
+        it { is_expected.to be < 'b' }
+
+        # deliberate failures
+        it { is_expected.to be < 18 }
       end
       """
      When I run `rspec numeric_operator_matchers_spec.rb`
-     Then the output should contain "8 examples, 4 failures"
+     Then the output should contain "11 examples, 6 failures"
       And the output should contain:
       """
            Failure/Error: it { is_expected.to be < 15 }
+
              expected: < 15
                   got:   18
       """
       And the output should contain:
       """
            Failure/Error: it { is_expected.to be > 20 }
+
              expected: > 20
                   got:   18
       """
       And the output should contain:
       """
            Failure/Error: it { is_expected.to be <= 17 }
+
              expected: <= 17
                   got:    18
       """
       And the output should contain:
       """
            Failure/Error: it { is_expected.to be >= 19 }
+
              expected: >= 19
                   got:    18
       """
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be < 'a' }
+
+             expected: < "a"
+                  got:   18
+      """
+      And the output should contain:
+      """
+           Failure/Error: it { is_expected.to be < 18 }
+
+             expected: < 18
+                  got:   "a"
+      """
+
 
   Scenario: string operator matchers
     Given a file named "string_operator_matchers_spec.rb" with:
@@ -73,24 +101,28 @@ Feature: Comparison matchers
       And the output should contain:
       """
            Failure/Error: it { is_expected.to be < "Cranberry" }
+
              expected: < "Cranberry"
                   got:   "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: it { is_expected.to be > "Zuchini" }
+
              expected: > "Zuchini"
                   got:   "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: it { is_expected.to be <= "Potato" }
+
              expected: <= "Potato"
                   got:    "Strawberry"
       """
       And the output should contain:
       """
            Failure/Error: it { is_expected.to be >= "Tomato" }
+
              expected: >= "Tomato"
                   got:    "Strawberry"
       """

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

@@ -38,6 +38,7 @@ Feature: `contain_exactly` matcher
       And the output should contain:
       """
            Failure/Error: it { is_expected.to contain_exactly(1, 2, 1) }
+
              expected collection contained:  [1, 1, 2]
              actual collection contained:    [1, 2, 3]
              the missing elements were:      [1]

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

@@ -1,9 +1,9 @@
 @ruby-1.9
 Feature: `cover` matcher
 
-  Use the cover matcher to specify that a range covers one or more
-  expected objects. This works on any object that responds to #cover?
-  (such as a Range):
+  Use the `cover` matcher to specify that a range covers one or more
+  expected objects. This works on any object that responds to `#cover?`
+  (such as a `Range`):
 
     ```ruby
     expect(1..10).to cover(5)

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

@@ -1,6 +1,6 @@
 Feature: `exist` matcher
 
-  The exist matcher is used to specify that something exists (as indicated by #exist? or #exists?):
+  The `exist` matcher is used to specify that something exists (as indicated by `#exist?` or `#exists?`):
 
     ```ruby
     expect(obj).to exist # passes if obj.exist? or obj.exists?

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

@@ -1,7 +1,6 @@
 Feature: `have_attributes` matcher
 
-  Use the have_attributes matcher to specify that
-  an object's attributes match the expected attributes:
+  Use the have_attributes matcher to specify that an object's attributes match the expected attributes:
 
     ```ruby
     Person = Struct.new(:name, :age)