lutaml-model 0.8.28 → 0.8.29

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b364f3d15a4c9fc529d85154e1e4789997432f557be698bfef559e3dc1139163
-  data.tar.gz: 3fe6af19792fc59b5800d0078e34171dd9b5d4c4009922e43a8eb0050ad8308c
+  metadata.gz: 9bf8f1fa19aff84c4b18067af1d357836567e7911c1217400fb1ae02afaaacff
+  data.tar.gz: 338d5c09177e3369a1910310523c2f3db651c6c157a225d1c2e46ca1cb7fac58
 SHA512:
-  metadata.gz: 7b3ebf674d7f7d306caea42542b54250dcd7ebbffc23186e2e8aa2b932d040e7dcdf4f74f41b1a9b66f089661eacd3eb8cf0676c8728b471f14e5c403175f2d4
-  data.tar.gz: e38d81dc78936d9e24d0f389134bca507c7a77d338196663ef10d1986bc3165da3ae7c88043ef0fe5c04189aace3f846034ed5a03f3463d7dfbf48267ab42fa6
+  metadata.gz: e18027c4914b6d7ad596612b46a1eb3e76b321c3f2d0fcc5677781ddff7da466f57b3923dff8059174dedb8e50be24a11e798b848c35b63ded06ab67d94718be
+  data.tar.gz: 4c828806bd1de1f35b85ced4106048d0a22b337cf970feede46b40c7d7b3ee87df1782f27ada7e76ed694877364ce982901b31c1b78245ef256169173915313f

data/lib/lutaml/key_value/transformation/value_serializer.rb

@@ -57,23 +57,24 @@ model_class: nil)
           return nil if value.nil?
           return nil if Lutaml::Model::Utils.uninitialized?(value)
 
-          # Compiled serialize plan (TODO.perf/07): builtin scalars whose
-          # type registers no custom to_<format> serializer serialize as the
-          # value itself — Type::Value#to_<format>'s default — without the
-          # wrap-allocate-cast ceremony per field. Computed once per rule.
-          if (fast = serialize_plan(rule)) && value.instance_of?(fast)
+          # Compiled serialize plan (TODO.perf/07): the rule-invariant
+          # probes — identity-fast builtin scalars, Reference, union,
+          # nested-model classification — resolve once per rule; the
+          # per-field hash lookups dominated primitive-heavy docs.
+          plan = serialize_plan(rule)
+          if (fast = plan[:identity_type]) && value.instance_of?(fast)
             return value
           end
 
           # Check for Reference type first - even if value is a Serializable,
           # it should be serialized as a key, not as a nested model
-          if reference_type?(rule)
+          if plan[:reference]
             return serialize_reference(value, rule)
           end
 
-          if Lutaml::Model::Type::Union.rule?(rule)
+          if plan[:union]
             serialize_union(value, options)
-          elsif nested_model?(rule)
+          elsif plan[:nested]
             serialize_nested_model(value, rule, options)
           else
             serialize_primitive(value, rule)
@@ -162,18 +163,45 @@ model_class: nil)
         # Per-rule serialize plan: the type class for builtin scalars with
         # no custom to_<format> serializer (identity serialization), nil
         # otherwise. Memoized per [rule].
+        # Rule-invariant resolution for Transformation#serialize_value,
+        # memoized here (Transformation freezes itself after compile;
+        # the ValueSerializer shares its model_class/register_id).
+        def serialize_value_plan(rule)
+          @serialize_value_plans ||= {}
+          @serialize_value_plans[rule] ||= begin
+            attr = model_class.attributes(register_id)&.[](rule.attribute_name)
+            attr ||= model_class.attributes&.[](rule.attribute_name)
+            {
+              attr: attr,
+              reference: attr && attr.unresolved_type == Lutaml::Model::Type::Reference,
+              nested: rule.attribute_type.is_a?(Class) &&
+                rule.attribute_type < Lutaml::Model::Serialize,
+            }
+          end
+        end
+
         def serialize_plan(rule)
           @serialize_plans ||= {}
-          @serialize_plans[rule] ||= begin
-            type = rule.attribute_type
-            if type.is_a?(::Class) && type < ::Lutaml::Model::Type::Value
-              serializer = ::Lutaml::Model::Type::Value
-                .format_type_serializer_for(@format, type)
-              has_custom_to = serializer && serializer[:to]
-              has_custom_from = ::Lutaml::Model::Attribute.custom_from_probe?(type)
-              type unless has_custom_to || has_custom_from
-            end
-          end
+          @serialize_plans[rule] ||= {
+            identity_type: identity_fast_type(rule),
+            reference: reference_type?(rule),
+            union: ::Lutaml::Model::Type::Union.rule?(rule),
+            nested: nested_model?(rule),
+          }
+        end
+
+        # Builtin scalars whose type registers no custom to_<format>
+        # serializer serialize as the value itself — Type::Value#to_<format>'s
+        # default — without the wrap-allocate-cast ceremony per field.
+        def identity_fast_type(rule)
+          type = rule.attribute_type
+          return nil unless type.is_a?(::Class) && type < ::Lutaml::Model::Type::Value
+
+          serializer = ::Lutaml::Model::Type::Value
+            .format_type_serializer_for(@format, type)
+          has_custom_to = serializer && serializer[:to]
+          has_custom_from = ::Lutaml::Model::Attribute.custom_from_probe?(type)
+          type unless has_custom_to || has_custom_from
         end
 
         private

data/lib/lutaml/key_value/transformation.rb

@@ -1069,19 +1069,20 @@ child_mappings, options)
         return nil if value.nil?
         return nil if Lutaml::Model::Utils.uninitialized?(value)
 
-        # For Reference types, use attribute's serialize method which handles reference_key extraction
-        # Check the attribute's unresolved_type to match the condition in Attribute#serialize
-        # Try to get attribute from model_class (with register first, then without)
-        attr = model_class.attributes(register_id)&.[](rule.attribute_name)
-        attr ||= model_class.attributes&.[](rule.attribute_name)
-
-        if attr && attr.unresolved_type == Lutaml::Model::Type::Reference
-          return attr.serialize(value, format, register_id, {})
+        # Rule-invariant resolution (attribute lookup, Reference probe,
+        # nested-type class) is compiled once per rule — the per-value
+        # hash lookups dominated primitive-heavy serialization.
+        # Transformation freezes itself after compile; the plan cache
+        # lives on the ValueSerializer (same model_class/register_id).
+        plan = value_serializer.serialize_value_plan(rule)
+
+        if plan[:reference]
+          return plan[:attr].serialize(value, format, register_id, {})
         end
 
         # Validate that value is an instance of the expected Serializable type
         # When attribute_type is a Serializable class, value must be an instance of that class
-        if rule.attribute_type.is_a?(Class) && rule.attribute_type < Lutaml::Model::Serialize
+        if plan[:nested]
           unless value.is_a?(rule.attribute_type)
             msg = "attribute '#{rule.attribute_name}' value is a '#{value.class}' but should be a '#{rule.attribute_type}'"
             raise Lutaml::Model::IncorrectModelError, msg

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.28"
+    VERSION = "0.8.29"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.28
+  version: 0.8.29
 platform: ruby
 authors:
 - Ribose Inc.