dry-initializer 0.11.0 → 2.5.0

data/spec/attributes_spec.rb

@@ -0,0 +1,38 @@
+describe Dry::Initializer, "dry_initializer.attributes" do
+  subject { instance.class.dry_initializer.attributes(instance) }
+
+  context "when class has params" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        param :foo, proc(&:to_s)
+        param :bar, default: proc { 1 }
+        param :baz, optional: true
+      end
+    end
+
+    let(:instance) { Test::Foo.new(:FOO) }
+
+    it "collects coerced params with default values" do
+      expect(subject).to eq({ foo: "FOO", bar: 1 })
+    end
+  end
+
+  context "when class has options" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        option :foo
+        option :bar, default: proc { 1 }
+        option :baz, optional: true
+        option :qux, proc(&:to_s), as: :quxx
+      end
+    end
+
+    let(:instance) { Test::Foo.new(foo: :FOO, qux: :QUX) }
+
+    it "collects coerced and renamed options with default values" do
+      expect(subject).to eq({ foo: :FOO, bar: 1, quxx: "QUX" })
+    end
+  end
+end

data/spec/coercion_of_nil_spec.rb

@@ -0,0 +1,25 @@
+describe "coercion of nil" do
+  before do
+    class Test::Foo
+      extend Dry::Initializer
+      param :bar, proc(&:to_i)
+    end
+
+    class Test::Baz
+      include Dry::Initializer.define -> do
+        param :qux, proc(&:to_i)
+      end
+    end
+  end
+
+  let(:foo) { Test::Foo.new(nil) }
+  let(:baz) { Test::Baz.new(nil) }
+
+  it "works with extend syntax" do
+    expect(foo.bar).to eq 0
+  end
+
+  it "works with include syntax" do
+    expect(baz.qux).to eq 0
+  end
+end

data/spec/custom_dispatchers_spec.rb

@@ -0,0 +1,35 @@
+describe "custom dispatchers" do
+  subject { Test::Foo.new "123" }
+
+  before do
+    dispatcher = ->(op) { op[:integer] ? op.merge(type: proc(&:to_i)) : op }
+    Dry::Initializer::Dispatchers << dispatcher
+  end
+
+  context "with extend syntax" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        param :id, integer: true
+      end
+    end
+
+    it "adds syntax sugar" do
+      expect(subject.id).to eq 123
+    end
+  end
+
+  context "with include syntax" do
+    before do
+      class Test::Foo
+        include Dry::Initializer.define -> do
+          param :id, integer: true
+        end
+      end
+    end
+
+    it "adds syntax sugar" do
+      expect(subject.id).to eq 123
+    end
+  end
+end

data/spec/custom_initializer_spec.rb

@@ -1,7 +1,7 @@
 describe "custom initializer" do
   before do
     class Test::Foo
-      extend Dry::Initializer::Mixin
+      extend Dry::Initializer
 
       param :bar
 

data/spec/default_values_spec.rb

@@ -1,13 +1,13 @@
 describe "default values" do
   before do
     class Test::Foo
-      extend Dry::Initializer::Mixin
+      extend Dry::Initializer
 
       param  :foo, default: proc { :FOO }
       param  :bar, default: proc { :BAR }
-      option :baz, default: proc { :BAZ }
+      option :baz, default: -> { :BAZ }
       option :qux, default: proc { foo }
-      option :mox, default: proc { default_mox }
+      option :mox, default: -> { default_mox }
 
       private
 
@@ -52,14 +52,14 @@ describe "default values" do
   describe "when the last param has a default and there are no options" do
     before do
       class Test::Bar
-        extend Dry::Initializer::Mixin
+        extend Dry::Initializer
 
-        param  :foo
-        param  :bar, default: proc { {} }
+        param :foo
+        param :bar, default: proc { {} }
       end
     end
 
-    it "instantiate arguments" do
+    it "instantiates arguments" do
       subject = Test::Bar.new(1, 2)
 
       expect(subject.foo).to eql 1
@@ -73,7 +73,7 @@ describe "default values" do
       expect(subject.bar).to eql({})
     end
 
-    it "instantiate arguments also if the last is an hash" do
+    it "instantiates arguments also if the last is an hash" do
       subject = Test::Bar.new(1, { baz: 2, qux: 3 })
 
       expect(subject.foo).to eql 1

data/spec/definition_spec.rb

