dynamicschema 2.0.0 → 2.2.0

data/lib/dynamic_schema/struct.rb

@@ -40,44 +40,69 @@ module DynamicSchema
             end
 
             __compiled_schema.each do | property, criteria |
-              
+
               key = ( criteria[ :as ] || property ).to_sym
               type = criteria[ :type ]
               default = criteria[ :default ]
+              has_multiple_types = type.is_a?( ::Array ) && criteria[ :compiler ]
 
-              if type == ::Object
+              if has_multiple_types
+                _criteria = criteria
+                define_method( property ) do
+                  @converted_attributes.fetch( key ) do
+                    value = @attributes[ key ]
+                    value = default if value.nil?
+                    schema = _criteria[ :schema ] ||= ( _criteria[ :compiler ]&.compiled )
+                    klass = _criteria[ :class ] ||= ( schema ? ::DynamicSchema::Struct.new( schema ) : nil )
+                    @converted_attributes[ key ] =
+                      if _criteria[ :array ]
+                        __convert_types_array( Array( value ), klass, _criteria )
+                      else
+                        __normalize( __convert_types( value, klass, _criteria ), _criteria )
+                      end
+                  end
+                end
+              elsif type == ::Object
+                _criteria = criteria
                 define_method( property ) do
                   @converted_attributes.fetch( key ) do
                     value = @attributes[ key ]
-                    schema = criteria[ :schema ] ||= ( criteria[ :compiler ]&.compiled )
+                    schema = _criteria[ :schema ] ||= ( _criteria[ :compiler ]&.compiled )
                     return value unless schema
-                    klass = criteria[ :class ] ||= ::DynamicSchema::Struct.new( schema )
-                    @converted_attributes[ key ] = 
-                      if criteria[ :array ]
-                        Array( value || default ).map { | v | klass.build( v || {} ) }
+                    klass = _criteria[ :class ] ||= ::DynamicSchema::Struct.new( schema )
+                    @converted_attributes[ key ] =
+                      if _criteria[ :array ]
+                        Array( value || default ).map { | v | __normalize( klass.build( v || {} ), _criteria ) }
                       else
-                        klass.build( value || default )
+                        __normalize( klass.build( value || default ), _criteria )
                       end
                   end
                 end
               elsif type
-                define_method( property ) do 
-                  @converted_attributes.fetch( key ) do 
-                    value = @attributes[ key ] 
-                    @converted_attributes[ key ] = criteria[ :array ] ? 
-                      Array( value || default ).map { | v | __convert( v, to: type ) } : 
-                      __convert( value || default, to: type )
+                _criteria = criteria
+                define_method( property ) do
+                  @converted_attributes.fetch( key ) do
+                    value = @attributes[ key ]
+                    @converted_attributes[ key ] = _criteria[ :array ] ?
+                      Array( value || default ).map { | v | __normalize( __coerce( v, to: type ), _criteria ) } :
+                      __normalize( __coerce( value || default, to: type ), _criteria )
                   end
                 end
               else
+                _criteria = criteria
                 define_method( property ) do
-                  @attributes[ key ] || default
-                end 
+                  value = @attributes[ key ] || default
+                  if _criteria[ :array ]
+                    Array( value ).map { | v | __normalize( v, _criteria ) }
+                  else
+                    __normalize( value, _criteria )
+                  end
+                end
               end
 
-              define_method( :"#{ property }=" ) do | value | 
+              define_method( :"#{ property }=" ) do | value |
                 @converted_attributes.delete( key )
-                @attributes[ key ] = value 
+                @attributes[ key ] = value
               end
 
             end
@@ -96,7 +121,7 @@ module DynamicSchema
               result
             end
 
-          private 
+          private
 
             def compiled_schema
               self.class.compiled_schema
@@ -119,10 +144,36 @@ module DynamicSchema
               end
             end
 
-            def __convert( value, to: )
+            def __coerce( value, to: )
               self.class.converter.convert( value, to: to ) { | v | to.new( v ) rescue nil }
             end
 
