opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-support/upstream/REPORT_TEMPLATE.md

@@ -0,0 +1,43 @@
+<!---
+This file was generated on 2020-12-25T18:48:31+00:00 from the rspec-dev repo.
+DO NOT modify it by hand as your changes will get lost the next time it is generated.
+-->
+
+# Report template
+
+```ruby
+# frozen_string_literal: true
+
+begin
+  require "bundler/inline"
+rescue LoadError => e
+  $stderr.puts "Bundler version 1.10 or later is required. Please update your Bundler"
+  raise e
+end
+
+gemfile(true) do
+  source "https://rubygems.org"
+
+  gem "rspec", "3.7.0" # Activate the gem and version you are reporting the issue against.
+end
+
+puts "Ruby version is: #{RUBY_VERSION}"
+require 'rspec/autorun'
+
+RSpec.describe 'additions' do
+  it 'returns 2' do
+    expect(1 + 1).to eq(2)
+  end
+
+  it 'returns 1' do
+    expect(3 - 1).to eq(-1)
+  end
+end
+```
+
+Simply copy the content of the appropriate template into a `.rb` file on your computer
+and make the necessary changes to demonstrate the issue. You can execute it by running
+`ruby rspec_report.rb` in your terminal.
+
+You can then share your executable test case as a [gist](https://gist.github.com), or
+simply paste the content into the issue description.

data/rspec-support/upstream/Rakefile

@@ -17,14 +17,18 @@ task :default => [:spec]
 task :verify_private_key_present do
   private_key = File.expand_path('~/.gem/rspec-gem-private_key.pem')
   unless File.exist?(private_key)
-    raise "Your private key is not present. This gem should not be built without that."
+    raise "Your private key is not present. This gem should not be built without it."
   end
 end
 
 task :build => :verify_private_key_present
 
-require 'rubocop/rake_task'
-desc 'Run RuboCop on the lib directory'
-RuboCop::RakeTask.new(:rubocop) do |task|
-  task.patterns = ['lib/**/*.rb']
+begin
+  require 'rubocop/rake_task'
+  desc 'Run RuboCop on the lib directory'
+  RuboCop::RakeTask.new(:rubocop) do |task|
+    task.patterns = ['lib/**/*.rb']
+  end
+rescue LoadError
+  # No rubocop means no rubocop rake task
 end

data/rspec-support/upstream/benchmarks/caller_vs_caller_locations.rb

@@ -0,0 +1,19 @@
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report("caller()              ") { caller }
+  x.report("caller_locations()    ") { caller_locations }
+  x.report("caller(1, 2)          ") { caller(1, 2) }
+  x.report("caller_locations(1, 2)") { caller_locations(1, 2) }
+end
+
+__END__
+
+caller()
+                        118.586k (±17.7%) i/s -    573.893k
+caller_locations()
+                        355.988k (±17.8%) i/s -      1.709M
+caller(1, 2)
+                        336.841k (±18.6%) i/s -      1.615M
+caller_locations(1, 2)
+                        781.330k (±23.5%) i/s -      3.665M

data/rspec-support/upstream/benchmarks/caller_vs_caller_locations_vs_raise.rb

@@ -0,0 +1,153 @@
+# This benchmark arose from rspec/rspec-support#199 where we experimented with
+# faster ways of generating / capturing a backtrace and wether it made sense
+# to lazily generate it using `raise` to capture the backtrace via an exception.
+# See also rspec/rspec-mocks#937
+
+require 'benchmark/ips'
+
+def use_raise_to_capture_caller
+  use_raise_lazily.backtrace
+end
+
+def use_raise_lazily
+  raise "nope"
+rescue StandardError => exception
+  return exception
+end
+
+def create_stack_trace(n, &block)
+  return create_stack_trace(n - 1, &block) if n > 0
+  yield
+end
+
+[10, 50, 100].each do |frames|
+  puts "-" * 80
+  puts "With #{frames} extra stack frames"
+  puts "-" * 80
+  create_stack_trace(frames) do
+    Benchmark.ips do |x|
+      x.report("caller()              ") { caller }
+      x.report("caller_locations()    ") { caller_locations }
+      x.report("raise with backtrace  ") { use_raise_to_capture_caller }
+      x.report("raise and store (lazy)") { use_raise_lazily }
+      x.report("caller(1, 2)          ") { caller(1, 2) }
+      x.report("caller_locations(1, 2)") { caller_locations(1, 2) }
+      x.compare!
+    end
+  end
+end
+
+__END__
+--------------------------------------------------------------------------------
+With 10 extra stack frames
+--------------------------------------------------------------------------------
+Calculating -------------------------------------
+caller()
+                         5.583k i/100ms
+caller_locations()
+                        14.540k i/100ms
+raise with backtrace
+                         4.544k i/100ms
+raise and store (lazy)
+                        27.028k i/100ms
+caller(1, 2)
+                        25.739k i/100ms
+caller_locations(1, 2)
+                        48.848k i/100ms
+-------------------------------------------------
+caller()
+                         61.386k (±11.6%) i/s -    307.065k
+caller_locations()
+                        176.033k (±12.8%) i/s -    872.400k
+raise with backtrace
+                         48.348k (±10.5%) i/s -    240.832k
+raise and store (lazy)
+                        425.768k (±10.7%) i/s -      2.108M
+caller(1, 2)
+                        368.142k (±18.9%) i/s -      1.776M
+caller_locations(1, 2)
+                        834.431k (±17.8%) i/s -      4.054M
+
+Comparison:
+caller_locations(1, 2):   834431.2 i/s
+raise and store (lazy):   425767.6 i/s - 1.96x slower
+caller(1, 2)          :   368142.0 i/s - 2.27x slower
+caller_locations()    :   176032.6 i/s - 4.74x slower
+caller()              :    61386.0 i/s - 13.59x slower
+raise with backtrace  :    48348.2 i/s - 17.26x slower
+
+--------------------------------------------------------------------------------
+With 50 extra stack frames
+--------------------------------------------------------------------------------
+Calculating -------------------------------------
+caller()
+                         2.282k i/100ms
+caller_locations()
+                         6.446k i/100ms
+raise with backtrace
+                         2.138k i/100ms
+raise and store (lazy)
+                        23.649k i/100ms
+caller(1, 2)
+                        22.113k i/100ms
+caller_locations(1, 2)
+                        36.586k i/100ms
+-------------------------------------------------
+caller()
+                         24.105k (± 9.9%) i/s -    120.946k
+caller_locations()
+                         68.610k (± 7.9%) i/s -    341.638k
+raise with backtrace
+                         21.458k (± 9.6%) i/s -    106.900k
+raise and store (lazy)
+                        341.152k (± 8.1%) i/s -      1.703M
+caller(1, 2)
+                        297.805k (±12.5%) i/s -      1.482M
+caller_locations(1, 2)
+                        557.278k (±16.6%) i/s -      2.744M
+
+Comparison:
+caller_locations(1, 2):   557278.2 i/s
+raise and store (lazy):   341151.6 i/s - 1.63x slower
+caller(1, 2)          :   297804.8 i/s - 1.87x slower
+caller_locations()    :    68610.3 i/s - 8.12x slower
+caller()              :    24105.5 i/s - 23.12x slower
+raise with backtrace  :    21458.2 i/s - 25.97x slower
+
+--------------------------------------------------------------------------------
+With 100 extra stack frames
+--------------------------------------------------------------------------------
+Calculating -------------------------------------
+caller()
+                         1.327k i/100ms
+caller_locations()
+                         3.773k i/100ms
+raise with backtrace
+                         1.235k i/100ms
+raise and store (lazy)
+                        19.990k i/100ms
+caller(1, 2)
+                        18.269k i/100ms
+caller_locations(1, 2)
+                        29.668k i/100ms
+-------------------------------------------------
+caller()
+                         13.879k (± 9.9%) i/s -     69.004k
+caller_locations()
+                         39.070k (± 7.6%) i/s -    196.196k
+raise with backtrace
+                         12.703k (±12.7%) i/s -     62.985k
+raise and store (lazy)
+                        243.959k (± 8.3%) i/s -      1.219M
+caller(1, 2)
+                        230.289k (± 8.2%) i/s -      1.151M
+caller_locations(1, 2)
+                        406.804k (± 8.8%) i/s -      2.047M
+
+Comparison:
+caller_locations(1, 2):   406804.3 i/s
+raise and store (lazy):   243958.7 i/s - 1.67x slower
+caller(1, 2)          :   230288.9 i/s - 1.77x slower
+caller_locations()    :    39069.8 i/s - 10.41x slower
+caller()              :    13879.4 i/s - 29.31x slower
+raise with backtrace  :    12702.9 i/s - 32.02x slower

data/rspec-support/upstream/benchmarks/class_exec_vs_klass_exec.rb

@@ -0,0 +1,43 @@
+require 'benchmark/ips'
+require 'rspec/support'
+require 'rspec/support/with_keywords_when_needed'
+
+Klass = Class.new do
+  def test(*args, **kwargs)
+  end
+end
+
+def class_exec_args
+  Klass.class_exec(:a, :b) { }
+end
+
+def klass_exec_args
+  RSpec::Support::WithKeywordsWhenNeeded.class_exec(Klass, :a, :b) { }
+end
+
+def class_exec_kw_args
+  Klass.class_exec(a: :b) { |a:| }
+end
+
+def klass_exec_kw_args
+  RSpec::Support::WithKeywordsWhenNeeded.class_exec(Klass, a: :b) { |a:| }
+end
+
+Benchmark.ips do |x|
+  x.report("class_exec(*args)          ") { class_exec_args }
+  x.report("klass_exec(*args)          ") { klass_exec_args }
+  x.report("class_exec(*args, **kwargs)") { class_exec_kw_args }
+  x.report("klass_exec(*args, **kwargs)") { klass_exec_kw_args }
+end
+
+__END__
+
+Calculating -------------------------------------
+class_exec(*args)
+                          5.555M (± 1.6%) i/s -     27.864M in   5.017682s
+klass_exec(*args)
+                        657.945k (± 4.6%) i/s -      3.315M in   5.051511s
+class_exec(*args, **kwargs)
+                          2.882M (± 3.3%) i/s -     14.555M in   5.056905s
+klass_exec(*args, **kwargs)
+                         52.710k (± 4.1%) i/s -    265.188k in   5.041218s

data/rspec-support/upstream/benchmarks/map_hash.rb

@@ -0,0 +1,70 @@
+require 'benchmark/ips'
+
+def use_map_and_hash_bracket(input)
+  Hash[ input.map { |k, v| [k.to_s, v.to_s] } ]
+end
+
+def use_inject(input)
+  input.inject({}) do |hash, (k, v)|
+    hash[k.to_s] = v.to_s
+    hash
+  end
+end
+
+[10, 100, 1000].each do |size|
+  hash = Hash[1.upto(size).map { |i| [i, i] }]
+  unless use_map_and_hash_bracket(hash) == use_inject(hash)
+    raise "Not the same!"
+  end
+
+  puts
+  puts "A hash of #{size} pairs"
+
+  Benchmark.ips do |x|
+    x.report("Use map and Hash[]") { use_map_and_hash_bracket(hash) }
+    x.report("Use inject") { use_inject(hash) }
+    x.compare!
+  end
+end
+
+__END__
+
+`inject` appears to be slightly faster.
+
+A hash of 10 pairs
+Calculating -------------------------------------
+  Use map and Hash[]     8.742k i/100ms
+          Use inject     9.565k i/100ms
+-------------------------------------------------
+  Use map and Hash[]     98.220k (± 6.8%) i/s -    489.552k
+          Use inject    110.130k (± 6.1%) i/s -    554.770k
+
+Comparison:
+          Use inject:   110129.9 i/s
+  Use map and Hash[]:    98219.8 i/s - 1.12x slower
+
+
+A hash of 100 pairs
+Calculating -------------------------------------
+  Use map and Hash[]     1.080k i/100ms
+          Use inject     1.124k i/100ms
+-------------------------------------------------
+  Use map and Hash[]     10.931k (± 4.5%) i/s -     55.080k
+          Use inject     11.494k (± 5.0%) i/s -     57.324k
+
+Comparison:
+          Use inject:    11494.4 i/s
+  Use map and Hash[]:    10930.7 i/s - 1.05x slower
+
+
+A hash of 1000 pairs
+Calculating -------------------------------------
+  Use map and Hash[]   106.000  i/100ms
+          Use inject   111.000  i/100ms
+-------------------------------------------------
+  Use map and Hash[]      1.081k (± 5.1%) i/s -      5.406k
+          Use inject      1.111k (± 4.8%) i/s -      5.550k
+
+Comparison:
+          Use inject:     1111.2 i/s
+  Use map and Hash[]:     1080.8 i/s - 1.03x slower

data/rspec-support/upstream/benchmarks/ripper.rb

@@ -0,0 +1,44 @@
+require 'benchmark/ips'
+require 'ripper'
+
+ruby_version = defined?(JRUBY_VERSION) ? JRUBY_VERSION : RUBY_VERSION
+puts "#{RUBY_ENGINE} #{ruby_version}"
+
+source = File.read(__FILE__)
+
+Benchmark.ips do |x|
+  x.report("Ripper") do
+    Ripper.sexp(source)
+    Ripper.lex(source)
+  end
+end
+
+__END__
+
+ruby 1.9.3
+Calculating -------------------------------------
+              Ripper   284.000  i/100ms
+
+ruby 2.2.3
+Calculating -------------------------------------
+              Ripper   320.000  i/100ms
+
+jruby 1.7.5
+Calculating -------------------------------------
+              Ripper    24.000  i/100ms
+
+jruby 1.7.13
+Calculating -------------------------------------
+              Ripper    25.000  i/100ms
+
+jruby 1.7.14
+Calculating -------------------------------------
+              Ripper   239.000  i/100ms
+
+jruby 1.7.22
+Calculating -------------------------------------
+              Ripper   231.000  i/100ms
+
+jruby 9.0.1.0
+Calculating -------------------------------------
+              Ripper   218.000  i/100ms

data/rspec-support/upstream/benchmarks/skip_frames_for_caller_filter.rb

@@ -0,0 +1,27 @@
+require 'rspec/support/caller_filter'
+
+eval <<-EOS, binding, "/lib/rspec/core/some_file.rb", 1 # make it think this code is in rspec-core
+  class Recurser
+    def self.recurse(times, *args)
+      return RSpec::CallerFilter.first_non_rspec_line(*args) if times.zero?
+      recurse(times - 1, *args)
+    end
+  end
+EOS
+
+# Ensure the correct first_non_rspec_line is found in these cases.
+puts Recurser.recurse(20, 19)
+puts Recurser.recurse(20)
+
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report("(no args)") { Recurser.recurse(20)        }
+  x.report("(19)")      { Recurser.recurse(20, 19)    }
+  x.report("(19, 2)")   { Recurser.recurse(20, 19, 2) }
+end
+
+__END__
+ (no args)     13.789k (± 7.8%) i/s -     69.377k
+      (19)     55.410k (± 8.4%) i/s -    275.123k
+   (19, 2)     61.076k (± 8.6%) i/s -    303.637k

data/rspec-support/upstream/lib/rspec/support/caller_filter.rb

@@ -1,3 +1,5 @@
+RSpec::Support.require_rspec_support "ruby_features"
+
 module RSpec
   # Consistent implementation for "cleaning" the caller method to strip out
   # non-rspec lines. This enables errors to be reported at the call site in
@@ -23,10 +25,32 @@ module RSpec
     # when `CallerFilter.first_non_rspec_line` is called from the top level of a required
     # file, but it depends on if rubygems is loaded or not. We don't want to have to deal
     # with this complexity in our `RSpec.deprecate` calls, so we ignore it here.
-    IGNORE_REGEX = Regexp.union(LIB_REGEX, "rubygems/core_ext/kernel_require.rb")
+    IGNORE_REGEX = Regexp.union(LIB_REGEX, "rubygems/core_ext/kernel_require.rb", "<internal:")
+
+    if RSpec::Support::RubyFeatures.caller_locations_supported?
+      # This supports args because it's more efficient when the caller specifies
+      # these. It allows us to skip frames the caller knows are part of RSpec,
+      # and to decrease the increment size if the caller is confident the line will
+      # be found in a small number of stack frames from `skip_frames`.
+      #
+      # Note that there is a risk to passing a `skip_frames` value that is too high:
+      # If it skipped the first non-rspec line, then this method would return the
+      # 2nd or 3rd (or whatever) non-rspec line. Thus, you generally shouldn't pass
+      # values for these parameters, particularly since most places that use this are
+      # not hot spots (generally it gets used for deprecation warnings). However,
+      # if you do have a hot spot that calls this, passing `skip_frames` can make
+      # a significant difference. Just make sure that that particular use is tested
+      # so that if the provided `skip_frames` changes to no longer be accurate in
+      # such a way that would return the wrong stack frame, a test will fail to tell you.
+      #
+      # See benchmarks/skip_frames_for_caller_filter.rb for measurements.
+      def self.first_non_rspec_line(skip_frames=3, increment=5)
+        # Why a default `skip_frames` of 3?
+        # By the time `caller_locations` is called below, the first 3 frames are:
+        #   lib/rspec/support/caller_filter.rb:63:in `block in first_non_rspec_line'
+        #   lib/rspec/support/caller_filter.rb:62:in `loop'
+        #   lib/rspec/support/caller_filter.rb:62:in `first_non_rspec_line'
 
-    if RUBY_VERSION >= '2.0.0'
-      def self.first_non_rspec_line
         # `caller` is an expensive method that scales linearly with the size of
         # the stack. The performance hit for fetching it in chunks is small,
         # and since the target line is probably near the top of the stack, the
@@ -34,28 +58,24 @@ module RSpec
         #
         # See benchmarks/caller.rb for measurements.
 
-        # Initial value here is mostly arbitrary, but is chosen to give good
-        # performance on the common case of creating a double.
-        increment = 5
-        i         = 1
-        line      = nil
+        # The default increment of 5 for this method are mostly arbitrary, but
+        # is chosen to give good performance on the common case of creating a double.
 
-        until line
-          stack = caller(i, increment)
+        loop do
+          stack = caller_locations(skip_frames, increment)
           raise "No non-lib lines in stack" unless stack
 
-          line = stack.find { |l| l !~ IGNORE_REGEX }
+          line = stack.find { |l| l.path !~ IGNORE_REGEX }
+          return line.to_s if line
 
-          i         += increment
+          skip_frames += increment
           increment *= 2 # The choice of two here is arbitrary.
         end
-
-        line
       end
     else
       # Earlier rubies do not support the two argument form of `caller`. This
       # fallback is logically the same, but slower.
-      def self.first_non_rspec_line
+      def self.first_non_rspec_line(*)
         caller.find { |line| line !~ IGNORE_REGEX }
       end
     end

data/rspec-support/upstream/lib/rspec/support/comparable_version.rb

@@ -0,0 +1,46 @@
+module RSpec
+  module Support
+    # @private
+    class ComparableVersion
+      include Comparable
+
+      attr_reader :string
+
+      def initialize(string)
+        @string = string
+      end
+
+      def <=>(other)
+        other = self.class.new(other) unless other.is_a?(self.class)
+
+        return 0 if string == other.string
+
+        longer_segment_count = [self, other].map { |version| version.segments.count }.max
+
+        longer_segment_count.times do |index|
+          self_segment = segments[index] || 0
+          other_segment = other.segments[index] || 0
+
+          if self_segment.class == other_segment.class
+            result = self_segment <=> other_segment
+            return result unless result == 0
+          else
+            return self_segment.is_a?(String) ? -1 : 1
+          end
+        end
+
+        0
+      end
+
+      def segments
+        @segments ||= string.scan(/[a-z]+|\d+/i).map do |segment|
+          if segment =~ /\A\d+\z/
+            segment.to_i
+          else
+            segment
+          end
+        end
+      end
+    end
+  end
+end