dry-initializer 2.3.0 → 3.0.2

data/dry-initializer.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |gem|
   gem.name     = "dry-initializer"
-  gem.version  = "2.3.0"
+  gem.version  = "3.0.2"
   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"
 
@@ -16,5 +16,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "rspec", "~> 3.0"
   gem.add_development_dependency "rake", "> 10"
   gem.add_development_dependency "dry-types", "> 0.5.1"
-  gem.add_development_dependency "rubocop", "~> 0.42"
+  gem.add_development_dependency "rubocop", "~> 0.49.0"
 end

data/lib/dry/initializer.rb

@@ -6,14 +6,13 @@ 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"
     require_relative "initializer/config"
     require_relative "initializer/mixin"
+    require_relative "initializer/dispatchers"
 
     # Adds methods [.[]] and [.define]
     extend DSL
@@ -26,24 +25,25 @@ module Dry
 
     # Adds or redefines a parameter of [#dry_initializer]
     # @param  [Symbol]       name
-    # @param  [#call, nil]   coercer (nil)
-    # @option opts [#call]   :type
+    # @param  [#call, nil]   type (nil)
     # @option opts [Proc]    :default
     # @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, 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, 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/builders/attribute.rb

@@ -60,22 +60,22 @@ module Dry::Initializer::Builders
 
     def default_line
       return unless @default
-      "#{@val} = instance_exec(&#{@item}.default) if #{@val} == #{@null}"
+      "#{@val} = instance_exec(&#{@item}.default) if #{@null} == #{@val}"
     end
 
     def coercion_line
       return unless @type
       arity = @type.is_a?(Proc) ? @type.arity : @type.method(:call).arity
       if arity.abs == 1
-        "#{@val} = #{@item}.type.call(#{@val}) unless #{@val} == #{@null}"
+        "#{@val} = #{@item}.type.call(#{@val}) unless #{@null} == #{@val}"
       else
-        "#{@val} = #{@item}.type.call(#{@val}, self) unless #{@val} == #{@null}"
+        "#{@val} = #{@item}.type.call(#{@val}, self) unless #{@null} == #{@val}"
       end
     end
 
     def assignment_line
       "#{@ivar} = #{@val}" \
-      " unless #{@val} == #{@null} && instance_variable_defined?(:#{@ivar})"
+      " unless #{@null} == #{@val} && instance_variable_defined?(:#{@ivar})"
     end
   end
 end

data/lib/dry/initializer/builders/reader.rb

@@ -38,7 +38,7 @@ module Dry::Initializer::Builders
       return unless @null
       [
         "def #{@target}",
-        "  #{@ivar} unless #{@ivar} == Dry::Initializer::UNDEFINED",
+        "  #{@ivar} unless Dry::Initializer::UNDEFINED == #{@ivar}",
         "end"
       ]
     end

data/lib/dry/initializer/config.rb

@@ -51,15 +51,14 @@ module Dry::Initializer
 
     # Adds or redefines a parameter
     # @param  [Symbol]       name
-    # @param  [#call, nil]   coercer (nil)
-    # @option opts [#call]   :type
+    # @param  [#call, nil]   type (nil)
     # @option opts [Proc]    :default
     # @option opts [Boolean] :optional
     # @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]
@@ -68,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]
@@ -80,7 +79,7 @@ module Dry::Initializer
         key = item.target
         next unless instance.respond_to? key
         val = instance.send(key)
-        obj[key] = val unless val == null
+        obj[key] = val unless null == val
       end
     end
 
@@ -91,7 +90,7 @@ module Dry::Initializer
       definitions.values.each_with_object({}) do |item, obj|
         key = item.target
         val = instance.send(:instance_variable_get, item.ivar)
-        obj[key] = val unless val == null
+        obj[key] = val unless null == val
       end
     end
 
@@ -134,13 +133,25 @@ module Dry::Initializer
       finalize
     end
 
-    def add_definition(option, name, type, opts)
-      definition = Definition.new(option, null, name, type, 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

@@ -0,0 +1,112 @@
+#
+# 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
+
+  #
+  # Registers a new dispatcher
+  #
+  # @param [#call] dispatcher
+  # @return [self] itself
+  #
+  def <<(dispatcher)
+    @pipeline = [dispatcher] + pipeline
+    self
+  end
+
+  #
+  # Normalizes the source set of options
+  #
+  # @param [Hash<Symbol, Object>] options
+  # @return [Hash<Symbol, Objct>] normalized set of options
+  #
+  def call(**options)
+    options = { null: null, **options }
+    pipeline.reduce(options) { |opts, dispatcher| dispatcher.call(**opts) }
+  end
+
+  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 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,59 @@
+#
+# 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, block)
+    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 block
+    return unless type
+
+    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, block)
+    return unless block
+    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