sorbet-coerce 0.3.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3a8032d0ba46f76ce47d4ec30e3e486005028d61a06c4f1047d6691f3e995f4
-  data.tar.gz: 6ec0fd090fbce8cb3889d69ce10bfa07b74b928425af2f9a4ca47bf60d1d1889
+  metadata.gz: 07b8a2f1d773bf25d7abda4c1bfc6de014a7b41c9dde01b58ff27e4aaa5952a7
+  data.tar.gz: ea45ba6647ed640581243698193f9c7e24520d1ab2b2dea9009bf97ddee5309b
 SHA512:
-  metadata.gz: 4ec5337779c9eece9610d73a037662d36d2dc9e50cfc77dd2762fb323f90dcb6edca41ee1337c12074243b1a1587450753a8afce49f5923aaf4ee1f88cc0bb2b
-  data.tar.gz: 84a9967bac7c2fb07d7c0f7530f1c4063a687019cc66e5787d0d69b1973884cf7e32d245ff2e99cb258abb963ae037f68e7dcc84c78d5c8f1b253d5b2f0b123a
+  metadata.gz: d4052f15f7b98b91dcbc3e1eb086dd1a8f74694f73889d04f578af0cefae29ac87fb9f5d3ddc67d275f23b98335fa9865ddd0c483aba80788c3b41ebbb1b5f3b
+  data.tar.gz: 7d4145c0966431329cf292c6c7347db7dfbd6db3870ef44f0d5f876ecaf0e8e4395c466c5138556bc5972d439d08947d0de245334e7e618a7324edd3eaa22418

data/lib/sorbet-coerce/converter.rb

@@ -25,12 +25,12 @@ class TypeCoerce::Converter
     "#{name}#[#{@type.to_s}]"
   end
 
-  def from(args, raise_coercion_error: nil)
+  def from(args, raise_coercion_error: nil, coerce_empty_to_nil: false)
     if raise_coercion_error.nil?
       raise_coercion_error = TypeCoerce::Configuration.raise_coercion_error
     end
 
-    T.let(_convert(args, @type, raise_coercion_error), @type)
+    T.let(_convert(args, @type, raise_coercion_error, coerce_empty_to_nil), @type)
   end
 
   private
@@ -45,15 +45,19 @@ class TypeCoerce::Converter
     Time,
   ], T.untyped)
 
-  def _convert(value, type, raise_coercion_error)
+  def _convert(value, type, raise_coercion_error, coerce_empty_to_nil)
     if type.is_a?(T::Types::Untyped)
       value
+    elsif type.is_a?(T::Types::ClassOf)
+      value
     elsif type.is_a?(T::Types::TypedArray)
-      _convert_to_a(value, type.type, raise_coercion_error)
+      _convert_to_a(value, type.type, raise_coercion_error, coerce_empty_to_nil)
+    elsif type.is_a?(T::Types::FixedArray)
+      _convert_to_a(value, type.types, raise_coercion_error, coerce_empty_to_nil)
     elsif type.is_a?(T::Types::TypedSet)
-      Set.new(_convert_to_a(value, type.type, raise_coercion_error))
+      Set.new(_convert_to_a(value, type.type, raise_coercion_error, coerce_empty_to_nil))
     elsif type.is_a?(T::Types::Simple)
-      _convert(value, type.raw_type, raise_coercion_error)
+      _convert(value, type.raw_type, raise_coercion_error, coerce_empty_to_nil)
     elsif type.is_a?(T::Types::Union)
       true_idx = T.let(nil, T.nilable(Integer))
       false_idx = T.let(nil, T.nilable(Integer))
@@ -65,9 +69,7 @@ class TypeCoerce::Converter
         false_idx = i if t.is_a?(T::Types::Simple) && t.raw_type == FalseClass
       end
 
