dry-initializer 3.0.1

data/benchmarks/with_defaults.rb

@@ -0,0 +1,66 @@
+Bundler.require(:benchmarks)
+
+require "dry-initializer"
+class DryTest
+  extend Dry::Initializer[undefined: false]
+
+  option :foo, default: -> { "FOO" }
+  option :bar, default: -> { "BAR" }
+end
+
+class DryTestUndefined
+  extend Dry::Initializer
+
+  option :foo, default: -> { "FOO" }
+  option :bar, default: -> { "BAR" }
+end
+
+class PlainRubyTest
+  attr_reader :foo, :bar
+
+  def initialize(foo: "FOO", bar: "BAR")
+    @foo = foo
+    @bar = bar
+  end
+end
+
+require "kwattr"
+class KwattrTest
+  kwattr foo: "FOO", bar: "BAR"
+end
+
+require "active_attr"
+class ActiveAttrTest
+  include ActiveAttr::AttributeDefaults
+
+  attribute :foo, default: "FOO"
+  attribute :bar, default: "BAR"
+end
+
+puts "Benchmark for instantiation with default values"
+
+Benchmark.ips do |x|
+  x.config time: 15, warmup: 10
+
+  x.report("plain Ruby") do
+    PlainRubyTest.new
+  end
+
+  x.report("dry-initializer") do
+    DryTest.new
+  end
+
+  x.report("dry-initializer (with UNDEFINED)") do
+    DryTestUndefined.new
+  end
+
+  x.report("kwattr") do
+    KwattrTest.new
+  end
+
+  x.report("active_attr") do
+    ActiveAttrTest.new
+  end
+
+  x.compare!
+end

data/benchmarks/with_defaults_and_coercion.rb

@@ -0,0 +1,59 @@
+Bundler.require(:benchmarks)
+
+require "dry-initializer"
+class DryTest
+  extend Dry::Initializer[undefined: false]
+
+  option :foo, proc(&:to_s), default: -> { "FOO" }
+  option :bar, proc(&:to_s), default: -> { "BAR" }
+end
+
+class DryTestUndefined
+  extend Dry::Initializer
+
+  option :foo, proc(&:to_s), default: -> { "FOO" }
+  option :bar, proc(&:to_s), default: -> { "BAR" }
+end
+
+class PlainRubyTest
+  attr_reader :foo, :bar
+
+  def initialize(foo: "FOO", bar: "BAR")
+    @foo = foo
+    @bar = bar
+    raise TypeError unless String === @foo
+    raise TypeError unless String === @bar
+  end
+end
+
+require "virtus"
+class VirtusTest
+  include Virtus.model
+
+  attribute :foo, String, default: "FOO"
+  attribute :bar, String, default: "BAR"
+end
+
+puts "Benchmark for instantiation with type constraints and default values"
+
+Benchmark.ips do |x|
+  x.config time: 15, warmup: 10
+
+  x.report("plain Ruby") do
+    PlainRubyTest.new
+  end
+
+  x.report("dry-initializer") do
+    DryTest.new
+  end
+
+  x.report("dry-initializer (with UNDEFINED)") do
+    DryTest.new
+  end
+
+  x.report("virtus") do
+    VirtusTest.new
+  end
+
+  x.compare!
+end

data/dry-initializer.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |gem|
+  gem.name     = "dry-initializer"
+  gem.version  = "3.0.1"
+  gem.author   = ["Vladimir Kochnev (marshall-lee)", "Andrew Kozin (nepalez)"]
+  gem.email    = "andrew.kozin@gmail.com"
+  gem.homepage = "https://github.com/dry-rb/dry-initializer"
+  gem.summary  = "DSL for declaring params and options of the initializer"
+  gem.license  = "MIT"
+
+  gem.files            = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  gem.test_files       = gem.files.grep(/^spec/)
+  gem.extra_rdoc_files = Dir["README.md", "LICENSE", "CHANGELOG.md"]
+
+  gem.required_ruby_version = ">= 2.3"
+
+  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.49.0"
+end

data/lib/dry-initializer.rb

@@ -0,0 +1 @@
+require_relative "dry/initializer"

data/lib/dry/initializer.rb

@@ -0,0 +1,61 @@
+require "set"
+
+# Namespace for gems in a dry-rb community
+module Dry
+  #
+  # DSL for declaring params and options of class initializers
+  #
+  module Initializer
+    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
+
+    # Gem-related configuration
+    # @return [Dry::Initializer::Config]
+    def dry_initializer
+      @dry_initializer ||= Config.new(self)
+    end
+
+    # Adds or redefines a parameter of [#dry_initializer]
+    # @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
+    # @yield block with nested definition
+    # @return [self] itself
+    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, &block)
+      dry_initializer.option(name, type, **opts, &block)
+      self
+    end
+
+    private
+
+    def inherited(klass)
+      super
+      config = Config.new(klass, null: dry_initializer.null)
+      klass.send(:instance_variable_set, :@dry_initializer, config)
+      dry_initializer.children << config
+    end
+
+    require_relative "initializer/struct"
+  end
+end

data/lib/dry/initializer/builders.rb

