dry-initializer 2.5.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 861264b64b414e7ff11f68071a530e3208093092
-  data.tar.gz: f3426ffd2670dbe47c276d67fd972e86fdeb9677
+SHA256:
+  metadata.gz: d65124ac530b85023e9152387677a694f2cab063b484ba48133ed8006fc79c2a
+  data.tar.gz: e35526cc7df9ad5271485742f75991e397c06c04af8029003ebdd567974f763c
 SHA512:
-  metadata.gz: 3205f5f09066d20a3f05255a71ae8451ec6c00b0c6701bdf2fb4d8a854a61d49d5b1eea952d4cd08d05e3165e8748d73dd1e530a39a12d85bb90e5514bf6c37c
-  data.tar.gz: 05205f55be677d470f553ec0e9fcf8d357ffc3ba245c9195b144c24cac478dd3aa2e1e8d6bcbbd6fc1b6b04d92d8e3e8345762bc76838651dab26d90632a31d2
+  metadata.gz: ad262ac79a0191fdaee557a4d1f1b48fbb3c3dc57af0cd639077277dffe52fcecb979db69af0b5f00c803006ceab893d7a057ae085006fc343ef742e2b6f0a2a
+  data.tar.gz: 7b79bd6d05a8a9a7bb239b35cd12629dbd8eda35721916d06b7d04dac7639d361f04958e3a3ace67f5267163c27ae983ad4cb63bbf003efc96cdcf25d9028099

data/.rubocop.yml

@@ -10,13 +10,17 @@ AllCops:
 Bundler/DuplicatedGem:
   Enabled: false
 
+Naming/FileName:
+  Exclude:
+    - lib/dry-initializer.rb
+
 Style/CaseEquality:
   Enabled: false
 
-Style/ClassVars:
+Style/ClassAndModuleChildren:
   Enabled: false
 
-Style/ClassAndModuleChildren:
+Style/ClassVars:
   Enabled: false
 
 Style/Documentation:
@@ -25,10 +29,6 @@ Style/Documentation:
 Style/DoubleNegation:
   Enabled: false
 
-Style/FileName:
-  Exclude:
-    - lib/dry-initializer.rb
-
 Style/Lambda:
   Exclude:
     - spec/**/*.rb
@@ -36,7 +36,7 @@ Style/Lambda:
 Style/LambdaCall:
   Enabled: false
 
-Style/RescueModified:
+Style/RescueModifier:
   Exclude:
     - spec/**/*.rb
 

data/.travis.yml

@@ -1,16 +1,19 @@
 ---
 language: ruby
-sudo: false
 cache: bundler
 bundler_args: --without benchmarks tools
 script:
   - bundle exec rake spec
 rvm:
-  - 2.3.0
-  - 2.4.0
+  - 2.3.8
+  - 2.4.6
+  - 2.5.5
+  - 2.6.2
+  - jruby-9.2.7.0
   - jruby-9000
   - rbx-3
   - ruby-head
+  - truffleruby
 env:
   global:
     - JRUBY_OPTS='--dev -J-Xmx1024M'
@@ -19,6 +22,7 @@ matrix:
     - rvm: rbx-3
     - rvm: ruby-head
     - rvm: jruby-head
+    - rvm: truffleruby
   include:
     - rvm: jruby-head
-      before_install: gem install bundler --no-ri --no-rdoc
+      before_install: gem install bundler --no-document

data/CHANGELOG.md

@@ -5,6 +5,89 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/)
 and this project adheres to [Semantic Versioning](http://semver.org/).
 
+## [3.0.0] [2019-04-14]
+
+### Added
+
+- Support of wrapped types/coercers (nepalez)
+
+  ```ruby
+  class Test
+    # Wrap type to the array
+    param :foo, [proc(&:to_s)]
+  end
+
+  # And the value will be wrapped as well
+  test = Test.new(42)
+  test.foo # => ["42"]
+  ```
+
+- It works with several layers of nesting (nepalez)
+
+  ```ruby
+  class Test
+    # Wrap type to the array
+    param :foo, [[proc(&:to_s)]]
+  end
+
+  # And the value will be wrapped as well
+  test = Test.new(42)
+  test.foo # => [["42"]]
+  ```
+
+- Support of nested types/coercers (nepalez)
+
+  ```ruby
+  class Test
+    param :foo do
+      option :bar do
+        option :baz, proc(&:to_s)
+      end
+    end
+  end
+
+  test = Test.new(bar: { "baz" => 42 })
+  test.foo.bar.baz # => "42"
+  ```
+
+- Wrapped/nested combinations are supported as well (nepalez)
+
+  ```ruby
+  class Test
+    param :foo, [] do
+      option :bar, proc(&:to_s)
+    end
+  end
+
+  test = Test.new(bar: 42)
+  test.foo.first.bar # => "42"
+  ```
+
+## [2.7.0] Unreleazed
+
+### Fixed
+
+- Roll back master to the state of [2.5.0].
+
+  Somehow distinction between `@default_null` and `@null` variables
+  in the `Dry::Initializer::Builders` broken the `rom` library.
+
+  The version [2.6.0] has been yanked on rubygems, so the master
+  was rolled back to the previous state until the reason for
+  the incompatibility become clear (bjeanes, nepalez)
+
+## [2.6.0] [2018-09-09] (YANKED)
+
+## [2.5.0] [2018-08-17]
+
+### Fixed
+
+- `nil` coercion (belousovAV)
+
+  When default value is `nil` instead of `Dry::Initializer::UNDEFINED`,
+  the coercion should be applied to any value, including `nil`, because
+  we cannot distinct "undefined" `nil` from the "assigned" `nil` value.
+
 ## [2.4.0] [2018-02-01]
 
 ### Added
@@ -367,18 +450,20 @@ and to @gzigzigzeo for persuading me to do this refactoring.
 ### Added
 - enhancement via `Dry::Initializer::Attribute.dispatchers` registry (nepalez)
 
-    # Register dispatcher for `:string` option
-    Dry::Initializer::Attribute.dispatchers << ->(string: nil, **op) do
-      string ? op.merge(type: proc(&:to_s)) : op
-    end
+  ```ruby
+  # Register dispatcher for `:string` option
+  Dry::Initializer::Attribute.dispatchers << ->(string: nil, **op) do
+    string ? op.merge(type: proc(&:to_s)) : op
+  end
 
-    # Now you can use the `:string` key for `param` and `option`
-    class User
-      extend Dry::Initializer
-      param :name, string: true
-    end
+  # Now you can use the `:string` key for `param` and `option`
+  class User
+    extend Dry::Initializer
+    param :name, string: true
+  end
 
-    User.new(:Andy).name # => "Andy"
+  User.new(:Andy).name # => "Andy"
+  ```
 
 ### Changed
 - optimize assignments for performance (nepalez)
@@ -757,4 +842,7 @@ First public release
 [2.1.0]: https://github.com/dry-rb/dry-initializer/compare/v2.0.0...v2.1.0
 [2.2.0]: https://github.com/dry-rb/dry-initializer/compare/v2.1.0...v2.2.0
 [2.3.0]: https://github.com/dry-rb/dry-initializer/compare/v2.2.0...v2.3.0
-[2.4.0]: https://github.com/dry-rb/dry-initializer/compare/v2.3.0...v2.4.0
+[2.4.0]: https://github.com/dry-rb/dry-initializer/compare/v2.3.0...v2.4.0
+[2.6.0]: https://github.com/dry-rb/dry-initializer/compare/v2.4.0...v2.5.0
+[2.6.0]: https://github.com/dry-rb/dry-initializer/compare/v2.5.0...v2.6.0
+[3.0.0]: https://github.com/dry-rb/dry-initializer/compare/v2.5.0...v3.0.0

data/Gemfile

@@ -17,7 +17,7 @@ group :benchmarks do
   gem "concord"
   gem "fast_attributes"
   gem "kwattr"
-  gem "ruby-prof"
+  gem "ruby-prof", platform: :mri
   gem "value_struct"
   gem "values"
   gem "virtus"

data/README.md

@@ -2,7 +2,6 @@
 
 [![Gem Version](https://badge.fury.io/rb/dry-initializer.svg)][gem]
 [![Build Status](https://travis-ci.org/dry-rb/dry-initializer.svg?branch=master)][travis]
-[![Dependency Status](https://gemnasium.com/dry-rb/dry-initializer.svg)][gemnasium]
 [![Code Climate](https://codeclimate.com/github/dry-rb/dry-initializer/badges/gpa.svg)][codeclimate]
 [![Test Coverage](https://codeclimate.com/github/dry-rb/dry-initializer/badges/coverage.svg)][coveralls]
 [![Inline docs](http://inch-ci.org/github/dry-rb/dry-initializer.svg?branch=master)][inchpages]

data/dry-initializer.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |gem|
   gem.name     = "dry-initializer"
-  gem.version  = "2.5.0"
+  gem.version  = "3.0.0"
   gem.author   = ["Vladimir Kochnev (marshall-lee)", "Andrew Kozin (nepalez)"]
   gem.email    = "andrew.kozin@gmail.com"
-  gem.homepage = "https://github.com/dryrb/dry-initializer"
+  gem.homepage = "https://github.com/dry-rb/dry-initializer"
   gem.summary  = "DSL for declaring params and options of the initializer"
   gem.license  = "MIT"
 

data/lib/dry/initializer.rb

@@ -6,9 +6,7 @@ module Dry
   # DSL for declaring params and options of class initializers
   #
   module Initializer
-    # Singleton for unassigned values
-    UNDEFINED = Object.new.freeze
-
+    require_relative "initializer/undefined"
     require_relative "initializer/dsl"
     require_relative "initializer/definition"
     require_relative "initializer/builders"
@@ -32,18 +30,20 @@ module Dry
     # @option opts [Boolean] :optional
     # @option opts [Symbol]  :as
     # @option opts [true, false, :protected, :public, :private] :reader
+    # @yield block with nested definition
     # @return [self] itself
-    def param(name, type = nil, **opts)
-      dry_initializer.param(name, type, Dispatchers[opts])
+    def param(name, type = nil, **opts, &block)
+      dry_initializer.param(name, type, **opts, &block)
       self
     end
 
     # Adds or redefines an option of [#dry_initializer]
     # @param  (see #param)
     # @option (see #param)
+    # @yield  (see #param)
     # @return (see #param)
-    def option(name, type = nil, **opts)
-      dry_initializer.option(name, type, Dispatchers[opts])
+    def option(name, type = nil, **opts, &block)
+      dry_initializer.option(name, type, **opts, &block)
       self
     end
 
@@ -55,5 +55,7 @@ module Dry
       klass.send(:instance_variable_set, :@dry_initializer, config)
       dry_initializer.children << config
     end
+
+    require_relative "initializer/struct"
   end
 end

data/lib/dry/initializer/config.rb

@@ -57,8 +57,8 @@ module Dry::Initializer
     # @option opts [Symbol]  :as
     # @option opts [true, false, :protected, :public, :private] :reader
     # @return [self] itself
-    def param(name, type = nil, **opts)
-      add_definition(false, name, type, opts)
+    def param(name, type = nil, **opts, &block)
+      add_definition(false, name, type, block, opts)
     end
 
     # Adds or redefines an option of [#dry_initializer]
@@ -67,8 +67,8 @@ module Dry::Initializer
     # @option (see #param)
     # @return (see #param)
     #
-    def option(name, type = nil, **opts)
-      add_definition(true, name, type, opts)
+    def option(name, type = nil, **opts, &block)
+      add_definition(true, name, type, block, opts)
     end
 
     # The hash of public attributes for an instance of the [#extended_class]
@@ -133,13 +133,25 @@ module Dry::Initializer
       finalize
     end
 
-    def add_definition(option, name, type, opts)
-      definition = Definition.new(option, null, name, type, Dispatchers[opts])
+    # rubocop: disable Metrics/MethodLength
+    def add_definition(option, name, type, block, **opts)
+      opts = {
+        parent: extended_class,
+        option: option,
+        null:   null,
+        source: name,
+        type:   type,
+        block:  block,
+        **opts,
+      }
+
+      options = Dispatchers.call(opts)
+      definition = Definition.new(options)
       definitions[definition.source] = definition
       finalize
-
       mixin.class_eval definition.code
     end
+    # rubocop: enable Metrics/MethodLength
 
     def final_definitions
       parent_definitions = Hash(parent&.definitions&.dup)

data/lib/dry/initializer/definition.rb

@@ -49,68 +49,17 @@ module Dry::Initializer
 
     private
 
-    def initialize(option, null, source, coercer = nil, **options)
-      @option   = !!option
-      @null     = null
-      @source   = source.to_sym
-      @target   = check_target options.fetch(:as, source).to_sym
-      @ivar     = :"@#{target}"
-      @type     = check_type(coercer || options[:type])
-      @reader   = prepare_reader options.fetch(:reader, true)
-      @default  = check_default options[:default]
-      @optional = options.fetch(:optional, @default)
-      @desc     = options[:desc]&.to_s&.capitalize
+    def initialize(**options)
+      @option   = options[:option]
+      @null     = options[:null]
+      @source   = options[:source]
+      @target   = options[:target]
+      @ivar     = "@#{@target}"
+      @type     = options[:type]
+      @reader   = options[:reader]
+      @default  = options[:default]
+      @optional = options[:optional]
+      @desc     = options[:desc]
     end
-
-    def check_source(value)
-      if RESERVED.include? value
-        raise ArgumentError, "Name #{value} is reserved by dry-initializer gem"
-      end
-
-      unless option || value[ATTRIBUTE]
-        raise ArgumentError, "Invalid parameter name :'#{value}'"
-      end
-
-      value
-    end
-
-    def check_target(value)
-      return value if value[ATTRIBUTE]
-      raise ArgumentError, "Invalid variable name :'#{value}'"
-    end
-
-    def check_type(value)
-      return if value.nil?
-      arity =   value.arity               if value.is_a? Proc
-      arity ||= value.method(:call).arity if value.respond_to? :call
-      return value if [1, 2].include? arity.to_i.abs
-      raise TypeError,
-            "type of #{inspect} should respond to #call with 1..2 arguments"
-    end
-
-    def check_default(value)
-      return if value.nil?
-      return value if value.is_a?(Proc) && value.arity < 1
-      raise TypeError,
-            "default value of #{inspect} should be a proc without params"
-    end
-
-    def prepare_reader(value)
-      case value.to_s
-      when "", "false" then false
-      when "private"   then :private
-      when "protected" then :protected
-      else :public
-      end
-    end
-
-    ATTRIBUTE = /\A\w+\z/
-    RESERVED  = %i[
-      __dry_initializer_options__
-      __dry_initializer_config__
-      __dry_initializer_value__
-      __dry_initializer_definition__
-      __dry_initializer_initializer__
-    ].freeze
   end
 end

data/lib/dry/initializer/dispatchers.rb

@@ -1,44 +1,112 @@
-module Dry::Initializer
-  #
-  # @private
-  #
-  # Dispatchers allow adding syntax sugar to `.param` and `.option` methods.
+#
+# The module is responsible for __normalizing__ arguments
+# of `.param` and `.option`.
+#
+# What the module does is convert the source list of arguments
+# into the standard set of options:
+# - `:option`   -- whether an argument is an option (or param)
+# - `:source`   -- the name of source option
+# - `:target`   -- the target name of the reader
+# - `:reader`   -- if the reader's privacy (:public, :protected, :private, nil)
+# - `:ivar`     -- the target nane of the variable
+# - `:type`     -- the callable coercer of the source value
+# - `:optional` -- if the argument is optional
+# - `:default`  -- the proc returning the default value of the source value
+# - `:null`     -- the value to be set to unassigned optional argument
+#
+# It is this set is used to build [Dry::Initializer::Definition].
+#
+# @example
+#    # from `option :foo, [], as: :bar, optional: :true
+#    input = { name: :foo, as: :bar, type: [], optional: true }
+#
+#    Dry::Initializer::Dispatcher.call(input)
+#    # => {
+#    #      source:   "foo",
+#    #      target:   "bar",
+#    #      reader:   :public,
+#    #      ivar:     "@bar",
+#    #      type:  ->(v) { Array(v) } }, # simplified for brevity
+#    #      optional: true,
+#    #      default:  -> { Dry::Initializer::UNDEFINED },
+#    #    }
+#
+# # Settings
+#
+# The module uses global setting `null` to define what value
+# should be set to variables that kept unassigned. By default it
+# uses `Dry::Initializer::UNDEFINED`
+#
+# # Syntax Extensions
+#
+# The module supports syntax extensions. You can add any number
+# of custom dispatchers __on top__ of the stack of default dispatchers.
+# Every dispatcher should be a callable object that takes
+# the source set of options and converts it to another set of options.
+#
+# @example Add special dispatcher
+#
+#   # Define a dispatcher for key :integer
+#   dispatcher = proc do |integer: false, **opts|
+#     opts.merge(type: proc(&:to_i)) if integer
+#   end
+#
+#   # Register a dispatcher
+#   Dry::Initializer::Dispatchers << dispatcher
+#
+#   # Now you can use option `integer: true` instead of `type: proc(&:to_i)`
+#   class Foo
+#     extend Dry::Initializer
+#     param :id, integer: true
+#   end
+#
+module Dry::Initializer::Dispatchers
+  extend self
+
+  # @!attribute [rw] null Defines a value to be set to unassigned attributes
+  # @return [Object]
+  attr_accessor :null
+
   #
-  # Every dispatcher should convert the source hash of options into
-  # the resulting hash so that you can send additional keys to the helpers.
+  # Registers a new dispatcher
   #
-  # @example Add special dispatcher
+  # @param [#call] dispatcher
+  # @return [self] itself
   #
-  #   # Define a dispatcher for key :integer
-  #   dispatcher = proc do |opts|
-  #     opts.merge(type: proc(&:to_i)) if opts[:integer]
-  #   end
+  def <<(dispatcher)
+    @pipeline = [dispatcher] + pipeline
+    self
+  end
+
   #
-  #   # Register a dispatcher
-  #   Dry::Initializer::Dispatchers << dispatcher
+  # Normalizes the source set of options
   #
-  #   # Now you can use option `integer: true` instead of `type: proc(&:to_i)`
-  #   class Foo
-  #     extend Dry::Initializer
-  #     param :id, integer: true
-  #   end
+  # @param [Hash<Symbol, Object>] options
+  # @return [Hash<Symbol, Objct>] normalized set of options
   #
-  module Dispatchers
-    class << self
-      def <<(item)
-        list << item
-        self
-      end
+  def call(**options)
+    options = { null: null }.merge(options)
+    pipeline.reduce(options) { |opts, dispatcher| dispatcher.call(opts) }
+  end
 
-      def [](options)
-        list.inject(options) { |opts, item| item.call(opts) }
-      end
+  private
 
-      private
+  require_relative "dispatchers/build_nested_type"
+  require_relative "dispatchers/check_type"
+  require_relative "dispatchers/prepare_default"
+  require_relative "dispatchers/prepare_ivar"
+  require_relative "dispatchers/prepare_optional"
+  require_relative "dispatchers/prepare_reader"
+  require_relative "dispatchers/prepare_source"
+  require_relative "dispatchers/prepare_target"
+  require_relative "dispatchers/unwrap_type"
+  require_relative "dispatchers/wrap_type"
 
-      def list
-        @list ||= []
-      end
-    end
+  def pipeline
+    @pipeline ||= [
+      PrepareSource, PrepareTarget, PrepareIvar, PrepareReader,
+      PrepareDefault, PrepareOptional,
+      UnwrapType, CheckType, BuildNestedType, WrapType
+    ]
   end
 end

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

@@ -0,0 +1,58 @@
+#
+# Prepare nested data type from a block
+#
+# @example
+#   option :foo do
+#     option :bar
+#     option :qux
+#   end
+#
+module Dry::Initializer::Dispatchers::BuildNestedType
+  extend self
+
+  # rubocop: disable Metrics/ParameterLists
+  def call(parent:, source:, target:, type: nil, block: nil, **options)
+    check_certainty!(source, type, block)
+    check_name!(target)
+    type ||= build_nested_type(parent, target, block)
+    { parent: parent, source: source, target: target, type: type, **options }
+  end
+  # rubocop: enable Metrics/ParameterLists
+
+  private
+
+  def check_certainty!(source, type, block)
+    return unless type
+    return unless block
+
+    raise ArgumentError, <<~MESSAGE
+      You should define coercer of values of argument '#{source}'
+      either though the parameter/option, or via nested block, but not the both.
+    MESSAGE
+  end
+
+  def check_name!(name)
+    return unless name[/^_|__|_$/]
+
+    raise ArgumentError, <<~MESSAGE
+      The name of the argument '#{name}' cannot be used for nested struct.
+      A proper name can use underscores _ to divide alphanumeric parts only.
+    MESSAGE
+  end
+
+  def build_nested_type(parent, name, block)
+    return unless block
+
+    klass_name = full_name(parent, name)
+    build_struct(klass_name, block)
+  end
+
+  def full_name(parent, name)
+    "::#{parent.name}::#{name.to_s.split("_").compact.map(&:capitalize).join}"
+  end
+
+  def build_struct(klass_name, block)
+    eval "class #{klass_name} < Dry::Initializer::Struct; end"
+    const_get(klass_name).tap { |klass| klass.class_eval(&block) }
+  end
+end

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

@@ -0,0 +1,43 @@
+#
+# Checks whether an unwrapped type is valid
+#
+module Dry::Initializer::Dispatchers::CheckType
+  extend self
+
+  def call(source:, type: nil, wrap: 0, **options)
+    check_if_callable! source, type
+    check_arity! source, type, wrap
+
+    { source: source, type: type, wrap: wrap, **options }
+  end
+
+  private
+
+  def check_if_callable!(source, type)
+    return if type.nil?
+    return if type.respond_to?(:call)
+
+    raise ArgumentError,
+          "The type of the argument '#{source}' should be callable"
+  end
+
+  def check_arity!(_source, type, wrap)
+    return if type.nil?
+    return if wrap.zero?
+    return if type.method(:call).arity.abs == 1
+
+    raise ArgumentError, <<~MESSAGE
+      The dry_intitializer supports wrapped types with one argument only.
+      You cannot use array types with element coercers having several arguments.
+
+      For example, this definitions are correct:
+        option :foo, [proc(&:to_s)]
+        option :bar, type: [[]]
+        option :baz, ->(a, b) { [a, b] }
+
+      While this is not:
+        option :foo, [->(a, b) { [a, b] }]
+    MESSAGE
+  end
+  # rubocop: enable Metrics/MethodLength
+end

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

@@ -0,0 +1,40 @@
+#
+# Prepares the `:default` option
+#
+# It must respond to `.call` without arguments
+#
+module Dry::Initializer::Dispatchers::PrepareDefault
+  extend self
+
+  def call(default: nil, optional: nil, **options)
+    default = callable! default
+    check_arity! default
+
+    { default: default, optional: (optional | default), **options }
+  end
+
+  private
+
+  def callable!(default)
+    return unless default
+    return default if default.respond_to?(:call)
+    return callable(default.to_proc) if default.respond_to?(:to_proc)
+
+    invalid!(default)
+  end
+
+  def check_arity!(default)
+    return unless default
+
+    arity = default.method(:call).arity.to_i
+    return unless arity.positive?
+
+    invalid!(default)
+  end
+
+  def invalid!(default)
+    raise TypeError, "The #{default.inspect} should be" \
+                     " either convertable to proc with no arguments," \
+                     " or respond to #call without arguments."
+  end
+end

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

@@ -0,0 +1,12 @@
+#
+# Prepares the variable name of a parameter or an option.
+#
+module Dry::Initializer::Dispatchers::PrepareIvar
+  module_function
+
+  def call(target:, **options)
+    ivar = "@#{target}".delete("?").to_sym
+
+    { target: target, ivar: ivar, **options }
+  end
+end

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

@@ -0,0 +1,13 @@
+#
+# Defines whether an argument is optional
+#
+module Dry::Initializer::Dispatchers::PrepareOptional
+  module_function
+
+  def call(optional: nil, default: nil, required: nil, **options)
+    optional ||= default
+    optional &&= !required
+
+    { optional: !!optional, default: default, **options }
+  end
+end

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

@@ -0,0 +1,30 @@
+#
+# Checks the reader privacy
+#
+module Dry::Initializer::Dispatchers::PrepareReader
+  extend self
+
+  def call(target: nil, reader: :public, **options)
+    reader = case reader.to_s
+             when "false", ""                      then nil
+             when "true"                           then :public
+             when "public", "private", "protected" then reader.to_sym
+             else invalid_reader!(target, reader)
+             end
+
+    { target: target, reader: reader, **options }
+  end
+
+  private
+
+  def invalid_reader!(target, _reader)
+    raise ArgumentError, <<~MESSAGE
+      Invalid setting for the ##{target} reader's privacy.
+      Use the one of the following values for the `:reader` option:
+      - 'public' (true) for the public reader (default)
+      - 'private' for the private reader
+      - 'protected' for the protected reader
+      - nil (false) if no reader should be defined
+    MESSAGE
+  end
+end

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

@@ -0,0 +1,28 @@
+#
+# The dispatcher verifies a correctness of the source name
+# of param or option, taken as a `:source` option.
+#
+# We allow any stringified name for the source.
+# For example, this syntax is correct because we accept any key
+# in the original hash of arguments, but give them proper names:
+#
+# ```ruby
+# class Foo
+#   extend Dry::Initializer
+#
+#   option "", as: :first
+#   option 1,  as: :second
+# end
+#
+# foo = Foo.new("": 42, 1: 666)
+# foo.first  # => 42
+# foo.second # => 666
+# ```
+#
+module Dry::Initializer::Dispatchers::PrepareSource
+  module_function
+
+  def call(source:, **options)
+    { source: source.to_s.to_sym, **options }
+  end
+end

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

@@ -0,0 +1,44 @@
+#
+# Prepares the target name of a parameter or an option.
+#
+# Unlike source, the target must satisfy requirements for Ruby variable names.
+# It also shouldn't be in conflict with names used by the gem.
+#
+module Dry::Initializer::Dispatchers::PrepareTarget
+  extend self
+
+  # List of variable names reserved by the gem
+  RESERVED = %i[
+    __dry_initializer_options__
+    __dry_initializer_config__
+    __dry_initializer_value__
+    __dry_initializer_definition__
+    __dry_initializer_initializer__
+  ].freeze
+
+  def call(source:, target: nil, as: nil, **options)
+    target ||= as || source
+    target = target.to_s.to_sym.downcase
+
+    check_ruby_name!(target)
+    check_reserved_names!(target)
+
+    { source: source, target: target, **options }
+  end
+
+  private
+
+  def check_ruby_name!(target)
+    return if target[/\A[[:alpha:]_][[:alnum:]_]*\??\z/u]
+
+    raise ArgumentError,
+          "The name `#{target}` is not allowed for Ruby methods"
+  end
+
+  def check_reserved_names!(target)
+    return unless RESERVED.include?(target)
+
+    raise ArgumentError,
+          "The method name `#{target}` is reserved by the dry-initializer gem"
+  end
+end

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/struct.rb

@@ -0,0 +1,40 @@
+#
+# 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).transform_keys(&:to_sym)
+    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)
+      .transform_values { |v| __hashify(v) }
+      .stringify_keys
+  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/spec/definition_spec.rb

@@ -22,7 +22,9 @@ describe "definition" do
         [definition.source, definition.options]
       end
 
-      expect(params).to eq [[:foo, { as: :foo, reader: :public }]]
+      expect(params).to eq [
+        [:foo, { as: :foo, reader: :public, optional: false }]
+      ]
     end
 
     it "preservers definition options" do
@@ -30,7 +32,9 @@ describe "definition" do
         [definition.source, definition.options]
       end
 
-      expect(options).to eq [[:bar, { as: :bar, reader: :public }]]
+      expect(options).to eq [
+        [:bar, { as: :bar, reader: :public, optional: false }]
+      ]
     end
   end
 

data/spec/list_type_spec.rb

@@ -0,0 +1,32 @@
+require "dry-types"
+
+describe "list type argument" do
+  before do
+    class Test::Foo
+      extend Dry::Initializer
+      param  :foo, [proc(&:to_s)]
+      option :bar, [Dry::Types["strict.string"]]
+      option :baz, []
+    end
+  end
+
+  context "with single items" do
+    subject { Test::Foo.new(1, bar: "2", baz: { qux: :QUX }) }
+
+    it "coerces and wraps them to arrays" do
+      expect(subject.foo).to eq %w[1]
+      expect(subject.bar).to eq %w[2]
+      expect(subject.baz).to eq [{ qux: :QUX }]
+    end
+  end
+
+  context "with arrays" do
+    subject { Test::Foo.new([1], bar: %w[2], baz: [{ qux: :QUX }]) }
+
+    it "coerces elements" do
+      expect(subject.foo).to eq %w[1]
+      expect(subject.bar).to eq %w[2]
+      expect(subject.baz).to eq [{ qux: :QUX }]
+    end
+  end
+end

data/spec/nested_type_spec.rb

@@ -0,0 +1,44 @@
+describe "nested type argument" do
+  subject { Test::Xyz.new("bar" => { "baz" => 42 }) }
+
+  context "with nested definition only" do
+    before do
+      class Test::Xyz
+        extend Dry::Initializer
+
+        param :foo, as: :x do
+          option :bar, as: :y do
+            option :baz, proc(&:to_s), as: :z
+            option :qux, as: :w, optional: true
+          end
+        end
+      end
+    end
+
+    it "builds the type" do
+      expect(subject.x.y.z).to eq "42"
+    end
+  end
+
+  context "with nested and wrapped definitions" do
+    before do
+      class Test::Xyz
+        extend Dry::Initializer
+
+        param :foo, [], as: :x do
+          option :bar, as: :y do
+            option :baz, proc(&:to_s), as: :z
+            option :qux, as: :w, optional: true
+          end
+        end
+      end
+    end
+
+    it "builds the type" do
+      x = subject.x
+      expect(x).to be_instance_of Array
+
+      expect(x.first.y.z).to eq "42"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,8 @@
 require "dry/initializer"
+
 begin
   require "pry"
-rescue
+rescue LoadError
   nil
 end
 

data/spec/type_constraint_spec.rb

@@ -42,7 +42,7 @@ describe "type constraint" do
     context "in case of mismatch" do
       subject { Test::Foo.new 1 }
 
-      it "raises TypeError" do
+      it "raises ArgumentError" do
         expect { subject }.to raise_error TypeError, /1/
       end
     end
@@ -66,13 +66,13 @@ describe "type constraint" do
   end
 
   context "by invalid constraint" do
-    it "raises TypeError" do
+    it "raises ArgumentError" do
       expect do
         class Test::Foo
           extend Dry::Initializer
           param :foo, type: String
         end
-      end.to raise_error(TypeError)
+      end.to raise_error(ArgumentError)
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dry-initializer
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Vladimir Kochnev (marshall-lee)
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-16 00:00:00.000000000 Z
+date: 2019-04-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -103,10 +103,22 @@ files:
 - lib/dry/initializer/config.rb
 - lib/dry/initializer/definition.rb
 - lib/dry/initializer/dispatchers.rb
+- lib/dry/initializer/dispatchers/build_nested_type.rb
+- lib/dry/initializer/dispatchers/check_type.rb
+- lib/dry/initializer/dispatchers/prepare_default.rb
+- lib/dry/initializer/dispatchers/prepare_ivar.rb
+- lib/dry/initializer/dispatchers/prepare_optional.rb
+- lib/dry/initializer/dispatchers/prepare_reader.rb
+- lib/dry/initializer/dispatchers/prepare_source.rb
+- lib/dry/initializer/dispatchers/prepare_target.rb
+- lib/dry/initializer/dispatchers/unwrap_type.rb
+- lib/dry/initializer/dispatchers/wrap_type.rb
 - lib/dry/initializer/dsl.rb
 - lib/dry/initializer/mixin.rb
 - lib/dry/initializer/mixin/local.rb
 - lib/dry/initializer/mixin/root.rb
+- lib/dry/initializer/struct.rb
+- lib/dry/initializer/undefined.rb
 - lib/tasks/benchmark.rake
 - lib/tasks/profile.rake
 - spec/attributes_spec.rb
@@ -116,7 +128,9 @@ files:
 - spec/default_values_spec.rb
 - spec/definition_spec.rb
 - spec/invalid_default_spec.rb
+- spec/list_type_spec.rb
 - spec/missed_default_spec.rb
+- spec/nested_type_spec.rb
 - spec/optional_spec.rb
 - spec/options_tolerance_spec.rb
 - spec/public_attributes_utility_spec.rb
@@ -128,7 +142,7 @@ files:
 - spec/type_argument_spec.rb
 - spec/type_constraint_spec.rb
 - spec/value_coercion_via_dry_types_spec.rb
-homepage: https://github.com/dryrb/dry-initializer
+homepage: https://github.com/dry-rb/dry-initializer
 licenses:
 - MIT
 metadata: {}
@@ -147,8 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: DSL for declaring params and options of the initializer
@@ -160,7 +173,9 @@ test_files:
 - spec/default_values_spec.rb
 - spec/definition_spec.rb
 - spec/invalid_default_spec.rb
+- spec/list_type_spec.rb
 - spec/missed_default_spec.rb
+- spec/nested_type_spec.rb
 - spec/optional_spec.rb
 - spec/options_tolerance_spec.rb
 - spec/public_attributes_utility_spec.rb