dry-initializer 3.0.1

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

@@ -0,0 +1,43 @@
+module Dry::Initializer
+  # Module-level DSL
+  module DSL
+    # Setting for null (undefined value)
+    # @return [nil, Dry::Initializer::UNDEFINED]
+    attr_reader :null
+
+    # Returns a version of the module with custom settings
+    # @option settings [Boolean] :undefined
+    #   If unassigned params and options should be treated different from nil
+    # @return [Dry::Initializer]
+    def [](undefined: true, **)
+      null = (undefined == false) ? nil : UNDEFINED
+      Module.new.tap do |mod|
+        mod.extend DSL
+        mod.include self
+        mod.send(:instance_variable_set, :@null, null)
+      end
+    end
+
+    # Returns mixin module to be included to target class by hand
+    # @return [Module]
+    # @yield proc defining params and options
+    def define(procedure = nil, &block)
+      config = Config.new(null: null)
+      config.instance_exec(&(procedure || block))
+      config.mixin.include Mixin::Root
+      config.mixin
+    end
+
+    private
+
+    def extended(klass)
+      config = Config.new(klass, null: null)
+      klass.send :instance_variable_set, :@dry_initializer, config
+      klass.include Mixin::Root
+    end
+
+    def self.extended(mod)
+      mod.instance_variable_set :@null, UNDEFINED
+    end
+  end
+end

data/lib/dry/initializer/mixin.rb

@@ -0,0 +1,15 @@
+module Dry::Initializer
+  # @private
+  module Mixin
+    extend  DSL              # @deprecated
+    include Dry::Initializer # @deprecated
+    def self.extended(klass) # @deprecated
+      warn "[DEPRECATED] Use Dry::Initializer instead of its alias" \
+           " Dry::Initializer::Mixin. The later will be removed in v2.1.0"
+      super
+    end
+
+    require_relative "mixin/root"
+    require_relative "mixin/local"
+  end
+end

data/lib/dry/initializer/mixin/local.rb

@@ -0,0 +1,19 @@
+module Dry::Initializer::Mixin
+  # @private
+  module Local
+    attr_reader :klass
+
+    def inspect
+      "Dry::Initializer::Mixin::Local[#{klass}]"
+    end
+    alias to_s   inspect
+    alias to_str inspect
+
+    private
+
+    def included(klass)
+      @klass = klass
+      super
+    end
+  end
+end

data/lib/dry/initializer/mixin/root.rb

@@ -0,0 +1,10 @@
+module Dry::Initializer::Mixin
+  # @private
+  module Root
+    private
+
+    def initialize(*args)
+      __dry_initializer_initialize__(*args)
+    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/lib/tasks/benchmark.rake

@@ -0,0 +1,41 @@
+namespace :benchmark do
+  desc "Runs benchmarks for plain params"
+  task :plain_params do
+    system "ruby benchmarks/plain_params.rb"
+  end
+
+  desc "Runs benchmarks for plain options"
+  task :plain_options do
+    system "ruby benchmarks/plain_options.rb"
+  end
+
+  desc "Runs benchmarks for value coercion"
+  task :with_coercion do
+    system "ruby benchmarks/with_coercion.rb"
+  end
+
+  desc "Runs benchmarks with defaults"
+  task :with_defaults do
+    system "ruby benchmarks/with_defaults.rb"
+  end
+
+  desc "Runs benchmarks with defaults and coercion"
+  task :with_defaults_and_coercion do
+    system "ruby benchmarks/with_defaults_and_coercion.rb"
+  end
+
+  desc "Runs benchmarks for several defaults"
+  task :compare_several_defaults do
+    system "ruby benchmarks/with_several_defaults.rb"
+  end
+end
+
+desc "Runs all benchmarks"
+task benchmark: %i[
+  benchmark:plain_params
+  benchmark:plain_options
+  benchmark:with_coercion
+  benchmark:with_defaults
+  benchmark:with_defaults_and_coercion
+  benchmark:compare_several_defaults
+]

data/lib/tasks/profile.rake

@@ -0,0 +1,78 @@
+namespace :profile do
+  def profile(name, execution, &definition)
+    require "dry-initializer"
+    require "ruby-prof"
+    require "fileutils"
+
+    definition.call
+    result = RubyProf.profile do
+      1_000.times { execution.call }
+    end
+
+    FileUtils.mkdir_p "./tmp"
+
+    FileUtils.touch "./tmp/#{name}.dot"
+    File.open("./tmp/#{name}.dot", "w+") do |output|
+      RubyProf::DotPrinter.new(result).print(output, min_percent: 0)
+    end
+
+    FileUtils.touch "./tmp/#{name}.html"
+    File.open("./tmp/#{name}.html", "w+") do |output|
+      RubyProf::CallStackPrinter.new(result).print(output, min_percent: 0)
+    end
+
+    system "dot -Tpng ./tmp/#{name}.dot > ./tmp/#{name}.png"
+  end
+
+  desc "Profiles initialization with required param and option"
+  task :required do
+    profile("required", -> { User.new :Andy, email: "andy@example.com" }) do
+      class User
+        extend Dry::Initializer
+        param  :name
+        option :email
+      end
+    end
+  end
+
+  desc "Profiles initialization with default param and option"
+  task :defaults do
+    profile("defaults", -> { User.new }) do
+      class User
+        extend Dry::Initializer
+        param  :name,  default: -> { :Andy }
+        option :email, default: -> { "andy@example.com" }
+      end
+    end
+  end
+
+  desc "Profiles initialization with coerced param and option"
+  task :coercion do
+    profile("coercion", -> { User.new :Andy, email: :"andy@example.com" }) do
+      class User
+        extend Dry::Initializer
+        param  :name,  proc(&:to_s)
+        option :email, proc(&:to_s)
+      end
+    end
+  end
+
+  desc "Profiles initialization with coerced defaults of param and option"
+  task :default_coercion do
+    profile("default_coercion", -> { User.new }) do
+      class User
+        extend Dry::Initializer
+        param  :name,  proc(&:to_s), default: -> { :Andy }
+        option :email, proc(&:to_s), default: -> { :"andy@example.com" }
+      end
+    end
+  end
+end
+
+desc "Makes all profiling at once"
+task profile: %i[
+  profile:required
+  profile:defaults
+  profile:coercion
+  profile:default_coercion
+]