sorbet-coerce 0.2.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a6067fb52161543309158003029c02c354f0c88d6dada780973141b4c7f3ca5
-  data.tar.gz: 15e371a34bdbb450ffa5a24f6f235d4f67f7b6964c1819a81286d60f687f2d66
+  metadata.gz: 459ea1a3f906360f8a0e0d33969f49110476a1aa8d1772a1adc4dc1fc704140c
+  data.tar.gz: 7e2bf805fcb1d89de859312576d7e9e4eb782d03e4e7ff5929205c0fb676e377
 SHA512:
-  metadata.gz: f0000b0124391cb0432486aaa4193442bb5adfd3ff67552bb6671a38ea4709f9c81b850355b838e00f6dda72f5d207f117b694dee1f78eb9f4d2805af7cad55d
-  data.tar.gz: 1ac80f3aad685c57123d4acd67178385a0068190676c4446d4bc6c99945e8313ea67b09e2a40958fc7e08778d8811a969e0467b46ed5071fc80d5aafa429de75
+  metadata.gz: c75dfa39c75773bd161fc67f2ee145192bc6431f58db621a39eadd2c02948d39a117f3d1a5c8ad277338cf1ab0342a6f4153f20326bd379e28e8a734ca1d190c
+  data.tar.gz: d9c87f91c2586aac705089fe519d6c58e28854fe8cf87019468f46ad4421e8166d5f042c6f512c983d25b120e4b31f699f755706694a47a29c91b2d38c1a5a78

data/lib/bundled_rbi/sorbet-coerce.rbi

@@ -1,4 +1,4 @@
-# typed: true
+# typed: false
 module SafeType
   class CoercionError < StandardError; end
 end

data/lib/sorbet-coerce.rb

@@ -1,23 +1,8 @@
-# typed: strict
-require 'sorbet-coerce/configuration'
+# typed: ignore
 require 'sorbet-coerce/converter'
-require 'safe_type'
 
 module TypeCoerce
-  class CoercionError < SafeType::CoercionError; end
-  class ShapeError < SafeType::CoercionError; end
-
-  define_singleton_method(:[]) do |type|
-    Class.new(TypeCoerce::Private::Converter) do
-      define_method(:to_s) { "#{name}#[#{type.to_s}]" }
-
-      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
+  def self.[](type)
+    TypeCoerce::Converter.new(type)
   end
 end

data/lib/sorbet-coerce/converter.rb

@@ -1,149 +1,185 @@
-# typed: strict
+# typed: ignore
+require 'polyfill'
 require 'safe_type'
 require 'set'
 require 'sorbet-runtime'
-require 'polyfill'
+require 'sorbet-coerce/configuration'
 
 using Polyfill(Hash: %w[#slice])
 
-module TypeCoerce; end
-
-module TypeCoerce::Private
-  class Converter
-    extend T::Sig
-
-    PRIMITIVE_TYPES = T.let(::Set[
-      Date,
-      DateTime,
-      Float,
-      Integer,
-      String,
-      Symbol,
-      Time,
-    ], T.untyped)
-
-    protected
-    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, 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))
-        nil_idx = T.let(nil, T.nilable(Integer))
-
-        type.types.each_with_index do |t, i|
-          nil_idx = i if t.is_a?(T::Types::Simple) && t.raw_type == NilClass
-          true_idx = i if t.is_a?(T::Types::Simple) && t.raw_type == TrueClass
-          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 (
-          (!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
-          ))
-        )
-
-        if !true_idx.nil? && !false_idx.nil?
-          _convert_simple(value, T::Boolean, raise_coercion_error)
-        else
-          _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, 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, raise_coercion_error)
-      end
-    end
+module TypeCoerce
+  class CoercionError < SafeType::CoercionError; end
+  class ShapeError < SafeType::CoercionError; end
+end
 
-    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)
+class TypeCoerce::Converter
+  def initialize(type)
+    @type = type
+  end
 
-      safe_type_rule = T.let(nil, T.untyped)
+  def new
+    self
+  end
 
