radius-spec 0.2.1 → 0.3.0

data/benchmarks/gsub_vs_tr.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# Run from the command line: bundle exec ruby benchmarks/gsub_vs_tr.rb
+require_relative 'bm_setup'
+
+display_benchmark_header
+
+[
+  ["No Replacement",       "Any String", "m", /m/, "-"],
+  ["Single Replacement",   "Any String", "i", /i/, "-"],
+  ["Multiple Replacement", "Any String", "n", /n/, "-"],
+].each do |title, str, pattern, regexp, replacement|
+  section title do |bench|
+    bench.report("gsub(string)") do
+      str.gsub(pattern, replacement)
+    end
+
+    bench.report("gsub(regexp)") do
+      str.gsub(regexp, replacement)
+    end
+
+    bench.report("tr") do
+      str.tr(pattern, replacement)
+    end
+  end
+end
+
+__END__
+
+### Environment
+
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin16]
+GC Disabled: false
+
+### Test Cases
+
+#### No Replacement
+
+```
+Warming up --------------------------------------
+        gsub(string)   225.903k i/100ms
+        gsub(regexp)   150.469k i/100ms
+                  tr   225.874k i/100ms
+Calculating -------------------------------------
+        gsub(string)      4.848M (± 0.7%) i/s -     24.398M in   5.042073s
+        gsub(regexp)      2.558M (± 1.3%) i/s -     12.790M in   5.018370s
+                  tr      4.872M (± 1.0%) i/s -     24.394M in   5.020983s
+                   with 95.0% confidence
+
+Comparison:
+                  tr:  4872264.7 i/s
+        gsub(string):  4847903.4 i/s - same-ish: difference falls within error
+        gsub(regexp):  2557821.1 i/s - 1.91x  (± 0.03) slower
+                   with 95.0% confidence
+```
+
+#### Single Replacement
+
+```
+Warming up --------------------------------------
+        gsub(string)   115.202k i/100ms
+        gsub(regexp)    64.609k i/100ms
+                  tr   230.643k i/100ms
+Calculating -------------------------------------
+        gsub(string)      1.431M (± 1.6%) i/s -      7.143M in   5.010792s
+        gsub(regexp)    663.965k (± 1.0%) i/s -      3.360M in   5.067248s
+                  tr      4.517M (± 0.9%) i/s -     22.603M in   5.014505s
+                   with 95.0% confidence
+
+Comparison:
+                  tr:  4516906.0 i/s
+        gsub(string):  1430926.3 i/s - 3.16x  (± 0.06) slower
+        gsub(regexp):   663964.7 i/s - 6.80x  (± 0.09) slower
+                   with 95.0% confidence
+```
+
+#### Multiple Replacement
+
+```
+Warming up --------------------------------------
+        gsub(string)    92.833k i/100ms
+        gsub(regexp)    51.482k i/100ms
+                  tr   222.779k i/100ms
+Calculating -------------------------------------
+        gsub(string)      1.263M (± 1.3%) i/s -      6.313M in   5.014495s
+        gsub(regexp)    663.557k (± 1.4%) i/s -      3.346M in   5.061408s
+                  tr      4.786M (± 0.9%) i/s -     24.060M in   5.040074s
+                   with 95.0% confidence
+
+Comparison:
+                  tr:  4785813.8 i/s
+        gsub(string):  1262609.0 i/s - 3.79x  (± 0.06) slower
+        gsub(regexp):   663557.0 i/s - 7.21x  (± 0.12) slower
+                   with 95.0% confidence
+```

