dry-initializer 3.0.2

data/dry-initializer.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |gem|
+  gem.name     = "dry-initializer"
+  gem.version  = "3.0.2"
+  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

data/lib/dry/initializer/config.rb

@@ -0,0 +1,184 @@
+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__
+        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 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
+
+    # 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
+
+    # 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
+      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
+      end
+    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
+
+    # 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
+
+    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 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
+
+    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
+
+    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
+end