sorbet-coerce 0.1.6 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9749ed0f8347a42911400212d8a30279876e10b1983daabc16167f819fdd76bd
-  data.tar.gz: 2866bbe6175228c14b563928bf44521608486ca7c1cb2aa6dc4bbf19aafd0bcf
+  metadata.gz: 8c5679d22c95a68cf624bef8a9d3f0c62b9b33f158b439b4115b2cb2f18dc508
+  data.tar.gz: f74881e16d72bb4b07b5de8072ef1f10d7794e8e6af249f9edcf132628a3a0e2
 SHA512:
-  metadata.gz: d8f9f8e5086248a4db00ef26a0285fb9363817f552f77658d0ca8c0b5c373221df6c67116b9735fcd33d41831f6c49d139dfd1608e44adbe0cd5168335b863c5
-  data.tar.gz: a159fd6c75c112e71ad4e801ae759b01051f1a1e0ef2d02f875e40b4444b25b098a9049f3ab7dea596b5373c5e86759ba3a78da622978ef8147ba4883a51c444
+  metadata.gz: 5f0a4df69764c02a35aba2101740beb6445bc77dec5f5edea12c31c7db18837696153e4f41ab5604ba374a610a203377ec38f621c2d93f5e58a57d72e6e05b4b
+  data.tar.gz: 334a49158e79661994d826dbd5845b071260d66f5ffeae49d45d22c6c62a2deeeccb11fe3efe8e616856c2eb3bf60c12031795c4cace5817b87e6ca7ebfa633f

data/lib/bundled_rbi/sorbet-coerce.rbi

@@ -0,0 +1,17 @@
+# typed: true
+module SafeType
+  class CoercionError < StandardError; end
+end
+
+module TypeCoerce
+  extend T::Sig
+  extend T::Generic
+
+  Elem = type_member
+
+  sig { params(args: T.untyped, raise_coercion_error: T.nilable(T::Boolean)).returns(Elem) }
+  def from(args, raise_coercion_error: nil); end
+
+  class CoercionError < SafeType::CoercionError; end
+  class ShapeError < SafeType::CoercionError; end
+end

data/lib/configuration.rb

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

data/lib/private/converter.rb

@@ -1,13 +1,14 @@
 # typed: strict
 require 'safe_type'
+require 'set'
 require 'sorbet-runtime'
 require 'polyfill'
 
 using Polyfill(Hash: %w[#slice])
 
-module T; end
+module TypeCoerce; end
 
-module T::Private
+module TypeCoerce::Private
   class Converter
     extend T::Sig
 
@@ -22,12 +23,16 @@ module T::Private
     ], T.untyped)
 
     protected
-    sig { params(value: T.untyped, type: T.untyped).returns(T.untyped) }
-    def _convert(value, type)
-      if type.is_a?(T::Types::TypedArray)
-        _convert_to_a(value, type.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::Untyped)
+        value
+      elsif type.is_a?(T::Types::TypedArray)
+        _convert_to_a(value, type.type, raise_coercion_error)
+      elsif type.is_a?(T::Types::TypedSet)
+        Set.new(_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 +54,36 @@ 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 type.is_a?(T::Types::TypedHash)
+        return {} if _nil_like?(value, type)
+
+        unless value.respond_to?(:map)
+          raise TypeCoerce::ShapeError.new(value, type)
+        end
+
+        value.map do |k, v|
+          [
+            _convert(k, type.keys, raise_coercion_error),
+            _convert(v, type.values, raise_coercion_error),
+          ]
+        end.to_h
       elsif Object.const_defined?('T::Private::Types::TypeAlias') &&
             type.is_a?(T::Private::Types::TypeAlias)
-        _convert(value, type.aliased_type)
-      elsif type < T::Struct
-        args = _build_args(value, type.props)
+        _convert(value, type.aliased_type, raise_coercion_error)
+      elsif type.respond_to?(:<) && type < T::Struct
+        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)
@@ -79,31 +97,46 @@ module T::Private
       else
         safe_type_rule = type
       end
