dry-initializer 0.1.1 → 0.2.0

data/benchmarks/with_types.rb

@@ -12,8 +12,10 @@ class PlainRubyTest
 end
 
 require "dry-initializer"
+require "dry/initializer/types"
 class DryTest
   extend Dry::Initializer::Mixin
+  extend Dry::Initializer::Types
 
   option :foo, type: String
   option :bar, type: String

data/benchmarks/with_types_and_defaults.rb

@@ -12,8 +12,10 @@ class PlainRubyTest
 end
 
 require "dry-initializer"
+require "dry/initializer/types"
 class DryTest
   extend Dry::Initializer::Mixin
+  extend Dry::Initializer::Types
 
   option :foo, type: String, default: proc { "FOO" }
   option :bar, type: String, default: proc { "BAR" }

data/dry-initializer.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name     = "dry-initializer"
-  gem.version  = "0.1.1"
+  gem.version  = "0.2.0"
   gem.author   = ["Vladimir Kochnev (marshall-lee)", "Andrew Kozin (nepalez)"]
   gem.email    = ["hashtable@yandex.ru", "andrew.kozin@gmail.com"]
   gem.homepage = "https://github.com/dryrb/dry-initializer"

data/lib/dry/initializer.rb

@@ -4,16 +4,17 @@ module Dry
   # @api public
   #
   module Initializer
-
     require_relative "initializer/errors"
-    require_relative "initializer/argument"
-    require_relative "initializer/arguments"
+    require_relative "initializer/plugins"
+    require_relative "initializer/signature"
     require_relative "initializer/builder"
     require_relative "initializer/mixin"
 
+    UNDEFINED = Object.new.freeze
+
     def self.define(proc = nil, &block)
       Module.new do |container|
-        container.extend Dry::Initializer::Mixin
+        container.extend Mixin
         container.instance_exec(&(proc || block))
       end
     end

data/lib/dry/initializer/builder.rb

@@ -1,33 +1,86 @@
 module Dry::Initializer
-  # Carries declarations for arguments along with a mixin module
+  # Rebuilds the initializer every time a new argument defined
   #
   # @api private
   #
   class Builder
-    def arguments
-      @arguments ||= Arguments.new
+    include Plugins
+
+    def initialize
+      @signature = Signature.new
+      @plugins   = Set.new [VariableSetter, TypeConstraint, DefaultProc]
+      @parts     = []
+    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]
+    #
+    def register(plugin)
+      @plugins << plugin
+    end
+
+    # Defines new agrument and rebuilds the initializer
+    #
+    # @param [#to_sym] name
+    # @param [Hash<Symbol, Object>] settings
+    #
+    # @return [self] itself
+    #
+    def define(name, settings)
+      update_signature(name, settings)
+      update_parts(name, settings)
+
+      define_reader(name, settings)
+      reload_initializer
+      reload_callback
+
+      self
     end
 
+    # The module with two methods: `#initialize` and `##__after_initialize__`
+    # to be mixed into the target class
+    #
+    # @return [Module]
+    #
     def mixin
       @mixin ||= Module.new
     end
 
-    def define_initializer(name, **options)
-      @arguments = arguments.add(name, **options)
-      mixin.instance_eval @arguments.declaration
+    private
+
+    def update_signature(name, settings)
+      @signature.add(name, settings)
+    end
+
+    def update_parts(name, settings)
+      @parts += @plugins.map { |klass| klass.call(name, settings) }.compact
+    end
+
+    def define_reader(name, settings)
+      mixin.send :attr_reader, name unless settings[:reader] == false
     end
 
-    def define_attributes_reader(name, keys)
-      symbol_keys = keys.map { |key| ":" << key.to_s }.join(", ")
-      key = '@#{key}'
+    def reload_initializer
+      strings = @parts.select { |part| String === part }
 
       mixin.class_eval <<-RUBY
