lib/avromatic/model/raw_serialization.rb in avromatic-0.28.1 vs lib/avromatic/model/raw_serialization.rb in avromatic-0.29.0

@@ -20,31 +20,31 @@
         included do
           @attribute_member_types = {}
         end
 
         module ClassMethods
-          def recursive_serialize(value, name: nil, member_types: nil)
+          def recursive_serialize(value, name: nil, member_types: nil, strict: false)
             member_types = attribute_member_types(name) if name
             member_types ||= EMPTY_ARRAY
 
             if value.is_a?(Avromatic::Model::Attributes)
-              hash = value.value_attributes_for_avro
-              if Avromatic.use_custom_datum_writer
+              hash = strict ? value.avro_value_datum : value.value_attributes_for_avro
+              if !strict && Avromatic.use_custom_datum_writer
                 if Avromatic.use_encoding_providers? && !value.class.config.mutable
                   # n.b. Ideally we'd just return value here instead of wrapping it in a
                   # hash but then we'd have no place to stash the union member index...
                   hash = { Avromatic::IO::ENCODING_PROVIDER => value }
                 end
                 member_index = member_types.index(value.class) if member_types.any?
                 hash[Avromatic::IO::UNION_MEMBER_INDEX] = member_index if member_index
               end
               hash
             elsif value.is_a?(Array)
-              value.map { |v| recursive_serialize(v, member_types: member_types) }
+              value.map { |v| recursive_serialize(v, member_types: member_types, strict: strict) }
             elsif value.is_a?(Hash)
               value.each_with_object({}) do |(k, v), map|
-                map[k] = recursive_serialize(v, member_types: member_types)
+                map[k] = recursive_serialize(v, member_types: member_types, strict: strict)
               end
             else
               avro_serializer[name].call(value)
             end
           end
@@ -94,14 +94,26 @@
 
         def key_attributes_for_avro
           avro_hash(key_avro_field_names)
         end
 
+        def avro_value_datum
+          if self.class.config.mutable
+            avro_hash(value_avro_field_names, strict: true)
+          else
+            @avro_datum ||= avro_hash(value_avro_field_names, strict: true)
+          end
+        end
+
+        def avro_key_datum
+          avro_hash(key_avro_field_names, strict: true)
+        end
+
         private
 
-        def avro_hash(fields)
+        def avro_hash(fields, strict: false)
           attributes.slice(*fields).each_with_object(Hash.new) do |(key, value), result|
-            result[key.to_s] = self.class.recursive_serialize(value, name: key)
+            result[key.to_s] = self.class.recursive_serialize(value, name: key, strict: strict)
           end
         end
 
         def avro_raw_encode(data, key_or_value = :value)
           stream = StringIO.new