opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-core/upstream/benchmarks/allocations/running_1_group_1000_examples.rb

@@ -0,0 +1,60 @@
+require_relative "helper"
+
+RSpec.describe "one example group" do
+  1000.times do |i|
+    example "example #{i}" do
+    end
+  end
+end
+
+benchmark_allocations(burn: 0) do
+  RSpec::Core::Runner.run([])
+end
+
+__END__
+
+Original allocations:
+
+                                          class_plus                                             count
+-----------------------------------------------------------------------------------------------  -----
+String                                                                                           35018
+Array<Symbol>                                                                                    14030
+Array                                                                                            12075
+RSpec::Core::Hooks::HookCollection                                                                4000
+Time                                                                                              2002
+Array<Symbol,Proc>                                                                                2000
+RSpec::Core::Hooks::AroundHookCollection                                                          2000
+RSpec::Core::Notifications::ExampleNotification                                                   2000
+Proc                                                                                              1065
+RubyVM::Env                                                                                       1018
+Array<Class>                                                                                      1006
+Array<RSpec::Core::Example>                                                                       1005
+RSpec::ExampleGroups::OneExampleGroup                                                             1002
+Array<String>                                                                                       67
+RubyVM::InstructionSequence                                                                         41
+Hash                                                                                                35
+Set                                                                                                 30
+File                                                                                                 6
+
+After my change:
+
+                                          class_plus                                             count
+-----------------------------------------------------------------------------------------------  -----
+Array<Symbol>                                                                                    14030
+String                                                                                           12967
+Array                                                                                            12075
+RSpec::Core::Hooks::HookCollection                                                                4000
+Time                                                                                              2002
+RSpec::Core::Notifications::ExampleNotification                                                   2000
+Array<Symbol,Proc>                                                                                2000
+RSpec::Core::Hooks::AroundHookCollection                                                          2000
+Proc                                                                                              1065
+RubyVM::Env                                                                                       1018
+Array<Class>                                                                                      1006
+Array<RSpec::Core::Example>                                                                       1005
+RSpec::ExampleGroups::OneExampleGroup                                                             1002
+Array<String>                                                                                       67
+RubyVM::InstructionSequence                                                                         41
+Hash                                                                                                35
+Set                                                                                                 30
+File                                                                                                 6

data/rspec-core/upstream/benchmarks/capture_block_vs_yield.rb