+            def __convert_types( value, klass, criteria )
+              return nil if value.nil?
+              if value.is_a?( ::Hash )
+                klass ? klass.build( value ) : value
+              else
+                scalar_types = __non_object_types( criteria[ :type ] )
+                __coerce( value, to: scalar_types )
+              end
+            end
+
+            def __convert_types_array( values, klass, criteria )
+              values.map { | v | __normalize( __convert_types( v, klass, criteria ), criteria ) }
+            end
+
+            def __non_object_types( types )
+              types_array = types.is_a?( ::Array ) ? types : [ types ]
+              result = types_array.reject { | type | type == ::Object }
+              result.length == 1 ? result.first : result
+            end
+
+            def __normalize( value, criteria )
+              normalize = criteria[ :normalize ]
+              return value unless normalize && !value.nil?
+              normalize.call( value )
+            end
+
           end
           __klass.instance_variable_set( :@__compiled_schema, __compiled_schema.dup )
           __klass.instance_variable_set( :@__converter, __converter )

data/lib/dynamic_schema/validator.rb

@@ -40,6 +40,33 @@ module DynamicSchema
       type_match
     end
 
+    def __validate_types( value, criteria, path, key, &block )
+      if value.is_a?( ::Hash )
+        traverse_and_validate_values(
+          value,
+          schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
+          path: "#{ ( path || '' ) + ( path ? '/' : '' ) + key.to_s }",
+          &block
+        )
+      else
+        scalar_types = __non_object_types( criteria[ :type ] )
+        unless value_matches_types?( value, scalar_types )
+          block.call( IncompatibleTypeError.new( path: path, key: key, type: criteria[ :type ], value: value ) )
+        end
+      end
+    end
+
+    def __validate_types_array( values, criteria, path, key, &block )
+      values.each do | value |
+        __validate_types( value, criteria, path, key, &block )
+      end
+    end
+
+    def __non_object_types( types )
+      types_array = types.is_a?( ::Array ) ? types : [ types ]
+      types_array.reject { | type | type == ::Object }
+    end
+
     def traverse_and_validate_values( values, schema:, path: nil, options: nil, &block )
       path.chomp( '/' ) if path
       unless values.respond_to?( :[] )
@@ -59,8 +86,13 @@ module DynamicSchema
             end
           end
         elsif !criteria[ :default_assigned ] && !value.nil?
+          type = criteria[ :type ]
+          has_multiple_types = type.is_a?( ::Array ) && criteria[ :compiler ]
+
           unless criteria[ :array ]
-            if criteria[ :type ] == Object
+            if has_multiple_types
+              __validate_types( value, criteria, path, key, &block )
+            elsif type == Object
               traverse_and_validate_values(
                 values[ name ],
                 schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
@@ -68,14 +100,16 @@ module DynamicSchema
                 &block
               )
             else
-              if criteria[ :type ] && value && !criteria[ :default_assigned ]
-                unless value_matches_types?( value, criteria[ :type ] )
-                  block.call( IncompatibleTypeError.new( path: path, key: key, type: criteria[ :type ], value: value ) )
+              if type && value && !criteria[ :default_assigned ]
+                unless value_matches_types?( value, type )
+                  block.call( IncompatibleTypeError.new( path: path, key: key, type: type, value: value ) )
                 end
               end
             end
           else
-            if criteria[ :type ] == Object
+            if has_multiple_types
+              __validate_types_array( Array( value ), criteria, path, key, &block )
+            elsif type == Object
               groups = Array( value )
               groups.each do | group |
                 traverse_and_validate_values(

metadata

@@ -1,29 +1,28 @@
 --- !ruby/object:Gem::Specification
 name: dynamicschema
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Kristoph Cichocki-Romanov
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.13'
+        version: '6.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.13'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -76,7 +75,6 @@ licenses:
 metadata:
   source_code_uri: https://github.com/EndlessInternational/dynamic_schema
   bug_tracker_uri: https://github.com/EndlessInternational/dynamic_schema/issues
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -91,8 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: DynamicSchema is a lightweight and simple yet powerful gem that enables flexible
   semantic   schema definitions for constructing and validating complex configurations