dry-initializer 3.0.2 → 3.0.3

data/spec/optional_spec.rb

@@ -1,5 +1,5 @@
-describe "optional value" do
-  context "when has no default value" do
+describe 'optional value' do
+  context 'when has no default value' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -9,27 +9,27 @@ describe "optional value" do
       end
     end
 
-    it "quacks like nil" do
+    it 'quacks like nil' do
       subject = Test::Foo.new(1)
 
       expect(subject.bar).to eq nil
     end
 
-    it "keeps info about been UNDEFINED" do
+    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")
+    it 'can be set explicitly' do
+      subject = Test::Foo.new(1, 'qux')
 
-      expect(subject.bar).to eq "qux"
+      expect(subject.bar).to eq 'qux'
     end
   end
 
-  context "with undefined: false" do
+  context 'with undefined: false' do
     before do
       class Test::Foo
         extend Dry::Initializer[undefined: false]
@@ -39,33 +39,33 @@ describe "optional value" do
       end
     end
 
-    it "sets undefined values to nil" do
+    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
+  context 'when has a default value' do
     before do
       class Test::Foo
         extend Dry::Initializer
 
         param :foo
-        param :bar, optional: true, default: proc { "baz" }
+        param :bar, optional: true, default: proc { 'baz' }
       end
     end
 
-    it "is takes default value" do
+    it 'is takes default value' do
       subject = Test::Foo.new(1)
 
-      expect(subject.bar).to eq "baz"
+      expect(subject.bar).to eq 'baz'
     end
 
-    it "can be set explicitly" do
-      subject = Test::Foo.new(1, "qux")
+    it 'can be set explicitly' do
+      subject = Test::Foo.new(1, 'qux')
 
-      expect(subject.bar).to eq "qux"
+      expect(subject.bar).to eq 'qux'
     end
   end
 end

data/spec/options_tolerance_spec.rb

@@ -1,11 +1,11 @@
-describe "options tolerance" do
+describe 'options tolerance' do
   before do
     class Test::Foo
       extend Dry::Initializer
     end
   end
 
-  it "allows options before any definition" do
+  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,11 +1,11 @@
-describe Dry::Initializer, ".dry_initializer.public_attributes" do
+describe Dry::Initializer, '.dry_initializer.public_attributes' do
   subject { instance.class.dry_initializer.public_attributes(instance) }
 
-  context "when class has params" do
+  context 'when class has params' do
     before do
       class Test::Foo
         extend Dry::Initializer
-        param  :foo, proc(&:to_s), desc: "a weird parameter"
+        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
@@ -15,8 +15,8 @@ describe Dry::Initializer, ".dry_initializer.public_attributes" do
 
     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 })
+    it 'collects public options only' do
+      expect(subject).to eq({ foo: 'FOO', moo: nil })
     end
   end
 end

data/spec/reader_spec.rb

@@ -1,12 +1,12 @@
-describe "reader" do
-  shared_examples "it has no public attr_reader" do
-    it "does not define a public attr_reader" do
+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
+  context 'with reader: :public or no reader: option' do
     subject do
       class Test::Foo
         extend Dry::Initializer
@@ -20,14 +20,14 @@ describe "reader" do
       Test::Foo.new 1, 2, bar: 3, bar2: 4
     end
 
-    it "defines a public attr_reader by default" do
+    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
+  context 'with reader: false' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -39,15 +39,15 @@ describe "reader" do
 
     subject { Test::Foo.new 1, bar: 2 }
 
-    it_behaves_like "it has no public attr_reader"
+    it_behaves_like 'it has no public attr_reader'
 
-    it "keeps assigning variables" do
+    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
+  context 'with reader: :private' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -59,15 +59,15 @@ describe "reader" do
 
     subject { Test::Foo.new 1, bar: 2 }
 
-    it_behaves_like "it has no public attr_reader"
+    it_behaves_like 'it has no public attr_reader'
 
-    it "adds a private attr_reader" do
+    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
+  context 'with reader: :protected' do
     subject do
       class Test::Foo
         extend Dry::Initializer
@@ -79,7 +79,7 @@ describe "reader" do
       Test::Foo.new 1, bar: 2
     end
 
-    it "adds a protected attr_reader" do
+    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

data/spec/repetitive_definitions_spec.rb

@@ -1,7 +1,7 @@
-describe "repetitive definitions" do
+describe 'repetitive definitions' do
   subject { Test::Foo.new }
 
-  context "of params" do
+  context 'of params' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -12,12 +12,12 @@ describe "repetitive definitions" do
       end
     end
 
-    it "reloads the attribute" do
+    it 'reloads the attribute' do
       expect(subject.foo).to eq 2
     end
   end
 
-  context "of options" do
+  context 'of options' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -28,12 +28,12 @@ describe "repetitive definitions" do
       end
     end
 
-    it "reloads the attribute" do
+    it 'reloads the attribute' do
       expect(subject.foo).to eq 2
     end
   end
 
