sorbet-schema 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c06e03c3878ac6b3cf04305124e1d3786de57f0543ee320181565a8b59f8c4b3
-  data.tar.gz: 97d11102e65875b5f77f06095fdacf1dea0fabdd1fd1a91b5428a509dd6bac4b
+  metadata.gz: 1b4040ccaa87f90e0d32acee9868fffb0f4d645e599fe29726738fdb54c4f1e6
+  data.tar.gz: b83d96b38d8b7d786a3e174e576053f531bf03e237d7c1f049e98b9c813dc117
 SHA512:
-  metadata.gz: 84e7f4308162784ee84b063ff743293cd6c72487479f23de3cf1ed31089f13ff8a148c4aad85854394343aa97eafbbab15551d54fd17ce8e390db343db5083c9
-  data.tar.gz: 37301dfecd29623d2f5be76220e70d0aa1a650dc2c792c3e01e15b4bce17abb2bf468f04dbfd5026686c11aa594590a91b369b49ef2a1de5393ff77af07d5d8b
+  metadata.gz: 248121230fc7a86b616259a89db47c210360034aad0ec70a23e2b25d73b350e16eff09c09ea87efd0aa859ef86b6f5c7f7700043b2e0d3e1f570555e98baac31
+  data.tar.gz: 6f0c35a33ff1e84ebe704c30a6d0ba4b3520030c8ca59c897c33cc96f736c48c16e8672e7f4efef6f81f4a9816326db41c1cc625f49addd520a437066a04db1c

data/CHANGELOG.md