@@ -0,0 +1,208 @@
+require 'benchmark/ips'
+
+def yield_control
+  yield
+end
+
+def capture_block_and_yield(&block)
+  yield
+end
+
+def capture_block_and_call(&block)
+  block.call
+end
+
+puts "Using the block directly"
+
+Benchmark.ips do |x|
+  x.report("yield                  ") do
+    yield_control { }
+  end
+
+  x.report("capture block and yield") do
+    capture_block_and_yield { }
+  end
+
+  x.report("capture block and call ") do
+    capture_block_and_call { }
+  end
+end
+
+puts "Forwarding the block to another method"
+
+def tap_with_yield
+  5.tap { |i| yield i }
+end
+
+def tap_with_forwarded_block(&block)
+  5.tap(&block)
+end
+
+Benchmark.ips do |x|
+  x.report("tap { |i| yield i }") do
+    tap_with_yield { |i| }
+  end
+
+  x.report("tap(&block)        ") do
+    tap_with_forwarded_block { |i| }
+  end
+end
+
+def yield_n_times(n)
+  n.times { yield }
+end
+
+def forward_block_to_n_times(n, &block)
+  n.times(&block)
+end
+
+def call_block_n_times(n, &block)
+  n.times { block.call }
+end
+
+[10, 25, 50, 100, 1000, 10000].each do |count|
+  puts "Invoking the block #{count} times"
+
+  Benchmark.ips do |x|
+    x.report("#{count}.times { yield }     ") do
+      yield_n_times(count) { }
+    end
+
+    x.report("#{count}.times(&block)       ") do
+      forward_block_to_n_times(count) { }
+    end
+
+    x.report("#{count}.times { block.call }") do
+      call_block_n_times(count) { }
+    end
+  end
+end
+
+__END__
+
+This benchmark demonstrates that capturing a block (e.g. `&block`) has
+a high constant cost, taking about 5x longer than a single `yield`
+(even if the block is never used!).
+
+However, fowarding a captured block can be faster than using `yield`
+if the block is used many times (the breakeven point is at about 20-25
+invocations), so it appears that he per-invocation cost of `yield`
+is higher than that of a captured-and-forwarded block.
+
+Note that there is no circumstance where using `block.call` is faster.
+
+See also `flat_map_vs_inject.rb`, which appears to contradict these
+results a little bit.
+
+Using the block directly
+Calculating -------------------------------------
+yield
+                        91.539k i/100ms
+capture block and yield
+                        50.945k i/100ms
+capture block and call
+                        50.923k i/100ms
+-------------------------------------------------
+yield
+                          4.757M (± 6.0%) i/s -     23.709M
+capture block and yield
+                          1.112M (±20.7%) i/s -      5.349M
+capture block and call
+                        964.475k (±20.3%) i/s -      4.634M
+Forwarding the block to another method
+Calculating -------------------------------------
+ tap { |i| yield i }    74.620k i/100ms
+ tap(&block)            51.382k i/100ms
+-------------------------------------------------
+ tap { |i| yield i }      3.213M (± 6.3%) i/s -     16.043M
+ tap(&block)            970.418k (±18.6%) i/s -      4.727M
+Invoking the block 10 times
+Calculating -------------------------------------
+10.times { yield }
+                        49.151k i/100ms
+10.times(&block)
+                        40.682k i/100ms
+10.times { block.call }
+                        27.576k i/100ms
+-------------------------------------------------
+10.times { yield }
+                        908.673k (± 4.9%) i/s -      4.571M
+10.times(&block)
+                        674.565k (±16.1%) i/s -      3.336M
+10.times { block.call }
+                        385.056k (±10.3%) i/s -      1.930M
+Invoking the block 25 times
+Calculating -------------------------------------
+25.times { yield }
+                        29.874k i/100ms
+25.times(&block)
+                        30.934k i/100ms
+25.times { block.call }
+                        17.119k i/100ms
+-------------------------------------------------
+25.times { yield }
+                        416.342k (± 3.6%) i/s -      2.091M
+25.times(&block)
+                        446.108k (±10.6%) i/s -      2.227M
+25.times { block.call }
+                        201.264k (± 7.2%) i/s -      1.010M
+Invoking the block 50 times
+Calculating -------------------------------------
+50.times { yield }
+                        17.690k i/100ms
+50.times(&block)
+                        21.760k i/100ms
+50.times { block.call }
+                         9.961k i/100ms
+-------------------------------------------------
+50.times { yield }
+                        216.195k (± 5.7%) i/s -      1.079M
+50.times(&block)
+                        280.217k (± 9.9%) i/s -      1.393M
+50.times { block.call }
+                        112.754k (± 5.6%) i/s -    567.777k
+Invoking the block 100 times
+Calculating -------------------------------------
+100.times { yield }
+                        10.143k i/100ms
+100.times(&block)
+                        13.688k i/100ms
+100.times { block.call }
+                         5.551k i/100ms
+-------------------------------------------------
+100.times { yield }
+                        111.700k (± 3.6%) i/s -    568.008k
+100.times(&block)
+                        163.638k (± 7.7%) i/s -    821.280k
+100.times { block.call }
+                         58.472k (± 5.6%) i/s -    294.203k
+Invoking the block 1000 times
+Calculating -------------------------------------
+1000.times { yield }
+                         1.113k i/100ms
+1000.times(&block)
+                         1.817k i/100ms
+1000.times { block.call }
+                       603.000  i/100ms
+-------------------------------------------------
+1000.times { yield }
+                         11.156k (± 8.4%) i/s -     56.763k
+1000.times(&block)
+                         18.551k (±10.1%) i/s -     92.667k
+1000.times { block.call }
+                          6.206k (± 3.5%) i/s -     31.356k
+Invoking the block 10000 times
+Calculating -------------------------------------
+10000.times { yield }
+                       113.000  i/100ms
+10000.times(&block)
+                       189.000  i/100ms
+10000.times { block.call }
+                        61.000  i/100ms
+-------------------------------------------------
+10000.times { yield }
+                          1.150k (± 3.6%) i/s -      5.763k
+10000.times(&block)
+                          1.896k (± 6.9%) i/s -      9.450k
+10000.times { block.call }
+                        624.401  (± 3.0%) i/s -      3.172k

