dry-initializer 3.0.4 → 3.1.0

data/lib/dry/initializer/config.rb

@@ -1,184 +1,186 @@
-module Dry::Initializer
-  #
-  # Gem-related configuration of some class
-  #
-  class Config
-    # @!attribute [r] null
-    # @return [Dry::Initializer::UNDEFINED, nil] value of unassigned variable
-
-    # @!attribute [r] extended_class
-    # @return [Class] the class whose config collected by current object
-
-    # @!attribute [r] parent
-    # @return [Dry::Initializer::Config] parent configuration
-
-    # @!attribute [r] definitions
-    # @return [Hash<Symbol, Dry::Initializer::Definition>]
-    #   hash of attribute definitions with their source names
-
-    attr_reader :null, :extended_class, :parent, :definitions
-
-    # @!attribute [r] mixin
-    # @return [Module] reference to the module to be included into class
-    def mixin
-      @mixin ||= Module.new.tap do |mod|
-        __dry_initializer__ = self
-        mod.extend(Mixin::Local)
-        mod.send :define_method, :__dry_initializer_config__ do
-          __dry_initializer__
+# frozen_string_literal: true
+
+module Dry
+  module Initializer
+    #
+    # Gem-related configuration of some class
+    #
+    class Config
+      # @!attribute [r] null
+      # @return [Dry::Initializer::UNDEFINED, nil] value of unassigned variable
+
+      # @!attribute [r] extended_class
+      # @return [Class] the class whose config collected by current object
+
+      # @!attribute [r] parent
+      # @return [Dry::Initializer::Config] parent configuration
+
+      # @!attribute [r] definitions
+      # @return [Hash<Symbol, Dry::Initializer::Definition>]
+      #   hash of attribute definitions with their source names
+
+      attr_reader :null, :extended_class, :parent, :definitions
+
+      # @!attribute [r] mixin
+      # @return [Module] reference to the module to be included into class
+      def mixin
+        @mixin ||= Module.new.tap do |mod|
+          initializer = self
+          mod.extend(Mixin::Local)
+          mod.define_method(:__dry_initializer_config__) do
+            initializer
+          end
+          mod.send :private, :__dry_initializer_config__
         end
-        mod.send :private, :__dry_initializer_config__
       end
-    end
 
-    # List of configs of all subclasses of the [#extended_class]
-    # @return [Array<Dry::Initializer::Config>]
-    def children
-      @children ||= Set.new
-    end
+      # List of configs of all subclasses of the [#extended_class]
+      # @return [Array<Dry::Initializer::Config>]
+      def children
+        @children ||= Set.new
+      end
 
-    # List of definitions for initializer params
-    # @return [Array<Dry::Initializer::Definition>]
-    def params
-      definitions.values.reject(&:option)
-    end
+      # List of definitions for initializer params
+      # @return [Array<Dry::Initializer::Definition>]
+      def params
+        definitions.values.reject(&:option)
+      end
 
-    # List of definitions for initializer options
-    # @return [Array<Dry::Initializer::Definition>]
-    def options
-      definitions.values.select(&:option)
-    end
+      # List of definitions for initializer options
+      # @return [Array<Dry::Initializer::Definition>]
+      def options
+        definitions.values.select(&:option)
+      end
 
-    # Adds or redefines a parameter
-    # @param  [Symbol]       name
-    # @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, &block)
-      add_definition(false, name, type, block, **opts)
-    end
+      # Adds or redefines a parameter
+      # @param  [Symbol]       name
+      # @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, &block)
+        add_definition(false, name, type, block, **opts)
+      end
 
-    # Adds or redefines an option of [#dry_initializer]
-    #
-    # @param  (see #param)
-    # @option (see #param)
-    # @return (see #param)
-    #
-    def option(name, type = nil, **opts, &block)
-      add_definition(true, name, type, block, **opts)
-    end
+      # Adds or redefines an option of [#dry_initializer]
+      #
+      # @param  (see #param)
+      # @option (see #param)
+      # @return (see #param)
+      #
+      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]
-    # @param  [Dry::Initializer::Instance] instance
-    # @return [Hash<Symbol, Object>]
-    def public_attributes(instance)
-      definitions.values.each_with_object({}) do |item, obj|
-        key = item.target
-        next unless instance.respond_to? key
+      # The hash of public attributes for an instance of the [#extended_class]
+      # @param  [Dry::Initializer::Instance] instance
+      # @return [Hash<Symbol, Object>]
+      def public_attributes(instance)
+        definitions.values.each_with_object({}) do |item, obj|
+          key = item.target
+          next unless instance.respond_to? key
 
