sorbet-coerce 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 459ea1a3f906360f8a0e0d33969f49110476a1aa8d1772a1adc4dc1fc704140c
-  data.tar.gz: 7e2bf805fcb1d89de859312576d7e9e4eb782d03e4e7ff5929205c0fb676e377
+  metadata.gz: 07b8a2f1d773bf25d7abda4c1bfc6de014a7b41c9dde01b58ff27e4aaa5952a7
+  data.tar.gz: ea45ba6647ed640581243698193f9c7e24520d1ab2b2dea9009bf97ddee5309b
 SHA512:
-  metadata.gz: c75dfa39c75773bd161fc67f2ee145192bc6431f58db621a39eadd2c02948d39a117f3d1a5c8ad277338cf1ab0342a6f4153f20326bd379e28e8a734ca1d190c
-  data.tar.gz: d9c87f91c2586aac705089fe519d6c58e28854fe8cf87019468f46ad4421e8166d5f042c6f512c983d25b120e4b31f699f755706694a47a29c91b2d38c1a5a78
+  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)
 
@@ -151,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)
@@ -174,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

@@ -47,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
 
@@ -63,6 +71,22 @@ 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,
@@ -144,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
@@ -192,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 []
@@ -273,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
@@ -295,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.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Chan Zuckerberg Initiative
@@ -76,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: 
@@ -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;