sorbet-coerce 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e0850189628e40cec7b240cd1a12c5abf995369f363444b7f5ecd398239bfa4
-  data.tar.gz: 06756e0942061e2feb84958027a666a86b52345000b797a5cab3ceaccbfce0f9
+  metadata.gz: 9749ed0f8347a42911400212d8a30279876e10b1983daabc16167f819fdd76bd
+  data.tar.gz: 2866bbe6175228c14b563928bf44521608486ca7c1cb2aa6dc4bbf19aafd0bcf
 SHA512:
-  metadata.gz: b08186d2c9c95bc3933f15895e23031a09fd49af3d16886c82433831e5d395c4a496c9e58a2b22c42630d01b925d151beca01656446a3d10b0ca46acab83dcad
-  data.tar.gz: 9dcec07cc34048713d4ea627b1afac67c6885e82e8623ecad4b2f36af763c70c13e7d79a6d295c36cb2d502f62837b7df5f304c29d845f40d5be2b75660b64b7
+  metadata.gz: d8f9f8e5086248a4db00ef26a0285fb9363817f552f77658d0ca8c0b5c373221df6c67116b9735fcd33d41831f6c49d139dfd1608e44adbe0cd5168335b863c5
+  data.tar.gz: a159fd6c75c112e71ad4e801ae759b01051f1a1e0ef2d02f875e40b4444b25b098a9049f3ab7dea596b5373c5e86759ba3a78da622978ef8147ba4883a51c444

data/lib/private/converter.rb

@@ -58,11 +58,7 @@ module T::Private
         _convert(value, type.aliased_type)
       elsif type < T::Struct
         args = _build_args(value, type.props)
-        begin
-          type.new(args)
-        rescue
-          nil
-        end
+        type.new(args)
       else
         _convert_simple(value, type)
       end
@@ -70,7 +66,8 @@ module T::Private
 
     sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
     def _convert_simple(value, type)
-      return nil if value.nil?
+      return nil if _nil_like?(value, type)
+
       safe_type_rule = T.let(nil, T.untyped)
 
       if type == T::Boolean
@@ -84,30 +81,23 @@ module T::Private
       end
       SafeType::coerce(value, safe_type_rule)
     rescue SafeType::EmptyValueError, SafeType::CoercionError
-      nil
+      value
     rescue SafeType::InvalidRuleError
-      begin
-        type.new(value)
-      rescue
-        nil
-      end
+      type.new(value)
     end
 
     sig { params(ary: T.untyped, type: T.untyped).returns(T.untyped) }
     def _convert_to_a(ary, type)
-      ary = [ary] unless ary.is_a?(::Array)
-      T.send(
-        'let',
-        ary.map { |value| _convert(value, type) },
-        T.const_get('Array')[type],
-      )
-    rescue TypeError
-      []
+      return [] if _nil_like?(ary, type)
+
+      # Checked by the T.let at root
+      ary.respond_to?(:map) ? ary.map { |value| _convert(value, type) } : ary
     end
 
     sig { params(args: T.untyped, props: T.untyped).returns(T.untyped) }
     def _build_args(args, props)
-      return {} if args.nil?
+      return {} if _nil_like?(args, Hash)
+
       args.map { |name, value|
         key = name.to_sym
         [
@@ -117,5 +107,10 @@ module T::Private
         ]
       }.to_h.slice(*props.keys)
     end
+
+    sig { params(value: T.untyped, type: T.untyped).returns(T::Boolean) }
+    def _nil_like?(value, type)
+      value.nil? || (value == '' && type != String)
+    end
   end
 end

data/spec/coerce_spec.rb

@@ -13,7 +13,7 @@ describe T::Coerce do
     class ParamInfo2 < T::Struct
       const :a, Integer
       const :b, Integer
-      const :notes, T::Array[String]
+      const :notes, T::Array[String], default: []
     end
 
     class Param < T::Struct
@@ -23,6 +23,10 @@ describe T::Coerce do
       const :opt, T.nilable(ParamInfo2)
     end
 
+    class DefaultParams < T::Struct
+      const :a, Integer, default: 1
+    end
+
     class CustomType
       attr_reader :a
 
@@ -31,6 +35,10 @@ describe T::Coerce do
       end
     end
 