@@ -0,0 +1,107 @@
+describe "definition" do
+  shared_examples :initializer do |in_context|
+    subject { Test::Foo.new(1, bar: 2) }
+
+    it "sets variables when defined via `#{in_context}`" do
+      expect(subject.instance_variable_get(:@foo)).to eql 1
+      expect(subject.instance_variable_get(:@bar)).to eql 2
+    end
+  end
+
+  it_behaves_like :initializer, "extend Dry::Initializer" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        param  :foo
+        option :bar
+      end
+    end
+
+    it "preservers definition params" do
+      params = Test::Foo.dry_initializer.params.map do |definition|
+        [definition.source, definition.options]
+      end
+
+      expect(params).to eq [[:foo, { as: :foo, reader: :public }]]
+    end
+
+    it "preservers definition options" do
+      options = Test::Foo.dry_initializer.options.map do |definition|
+        [definition.source, definition.options]
+      end
+
+      expect(options).to eq [[:bar, { as: :bar, reader: :public }]]
+    end
+  end
+
+  it_behaves_like :initializer, "extend Dry::Initializer" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        param  :foo
+        option :bar
+      end
+    end
+  end
+
+  it_behaves_like :initializer, "extend Dry::Initializer[undefined: false]" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer[undefined: false]
+        param  :foo
+        option :bar
+      end
+    end
+  end
+
+  it_behaves_like :initializer, "include Dry::Initializer with block" do
+    before do
+      class Test::Foo
+        include(
+          Dry::Initializer.define do
+            param  :foo
+            option :bar
+          end
+        )
+      end
+    end
+  end
+
+  it_behaves_like :initializer, "include Dry::Initializer with lambda" do
+    before do
+      class Test::Foo
+        include Dry::Initializer.define -> do
+          param  :foo
+          option :bar
+        end
+      end
+    end
+  end
+
+  it_behaves_like :initializer, "include Dry::Initializer[undefined: false]" do
+    before do
+      class Test::Foo
+        include(
+          Dry::Initializer[undefined: false].define do
+            param  :foo
+            option :bar
+          end
+        )
+      end
+    end
+  end
+
+  # @deprecated
+  it_behaves_like :initializer, "include Dry::Initializer::Mixin" do
+    before do
+      class Test::Foo
+        include(
+          Dry::Initializer::Mixin.define do
+            param  :foo
+            option :bar
+          end
+        )
+      end
+    end
+  end
+end

data/spec/invalid_default_spec.rb

@@ -1,13 +1,13 @@
 describe "invalid default value assignment" do
   subject do
     class Test::Foo
-      extend Dry::Initializer::Mixin
+      extend Dry::Initializer
 
       param :foo, default: 1
     end
   end
 
   it "raises TypeError" do
-    expect { subject }.to raise_error TypeError, /1/
+    expect { subject }.to raise_error TypeError
   end
 end

data/spec/missed_default_spec.rb

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

data/spec/optional_spec.rb

@@ -2,32 +2,54 @@ describe "optional value" do
   context "when has no default value" do
     before do
       class Test::Foo
-        extend Dry::Initializer::Mixin
+        extend Dry::Initializer
 
         param :foo
         param :bar, optional: true
       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 "with undefined: false" do
     before do
       class Test::Foo
-        extend Dry::Initializer::Mixin
+        extend Dry::Initializer[undefined: false]
+
+        param :foo
+        param :bar, optional: true
+      end
+    end
+
+    it "sets undefined values to nil" do
+      subject = Test::Foo.new(1)
+
+      expect(subject.instance_variable_get(:@bar)).to be_nil
+    end
+  end
+
+  context "when has a default value" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
 
         param :foo
         param :bar, optional: true, default: proc { "baz" }
@@ -37,8 +59,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_tolerance_spec.rb

@@ -1,7 +1,7 @@
 describe "options tolerance" do
   before do
     class Test::Foo
-      extend Dry::Initializer::Mixin
+      extend Dry::Initializer
     end
   end
 

data/spec/public_attributes_utility_spec.rb

@@ -0,0 +1,22 @@
+describe Dry::Initializer, ".dry_initializer.public_attributes" do
+  subject { instance.class.dry_initializer.public_attributes(instance) }
+
+  context "when class has params" do
+    before do
+      class Test::Foo
+        extend Dry::Initializer
+        param  :foo, proc(&:to_s), desc: "a weird parameter"
+        option :moo, optional: true
+        option :bar, default: proc { 1 },     reader: false
+        option :baz, optional: true,          reader: :protected
+        option :qux, proc(&:to_s), as: :quxx, reader: :private
+      end
+    end
+
+    let(:instance) { Test::Foo.new(:FOO, bar: :BAR, baz: :BAZ, qux: :QUX) }
+
+    it "collects public options only" do
+      expect(subject).to eq({ foo: "FOO", moo: nil })
+    end
+  end
+end

