dry-initializer 0.11.0 → 1.0.0

data/lib/dry/initializer.rb

@@ -1,22 +1,86 @@
 module Dry
-  # Declares arguments of the initializer (params and options)
-  #
-  # @api public
-  #
   module Initializer
-    require_relative "initializer/errors"
-    require_relative "initializer/plugins"
-    require_relative "initializer/signature"
+    require_relative "initializer/exceptions/default_value_error"
+    require_relative "initializer/exceptions/type_constraint_error"
+    require_relative "initializer/exceptions/params_order_error"
+
+    require_relative "initializer/attribute"
+    require_relative "initializer/param"
+    require_relative "initializer/option"
     require_relative "initializer/builder"
-    require_relative "initializer/mixin"
 
-    UNDEFINED = Object.new.freeze
+    # rubocop: disable Style/ConstantName
+    Mixin = self # for compatibility to versions below 0.12
+    # rubocop: enable Style/ConstantName
+
+    UNDEFINED = Object.new.tap do |obj|
+      obj.define_singleton_method(:inspect) { "Dry::Initializer::UNDEFINED" }
+    end.freeze
+
+    class << self
+      def extended(klass)
+        super
+        mixin   = klass.send(:__initializer_mixin__)
+        builder = klass.send(:__initializer_builder__)
+
+        builder.call(mixin)
+        klass.include(mixin)
+        klass.send(:define_method, :initialize) do |*args|
+          __initialize__(*args)
+        end
+      end
+
+      def define(fn = nil, &block)
+        mixin = Module.new do
+          def initialize(*args)
+            __initialize__(*args)
+          end
+        end
 
-    def self.define(proc = nil, &block)
-      Module.new do |container|
-        container.extend Mixin
-        container.instance_exec(&(proc || block))
+        builder = Builder.new
+        builder.instance_exec(&(fn || block))
+        builder.call(mixin)
+        mixin
       end
+
+      def mixin(fn = nil, &block)
+        define(fn, &block)
+      end
+    end
+
+    def param(*args)
+      __initializer_builder__.param(*args).call(__initializer_mixin__)
+    end
+
+    def option(*args)
+      __initializer_builder__.option(*args).call(__initializer_mixin__)
+    end
+
+    private
+
+    def __initializer_mixin__
+      @__initializer_mixin__ ||= Module.new do
+        def initialize(*args)
+          __initialize__(*args)
+        end
+      end
+    end
+
+    def __initializer_builder__
+      @__initializer_builder__ ||= Dry::Initializer::Builder.new
+    end
+
+    def inherited(klass)
+      builder = @__initializer_builder__.dup
+      mixin   = Module.new
+
+      klass.instance_variable_set :@__initializer_builder__, builder
+      klass.instance_variable_set :@__initializer_mixin__,   mixin
+
+      builder.call(mixin)
+      klass.include mixin
+
+      super
     end
   end
 end

data/lib/dry/initializer/attribute.rb

@@ -0,0 +1,52 @@
+module Dry::Initializer
+  # Contains definitions for a single attribute, and builds its parts of mixin
+  class Attribute
+    attr_reader :source, :target, :coercer, :default, :optional, :reader
+
+    # definition for the getter method
+    def getter
+      return unless reader
+      command = %w(private protected).include?(reader.to_s) ? reader : :public
+
+      <<-RUBY.gsub(/^ *\|/, "")
+        |def #{target}
+        |  @#{target} unless @#{target} == Dry::Initializer::UNDEFINED
+        |end
+        |#{command} :#{target}
+      RUBY
+    end
+
+    private
+
+    def initialize(source, coercer = nil, **options)
+      @source   = source
+      @target   = options.fetch(:as, source)
+      @coercer  = coercer || options[:type]
+      @reader   = options.fetch(:reader, :public)
+      @default  = options[:default]
+      @optional = !!(options[:optional] || @default)
+      validate
+    end
+
+    def validate
+      validate_target
+      validate_default
+      validate_coercer
+    end
+
+    def validate_target
+      return if target =~ /\A\w+\Z/
+      fail ArgumentError.new("Invalid name '#{target}' for the target variable")
+    end
+
+    def validate_default
+      return if default.nil? || default.is_a?(Proc)
+      fail DefaultValueError.new(source, default)
+    end
+
+    def validate_coercer
+      return if coercer.nil? || coercer.respond_to?(:call)
+      fail TypeConstraintError.new(source, coercer)
+    end
+  end
+end