+    class CustomType2
+      def self.new(a); 1; end
+    end
+
     class UnsupportedCustomType
       # Does not respond to new
     end
@@ -82,7 +90,7 @@ describe T::Coerce do
       expect(param.info.lvl).to eql 100
       expect(param.info.name).to eql 'mango'
       expect(param.info.skill_ids).to eql [123, 456]
-      expect(param.opt).to be nil # missing notes
+      expect(param.opt.notes).to eql []
 
       expect(param2.id).to eql 2
       expect(param2.info.name).to eql 'honeydew'
@@ -92,15 +100,18 @@ describe T::Coerce do
       expect(param2.opt.b).to eql 2
       expect(param2.opt.notes).to eql []
 
-      expect(
-        T::Coerce[T.nilable(Param)].new.from({
+      expect {
+        T::Coerce[Param].new.from({
           id: 3,
           info: {
             # missing required name
             lvl: 2,
           },
         })
-      ).to be nil
+      }.to raise_error(ArgumentError)
+
+      expect(T::Coerce[DefaultParams].new.from(nil).a).to be 1
+      expect(T::Coerce[DefaultParams].new.from('').a).to be 1
     end
   end
 
@@ -130,11 +141,15 @@ describe T::Coerce do
       expect(T::Coerce[Integer].new.from(2)).to eql 2
       expect(T::Coerce[Integer].new.from('1.0')).to eql 1
 
-      expect(T::Coerce[T.nilable(Integer)].new.from('invalid integer string')).to be nil
+      expect{T::Coerce[T.nilable(Integer)].new.from('invalid integer string')}.to raise_error(T::CoercionError)
       expect(T::Coerce[Float].new.from('1.0')).to eql 1.0
 
       expect(T::Coerce[T::Boolean].new.from('false')).to be false
       expect(T::Coerce[T::Boolean].new.from('true')).to be true
+
+      expect(T::Coerce[T.nilable(Integer)].new.from('')).to be nil
+      expect{T::Coerce[T.nilable(Integer)].new.from([])}.to raise_error(T::CoercionError)
+      expect(T::Coerce[T.nilable(String)].new.from('')).to eql ''
     end
   end
 
@@ -143,19 +158,22 @@ describe T::Coerce do
       T.assert_type!(T::Coerce[CustomType].new.from(a: 1), CustomType)
       expect(T::Coerce[CustomType].new.from(1).a).to be 1
 
-      expect{T::Coerce[UnsupportedCustomType].new.from(1)}.to raise_error(T::CoercionError)
+      expect{T::Coerce[UnsupportedCustomType].new.from(1)}.to raise_error(ArgumentError)
+      expect{T::Coerce[CustomType2].new.from(1)}.to raise_error(T::CoercionError)
     end
   end
 
   context 'when dealing with arries' do
     it 'coreces correctly' do
       expect(T::Coerce[T::Array[Integer]].new.from(nil)).to eql []
-      expect(T::Coerce[T::Array[Integer]].new.from('not an array')).to eql []
-      expect(T::Coerce[T::Array[Integer]].new.from('1')).to eql [1]
+      expect(T::Coerce[T::Array[Integer]].new.from('')).to eql []
+      expect{T::Coerce[T::Array[Integer]].new.from('not an array')}.to raise_error(T::CoercionError)
+      expect{T::Coerce[T::Array[Integer]].new.from('1')}.to raise_error(T::CoercionError)
       expect(T::Coerce[T::Array[Integer]].new.from(['1', '2', '3'])).to eql [1, 2, 3]
-      expect(T::Coerce[T::Array[Integer]].new.from(['1', 'invalid', '3'])).to eql []
+      expect{T::Coerce[T::Array[Integer]].new.from(['1', 'invalid', '3'])}.to raise_error(T::CoercionError)
+      expect{T::Coerce[T::Array[Integer]].new.from({a: 1})}.to raise_error(T::CoercionError)
 
-      infos = T::Coerce[T::Array[ParamInfo]].new.from(name: 'a', skill_ids: [])
+      infos = T::Coerce[T::Array[ParamInfo]].new.from([{name: 'a', skill_ids: []}])
       T.assert_type!(infos, T::Array[ParamInfo])
       expect(infos.first.name).to eql 'a'
 

data/spec/nested_spec.rb

@@ -16,11 +16,11 @@ describe T::Coerce do
 
     it 'works with nest T::Struct' do
       converted = T::Coerce[NestedParam].new.from({
-        users: {id: '1'},
+        users: [{id: '1'}],
         params: {
-          users: {id: '2', valid: 'true'},
+          users: [{id: '2', valid: 'true'}],
           params: {
-            users: {id: '3', valid: 'true'},
+            users: [{id: '3', valid: 'true'}],
           },
         },
       })
@@ -41,12 +41,12 @@ describe T::Coerce do
     end
 
     it 'works with nest T::Array' do
+      expect {
+        T::Coerce[T::Array[T.nilable(Integer)]].new.from(['1', 'invalid', '3'])
+      }.to raise_error(T::CoercionError)
       expect(
-        T::Coerce[T::Array[T.nilable(Integer)]].new.from(['1', 'invalid', '3']),
-      ).to eql [1, nil, 3]
-      expect(
-        T::Coerce[T::Array[T::Array[Integer]]].new.from(['', '', '']),
-      ).to eql [[], [], []]
+        T::Coerce[T::Array[T::Array[Integer]]].new.from([nil])
+      ).to eql([[]])
       expect(
         T::Coerce[T::Array[T::Array[Integer]]].new.from([['1'], ['2'], ['3']]),
       ).to eql [[1], [2], [3]]
@@ -64,12 +64,12 @@ describe T::Coerce do
           T::Array[
             T::Array[
               T::Array[
-                T::Array[T.nilable(User)]
+                T::Array[User]
               ]
             ]
           ]
         ]
