dynamicschema 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1142cd4153d7801dc9b6d5e363001891130cdf06b47f7b33b7d2c93e7285400f
-  data.tar.gz: 3c5d76c15ff02f845bc35c633d52bc04daa6dae9fc5b0a14b338658cdaaa8212
+  metadata.gz: 02ef93530db92a0a71dbd58cb6fef978b72d11d6d92704d4ca9714bc2a329beb
+  data.tar.gz: 0a846b974a9c41dfe5dd3caf1034f81a75974bbf9eb1b00b743f5f16bfb1fd06
 SHA512:
-  metadata.gz: 220295ed04510fde286848d17a9723ac3b30d9cb4cd7daa312c25e81bb6f647b1121ceacd83348e179cd3c7e7cc57d850a5505906f3584d65355610c85988845
-  data.tar.gz: 32c4c1f21b34c469ed0103d96e4da57b7861182ed6f0fa2b6f65b7bf64f73ff087b49a2a041cbbc0d7e4427d7d2571069840a529d6684ac16b46a8e84754e703
+  metadata.gz: f6ef7406250f00130c77dcf5bd1c025d7185616d96a6d96193979c2c2ad57098bb3b80952225759b8d07baf537d2cd3c0746ea4b23d504e12937fcf19d7353bd
+  data.tar.gz: 943d6dd203630808c5838f484b4c77fa6b0511b2d23dd24e076ddb8aa22c9fbea74d05fb291b7c915b3c176db99f7eff9afb19a27e5b65c90d823744328b7237

data/README.md

