lutaml-model 0.8.131 → 0.8.133

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 411fee08073d8c3578b1071024486fa23ed6f1c3b93e918f7c47e175b9a95f90
-  data.tar.gz: 80e702fd74cda828374ffc7b5367311a2b49ce5ba2d5580e8038e13b6b9269ca
+  metadata.gz: 7ea94bb734406bacfb047edb9c580a3f224f19c497b4f506440da60d381cd1bf
+  data.tar.gz: 96f7c71f51a0ec8b863eec77b894ec611ff3a4e8b59354ec9b477e6470258852
 SHA512:
-  metadata.gz: d48928bc46206f2067989a4637ace150fcf71db4df6c18e1df93de5c621c088db0490bf85d860ec6861ad08d208218553a5d2ae7806ea4b5e88067b0032d51ed
-  data.tar.gz: 8d0127e8139146f8d1df26a488904d7e48202e4c5b75a49f67a895f87d372507f9217253590496c44513677653bd8516f009d59f7889a41832c2e12333987585
+  metadata.gz: 4e61d4a02ebb21a794de64a0301a3489b045b8562ce8e1a8f3522b227bea1632882e7e09d1ce6fe18352d41c8fe62d2a5d9652b315dda76a220cbd30fe15f3cf
+  data.tar.gz: 60c206b080775425586980a1f3b484db2280be9e9b73bc365237210f64c90fc3faa80f1f9e9a42e94259a9a83ba1edab1ceecc25bb804147ecd3e31ead97c15d

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/hash.rb

@@ -18,22 +18,37 @@ module Lutaml
         end
 
         def self.normalize_hash(hash)
-          return hash["text"] if hash.keys == ["text"]
+          xml = hash.is_a?(Lutaml::Model::MappingHash)
+          return hash["text"] if text_node?(hash)
 
-          hash = hash.to_h if hash.is_a?(Lutaml::Model::MappingHash)
+          hash = hash.to_h if xml
 
-          normalized_hash = hash.transform_values do |value|
+          normalized = hash.transform_values do |value|
             normalize_value(value)
           end
+          xml ? (normalized["elements"] || normalized) : normalized
+        end
 
-          normalized_hash["elements"] || normalized_hash
+        # {"text" => string} is the XML text-node convention and
+        # collapses to the string. Any other "text" key — structured
+        # values, or appearing alongside other keys in non-XML data —
+        # is ordinary data and must round-trip verbatim
+        # (lutaml/lutaml-model#1013).
+        def self.text_node?(hash)
+          # ::String — unqualified String resolves to Type::String here
+          hash.is_a?(::Hash) && hash.keys == ["text"] &&
+            hash["text"].is_a?(::String)
         end
 
         def self.normalize_value(value)
           return value unless value.is_a?(::Hash)
 
           nested = normalize_hash(value)
-          nested.is_a?(::Hash) ? nested.except("text") : nested
+          if value.is_a?(Lutaml::Model::MappingHash) && nested.is_a?(::Hash)
+            nested.except("text")
+          else
+            nested
+          end
         end
 
         def self.serialize(value)

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

data/lib/lutaml/xml/serialization/instance_methods.rb

@@ -178,8 +178,13 @@ module Lutaml
                     elsif val.is_a?(Lutaml::Model::Serializable)
                       collection_indices[attr_name] += 1
                       collection_indices[attr_name] == 1 ? val : nil
+                    else
+                      # Scalar mapped elements (e.g. a string-valued
+                      # <main>) are part of the mixed content too.
+                      collection_indices[attr_name] += 1
+                      val
                     end
-              yield(obj) if obj
+              yield(obj) unless obj.nil? || (obj.is_a?(String) && obj.empty?)
             end
           end
 

data/spec/lutaml/model/mixed_content_spec.rb

@@ -1449,4 +1449,36 @@ RSpec.describe "MixedContent" do
                       described_class
     end
   end
+
+  describe "each_mixed_content with string-valued mapped elements" do
+    it "yields scalar mapped elements, not only Arrays and Serializable children" do
+      xml = "<title-wrap><main>Test Document</main></title-wrap>"
+      model = MixedContentSpec::TitleWrap.from_xml(xml)
+
+      expect(model.main).to eq("Test Document")
+
+      yielded = model.each_mixed_content.to_a
+      expect(yielded).to include("Test Document")
+    end
+
+    it "skips empty scalar values" do
+      xml = "<title-wrap><main></main></title-wrap>"
+      model = MixedContentSpec::TitleWrap.from_xml(xml)
+
+      yielded = model.each_mixed_content.to_a
+      expect(yielded).not_to include("")
+    end
+  end
+end
+
+module MixedContentSpec
+  class TitleWrap < Lutaml::Model::Serializable
+    attribute :main, :string
+
+    xml do
+      element "title-wrap"
+      mixed_content
+      map_element "main", to: :main
+    end
+  end
 end

data/spec/lutaml/model/type/hash_spec.rb

@@ -6,11 +6,30 @@ RSpec.describe Lutaml::Model::Type::Hash do
       expect(described_class.cast(nil)).to be_nil
     end
 
-    it "returns text content from hash with only text key" do
-      hash = { "text" => "content" }
+    it "returns text content from a MappingHash with only text key" do
+      hash = Lutaml::Model::MappingHash.new
+      hash["text"] = "content"
       expect(described_class.cast(hash)).to eq "content"
     end
 
+    # lutaml/lutaml-model#1013: a "text" key holding structured data
+    # (or appearing alongside other keys in non-XML data) is ordinary
+    # data and must round-trip verbatim
+    it "preserves a structured text key from a plain hash" do
+      hash = { "text" => { "type" => "string", "description" => "y" } }
+      expect(described_class.cast(hash)).to eq hash
+    end
+
+    it "preserves text alongside other keys in a plain hash" do
+      hash = { "text" => "content", "other" => "value" }
+      expect(described_class.cast(hash)).to eq hash
+    end
+
+    it "preserves an elements key from a plain hash" do
+      hash = { "elements" => [{ "a" => 1 }] }
+      expect(described_class.cast(hash)).to eq hash
+    end
+
     it "normalizes MappingHash to regular Hash" do
       mapping_hash = Lutaml::Model::MappingHash.new
       mapping_hash["key"] = "value"
@@ -18,28 +37,29 @@ RSpec.describe Lutaml::Model::Type::Hash do
     end
 
     context "with nested hashes" do
-      let(:input) do
-        {
-          "key1" => {
-            "text" => "content1",
-            "other" => "value1",
-          },
-          "key2" => {
-            "text" => "content2",
-            "other" => "value2",
-          },
-        }
-      end
-
-      let(:expected_hash) do
-        {
+      it "filters out text keys from nested MappingHashes" do
+        child1 = Lutaml::Model::MappingHash.new
+        child1["text"] = "content1"
+        child1["other"] = "value1"
+        child2 = Lutaml::Model::MappingHash.new
+        child2["text"] = "content2"
+        child2["other"] = "value2"
+        input = Lutaml::Model::MappingHash.new
+        input["key1"] = child1
+        input["key2"] = child2
+        expected = {
           "key1" => { "other" => "value1" },
           "key2" => { "other" => "value2" },
         }
+        expect(described_class.cast(input)).to eq(expected)
       end
 
-      it "filters out text keys from nested hashes" do
-        expect(described_class.cast(input)).to eq(expected_hash)
+      it "preserves text keys in nested plain hashes" do
+        input = {
+          "key1" => { "text" => "content1", "other" => "value1" },
+          "key2" => { "text" => "content2", "other" => "value2" },
+        }
+        expect(described_class.cast(input)).to eq(input)
       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.133
 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