lutaml-model 0.8.28 → 0.8.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b364f3d15a4c9fc529d85154e1e4789997432f557be698bfef559e3dc1139163
-  data.tar.gz: 3fe6af19792fc59b5800d0078e34171dd9b5d4c4009922e43a8eb0050ad8308c
+  metadata.gz: b34b7ff545ae437b23517945172d87ca4a954c0c4fad64c15fce8e9f3f14e02c
+  data.tar.gz: 8db18d5b33eef8ea93d920ee49db17511095c697bbddda129ff6ab6506970ac7
 SHA512:
-  metadata.gz: 7b3ebf674d7f7d306caea42542b54250dcd7ebbffc23186e2e8aa2b932d040e7dcdf4f74f41b1a9b66f089661eacd3eb8cf0676c8728b471f14e5c403175f2d4
-  data.tar.gz: e38d81dc78936d9e24d0f389134bca507c7a77d338196663ef10d1986bc3165da3ae7c88043ef0fe5c04189aace3f846034ed5a03f3463d7dfbf48267ab42fa6
+  metadata.gz: 7134619f7177e46dfd8558489092814d1b84fdae0e0a8bd2a33c95afbf9fba721d81928a30a4911b8833baccfead7a70bd9bd2a0633c00e4cdcf45b50178a86e
+  data.tar.gz: fa4f5701225229b3d2f1b1e8a18d00797bf96fad94b99ff2875bf177f5fcfbeee418099a5fd0686245c1dffda6cd57d2f716411b315f5e87731e77f8e7700b51

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.30"
   end
 end

data/lutaml-model.gemspec

@@ -40,7 +40,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
   spec.add_dependency "moxml", "~> 0.5.56"
   spec.add_dependency "ostruct"
-  spec.add_dependency "rubyzip", "~> 2.3"
+  spec.add_dependency "rubyzip", "~> 3.4"
   spec.add_dependency "thor"
 
   spec.metadata["rubygems_mfa_required"] = "true"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.28
+  version: 0.8.30
 platform: ruby
 authors:
 - Ribose Inc.
@@ -120,14 +120,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '3.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '3.4'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement