lutaml-model 0.8.131 → 0.8.132

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 411fee08073d8c3578b1071024486fa23ed6f1c3b93e918f7c47e175b9a95f90
-  data.tar.gz: 80e702fd74cda828374ffc7b5367311a2b49ce5ba2d5580e8038e13b6b9269ca
+  metadata.gz: 83ece4646bc4f2ecd052f6ba5edf994cb512b4be3a08e8a1778c5b357daab424
+  data.tar.gz: 9bac20d16559163de764a7148974724c199cacbce0d88d945b932c7d36ccaa19
 SHA512:
-  metadata.gz: d48928bc46206f2067989a4637ace150fcf71db4df6c18e1df93de5c621c088db0490bf85d860ec6861ad08d208218553a5d2ae7806ea4b5e88067b0032d51ed
-  data.tar.gz: 8d0127e8139146f8d1df26a488904d7e48202e4c5b75a49f67a895f87d372507f9217253590496c44513677653bd8516f009d59f7889a41832c2e12333987585
+  metadata.gz: 27120683de1ff8d9c95049e683dffdf302aa43edf9a4e5e6debda189df3903fdf98f4722200eb4106285e86dfabb170b77fcaea3313c6e1a8e8e548ec2db0eab
+  data.tar.gz: 26a84cc1b288f7b829c1bdb44360adc7211843e506d1d51c1f416c411636fa6099dee79fd26d4d41a7e22b5eaf3ef1510d9580dbe49318ac8c2b9e02b80974bc

data/lib/lutaml/key_value/transform.rb

@@ -346,15 +346,21 @@ child_mappings)
       # path. Returns nil (caller falls back) on any shape the plan
       # does not cover, e.g. a non-Hash item where a model was expected.
       def kv_group_build(rows, doc, format, register, options)
-        setters = []
+        # Positional values, not per-row [name, value] pairs: rows are a
+        # fixed per-class list, so the writer to apply lives at the row's
+        # index and the pair arrays were the lane's biggest allocation
+        # (~6 arrays per node on hydrate-heavy corpora).
+        values = Array.new(rows.size, MISSING)
         children = []
         # Lazy: the present-key hot path never pushes, and this runs
         # once per hydrated model instance.
         absent = nil
         unmapped = nil
+        i = 0
         rows.each do |rule, attr, kind, type, child_rows, child_register|
           if kind == :unmapped
             unmapped = [type, child_rows]
+            i += 1
             next
           end
 
@@ -364,6 +370,7 @@ child_mappings)
           v = Lutaml::Model::Utils.fetch_str_or_sym(doc, rule.name, MISSING)
           if v.equal?(MISSING)
             (absent ||= []) << rule
+            i += 1
             next
           end
 
@@ -389,13 +396,15 @@ child_mappings)
               built << self.class.data_to_model(type.attr_type,
 child_hash, format, { mappings: type.child_rules })
             end
-            setters << [rule.kv_setter, built]
+            values[i] = built
             children.concat(built)
+            i += 1
             next
           end
 
           if kind == :scalar
-            setters << [rule.kv_setter, v]
+            values[i] = v
+            i += 1
             next
           end
 
@@ -417,7 +426,7 @@ child_hash, format, { mappings: type.child_rules })
 
               built << child
             end
-            setters << [rule.kv_setter, built]
+            values[i] = built
             children.concat(built)
           else
             return nil unless v.is_a?(::Hash)
@@ -427,12 +436,20 @@ child_hash, format, { mappings: type.child_rules })
                                                  options)
             return nil if child.nil?
 
-            setters << [rule.kv_setter, child]
+            values[i] = child
             children << child
           end
+          i += 1
         end
         instance = model_class.allocate_for_walk(register)
-        setters.each { |name, value| instance.public_send(name, value) }
+        i = 0
+        rows.each do |rule, _attr, kind, *_rest|
+          v = values[i]
+          i += 1
+          next if v.equal?(MISSING) || kind == :unmapped
+
+          instance.public_send(rule.kv_setter, v)
+        end
         absent&.each do |rule|
           process_mapping_rule(doc, instance, format, rule, options, nil)
         end

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

