dry-initializer 0.0.1

data/benchmarks/without_options.rb

@@ -0,0 +1,52 @@
+Bundler.require(:benchmarks)
+
+class PlainRubyTest
+  attr_reader :foo, :bar
+
+  def initialize(foo:, bar:)
+    @foo = foo
+    @bar = bar
+  end
+end
+
+require "dry-initializer"
+class DryTest
+  extend Dry::Initializer
+
+  option :foo
+  option :bar
+end
+
+require "anima"
+class AnimaTest
+  include Anima.new(:foo, :bar)
+end
+
+require "kwattr"
+class KwattrTest
+  kwattr :foo, :bar
+end
+
+puts "Benchmark for instantiation without options"
+
+Benchmark.ips do |x|
+  x.config time: 15, warmup: 10
+
+  x.report("plain Ruby") do
+    PlainRubyTest.new foo: "FOO", bar: "BAR"
+  end
+
+  x.report("dry-initializer") do
+    DryTest.new foo: "FOO", bar: "BAR"
+  end
+
+  x.report("anima") do
+    AnimaTest.new foo: "FOO", bar: "BAR"
+  end
+
+  x.report("kwattr") do
+    KwattrTest.new foo: "FOO", bar: "BAR"
+  end
+
+  x.compare!
+end

data/dry-initializer.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |gem|
+  gem.name     = "dry-initializer"
+  gem.version  = "0.0.1"
+  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"
+  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.2"
+
+  gem.add_development_dependency "guard-rspec", "~> 4.0"
+  gem.add_development_dependency "rake", "~> 10.5"
+  gem.add_development_dependency "dry-types", "~> 0.5.1"
+end

data/lib/dry-initializer.rb

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

data/lib/dry/initializer.rb

@@ -0,0 +1,53 @@
+module Dry
+  # Declares arguments of the initializer (params and options)
+  #
+  # @api public
+  #
+  module Initializer
+
+    require_relative "initializer/errors"
+    require_relative "initializer/argument"
+    require_relative "initializer/arguments"
+    require_relative "initializer/builder"
+
+    # Declares a plain argument
+    #
+    # @param [#to_sym] name
+    #
+    # @option options [Object]  :default The default value
+    # @option options [#call]   :type    The type constraings via `dry-types`
+    # @option options [Boolean] :reader (true) Whether to define attr_reader
+    #
+    # @return [self] itself
+    #
+    def param(name, **options)
+      arguments_builder.define_initializer(name, option: false, **options)
+      self
+    end
+
+    # Declares a named argument
+    #
+    # @param  (see #param)
+    # @option (see #param)
+    # @return (see #param)
+    #
+    def option(name, **options)
+      arguments_builder.define_initializer(name, option: true, **options)
+      self
+    end
+
+    private
+
+    def arguments_builder
+      @arguments_builder ||= begin
+        builder = Builder.new
+        include builder.mixin
+        builder
+      end
+    end
+
+    def inherited(klass)
+      klass.instance_variable_set(:@arguments_builder, arguments_builder)
+    end
+  end
+end

data/lib/dry/initializer/argument.rb

@@ -0,0 +1,96 @@
+module Dry::Initializer
+  # A simple structure describes an argument (either param, or option)
+  #
+  # @api private
+  #
+  class Argument
+    include Errors
+
+    UNDEFINED = Object.new.freeze
+
+    # @!attribute [r] option
+    # @return [Boolean]
+    #   Whether this is an option, or param of the initializer
+    attr_reader :option
+
+    # @!attribute [r] name
+    # @return [Symbol] the name of the argument
+    attr_reader :name
+
+    # @!attribute [r] default
+    # @return [Boolean] whether the argument has a default value
+    attr_reader :default
+
+    # @!attribute [r] default_value
+    # @return [Object] the default value of the argument
+    attr_reader :default_value
+
+    # @!attribute [r] type
+    # @return [Class, nil] a type constraint
+    attr_reader :type
+
+    # @!attribute [r] reader
+    # @return [Boolean] whether an attribute reader is defined for the argument
+    attr_reader :reader
+
+    def initialize(name, option:, reader: true, **options)
+      @name   = name.to_sym
+      @option = option
+      @reader = reader
+      assign_default_value(options)
+      assign_type(options)
+    end
+
+    def ==(other)
+      other.name == name
+    end
+
+    def signature
+      case [option, default]
+      when [false, false] then name
+      when [false, true]  then "#{name} = Dry::Initializer::Argument::UNDEFINED"
+      when [true, false]  then "#{name}:"
+      else
+        "#{name}: Dry::Initializer::Argument::UNDEFINED"
+      end
+    end
+
+    def assignment
+      "@#{name} = #{name}"
+    end
+
+    def default_assignment
+      "@#{name} = instance_eval(&__arguments__[:#{name}].default_value)" \
+      " if #{name} == Dry::Initializer::Argument::UNDEFINED"
+    end
+
+    def type_constraint
+      "__arguments__[:#{name}].type.call(@#{name})"
+    end
+
+    private
+
+    def assign_default_value(options)
+      @default = options.key? :default
+      return unless @default
+
+      @default_value = options[:default]
+      return if Proc === @default_value
+
+      fail InvalidDefaultValueError.new(@default_value)
+    end
+
+    def assign_type(options)
+      return unless options.key? :type
+
+      type = options[:type]
+      type = plain_type_to_proc(type) if Module === type
+      fail InvalidTypeError.new(type) unless type.respond_to? :call
+      @type = type
+    end
+
+    def plain_type_to_proc(type)
+      proc { |value| fail TypeError.new(type, value) unless type === value }
+    end
+  end
+end