-      if type == T::Boolean
-        safe_type_rule = SafeType::Boolean.strict
-      elsif value.is_a?(type)
-        return value
-      elsif PRIMITIVE_TYPES.include?(type)
-        safe_type_rule = SafeType.const_get(type.name).strict
-      else
-        safe_type_rule = type
+  def to_s
+    "#{name}#[#{@type.to_s}]"
+  end
+
+  def from(args, raise_coercion_error: nil)
+    if raise_coercion_error.nil?
+      raise_coercion_error = TypeCoerce::Configuration.raise_coercion_error
+    end
+
+    T.let(_convert(args, @type, raise_coercion_error), @type)
+  end
+
+  private
+
+  PRIMITIVE_TYPES = T.let(::Set[
+    Date,
+    DateTime,
+    Float,
+    Integer,
+    String,
+    Symbol,
+    Time,
+  ], 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, 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))
+      nil_idx = T.let(nil, T.nilable(Integer))
+
+      type.types.each_with_index do |t, i|
+        nil_idx = i if t.is_a?(T::Types::Simple) && t.raw_type == NilClass
+        true_idx = i if t.is_a?(T::Types::Simple) && t.raw_type == TrueClass
+        false_idx = i if t.is_a?(T::Types::Simple) && t.raw_type == FalseClass
       end
 
-      if safe_type_rule.is_a?(SafeType::Rule)
-        SafeType::coerce(value, safe_type_rule)
+      raise ArgumentError.new(
+        'the only supported union types are T.nilable and T::Boolean',
+      ) 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
+        ))
+      )
+
+      if !true_idx.nil? && !false_idx.nil?
+        _convert_simple(value, T::Boolean, raise_coercion_error)
       else
-        type.new(value)
+        _convert(value, type.types[nil_idx == 0 ? 1 : 0], raise_coercion_error)
       end
-    rescue SafeType::EmptyValueError, SafeType::CoercionError
-      if raise_coercion_error
-        raise TypeCoerce::CoercionError.new(value, type)
-      else
-        nil
+    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
-    end
 
-    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)
+      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, 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)
+    else
+      return value if value.is_a?(type)
+
+      _convert_simple(value, type, raise_coercion_error)
+    end
+  end
 
-      unless ary.respond_to?(:map)
-        raise TypeCoerce::ShapeError.new(ary, type)
-      end
+  def _convert_enum(value, type, raise_coercion_error)
+    if raise_coercion_error
+      type.deserialize(value)
+    else
+      type.try_deserialize(value)
+    end
+  rescue KeyError
+    raise TypeCoerce::CoercionError.new(value, type)
+  end
 
-      ary.map { |value| _convert(value, type, raise_coercion_error) }
+  def _convert_simple(value, type, raise_coercion_error)
+    return nil if _nil_like?(value, type)
+
+    safe_type_rule = T.let(nil, T.untyped)
+
+    if type == T::Boolean
+      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
+      safe_type_rule = type
     end
 
-    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)
+    if safe_type_rule.is_a?(SafeType::Rule)
+      SafeType::coerce(value, safe_type_rule)
+    else
+      type.new(value)
+    end
+  rescue SafeType::EmptyValueError, SafeType::CoercionError
+    if raise_coercion_error
+      raise TypeCoerce::CoercionError.new(value, type)
+    else
+      nil
+    end
+  end
 
-      unless args.respond_to?(:each_pair)
-        raise TypeCoerce::ShapeError.new(args, type)
-      end
+  def _convert_to_a(ary, type, raise_coercion_error)
+    return [] if _nil_like?(ary, type)
 
-      props = type.props
-      args.map { |name, value|
-        key = name.to_sym
-        [
-          key,
-          (!props.include?(key) || value.nil?) ?
-            nil : _convert(value, props[key][:type], raise_coercion_error),
-        ]
-      }.to_h.slice(*props.keys)
+    unless ary.respond_to?(:map)
+      raise TypeCoerce::ShapeError.new(ary, type)
     end
 
