dry-initializer 3.0.3 → 3.0.4

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,24 +0,0 @@
-require_relative 'support/coverage'
-
-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/support/coverage.rb

@@ -1,7 +0,0 @@
-# this file is managed by dry-rb/devtools
-
-if ENV['COVERAGE'] == 'true'
-  require 'codacy-coverage'
-
-  Codacy::Reporter.start
-end

data/spec/support/warnings.rb

@@ -1,7 +0,0 @@
-# this file is managed by dry-rb/devtools project
-
-require 'warning'
-
-Warning.ignore(%r{rspec/core})
-Warning.ignore(/codacy/)
-Warning[:experimental] = false if Warning.respond_to?(:[])

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 Dry::Types::ConstraintError, /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 Dry::Types::ConstraintError, /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

data/spec/type_constraint_spec.rb

@@ -1,96 +0,0 @@
-require 'dry-types'
-
-describe 'type constraint' do
-  context 'by a proc with 1 argument' do
-    before do
-      class Test::Foo
-        extend Dry::Initializer
-        param :__foo__, proc(&:to_s), optional: true
-      end
-    end
-
-    subject { Test::Foo.new :foo }
-
-    it 'coerces a value' do
-      expect(subject.__foo__).to eq 'foo'
-    end
-  end
-
-  context 'by a proc with 2 arguments' do
-    before do
-      class Test::Foo
-        extend Dry::Initializer
-        param :foo, proc { |val, obj| "#{obj.hash}:#{val}" }, optional: true
-      end
-    end
-
-    subject { Test::Foo.new :foo }
-
-    it 'coerces a value with self as a second argument' do
-      expect(subject.foo).to eq "#{subject.hash}:foo"
-    end
-  end
-
-  context 'by dry-type' do
-    before do
-      constraint = self.constraint
-
-      Test::Foo = Class.new do
-        extend Dry::Initializer
-        param :foo, constraint, optional: true
-      end
-    end
-
-    context 'with a strict string' do
-      let(:constraint) { Dry::Types['strict.string'] }
-
-      context 'in case of mismatch' do
-        subject { Test::Foo.new 1 }
-
-        it 'raises ArgumentError' do
-          expect { subject }.to raise_error Dry::Types::ConstraintError, /1/
-        end
-      end
-
-      context 'in case of match' do
-        subject { Test::Foo.new 'foo' }
-
-        it 'completes the initialization' do
-          expect { subject }.not_to raise_error
-        end
-      end
-
-      context 'if optional value not set' do
-        subject { Test::Foo.new }
-
-        it 'not applicable to Dry::Initializer::UNDEFINED' do
-          expect(subject.instance_variable_get(:@foo))
-            .to eq Dry::Initializer::UNDEFINED
-        end
-      end
-    end
-
-    context 'with a member array string' do
-      let(:constraint) { Dry::Types['array'].of(Dry::Types['strict.string']) }
-
-      context 'with arity other than 1' do
-        subject { Test::Foo.new ['foo'] }
-
-        it 'completes the initialization' do
-          expect { subject }.not_to raise_error
-        end
-      end
-    end
-  end
-
-  context 'by invalid constraint' do
-    it 'raises ArgumentError' do
-      expect do
-        class Test::Foo
-          extend Dry::Initializer
-          param :foo, type: String
-        end
-      end.to raise_error(ArgumentError)
-    end
-  end
-end