-      ].new.from(nil).flatten).to eql([nil])
+      ].new.from([[[[[{id: 1}]]]]]).flatten.first.id).to eql 1
 
       expect(T::Coerce[
         T.nilable(T::Array[T.nilable(T::Array[T.nilable(User)])])

data/spec/soft_error_spec.rb

@@ -0,0 +1,54 @@
+# typed: false
+require 'sorbet-coerce'
+require 'sorbet-runtime'
+
+describe T::Coerce do
+  context 'when type errors are soft errors' do
+    let(:ignore_error) { Proc.new {} }
+
+    before(:each) do
+      allow(T::Configuration).to receive(
+        :inline_type_error_handler,
+      ).and_return(ignore_error)
+
+      allow(T::Configuration).to receive(
+        :call_validation_error_handler,
+      ).and_return(ignore_error)
+
+      allow(T::Configuration).to receive(
+        :sig_builder_error_handler,
+      ).and_return(ignore_error)
+    end
+
+    class ParamsWithSortError < T::Struct
+      const :a, Integer
+    end
+
+    class CustomTypeRaisesHardError
+      def initialize(value)
+        raise StandardError.new('value cannot be 1') if value == 1
+      end
+    end
+
+    class CustomTypeDoesNotRiaseHardError
+      def self.new(a); 1; end
+    end
+
+    it 'works as expected' do
+      invalid_arg = 'invalid integer string'
+      expect(T::Coerce[Integer].new.from(invalid_arg)).to eql(invalid_arg)
+      expect(T::Coerce[T::Array[Integer]].new.from(1)).to be 1
+      expect(T::Coerce[T::Array[Integer]].new.from(invalid_arg)).to eql(invalid_arg)
+      expect(T::Coerce[T::Array[Integer]].new.from({a: 1})).to eql([[:a, 1]])
+
+      expect {
+        T::Coerce[CustomTypeRaisesHardError].new.from(1)
+      }.to raise_error(StandardError)
+      expect(T::Coerce[CustomTypeDoesNotRiaseHardError].new.from(1)).to eql(1)
+
+      if Gem.loaded_specs['sorbet-runtime'].version >= Gem::Version.new('0.4.4948')
+        expect(T::Coerce[ParamsWithSortError].new.from({a: invalid_arg}).a).to eql(invalid_arg)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-coerce
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -123,6 +123,7 @@ files:
 - rbi/sorbet-coerce.rbi
 - spec/coerce_spec.rb
 - spec/nested_spec.rb
+- spec/soft_error_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/chanzuckerberg/sorbet-coerce
 licenses: