dry-initializer 3.0.2 → 3.0.3

data/Rakefile

@@ -1,8 +1,8 @@
-require "bundler/setup"
+require 'bundler/setup'
 Bundler::GemHelper.install_tasks
 
-require "rspec/core/rake_task"
+require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new :default
 
-load "lib/tasks/benchmark.rake"
-load "lib/tasks/profile.rake"
+load 'lib/tasks/benchmark.rake'
+load 'lib/tasks/profile.rake'

data/benchmarks/compare_several_defaults.rb

@@ -1,6 +1,6 @@
 Bundler.require(:benchmarks)
 
-require "dry-initializer"
+require 'dry-initializer'
 class WithoutDefaults
   extend Dry::Initializer
 
@@ -14,67 +14,67 @@ class WithOneDefault
 
   param :foo
   param :bar
-  param :baz, default: proc { "BAZ" }
+  param :baz, default: proc { 'BAZ' }
 end
 
 class WithTwoDefaults
   extend Dry::Initializer
 
   param :foo
-  param :bar, default: proc { "BAR" }
-  param :baz, default: proc { "BAZ" }
+  param :bar, default: proc { 'BAR' }
+  param :baz, default: proc { 'BAZ' }
 end
 
 class WithThreeDefaults
   extend Dry::Initializer
 
-  param :foo, default: proc { "FOO" }
-  param :bar, default: proc { "BAR" }
-  param :baz, default: proc { "BAZ" }
+  param :foo, default: proc { 'FOO' }
+  param :bar, default: proc { 'BAR' }
+  param :baz, default: proc { 'BAZ' }
 end
 
-puts "Benchmark for various options"
+puts 'Benchmark for various options'
 
 Benchmark.ips do |x|
   x.config time: 15, warmup: 10
 
-  x.report("without defaults") do
-    WithoutDefaults.new "FOO", "BAR", "BAZ"
+  x.report('without defaults') do
+    WithoutDefaults.new 'FOO', 'BAR', 'BAZ'
   end
 
-  x.report("with 0 of 1 default used") do
-    WithOneDefault.new "FOO", "BAR", "BAZ"
+  x.report('with 0 of 1 default used') do
+    WithOneDefault.new 'FOO', 'BAR', 'BAZ'
   end
 
-  x.report("with 1 of 1 default used") do
-    WithOneDefault.new "FOO", "BAR"
+  x.report('with 1 of 1 default used') do
+    WithOneDefault.new 'FOO', 'BAR'
   end
 
-  x.report("with 0 of 2 defaults used") do
-    WithTwoDefaults.new "FOO", "BAR", "BAZ"
+  x.report('with 0 of 2 defaults used') do
+    WithTwoDefaults.new 'FOO', 'BAR', 'BAZ'
   end
 
-  x.report("with 1 of 2 defaults used") do
-    WithTwoDefaults.new "FOO", "BAR"
+  x.report('with 1 of 2 defaults used') do
+    WithTwoDefaults.new 'FOO', 'BAR'
   end
 
-  x.report("with 2 of 2 defaults used") do
-    WithTwoDefaults.new "FOO"
+  x.report('with 2 of 2 defaults used') do
+    WithTwoDefaults.new 'FOO'
   end
 
-  x.report("with 0 of 3 defaults used") do
-    WithThreeDefaults.new "FOO", "BAR", "BAZ"
+  x.report('with 0 of 3 defaults used') do
+    WithThreeDefaults.new 'FOO', 'BAR', 'BAZ'
   end
 
-  x.report("with 1 of 3 defaults used") do
-    WithThreeDefaults.new "FOO", "BAR"
+  x.report('with 1 of 3 defaults used') do
+    WithThreeDefaults.new 'FOO', 'BAR'
   end
 
-  x.report("with 2 of 3 defaults used") do
-    WithThreeDefaults.new "FOO"
+  x.report('with 2 of 3 defaults used') do
+    WithThreeDefaults.new 'FOO'
   end
 
-  x.report("with 3 of 3 defaults used") do
+  x.report('with 3 of 3 defaults used') do
     WithThreeDefaults.new
   end
 

data/benchmarks/plain_options.rb

@@ -1,6 +1,6 @@
 Bundler.require(:benchmarks)
 
-require "dry-initializer"
+require 'dry-initializer'
 class DryTest
   extend Dry::Initializer[undefined: false]
 
@@ -24,39 +24,39 @@ class PlainRubyTest
   end
 end
 
-require "anima"
+require 'anima'
 class AnimaTest
   include Anima.new(:foo, :bar)
 end
 
-require "kwattr"
+require 'kwattr'
 class KwattrTest
   kwattr :foo, :bar
 end
 
-puts "Benchmark for instantiation with plain options"
+puts 'Benchmark for instantiation with plain options'
 
 Benchmark.ips do |x|
   x.config time: 15, warmup: 10
 
-  x.report("plain Ruby") do
-    PlainRubyTest.new foo: "FOO", bar: "BAR"
+  x.report('plain Ruby') do
+    PlainRubyTest.new foo: 'FOO', bar: 'BAR'
   end
 
-  x.report("dry-initializer") do
-    DryTest.new foo: "FOO", bar: "BAR"
+  x.report('dry-initializer') do
+    DryTest.new foo: 'FOO', bar: 'BAR'
   end
 
-  x.report("dry-initializer (with UNDEFINED)") do
-    DryTestUndefined.new foo: "FOO", bar: "BAR"
+  x.report('dry-initializer (with UNDEFINED)') do
+    DryTestUndefined.new foo: 'FOO', bar: 'BAR'
   end
 
-  x.report("anima") do
-    AnimaTest.new foo: "FOO", bar: "BAR"
+  x.report('anima') do
+    AnimaTest.new foo: 'FOO', bar: 'BAR'
   end
 
-  x.report("kwattr") do
-    KwattrTest.new foo: "FOO", bar: "BAR"
+  x.report('kwattr') do
+    KwattrTest.new foo: 'FOO', bar: 'BAR'
   end
 
   x.compare!

data/benchmarks/plain_params.rb

@@ -1,6 +1,6 @@
 Bundler.require(:benchmarks)
 
-require "dry-initializer"
+require 'dry-initializer'
 class DryTest
   extend Dry::Initializer[undefined: false]
 
@@ -26,58 +26,58 @@ end
 
 StructTest = Struct.new(:foo, :bar)
 
-require "concord"
+require 'concord'
 class ConcordTest
   include Concord.new(:foo, :bar)
 end
 
-require "values"
+require 'values'
 ValueTest = Value.new(:foo, :bar)
 
-require "value_struct"
+require 'value_struct'
 ValueStructTest = ValueStruct.new(:foo, :bar)
 
-require "attr_extras"
+require 'attr_extras'
 class AttrExtrasText
   attr_initialize :foo, :bar
   attr_reader :foo, :bar
 end
 
-puts "Benchmark for instantiation with plain params"
+puts 'Benchmark for instantiation with plain params'
 
 Benchmark.ips do |x|
   x.config time: 15, warmup: 10
 
-  x.report("plain Ruby") do
-    PlainRubyTest.new "FOO", "BAR"
+  x.report('plain Ruby') do
+    PlainRubyTest.new 'FOO', 'BAR'
   end
 
-  x.report("Core Struct") do
-    StructTest.new "FOO", "BAR"
+  x.report('Core Struct') do
+    StructTest.new 'FOO', 'BAR'
   end
 
-  x.report("values") do
-    ValueTest.new "FOO", "BAR"
+  x.report('values') do
+    ValueTest.new 'FOO', 'BAR'
   end
 
-  x.report("value_struct") do
-    ValueStructTest.new "FOO", "BAR"
+  x.report('value_struct') do
+    ValueStructTest.new 'FOO', 'BAR'
   end
 
-  x.report("dry-initializer") do
-    DryTest.new "FOO", "BAR"
+  x.report('dry-initializer') do
+    DryTest.new 'FOO', 'BAR'
   end
 
-  x.report("dry-initializer (with UNDEFINED)") do
-    DryTestUndefined.new "FOO", "BAR"
+  x.report('dry-initializer (with UNDEFINED)') do
+    DryTestUndefined.new 'FOO', 'BAR'
   end
 
-  x.report("concord") do
-    ConcordTest.new "FOO", "BAR"
+  x.report('concord') do
+    ConcordTest.new 'FOO', 'BAR'
   end
 
-  x.report("attr_extras") do
-    AttrExtrasText.new "FOO", "BAR"
+  x.report('attr_extras') do
+    AttrExtrasText.new 'FOO', 'BAR'
   end
 
   x.compare!

data/benchmarks/with_coercion.rb

@@ -1,6 +1,6 @@
 Bundler.require(:benchmarks)
 
-require "dry-initializer"
+require 'dry-initializer'
 class DryTest
   extend Dry::Initializer[undefined: false]
 
@@ -24,7 +24,7 @@ class PlainRubyTest
   end
 end
 
-require "virtus"
+require 'virtus'
 class VirtusTest
   include Virtus.model
 
@@ -32,7 +32,7 @@ class VirtusTest
   attribute :bar, String
 end
 
-require "fast_attributes"
+require 'fast_attributes'
 class FastAttributesTest
   extend FastAttributes
 
@@ -42,29 +42,29 @@ class FastAttributesTest
   end
 end
 
-puts "Benchmark for instantiation with coercion"
+puts 'Benchmark for instantiation with coercion'
 
 Benchmark.ips do |x|
   x.config time: 15, warmup: 10
 
-  x.report("plain Ruby") do
-    PlainRubyTest.new foo: "FOO", bar: "BAR"
+  x.report('plain Ruby') do
+    PlainRubyTest.new foo: 'FOO', bar: 'BAR'
   end
 
-  x.report("dry-initializer") do
-    DryTest.new foo: "FOO", bar: "BAR"
+  x.report('dry-initializer') do
+    DryTest.new foo: 'FOO', bar: 'BAR'
   end
 
-  x.report("dry-initializer (with UNDEFINED)") do
-    DryTestUndefined.new foo: "FOO", bar: "BAR"
+  x.report('dry-initializer (with UNDEFINED)') do
+    DryTestUndefined.new foo: 'FOO', bar: 'BAR'
   end
 
