sorbet-coerce 0.1.6 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9749ed0f8347a42911400212d8a30279876e10b1983daabc16167f819fdd76bd
-  data.tar.gz: 2866bbe6175228c14b563928bf44521608486ca7c1cb2aa6dc4bbf19aafd0bcf
+  metadata.gz: e5eefb63dc137b65889fa5dd16b05fcf3bef550474d7f7f175746ccca96e640d
+  data.tar.gz: 0ca052e76b580d9979d24444b8bee8d564a49c6d2162acd36469fbd205cb6354
 SHA512:
-  metadata.gz: d8f9f8e5086248a4db00ef26a0285fb9363817f552f77658d0ca8c0b5c373221df6c67116b9735fcd33d41831f6c49d139dfd1608e44adbe0cd5168335b863c5
-  data.tar.gz: a159fd6c75c112e71ad4e801ae759b01051f1a1e0ef2d02f875e40b4444b25b098a9049f3ab7dea596b5373c5e86759ba3a78da622978ef8147ba4883a51c444
+  metadata.gz: afb06e4b35972579d9ff0ffb0d9eb48c1de7465911b0f56a07a1d7dcda528f70d525834f5ac81c300394132ae5e8fec7d614814c900710778fa13296ed2db7f3
+  data.tar.gz: eecba6f2089a944984b2e6ba595ad21bbff2d11bb3fc56d38532fff94f029fe6beac3e1fce25272d46162e893d3040a548fe4240058db8a258900ee815acb946

data/lib/configuration.rb

@@ -0,0 +1,15 @@
+# typed: true
+require 'sorbet-runtime'
+
+module T::Coerce
+  module Configuration
+    class << self
+      extend T::Sig
+
+      sig { returns(T::Boolean) }
+      attr_accessor :raise_coercion_error
+    end
+  end
+end
+
+T::Coerce::Configuration.raise_coercion_error = true

data/lib/private/converter.rb

@@ -5,8 +5,6 @@ require 'polyfill'
 
 using Polyfill(Hash: %w[#slice])
 
-module T; end
-
 module T::Private
   class Converter
     extend T::Sig
@@ -22,12 +20,12 @@ module T::Private
     ], T.untyped)
 
     protected
-    sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
-    def _convert(value, type)
+    sig { params(value: T.untyped, type: T.untyped, raise_coercion_error: T::Boolean).returns(T.untyped) }
+    def _convert(value, type, raise_coercion_error)
       if type.is_a?(T::Types::TypedArray)
-        _convert_to_a(value, type.type)
+        _convert_to_a(value, type.type, raise_coercion_error)
       elsif type.is_a?(T::Types::Simple)
-        _convert(value, type.raw_type)
+        _convert(value, type.raw_type, raise_coercion_error)
       elsif type.is_a?(T::Types::Union)
         true_idx = T.let(nil, T.nilable(Integer))
         false_idx = T.let(nil, T.nilable(Integer))
@@ -49,23 +47,23 @@ module T::Private
         )
 
         if !true_idx.nil? && !false_idx.nil?
-          _convert_simple(value, T::Boolean)
+          _convert_simple(value, T::Boolean, raise_coercion_error)
         else
-          _convert(value, type.types[nil_idx == 0 ? 1 : 0])
+          _convert(value, type.types[nil_idx == 0 ? 1 : 0], raise_coercion_error)
         end
       elsif Object.const_defined?('T::Private::Types::TypeAlias') &&
             type.is_a?(T::Private::Types::TypeAlias)
-        _convert(value, type.aliased_type)
+        _convert(value, type.aliased_type, raise_coercion_error)
       elsif type < T::Struct
-        args = _build_args(value, type.props)
+        args = _build_args(value, type, raise_coercion_error)
         type.new(args)
       else
-        _convert_simple(value, type)
+        _convert_simple(value, type, raise_coercion_error)
       end
     end
 
-    sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
-    def _convert_simple(value, type)
+    sig { params(value: T.untyped, type: T.untyped, raise_coercion_error: T::Boolean).returns(T.untyped) }
+    def _convert_simple(value, type, raise_coercion_error)
       return nil if _nil_like?(value, type)
 
       safe_type_rule = T.let(nil, T.untyped)