@@ -43,6 +43,9 @@ model_class: nil)
           @register_id = register_id
           @transformation_factory = transformation_factory
           @model_class = model_class
+          # Pre-declared: the serializer may be frozen after setup, and
+          # the type-transformation memo mutates this hash in place.
+          @lutaml_type_transformations = {}
         end
 
         # Serialize a value for an item (handles nested models and primitives).
@@ -117,10 +120,10 @@ model_class: nil)
 
           # Get or create child transformation
           child_transformation = if uses_polymorphism
-                                   create_transformation(actual_type)
+                                   transformation_for_type(actual_type)
                                  else
                                    rule.child_transformation ||
-                                     create_transformation(rule.attribute_type)
+                                     transformation_for_type(rule.attribute_type)
                                  end
 
           if child_transformation
@@ -296,6 +299,15 @@ model_class: nil)
           transformation_factory.call(type_class)
         end
 
+        # Memoized on this object: the factory binds this object's
+        # mapping/format/register, so the memo is register-safe, and
+        # building one per serialized node is a Transformation per
+        # nested model per instance.
+        def transformation_for_type(type_class)
+          (@lutaml_type_transformations ||= {})[type_class] ||=
+            create_transformation(type_class)
+        end
+
         # Transform a nested model using the child transformation.
         #
         # @param value [Object] The model instance

data/lib/lutaml/key_value/transformation.rb

@@ -63,6 +63,9 @@ module Lutaml
 
         # Set up serializers before calling super
         # The super will call compile_rules and freeze
+        # Pre-declared: the transformation is frozen after compile, and
+        # the type-transformation memo mutates this hash in place.
+        @lutaml_type_transformations = {}
         @rule_compiler = RuleCompiler.new(
           model_class: model_class,
           register_id: register_id,
@@ -1034,6 +1037,15 @@ child_mappings, options)
       # @param value [Object] The value
       # @param options [Hash] Options
       # @return [Object] The value (could be Hash, primitive, or KeyValueElement)
+      # Child transformations memoized on this transformation instance:
+      # the factory binds this instance's mapping/format/register, so
+      # the memo is register-safe, and building one per serialized node
+      # is a Transformation per nested model per instance.
+      def transformation_for_type(type_class)
+        (@lutaml_type_transformations ||= {})[type_class] ||=
+          build_child_transformation(type_class)
+      end
+
       def create_value_for_item(rule, value, options)
         return nil if value.nil?
 
@@ -1098,9 +1110,7 @@ child_mappings, options)
           if !child_transformation || uses_polymorphism
             # For polymorphic types, use the actual runtime type's mappings
             type_for_mapping = uses_polymorphism ? actual_type : rule.attribute_type
-            mapping = type_for_mapping.mappings_for(format, register_id)
-            child_transformation = self.class.new(type_for_mapping, mapping,
-                                                  format, register)
+            child_transformation = transformation_for_type(type_for_mapping)
           end
 
           if child_transformation

data/lib/lutaml/model/transform.rb

@@ -3,12 +3,81 @@
 module Lutaml
   module Model
     class Transform
-      @transform_cache = {}
-
       # Maximum number of cached Transform instances before eviction.
       # Covers most OOXML/ISO schemas with ~1000+ classes and multiple registers.
       MAX_CACHE_SIZE = 2048
 