data/spec/reader_spec.rb

@@ -9,7 +9,7 @@ describe "reader" do
   context "with reader: :public or no reader: option" do
     subject do
       class Test::Foo
-        extend Dry::Initializer::Mixin
+        extend Dry::Initializer
 
         param  :foo
         param  :foo2, reader: :public
@@ -28,17 +28,17 @@ describe "reader" do
   end
 
   context "with reader: false" do
-    subject do
+    before do
       class Test::Foo
-        extend Dry::Initializer::Mixin
+        extend Dry::Initializer
 
         param  :foo, reader: false
         option :bar, reader: false
       end
-
-      Test::Foo.new 1, bar: 2
     end
 
+    subject { Test::Foo.new 1, bar: 2 }
+
     it_behaves_like "it has no public attr_reader"
 
     it "keeps assigning variables" do
@@ -48,17 +48,17 @@ describe "reader" do
   end
 
   context "with reader: :private" do
-    subject do
+    before do
       class Test::Foo
-        extend Dry::Initializer::Mixin
+        extend Dry::Initializer
 
         param  :foo, reader: :private
         option :bar, reader: :private
       end
-
-      Test::Foo.new 1, bar: 2
     end
 
+    subject { Test::Foo.new 1, bar: 2 }
+
     it_behaves_like "it has no public attr_reader"
 
     it "adds a private attr_reader" do
@@ -70,7 +70,7 @@ describe "reader" do
   context "with reader: :protected" do
     subject do
       class Test::Foo
-        extend Dry::Initializer::Mixin
+        extend Dry::Initializer
 
         param  :foo, reader: :protected
         option :bar, reader: :protected
@@ -81,7 +81,7 @@ describe "reader" do
 
     it "adds a protected attr_reader" do
       protected_instance_methods = subject.class.protected_instance_methods
-      expect(protected_instance_methods).to match_array([:foo, :bar])
+      expect(protected_instance_methods).to match_array(%i[foo bar])
     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
+        extend Dry::Initializer
 
-        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
+        extend Dry::Initializer
 
-        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
+
+        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
+        extend Dry::Initializer
 
-        param  :foo
-        option :bar
-        option :foo
+        param  :baz, optional: true, as: :foo
+        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
+
+      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

data/spec/spec_helper.rb

@@ -1,4 +1,9 @@
 require "dry/initializer"
+begin
+  require "pry"
+rescue
+  nil
+end
 
 RSpec.configure do |config|
   config.order = :random
@@ -11,4 +16,6 @@ RSpec.configure do |config|
     example.run
     Object.send :remove_const, :Test
   end
+
+  config.warnings = true
 end

data/spec/subclassing_spec.rb

@@ -1,8 +1,7 @@
 describe "subclassing" do
   before do
     class Test::Foo
-      extend Dry::Initializer::Mixin
-
+      extend Dry::Initializer[undefined: false]
       param  :foo
       option :bar
     end
@@ -21,6 +20,11 @@ describe "subclassing" do
     Test::Bar.new 1, 2, bar: 3, qux: 4
   end
 
+  it "preserves null definition" do
+    expect(Test::Foo.dry_initializer.null).to be_nil
+    expect(Test::Bar.dry_initializer.null).to be_nil
+  end
+
   it "preserves definitions made in the superclass" do
     expect(instance_of_subclass.foo).to eql 1
     expect(instance_of_subclass.baz).to eql 2
@@ -37,7 +41,7 @@ describe "subclassing" do
     called = false
     mixin = Module.new { define_method(:inherited) { |_| called = true } }
 
-    base = Class.new { extend mixin; extend Dry::Initializer::Mixin }
+    base = Class.new { extend mixin; extend Dry::Initializer }
     Class.new(base)
 
     expect(called).to be true

data/spec/type_argument_spec.rb

@@ -3,7 +3,7 @@ require "dry-types"
 describe "type argument" do
   before do
     class Test::Foo
-      extend Dry::Initializer::Mixin
+      extend Dry::Initializer
       param  :foo, Dry::Types["strict.string"]
       option :bar, Dry::Types["strict.string"]
     end