@@ -0,0 +1,7 @@
+module Dry::Initializer
+  # @private
+  module Builders
+    require_relative "builders/reader"
+    require_relative "builders/initializer"
+  end
+end

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

@@ -0,0 +1,81 @@
+module Dry::Initializer::Builders
+  # @private
+  class Attribute
+    def self.[](definition)
+      new(definition).call
+    end
+
+    def call
+      lines.compact
+    end
+
+    private
+
+    # rubocop: disable Metrics/MethodLength
+    def initialize(definition)
+      @definition = definition
+      @option     = definition.option
+      @type       = definition.type
+      @optional   = definition.optional
+      @default    = definition.default
+      @source     = definition.source
+      @ivar       = definition.ivar
+      @null       = definition.null ? "Dry::Initializer::UNDEFINED" : "nil"
+      @opts       = "__dry_initializer_options__"
+      @congif     = "__dry_initializer_config__"
+      @item       = "__dry_initializer_definition__"
+      @val        = @option ? "__dry_initializer_value__" : @source
+    end
+    # rubocop: enable Metrics/MethodLength
+
+    def lines
+      [
+        "",
+        definition_line,
+        reader_line,
+        default_line,
+        coercion_line,
+        assignment_line
+      ]
+    end
+
+    def reader_line
+      return unless @option
+      @optional ? optional_reader : required_reader
+    end
+
+    def optional_reader
+      "#{@val} = #{@opts}.fetch(:'#{@source}', #{@null})"
+    end
+
+    def required_reader
+      "#{@val} = #{@opts}.fetch(:'#{@source}')" \
+      " { raise KeyError, \"\#{self.class}: #{@definition} is required\" }"
+    end
+
+    def definition_line
+      return unless @type || @default
+      "#{@item} = __dry_initializer_config__.definitions[:'#{@source}']"
+    end
+
+    def default_line
+      return unless @default
+      "#{@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 #{@null} == #{@val}"
+      else
+        "#{@val} = #{@item}.type.call(#{@val}, self) unless #{@null} == #{@val}"
+      end
+    end
+
+    def assignment_line
+      "#{@ivar} = #{@val}" \
+      " unless #{@null} == #{@val} && instance_variable_defined?(:#{@ivar})"
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Dry::Initializer::Builders
+  # @private
+  class Initializer
+    require_relative "signature"
+    require_relative "attribute"
+
+    def self.[](config)
+      new(config).call
+    end
+
+    def call
+      lines.flatten.compact.join("\n")
+    end
+
+    private
+
+    def initialize(config)
+      @config = config
+      @definitions = config.definitions.values
+    end
+
+    def lines
+      [
+        undef_line,
+        define_line,
+        params_lines,
+        options_lines,
+        end_line
+      ]
+    end
+
+    def undef_line
+      "undef :__dry_initializer_initialize__" \
+      " if private_method_defined? :__dry_initializer_initialize__"
+    end
+
+    def define_line
+      "private def __dry_initializer_initialize__(#{Signature[@config]})"
+    end
+
+    def params_lines
+      @definitions.reject(&:option)
+                  .flat_map { |item| Attribute[item] }
+                  .map { |line| "  " << line }
+    end
+
+    def options_lines
+      @definitions.select(&:option)
+                  .flat_map { |item| Attribute[item] }
+                  .map { |line| "  " << line }
+    end
+
+    def end_line
+      "end"
+    end
+
+    def private_line
+      "private :__dry_initializer_initialize__"
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Dry::Initializer::Builders
+  # @private
+  class Reader
+    def self.[](definition)
+      new(definition).call
+    end
+
+    def call
+      lines.flatten.compact.join("\n")
+    end
+
+    private
+
+    def initialize(definition)
+      @target = definition.target
+      @ivar   = definition.ivar
+      @null   = definition.null
+      @reader = definition.reader
+    end
+
+    def lines
+      [undef_line, attribute_line, method_lines, type_line]
+    end
+
+    def undef_line
+      "undef :#{@target} if method_defined?(:#{@target})" \
+      "  || private_method_defined?(:#{@target})" \
+      "  || protected_method_defined?(:#{@target})"
+    end
+
+    def attribute_line
+      return unless @reader
+      "attr_reader :#{@target}" unless @null
+    end
+
+    def method_lines
+      return unless @reader
+      return unless @null
+      [
+        "def #{@target}",
+        "  #{@ivar} unless Dry::Initializer::UNDEFINED == #{@ivar}",
+        "end"
+      ]
+    end
+
+    def type_line
+      "#{@reader} :#{@target}" if %i[private protected].include? @reader
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Dry::Initializer::Builders
+  # @private
+  class Signature
+    def self.[](config)
+      new(config).call
+    end
+
+    def call
+      [*required_params, *optional_params, "*", options].compact.join(", ")
+    end
+
+    private
+
+    def initialize(config)
+      @config  = config
+      @options = config.options.any?
+      @null    = config.null ? "Dry::Initializer::UNDEFINED" : "nil"
+    end
+
+    def required_params
+      @config.params.reject(&:optional).map(&:source)
+    end
+
+    def optional_params
+      @config.params.select(&:optional).map { |rec| "#{rec.source} = #{@null}" }
+    end
+
+    def options
+      "**__dry_initializer_options__" if @options
+    end
+  end
+end