dry-initializer 3.0.2

data/lib/dry/initializer/dispatchers/unwrap_type.rb

@@ -0,0 +1,22 @@
+#
+# Looks at the `:type` option and counts how many nested arrays
+# it contains around either nil or a callable value.
+#
+# The counted number is preserved in the `:wrap` virtual option
+# used by the [WrapType] dispatcher.
+#
+module Dry::Initializer::Dispatchers::UnwrapType
+  extend self
+
+  def call(type: nil, wrap: 0, **options)
+    type, wrap = unwrap(type, 0)
+
+    { type: type, wrap: wrap, **options }
+  end
+
+  private
+
+  def unwrap(type, count)
+    type.is_a?(Array) ? unwrap(type.first, count + 1) : [type, count]
+  end
+end

data/lib/dry/initializer/dispatchers/wrap_type.rb

@@ -0,0 +1,27 @@
+#
+# Takes `:type` and `:wrap` to construct the final value coercer
+#
+module Dry::Initializer::Dispatchers::WrapType
+  extend self
+
+  def call(type: nil, wrap: 0, **options)
+    { type: wrapped_type(type, wrap), **options }
+  end
+
+  private
+
+  def wrapped_type(type, count)
+    return type if count.zero?
+
+    ->(value) { wrap_value(value, count, type) }
+  end
+
+  def wrap_value(value, count, type)
+    if count.zero?
+      type ? type.call(value) : value
+    else
+      return [wrap_value(value, count - 1, type)] unless value.is_a?(Array)
+      value.map { |item| wrap_value(item, count - 1, type) }
+    end
+  end
+end

data/lib/dry/initializer/dsl.rb

@@ -0,0 +1,43 @@
+module Dry::Initializer
+  # Module-level DSL
+  module DSL
+    # Setting for null (undefined value)
+    # @return [nil, Dry::Initializer::UNDEFINED]
+    attr_reader :null
+
+    # Returns a version of the module with custom settings
+    # @option settings [Boolean] :undefined
+    #   If unassigned params and options should be treated different from nil
+    # @return [Dry::Initializer]
+    def [](undefined: true, **)
+      null = (undefined == false) ? nil : UNDEFINED
+      Module.new.tap do |mod|
+        mod.extend DSL
+        mod.include self
+        mod.send(:instance_variable_set, :@null, null)
+      end
+    end
+
+    # Returns mixin module to be included to target class by hand
+    # @return [Module]
+    # @yield proc defining params and options
+    def define(procedure = nil, &block)
+      config = Config.new(null: null)
+      config.instance_exec(&(procedure || block))
+      config.mixin.include Mixin::Root
+      config.mixin
+    end
+
+    private
+
+    def extended(klass)
+      config = Config.new(klass, null: null)
+      klass.send :instance_variable_set, :@dry_initializer, config
+      klass.include Mixin::Root
+    end
+
+    def self.extended(mod)
+      mod.instance_variable_set :@null, UNDEFINED
+    end
+  end
+end

data/lib/dry/initializer/mixin.rb

@@ -0,0 +1,15 @@
+module Dry::Initializer
+  # @private
+  module Mixin
+    extend  DSL              # @deprecated
+    include Dry::Initializer # @deprecated
+    def self.extended(klass) # @deprecated
+      warn "[DEPRECATED] Use Dry::Initializer instead of its alias" \
+           " Dry::Initializer::Mixin. The later will be removed in v2.1.0"
+      super
+    end
+
+    require_relative "mixin/root"
+    require_relative "mixin/local"
+  end
+end

data/lib/dry/initializer/mixin/local.rb

@@ -0,0 +1,19 @@
+module Dry::Initializer::Mixin
+  # @private
+  module Local
+    attr_reader :klass
+
+    def inspect
+      "Dry::Initializer::Mixin::Local[#{klass}]"
+    end
+    alias to_s   inspect
+    alias to_str inspect
+
+    private
+
+    def included(klass)
+      @klass = klass
+      super
+    end
+  end
+end

data/lib/dry/initializer/mixin/root.rb

@@ -0,0 +1,11 @@
+module Dry::Initializer::Mixin
+  # @private
+  module Root
+    private
+
+    def initialize(*args)
+      __dry_initializer_initialize__(*args)
+    end
+    ruby2_keywords(:initialize) if respond_to?(:ruby2_keywords, true)
+  end
+end

data/lib/dry/initializer/struct.rb

@@ -0,0 +1,39 @@
+#
+# The nested structure that takes nested hashes with indifferent access
+#
+class Dry::Initializer::Struct
+  extend Dry::Initializer
+
+  class << self
+    undef_method :param
+
+    def new(options)
+      super(**Hash(options).each_with_object({}) { |(k, v), h| h[k.to_sym] = v })
+    end
+    alias call new
+  end
+
+  #
+  # Represents event data as a nested hash with deeply stringified keys
+  # @return [Hash<String, ...>]
+  #
+  def to_h
+    self
+      .class
+      .dry_initializer
+      .attributes(self)
+      .each_with_object({}) { |(k, v), h| h[k.to_s] = __hashify(v) }
+  end
+
+  private
+
+  def __hashify(value)
+    case value
+    when Hash
+      value.each_with_object({}) { |(k, v), obj| obj[k.to_s] = __hashify(v) }
+    when Array then value.map { |v| __hashify(v) }
+    when Dry::Initializer::Struct then value.to_h
+    else value
+    end
+  end
+end

data/lib/dry/initializer/undefined.rb

@@ -0,0 +1,2 @@
+module Dry::Initializer::UNDEFINED
+end

data/lib/tasks/benchmark.rake

@@ -0,0 +1,41 @@
+namespace :benchmark do
+  desc "Runs benchmarks for plain params"
+  task :plain_params do
+    system "ruby benchmarks/plain_params.rb"
+  end
+
+  desc "Runs benchmarks for plain options"
+  task :plain_options do
+    system "ruby benchmarks/plain_options.rb"
+  end
+
+  desc "Runs benchmarks for value coercion"
+  task :with_coercion do
+    system "ruby benchmarks/with_coercion.rb"
+  end
+
+  desc "Runs benchmarks with defaults"
+  task :with_defaults do
+    system "ruby benchmarks/with_defaults.rb"
+  end
+
+  desc "Runs benchmarks with defaults and coercion"
+  task :with_defaults_and_coercion do
+    system "ruby benchmarks/with_defaults_and_coercion.rb"
+  end
+
+  desc "Runs benchmarks for several defaults"
+  task :compare_several_defaults do
+    system "ruby benchmarks/with_several_defaults.rb"
+  end
+end
+
+desc "Runs all benchmarks"
+task benchmark: %i[
+  benchmark:plain_params
+  benchmark:plain_options
+  benchmark:with_coercion
+  benchmark:with_defaults
+  benchmark:with_defaults_and_coercion
+  benchmark:compare_several_defaults
+]

data/lib/tasks/profile.rake

@@ -0,0 +1,78 @@
+namespace :profile do
+  def profile(name, execution, &definition)
+    require "dry-initializer"
+    require "ruby-prof"
+    require "fileutils"
+
+    definition.call
+    result = RubyProf.profile do
+      1_000.times { execution.call }
+    end
+
+    FileUtils.mkdir_p "./tmp"
+
+    FileUtils.touch "./tmp/#{name}.dot"
+    File.open("./tmp/#{name}.dot", "w+") do |output|
+      RubyProf::DotPrinter.new(result).print(output, min_percent: 0)
+    end
+
+    FileUtils.touch "./tmp/#{name}.html"
+    File.open("./tmp/#{name}.html", "w+") do |output|
+      RubyProf::CallStackPrinter.new(result).print(output, min_percent: 0)
+    end
+
+    system "dot -Tpng ./tmp/#{name}.dot > ./tmp/#{name}.png"
+  end
+
+  desc "Profiles initialization with required param and option"
+  task :required do
+    profile("required", -> { User.new :Andy, email: "andy@example.com" }) do
+      class User
+        extend Dry::Initializer
+        param  :name
+        option :email
+      end
+    end
+  end
+
+  desc "Profiles initialization with default param and option"
+  task :defaults do
+    profile("defaults", -> { User.new }) do
+      class User
+        extend Dry::Initializer
+        param  :name,  default: -> { :Andy }
+        option :email, default: -> { "andy@example.com" }
+      end
+    end
+  end
+
+  desc "Profiles initialization with coerced param and option"
+  task :coercion do
+    profile("coercion", -> { User.new :Andy, email: :"andy@example.com" }) do
+      class User
+        extend Dry::Initializer
+        param  :name,  proc(&:to_s)
+        option :email, proc(&:to_s)
+      end
+    end
+  end
+
+  desc "Profiles initialization with coerced defaults of param and option"
+  task :default_coercion do
+    profile("default_coercion", -> { User.new }) do
+      class User
+        extend Dry::Initializer
+        param  :name,  proc(&:to_s), default: -> { :Andy }
+        option :email, proc(&:to_s), default: -> { :"andy@example.com" }
+      end
+    end
+  end
+end
+
+desc "Makes all profiling at once"
+task profile: %i[
+  profile:required
+  profile:defaults
+  profile:coercion
+  profile:default_coercion
+]

data/spec/attributes_spec.rb

@@ -0,0 +1,38 @@
+describe Dry::Initializer, "dry_initializer.attributes" do
+  subject { instance.class.dry_initializer.attributes(instance) }
+
+  context "when class has params" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        param :foo, proc(&:to_s)
+        param :bar, default: proc { 1 }
+        param :baz, optional: true
+      end
+    end
+
+    let(:instance) { Test::Foo.new(:FOO) }
+
+    it "collects coerced params with default values" do
+      expect(subject).to eq({ foo: "FOO", bar: 1 })
+    end
+  end
+
+  context "when class has options" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        option :foo
+        option :bar, default: proc { 1 }
+        option :baz, optional: true
+        option :qux, proc(&:to_s), as: :quxx
+      end
+    end
+
+    let(:instance) { Test::Foo.new(foo: :FOO, qux: :QUX) }
+
+    it "collects coerced and renamed options with default values" do
+      expect(subject).to eq({ foo: :FOO, bar: 1, quxx: "QUX" })
+    end
+  end
+end

