sorbet-coerce 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4605f60de1cb850becbead372463c72a479e75c4733744d22241ddcfe735620f
-  data.tar.gz: 367859276f17ed037a1b86c472932d686e89e6bb643859ff57ac39d22e3a6f7d
+  metadata.gz: 5e0850189628e40cec7b240cd1a12c5abf995369f363444b7f5ecd398239bfa4
+  data.tar.gz: 06756e0942061e2feb84958027a666a86b52345000b797a5cab3ceaccbfce0f9
 SHA512:
-  metadata.gz: c38e66605e0d58224aa5ee7cd9705d6dd62abdaedefc265752f4723bfdf0c1611af8f7906691484a73a48f35113bb457a6dafc5ec640e68f3921b12166f90385
-  data.tar.gz: 841c74dfed4c9860125865ead6649d1e80799a7d3a81e88c4d7878e549718080744abd261dcddb0e23e89521e33448594ddbbd33bc44842853a1bb79a153af20
+  metadata.gz: b08186d2c9c95bc3933f15895e23031a09fd49af3d16886c82433831e5d395c4a496c9e58a2b22c42630d01b925d151beca01656446a3d10b0ca46acab83dcad
+  data.tar.gz: 9dcec07cc34048713d4ea627b1afac67c6885e82e8623ecad4b2f36af763c70c13e7d79a6d295c36cb2d502f62837b7df5f304c29d845f40d5be2b75660b64b7

data/rbi/sorbet-coerce.rbi

@@ -0,0 +1,20 @@
+# typed: true
+module T
+  module Coerce
+    extend T::Sig
+    extend T::Generic
+
+    Elem = type_member
+
+    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,175 @@
+# 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]
+    end
+
+    class Param < T::Struct
+      const :id, Integer
+      const :role, String, default: 'wizard'
+      const :info, ParamInfo
+      const :opt, T.nilable(ParamInfo2)
+    end
+
+    class CustomType
+      attr_reader :a
+
+      def initialize(a)
+        @a = a
+      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).to be nil # missing notes
+
+      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[T.nilable(Param)].new.from({
+          id: 3,
+          info: {
+            # missing required name
+            lvl: 2,
+          },
+        })
+      ).to be nil
+    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 be nil
+      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
+    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(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('not an array')).to eql []
+      expect(T::Coerce[T::Array[Integer]].new.from('1')).to eql [1]
+      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 eql []
+
+      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 eql [1, nil, 3]
+      expect(
+        T::Coerce[T::Array[T::Array[Integer]]].new.from(['', '', '']),
+      ).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[T.nilable(User)]
+              ]
+            ]
+          ]
+        ]
+      ].new.from(nil).flatten).to eql([nil])
+
+      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/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.4
+  version: 0.1.5
 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: 
@@ -120,6 +120,10 @@ extra_rdoc_files: []
 files:
 - lib/private/converter.rb
 - lib/sorbet-coerce.rb
+- rbi/sorbet-coerce.rbi
+- spec/coerce_spec.rb
+- spec/nested_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/chanzuckerberg/sorbet-coerce
 licenses:
 - MIT
@@ -140,7 +144,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;