sorbet-coerce 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66e3f4b05deb745fbcff9b66bbb7ddfd1d10529ce292e9d27eaacc9bb7b8983f
-  data.tar.gz: 8a3e7c12cf1233854e369f3c6d02f3182ed4977ffee07a8bdd5bc223f02d216b
+  metadata.gz: 9749ed0f8347a42911400212d8a30279876e10b1983daabc16167f819fdd76bd
+  data.tar.gz: 2866bbe6175228c14b563928bf44521608486ca7c1cb2aa6dc4bbf19aafd0bcf
 SHA512:
-  metadata.gz: cbea704d16c04d30e695c5d65c0963e31288f1a70b5ba205fac12ca48bc65e8977882450927dc062ab26eab6d68c9f0861bf5f1931dec1ba9ebbe55a068c5f83
-  data.tar.gz: '09dda06d9da527001aca7fbbb4bd311385647317150a2efb0fd4fa07e1bfaed22130d4e0d36c4d35e17908cb972203764039a9537314db0507cea0ae595652ba'
+  metadata.gz: d8f9f8e5086248a4db00ef26a0285fb9363817f552f77658d0ca8c0b5c373221df6c67116b9735fcd33d41831f6c49d139dfd1608e44adbe0cd5168335b863c5
+  data.tar.gz: a159fd6c75c112e71ad4e801ae759b01051f1a1e0ef2d02f875e40b4444b25b098a9049f3ab7dea596b5373c5e86759ba3a78da622978ef8147ba4883a51c444

data/lib/private/converter.rb

@@ -53,13 +53,12 @@ module T::Private
         else
           _convert(value, type.types[nil_idx == 0 ? 1 : 0])
         end
+      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)
-        begin
-          type.new(args)
-        rescue T::Props::InvalidValueError, ArgumentError
-          nil
-        end
+        type.new(args)
       else
         _convert_simple(value, type)
       end
@@ -67,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
@@ -81,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
         [
@@ -114,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/{lib → rbi}/sorbet-coerce.rbi

@@ -1,5 +1,4 @@
-# typed: strong
-
+# typed: true
 module T
   module Coerce
     extend T::Sig
@@ -10,4 +9,12 @@ module T
     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

data/spec/coerce_spec.rb

@@ -0,0 +1,193 @@
+# typed: ignore
+require 'sorbet-coerce'
+require 'sorbet-runtime'
+
+describe T::Coerce do
+  context 'when given T::Struct' do
+    class ParamInfo < T::Struct
+      const :name, String
+      const :lvl, T.nilable(Integer)
+      const :skill_ids, T::Array[Integer]
+    end
+
+    class ParamInfo2 < T::Struct
+      const :a, Integer
+      const :b, Integer
+      const :notes, T::Array[String], default: []
+    end
+
+    class Param < T::Struct
+      const :id, Integer
+      const :role, String, default: 'wizard'
+      const :info, ParamInfo
+      const :opt, T.nilable(ParamInfo2)
+    end
+
+    class DefaultParams < T::Struct
+      const :a, Integer, default: 1
+    end
+
+    class CustomType
+      attr_reader :a
+
+      def initialize(a)
+        @a = a
+      end
+    end
+
+    class CustomType2
+      def self.new(a); 1; end
+    end
+
+    class UnsupportedCustomType
+      # Does not respond to new
+    end
+
+    let!(:param) {
+      T::Coerce[Param].new.from({
+        id: 1,
+        info: {
+          name: 'mango',
+          lvl: 100,
+          skill_ids: ['123', '456'],
+        },
+        opt: {
+          a: 1,
+          b: 2,
+        },
+        extra_attr: 'does not matter',
+      })
+    }
+
+    let!(:param2) {
+      T::Coerce[Param].new.from({
+        id: '2',
+        info: {
+          name: 'honeydew',
+          lvl: '5',
+          skill_ids: [],
+        },
+        opt: {
+          a: '1',
+          b: '2',
+          notes: [],
+        },
+      })
+    }
+
+    it 'reveals the right type' do
+      T.assert_type!(param, Param)
+      T.assert_type!(param.id, Integer)
+      T.assert_type!(param.info, ParamInfo)
+      T.assert_type!(param.info.name,String)
+      T.assert_type!(param.info.lvl, Integer)
+      T.assert_type!(param.opt, T.nilable(ParamInfo2))
+    end
+
+    it 'coerces correctly' do
+      expect(param.id).to eql 1
+      expect(param.role).to eql 'wizard'
+      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.notes).to eql []
+
+      expect(param2.id).to eql 2
+      expect(param2.info.name).to eql 'honeydew'
+      expect(param2.info.lvl).to eql 5
+      expect(param2.info.skill_ids).to eql []
+      expect(param2.opt.a).to eql 1
+      expect(param2.opt.b).to eql 2
+      expect(param2.opt.notes).to eql []
+
+      expect {
+        T::Coerce[Param].new.from({
+          id: 3,
+          info: {
+            # missing required name
+            lvl: 2,
+          },
+        })
+      }.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
+
+  context 'when the given T::Struct is invalid' do
+    class Param2 < T::Struct
+      const :id, Integer
+      const :info, T.any(Integer, String)
+    end
+
+    it 'raises an error' do
+      expect {
+        T::Coerce[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))
+    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{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
+
+  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
+
+      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('')).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: []}])
+      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: []}])
+      T.assert_type!(infos, T::Array[ParamInfo])
+      expect(infos.first.name).to eql 'b'
+    end
+  end
+
+  context 'when given a type alias' do
+    MyType = T.type_alias(T::Boolean)
+
+    it 'coerces correctly' do
+      expect(T::Coerce[MyType].new.from('false')).to be false
+    end
+  end
+end