@@ -4,6 +4,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0](https://github.com/maxveldink/sorbet-schema/compare/v0.5.1...v0.6.0) (2024-07-07)
+
+
+### ⚠ BREAKING CHANGES
+
+* implement default handling for fields ([#105](https://github.com/maxveldink/sorbet-schema/issues/105))
+
+### Features
+
+* implement default handling for fields ([#105](https://github.com/maxveldink/sorbet-schema/issues/105)) ([054d59f](https://github.com/maxveldink/sorbet-schema/commit/054d59ff92c68b272d495a0816370b9a890f0f50))
+* implement SymbolCoercer ([#109](https://github.com/maxveldink/sorbet-schema/issues/109)) ([422a995](https://github.com/maxveldink/sorbet-schema/commit/422a9957177039a3dde5c4daa41d597fd44f2b48))
+* implement TypedHashCoercer ([#110](https://github.com/maxveldink/sorbet-schema/issues/110)) ([6d64db7](https://github.com/maxveldink/sorbet-schema/commit/6d64db7fcef8af56cb96f1ee6c42ba1e3ce076c3))
+* support T.any for deserialization ([#107](https://github.com/maxveldink/sorbet-schema/issues/107)) ([c0c2ca3](https://github.com/maxveldink/sorbet-schema/commit/c0c2ca369abef136943e633b7987decad7291d98))
+
+
+### Bug Fixes
+
+* default value set to true causes undefined method [] error ([#108](https://github.com/maxveldink/sorbet-schema/issues/108)) ([6829bbf](https://github.com/maxveldink/sorbet-schema/commit/6829bbf8b6bf47db51209e9874608b7e10c38b8e))
+
+## [0.5.1](https://github.com/maxveldink/sorbet-schema/compare/v0.5.0...v0.5.1) (2024-06-26)
+
+
+### Features
+
+* support nested structs ([#102](https://github.com/maxveldink/sorbet-schema/issues/102)) ([08428e1](https://github.com/maxveldink/sorbet-schema/commit/08428e18afdbb4121ef2f290e8a85651b2e13edf))
+
 ## [0.5.0](https://github.com/maxveldink/sorbet-schema/compare/v0.4.2...v0.5.0) (2024-04-19)
 
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    sorbet-schema (0.5.0)
+    sorbet-schema (0.6.0)
       sorbet-result (~> 1.1)
       sorbet-runtime (~> 0.5)
       sorbet-struct-comparable (~> 1.3)
@@ -13,32 +13,32 @@ GEM
     ansi (1.5.0)
     ast (2.4.2)
     bigdecimal (3.1.8)
-    builder (3.2.4)
+    builder (3.3.0)
     debug (1.9.2)
       irb (~> 1.10)
       reline (>= 0.3.8)
-    erubi (1.12.0)
+    erubi (1.13.0)
     io-console (0.7.2)
-    irb (1.13.1)
+    irb (1.13.2)
       rdoc (>= 4.0.0)
       reline (>= 0.4.2)
     json (2.7.2)
     language_server-protocol (3.17.0.3)
     lint_roller (1.1.0)
-    minitest (5.23.1)
+    minitest (5.24.0)
     minitest-focus (1.4.0)
       minitest (>= 4, < 6)
-    minitest-reporters (1.6.1)
+    minitest-reporters (1.7.1)
       ansi
       builder
       minitest (>= 5.0)
       ruby-progressbar
     netrc (0.11.0)
-    parallel (1.24.0)
-    parser (3.3.1.0)
+    parallel (1.25.1)
+    parser (3.3.3.0)
       ast (~> 2.4.1)
       racc
-    prism (0.29.0)
+    prism (0.30.0)
     psych (5.1.2)
       stringio
     racc (1.8.0)
@@ -50,11 +50,11 @@ GEM
     rdoc (6.7.0)
       psych (>= 4.0.0)
     regexp_parser (2.9.2)
-    reline (0.5.7)
+    reline (0.5.9)
       io-console (~> 0.5)
-    rexml (3.2.8)
-      strscan (>= 3.0.9)
-    rubocop (1.63.5)
+    rexml (3.3.0)
+      strscan
+    rubocop (1.64.1)
       json (~> 2.3)
       language_server-protocol (>= 3.17.0)
       parallel (~> 1.10)
@@ -67,22 +67,22 @@ GEM
       unicode-display_width (>= 2.4.0, < 3.0)
     rubocop-ast (1.31.3)
       parser (>= 3.3.1.0)
-    rubocop-performance (1.21.0)
+    rubocop-performance (1.21.1)
       rubocop (>= 1.48.1, < 2.0)
       rubocop-ast (>= 1.31.1, < 2.0)
     rubocop-sorbet (0.7.8)
       rubocop (>= 0.90.0)
     ruby-progressbar (1.13.0)
-    sorbet (0.5.11391)
-      sorbet-static (= 0.5.11391)
+    sorbet (0.5.11444)
+      sorbet-static (= 0.5.11444)
     sorbet-result (1.1.0)
       sorbet-runtime (~> 0.5)
-    sorbet-runtime (0.5.11391)
-    sorbet-static (0.5.11391-universal-darwin)
-    sorbet-static (0.5.11391-x86_64-linux)
-    sorbet-static-and-runtime (0.5.11391)
-      sorbet (= 0.5.11391)
-      sorbet-runtime (= 0.5.11391)
+    sorbet-runtime (0.5.11444)
+    sorbet-static (0.5.11444-universal-darwin)
+    sorbet-static (0.5.11444-x86_64-linux)
+    sorbet-static-and-runtime (0.5.11444)
+      sorbet (= 0.5.11444)
+      sorbet-runtime (= 0.5.11444)
     sorbet-struct-comparable (1.3.0)
       sorbet-runtime (>= 0.5)
     spoom (1.3.2)
@@ -90,10 +90,10 @@ GEM
       prism (>= 0.19.0)
       sorbet-static-and-runtime (>= 0.5.10187)
       thor (>= 0.19.2)
-    standard (1.36.0)
+    standard (1.39.0)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.0)
-      rubocop (~> 1.63.0)
+      rubocop (~> 1.64.0)
       standard-custom (~> 1.0.0)
       standard-performance (~> 1.4)
     standard-custom (1.0.2)
@@ -105,9 +105,9 @@ GEM
     standard-sorbet (0.0.2)
       lint_roller (~> 1.1)
       rubocop-sorbet (~> 0.7.0)
-    stringio (3.1.0)
+    stringio (3.1.1)
     strscan (3.1.0)
-    tapioca (0.14.2)
+    tapioca (0.14.4)
       bundler (>= 2.2.25)
       netrc (>= 0.11.0)
       parallel (>= 1.21.0)
@@ -122,7 +122,7 @@ GEM
     yard-sorbet (0.8.1)
       sorbet-runtime (>= 0.5)
       yard (>= 0.9)
-    zeitwerk (2.6.15)
+    zeitwerk (2.6.16)
 
 PLATFORMS
   arm64-darwin-22

data/lib/sorbet-schema/version.rb

@@ -1,5 +1,5 @@
 # typed: strict
 
 module SorbetSchema
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/typed/coercion/coercer_registry.rb

@@ -14,13 +14,15 @@ module Typed
       DEFAULT_COERCERS = T.let(
         [
           StringCoercer,
+          SymbolCoercer,
           BooleanCoercer,
           IntegerCoercer,
           FloatCoercer,
           DateCoercer,
           EnumCoercer,
           StructCoercer,
-          TypedArrayCoercer
+          TypedArrayCoercer,
+          TypedHashCoercer
         ],
         Registry
       )

data/lib/typed/coercion/struct_coercer.rb

@@ -21,7 +21,15 @@ module Typed
 
         return Failure.new(CoercionError.new("Value of type '#{value.class}' cannot be coerced to #{type} Struct.")) unless value.is_a?(Hash)
 
-        Success.new(T.cast(type, T::Types::Simple).raw_type.from_hash!(HashTransformer.new.deep_stringify_keys(value)))
+        deserialization_result = T.cast(type, T::Types::Simple)
+          .raw_type
+          .deserialize_from(:hash, value)
+
+        if deserialization_result.success?
+          deserialization_result
+        else
+          Failure.new(CoercionError.new(deserialization_result.error.message))
+        end
       rescue ArgumentError, RuntimeError
         Failure.new(CoercionError.new("Given hash could not be coerced to #{type}."))
       end

data/lib/typed/coercion/symbol_coercer.rb

@@ -0,0 +1,27 @@
+# typed: strict
+
+module Typed
+  module Coercion
+    class SymbolCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: Symbol} }
+
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
+      def used_for_type?(type)
+        type == T::Utils.coerce(Symbol)
+      end
+
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Type must be a Symbol.")) unless used_for_type?(type)
+
+        if value.respond_to?(:to_sym)
+          Success.new(value.to_sym)
+        else
+          Failure.new(CoercionError.new("Value cannot be coerced into Symbol. Consider adding a #to_sym implementation."))
+        end
+      end
+    end
+  end
+end

data/lib/typed/coercion/typed_hash_coercer.rb

@@ -0,0 +1,50 @@
+# typed: strict
+
+module Typed
+  module Coercion
+    class TypedHashCoercer < Coercer
+      extend T::Generic
+
+      Target = type_member { {fixed: T::Hash[T.untyped, T.untyped]} }
+
+      sig { override.params(type: T::Types::Base).returns(T::Boolean) }
+      def used_for_type?(type)
+        type.is_a?(T::Types::TypedHash)
+      end
+
+      sig { override.params(type: T::Types::Base, value: Value).returns(Result[Target, CoercionError]) }
+      def coerce(type:, value:)
+        return Failure.new(CoercionError.new("Field type must be a T::Hash.")) unless used_for_type?(type)
+        return Failure.new(CoercionError.new("Value must be a Hash.")) unless value.is_a?(Hash)
+
+        return Success.new(value) if type.recursively_valid?(value)
+
+        coerced_hash = {}
+        errors = []
+
+        value.each do |k, v|
+          key_result = Coercion.coerce(type: T::Utils.coerce(T.cast(type, T::Types::TypedHash).type.types.first), value: k)
+          value_result = Coercion.coerce(type: T::Utils.coerce(T.cast(type, T::Types::TypedHash).type.types.last), value: v)
+
+          if key_result.success? && value_result.success?
+            coerced_hash[key_result.payload] = value_result.payload
+          else
+            if key_result.failure?
+              errors << key_result.error
+            end
+
+            if value_result.failure?
+              errors << value_result.error
+            end
+          end
+        end
+
+        if errors.empty?
+          Success.new(coerced_hash)
+        else
+          Failure.new(CoercionError.new(errors.map(&:message).join(" | ")))
+        end
+      end
+    end
+  end
+end

data/lib/typed/field.rb

@@ -12,6 +12,9 @@ module Typed
     sig { returns(T::Types::Base) }
     attr_reader :type
 
+    sig { returns(T.untyped) }
+    attr_reader :default
+
     sig { returns(T::Boolean) }
     attr_reader :required
 
@@ -22,15 +25,36 @@ module Typed
       params(
         name: Symbol,
         type: T.any(T::Class[T.anything], T::Types::Base),
-        required: T::Boolean,
+        optional: T::Boolean,
+        default: T.untyped,
         inline_serializer: T.nilable(InlineSerializer)
       ).void
     end
-    def initialize(name:, type:, required: true, inline_serializer: nil)
+    def initialize(name:, type:, optional: false, default: nil, inline_serializer: nil)
       @name = name
-      @type = T.let(T::Utils.coerce(type), T::Types::Base)
-      @required = required
+      # TODO: Guarentee type signature of the serializer will be valid
       @inline_serializer = inline_serializer
+
+      coerced_type = T::Utils.coerce(type)
+
+      if coerced_type.valid?(nil)
+        @required = T.let(false, T::Boolean)
+        @type = T.let(T.unsafe(coerced_type).unwrap_nilable, T::Types::Base)
+      else
+        @required = true
+        @type = coerced_type
+      end
+
+      if optional
+        @required = false
+      end
+
+      if !default.nil? && @type.valid?(default)
+        @default = T.let(default, T.untyped)
+        @required = false
+      elsif !default.nil? && @required
+        raise ArgumentError, "Given #{default} with class of #{default.class} for default, invalid with type #{@type}"
+      end
     end
 
     sig { params(other: Field).returns(T.nilable(T::Boolean)) }
@@ -38,6 +62,7 @@ module Typed
       name == other.name &&
         type == other.type &&
         required == other.required &&
+        default == other.default &&
         inline_serializer == other.inline_serializer
     end
 

data/lib/typed/schema.rb

@@ -13,7 +13,7 @@ module Typed
       Typed::Schema.new(
         target: struct,
         fields: struct.props.map do |name, properties|
-          Typed::Field.new(name: name, type: properties[:type], required: !properties[:fully_optional])
+          Typed::Field.new(name:, type: properties[:type_object], default: properties.fetch(:default, nil))
         end
       )
     end
@@ -34,7 +34,7 @@ module Typed
         target: target,
         fields: fields.map do |field|
           if field.name == field_name
-            Field.new(name: field.name, type: field.type, required: field.required, inline_serializer: serializer)
+            Field.new(name: field.name, type: field.type, default: field.default, inline_serializer: serializer)
           else
             field
           end

data/lib/typed/serializer.rb

@@ -33,12 +33,34 @@ module Typed
     sig { params(creation_params: Params).returns(DeserializeResult) }
     def deserialize_from_creation_params(creation_params)
       results = schema.fields.map do |field|
-        value = creation_params[field.name]
+        value = creation_params.fetch(field.name, nil)
 
-        if value.nil? || field.works_with?(value)
+        if value.nil? && !field.default.nil?
+          Success.new(Validations::ValidatedValue.new(name: field.name, value: field.default))
+        elsif value.nil? || field.works_with?(value)
           field.validate(value)
+        elsif field.type.class <= T::Types::Union
+          errors = []
+          validated_value = T.let(nil, T.nilable(Typed::Result[Typed::Validations::ValidatedValue, Typed::Validations::ValidationError]))
+
+          T.cast(field.type, T::Types::Union).types.each do |sub_type|
+            # the if clause took care of cases where value is nil so we can skip NilClass
+            next if sub_type.raw_type.equal?(NilClass)
+
+            coercion_result = Coercion.coerce(type: sub_type, value: value)
+
+            if coercion_result.success?
+              validated_value = field.validate(coercion_result.payload)
+
+              break
+            else
+              errors << Validations::ValidationError.new(coercion_result.error.message)
+            end
+          end
+
+          validated_value.nil? ? Failure.new(Validations::ValidationError.new(errors.map(&:message).join(", "))) : validated_value
         else
-          coercion_result = Coercion.coerce(type: field.type, value: value)
+          coercion_result = Coercion.coerce(type: field.type, value:)
 
           if coercion_result.success?
             field.validate(coercion_result.payload)
@@ -49,7 +71,7 @@ module Typed
       end
 
       Validations::ValidationResults
-        .new(results: results)
+        .new(results:)
         .combine
         .and_then do |validated_params|
           Success.new(schema.target.new(**validated_params))

data/lib/typed/validations/field_type_validator.rb

@@ -10,11 +10,15 @@ module Typed
       sig { override.params(field: Field, value: Value).returns(ValidationResult) }
       def validate(field:, value:)
         if field.works_with?(value)
-          Success.new(ValidatedValue.new(name: field.name, value: value))
+          Success.new(ValidatedValue.new(name: field.name, value:))
         elsif field.required? && value.nil?
           Failure.new(RequiredFieldError.new(field_name: field.name))
         elsif field.optional? && value.nil?
-          Success.new(ValidatedValue.new(name: field.name, value: value))
+          if field.default.nil?
+            Success.new(ValidatedValue.new(name: field.name, value:))
+          else
+            Success.new(ValidatedValue.new(name: field.name, value: field.default))
+          end
         else
           Failure.new(TypeMismatchError.new(field_name: field.name, field_type: field.type, given_type: value.class))
         end

data/sorbet/rbi/gems/{builder@3.2.4.rbi → builder@3.3.0.rbi}

@@ -8,7 +8,7 @@
 # If the Builder::XChar module is not currently defined, fail on any
 # name clashes in standard library classes.
 #
-# source://builder//lib/builder/blankslate.rb#17
+# source://builder//lib/builder/xmlbase.rb#4
 module Builder
   class << self
     # source://builder//lib/builder/xchar.rb#13
@@ -16,12 +16,9 @@ module Builder
   end
 end
 
-# source://builder//lib/builder/blankslate.rb#19
-Builder::BlankSlate = BasicObject
-
 # Generic error for builder
 #
-# source://builder//lib/builder/xmlbase.rb#9
+# source://builder//lib/builder/xmlbase.rb#7
 class Builder::IllegalBlockError < ::RuntimeError; end
 
 # source://builder//lib/builder/xchar.rb#33
@@ -86,7 +83,7 @@ Builder::XChar::XML_PREDEFINED = T.let(T.unsafe(nil), Regexp)
 # XmlBase is a base class for building XML builders.  See
 # Builder::XmlMarkup and Builder::XmlEvents for examples.
 #
-# source://builder//lib/builder/xmlbase.rb#13
+# source://builder//lib/builder/xmlbase.rb#11
 class Builder::XmlBase < ::BasicObject
   # Create an XML markup builder.
   #
@@ -101,7 +98,7 @@ class Builder::XmlBase < ::BasicObject
   #
   # @return [XmlBase] a new instance of XmlBase
   #
-  # source://builder//lib/builder/xmlbase.rb#29
+  # source://builder//lib/builder/xmlbase.rb#27
   def initialize(indent = T.unsafe(nil), initial = T.unsafe(nil), encoding = T.unsafe(nil)); end
 
   # Append text to the output target without escaping any markup.
@@ -118,19 +115,19 @@ class Builder::XmlBase < ::BasicObject
   # method/operation builders can use other builders as their
   # targets.
   #
-  # source://builder//lib/builder/xmlbase.rb#118
+  # source://builder//lib/builder/xmlbase.rb#116
   def <<(text); end
 
   # @return [Boolean]
   #
-  # source://builder//lib/builder/xmlbase.rb#35
+  # source://builder//lib/builder/xmlbase.rb#33
   def explicit_nil_handling?; end
 
   # Create XML markup based on the name of the method.  This method
   # is never invoked directly, but is called for each markup method
   # in the markup block that isn't cached.
   #
-  # source://builder//lib/builder/xmlbase.rb#92
+  # source://builder//lib/builder/xmlbase.rb#90
   def method_missing(sym, *args, &block); end
 
   # For some reason, nil? is sent to the XmlMarkup object.  If nil?
@@ -142,14 +139,14 @@ class Builder::XmlBase < ::BasicObject
   #
   # @return [Boolean]
   #
-  # source://builder//lib/builder/xmlbase.rb#128
+  # source://builder//lib/builder/xmlbase.rb#126
   def nil?; end
 
   # Create a tag named +sym+.  Other than the first argument which
   # is the tag name, the arguments are the same as the tags
   # implemented via <tt>method_missing</tt>.
   #
-  # source://builder//lib/builder/xmlbase.rb#42
+  # source://builder//lib/builder/xmlbase.rb#40
   def tag!(sym, *args, &block); end
 
   # Append text to the output target.  Escape any markup.  May be
@@ -157,24 +154,24 @@ class Builder::XmlBase < ::BasicObject
   #
   #   builder.p { |b| b.br; b.text! "HI" }   #=>  <p><br/>HI</p>
   #
-  # source://builder//lib/builder/xmlbase.rb#101
+  # source://builder//lib/builder/xmlbase.rb#99
   def text!(text); end
 
   private
 
-  # source://builder//lib/builder/xmlbase.rb#136
+  # source://builder//lib/builder/xmlbase.rb#134
   def _escape(text); end
 
-  # source://builder//lib/builder/xmlbase.rb#159
+  # source://builder//lib/builder/xmlbase.rb#157
   def _escape_attribute(text); end
 
-  # source://builder//lib/builder/xmlbase.rb#169
+  # source://builder//lib/builder/xmlbase.rb#167
   def _indent; end
 
-  # source://builder//lib/builder/xmlbase.rb#174
+  # source://builder//lib/builder/xmlbase.rb#172
   def _nested_structures(block); end
 
-  # source://builder//lib/builder/xmlbase.rb#164
+  # source://builder//lib/builder/xmlbase.rb#162
   def _newline; end
 
   # If XmlBase.cache_method_calls = true, we dynamicly create the method
@@ -184,20 +181,20 @@ class Builder::XmlBase < ::BasicObject
   # method_missing is very slow, this speeds up document generation
   # significantly.
   #
-  # source://builder//lib/builder/xmlbase.rb#187
+  # source://builder//lib/builder/xmlbase.rb#185
   def cache_method_call(sym); end
 
   class << self
     # Returns the value of attribute cache_method_calls.
     #
-    # source://builder//lib/builder/xmlbase.rb#16
+    # source://builder//lib/builder/xmlbase.rb#14
     def cache_method_calls; end
 
     # Sets the attribute cache_method_calls
     #
     # @param value the value to set the attribute cache_method_calls to.
     #
-    # source://builder//lib/builder/xmlbase.rb#16
+    # source://builder//lib/builder/xmlbase.rb#14
     def cache_method_calls=(_arg0); end
   end
 end
@@ -348,15 +345,15 @@ end
 #
 #   Example:
 #
-#     xm = Builder.new(:indent=>2)
+#     xm = Builder::XmlMarkup.new(:indent=>2)
 #     # xm will produce nicely formatted and indented XML.
 #
-#     xm = Builder.new(:indent=>2, :margin=>4)
+#     xm = Builder::XmlMarkup.new(:indent=>2, :margin=>4)
 #     # xm will produce nicely formatted and indented XML with 2
 #     # spaces per indent and an over all indentation level of 4.
 #
 #     builder = Builder::XmlMarkup.new(:target=>$stdout, :indent=>2)
-#     builder.name { |b| b.first("Jim"); b.last("Weirich) }
+#     builder.name { |b| b.first("Jim"); b.last("Weirich") }
 #     # prints:
 #     #     <name>
 #     #       <first>Jim</first>
@@ -385,7 +382,7 @@ end
 #
 #     xml_builder = Builder::XmlMarkup.new
 #     xml_builder.div { |xml|
-#       xml.stong("text")
+#       xml.strong("text")
 #     }
 #
 # source://builder//lib/builder/xmlmarkup.rb#161