-  context "of param and option" do
+  context 'of param and option' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -44,12 +44,12 @@ describe "repetitive definitions" do
       end
     end
 
-    it "reloads the attribute" do
+    it 'reloads the attribute' do
       expect(subject.foo).to eq 2
     end
   end
 
-  context "of optional param and option" do
+  context 'of optional param and option' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -60,7 +60,7 @@ describe "repetitive definitions" do
       end
     end
 
-    it "allows various assignments" do
+    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

data/spec/several_assignments_spec.rb

@@ -1,4 +1,4 @@
-describe "attribute with several assignments" do
+describe 'attribute with several assignments' do
   before do
     class Test::Foo
       extend Dry::Initializer
@@ -8,33 +8,33 @@ describe "attribute with several assignments" do
     end
   end
 
-  context "when not defined" do
+  context 'when not defined' do
     subject { Test::Foo.new }
 
-    it "is left undefined" do
+    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
+  context 'when set directly' do
     subject { Test::Foo.new bar: :BAZ }
 
-    it "sets the attribute" do
-      expect(subject.bar).to eq "BAZ"
+    it 'sets the attribute' do
+      expect(subject.bar).to eq 'BAZ'
     end
   end
 
-  context "when renamed" do
+  context 'when renamed' do
     subject { Test::Foo.new "some foo": :BAZ }
 
-    it "renames the attribute" do
+    it 'renames the attribute' do
       expect(subject.bar).to eq :BAZ
       expect(subject).not_to respond_to :foo
     end
 
-    it "renames the variable" do
+    it 'renames the variable' do
       expect(subject.instance_variable_get(:@bar)).to eq :BAZ
     end
   end

data/spec/spec_helper.rb

@@ -1,14 +1,9 @@
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter '/spec/'
-  end
-end
+require_relative 'support/coverage'
 
-require "dry/initializer"
+require 'dry/initializer'
 
 begin
-  require "pry"
+  require 'pry'
 rescue LoadError
   nil
 end

data/spec/subclassing_spec.rb

@@ -1,4 +1,4 @@
-describe "subclassing" do
+describe 'subclassing' do
   before do
     class Test::Foo
       extend Dry::Initializer[undefined: false]
@@ -20,24 +20,24 @@ describe "subclassing" do
     Test::Bar.new 1, 2, bar: 3, qux: 4
   end
 
-  it "preserves null definition" do
+  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
+  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
+  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
+  it 'calls .inherited hook added by other mixin' do
     called = false
     mixin = Module.new { define_method(:inherited) { |_| called = true } }
 

data/spec/support/coverage.rb

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

data/spec/support/warnings.rb

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

data/spec/type_constraint_spec.rb

@@ -1,7 +1,7 @@
-require "dry-types"
+require 'dry-types'
 
-describe "type constraint" do
-  context "by a proc with 1 argument" do
+describe 'type constraint' do
+  context 'by a proc with 1 argument' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -11,12 +11,12 @@ describe "type constraint" do
 
     subject { Test::Foo.new :foo }
 
-    it "coerces a value" do
-      expect(subject.__foo__).to eq "foo"
+    it 'coerces a value' do
+      expect(subject.__foo__).to eq 'foo'
     end
   end
 
-  context "by a proc with 2 arguments" do
+  context 'by a proc with 2 arguments' do
     before do
       class Test::Foo
         extend Dry::Initializer
@@ -26,47 +26,65 @@ describe "type constraint" do
 
     subject { Test::Foo.new :foo }
 
-    it "coerces a value with self as a second argument" do
+    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
+  context 'by dry-type' do
     before do
-      class Test::Foo
+      constraint = self.constraint
+
+      Test::Foo = Class.new do
         extend Dry::Initializer
-        param :foo, Dry::Types["strict.string"], optional: true
+        param :foo, constraint, optional: true
       end
     end
 
-    context "in case of mismatch" do
-      subject { Test::Foo.new 1 }
+    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/
+        it 'raises ArgumentError' do
+          expect { subject }.to raise_error Dry::Types::ConstraintError, /1/
+        end
       end
-    end
 
-    context "in case of match" do
-      subject { Test::Foo.new "foo" }
+      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 "completes the initialization" do
-        expect { subject }.not_to raise_error
+        it 'not applicable to Dry::Initializer::UNDEFINED' do
+          expect(subject.instance_variable_get(:@foo))
+            .to eq Dry::Initializer::UNDEFINED
+        end
       end
     end
 
-    context "if optional value not set" do
-      subject { Test::Foo.new }
+    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 "not applicable to Dry::Initializer::UNDEFINED" do
-        expect(subject.instance_variable_get(:@foo))
-          .to eq Dry::Initializer::UNDEFINED
+        it 'completes the initialization' do
+          expect { subject }.not_to raise_error
+        end
       end
     end
   end
 
-  context "by invalid constraint" do
-    it "raises ArgumentError" do
+  context 'by invalid constraint' do
+    it 'raises ArgumentError' do
       expect do
         class Test::Foo
           extend Dry::Initializer