data/lib/dry/initializer/builder.rb

@@ -1,100 +1,107 @@
-require "set"
 module Dry::Initializer
-  # Rebuilds the initializer every time a new argument defined
-  #
-  # @api private
-  #
   class Builder
-    include Plugins
+    def param(*args)
+      @params = insert(@params, Param, *args)
+      validate_collections
+    end
 
-    def initialize
-      @signature = Signature.new
-      @plugins   = Set.new [VariableSetter, TypeConstraint, DefaultProc]
-      @parts     = []
+    def option(*args)
+      @options = insert(@options, Option, *args)
+      validate_collections
+    end
+
+    def call(mixin)
+      defaults = send(:defaults)
+      coercers = send(:coercers)
+      mixin.send(:define_method, :__defaults__) { defaults }
+      mixin.send(:define_method, :__coercers__) { coercers }
+      mixin.class_eval(code, __FILE__, __LINE__ + 1)
     end
 
-    # Register new plugin to be applied as a chunk of code, or a proc
-    # to be evaluated in the instance's scope
-    #
-    # @param [Dry::Initializer::Plugin]
-    #
-    # @return [Dry::Initializer::Builder]
-    #
-    def register(plugin)
-      plugins = @plugins + [plugin]
-      copy { @plugins = plugins }
+    private
+
+    def initialize
+      @params  = []
+      @options = []
     end
 
-    # Defines new agrument and reloads mixin definitions
-    #
-    # @param [#to_sym] name
-    # @param [Hash<Symbol, Object>] settings
-    #
-    # @return [Dry::Initializer::Builder]
-    #
-    def define(name, settings)
-      signature = @signature.add(name, settings)
-      parts     = @parts + @plugins.map { |p| p.call(name, settings) }.compact
-
-      copy do
-        @signature = signature
-        @parts     = parts
+    def insert(collection, klass, source, *args)
+      index = collection.index { |option| option.source == source.to_s }
+
+      if index
+        new_item = klass.new(source, *args)
+        collection.dup.tap { |list| list[index] = new_item }
+      else
+        new_item = klass.new(source, *args)
+        collection + [new_item]
       end
     end
 