-    sig { params(value: T.untyped, type: T.untyped).returns(T::Boolean) }
-    def _nil_like?(value, type)
-      value.nil? || (value == '' && type != String)
+    ary.map { |value| _convert(value, type, raise_coercion_error) }
+  end
+
+  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], raise_coercion_error),
+      ]
+    }.to_h.slice(*props.keys)
+  end
+
+  def _nil_like?(value, type)
+    value.nil? || (value == '' && type != String)
   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
@@ -35,6 +36,17 @@ describe TypeCoerce do
       const :myhash, T::Hash[String, Integer], default: Hash['a' => 1]
     end
 
+    class TestEnum < T::Enum
+      enums do
+        Test = new
+        Other = new
+      end
+    end
+
+    class WithEnum < T::Struct
+      const :myenum, TestEnum
+    end
+
     class CustomType
       attr_reader :a
 
@@ -54,6 +66,7 @@ describe TypeCoerce do
     let!(:param) {
       TypeCoerce[Param].new.from({
         id: 1,
+        price: BigDecimal('98.76'),
         info: {
           name: 'mango',
           lvl: 100,
@@ -70,6 +83,7 @@ describe TypeCoerce do
     let!(:param2) {
       TypeCoerce[Param].new.from({
         id: '2',
+        price: '98.76',
         info: {
           name: 'honeydew',
           lvl: '5',
@@ -86,6 +100,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)
@@ -95,12 +110,15 @@ 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]
       expect(param.opt.notes).to eql []
+      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 []
@@ -163,8 +181,10 @@ describe TypeCoerce do
 
   context 'when given custom types' do
     it 'coerces correctly' do
-      T.assert_type!(TypeCoerce[CustomType].new.from(a: 1), CustomType)
-      expect(TypeCoerce[CustomType].new.from(1).a).to be 1
+      obj = TypeCoerce[CustomType].new.from(1)
+      T.assert_type!(obj, CustomType)
+      expect(obj.a).to be 1
+      expect(TypeCoerce[CustomType].new.from(obj)).to be obj
 
       expect{TypeCoerce[UnsupportedCustomType].new.from(1)}.to raise_error(ArgumentError)
       # CustomType2.new(anything) returns Integer 1; 1.is_a?(CustomType2) == false
@@ -251,6 +271,24 @@ describe TypeCoerce do
     end
   end
 
+  context 'when dealing with enums' do
+    it 'coerces a serialized enum correctly' do
+      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)
+      expect(coerced.myenum).to eq(TestEnum::Test)
+    end
+
+    it 'handles bad enum' do
+      expect {
+        TypeCoerce[WithEnum].new.from(myenum: "bad_key")
+      }.to raise_error(TypeCoerce::CoercionError)
+    end
+  end
+
   it 'works with T.untyped' do
     expect(TypeCoerce[T.untyped].new.from(1)).to eql 1
 

data/spec/soft_error_spec.rb

@@ -4,6 +4,12 @@ require 'sorbet-runtime'
 
 describe TypeCoerce do
   context 'when type errors are soft errors' do
+    class SoftErrorTestEnum < T::Enum
+      enums do
+        Other = new
+      end
+    end
+
     let(:ignore_error) { Proc.new {} }
 
     before(:each) do
@@ -48,6 +54,7 @@ describe TypeCoerce do
 
     it 'works as expected' do
       expect(TypeCoerce[Integer].new.from(invalid_arg)).to eql(nil)
+      expect(TypeCoerce[SoftErrorTestEnum].new.from('bad_key')).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])

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-coerce
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.5.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
@@ -72,44 +58,58 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.4.4704
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        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: 
@@ -122,7 +122,6 @@ files:
 - lib/sorbet-coerce.rb
 - lib/sorbet-coerce/configuration.rb
 - lib/sorbet-coerce/converter.rb
-- lib/sorbet-coerce/coverter.rbi
 - spec/coerce_spec.rb
 - spec/nested_spec.rb
 - spec/soft_error_spec.rb
@@ -147,8 +146,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: A type coercion lib works with Sorbet's static type checker and type definitions;

data/lib/sorbet-coerce/coverter.rbi

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