-        def #{name}
-          [#{symbol_keys}].inject({}) do |hash, key|
-            hash.merge key => instance_variable_get(:"#{key}")
-          end
+        def initialize(#{@signature.call})
+          #{strings.join("\n")}
+          __after_initialize__
         end
       RUBY
     end
+
+    def reload_callback
+      blocks = @parts.select { |part| Proc === part }
+
+      mixin.send :define_method, :__after_initialize__ do
+        blocks.each { |block| instance_eval(&block) }
+      end
+
+      mixin.send :private, :__after_initialize__
+    end
   end
 end

data/lib/dry/initializer/errors.rb

@@ -1,13 +1,11 @@
 module Dry::Initializer
   # Collection of gem-specific exceptions
   module Errors
-
-    require_relative "errors/existing_argument_error"
-    require_relative "errors/invalid_default_value_error"
-    require_relative "errors/invalid_type_error"
-    require_relative "errors/key_error"
-    require_relative "errors/missed_default_value_error"
+    require_relative "errors/default_value_error"
+    require_relative "errors/order_error"
+    require_relative "errors/plugin_error"
+    require_relative "errors/redefinition_error"
     require_relative "errors/type_error"
-
+    require_relative "errors/type_constraint_error"
   end
 end

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

@@ -0,0 +1,6 @@
+class Dry::Initializer::Errors::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

data/lib/dry/initializer/errors/order_error.rb

@@ -0,0 +1,7 @@
+class Dry::Initializer::Errors::OrderError < SyntaxError
+  def initialize(name)
+    super "Cannot define the required param '#{name}' after optional ones." \
+          " Either provide a default value for the '#{name}', or declare it" \
+          " before params with default values."
+  end
+end

data/lib/dry/initializer/errors/plugin_error.rb

@@ -0,0 +1,6 @@
+class Dry::Initializer::Errors::PluginError < TypeError
+  def initialize(plugin)
+    super "#{plugin} is not a valid plugin." \
+          " Use a subclass of Dry::Initialier::Plugins::Base."
+  end
+end

data/lib/dry/initializer/errors/{existing_argument_error.rb → redefinition_error.rb}

@@ -1,4 +1,4 @@
-class Dry::Initializer::Errors::ExistingArgumentError < SyntaxError
+class Dry::Initializer::Errors::RedefinitionError < SyntaxError
   def initialize(name)
     super "The argument '#{name}' is already defined."
   end

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

@@ -0,0 +1,6 @@
+class Dry::Initializer::Errors::TypeConstraintError < TypeError
+  def initialize(name, type)
+    super "#{type} is inacceptable constraint for the argument '#{name}'." \
+          " Use either plain Ruby module/class, or dry-type."
+  end
+end

data/lib/dry/initializer/errors/type_error.rb

@@ -1,5 +1,6 @@
-class Dry::Initializer::Errors::TypeError < ::TypeError
-  def initialize(type, value)
-    super "#{value.inspect} mismatches the type #{type}."
+class Dry::Initializer::Errors::TypeError < TypeError
+  def initialize(name, type, value)
+    super "A value #{value.inspect} assigned to the argument '#{name}'" \
+          " mismatches type constraint: #{type}."
   end
 end

data/lib/dry/initializer/mixin.rb

@@ -12,7 +12,7 @@ module Dry::Initializer
     # @return [self] itself
     #
     def param(name, **options)
-      arguments_builder.define_initializer(name, option: false, **options)
+      initializer_builder.define(name, option: false, **options)
       self
     end
 
@@ -23,22 +23,22 @@ module Dry::Initializer
     # @return (see #param)
     #
     def option(name, **options)
-      arguments_builder.define_initializer(name, option: true, **options)
+      initializer_builder.define(name, option: true, **options)
       self
     end
 
-    private
-
-    def arguments_builder
-      @arguments_builder ||= begin
+    # @private
+    def initializer_builder
+      @initializer_builder ||= begin
         builder = Builder.new
         include builder.mixin
         builder
       end
     end
 
+    # @private
     def inherited(klass)
-      klass.instance_variable_set(:@arguments_builder, arguments_builder)
+      klass.instance_variable_set(:@initializer_builder, initializer_builder)
     end
   end
 end

data/lib/dry/initializer/plugins.rb

@@ -0,0 +1,10 @@
+module Dry::Initializer
+  # Namespace for code plugins builders
+  module Plugins
+    require_relative "plugins/base"
+    require_relative "plugins/default_proc"
+    require_relative "plugins/signature"
+    require_relative "plugins/type_constraint"
+    require_relative "plugins/variable_setter"
+  end
+end

data/lib/dry/initializer/plugins/base.rb

@@ -0,0 +1,42 @@
+module Dry::Initializer::Plugins
+  # Base class for plugins
+  #
+  # A plugin should has class method [.call] that takes argument name and
+  # settings and return a chunk of code for the #initialize method body.
+  #
+  class Base
+    include Dry::Initializer::Errors
+
+    # Builds the proc for the `__after_initializer__` callback
+    #
+    # @param [#to_s] name
+    # @param [Hash<Symbol, Object>] settings
+    #
+    # @return [String, Proc, nil]
+    #
+    def self.call(name, settings)
+      new(name, settings).call
+    end
+
+    # @private
+    attr_reader :name, :settings
+
+    # Initializes a builder with argument name and settings
+    # @param (see .call)
+    def initialize(name, settings)
+      @name     = name
+      @settings = settings
+    end
+
+    # Checks equality to another instance by name
+    # @return [Boolean]
+    def ==(other)
+      other.instance_of?(self.class) && (other.name == name)
+    end
+
+    # Builds a chunk of code
+    # @return (see .call)
+    def call
+    end
+  end
+end

data/lib/dry/initializer/plugins/default_proc.rb

@@ -0,0 +1,28 @@
+module Dry::Initializer::Plugins
+  # Builds a block to be evaluated by initializer (__after_initialize__)
+  # to assign a default value to the argument
+  class DefaultProc < Base
+    def call
+      return unless default
+
+      ivar = :"@#{name}"
+      default_proc = default
+
+      proc do
+        if instance_variable_get(ivar) == Dry::Initializer::UNDEFINED
+          instance_variable_set ivar, instance_eval(&default_proc)
+        end
+      end
+    end
+
+    private
+
+    def default
+      return unless settings.key? :default
+
+      @default ||= settings[:default].tap do |value|
+        fail DefaultValueError.new(name, value) unless Proc === value
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Dry::Initializer::Plugins
+  # Plugin builds a chunk of code for the initializer's signature:
+  #
+  # @example
+  #   Signature.call(:user, option: true)
+  #   # => "user:"
+  #
+  #   Signature.call(:user, default: -> { nil })
+  #   # => "user = Dry::Initializer::UNDEFINED"
+  #
+  class Signature < Base
+    def param?
+      settings[:option] != true
+    end
+
+    def default?
+      settings.key? :default
+    end
+
+    def call
+      case [param?, default?]
+      when [true, false]  then name.to_s
+      when [false, false] then "#{name}:"
+      when [true, true]   then "#{name} = #{undefined}"
+      when [false, true]  then "#{name}: #{undefined}"
+      end
+    end
+
+    private
+
+    def undefined
+      @undefined ||= "Dry::Initializer::UNDEFINED"
+    end
+  end
+end

data/lib/dry/initializer/plugins/type_constraint.rb

@@ -0,0 +1,58 @@
+module Dry::Initializer::Plugins
+  # Plugin builds either chunk of code for the #initializer,
+  # or a proc for the ##__after_initialize__ callback.
+  class TypeConstraint < Base
+    def call
+      return unless settings.key? :type
+      dry_type_constraint || module_type_constraint || object_type_constraint
+    end
+
+    private
+
+    def type
+      @type ||= settings[:type]
+    end
+
+    def dry_type?
+      type.class.ancestors.map(&:name).include? "Dry::Types::Builder"
+    end
+
+    def plain_type?
+      Module === type
+    end
+
+    def module_type_constraint
+      return unless plain_type?
+
+      "fail #{TypeError}.new(:#{name}, #{type}, @#{name})" \
+      " unless @#{name} == Dry::Initializer::UNDEFINED ||" \
+      " #{type} === @#{name}"
+    end
+
+    def dry_type_constraint
+      return unless dry_type?
+
+      ivar = :"@#{name}"
+      constraint = type
+
+      lambda do |*|
+        value = instance_variable_get(ivar)
+        return if value == Dry::Initializer::UNDEFINED
+
+        instance_variable_set ivar, constraint[value]
+      end
+    end
+
+    def object_type_constraint
+      ivar = :"@#{name}"
+      constraint = type
+
+      lambda do |*|
+        value = instance_variable_get(ivar)
+        return if value == Dry::Initializer::UNDEFINED
+
+        fail TypeError.new(ivar, constraint, value) unless constraint === value
+      end
+    end
+  end
+end

data/lib/dry/initializer/plugins/variable_setter.rb

@@ -0,0 +1,12 @@
+module Dry::Initializer::Plugins
+  # Plugin builds a code for variable setter:
+  #
+  # @example
+  #   VariableSetter.call(:user, {}) # => "@user = user"
+  #
+  class VariableSetter < Base
+    def call
+      "@#{name} = #{name}"
+    end
+  end
+end