-    # Redeclares initializer and readers in the mixin module
-    #
-    # @param [Module] mixin
-    #
-    def call(mixin)
-      define_readers(mixin)
-      reload_initializer(mixin)
-      reload_callback(mixin)
-      mixin
+    def code
+      <<-RUBY.gsub(/^ +\|/, "")
+        |def __initialize__(#{initializer_signatures})
+        |  @__options__ = __options__
+        |#{initializer_presetters}
+        |#{initializer_setters}
+        |end
+        |private :__initialize__
+        |private :__defaults__
+        |private :__coercers__
+        |
+        |#{getters}
+      RUBY
     end
 
-    private
+    def attributes
+      @params + @options
+    end
 
-    def copy(&block)
-      dup.tap { |instance| instance.instance_eval(&block) }
+    def initializer_signatures
+      sig = @params.map(&:initializer_signature).compact.uniq
+      sig << (@options.any? ? "**__options__" : "__options__ = {}")
+      sig.join(", ")
     end
 
-    def define_readers(mixin)
-      define_reader(
-        mixin,
-        :attr_reader,
-        ->(item) { item.settings[:reader] != false }
-      )
-      define_reader mixin, :private
-      define_reader mixin, :protected
+    def initializer_presetters
+      attributes.map(&:initializer_presetter)
+                .compact
+                .uniq
+                .map { |line| "  #{line}" }
+                .join("\n")
     end
 
-    def define_reader(mixin, method, filter_lambda = nil)
-      filter_lambda ||= ->(item) { item.settings[:reader] == method }
-      readers = @signature.select(&filter_lambda).map(&:rename)
-      mixin.send method, *readers if readers.any?
+    def initializer_setters
+      attributes.map(&:initializer_setter)
+                .compact
+                .uniq
+                .map { |text| text.lines.map { |line| "  #{line}" }.join }
+                .join("\n")
     end
 
-    def reload_initializer(mixin)
-      mixin.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def __initialize__(#{@signature.call})
-          @__options__ = __options__
-          #{@parts.select { |part| String === part }.join("\n")}
-          __after_initialize__
-        end
-      RUBY
+    def getters
+      attributes.map(&:getter).compact.uniq.join("\n")
+    end
+
+    def defaults
+      attributes.map(&:default_hash).reduce({}, :merge)
+    end
 
-      mixin.send :private, :__initialize__
+    def coercers
+      attributes.map(&:coercer_hash).reduce({}, :merge)
     end
 
-    def reload_callback(mixin)
-      blocks = @parts.select { |part| Proc === part }
+    def validate_collections
+      optional_param = nil
 
-      mixin.send :define_method, :__after_initialize__ do
-        blocks.each { |block| instance_eval(&block) }
+      @params.each do |param|
+        if param.optional
+          optional_param = param.source if param.optional
+        elsif optional_param
+          fail ParamsOrderError.new(param.source, optional_param)
+        end
       end
 
-      mixin.send :private, :__after_initialize__
+      self
     end
   end
 end

data/lib/dry/initializer/exceptions/default_value_error.rb

@@ -0,0 +1,8 @@
+module Dry::Initializer
+  class DefaultValueError < TypeError
+    def initialize(name, value)
+      super "Cannot set #{value.inspect} directly as a default value" \
+            " of the argument '#{name}'. Wrap it to either proc or lambda."
+    end
+  end
+end

data/lib/dry/initializer/exceptions/params_order_error.rb

@@ -0,0 +1,8 @@
+module Dry::Initializer
+  class ParamsOrderError < SyntaxError
+    def initialize(required, optional)
+      super "Optional param '#{optional}'" \
+            " should not preceed required '#{required}'"
+    end
+  end
+end

data/lib/dry/initializer/exceptions/type_constraint_error.rb

@@ -0,0 +1,7 @@
+module Dry::Initializer
+  class TypeConstraintError < TypeError
+    def initialize(name, type)
+      super "#{type} constraint for argument '#{name}' doesn't respond to #call"
+    end
+  end
+end

data/lib/dry/initializer/option.rb

@@ -0,0 +1,55 @@
+module Dry::Initializer
+  class Option < Attribute
+    # part of __initializer__ definition
+    def initializer_signature
+      "**__options__"
+    end
+
+    # part of __initializer__ body
+    def initializer_presetter
+      "@#{target} = Dry::Initializer::UNDEFINED"
+    end
+
+    # part of __initializer__ body
+    def initializer_setter
+      "#{setter_part}#{maybe_optional}"
+    end
+
+    # part of __defaults__
+    def default_hash
+      default ? { :"option_#{source}" => default } : {}
+    end
+
+    # part of __coercers__
+    def coercer_hash
+      coercer ? { :"option_#{source}" => coercer } : {}
+    end
+
+    private
+
+    def maybe_optional
+      " if __options__.key? :'#{source}'" if optional && !default
+    end
+
+    def setter_part
+      "@#{target} = #{maybe_coerced}"
+    end
+
+    def maybe_coerced
+      return maybe_default unless coercer
+      "__coercers__[:'option_#{source}'].call(#{maybe_default})"
+    end
+
+    def maybe_default
+      "__options__.fetch(:'#{source}') { #{default_part} }"
+    end
+
+    def default_part
+      if default
+        "instance_eval(&__defaults__[:'option_#{source}'])"
+      else
+        "raise ArgumentError, \"option :'#{source}' is required\""
+      end
+    end
+  end
+end

data/lib/dry/initializer/param.rb

@@ -0,0 +1,49 @@
+module Dry::Initializer
+  class Param < Attribute
+    # part of __initializer__ definition
+    def initializer_signature
+      optional ? "#{target} = Dry::Initializer::UNDEFINED" : target
+    end
+
+    # part of __initializer__ body
+    def initializer_presetter; end
+
+    # part of __initializer__ body
+    def initializer_setter
+      "@#{target} = #{maybe_coerced}"
+    end
+
+    # part of __defaults__
+    def default_hash
+      default ? { :"param_#{target}" => default } : {}
+    end
+
+    # part of __coercers__
+    def coercer_hash
+      coercer ? { :"param_#{target}" => coercer } : {}
+    end
+
+    private
+
+    def initialize(*args, **options)
+      fail ArgumentError.new("Do not rename params") if options.key? :as
+      super
+    end
+
+    def maybe_coerced
+      return maybe_default unless coercer
+      "__coercers__[:param_#{target}].call(#{maybe_default})"
+    end
+
+    def maybe_default
+      "#{target}#{default_part}"
+    end
+
+    def default_part
+      return unless default
+      " == Dry::Initializer::UNDEFINED ?" \
+      " instance_eval(&__defaults__[:param_#{target}]) :" \
+      " #{target}"
+    end
+  end
+end