dry-initializer 3.0.2 → 3.1.1

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

@@ -1,43 +1,49 @@
-#
+# frozen_string_literal: true
+
 # 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
+module Dry
+  module Initializer
+    module Dispatchers
+      module 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
+      end
+    end
   end
-  # rubocop: enable Metrics/MethodLength
 end

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

@@ -1,40 +1,47 @@
-#
+# frozen_string_literal: true
+
 # Prepares the `:default` option
 #
 # It must respond to `.call` without arguments
 #
-module Dry::Initializer::Dispatchers::PrepareDefault
-  extend self
+module Dry
+  module Initializer
+    module Dispatchers
+      module PrepareDefault
+        extend self
 
-  def call(default: nil, optional: nil, **options)
-    default = callable! default
-    check_arity! default
+        def call(default: nil, optional: nil, **options)
+          default = callable! default
+          check_arity! default
 
-    { default: default, optional: (optional | default), **options }
-  end
+          {default: default, optional: (optional | default), **options}
+        end
 
-  private
+        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)
+        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
+          invalid!(default)
+        end
 
-  def check_arity!(default)
-    return unless default
+        def check_arity!(default)
+          return unless default
 
-    arity = default.method(:call).arity.to_i
-    return unless arity.positive?
+          arity = default.method(:call).arity.to_i
+          return unless arity.positive?
 
-    invalid!(default)
-  end
+          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."
+        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
+    end
   end
 end

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

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

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

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

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

@@ -1,30 +1,37 @@
-#
+# frozen_string_literal: true
+
 # Checks the reader privacy
 #
-module Dry::Initializer::Dispatchers::PrepareReader
-  extend self
+module Dry
+  module Initializer
+    module Dispatchers
+      module 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
+        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
+          {target: target, reader: reader, **options}
+        end
 
-  private
+        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
+        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
+    end
   end
 end

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

@@ -1,4 +1,5 @@
-#
+# frozen_string_literal: true
+
 # The dispatcher verifies a correctness of the source name
 # of param or option, taken as a `:source` option.
 #
@@ -19,10 +20,16 @@
 # foo.second # => 666
 # ```
 #
-module Dry::Initializer::Dispatchers::PrepareSource
-  module_function
+module Dry
+  module Initializer
+    module Dispatchers
+      module PrepareSource
+        module_function
 
-  def call(source:, **options)
-    { source: source.to_s.to_sym, **options }
+        def call(source:, **options)
+          {source: source.to_s.to_sym, **options}
+        end
+      end
+    end
   end
 end

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

@@ -1,44 +1,51 @@
-#
+# frozen_string_literal: true
+
 # 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"
+module Dry
+  module Initializer
+    module Dispatchers
+      module 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
+    end
   end
 end

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

@@ -1,22 +1,33 @@
-#
+# frozen_string_literal: true
+
 # 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
+module Dry
+  module Initializer
+    module Dispatchers
+      module UnwrapType
+        extend self
 
-  def call(type: nil, wrap: 0, **options)
-    type, wrap = unwrap(type, 0)
+        def call(type: nil, wrap: 0, **options)
+          type, count = unwrap(type, wrap)
 
-    { type: type, wrap: wrap, **options }
-  end
+          {type: type, wrap: count, **options}
+        end
 
-  private
+        private
 
-  def unwrap(type, count)
-    type.is_a?(Array) ? unwrap(type.first, count + 1) : [type, count]
+        def unwrap(type, count)
+          if type.is_a?(::Array)
+            unwrap(type.first, count + 1)
+          else
+            [type, count]
+          end
+        end
+      end
+    end
   end
 end

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

@@ -1,27 +1,35 @@
-#
+# frozen_string_literal: true
+
 # Takes `:type` and `:wrap` to construct the final value coercer
 #
-module Dry::Initializer::Dispatchers::WrapType
-  extend self
+module Dry
+  module Initializer
+    module Dispatchers
+      module WrapType
+        extend self
 
-  def call(type: nil, wrap: 0, **options)
-    { type: wrapped_type(type, wrap), **options }
-  end
+        def call(type: nil, wrap: 0, **options)
+          {type: wrapped_type(type, wrap), **options}
+        end
 
-  private
+        private
 
-  def wrapped_type(type, count)
-    return type if count.zero?
+        def wrapped_type(type, count)
+          return type if count.zero?
 
-    ->(value) { wrap_value(value, count, type) }
-  end
+          ->(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)
 
-  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) }
+            value.map { |item| wrap_value(item, count - 1, type) }
+          end
+        end
+      end
     end
   end
 end

data/lib/dry/initializer/dispatchers.rb

@@ -1,4 +1,5 @@
-#
+# frozen_string_literal: true
+
 # The module is responsible for __normalizing__ arguments
 # of `.param` and `.option`.
 #
@@ -60,53 +61,57 @@
 #     param :id, integer: true
 #   end
 #
-module Dry::Initializer::Dispatchers
-  extend self
+module Dry
+  module Initializer
+    module Dispatchers
+      extend self
 
-  # @!attribute [rw] null Defines a value to be set to unassigned attributes
-  # @return [Object]
-  attr_accessor :null
+      # @!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
+      #
+      # 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
+      #
+      # 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
+      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"
+      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
-    ]
+      def pipeline
+        @pipeline ||= [
+          PrepareSource, PrepareTarget, PrepareIvar, PrepareReader,
+          PrepareDefault, PrepareOptional,
+          UnwrapType, CheckType, BuildNestedType, WrapType
+        ]
+      end
+    end
   end
 end