-      SafeType::coerce(value, safe_type_rule)
+
+      if safe_type_rule.is_a?(SafeType::Rule)
+        SafeType::coerce(value, safe_type_rule)
+      else
+        type.new(value)
+      end
     rescue SafeType::EmptyValueError, SafeType::CoercionError
-      value
-    rescue SafeType::InvalidRuleError
-      type.new(value)
+      if raise_coercion_error
+        raise TypeCoerce::CoercionError.new(value, type)
+      else
+        nil
+      end
     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 TypeCoerce::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 TypeCoerce::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/private/coverter.rbi

@@ -0,0 +1,10 @@
+# typed: true
+module T
+  module Private
+    module Types
+      class TypeAlias
+        def aliased_type; end
+      end
+    end
+  end
+end

data/lib/sorbet-coerce.rb

@@ -1,22 +1,22 @@
 # typed: strict
+require_relative 'configuration'
 require 'private/converter'
 require 'safe_type'
 
-module T
+module TypeCoerce
   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(TypeCoerce::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 = TypeCoerce::Configuration.raise_coercion_error
         end
+
+        T.send('let', send('_convert', args, type, raise_coercion_error), type)
       end
     end
   end

data/spec/coerce_spec.rb

@@ -2,7 +2,7 @@
 require 'sorbet-coerce'
 require 'sorbet-runtime'
 
-describe T::Coerce do
+describe TypeCoerce do
   context 'when given T::Struct' do
     class ParamInfo < T::Struct
       const :name, String
@@ -27,6 +27,14 @@ describe T::Coerce do
       const :a, Integer, default: 1
     end
 
+    class HashParams < T::Struct
+      const :myhash, T::Hash[String, Integer]
+    end
+
+    class HashParamsWithDefault < T::Struct
+      const :myhash, T::Hash[String, Integer], default: Hash['a' => 1]
+    end
+
     class CustomType
       attr_reader :a
 
@@ -44,7 +52,7 @@ describe T::Coerce do
     end
 
     let!(:param) {
-      T::Coerce[Param].new.from({
+      TypeCoerce[Param].new.from({
         id: 1,
         info: {
           name: 'mango',
@@ -60,7 +68,7 @@ describe T::Coerce do
     }
 
     let!(:param2) {
-      T::Coerce[Param].new.from({
+      TypeCoerce[Param].new.from({
         id: '2',
         info: {
           name: 'honeydew',
@@ -101,7 +109,7 @@ describe T::Coerce do
       expect(param2.opt.notes).to eql []
 
       expect {
-        T::Coerce[Param].new.from({
+        TypeCoerce[Param].new.from({
           id: 3,
           info: {
             # missing required name
@@ -110,8 +118,8 @@ describe T::Coerce do
         })
       }.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
+      expect(TypeCoerce[DefaultParams].new.from(nil).a).to be 1
+      expect(TypeCoerce[DefaultParams].new.from('').a).to be 1
     end
   end
 
@@ -123,63 +131,115 @@ describe T::Coerce do
 
     it 'raises an error' do
       expect {
-        T::Coerce[Param2].new.from({id: 1, info: 1})
+        TypeCoerce[Param2].new.from({id: 1, info: 1})
       }.to raise_error(ArgumentError)
     end
   end
 
   context 'when given primitive types' do
     it 'reveals the right type' do
-      T.assert_type!(T::Coerce[Integer].new.from(1), Integer)
-      T.assert_type!(T::Coerce[Integer].new.from('1.0'), Integer)
-      T.assert_type!(T::Coerce[T.nilable(Integer)].new.from(nil), T.nilable(Integer))
+      T.assert_type!(TypeCoerce[Integer].new.from(1), Integer)
+      T.assert_type!(TypeCoerce[Integer].new.from('1.0'), Integer)
+      T.assert_type!(TypeCoerce[T.nilable(Integer)].new.from(nil), T.nilable(Integer))
     end
 
     it 'coreces correctly' do
-      expect{T::Coerce[Integer].new.from(nil)}.to raise_error(T::CoercionError)
-      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{TypeCoerce[Integer].new.from(nil)}.to raise_error(TypeError)
+      expect(TypeCoerce[T.nilable(Integer)].new.from(nil) || 1).to eql 1
+      expect(TypeCoerce[Integer].new.from(2)).to eql 2
+      expect(TypeCoerce[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[Float].new.from('1.0')).to eql 1.0
+      expect{TypeCoerce[T.nilable(Integer)].new.from('invalid integer string')}.to raise_error(TypeCoerce::CoercionError)
+      expect(TypeCoerce[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(TypeCoerce[T::Boolean].new.from('false')).to be false
+      expect(TypeCoerce[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 ''
+      expect(TypeCoerce[T.nilable(Integer)].new.from('')).to be nil
+      expect{TypeCoerce[T.nilable(Integer)].new.from([])}.to raise_error(TypeCoerce::CoercionError)
+      expect(TypeCoerce[T.nilable(String)].new.from('')).to eql ''
     end
   end
 
   context 'when given custom types' do
     it 'coerces correctly' do
-      T.assert_type!(T::Coerce[CustomType].new.from(a: 1), CustomType)
-      expect(T::Coerce[CustomType].new.from(1).a).to be 1
+      T.assert_type!(TypeCoerce[CustomType].new.from(a: 1), CustomType)
+      expect(TypeCoerce[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)
+      expect{TypeCoerce[UnsupportedCustomType].new.from(1)}.to raise_error(ArgumentError)
+      # CustomType2.new(anything) returns Integer 1; 1.is_a?(CustomType2) == false
+      expect{TypeCoerce[CustomType2].new.from(1)}.to raise_error(TypeError)
     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('')).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 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: []}])
+      expect(TypeCoerce[T::Array[Integer]].new.from(nil)).to eql []
+      expect(TypeCoerce[T::Array[Integer]].new.from('')).to eql []
+      expect{TypeCoerce[T::Array[Integer]].new.from('not an array')}.to raise_error(TypeCoerce::ShapeError)
+      expect{TypeCoerce[T::Array[Integer]].new.from('1')}.to raise_error(TypeCoerce::ShapeError)
+      expect(TypeCoerce[T::Array[Integer]].new.from(['1', '2', '3'])).to eql [1, 2, 3]
+      expect{TypeCoerce[T::Array[Integer]].new.from(['1', 'invalid', '3'])}.to raise_error(TypeCoerce::CoercionError)
+      expect{TypeCoerce[T::Array[Integer]].new.from({a: 1})}.to raise_error(TypeCoerce::CoercionError)
+
+      infos = TypeCoerce[T::Array[ParamInfo]].new.from([{name: 'a', skill_ids: []}])
       T.assert_type!(infos, T::Array[ParamInfo])
       expect(infos.first.name).to eql 'a'
 
-      infos = T::Coerce[T::Array[ParamInfo]].new.from([{name: 'b', skill_ids: []}])
+      infos = TypeCoerce[T::Array[ParamInfo]].new.from([{name: 'b', skill_ids: []}])
       T.assert_type!(infos, T::Array[ParamInfo])
       expect(infos.first.name).to eql 'b'
+
+      expect {
+        TypeCoerce[ParamInfo2].new.from({a: nil, b: nil})
+      }.to raise_error(TypeError)
+    end
+  end
+
+  context 'when dealing with hashes' do
+    it 'coreces correctly' do
+      expect(TypeCoerce[T::Hash[T.untyped, T.untyped]].new.from(nil)).to eql({})
+
+      expect(TypeCoerce[T::Hash[String, T::Boolean]].new.from({
+        a: 'true',
+        b: 'false',
+      })).to eql({
+        'a' => true,
+        'b' => false,
+      })
+
+      expect(TypeCoerce[HashParams].new.from({
+        myhash: {'a' => '1', 'b' => '2'},
+      }).myhash).to eql({'a' => 1, 'b' => 2})
+
+      expect(TypeCoerce[HashParamsWithDefault].new.from({}).myhash).to eql({'a' => 1})
+
+      expect {
+        TypeCoerce[T::Hash[String, T::Boolean]].new.from({
+          a: 'invalid',
+          b: 'false',
+        })
+      }.to raise_error(TypeCoerce::CoercionError)
+
+      expect {
+        TypeCoerce[T::Hash[String, Integer]].new.from(1)
+      }.to raise_error(TypeCoerce::ShapeError)
+    end
+  end
+
+  context 'when dealing with sets' do
+    it 'coreces correctly' do
+      expect(TypeCoerce[T::Set[Integer]].new.from(
+        Set.new(['1', '2', '3'])
+      )).to eq Set.new([1, 2, 3])
+
+      expect {
+        TypeCoerce[T::Set[Integer]].new.from(Set.new(['1', 'invalid', '3']))
+      }.to raise_error(TypeCoerce::CoercionError)
+
+      expect {
+        TypeCoerce[T::Set[Integer]].new.from(1)
+      }.to raise_error(TypeCoerce::ShapeError)
     end
   end
 
@@ -187,7 +247,14 @@ describe T::Coerce do
     MyType = T.type_alias(T::Boolean)
 
     it 'coerces correctly' do
-      expect(T::Coerce[MyType].new.from('false')).to be false
+      expect(TypeCoerce[MyType].new.from('false')).to be false
     end
   end
+
+  it 'works with T.untyped' do
+    expect(TypeCoerce[T.untyped].new.from(1)).to eql 1
+
+    obj = CustomType.new(1)
+    expect(TypeCoerce[T::Hash[String, T.untyped]].new.from({a: obj})).to eq({'a' => obj})
+  end
 end

data/spec/nested_spec.rb

@@ -2,7 +2,7 @@
 require 'sorbet-coerce'
 require 'sorbet-runtime'
 
-describe T::Coerce do
+describe TypeCoerce do
   context 'when given nested types' do
     class User < T::Struct
       const :id, Integer
@@ -15,7 +15,7 @@ describe T::Coerce do
     end
 
     it 'works with nest T::Struct' do
-      converted = T::Coerce[NestedParam].new.from({
+      converted = TypeCoerce[NestedParam].new.from({
         users: [{id: '1'}],
         params: {
           users: [{id: '2', valid: 'true'}],
@@ -42,16 +42,16 @@ 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)
+        TypeCoerce[T::Array[T.nilable(Integer)]].new.from(['1', 'invalid', '3'])
+      }.to raise_error(TypeCoerce::CoercionError)
       expect(
-        T::Coerce[T::Array[T::Array[Integer]]].new.from([nil])
+        TypeCoerce[T::Array[T::Array[Integer]]].new.from([nil])
       ).to eql([[]])
       expect(
-        T::Coerce[T::Array[T::Array[Integer]]].new.from([['1'], ['2'], ['3']]),
+        TypeCoerce[T::Array[T::Array[Integer]]].new.from([['1'], ['2'], ['3']]),
       ).to eql [[1], [2], [3]]
 
-      expect(T::Coerce[
+      expect(TypeCoerce[
         T::Array[
           T::Array[
             T::Array[User]
@@ -59,7 +59,7 @@ describe T::Coerce do
         ]
       ].new.from([[[{id: '1'}]]]).flatten.first.id).to eql(1)
 
-      expect(T::Coerce[
+      expect(TypeCoerce[
         T::Array[
           T::Array[
             T::Array[
@@ -71,9 +71,18 @@ describe T::Coerce do
         ]
       ].new.from([[[[[{id: 1}]]]]]).flatten.first.id).to eql 1
 
-      expect(T::Coerce[
+      expect(TypeCoerce[
         T.nilable(T::Array[T.nilable(T::Array[T.nilable(User)])])
       ].new.from([[{id: '1'}]]).flatten.map(&:id)).to eql([1])
     end
+
+    it 'works with nested T::Hash' do
+      expect(
+        TypeCoerce[T::Hash[Symbol, T::Hash[Symbol, Integer]]].new.from({
+          a: nil,
+          b: {c: '1'}
+        })
+      ).to eql({a: {}, b: {c: 1}})
+    end
   end
 end

data/spec/soft_error_spec.rb

@@ -2,11 +2,15 @@
 require 'sorbet-coerce'
 require 'sorbet-runtime'
 
-describe T::Coerce do
+describe TypeCoerce do
   context 'when type errors are soft errors' do
     let(:ignore_error) { Proc.new {} }
 
     before(:each) do
+      allow(TypeCoerce::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 {
+        TypeCoerce[Integer].new.from(invalid_arg, raise_coercion_error: true)
+      }.to raise_error(TypeCoerce::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(TypeCoerce[Integer].new.from(invalid_arg)).to eql(nil)
+
+      expect{TypeCoerce[T::Array[Integer]].new.from(1)}.to raise_error(TypeCoerce::ShapeError)
+      expect(TypeCoerce[T::Array[Integer]].new.from({a: 1})).to eql([nil])
 
       expect {
-        T::Coerce[CustomTypeRaisesHardError].new.from(1)
+        TypeCoerce[CustomTypeRaisesHardError].new.from(1)
       }.to raise_error(StandardError)
-      expect(T::Coerce[CustomTypeDoesNotRiaseHardError].new.from(1)).to eql(1)
+      expect(TypeCoerce[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(TypeCoerce[ParamsWithSortError].new.from({a: invalid_arg}).a).to eql(nil)
       end
     end
   end

data/spec/sorbet_test_cases.rb

@@ -0,0 +1,22 @@
+# typed: true
+require 'sorbet-coerce'
+
+T.assert_type!(TypeCoerce[Integer].new.from('1'), Integer)
+T.assert_type!(
+  TypeCoerce[T.nilable(Integer)].new.from('invalid', raise_coercion_error: false),
+  T.nilable(Integer),
+)
+
+TypeCoerce::Configuration.raise_coercion_error = true
+coercion_error = nil
+begin
+  TypeCoerce[T.nilable(Integer)].new.from('invalid')
+rescue TypeCoerce::CoercionError => e
+  coercion_error = e
+end
+raise 'no coercion error is raised' unless coercion_error
+
+T.assert_type!(
+  TypeCoerce[T.nilable(Integer)].new.from('invalid', raise_coercion_error: false),
+  T.nilable(Integer),
+)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-coerce
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.4
 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,12 +118,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/bundled_rbi/sorbet-coerce.rbi
+- lib/configuration.rb
 - lib/private/converter.rb
+- lib/private/coverter.rbi
 - lib/sorbet-coerce.rb
-- rbi/sorbet-coerce.rbi
 - spec/coerce_spec.rb
 - spec/nested_spec.rb
 - spec/soft_error_spec.rb
+- spec/sorbet_test_cases.rb
 - spec/spec_helper.rb
 homepage: https://github.com/chanzuckerberg/sorbet-coerce
 licenses:
@@ -137,7 +140,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:
   - - ">="

data/rbi/sorbet-coerce.rbi

@@ -1,20 +0,0 @@
-# typed: true
-module T
-  module Coerce
-    extend T::Sig
-    extend T::Generic
-
-    Elem = type_member
-
-    sig { params(args: T.untyped).returns(Elem) }
-    def from(args); end
-  end
-
-  module Private
-    module Types
-      class TypeAlias
-        def aliased_type; end
-      end
-    end
-  end
-end