data/spec/nested_spec.rb

@@ -0,0 +1,79 @@
+# typed: false
+require 'sorbet-coerce'
+require 'sorbet-runtime'
+
+describe T::Coerce do
+  context 'when given nested types' do
+    class User < T::Struct
+      const :id, Integer
+      const :valid, T.nilable(T::Boolean)
+    end
+
+    class NestedParam < T::Struct
+      const :users, T::Array[User]
+      const :params, T.nilable(NestedParam)
+    end
+
+    it 'works with nest T::Struct' do
+      converted = T::Coerce[NestedParam].new.from({
+        users: [{id: '1'}],
+        params: {
+          users: [{id: '2', valid: 'true'}],
+          params: {
+            users: [{id: '3', valid: 'true'}],
+          },
+        },
+      })
+      # => <NestedParam
+      #   params=<NestedParam
+      #     params=<NestedParam
+      #       params=nil,
+      #       users=[<User id=3 valid=true>]
+      #     >,
+      #     users=[<User id=2 valid=true>]
+      #   >,
+      #   users=[<User id=1 valid=nil>]
+      # >
+
+      expect(converted.users.map(&:id)).to eql([1])
+      expect(converted.params.users.map(&:id)).to eql([2])
+      expect(converted.params.params.users.map(&:id)).to eql([3])
+    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::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]]
+
+      expect(T::Coerce[
+        T::Array[
+          T::Array[
+            T::Array[User]
+          ]
+        ]
+      ].new.from([[[{id: '1'}]]]).flatten.first.id).to eql(1)
+
+      expect(T::Coerce[
+        T::Array[
+          T::Array[
+            T::Array[
+              T::Array[
+                T::Array[User]
+              ]
+            ]
+          ]
+        ]
+      ].new.from([[[[[{id: 1}]]]]]).flatten.first.id).to eql 1
+
+      expect(T::Coerce[
+        T.nilable(T::Array[T.nilable(T::Array[T.nilable(User)])])
+      ].new.from([[{id: '1'}]]).flatten.map(&:id)).to eql([1])
+    end
+  end
+end

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

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+# typed: strict
+require 'byebug'
+require 'simplecov'
+
+SimpleCov.start
+
+if ENV['CI'] == 'true'
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+RSpec.configure do |config|
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-coerce
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.4.4704
+- !ruby/object:Gem::Dependency
+  name: polyfill
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
 - !ruby/object:Gem::Dependency
   name: safe_type
   requirement: !ruby/object:Gem::Requirement
@@ -62,40 +76,40 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.8'
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.8'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.8'
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.8'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 11.0.1
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 11.0.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 11.0.1
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 11.0.1
 description: 
@@ -106,7 +120,11 @@ extra_rdoc_files: []
 files:
 - lib/private/converter.rb
 - lib/sorbet-coerce.rb
-- lib/sorbet-coerce.rbi
+- 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:
 - MIT
@@ -127,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: A type coercion lib works with Sorbet's static type checker and type definitions;