data/rspec-core/upstream/benchmarks/flat_map_vs_inject.rb

@@ -0,0 +1,55 @@
+require 'benchmark/ips'
+
+words = %w[ foo bar bazz big small medium large tiny less more good bad mediocre ]
+
+def flat_map_using_yield(array)
+  array.flat_map { |item| yield item }
+end
+
+def flat_map_using_block(array, &block)
+  array.flat_map(&block)
+end
+
+Benchmark.ips do |x|
+  x.report("flat_map") do
+    words.flat_map(&:codepoints)
+  end
+
+  x.report("inject (+)") do
+    words.inject([]) { |a, w| a + w.codepoints }
+  end
+
+  x.report("inject (concat)") do
+    words.inject([]) { |a, w| a.concat w.codepoints }
+  end
+
+  x.report("flat_map_using_yield") do
+    flat_map_using_yield(words, &:codepoints)
+  end
+
+  x.report("flat_map_using_block") do
+    flat_map_using_block(words, &:codepoints)
+  end
+end
+
+__END__
+
+Surprisingly, `flat_map(&block)` appears to be faster than
+`flat_map { yield }` in spite of the fact that our array here
+is smaller than the break-even point of 20-25 measured in the
+`capture_block_vs_yield.rb` benchmark. In fact, the forwaded-block
+version remains faster in my benchmarks here no matter how small
+I shrink the `words` array. I'm not sure why!
+
+Calculating -------------------------------------
+            flat_map    10.594k i/100ms
+          inject (+)     8.357k i/100ms
+     inject (concat)    10.404k i/100ms
+flat_map_using_yield    10.081k i/100ms
+flat_map_using_block    11.683k i/100ms
+-------------------------------------------------
+            flat_map    136.442k (±10.4%) i/s -    678.016k
+          inject (+)     98.024k (± 9.7%) i/s -    493.063k
+     inject (concat)    119.822k (±10.5%) i/s -    593.028k
+flat_map_using_yield    112.284k (± 9.7%) i/s -    564.536k
+flat_map_using_block    134.533k (± 6.3%) i/s -    677.614k

data/rspec-core/upstream/benchmarks/hash_functions.rb

@@ -0,0 +1,74 @@
+require 'benchmark/ips'
+require 'digest/md5'
+
+MAX_32_BIT = 4294967295
+
+def jenkins_iterative(string)
+  hash = 0
+
+  string.each_byte do |byte|
+    hash += byte
+    hash &= MAX_32_BIT
+    hash += ((hash << 10) & MAX_32_BIT)
+    hash &= MAX_32_BIT
+    hash ^= hash >> 6
+  end
+
+  hash += (hash << 3 & MAX_32_BIT)
+  hash &= MAX_32_BIT
+  hash ^= hash >> 11
+  hash += (hash << 15 & MAX_32_BIT)
+  hash &= MAX_32_BIT
+  hash
+end
+
+def jenkins_inject(string)
+  hash = string.each_byte.inject(0) do |byte, hash|
+    hash += byte
+    hash &= MAX_32_BIT
+    hash += ((hash << 10) & MAX_32_BIT)
+    hash &= MAX_32_BIT
+    hash ^= hash >> 6
+  end
+
+  hash += (hash << 3 & MAX_32_BIT)
+  hash &= MAX_32_BIT
+  hash ^= hash >> 11
+  hash += (hash << 15 & MAX_32_BIT)
+  hash &= MAX_32_BIT
+  hash
+end
+
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report("md5") do
+    Digest::MD5.digest("string")
+  end
+
+  x.report("jenkins iterative") do
+    jenkins_iterative("string")
+  end
+
+  x.report("jenkins inject") do
+    jenkins_inject("string")
+  end
+
+  x.compare!
+end
+
+__END__
+
+Calculating -------------------------------------
+                 md5    39.416k i/100ms
+   jenkins iterative    22.646k i/100ms
+      jenkins inject    18.271k i/100ms
+-------------------------------------------------
+                 md5    654.294k (±15.7%) i/s -      3.193M
+   jenkins iterative    349.669k (±10.3%) i/s -      1.744M
+      jenkins inject    286.774k (± 5.5%) i/s -      1.443M
+
+Comparison:
+                 md5:   654293.8 i/s
+   jenkins iterative:   349668.8 i/s - 1.87x slower
+      jenkins inject:   286774.4 i/s - 2.28x slower

