dry-initializer 3.0.1 → 3.1.0

data/spec/definition_spec.rb

@@ -1,111 +0,0 @@
-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, optional: false }]
-      ]
-    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, optional: false }]
-      ]
-    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 +0,0 @@
-describe "invalid default value assignment" do
-  subject do
-    class Test::Foo
-      extend Dry::Initializer
-
-      param :foo, default: 1
-    end
-  end
-
-  it "raises TypeError" do
-    expect { subject }.to raise_error TypeError
-  end
-end

data/spec/list_type_spec.rb

@@ -1,32 +0,0 @@
-require "dry-types"
-
-describe "list type argument" do
-  before do
-    class Test::Foo
-      extend Dry::Initializer
-      param  :foo, [proc(&:to_s)]
-      option :bar, [Dry::Types["strict.string"]]
-      option :baz, []
-    end
-  end
-
-  context "with single items" do
-    subject { Test::Foo.new(1, bar: "2", baz: { qux: :QUX }) }
-
-    it "coerces and wraps them to arrays" do
-      expect(subject.foo).to eq %w[1]
-      expect(subject.bar).to eq %w[2]
-      expect(subject.baz).to eq [{ qux: :QUX }]
-    end
-  end
-
-  context "with arrays" do
-    subject { Test::Foo.new([1], bar: %w[2], baz: [{ qux: :QUX }]) }
-
-    it "coerces elements" do
-      expect(subject.foo).to eq %w[1]
-      expect(subject.bar).to eq %w[2]
-      expect(subject.baz).to eq [{ qux: :QUX }]
-    end
-  end
-end

data/spec/missed_default_spec.rb

@@ -1,14 +0,0 @@
-describe "missed default values" do
-  subject do
-    class Test::Foo
-      extend Dry::Initializer
-
-      param :foo, default:  proc { :FOO }
-      param :bar, required: true
-    end
-  end
-
-  it "raises SyntaxError" do
-    expect { subject }.to raise_error SyntaxError, /bar/
-  end
-end

data/spec/nested_type_spec.rb

@@ -1,44 +0,0 @@
-describe "nested type argument" do
-  subject { Test::Xyz.new("bar" => { "baz" => 42 }) }
-
-  context "with nested definition only" do
-    before do
-      class Test::Xyz
-        extend Dry::Initializer
-
-        param :foo, as: :x do
-          option :bar, as: :y do
-            option :baz, proc(&:to_s), as: :z
-            option :qux, as: :w, optional: true
-          end
-        end
-      end
-    end
-
-    it "builds the type" do
-      expect(subject.x.y.z).to eq "42"
-    end
-  end
-
-  context "with nested and wrapped definitions" do
-    before do
-      class Test::Xyz
-        extend Dry::Initializer
-
-        param :foo, [], as: :x do
-          option :bar, as: :y do
-            option :baz, proc(&:to_s), as: :z
-            option :qux, as: :w, optional: true
-          end
-        end
-      end
-    end
-
-    it "builds the type" do
-      x = subject.x
-      expect(x).to be_instance_of Array
-
-      expect(x.first.y.z).to eq "42"
-    end
-  end
-end

data/spec/optional_spec.rb