@@ -55,6 +55,7 @@ You can find a full OpenAI request example in the `/examples` folder of this rep
   - [as Option](#as-option)
   - [in Option (Values Only)](#in-option)
   - [arguments Option](#arguments-option)
+  - [normalize Option](#normalize-option)
 - [Class Schema](#class-schemas)
   - [Definable](#definable)
   - [Buildable](#buildable)
@@ -718,6 +719,91 @@ result = schema.build! do
 end
 ```
 
+### :normalize Option
+
+The `:normalize` option allows you to transform values immediately upon assignment. It accepts a lambda or Proc that receives the value and returns the transformed result. When used with arrays, the normalizer is called for each individual item, not the array itself.
+
+#### example:
+
+```ruby
+schema = DynamicSchema.define do
+  name String, normalize: ->( v ) { v.strip.downcase }
+  tags String, array: true, normalize: ->( v ) { v.upcase }
+  score Integer, normalize: ->( v ) { v.clamp( 0, 100 ) }
+end
+
+result = schema.build! do
+  name '  Alice  '
+  tags [ 'important', 'urgent' ]
+  score 150
+end
+
+puts result[:name]   # => "alice"
+puts result[:tags]   # => ["IMPORTANT", "URGENT"]
+puts result[:score]  # => 100
+```
+
+The normalizer is applied after type coercion, so you receive the properly typed value:
+
+```ruby
+schema = DynamicSchema.define do
+  count Integer, normalize: ->( v ) { v * 2 }
+end
+
+result = schema.build! do
+  count '5'  # coerced to Integer first, then normalized
+end
+
+puts result[:count]  # => 10
+```
+
+You can also use normalize with objects to transform the entire nested structure:
+
+```ruby
+CustomUser = Struct.new( :name, :email )
+
+schema = DynamicSchema.define do
+  user normalize: ->( v ) { CustomUser.new( v.to_h[:name], v.to_h[:email] ) } do
+    name String
+    email String
+  end
+end
+
+result = schema.build! do
+  user do
+    name 'Alice'
+    email 'alice@example.com'
+  end
+end
+
+result[:user].class  # => CustomUser
+result[:user].name   # => "Alice"
+```
+
+The normalize option works with Struct as well:
+
+```ruby
+Person = DynamicSchema::Struct.define do
+  name String, normalize: ->( v ) { v.strip.capitalize }
+  tags String, array: true, normalize: ->( v ) { v.downcase }
+end
+
+person = Person.build( name: '  alice  ', tags: [ 'ADMIN', 'USER' ] )
+person.name  # => "Alice"
+person.tags  # => ["admin", "user"]
+```
+
+Note that any exceptions raised within a normalize lambda are not captured and will propagate to the caller:
+
+```ruby
+schema = DynamicSchema.define do
+  value Integer, normalize: ->( v ) { raise "invalid value" if v < 0; v }
+end
+
+# This will raise RuntimeError: "invalid value"
+schema.build! { value -1 }
+```
+
 ## Class Schemas
 
 DynamicSchema provides a number of modules you can include into your own classes to simplify their definition and construction.

data/dynamicschema.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do | spec |
 
   spec.name           = 'dynamicschema'
-  spec.version        = '2.1.0'
+  spec.version        = '2.2.0'
   spec.authors        = [ 'Kristoph Cichocki-Romanov' ]
   spec.email          = [ 'rubygems.org@kristoph.net' ]
 

data/lib/dynamic_schema/receiver/object.rb

@@ -167,43 +167,45 @@ module DynamicSchema
         value = arguments.first
         new_value = criteria[ :type ] ? __coerce_value( criteria[ :type ], value ) : value
         new_value = new_value.nil? ? value : new_value
-        block ? 
-          __value_block( method, value: new_value, criteria: criteria, &block ) : 
+        new_value = block ?
+          __value_block( method, value: new_value, criteria: criteria, &block ) :
           new_value
+        __normalize( new_value, criteria )
       end
 
       def __values_array( method, arguments, value:, criteria:, &block )
         values = [ arguments.first ].flatten
         if type = criteria[ :type ]
-          values = values.map do | v | 
+          values = values.map do | v |
             new_value = __coerce_value( type, v )
             new_value.nil? ? v : new_value
-          end 
+          end
         end
-        if block 
-          values = values.map do | value | 
+        if block
+          values = values.map do | value |
             __value_block( method, value: value, criteria: criteria, &block )
           end
         end
+        values = values.map { | v | __normalize( v, criteria ) }
         value.concat( values )
       end 
 
       def __object( method, arguments, value:, criteria:, &block )
-        attributes = __process_arguments( 
-          method, arguments, 
-          required_arguments: criteria[ :arguments ] 
+        attributes = __process_arguments(
+          method, arguments,
+          required_arguments: criteria[ :arguments ]
         )
-        if value.nil? || attributes&.any?  
-          value = 
-            Receiver::Object.new( 
+        if value.nil? || attributes&.any?
+          value =
+            Receiver::Object.new(
               attributes,
-              converter: @converter, 
+              converter: @converter,
               schema: criteria[ :schema ] ||= criteria[ :compiler ].compiled,
               defaults: @defaults
             )
         end
         value.instance_eval( &block ) if block
-        value 
+        __normalize( value, criteria )
       end
 
       def __object_array( method, arguments, value:, criteria:, &block )
@@ -219,7 +221,7 @@ module DynamicSchema
             defaults: @defaults
           )
           receiver.instance_eval( &block ) if block
-          receiver
+          __normalize( receiver, criteria )
         } )
       end
 
@@ -296,6 +298,12 @@ module DynamicSchema
         value
       end
 
+      def __normalize( value, criteria )
+        normalize = criteria[ :normalize ]
+        return value unless normalize && !value.nil?
+        normalize.call( value )
+      end
+
     end
   end
 end    

data/lib/dynamic_schema/struct.rb

@@ -47,47 +47,56 @@ module DynamicSchema
               has_multiple_types = type.is_a?( ::Array ) && criteria[ :compiler ]
 
               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 )
+                    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 )
+                      if _criteria[ :array ]
+                        __convert_types_array( Array( value ), klass, _criteria )
                       else
-                        __convert_types( value, klass, criteria )
+                        __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 )
+                    klass = _criteria[ :class ] ||= ::DynamicSchema::Struct.new( schema )
                     @converted_attributes[ key ] =
-                      if criteria[ :array ]
-                        Array( value || default ).map { | v | klass.build( v || {} ) }
+                      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
+                _criteria = criteria
                 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 )
+                    @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
+                  value = @attributes[ key ] || default
+                  if _criteria[ :array ]
+                    Array( value ).map { | v | __normalize( v, _criteria ) }
+                  else
+                    __normalize( value, _criteria )
+                  end
                 end
               end
 
@@ -135,7 +144,7 @@ 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
 
@@ -145,12 +154,12 @@ module DynamicSchema
                 klass ? klass.build( value ) : value
               else
                 scalar_types = __non_object_types( criteria[ :type ] )
-                __convert( value, to: scalar_types )
+                __coerce( value, to: scalar_types )
               end
             end
 
             def __convert_types_array( values, klass, criteria )
-              values.map { | v | __convert_types( v, klass, criteria ) }
+              values.map { | v | __normalize( __convert_types( v, klass, criteria ), criteria ) }
             end
 
             def __non_object_types( types )
@@ -159,6 +168,12 @@ module DynamicSchema
               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 )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dynamicschema
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Kristoph Cichocki-Romanov