-  x.report("virtus") do
-    VirtusTest.new foo: "FOO", bar: "BAR"
+  x.report('virtus') do
+    VirtusTest.new foo: 'FOO', bar: 'BAR'
   end
 
-  x.report("fast_attributes") do
-    FastAttributesTest.new foo: "FOO", bar: "BAR"
+  x.report('fast_attributes') do
+    FastAttributesTest.new foo: 'FOO', bar: 'BAR'
   end
 
   x.compare!

data/benchmarks/with_defaults.rb

@@ -1,64 +1,64 @@
 Bundler.require(:benchmarks)
 
-require "dry-initializer"
+require 'dry-initializer'
 class DryTest
   extend Dry::Initializer[undefined: false]
 
-  option :foo, default: -> { "FOO" }
-  option :bar, default: -> { "BAR" }
+  option :foo, default: -> { 'FOO' }
+  option :bar, default: -> { 'BAR' }
 end
 
 class DryTestUndefined
   extend Dry::Initializer
 
-  option :foo, default: -> { "FOO" }
-  option :bar, default: -> { "BAR" }
+  option :foo, default: -> { 'FOO' }
+  option :bar, default: -> { 'BAR' }
 end
 
 class PlainRubyTest
   attr_reader :foo, :bar
 
-  def initialize(foo: "FOO", bar: "BAR")
+  def initialize(foo: 'FOO', bar: 'BAR')
     @foo = foo
     @bar = bar
   end
 end
 
-require "kwattr"
+require 'kwattr'
 class KwattrTest
-  kwattr foo: "FOO", bar: "BAR"
+  kwattr foo: 'FOO', bar: 'BAR'
 end
 
-require "active_attr"
+require 'active_attr'
 class ActiveAttrTest
   include ActiveAttr::AttributeDefaults
 
-  attribute :foo, default: "FOO"
-  attribute :bar, default: "BAR"
+  attribute :foo, default: 'FOO'
+  attribute :bar, default: 'BAR'
 end
 
-puts "Benchmark for instantiation with default values"
+puts 'Benchmark for instantiation with default values'
 
 Benchmark.ips do |x|
   x.config time: 15, warmup: 10
 
-  x.report("plain Ruby") do
+  x.report('plain Ruby') do
     PlainRubyTest.new
   end
 
-  x.report("dry-initializer") do
+  x.report('dry-initializer') do
     DryTest.new
   end
 
-  x.report("dry-initializer (with UNDEFINED)") do
+  x.report('dry-initializer (with UNDEFINED)') do
     DryTestUndefined.new
   end
 
-  x.report("kwattr") do
+  x.report('kwattr') do
     KwattrTest.new
   end
 
-  x.report("active_attr") do
+  x.report('active_attr') do
     ActiveAttrTest.new
   end
 

data/benchmarks/with_defaults_and_coercion.rb

@@ -1,24 +1,24 @@
 Bundler.require(:benchmarks)
 
-require "dry-initializer"
+require 'dry-initializer'
 class DryTest
   extend Dry::Initializer[undefined: false]
 
-  option :foo, proc(&:to_s), default: -> { "FOO" }
-  option :bar, proc(&:to_s), default: -> { "BAR" }
+  option :foo, proc(&:to_s), default: -> { 'FOO' }
+  option :bar, proc(&:to_s), default: -> { 'BAR' }
 end
 
 class DryTestUndefined
   extend Dry::Initializer
 
-  option :foo, proc(&:to_s), default: -> { "FOO" }
-  option :bar, proc(&:to_s), default: -> { "BAR" }
+  option :foo, proc(&:to_s), default: -> { 'FOO' }
+  option :bar, proc(&:to_s), default: -> { 'BAR' }
 end
 
 class PlainRubyTest
   attr_reader :foo, :bar
 
-  def initialize(foo: "FOO", bar: "BAR")
+  def initialize(foo: 'FOO', bar: 'BAR')
     @foo = foo
     @bar = bar
     raise TypeError unless String === @foo
@@ -26,32 +26,32 @@ class PlainRubyTest
   end
 end
 
-require "virtus"
+require 'virtus'
 class VirtusTest
   include Virtus.model
 
-  attribute :foo, String, default: "FOO"
-  attribute :bar, String, default: "BAR"
+  attribute :foo, String, default: 'FOO'
+  attribute :bar, String, default: 'BAR'
 end
 
-puts "Benchmark for instantiation with type constraints and default values"
+puts 'Benchmark for instantiation with type constraints and default values'
 
 Benchmark.ips do |x|
   x.config time: 15, warmup: 10
 
-  x.report("plain Ruby") do
+  x.report('plain Ruby') do
     PlainRubyTest.new
   end
 
-  x.report("dry-initializer") do
+  x.report('dry-initializer') do
     DryTest.new
   end
 
-  x.report("dry-initializer (with UNDEFINED)") do
+  x.report('dry-initializer (with UNDEFINED)') do
     DryTest.new
   end
 
-  x.report("virtus") do
+  x.report('virtus') do
     VirtusTest.new
   end