@@ -1,71 +0,0 @@
-describe "optional value" do
-  context "when has no default value" do
-    before do
-      class Test::Foo
-        extend Dry::Initializer
-
-        param :foo
-        param :bar, optional: true
-      end
-    end
-
-    it "quacks like nil" do
-      subject = Test::Foo.new(1)
-
-      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.bar).to eq "qux"
-    end
-  end
-
-  context "with undefined: false" do
-    before do
-      class Test::Foo
-        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" }
-      end
-    end
-
-    it "is takes default value" do
-      subject = Test::Foo.new(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,11 +0,0 @@
-describe "options tolerance" do
-  before do
-    class Test::Foo
-      extend Dry::Initializer
-    end
-  end
-
-  it "allows options before any definition" do
-    expect { Test::Foo.new bar: :baz }.not_to raise_error
-  end
-end

data/spec/public_attributes_utility_spec.rb

@@ -1,22 +0,0 @@
-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

@@ -1,87 +0,0 @@
-describe "reader" do
-  shared_examples "it has no public attr_reader" do
-    it "does not define a public attr_reader" do
-      expect(subject).not_to respond_to :foo
-      expect(subject).not_to respond_to :bar
-    end
-  end
-
-  context "with reader: :public or no reader: option" do
-    subject do
-      class Test::Foo
-        extend Dry::Initializer
-
-        param  :foo
-        param  :foo2, reader: :public
-        option :bar
-        option :bar2, reader: :public
-      end
-
-      Test::Foo.new 1, 2, bar: 3, bar2: 4
-    end
-
-    it "defines a public attr_reader by default" do
-      expect(subject).to respond_to(:foo, :foo2)
-      expect(subject).to respond_to :bar
-      expect(subject).to respond_to :bar2
-    end
-  end
-
-  context "with reader: false" do
-    before do
-      class Test::Foo
-        extend Dry::Initializer
-
-        param  :foo, reader: false
-        option :bar, reader: false
-      end
-    end
-
-    subject { Test::Foo.new 1, bar: 2 }
-
-    it_behaves_like "it has no public attr_reader"
-
-    it "keeps assigning variables" do
-      expect(subject.instance_variable_get(:@foo)).to eql 1
-      expect(subject.instance_variable_get(:@bar)).to eql 2
-    end
-  end
-
-  context "with reader: :private" do
-    before do
-      class Test::Foo
-        extend Dry::Initializer
-
-        param  :foo, reader: :private
-        option :bar, reader: :private
-      end
-    end
-
-    subject { Test::Foo.new 1, bar: 2 }
-
-    it_behaves_like "it has no public attr_reader"
-
-    it "adds a private attr_reader" do
-      expect(subject.send(:foo)).to eql 1
-      expect(subject.send(:bar)).to eql 2
-    end
-  end
-
-  context "with reader: :protected" do
-    subject do
-      class Test::Foo
-        extend Dry::Initializer
-
-        param  :foo, reader: :protected
-        option :bar, reader: :protected
-      end
-
-      Test::Foo.new 1, bar: 2
-    end
-
-    it "adds a protected attr_reader" do
-      protected_instance_methods = subject.class.protected_instance_methods
-      expect(protected_instance_methods).to match_array(%i[foo bar])
-    end
-  end
-end

data/spec/repetitive_definitions_spec.rb

@@ -1,69 +0,0 @@
-describe "repetitive definitions" do
-  subject { Test::Foo.new }
-
-  context "of params" do
-    before do
-      class Test::Foo
-        extend Dry::Initializer
-
-        param :foo, default: proc { 0 }
-        param :bar, default: proc { 1 }
-        param :foo, default: proc { 2 }
-      end
-    end
-
-    it "reloads the attribute" do
-      expect(subject.foo).to eq 2
-    end
-  end
-
-  context "of options" do
-    before do
-      class Test::Foo
-        extend Dry::Initializer
-
-        option :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 param and option" 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
-
-        param  :baz, optional: true, as: :foo
-        option :bar, optional: true
-        option :foo, optional: true
-      end
-    end
-
-    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

@@ -1,41 +0,0 @@
-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,22 +0,0 @@
-require "dry/initializer"
-
-begin
-  require "pry"
-rescue LoadError
-  nil
-end
-
-RSpec.configure do |config|
-  config.order = :random
-  config.filter_run focus: true
-  config.run_all_when_everything_filtered = true
-
-  # Prepare the Test namespace for constants defined in specs
-  config.around(:each) do |example|
-    Test = Class.new(Module)
-    example.run
-    Object.send :remove_const, :Test
-  end
-
-  config.warnings = true
-end

data/spec/subclassing_spec.rb

@@ -1,49 +0,0 @@
-describe "subclassing" do
-  before do
-    class Test::Foo
-      extend Dry::Initializer[undefined: false]
-      param  :foo
-      option :bar
-    end
-
-    class Test::Bar < Test::Foo
-      param  :baz
-      option :qux
-    end
-  end
-
-  let(:instance_of_superclass) do
-    Test::Foo.new 1, bar: 3
-  end
-
-  let(:instance_of_subclass) 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
-    expect(instance_of_subclass.bar).to eql 3
-    expect(instance_of_subclass.qux).to eql 4
-  end
-
-  it "does not pollute superclass with definitions from subclass" do
-    expect(instance_of_superclass).not_to respond_to :baz
-    expect(instance_of_superclass).not_to respond_to :qux
-  end
-
-  it "calls .inherited hook added by other mixin" do
-    called = false
-    mixin = Module.new { define_method(:inherited) { |_| called = true } }
-
-    base = Class.new { extend mixin; extend Dry::Initializer }
-    Class.new(base)
-
-    expect(called).to be true
-  end
-end

data/spec/type_argument_spec.rb

@@ -1,35 +0,0 @@
-require "dry-types"
-
-describe "type argument" do
-  before do
-    class Test::Foo
-      extend Dry::Initializer
-      param  :foo, Dry::Types["strict.string"]
-      option :bar, Dry::Types["strict.string"]
-    end
-  end
-
-  context "in case of param mismatch" do
-    subject { Test::Foo.new 1, bar: "2" }
-
-    it "raises TypeError" do
-      expect { subject }.to raise_error TypeError, /1/
-    end
-  end
-
-  context "in case of option mismatch" do
-    subject { Test::Foo.new "1", bar: 2 }
-
-    it "raises TypeError" do
-      expect { subject }.to raise_error TypeError, /2/
-    end
-  end
-
-  context "in case of match" do
-    subject { Test::Foo.new "1", bar: "2" }
-
-    it "completes the initialization" do
-      expect { subject }.not_to raise_error
-    end
-  end
-end