sorbet-coerce 0.4.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7503ed812a03fc5478701f1821be08195b10945d700dd27cda21088aa2e01f55
-  data.tar.gz: 6fd2a30012fad3af9f5fceee3de2a60c03bc7fb3f7fccdf42223b669c0e8c409
+  metadata.gz: 5831cb764479cf2f531e1f8b9ff26b189cfc7783ab0075f75aaa6e1a5bc5ac13
+  data.tar.gz: e9fd50d576cebbd6120e84c7c06db5e60828d3ad067fb374dd27d07b97b140a8
 SHA512:
-  metadata.gz: ebbeb777352a39fe67575ee44c12ccb4ad1433ff7504bd76a9f9b86d91aef09a6e120496763254f433af783e2ab6dfec17b7822651db1bf563f9b7f223e8149c
-  data.tar.gz: 7d536c441a095d32af634b7ad362750e9c6d4f95789cf9cfdeb3d77aa0a90485ca4622517d3138cf7815c9eadc0e282ef7e75711b5fde27d4bfcca75b561dba8
+  metadata.gz: df61492bbd7352033ee05db2b589078fe791b9a9f2b0e18539e89557a7a58c8f77b6f87fcf6aca3fb3b94933dc350b437738a68aee42e9214d946f177ea24e8e
+  data.tar.gz: 97356a851a7629866bdccb99beed3bb36a8820add245688161c8cbc0c734bfeabd5884794cb712d6090268f965f8a98df1ff7886674ed592695518f3e56c4956

data/lib/bundled_rbi/sorbet-coerce.rbi

@@ -9,8 +9,8 @@ module TypeCoerce
 
   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
+  sig { params(args: T.untyped, raise_coercion_error: T.nilable(T::Boolean), coerce_empty_to_nil: T::Boolean).returns(Elem) }
+  def from(args, raise_coercion_error: nil, coerce_empty_to_nil: false); end
 
   class CoercionError < SafeType::CoercionError; end
   class ShapeError < SafeType::CoercionError; end

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.4.0
+  version: 0.7.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: 
@@ -139,14 +139,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !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;