-        val = instance.send(key)
-        obj[key] = val unless null == val
+          val = instance.send(key)
+          obj[key] = val unless null == val
+        end
       end
-    end
 
-    # The hash of assigned attributes for an instance of the [#extended_class]
-    # @param  [Dry::Initializer::Instance] instance
-    # @return [Hash<Symbol, Object>]
-    def attributes(instance)
-      definitions.values.each_with_object({}) do |item, obj|
-        key = item.target
-        val = instance.send(:instance_variable_get, item.ivar)
-        obj[key] = val unless null == val
+      # The hash of assigned attributes for an instance of the [#extended_class]
+      # @param  [Dry::Initializer::Instance] instance
+      # @return [Hash<Symbol, Object>]
+      def attributes(instance)
+        definitions.values.each_with_object({}) do |item, obj|
+          key = item.target
+          val = instance.send(:instance_variable_get, item.ivar)
+          obj[key] = val unless null == val
+        end
       end
-    end
 
-    # Code of the `#__initialize__` method
-    # @return [String]
-    def code
-      Builders::Initializer[self]
-    end
+      # Code of the `#__initialize__` method
+      # @return [String]
+      def code
+        Builders::Initializer[self]
+      end
 
-    # Finalizes config
-    # @return [self]
-    def finalize
-      @definitions = final_definitions
-      check_order_of_params
-      mixin.class_eval(code)
-      children.each(&:finalize)
-      self
-    end
+      # Finalizes config
+      # @return [self]
+      def finalize
+        @definitions = final_definitions
+        check_order_of_params
+        mixin.class_eval(code)
+        children.each(&:finalize)
+        self
+      end
 
-    # Human-readable representation of configured params and options
-    # @return [String]
-    def inch
-      line  =  Builders::Signature[self]
-      line  =  line.gsub('__dry_initializer_options__', 'options')
-      lines =  ["@!method initialize(#{line})"]
-      lines += ["Initializes an instance of #{extended_class}"]
-      lines += definitions.values.map(&:inch)
-      lines += ["@return [#{extended_class}]"]
-      lines.join("\n")
-    end
+      # Human-readable representation of configured params and options
+      # @return [String]
+      def inch
+        line  =  Builders::Signature[self]
+        line  =  line.gsub("__dry_initializer_options__", "options")
+        lines =  ["@!method initialize(#{line})"]
+        lines += ["Initializes an instance of #{extended_class}"]
+        lines += definitions.values.map(&:inch)
+        lines += ["@return [#{extended_class}]"]
+        lines.join("\n")
+      end
 
-    private
+      private
 
-    def initialize(extended_class = nil, null: UNDEFINED)
-      @extended_class = extended_class.tap { |klass| klass&.include mixin }
-      sklass          = extended_class&.superclass
-      @parent         = sklass.dry_initializer if sklass.is_a? Dry::Initializer
-      @null           = null || parent&.null
-      @definitions    = {}
-      finalize
-    end
+      def initialize(extended_class = nil, null: UNDEFINED)
+        @extended_class = extended_class.tap { |klass| klass&.include mixin }
+        sklass          = extended_class&.superclass
+        @parent         = sklass.dry_initializer if sklass.is_a? Dry::Initializer
+        @null           = null || parent&.null
+        @definitions    = {}
+        finalize
+      end
 
-    # 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 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
 
-    def final_definitions
-      parent_definitions = Hash(parent&.definitions&.dup)
-      definitions.each_with_object(parent_definitions) do |(key, val), obj|
-        obj[key] = check_type(obj[key], val)
+      def final_definitions
+        parent_definitions = Hash(parent&.definitions&.dup)
+        definitions.each_with_object(parent_definitions) do |(key, val), obj|
+          obj[key] = check_type(obj[key], val)
+        end
       end
-    end
 
-    def check_type(previous, current)
-      return current unless previous
-      return current if previous.option == current.option
+      def check_type(previous, current)
+        return current unless previous
+        return current if previous.option == current.option
 
-      raise SyntaxError,
-            "cannot reload #{previous} of #{extended_class.superclass}" \
-            " by #{current} of its subclass #{extended_class}"
-    end
+        raise SyntaxError,
+              "cannot reload #{previous} of #{extended_class.superclass}" \
+              " by #{current} of its subclass #{extended_class}"
+      end
 