data/rspec-core/upstream/benchmarks/keys_each_vs_each_key.rb

@@ -0,0 +1,43 @@
+require 'benchmark/ips'
+
+small_hash = { :key => true, :more_key => true, :other_key => true }
+large_hash = (1...100).inject({}) { |hash, key| hash["key_#{key}"] = true; hash }
+
+Benchmark.ips do |x|
+  x.report('keys.each with small hash') do
+    small_hash.keys.each { |value| value == true }
+  end
+
+  x.report('each_key with small hash') do
+    small_hash.each_key { |value| value == true }
+  end
+
+  x.report('keys.each with large hash') do
+    large_hash.keys.each { |value| value == true }
+  end
+
+  x.report('each_key with large hash') do
+    large_hash.each_key { |value| value == true }
+  end
+end
+
+__END__
+
+Calculating -------------------------------------
+keys.each with small hash
+                       105.581k i/100ms
+each_key with small hash
+                       112.045k i/100ms
+keys.each with large hash
+                         7.625k i/100ms
+each_key with large hash
+                         6.959k i/100ms
+-------------------------------------------------
+keys.each with small hash
+                          2.953M (± 3.8%) i/s -     14.781M
+each_key with small hash
+                          2.917M (± 4.0%) i/s -     14.678M
+keys.each with large hash
+                         79.349k (± 2.5%) i/s -    396.500k
+each_key with large hash
+                         72.080k (± 2.1%) i/s -    361.868k

data/rspec-core/upstream/benchmarks/module_inclusion_filtering.rb

