dry-initializer 0.0.1

data/Rakefile

@@ -0,0 +1,47 @@
+require "bundler/setup"
+Bundler::GemHelper.install_tasks
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new :default
+
+namespace :benchmark do
+  desc "Runs benchmarks without options"
+  task :without_options do
+    system "ruby benchmarks/without_options.rb"
+  end
+
+  desc "Runs benchmarks for several defaults"
+  task :several_defaults do
+    system "ruby benchmarks/several_defaults.rb"
+  end
+
+  desc "Runs benchmarks for defaults of params vs. options"
+  task :params_vs_options do
+    system "ruby benchmarks/params_vs_options.rb"
+  end
+
+  desc "Runs benchmarks with types"
+  task :with_types do
+    system "ruby benchmarks/with_types.rb"
+  end
+
+  desc "Runs benchmarks with defaults"
+  task :with_defaults do
+    system "ruby benchmarks/with_defaults.rb"
+  end
+
+  desc "Runs benchmarks with types and defaults"
+  task :with_types_and_defaults do
+    system "ruby benchmarks/with_types_and_defaults.rb"
+  end
+
+  desc "Runs benchmarks for plain params"
+  task :params do
+    system "ruby benchmarks/params.rb"
+  end
+
+  desc "Runs benchmarks various opts"
+  task :options do
+    system "ruby benchmarks/options.rb"
+  end
+end

data/benchmarks/options.rb

@@ -0,0 +1,54 @@
+Bundler.require(:benchmarks)
+
+require "dry-initializer"
+class NoOptsTest
+  extend Dry::Initializer
+
+  param  :foo
+  option :bar
+end
+
+class DefaultsTest
+  extend Dry::Initializer
+
+  param  :foo, default: proc { "FOO" }
+  option :bar, default: proc { "BAR" }
+end
+
+class TypesTest
+  extend Dry::Initializer
+
+  param  :foo, type: String
+  option :bar, type: String
+end
+
+class DefaultsAndTypesTest
+  extend Dry::Initializer
+
+  param  :foo, type: String, default: proc { "FOO" }
+  option :bar, type: String, default: proc { "BAR" }
+end
+
+puts "Benchmark for various options"
+
+Benchmark.ips do |x|
+  x.config time: 15, warmup: 10
+
+  x.report("no opts") do
+    NoOptsTest.new "foo", bar: "bar"
+  end
+
+  x.report("with defaults") do
+    DefaultsTest.new
+  end
+
+  x.report("with types") do
+    TypesTest.new "foo", bar: "bar"
+  end
+
+  x.report("with defaults and types") do
+    DefaultsAndTypesTest.new
+  end
+
+  x.compare!
+end

data/benchmarks/params.rb

@@ -0,0 +1,73 @@
+Bundler.require(:benchmarks)
+
+class PlainRubyTest
+  attr_reader :foo, :bar
+
+  def initialize(foo, bar)
+    @foo = foo
+    @bar = bar
+  end
+end
+
+StructTest = Struct.new(:foo, :bar)
+
+require "dry-initializer"
+class DryTest
+  extend Dry::Initializer
+
+  param :foo
+  param :bar
+end
+
+require "concord"
+class ConcordTest
+  include Concord.new(:foo, :bar)
+end
+
+require "values"
+ValueTest = Value.new(:foo, :bar)
+
+require "value_struct"
+ValueStructTest = ValueStruct.new(:foo, :bar)
+
+require "attr_extras"
+class AttrExtrasText
+  attr_initialize :foo, :bar
+  attr_reader :foo, :bar
+end
+
+puts "Benchmark for instantiation of plain params"
+
+Benchmark.ips do |x|
+  x.config time: 15, warmup: 10
+
+  x.report("plain Ruby") do
+    PlainRubyTest.new "FOO", "BAR"
+  end
+
+  x.report("Core Struct") do
+    StructTest.new "FOO", "BAR"
+  end
+
+  x.report("values") do
+    ValueTest.new "FOO", "BAR"
+  end
+
+  x.report("value_struct") do
+    ValueStructTest.new "FOO", "BAR"
+  end
+
+  x.report("dry-initializer") do
+    DryTest.new "FOO", "BAR"
+  end
+
+  x.report("concord") do
+    ConcordTest.new "FOO", "BAR"
+  end
+
+  x.report("attr_extras") do
+    AttrExtrasText.new "FOO", "BAR"
+  end
+
+  x.compare!
+end

