dry-initializer 0.11.0 → 1.1.0

data/lib/dry/initializer/option.rb

@@ -0,0 +1,62 @@
+module Dry::Initializer
+  class Option < Attribute
+    # part of __initializer__ definition
+    def initializer_signature
+      "**__options__"
+    end
+
+    # parts of __initalizer__
+    def presetter
+      "@#{target} = Dry::Initializer::UNDEFINED" if dispensable?
+    end
+
+    def safe_setter
+      "@#{target} = #{safe_coerced}#{maybe_optional}"
+    end
+
+    def fast_setter
+      return safe_setter unless dispensable?
+      "@#{target} = __options__.key?(:'#{source}') ? #{safe_coerced} : " \
+      "Dry::Initializer::UNDEFINED"
+    end
+
+    # part of __defaults__
+    def default_hash
+      default ? { :"option_#{source}" => default } : {}
+    end
+
+    # part of __coercers__
+    def coercer_hash
+      return {} unless coercer
+      value = proc { |v| (v == Dry::Initializer::UNDEFINED) ? v : coercer.(v) }
+      { :"option_#{source}" => value }
+    end
+
+    private
+
+    def dispensable?
+      optional && !default
+    end
+
+    def maybe_optional
+      " if __options__.key? :'#{source}'" if dispensable?
+    end
+
+    def safe_coerced
+      return safe_default unless coercer
+      "__coercers__[:'option_#{source}'].call(#{safe_default})"
+    end
+
+    def safe_default
+      "__options__.fetch(:'#{source}')#{default_part}"
+    end
+
+    def default_part
+      if default
+        " { instance_eval(&__defaults__[:'option_#{source}']) }"
+      elsif !optional
+        " { raise ArgumentError, \"option :'#{source}' is required\" }"
+      end
+    end
+  end
+end

data/lib/dry/initializer/param.rb

@@ -0,0 +1,54 @@
+module Dry::Initializer
+  class Param < Attribute
+    # part of __initializer__ definition
+    def initializer_signature
+      optional ? "#{target} = Dry::Initializer::UNDEFINED" : target
+    end
+
+    # parts of __initalizer__
+    def presetter; end
+
+    def safe_setter
+      "@#{target} = #{maybe_coerced}"
+    end
+
+    def fast_setter
+      safe_setter
+    end
+
+    # part of __defaults__
+    def default_hash
+      default ? { :"param_#{target}" => default } : {}
+    end
+
+    # part of __coercers__
+    def coercer_hash
+      return {} unless coercer
+      value = proc { |v| (v == Dry::Initializer::UNDEFINED) ? v : coercer.(v) }
+      { :"param_#{target}" => value }
+    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

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/spec/enhancement_spec.rb

@@ -0,0 +1,18 @@
+describe "gem enhancement" do
+  before do
+    Dry::Initializer::Attribute.dispatchers << ->(string: false, **op) do
+      op[:type] = proc(&:to_s) if string
+      op
+    end
+
+    class Test::Foo
+      extend Dry::Initializer
+      param :bar, string: true
+    end
+  end
+
+  it "works" do
+    foo = Test::Foo.new(:BAZ)
+    expect(foo.bar).to eq "BAZ"
+  end
+end

data/spec/missed_default_spec.rb

@@ -3,8 +3,8 @@ describe "missed default values" do
     class Test::Foo
       extend Dry::Initializer::Mixin
 
-      param :foo, default: proc { :FOO }
-      param :bar
+      param :foo, default:  proc { :FOO }
+      param :bar, required: true
     end
   end
 

data/spec/optional_spec.rb

@@ -9,22 +9,27 @@ describe "optional value" do
       end
     end
 
-    it "is left UNDEFINED by default" do
+    it "quacks like nil" do
       subject = Test::Foo.new(1)
 
-      expect(subject.foo).to eq 1
-      expect(subject.bar).to eq Dry::Initializer::UNDEFINED
+      expect(subject.bar).to eq nil
+    end
+
+    it "keeps info about been UNDEFINED" do
+      subject = Test::Foo.new(1)
+
+      expect(subject.instance_variable_get(:@bar))
+        .to eq Dry::Initializer::UNDEFINED
     end
 
     it "can be set explicitly" do
       subject = Test::Foo.new(1, "qux")
 
-      expect(subject.foo).to eq 1
       expect(subject.bar).to eq "qux"
     end
   end
 
-  context "when has default value" do
+  context "when has a default value" do
     before do
       class Test::Foo
         extend Dry::Initializer::Mixin
@@ -37,8 +42,13 @@ describe "optional value" do
     it "is takes default value" do
       subject = Test::Foo.new(1)
 