@@ -81,29 +79,41 @@ module T::Private
       end
       SafeType::coerce(value, safe_type_rule)
     rescue SafeType::EmptyValueError, SafeType::CoercionError
-      value
+      if raise_coercion_error
+        raise T::Coerce::CoercionError.new(value, type)
+      else
+        nil
+      end
     rescue SafeType::InvalidRuleError
       type.new(value)
     end
 
-    sig { params(ary: T.untyped, type: T.untyped).returns(T.untyped) }
-    def _convert_to_a(ary, type)
+    sig { params(ary: T.untyped, type: T.untyped, raise_coercion_error: T::Boolean).returns(T.untyped) }
+    def _convert_to_a(ary, type, raise_coercion_error)
       return [] if _nil_like?(ary, type)
 
-      # Checked by the T.let at root
-      ary.respond_to?(:map) ? ary.map { |value| _convert(value, type) } : ary
+      unless ary.respond_to?(:map)
+        raise T::Coerce::ShapeError.new(ary, type)
+      end
+
+      ary.map { |value| _convert(value, type, raise_coercion_error) }
     end
 
-    sig { params(args: T.untyped, props: T.untyped).returns(T.untyped) }
-    def _build_args(args, props)
+    sig { params(args: T.untyped, type: T.untyped, raise_coercion_error: T::Boolean).returns(T.untyped) }
+    def _build_args(args, type, raise_coercion_error)
       return {} if _nil_like?(args, Hash)
 
+      unless args.respond_to?(:each_pair)
+        raise T::Coerce::ShapeError.new(args, type)
+      end
+
+      props = type.props
       args.map { |name, value|
         key = name.to_sym
         [
           key,
           (!props.include?(key) || value.nil?) ?
-            nil : _convert(value, props[key][:type]),
+            nil : _convert(value, props[key][:type], raise_coercion_error),
         ]
       }.to_h.slice(*props.keys)
     end

data/lib/sorbet-coerce.rb

@@ -1,22 +1,22 @@
 # typed: strict
+require_relative 'configuration'
 require 'private/converter'
 require 'safe_type'
 
-module T
+module T::Coerce
   class CoercionError < SafeType::CoercionError; end
+  class ShapeError < SafeType::CoercionError; end
 
-  module Coerce
-    define_singleton_method(:[]) do |type|
-      Class.new(T::Private::Converter) do
-        define_method(:to_s) { "#{name}#[#{type.to_s}]" }
+  define_singleton_method(:[]) do |type|
+    Class.new(T::Private::Converter) do
+      define_method(:to_s) { "#{name}#[#{type.to_s}]" }
 
-        define_method(:from) do |args|
-          begin
-            T.send('let', send('_convert', args, type), type)
-          rescue TypeError
-            raise CoercionError.new(args, type)
-          end
+      define_method(:from) do |args, raise_coercion_error: nil|
+        if raise_coercion_error.nil?
+          raise_coercion_error = T::Coerce::Configuration.raise_coercion_error
         end
+
+        T.send('let', send('_convert', args, type, raise_coercion_error), type)
       end
     end
   end

data/rbi/sorbet-coerce.rbi

@@ -6,8 +6,8 @@ module T
 
     Elem = type_member
 
-    sig { params(args: T.untyped).returns(Elem) }
-    def from(args); end
+    sig { params(args: T.untyped, raise_value_error: T.nilable(T::Boolean)).returns(Elem) }
+    def from(args, raise_value_error: nil); end
   end
 
   module Private

data/spec/coerce_spec.rb

@@ -136,19 +136,19 @@ describe T::Coerce do
     end
 
     it 'coreces correctly' do
-      expect{T::Coerce[Integer].new.from(nil)}.to raise_error(T::CoercionError)
+      expect{T::Coerce[Integer].new.from(nil)}.to raise_error(TypeError)
       expect(T::Coerce[T.nilable(Integer)].new.from(nil) || 1).to eql 1
       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 raise_error(T::CoercionError)
+      expect{T::Coerce[T.nilable(Integer)].new.from('invalid integer string')}.to raise_error(T::Coerce::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(Integer)].new.from([])}.to raise_error(T::Coerce::CoercionError)
       expect(T::Coerce[T.nilable(String)].new.from('')).to eql ''
     end
   end