@@ -0,0 +1,89 @@
+require_relative "../bundle/bundler/setup" # configures load paths
+require 'rspec/core'
+
+class << RSpec
+  attr_writer :world
+end
+
+# Here we are restoring the old implementation of `configure_group`, so that
+# we can toggle the new vs old implementation in the benchmark by aliasing it.
+module RSpecConfigurationOverrides
+  def initialize(*args)
+    super
+    @include_extend_or_prepend_modules = []
+  end
+
+  def include(mod, *filters)
+    meta = RSpec::Core::Metadata.build_hash_from(filters, :warn_about_example_group_filtering)
+    @include_extend_or_prepend_modules << [:include, mod, meta]
+    super
+  end
+
+  def old_configure_group(group)
+    @include_extend_or_prepend_modules.each do |include_extend_or_prepend, mod, filters|
+      next unless filters.empty? || RSpec::Core::MetadataFilter.apply?(:any?, filters, group.metadata)
+      __send__("safe_#{include_extend_or_prepend}", mod, group)
+    end
+  end
+
+  def self.prepare_implementation(prefix)
+    RSpec.world = RSpec::Core::World.new # clear our state
+    RSpec::Core::Configuration.class_eval do
+      alias_method :configure_group, :"#{prefix}_configure_group"
+    end
+  end
+end
+
+RSpec::Core::Configuration.class_eval do
+  prepend RSpecConfigurationOverrides
+  alias new_configure_group configure_group
+end
+
+RSpec.configure do |c|
+  50.times { c.include Module.new, :include_it }
+end
+
+require 'benchmark/ips'
+
+Benchmark.ips do |x|
+  x.report("Old linear search: non-matching metadata") do |times|
+    RSpecConfigurationOverrides.prepare_implementation(:old)
+    times.times { |i| RSpec.describe "Old linear search: non-matching metadata #{i}" }
+  end
+
+  x.report("New memoized search: non-matching metadata") do |times|
+    RSpecConfigurationOverrides.prepare_implementation(:new)
+    times.times { |i| RSpec.describe "New memoized search: non-matching metadata #{i}" }
+  end
+
+  x.report("Old linear search: matching metadata") do |times|
+    RSpecConfigurationOverrides.prepare_implementation(:old)
+    times.times { |i| RSpec.describe "Old linear search: matching metadata #{i}", :include_it }
+  end
+
+  x.report("New memoized search: matching metadata") do |times|
+    RSpecConfigurationOverrides.prepare_implementation(:new)
+    times.times { |i| RSpec.describe "New memoized search: matching metadata #{i}", :include_it }
+  end
+end
+
+__END__
+
+Calculating -------------------------------------
+Old linear search: non-matching metadata
+                        86.000  i/100ms
+New memoized search: non-matching metadata
+                        93.000  i/100ms
+Old linear search: matching metadata
+                        79.000  i/100ms
+New memoized search: matching metadata
+                        90.000  i/100ms
+-------------------------------------------------
+Old linear search: non-matching metadata
+                        884.109  (±61.9%) i/s -      3.268k
+New memoized search: non-matching metadata
+                          1.099k (±81.2%) i/s -      3.441k
+Old linear search: matching metadata
+                        822.348  (±57.5%) i/s -      3.081k
+New memoized search: matching metadata
+                          1.116k (±76.6%) i/s -      3.510k

data/rspec-core/upstream/benchmarks/precalculate_absolute_file_path_or_not.rb

@@ -0,0 +1,29 @@
+require 'benchmark/ips'
+
+metadata = { :file_path => "some/path.rb" }
+meta_with_absolute = metadata.merge(:absolute_file_path => File.expand_path(metadata[:file_path]))
+
+Benchmark.ips do |x|
+  x.report("fetch absolute path from hash") do
+    meta_with_absolute[:absolute_file_path]
+  end
+
+  x.report("calculate absolute path") do
+    File.expand_path(metadata[:file_path])
+  end
+end
+
+__END__
+
+Precalculating the absolute file path is much, much faster!
+
+Calculating -------------------------------------
+fetch absolute path from hash
+                       102.164k i/100ms
+calculate absolute path
+                         9.331k i/100ms
+-------------------------------------------------
+fetch absolute path from hash
+                          7.091M (±11.6%) i/s -     34.736M
+calculate absolute path
+                        113.141k (± 8.6%) i/s -    569.191k

data/rspec-core/upstream/benchmarks/shuffle_vs_sort_by_for_random_ordering.rb

@@ -0,0 +1,131 @@
+require 'benchmark/ips'
+require 'digest/md5'
+
+class Digest::Jenkins
+  MAX_32_BIT = 4294967295
+
+  def self.digest(string)
+    hash = 0
+
+    string.each_byte do |byte|
+      hash += byte
+      hash &= MAX_32_BIT
+      hash += ((hash << 10) & MAX_32_BIT)
+      hash &= MAX_32_BIT
+      hash ^= hash >> 6
+    end
+
+    hash += (hash << 3 & MAX_32_BIT)
+    hash &= MAX_32_BIT
+    hash ^= hash >> 11
+    hash += (hash << 15 & MAX_32_BIT)
+    hash &= MAX_32_BIT
+    hash
+  end
+end
+
+Example = Struct.new(:id)
+$seed = Kernel.srand.to_s
+
+def shuffle_list(list)
+  list.shuffle
+end
+
+def sort_using_id(list)
+  list.sort_by(&:id)
+end
+
+def sort_using_md5(list)
+  list.sort_by { |item| Digest::MD5.digest($seed + item.id) }
+end
+
+def sort_using_jenkins(list)
+  list.sort_by { |item| Digest::Jenkins.digest($seed + item.id) }
+end
+
+[10, 100, 1000, 10000].each do |size|
+  puts "Size: #{size}"
+  list = Array.new(size) { |i| Example.new("./some_spec.rb[1:#{i}]") }
+
+  Benchmark.ips do |x|
+    x.report("shuffle") { shuffle_list(list) }
+    x.report("use id") { sort_using_id(list) }
+    x.report("use md5") { sort_using_md5(list) }
+    x.report("use jenkins") { sort_using_md5(list) }
+    x.compare!
+  end
+end
+
+__END__
+
+Size: 10
+Calculating -------------------------------------
+             shuffle    71.860k i/100ms
+              use id    22.562k i/100ms
+             use md5     4.620k i/100ms
+         use jenkins     4.644k i/100ms
+-------------------------------------------------
+             shuffle      1.594M (±12.4%) i/s -      7.905M
+              use id    299.105k (± 7.1%) i/s -      1.489M
+             use md5     49.663k (± 7.5%) i/s -    249.480k
+         use jenkins     49.389k (± 7.5%) i/s -    246.132k
+
+Comparison:
+             shuffle:  1593820.8 i/s
+              use id:   299104.9 i/s - 5.33x slower
+             use md5:    49662.9 i/s - 32.09x slower
+         use jenkins:    49389.2 i/s - 32.27x slower
+
+Size: 100
+Calculating -------------------------------------
+             shuffle    24.629k i/100ms
+              use id     2.076k i/100ms
+             use md5   477.000  i/100ms
+         use jenkins   483.000  i/100ms
+-------------------------------------------------
+             shuffle    317.269k (±13.8%) i/s -      1.576M
+              use id     20.958k (± 4.2%) i/s -    105.876k
+             use md5      4.916k (± 7.5%) i/s -     24.804k
+         use jenkins      4.824k (± 8.6%) i/s -     24.150k
+
+Comparison:
+             shuffle:   317269.5 i/s
+              use id:    20957.6 i/s - 15.14x slower
+             use md5:     4916.5 i/s - 64.53x slower
+         use jenkins:     4823.5 i/s - 65.78x slower
+
+Size: 1000
+Calculating -------------------------------------
+             shuffle     3.862k i/100ms
+              use id   134.000  i/100ms
+             use md5    44.000  i/100ms
+         use jenkins    44.000  i/100ms
+-------------------------------------------------
+             shuffle     40.104k (± 4.4%) i/s -    200.824k
+              use id      1.424k (±13.5%) i/s -      6.968k
+             use md5    450.556  (± 8.0%) i/s -      2.244k
+         use jenkins    450.189  (± 7.6%) i/s -      2.244k
+
+Comparison:
+             shuffle:    40104.2 i/s
+              use id:     1423.9 i/s - 28.16x slower
+             use md5:      450.6 i/s - 89.01x slower
+         use jenkins:      450.2 i/s - 89.08x slower
+
+Size: 10000
+Calculating -------------------------------------
+             shuffle   374.000  i/100ms
+              use id    10.000  i/100ms
+             use md5     3.000  i/100ms
+         use jenkins     4.000  i/100ms
+-------------------------------------------------
+             shuffle      3.750k (± 5.4%) i/s -     18.700k
+              use id    109.008  (± 4.6%) i/s -    550.000
+             use md5     40.614  (± 9.8%) i/s -    201.000
+         use jenkins     39.975  (± 7.5%) i/s -    200.000
+
+Comparison:
+             shuffle:     3750.0 i/s
+              use id:      109.0 i/s - 34.40x slower
+             use md5:       40.6 i/s - 92.33x slower
+         use jenkins:       40.0 i/s - 93.81x slower