-      expect(subject.foo).to eq 1
       expect(subject.bar).to eq "baz"
     end
+
+    it "can be set explicitly" do
+      subject = Test::Foo.new(1, "qux")
+
+      expect(subject.bar).to eq "qux"
+    end
   end
 end

data/spec/options_var_spec.rb

@@ -0,0 +1,39 @@
+describe "@__options__" do
+  context "when class has no options" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer::Mixin
+        param :foo
+      end
+    end
+
+    it "is set to empty hash" do
+      subject = Test::Foo.new(1)
+
+      expect(subject.instance_variable_get(:@__options__)).to eq({})
+    end
+  end
+
+  context "when class has options" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer::Mixin
+        param  :foo
+        option :bar, optional: true
+        option :baz, optional: true
+      end
+    end
+
+    it "is set to empty hash if no options assigned" do
+      subject = Test::Foo.new(1)
+
+      expect(subject.instance_variable_get(:@__options__)).to eq({})
+    end
+
+    it "is set to hash of assigned options" do
+      subject = Test::Foo.new(1, baz: :QUX)
+
+      expect(subject.instance_variable_get(:@__options__)).to eq({ baz: :QUX })
+    end
+  end
+end

data/spec/repetitive_definitions_spec.rb

@@ -1,49 +1,69 @@
 describe "repetitive definitions" do
+  subject { Test::Foo.new }
+
   context "of params" do
-    subject do
+    before do
       class Test::Foo
         extend Dry::Initializer::Mixin
 
-        param :foo
-        param :bar
-        param :foo
+        param :foo, default: proc { 0 }
+        param :bar, default: proc { 1 }
+        param :foo, default: proc { 2 }
       end
     end
 
-    it "raise SyntaxError" do
-      expect { subject }.to raise_error SyntaxError, /foo/
+    it "reloads the attribute" do
+      expect(subject.foo).to eq 2
     end
   end
 
   context "of options" do
-    subject do
+    before do
       class Test::Foo
         extend Dry::Initializer::Mixin
 
-        option :foo
-        option :bar
-        option :foo
+        option :foo, default: proc { 0 }
+        option :bar, default: proc { 1 }
+        option :foo, default: proc { 2 }
       end
     end
 
-    it "raise SyntaxError" do
-      expect { subject }.to raise_error SyntaxError, /foo/
+    it "reloads the attribute" do
+      expect(subject.foo).to eq 2
     end
   end
 
   context "of param and option" do
-    subject do
+    before do
+      class Test::Foo
+        extend Dry::Initializer::Mixin
+
+        param  :foo, default: proc { 0 }
+        option :bar, default: proc { 1 }
+        option :foo, default: proc { 2 }
+      end
+    end
+
+    it "reloads the attribute" do
+      expect(subject.foo).to eq 2
+    end
+  end
+
+  context "of optional param and option" do
+    before do
       class Test::Foo
         extend Dry::Initializer::Mixin
 
-        param  :foo
-        option :bar
-        option :foo
+        param  :foo, optional: true
+        option :bar, optional: true
+        option :foo, optional: true
       end
     end
 
-    it "raise SyntaxError" do
-      expect { subject }.to raise_error SyntaxError, /foo/
+    it "allows various assignments" do
+      expect(Test::Foo.new(1).foo).to eq 1
+      expect(Test::Foo.new(foo: 2).foo).to eq 2
+      expect(Test::Foo.new(1, foo: 2).foo).to eq 2
     end
   end
 end

data/spec/several_assignments_spec.rb

@@ -0,0 +1,41 @@
+describe "attribute with several assignments" do
+  before do
+    class Test::Foo
+      extend Dry::Initializer::Mixin
+
+      option :bar, proc(&:to_s),    optional: true
+      option :"some foo", as: :bar, optional: true
+    end
+  end
+
+  context "when not defined" do
+    subject { Test::Foo.new }
+
+    it "is left undefined" do
+      expect(subject.bar).to be_nil
+      expect(subject.instance_variable_get :@bar)
+        .to eq Dry::Initializer::UNDEFINED
+    end
+  end
+
+  context "when set directly" do
+    subject { Test::Foo.new bar: :BAZ }
+
+    it "sets the attribute" do
+      expect(subject.bar).to eq "BAZ"
+    end
+  end
+
+  context "when renamed" do
+    subject { Test::Foo.new "some foo": :BAZ }
+
+    it "renames the attribute" do
+      expect(subject.bar).to eq :BAZ
+      expect(subject).not_to respond_to :foo
+    end
+
+    it "renames the variable" do
+      expect(subject.instance_variable_get(:@bar)).to eq :BAZ
+    end
+  end
+end