data/spec/coercion_of_nil_spec.rb

@@ -0,0 +1,25 @@
+describe "coercion of nil" do
+  before do
+    class Test::Foo
+      extend Dry::Initializer
+      param :bar, proc(&:to_i)
+    end
+
+    class Test::Baz
+      include Dry::Initializer.define -> do
+        param :qux, proc(&:to_i)
+      end
+    end
+  end
+
+  let(:foo) { Test::Foo.new(nil) }
+  let(:baz) { Test::Baz.new(nil) }
+
+  it "works with extend syntax" do
+    expect(foo.bar).to eq 0
+  end
+
+  it "works with include syntax" do
+    expect(baz.qux).to eq 0
+  end
+end

data/spec/custom_dispatchers_spec.rb

@@ -0,0 +1,35 @@
+describe "custom dispatchers" do
+  subject { Test::Foo.new "123" }
+
+  before do
+    dispatcher = ->(op) { op[:integer] ? op.merge(type: proc(&:to_i)) : op }
+    Dry::Initializer::Dispatchers << dispatcher
+  end
+
+  context "with extend syntax" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        param :id, integer: true
+      end
+    end
+
+    it "adds syntax sugar" do
+      expect(subject.id).to eq 123
+    end
+  end
+
+  context "with include syntax" do
+    before do
+      class Test::Foo
+        include Dry::Initializer.define -> do
+          param :id, integer: true
+        end
+      end
+    end
+
+    it "adds syntax sugar" do
+      expect(subject.id).to eq 123
+    end
+  end
+end

data/spec/custom_initializer_spec.rb

@@ -0,0 +1,30 @@
+describe "custom initializer" do
+  before do
+    class Test::Foo
+      extend Dry::Initializer
+
+      param :bar
+
+      def initialize(*args)
+        super
+        @bar *= 3
+      end
+    end
+
+    class Test::Baz < Test::Foo
+      param :qux
+
+      def initialize(*args)
+        super
+        @qux += 1
+      end
+    end
+  end
+
+  it "reloads the initializer" do
+    baz = Test::Baz.new(5, 5)
+
+    expect(baz.bar).to eq 15 # 5 * 3
+    expect(baz.qux).to eq 6  # 5 + 1
+  end
+end

data/spec/default_values_spec.rb

@@ -0,0 +1,83 @@
+describe "default values" do
+  before do
+    class Test::Foo
+      extend Dry::Initializer
+
+      param  :foo, default: proc { :FOO }
+      param  :bar, default: proc { :BAR }
+      option :baz, default: -> { :BAZ }
+      option :qux, default: proc { foo }
+      option :mox, default: -> { default_mox }
+
+      private
+
+      def default_mox
+        :MOX
+      end
+    end
+  end
+
+  it "instantiate arguments" do
+    subject = Test::Foo.new(1, 2, baz: 3, qux: 4)
+
+    expect(subject.foo).to eql 1
+    expect(subject.bar).to eql 2
+    expect(subject.baz).to eql 3
+    expect(subject.qux).to eql 4
+  end
+
+  it "applies default values" do
+    subject = Test::Foo.new
+
+    expect(subject.foo).to eql :FOO
+    expect(subject.bar).to eql :BAR
+    expect(subject.baz).to eql :BAZ
+    expect(subject.qux).to eql :FOO
+  end
+
+  it "applies default values partially" do
+    subject = Test::Foo.new 1, baz: 3
+
+    expect(subject.foo).to eql 1
+    expect(subject.bar).to eql :BAR
+    expect(subject.baz).to eql 3
+    expect(subject.qux).to eql 1
+  end
+
+  it "applies default values from private methods" do
+    subject = Test::Foo.new
+    expect(subject.mox).to eql :MOX
+  end
+
+  describe "when the last param has a default and there are no options" do
+    before do
+      class Test::Bar
+        extend Dry::Initializer
+
+        param :foo
+        param :bar, default: proc { {} }
+      end
+    end
+
+    it "instantiates arguments" do
+      subject = Test::Bar.new(1, 2)
+
+      expect(subject.foo).to eql 1
+      expect(subject.bar).to eql 2
+    end
+
+    it "applies default values" do
+      subject = Test::Bar.new(1)
+
+      expect(subject.foo).to eql 1
+      expect(subject.bar).to eql({})
+    end
+
+    it "instantiates arguments also if the last is an hash" do
+      subject = Test::Bar.new(1, { baz: 2, qux: 3 })
+
+      expect(subject.foo).to eql 1
+      expect(subject.bar).to eql({ baz: 2, qux: 3 })
+    end
+  end
+end