dry-initializer 2.3.0 → 3.0.2

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/mixin/root.rb

@@ -6,5 +6,6 @@ module Dry::Initializer::Mixin
     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/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/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,48 @@
+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
+
+    it "converts the nested type to hash" do
+      expect(subject.x.to_h).to eq("y" => { "z" => "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