data/benchmarks/params_vs_options.rb

@@ -0,0 +1,35 @@
+Bundler.require(:benchmarks)
+
+require "dry-initializer"
+
+class ParamDefaults
+  extend Dry::Initializer
+
+  param :foo, default: proc { "FOO" }
+  param :bar, default: proc { "BAR" }
+  param :baz, default: proc { "BAZ" }
+end
+
+class OptionDefaults
+  extend Dry::Initializer
+
+  option :foo, default: proc { "FOO" }
+  option :bar, default: proc { "BAR" }
+  option :baz, default: proc { "BAZ" }
+end
+
+puts "Benchmark for param's vs. option's defaults"
+
+Benchmark.ips do |x|
+  x.config time: 15, warmup: 10
+
+  x.report("param's defaults") do
+    ParamDefaults.new
+  end
+
+  x.report("option's defaults") do
+    OptionDefaults.new
+  end
+
+  x.compare!
+end

data/benchmarks/several_defaults.rb

@@ -0,0 +1,82 @@
+Bundler.require(:benchmarks)
+
+require "dry-initializer"
+class WithoutDefaults
+  extend Dry::Initializer
+
+  param :foo
+  param :bar
+  param :baz
+end
+
+class WithOneDefault
+  extend Dry::Initializer
+
+  param :foo
+  param :bar
+  param :baz, default: proc { "BAZ" }
+end
+
+class WithTwoDefaults
+  extend Dry::Initializer
+
+  param :foo
+  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" }
+end
+
+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"
+  end
+
+  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"
+  end
+
+  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"
+  end
+
+  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"
+  end
+
+  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"
+  end
+
+  x.report("with 3 of 3 defaults used") do
+    WithThreeDefaults.new
+  end
+
+  x.compare!
+end

data/benchmarks/with_defaults.rb

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

data/benchmarks/with_types.rb

@@ -0,0 +1,62 @@
+Bundler.require(:benchmarks)
+
+class PlainRubyTest
+  attr_reader :foo, :bar
+
+  def initialize(foo:, bar:)
+    @foo = foo
+    @bar = bar
+    fail TypeError unless String === @foo
+    fail TypeError unless String === @bar
+  end
+end
+
+require "dry-initializer"
+class DryTest
+  extend Dry::Initializer
+
+  option :foo, type: String
+  option :bar, type: String
+end
+
+require "virtus"
+class VirtusTest
+  include Virtus.model
+
+  attribute :foo, String
+  attribute :bar, String
+end
+
+require "fast_attributes"
+class FastAttributesTest
+  extend FastAttributes
+
+  define_attributes initialize: true do
+    attribute :foo, String
+    attribute :bar, String
+  end
+end
+
+puts "Benchmark for instantiation with type constraints"
+
+Benchmark.ips do |x|
+  x.config time: 15, warmup: 10
+
+  x.report("plain Ruby") do
+    PlainRubyTest.new foo: "FOO", bar: "BAR"
+  end
+
+  x.report("dry-initializer") do
+    DryTest.new foo: "FOO", bar: "BAR"
+  end
+
+  x.report("virtus") do
+    VirtusTest.new foo: "FOO", bar: "BAR"
+  end
+
+  x.report("fast_attributes") do
+    FastAttributesTest.new foo: "FOO", bar: "BAR"
+  end
+
+  x.compare!
+end

data/benchmarks/with_types_and_defaults.rb

@@ -0,0 +1,48 @@
+Bundler.require(:benchmarks)
+
+class PlainRubyTest
+  attr_reader :foo, :bar
+
+  def initialize(foo: "FOO", bar: "BAR")
+    @foo = foo
+    @bar = bar
+    fail TypeError unless String === @foo
+    fail TypeError unless String === @bar
+  end
+end
+
+require "dry-initializer"
+class DryTest
+  extend Dry::Initializer
+
+  option :foo, type: String, default: proc { "FOO" }
+  option :bar, type: String, default: proc { "BAR" }
+end
+
+require "virtus"
+class VirtusTest
+  include Virtus.model
+
+  attribute :foo, String, default: "FOO"
+  attribute :bar, String, default: "BAR"
+end
+
+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
+    PlainRubyTest.new
+  end
+
+  x.report("dry-initializer") do
+    DryTest.new
+  end
+
+  x.report("virtus") do
+    VirtusTest.new
+  end
+
+  x.compare!
+end