dry-initializer 0.11.0 → 1.1.0

data/Gemfile

@@ -21,6 +21,7 @@ group :benchmarks do
   gem "value_struct"
   gem "values"
   gem "virtus"
+  gem "ruby-prof"
 end
 
 group :development, :test do

data/Rakefile

@@ -45,3 +45,9 @@ namespace :benchmark do
     system "ruby benchmarks/options.rb"
   end
 end
+
+desc "Runs profiler"
+task :profile do
+  system "ruby benchmarks/profiler.rb && " \
+         "dot -Tpng ./tmp/profile.dot > ./tmp/profile.png"
+end

data/benchmarks/options.rb

@@ -18,15 +18,15 @@ end
 class TypesTest
   extend Dry::Initializer::Mixin
 
-  param  :foo, type: String
-  option :bar, type: String
+  param  :foo, proc(&:to_s)
+  option :bar, proc(&:to_s)
 end
 
 class DefaultsAndTypesTest
   extend Dry::Initializer::Mixin
 
-  param  :foo, type: String, default: proc { "FOO" }
-  option :bar, type: String, default: proc { "BAR" }
+  param  :foo, proc(&:to_s), default: proc { "FOO" }
+  option :bar, proc(&:to_s), default: proc { "BAR" }
 end
 
 puts "Benchmark for various options"

data/benchmarks/params.rb

@@ -13,7 +13,7 @@ StructTest = Struct.new(:foo, :bar)
 
 require "dry-initializer"
 class DryTest
-  extend Dry::Initializer::Mixin
+  extend Dry::Initializer
 
   param :foo
   param :bar

data/benchmarks/profiler.rb

@@ -0,0 +1,28 @@
+require "dry-initializer"
+require "ruby-prof"
+require "fileutils"
+
+class User
+  extend Dry::Initializer
+
+  param  :first_name,  proc(&:to_s), default: proc { "Unknown" }
+  param  :second_name, proc(&:to_s), default: proc { "Unknown" }
+  option :email,       proc(&:to_s), optional: true
+  option :phone,       proc(&:to_s), optional: true
+end
+
+result = RubyProf.profile do
+  1_000.times { User.new :Andy, email: :"andy@example.com" }
+end
+
+FileUtils.mkdir_p "./tmp"
+
+FileUtils.touch "./tmp/profile.dot"
+File.open("./tmp/profile.dot", "w+") do |output|
+  RubyProf::DotPrinter.new(result).print(output, min_percent: 0)
+end
+
+FileUtils.touch "./tmp/profile.html"
+File.open("./tmp/profile.html", "w+") do |output|
+  RubyProf::CallStackPrinter.new(result).print(output, min_percent: 0)
+end

data/benchmarks/with_types.rb

@@ -3,22 +3,18 @@ Bundler.require(:benchmarks)
 class PlainRubyTest
   attr_reader :foo, :bar
 
-  def initialize(foo:, bar:)
-    @foo = foo
-    @bar = bar
-    fail TypeError unless String === @foo
-    fail TypeError unless String === @bar
+  def initialize(options)
+    @foo = options[:foo].to_s
+    @bar = options[:bar].to_s
   end
 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
+  option :foo, &(:to_s)
+  option :bar, &(:to_s)
 end
 
 require "virtus"

data/benchmarks/with_types_and_defaults.rb

@@ -12,13 +12,11 @@ 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" }
+  option :foo, proc(&:to_s), default: proc { "FOO" }
+  option :bar, proc(&:to_s), default: proc { "BAR" }
 end
 
 require "virtus"

data/benchmarks/without_options.rb

@@ -3,9 +3,9 @@ Bundler.require(:benchmarks)
 class PlainRubyTest
   attr_reader :foo, :bar
 
-  def initialize(foo:, bar:)
-    @foo = foo
-    @bar = bar
+  def initialize(options = {})
+    @foo = options[:foo]
+    @bar = options[:bar]
   end
 end
 

data/dry-initializer.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |gem|
   gem.name     = "dry-initializer"
-  gem.version  = "0.11.0"
+  gem.version  = "1.1.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/attribute.rb

@@ -0,0 +1,92 @@
+module Dry::Initializer
+  # Contains definitions for a single attribute, and builds its parts of mixin
+  class Attribute
+    class << self
+      # Collection of additional dispatchers for method options
+      #
+      # @example Enhance the gem by adding :coercer alias for type
+      #   Dry::Initializer::Attribute.dispatchers << -> (string: nil, **op) do
+      #     op[:type] = proc(&:to_s) if string
+      #     op
+      #   end
+      #
+      #   class User
+      #     extend Dry::Initializer
+      #     param :name, string: true # same as `type: proc(&:to_s)`
+      #   end
+      #
+      def dispatchers
+        @@dispatchers ||= []
+      end
+
+      def new(source, coercer = nil, **options)
+        options[:source] = source
+        options[:target] = options.delete(:as) || source
+        options[:type] ||= coercer
+        params = dispatchers.inject(options) { |h, m| m.call(h) }
+
+        super(params)
+      end
+
+      def param(*args)
+        Param.new(*args)
+      end
+
+      def option(*args)
+        Option.new(*args)
+      end
+    end
+
+    attr_reader :source, :target, :coercer, :default, :optional, :reader
+
+    def initialize(options)
+      @source   = options[:source]
+      @target   = options[:target]
+      @coercer  = options[:type]
+      @default  = options[:default]
+      @optional = !!(options[:optional] || @default)
+      @reader   = options.fetch(:reader, :public)
+      validate
+    end
+
+    def ==(other)
+      source == other.source
+    end
+
+    # 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 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,104 @@
-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, Attribute.param(*args))
+      validate_collections
+    end
+
+    def option(*args)
+      @options = insert(@options, Attribute.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
+
+    private
 
     def initialize
-      @signature = Signature.new
-      @plugins   = Set.new [VariableSetter, TypeConstraint, DefaultProc]
-      @parts     = []
+      @params  = []
+      @options = []
     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 }
+    def insert(collection, new_item)
+      index = collection.index(new_item) || collection.count
+      collection.dup.tap { |list| list[index] = new_item }
     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
-      end
+    def code
+      <<-RUBY.gsub(/^ +\|/, "")
+        |def __initialize__(#{initializer_signatures})
+        |  @__options__ = __options__
+        |#{initializer_presetters}
+        |#{initializer_setters}
+        |end
+        |private :__initialize__
+        |private :__defaults__
+        |private :__coercers__
+        |
+        |#{getters}
+      RUBY
     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 attributes
+      @params + @options
     end
 
-    private
+    def duplications
+      attributes.group_by(&:target)
+                .reject { |_, val| val.count == 1 }
+                .keys
+    end
 
-    def copy(&block)
-      dup.tap { |instance| instance.instance_eval(&block) }
+    def initializer_signatures
+      sig = @params.map(&:initializer_signature).compact.uniq
+      sig << (sig.any? && @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
+      dups = duplications
+      attributes
+        .map { |a| "  #{a.presetter}" if dups.include? a.target }
+        .compact.uniq.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
+      dups = duplications
+      attributes.map do |a|
+        dups.include?(a.target) ? "  #{a.safe_setter}" : "  #{a.fast_setter}"
+      end.compact.uniq.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