data/lib/dry/initializer/arguments.rb

@@ -0,0 +1,85 @@
+module Dry::Initializer
+  # Collection of definitions for arguments
+  #
+  # @api private
+  #
+  class Arguments
+    include Errors
+    include Enumerable
+
+    def initialize(**arguments)
+      @arguments = arguments
+    end
+
+    def add(name, options)
+      validate_uniqueness(name)
+      validate_presence_of_default(name, options)
+
+      new_argument = Argument.new(name, options)
+      self.class.new @arguments.merge(name.to_sym => new_argument)
+    end
+
+    def declaration
+      <<-RUBY
+        attr_reader #{select(&:reader).map { |arg| ":#{arg.name}" }.join(", ")}
+        define_method :initialize do |#{signature}|
+          #{assign_arguments}
+          #{take_declarations}
+          #{assign_defaults}
+          #{check_constraints}
+        end
+      RUBY
+    end
+
+    def [](name)
+      @arguments[name]
+    end
+
+    private
+
+    def each
+      @arguments.each { |_, argument| yield(argument) }
+    end
+
+    def params
+      reject(&:option)
+    end
+
+    def options
+      select(&:option)
+    end
+
+    def validate_uniqueness(name)
+      fail ExistingArgumentError.new(name) if self[name.to_sym]
+    end
+
+    def validate_presence_of_default(name, options)
+      return if options.key? :default
+      return if options[:option]
+      return unless params.any?(&:default)
+
+      fail MissedDefaultValueError.new(name)
+    end
+
+    def signature
+      (params + options).map(&:signature).join(", ")
+    end
+
+    def assign_arguments
+      map(&:assignment).join("\n")
+    end
+
+    def take_declarations
+      return unless any?(&:default) || any?(&:type)
+      "__arguments__ = self.class.send(:arguments_builder).arguments"
+    end
+
+    def assign_defaults
+      select(&:default).map(&:default_assignment).join("\n")
+    end
+
+    def check_constraints
+      select(&:type).map(&:type_constraint).join("\n")
+    end
+  end
+end

data/lib/dry/initializer/builder.rb

@@ -0,0 +1,33 @@
+module Dry::Initializer
+  # Carries declarations for arguments along with a mixin module
+  #
+  # @api private
+  #
+  class Builder
+    def arguments
+      @arguments ||= Arguments.new
+    end
+
+    def mixin
+      @mixin ||= Module.new
+    end
+
+    def define_initializer(name, **options)
+      @arguments = arguments.add(name, **options)
+      mixin.instance_eval @arguments.declaration
+    end
+
+    def define_attributes_reader(name, keys)
+      symbol_keys = keys.map { |key| ":" << key.to_s }.join(", ")
+      key = '@#{key}'
+
+      mixin.class_eval <<-RUBY
+        def #{name}
+          [#{symbol_keys}].inject({}) do |hash, key|
+            hash.merge key => instance_variable_get(:"#{key}")
+          end
+        end
+      RUBY
+    end
+  end
+end

data/lib/dry/initializer/errors.rb

@@ -0,0 +1,13 @@
+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/type_error"
+
+  end
+end

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

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

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

@@ -0,0 +1,6 @@
+class Dry::Initializer::Errors::InvalidDefaultValueError < SyntaxError
+  def initialize(value)
+    super "#{value.inspect} is set directly as a default value." \
+          " Wrap it to either proc or lambda."
+  end
+end

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

@@ -0,0 +1,6 @@
+class Dry::Initializer::Errors::InvalidTypeError < ::TypeError
+  def initialize(type)
+    super "#{type.inspect} doesn't describe a valid type." \
+          " Use either a module/class, or an object responding to #call."
+  end
+end

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

@@ -0,0 +1,5 @@
+class Dry::Initializer::Errors::KeyError < ::KeyError
+  def initialize(*keys)
+    super "Unrecognized keys: #{keys.join(", ")}."
+  end
+end

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

@@ -0,0 +1,5 @@
+class Dry::Initializer::Errors::MissedDefaultValueError < SyntaxError
+  def initialize(name)
+    super "You should set a default value for the '#{name}'."
+  end
+end

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

@@ -0,0 +1,5 @@
+class Dry::Initializer::Errors::TypeError < ::TypeError
+  def initialize(type, value)
+    super "#{value.inspect} mismatches the type #{type}."
+  end
+end

data/spec/dry/base_spec.rb

@@ -0,0 +1,21 @@
+describe "base example" do
+  before do
+    class Test::Foo
+      extend Dry::Initializer
+
+      param  :foo
+      param  :bar
+      option :baz
+      option :qux
+    end
+  end
+
+  it "instantiates attributes" do
+    subject = Test::Foo.new(1, 2, baz: 3, qux: 4)
+
+    expect(subject.foo).to eql 1
+    expect(subject.bar).to eql 2
+    expect(subject.baz).to eql 3
+    expect(subject.qux).to eql 4
+  end
+end

data/spec/dry/default_nil_spec.rb

@@ -0,0 +1,17 @@
+describe "default nil" do
+  before do
+    class Test::Foo
+      extend Dry::Initializer
+
+      param :foo, default: proc { nil }
+      param :bar, default: proc { nil }
+    end
+  end
+
+  it "is assigned" do
+    subject = Test::Foo.new(1)
+
+    expect(subject.foo).to eql 1
+    expect(subject.bar).to be_nil
+  end
+end