@@ -159,7 +159,8 @@ describe T::Coerce do
       expect(T::Coerce[CustomType].new.from(1).a).to be 1
 
       expect{T::Coerce[UnsupportedCustomType].new.from(1)}.to raise_error(ArgumentError)
-      expect{T::Coerce[CustomType2].new.from(1)}.to raise_error(T::CoercionError)
+      # CustomType2.new(anything) returns Integer 1; 1.is_a?(CustomType2) == false
+      expect{T::Coerce[CustomType2].new.from(1)}.to raise_error(TypeError)
     end
   end
 
@@ -167,11 +168,11 @@ describe T::Coerce do
     it 'coreces correctly' do
       expect(T::Coerce[T::Array[Integer]].new.from(nil)).to eql []
       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('not an array')}.to raise_error(T::Coerce::ShapeError)
+      expect{T::Coerce[T::Array[Integer]].new.from('1')}.to raise_error(T::Coerce::ShapeError)
       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 raise_error(T::CoercionError)
-      expect{T::Coerce[T::Array[Integer]].new.from({a: 1})}.to raise_error(T::CoercionError)
+      expect{T::Coerce[T::Array[Integer]].new.from(['1', 'invalid', '3'])}.to raise_error(T::Coerce::CoercionError)
+      expect{T::Coerce[T::Array[Integer]].new.from({a: 1})}.to raise_error(T::Coerce::CoercionError)
 
       infos = T::Coerce[T::Array[ParamInfo]].new.from([{name: 'a', skill_ids: []}])
       T.assert_type!(infos, T::Array[ParamInfo])
@@ -180,6 +181,10 @@ describe T::Coerce do
       infos = T::Coerce[T::Array[ParamInfo]].new.from([{name: 'b', skill_ids: []}])
       T.assert_type!(infos, T::Array[ParamInfo])
       expect(infos.first.name).to eql 'b'
+
+      expect {
+        T::Coerce[ParamInfo2].new.from({a: nil, b: nil})
+      }.to raise_error(TypeError)
     end
   end
 

data/spec/nested_spec.rb

@@ -43,7 +43,7 @@ describe T::Coerce do
     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)
+      }.to raise_error(T::Coerce::CoercionError)
       expect(
         T::Coerce[T::Array[T::Array[Integer]]].new.from([nil])
       ).to eql([[]])

data/spec/soft_error_spec.rb

@@ -7,6 +7,10 @@ describe T::Coerce do
     let(:ignore_error) { Proc.new {} }
 
     before(:each) do
+      allow(T::Coerce::Configuration).to receive(
+        :raise_coercion_error,
+      ).and_return(false)
+
       allow(T::Configuration).to receive(
         :inline_type_error_handler,
       ).and_return(ignore_error)
@@ -34,20 +38,28 @@ describe T::Coerce do
       def self.new(a); 1; end
     end
 
+    let(:invalid_arg) { 'invalid integer string' }
+
+    it 'overwrites the global config when inline config is set' do
+      expect {
+        T::Coerce[Integer].new.from(invalid_arg, raise_coercion_error: true)
+      }.to raise_error(T::Coerce::CoercionError)
+    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[Integer].new.from(invalid_arg)).to eql(nil)
+
+      expect{T::Coerce[T::Array[Integer]].new.from(1)}.to raise_error(T::Coerce::ShapeError)
+      expect(T::Coerce[T::Array[Integer]].new.from({a: 1})).to eql([nil])
 
       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)
+      sorbet_version = Gem.loaded_specs['sorbet-runtime'].version
+      if sorbet_version >= Gem::Version.new('0.4.4948')
+        expect(T::Coerce[ParamsWithSortError].new.from({a: invalid_arg}).a).to eql(nil)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-coerce
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -14,14 +14,14 @@ dependencies:
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.4704
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.4704
 - !ruby/object:Gem::Dependency
@@ -62,14 +62,14 @@ dependencies:
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.4704
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.4704
 - !ruby/object:Gem::Dependency
@@ -118,6 +118,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/configuration.rb
 - lib/private/converter.rb
 - lib/sorbet-coerce.rb
 - rbi/sorbet-coerce.rbi
@@ -137,7 +138,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="