data/benchmarks/hash_merge.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# Run from the command line: bundle exec ruby benchmarks/hash_merge.rb
+require_relative 'bm_setup'
+
+display_benchmark_header
+
+ENUM = (1..100)
+
+def hash_merge
+  tmp = {}
+  ENUM.each do |e|
+    tmp.merge! e => e
+  end
+  tmp
+end
+
+def hash_assign
+  tmp = {}
+  ENUM.each do |e|
+    tmp[e] = e
+  end
+  tmp
+end
+
+COMPOSE = {
+  a: 'a',
+  b: 'b',
+  c: 'c',
+}.freeze
+
+def hash_compose_merge
+  { one: 1 }.merge(COMPOSE)
+end
+
+def hash_compose_merge!
+  { one: 1 }.merge!(COMPOSE)
+end
+
+def hash_compose_splat
+  { one: 1, **COMPOSE }
+end
+
+section "Hash merge vs assign" do |bench|
+  bench.report("Hash#merge!") do
+    hash_merge
+  end
+
+  bench.report("Hash#[]=") do
+    hash_assign
+  end
+end
+
+section "Hash compose: merge vs splat" do |bench|
+  bench.report("merge") do
+    hash_compose_merge
+  end
+
+  bench.report("merge!") do
+    hash_compose_merge!
+  end
+
+  bench.report("splat") do
+    hash_compose_splat
+  end
+end
+
+__END__
+
+### Environment
+
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin16]
+GC Disabled: false
+
+### Test Cases
+
+#### Hash merge vs assign
+
+```
+Warming up --------------------------------------
+         Hash#merge!     1.760k i/100ms
+            Hash#[]=     7.821k i/100ms
+Calculating -------------------------------------
+         Hash#merge!     17.746k (± 1.1%) i/s -     89.760k in   5.065762s
+            Hash#[]=     83.691k (± 1.2%) i/s -    422.334k in   5.057697s
+                   with 95.0% confidence
+
+Comparison:
+            Hash#[]=:    83691.2 i/s
+         Hash#merge!:    17746.3 i/s - 4.71x  (± 0.08) slower
+                   with 95.0% confidence
+```
+
+#### Hash compose: merge vs splat
+
+```
+Warming up --------------------------------------
+               merge    78.448k i/100ms
+              merge!   111.435k i/100ms
+               splat   111.927k i/100ms
+Calculating -------------------------------------
+               merge    978.337k (± 1.0%) i/s -      4.942M in   5.061428s
+              merge!      1.571M (± 1.0%) i/s -      7.912M in   5.046875s
+               splat      1.587M (± 1.0%) i/s -      7.947M in   5.017037s
+                   with 95.0% confidence
+
+Comparison:
+               splat:  1587073.4 i/s
+              merge!:  1570636.9 i/s - same-ish: difference falls within error
+               merge:   978337.3 i/s - 1.62x  (± 0.02) slower
+                   with 95.0% confidence
+```

data/benchmarks/kwargs.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# Run from the command line: bundle exec ruby benchmarks/kwargs.rb
+require_relative 'bm_setup'
+
+display_benchmark_header
+
+NAME = "any name"
+STATIC_OPTS = { name: "any name" }.freeze
+
+def hash_param(hash)
+  hash
+end
+
+def kwarg_param(name: nil)
+  name
+end
+
+def kwarg_splat_param(**kwargs)
+  kwargs
+end
+
+def static_opts
+  kwarg_param STATIC_OPTS
+end
+
+def named_opts
+  kwarg_param name: NAME
+end
+
+def splat_opts
+  kwarg_splat_param name: NAME
+end
+
+def hash_opts
+  hash_param name: NAME
+end
+
+section "kwargs vs hash method" do |x|
+  x.report("hash param") do
+    hash_opts
+  end
+
+  x.report("kwarg param") do
+    named_opts
+  end
+
+  x.report("kwarg splat param") do
+    splat_opts
+  end
+
+  x.compare!
+end
+
+section "Call kwargs method" do |x|
+  x.report("static opts") do
+    static_opts
+  end
+
+  x.report("named opts") do
+    named_opts
+  end
+
+  x.compare!
+end
+
+__END__
+
+Perhaps surprisingly the kwarg parameters option is much faster. I'm not sure
+why this actually is, but my guess is that Ruby optimizes this during the byte
+code process.
+
+### Environment
+
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin16]
+GC Disabled: false
+
+### Test Cases
+
+#### kwargs vs hash method
+
+```
+Warming up --------------------------------------
+          hash param   131.753k i/100ms
+         kwarg param   266.657k i/100ms
+   kwarg splat param    66.641k i/100ms
+Calculating -------------------------------------
+          hash param      2.057M (± 1.6%) i/s -     10.277M in   5.023252s
+         kwarg param      7.351M (± 0.7%) i/s -     36.799M in   5.015356s
+   kwarg splat param    850.179k (± 1.4%) i/s -      4.265M in   5.035194s
+                   with 95.0% confidence
+
+Comparison:
+         kwarg param:  7351007.8 i/s
+          hash param:  2056501.2 i/s - 3.57x  (± 0.06) slower
+   kwarg splat param:   850179.4 i/s - 8.64x  (± 0.13) slower
+                   with 95.0% confidence
+```
+
+#### Call kwargs method
+
+```
+Warming up --------------------------------------
+         static opts   127.699k i/100ms
+          named opts   274.978k i/100ms
+Calculating -------------------------------------
+         static opts      1.879M (± 1.0%) i/s -      9.450M in   5.039627s
+          named opts      6.938M (± 1.1%) i/s -     34.647M in   5.014500s
+                   with 95.0% confidence
+
+Comparison:
+          named opts:  6937888.3 i/s
+         static opts:  1878705.6 i/s - 3.69x  (± 0.05) slower
+                   with 95.0% confidence
+```
+
+### Environment
+
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin16]
+GC Disabled: true
+
+### Test Cases
+
+#### kwargs vs hash method
+
+```
+Warming up --------------------------------------
+          hash param   144.722k i/100ms
+         kwarg param   266.216k i/100ms
+   kwarg splat param    67.212k i/100ms
+Calculating -------------------------------------
+          hash param      2.318M (± 5.2%) i/s -     10.709M in   5.017846s
+         kwarg param      7.381M (± 0.8%) i/s -     37.004M in   5.026198s
+   kwarg splat param    893.963k (±15.1%) i/s -      3.159M in   5.180853s
+                   with 95.0% confidence
+
+Comparison:
+         kwarg param:  7380700.1 i/s
+          hash param:  2317626.6 i/s - 3.19x  (± 0.17) slower
+   kwarg splat param:   893963.2 i/s - 8.26x  (± 1.26) slower
+                   with 95.0% confidence
+```
+
+#### Call kwargs method
+
+```
+Warming up --------------------------------------
+         static opts   157.568k i/100ms
+          named opts   271.741k i/100ms
+Calculating -------------------------------------
+         static opts      1.741M (±12.7%) i/s -      7.091M in   5.038616s
+          named opts      7.335M (± 0.7%) i/s -     36.685M in   5.010800s
+                   with 95.0% confidence
+
+Comparison:
+          named opts:  7335402.3 i/s
+         static opts:  1740760.5 i/s - 4.21x  (± 0.53) slower
+                   with 95.0% confidence
+```

data/benchmarks/max_ternary.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# Run from the command line: bundle exec ruby benchmarks/max_ternary.rb
+require_relative 'bm_setup'
+
+display_benchmark_header
+
+section "Min First" do |bench|
+  x = 1
+  y = 2
+
+  bench.report("max") do
+    [x, y].max
+  end
+
+  bench.report("ternary") do
+    (x < y) ? y : x
+  end
+end
+
+section "Max First" do |bench|
+  x = 2
+  y = 1
+
+  bench.report("max") do
+    [x, y].max
+  end
+
+  bench.report("ternary") do
+    (x < y) ? y : x
+  end
+end
+
+section "Equal values" do
+  x = 2
+  y = 2
+
+  bench.report("max") do
+    [x, y].max
+  end
+
+  bench.report("ternary") do
+    (x < y) ? y : x
+  end
+end
+
+__END__
+
+### Environment
+
+ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-darwin16]
+GC Disabled: false
+
+### Test Cases
+
+#### Min First
+
+```
+Warming up --------------------------------------
+                 max   349.454k i/100ms
+             ternary   349.128k i/100ms
+Calculating -------------------------------------
+                 max     12.628M (± 0.9%) i/s -     62.902M in   5.000232s
+             ternary     12.853M (± 0.8%) i/s -     64.240M in   5.015540s
+                   with 95.0% confidence
+
+Comparison:
+             ternary: 12852607.6 i/s
+                 max: 12628052.1 i/s - 1.02x  (± 0.01) slower
+                   with 95.0% confidence
+```
+
+#### Max First
+
+```
+Warming up --------------------------------------
+                 max   346.104k i/100ms
+             ternary   344.003k i/100ms
+Calculating -------------------------------------
+                 max     12.788M (± 0.7%) i/s -     64.029M in   5.022073s
+             ternary     12.607M (± 0.7%) i/s -     62.953M in   5.006764s
+                   with 95.0% confidence
+
+Comparison:
+                 max: 12787891.5 i/s
+             ternary: 12606659.1 i/s - same-ish: difference falls within error
+                   with 95.0% confidence
+```
+
+#### Equal values
+
+```
+Warming up --------------------------------------
+                 max   340.468k i/100ms
+             ternary   343.788k i/100ms
+Calculating -------------------------------------
+                 max     12.278M (± 0.9%) i/s -     61.284M in   5.010572s
+             ternary     12.703M (± 0.9%) i/s -     63.601M in   5.026552s
+                   with 95.0% confidence
+
+Comparison:
+             ternary: 12702775.1 i/s
+                 max: 12277915.1 i/s - 1.03x  (± 0.01) slower
+                   with 95.0% confidence
+```