+      # The (lane, context, register) memo lives in a shared constant,
+      # not in class-level ivars: KeyValue::Transform subclasses this
+      # class, and inherited class methods run with the subclass as
+      # self — ivar state forked per subclass, and clear_cache! on the
+      # base class never reached the subclass's copy (stale compiled
+      # plans across register resets). The lane is part of the key:
+      # each transform class compiles format-specific rules, so a KV
+      # transform and the base one must never answer for each other.
+      class TransformCache
+        attr_reader :size
+
+        def initialize
+          @entries = {}
+          @size = 0
+        end
+
+        # Nested memo, not an array key: the hot path is one lookup per
+        # parsed node and the key array was that lookup's only
+        # allocation (60k arrays on a 6k-node corpus).
+        def fetch_or_store(lane, context, register)
+          by_context = @entries[lane]
+          by_register = by_context&.[](context)
+          return by_register[register] if by_register&.key?(register)
+
+          by_register = ((@entries[lane] ||= {})[context] ||= {})
+          transform = yield
+          by_register[register] = transform
+          @size += 1
+          transform
+        end
+
+        def evict_half_if_full
+          return unless @size >= MAX_CACHE_SIZE
+
+          drop = @size / 2
+          @entries.each do |lane, by_context|
+            by_context.each do |ctx, by_register|
+              break if drop <= 0
+
+              drop -= by_register.size
+              by_context.delete(ctx)
+            end
+            @entries.delete(lane) if by_context.empty?
+            break if drop <= 0
+          end
+          @size = @entries.sum { |_, by_context| by_context.sum { |_, br| br.size } }
+        end
+
+        def invalidate(context, register = nil)
+          @entries.each_value do |by_context|
+            if register
+              by_register = by_context[context]
+              next unless by_register&.delete(register)
+
+              @size -= 1
+              by_context.delete(context) if by_register.empty?
+            else
+              removed = by_context.delete(context)
+              @size -= removed.size if removed
+            end
+          end
+        end
+
+        def clear
+          @entries.clear
+          @size = 0
+        end
+      end
+
+      TRANSFORM_CACHE = TransformCache.new
+
       def self.data_to_model(context, data, format, options = {})
         register = options[:register] || Lutaml::Model::Config.default_register
         transform = cached_transform(context, register, options[:mappings])
@@ -28,13 +97,10 @@ module Lutaml
       def self.cached_transform(context, register, mappings = nil)
         return override_transform(context, register, mappings) if mappings
 
-        @transform_cache ||= {}
-        cache_key = [context, register]
-        entry = @transform_cache[cache_key]
-        return entry if entry
-
-        evict_if_needed if @transform_cache.size >= MAX_CACHE_SIZE
-        @transform_cache[cache_key] = new(context, register)
+        TRANSFORM_CACHE.evict_half_if_full
+        TRANSFORM_CACHE.fetch_or_store(self, context, register) do
+          new(context, register)
+        end
       end
 
       def self.override_transform(context, register, mappings)
@@ -54,30 +120,17 @@ module Lutaml
       private_class_method :evict_override_if_needed
 
       def self.clear_cache!
-        @transform_cache&.clear
+        TRANSFORM_CACHE.clear
         @override_transform_cache&.clear
       end
 
       def self.cache_size
-        @transform_cache&.size || 0
+        TRANSFORM_CACHE.size
       end
 
       def self.invalidate_for(context, register = nil)
-        return unless @transform_cache
-
-        if register
-          @transform_cache.delete([context, register])
-        else
-          @transform_cache.reject! { |(ctx, _reg)| ctx == context }
-        end
-      end
-
-      def self.evict_if_needed
-        # Evict oldest half of entries when cache is full
-        keys_to_remove = @transform_cache.keys.first(@transform_cache.size / 2)
-        keys_to_remove.each { |k| @transform_cache.delete(k) }
+        TRANSFORM_CACHE.invalidate(context, register)
       end
-      private_class_method :evict_if_needed
 
       attr_reader :context, :lutaml_register
 

data/lib/lutaml/model/type_context.rb

@@ -38,6 +38,8 @@ module Lutaml
     #   # Has :custom, falls back to default for built-in types
     #
     class TypeContext
+      EMPTY_SUBSTITUTIONS = [].freeze
+
       # @return [Symbol] The context identifier
       attr_reader :id
 
@@ -204,6 +206,13 @@ module Lutaml
       # @param from_type [Class, Symbol, String] The type to find substitutions for
       # @return [Array<TypeSubstitution>] Matching substitutions
       def substitution_for(from_type)
+        # The no-substitution context is the common case, and this
+        # lookup runs per nested model per serialized instance — the
+        # select's result array was the allocation (#KV-to profile
+        # 2026-10-26). The frozen shared array answers readers only;
+        # every consumer here selects/any?/eaches it.
+        return EMPTY_SUBSTITUTIONS if substitutions.empty?
+
         from_type_class = from_type.is_a?(Class) ? from_type : nil
 
         substitutions.select do |sub|

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.131"
+    VERSION = "0.8.132"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.131
+  version: 0.8.132
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-25 00:00:00.000000000 Z
+date: 2026-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64