-    def check_order_of_params
-      params.inject(nil) do |optional, current|
-        if current.optional
-          current
-        elsif optional
-          raise SyntaxError, "#{extended_class}: required #{current}" \
-                             " goes after optional #{optional}"
-        else
-          optional
+      def check_order_of_params
+        params.inject(nil) do |optional, current|
+          if current.optional
+            current
+          elsif optional
+            raise SyntaxError, "#{extended_class}: required #{current}" \
+                              " goes after optional #{optional}"
+          else
+            optional
+          end
         end
       end
     end

data/lib/dry/initializer/definition.rb

@@ -1,65 +1,69 @@
-module Dry::Initializer
-  #
-  # @private
-  # @abstract
-  #
-  # Base class for parameter or option definitions
-  # Defines methods to add corresponding reader to the class,
-  # and build value of instance attribute.
-  #
-  class Definition
-    attr_reader :option, :null, :source, :target, :ivar,
-                :type, :optional, :default, :reader,
-                :desc
+# frozen_string_literal: true
 
-    def options
-      {
-        as: target,
-        type: type,
-        optional: optional,
-        default: default,
-        reader: reader,
-        desc: desc
-      }.reject { |_, value| value.nil? }
-    end
+module Dry
+  module Initializer
+    #
+    # @private
+    # @abstract
+    #
+    # Base class for parameter or option definitions
+    # Defines methods to add corresponding reader to the class,
+    # and build value of instance attribute.
+    #
+    class Definition
+      attr_reader :option, :null, :source, :target, :ivar,
+                  :type, :optional, :default, :reader,
+                  :desc
 
-    def name
-      @name ||= (option ? 'option' : 'parameter') << " '#{source}'"
-    end
-    alias to_s    name
-    alias to_str  name
-    alias inspect name
+      def options
+        {
+          as: target,
+          type: type,
+          optional: optional,
+          default: default,
+          reader: reader,
+          desc: desc
+        }.compact
+      end
 
-    def ==(other)
-      other.instance_of?(self.class) && (other.source == source)
-    end
+      def name
+        @name ||= "#{option ? "option" : "parameter"} '#{source}'"
+      end
+      alias_method :to_s, :name
+      alias_method :to_str, :name
+      alias_method :inspect, :name
 
-    def code
-      Builders::Reader[self]
-    end
+      def ==(other)
+        other.instance_of?(self.class) && (other.source == source)
+      end
 
-    def inch
-      @inch ||= (option ? '@option' : '@param ').tap do |text|
-        text << ' [Object]'
-        text << (option ? " :#{source}" : " #{source}")
-        text << (optional ? ' (optional)' : ' (required)')
-        text << " #{desc}" if desc
+      def code
+        Builders::Reader[self]
       end
-    end
 
-    private
+      def inch
+        @inch ||= (option ? "@option" : "@param ").tap do |text|
+          text << " [Object]"
+          text << (option ? " :#{source}" : " #{source}")
+          text << (optional ? " (optional)" : " (required)")
+          text << " #{desc}" if desc
+        end
+      end
 
-    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]
+      private
+
+      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
     end
   end
 end

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

@@ -1,4 +1,5 @@
-#
+# frozen_string_literal: true
+
 # Prepare nested data type from a block
 #
 # @example
@@ -7,53 +8,66 @@
 #     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
+module Dry
+  module Initializer
+    module Dispatchers
+      module BuildNestedType
+        extend self
 
-  private
+        # 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
 
-  def check_certainty!(source, type, block)
-    return unless block
-    return unless type
+        private
 
-    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_certainty!(source, type, block)
+          return unless block
+          return unless type
 
-  def check_name!(name, block)
-    return unless block
-    return unless name[/^_|__|_$/]
+          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
 
-    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 check_name!(name, block)
+          return unless block
+          return unless name[/^_|__|_$/]
 
-  def build_nested_type(parent, name, block)
-    return unless block
+          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
 
-    klass_name = full_name(parent, name)
-    build_struct(klass_name, block)
-  end
+        def build_nested_type(parent, name, block)
+          return unless block
 
-  def full_name(parent, name)
-    "::#{parent.name}::#{name.to_s.split("_").compact.map(&:capitalize).join}"
-  end
+          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) }
+        def build_struct(klass_name, block)
+          # rubocop: disable Security/Eval
+          # rubocop: disable Style/DocumentDynamicEvalDefinition
+          eval <<~RUBY, TOPLEVEL_BINDING, __FILE__, __LINE__ + 1
+            class #{klass_name} < Dry::Initializer::Struct
+            end
+          RUBY
+          # rubocop: enable Style/DocumentDynamicEvalDefinition
+          # rubocop: enable Security/Eval
+          const_get(klass_name).tap { _1.class_eval(&block) }
+        end
+      end
+    end
   end
 end