-      raise ArgumentError.new(
-        'the only supported union types are T.nilable and T::Boolean',
-      ) unless (
+      return value unless (
         (!true_idx.nil? && !false_idx.nil? && !nil_idx.nil?) || # T.nilable(T::Boolean)
         (type.types.length == 2 && (
           !nil_idx.nil? || (!true_idx.nil? && !false_idx.nil?) # T.nilable || T::Boolean
@@ -75,12 +77,12 @@ class TypeCoerce::Converter
       )
 
       if !true_idx.nil? && !false_idx.nil?
-        _convert_simple(value, T::Boolean, raise_coercion_error)
+        _convert_simple(value, T::Boolean, raise_coercion_error, coerce_empty_to_nil)
       else
-        _convert(value, type.types[nil_idx == 0 ? 1 : 0], raise_coercion_error)
+        _convert(value, type.types[nil_idx == 0 ? 1 : 0], raise_coercion_error, coerce_empty_to_nil)
       end
     elsif type.is_a?(T::Types::TypedHash)
-      return {} if _nil_like?(value, type)
+      return {} if _nil_like?(value, type, coerce_empty_to_nil)
 
       unless value.respond_to?(:map)
         raise TypeCoerce::ShapeError.new(value, type)
@@ -88,30 +90,34 @@ class TypeCoerce::Converter
 
       value.map do |k, v|
         [
-          _convert(k, type.keys, raise_coercion_error),
-          _convert(v, type.values, raise_coercion_error),
+          _convert(k, type.keys, raise_coercion_error, coerce_empty_to_nil),
+          _convert(v, type.values, raise_coercion_error, coerce_empty_to_nil),
         ]
       end.to_h
     elsif Object.const_defined?('T::Private::Types::TypeAlias') &&
           type.is_a?(T::Private::Types::TypeAlias)
-      _convert(value, type.aliased_type, raise_coercion_error)
-    elsif type.respond_to?(:<) && type < T::Struct
-      return value if value.is_a?(type)
-
-      args = _build_args(value, type, raise_coercion_error)
-      type.new(args)
-    elsif type.respond_to?(:<) && type < T::Enum
-      return value if value.is_a?(type)
-
-      _convert_enum(value, type, raise_coercion_error)
+      _convert(value, type.aliased_type, raise_coercion_error, coerce_empty_to_nil)
+    elsif type.is_a?(Class) || type.is_a?(Module)
+      return coerce_nil(value, type, coerce_empty_to_nil) if value.is_a?(type)
+
+      if type < T::Struct
+        args = _build_args(value, type, raise_coercion_error, coerce_empty_to_nil)
+        type.new(args)
+      elsif type < T::Enum
+        _convert_enum(value, type, raise_coercion_error, coerce_empty_to_nil)
+      else
+        _convert_simple(value, type, raise_coercion_error, coerce_empty_to_nil)
+      end
     else
-      return value if value.is_a?(type)
-
-      _convert_simple(value, type, raise_coercion_error)
+      if raise_coercion_error
+        raise TypeCoerce::CoercionError.new(value, type)
+      else
+        value
+      end
     end
   end
 
-  def _convert_enum(value, type, raise_coercion_error)
+  def _convert_enum(value, type, raise_coercion_error, coerce_empty_to_nil)
     if raise_coercion_error
       type.deserialize(value)
     else
@@ -121,8 +127,8 @@ class TypeCoerce::Converter
     raise TypeCoerce::CoercionError.new(value, type)
   end
 
-  def _convert_simple(value, type, raise_coercion_error)
-    return nil if _nil_like?(value, type)
+  def _convert_simple(value, type, raise_coercion_error, coerce_empty_to_nil)
+    return nil if _nil_like?(value, type, coerce_empty_to_nil)
 
     safe_type_rule = T.let(nil, T.untyped)
 
@@ -130,6 +136,8 @@ class TypeCoerce::Converter
       safe_type_rule = SafeType::Boolean.strict
     elsif value.is_a?(type)
       return value
+    elsif type == BigDecimal
+      return BigDecimal(value)
     elsif PRIMITIVE_TYPES.include?(type)
       safe_type_rule = SafeType.const_get(type.name).strict
     else
@@ -149,18 +157,24 @@ class TypeCoerce::Converter
     end
   end
 
-  def _convert_to_a(ary, type, raise_coercion_error)
-    return [] if _nil_like?(ary, type)
+  def _convert_to_a(ary, type, raise_coercion_error, coerce_empty_to_nil)
+    return [] if _nil_like?(ary, type, coerce_empty_to_nil)
 
     unless ary.respond_to?(:map)
       raise TypeCoerce::ShapeError.new(ary, type)
     end
 
-    ary.map { |value| _convert(value, type, raise_coercion_error) }
+    ary.map.with_index do |value, i|
+      if type.is_a?(Array)
+        _convert(value, type[i], raise_coercion_error, coerce_empty_to_nil)
+      else
+        _convert(value, type, raise_coercion_error, coerce_empty_to_nil)
+      end
+    end
   end
 
-  def _build_args(args, type, raise_coercion_error)
-    return {} if _nil_like?(args, Hash)
+  def _build_args(args, type, raise_coercion_error, coerce_empty_to_nil)
+    return {} if _nil_like?(args, Hash, coerce_empty_to_nil)
 
     unless args.respond_to?(:each_pair)
       raise TypeCoerce::ShapeError.new(args, type)
@@ -172,12 +186,22 @@ class TypeCoerce::Converter
       [
         key,
         (!props.include?(key) || value.nil?) ?
-          nil : _convert(value, props[key][:type], raise_coercion_error),
+          nil : _convert(value, props[key][:type], raise_coercion_error, coerce_empty_to_nil),
       ]
     }.to_h.slice(*props.keys)
   end
 
-  def _nil_like?(value, type)
-    value.nil? || (value == '' && type != String)
+  def _nil_like?(value, type, coerce_empty_to_nil)
+    return true if value.nil?
+    return true if value == '' && coerce_empty_to_nil
+    return true if value == '' && type != String
+
+    false
+  end
+
+  def coerce_nil(value, type, coerce_empty_to_nil)
+    return nil if _nil_like?(value, type, coerce_empty_to_nil)
+
+    value
   end
 end

data/spec/coerce_spec.rb

@@ -19,6 +19,7 @@ describe TypeCoerce do
     class Param < T::Struct
       const :id, Integer
       const :role, String, default: 'wizard'
+      const :price, BigDecimal
       const :info, ParamInfo
       const :opt, T.nilable(ParamInfo2)
     end
@@ -46,6 +47,14 @@ describe TypeCoerce do
       const :myenum, TestEnum
     end
 
+    class WithNilableString < T::Struct
+      const :myvalue, T.nilable(String)
+    end
+
+    class WithNilableInteger < T::Struct
+      const :myvalue, T.nilable(Integer)
+    end
+
     class CustomType
       attr_reader :a
 
@@ -62,9 +71,26 @@ describe TypeCoerce do
       # Does not respond to new
     end
 
+    class WithSupportedUnion < T::Struct
+      const :nilable, T.nilable(String)
+      const :nilable_boolean, T.nilable(T::Boolean)
+    end
+
+    class WithUnsupportedUnion < T::Struct
+      const :union, T.any(String, Integer)
+    end
+
+    class WithFixedArray < T::Struct
+      const :arr, [Integer, String, Integer]
+    end
+
+    class CustomString < String
+    end
+
     let!(:param) {
       TypeCoerce[Param].new.from({
         id: 1,
+        price: BigDecimal('98.76'),
         info: {
           name: 'mango',
           lvl: 100,
@@ -81,6 +107,7 @@ describe TypeCoerce do
     let!(:param2) {
       TypeCoerce[Param].new.from({
         id: '2',
+        price: '98.76',
         info: {
           name: 'honeydew',
           lvl: '5',
@@ -97,6 +124,7 @@ describe TypeCoerce do
     it 'reveals the right type' do
       T.assert_type!(param, Param)
       T.assert_type!(param.id, Integer)
+      T.assert_type!(param.price, BigDecimal)
       T.assert_type!(param.info, ParamInfo)
       T.assert_type!(param.info.name,String)
       T.assert_type!(param.info.lvl, Integer)
@@ -106,6 +134,7 @@ describe TypeCoerce do
     it 'coerces correctly' do
       expect(param.id).to eql 1
       expect(param.role).to eql 'wizard'
+      expect(param.price).to eql BigDecimal('98.76')
       expect(param.info.lvl).to eql 100
       expect(param.info.name).to eql 'mango'
       expect(param.info.skill_ids).to eql [123, 456]
@@ -113,6 +142,7 @@ describe TypeCoerce do
       expect(TypeCoerce[Param].new.from(param)).to eq(param)
 
       expect(param2.id).to eql 2
+      expect(param2.price).to eql BigDecimal('98.76')
       expect(param2.info.name).to eql 'honeydew'
       expect(param2.info.lvl).to eql 5
       expect(param2.info.skill_ids).to eql []
@@ -138,12 +168,12 @@ describe TypeCoerce do
   context 'when the given T::Struct is invalid' do
     class Param2 < T::Struct
       const :id, Integer
-      const :info, T.any(Integer, String)
+      const :param, Param
     end
 
     it 'raises an error' do
       expect {
-        TypeCoerce[Param2].new.from({id: 1, info: 1})
+        TypeCoerce[Param2].new.from({id: 1, info: {}})
       }.to raise_error(ArgumentError)
     end
   end
@@ -186,7 +216,34 @@ describe TypeCoerce do
     end
   end
 
-  context 'when dealing with arries' do
+  context 'when given union types' do
+    context 'supported union types' do
+      it 'coerces correctly' do
+        coerced = TypeCoerce[WithSupportedUnion].new.from({
+          nilable: 2,
+          nilable_boolean: 'true'
+        })
+        expect(coerced.nilable).to eq('2')
+        expect(coerced.nilable_boolean).to eq(true)
+      end
+    end
+
+    context 'unsupported union types' do
+      it 'keeps the values as-is' do
+        coerced = TypeCoerce[WithUnsupportedUnion].new.from({union: 'a'})
+        expect(coerced.union).to eq('a')
+
+        coerced = TypeCoerce[WithUnsupportedUnion].new.from({union: 2})
+        expect(coerced.union).to eq(2)
+
+        expect do
+          TypeCoerce[WithUnsupportedUnion].new.from({union: nil})
+        end.to raise_error(TypeError)
+      end
+    end
+  end
+
+  context 'when dealing with arrays' do
     it 'coreces correctly' do
       expect(TypeCoerce[T::Array[Integer]].new.from(nil)).to eql []
       expect(TypeCoerce[T::Array[Integer]].new.from('')).to eql []
@@ -267,18 +324,18 @@ describe TypeCoerce do
 
   context 'when dealing with enums' do
     it 'coerces a serialized enum correctly' do
-      coerced = TypeCoerce[WithEnum].new.from(myenum: "test")
+      coerced = TypeCoerce[WithEnum].new.from({myenum: "test"})
       expect(coerced.myenum).to eq(TestEnum::Test)
     end
 
     it 'handles a real enum correctly' do
-      coerced = TypeCoerce[WithEnum].new.from(myenum: TestEnum::Test)
+      coerced = TypeCoerce[WithEnum].new.from({myenum: TestEnum::Test})
       expect(coerced.myenum).to eq(TestEnum::Test)
     end
 
     it 'handles bad enum' do
       expect {
-        TypeCoerce[WithEnum].new.from(myenum: "bad_key")
+        TypeCoerce[WithEnum].new.from({myenum: "bad_key"})
       }.to raise_error(TypeCoerce::CoercionError)
     end
   end
@@ -289,4 +346,68 @@ describe TypeCoerce do
     obj = CustomType.new(1)
     expect(TypeCoerce[T::Hash[String, T.untyped]].new.from({a: obj})).to eq({'a' => obj})
   end
+
+  it 'works with T::Types::FixedArray' do
+    type = T.type_alias { [Integer, String, Integer] }
+    coerced = TypeCoerce[type].new.from(['1', 2, '3'])
+    expect(coerced).to eql([1, '2', 3])
+
+    coerced = TypeCoerce[WithFixedArray].new.from({ arr: ['1', 2, '3'] })
+    expect(coerced.arr).to eql([1, '2', 3])
+  end
+
+  context 'when dealing with T.class_of' do
+    it 'keeps the value as-is' do
+      string_class_type = T.class_of(String)
+      expect(TypeCoerce[string_class_type].new.from(String)).to eql(String)
+      expect(TypeCoerce[string_class_type].new.from(CustomString)).to eql(CustomString)
+      expect do
+        TypeCoerce[string_class_type].new.from(Integer)
+      end.to raise_error(TypeError)
+      expect do
+        TypeCoerce[string_class_type].new.from('a')
+      end.to raise_error(TypeError)
+    end
+  end
+
+  context 'when dealing with unknown types' do
+    context 'raise_coercion_error is enabled' do
+      it 'raises error' do
+        expect do
+          TypeCoerce['a'].new.from('a', raise_coercion_error: true)
+        end.to raise_error(TypeCoerce::CoercionError)
+      end
+    end
+    context 'raise_coercion_error is disabled' do
+      it 'keeps the value as-is (and let Sorbet raise error)' do
+        expect do
+          TypeCoerce['a'].new.from('a', raise_coercion_error: false)
+        end.to raise_error(/must be an T::Types::Base/i)
+      end
+    end
+  end
+
+  context 'when dealing with coercing empty strings' do
+    context 'when flag is set' do
+      it 'coerces empty strings to nil from a simple type' do
+        expect(TypeCoerce[T.nilable(String)].new.from('', coerce_empty_to_nil: true)).to be_nil
+      end
+
+      it 'coerces empty strings to nil from a struct' do
+        coerced = TypeCoerce[WithNilableString].new.from({myvalue: ''}, coerce_empty_to_nil: true)
+        expect(coerced.myvalue).to eql(nil)
+      end
+    end
+
+    context 'when flag is not set' do
+      it 'coerces empty strings to nil from a simple type' do
+        expect(TypeCoerce[T.nilable(String)].new.from('', coerce_empty_to_nil: false)).to eql('')
+      end
+
+      it 'coerces empty strings to nil from a struct' do
+        coerced = TypeCoerce[WithNilableString].new.from({myvalue: ''}, coerce_empty_to_nil: false)
+        expect(coerced.myvalue).to eql('')
+      end
+    end
+  end
 end

data/spec/sorbet_test_cases.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: false
 require 'sorbet-coerce'
 
 T.assert_type!(TypeCoerce[Integer].new.from('1'), Integer)

data/spec/spec_helper.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-coerce
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -10,20 +10,6 @@ bindir: bin
 cert_chain: []
 date: 2019-10-04 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  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
   name: polyfill
   requirement: !ruby/object:Gem::Requirement
@@ -73,43 +59,57 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.4.4704
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.8'
+        version: 0.4.4704
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.4.4704
+- !ruby/object:Gem::Dependency
+  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: 
@@ -146,7 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.8
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A type coercion lib works with Sorbet's static type checker and type definitions;