lutaml-model 0.8.138 → 0.8.140

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b04af29b0ab95619a185f91ca138ff213b771112707395df0aea9d093978aa5
-  data.tar.gz: c3830c610420cceb888b370417cf2f83a044aa00e10cb3bca7c71c3833587dc4
+  metadata.gz: e4340bd1bf4b75d088acb5a60a68073d2980d419fe5c7f59412966956a58e377
+  data.tar.gz: 829a741bc56fa070059d8198887cc51051859f64a2aeab747814c5f0d278356b
 SHA512:
-  metadata.gz: 205e61d1960bfff5771363582c8db6600f6f703a255b69e7684d40abc04434dc9ef786ec260518930afb4584db219acade52068975fea7ac39604cab82891d28
-  data.tar.gz: 1a19fc45f5880487573f2849203247015edd843f9c7000a6de992c70aaa439dbcc36e4741f1027b0ca441ee8358ec3ce1559e3f877f91476b80a3b661a3fecfd
+  metadata.gz: 14cda9bfd53830559db4848694f3118289958108e17f9445a079c585c8aed5f637878d4b1a0b4f232f1dca8d12100f4d56d73bb8289d2e73cd625a42682c90df
+  data.tar.gz: 124577fb5f037a6dea46e3da4f409713fadcc2ca2398e34a578d47230be5651274d3eabac7342fc708b2939c59d56f4248bfe97da88cc39dddce509cdffc83ef

data/lib/lutaml/model/attribute.rb

@@ -379,6 +379,13 @@ module Lutaml
       # Performance: Frozen empty hash to reduce allocations
       EMPTY_TRANSFORM_HASH = {}.freeze
 
+      # Default-argument options for the serialize lane. The per-call
+      # `options = {}` literal allocated one Hash per serialize call
+      # (two per mapped XML row); every consumer of the argument only
+      # reads it or derives a new hash (merge), so a shared frozen
+      # empty is safe.
+      EMPTY_OPTIONS = {}.freeze
+
       def transform
         # Options are fixed after definition (value_policy memoizes the
         # same way) — the per-call @options[:transform] Hash#[] was hit
@@ -918,7 +925,7 @@ instance_object = nil)
         true
       end
 
-      def serialize(value, format, register, options = {})
+      def serialize(value, format, register, options = EMPTY_OPTIONS)
         value ||= build_collection if collection? && initialize_empty?
         return value if value.nil? || Utils.uninitialized?(value)
 

data/lib/lutaml/model/serialize/initialization.rb

@@ -374,9 +374,6 @@ module Lutaml
           # compiled seed cannot know about (SchemaRepository's
           # @parsed_schemas/@namespace_registry/@type_index): construct
           # through the real constructor for them, exactly as the walk
-          # did before the compiled seed existed. The seed stays the
-          # fast path for classes using the standard initializer.
-          return new(lutaml_register: register) if constructs_through_initialize?
           # did before the compiled seed existed, register included. The
           # seed stays the fast path for classes using the standard
           # initializer.

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.138"
+    VERSION = "0.8.140"
   end
 end

data/lib/lutaml/xml/leptris/native_emission.rb

@@ -31,6 +31,17 @@ module Lutaml
         ROOT_ROW = 0xFFFF_FFFF
         EMITTABLE_KINDS = %i[scalar collection nested].freeze
 
+        # Fiber-local buffer of reusable op Hash slots. The engine's
+        # build_result copies every op into FFI memory before it
+        # returns, so the Ruby hashes are dead weight past the call;
+        # recycling them positionally removes one Hash allocation per
+        # emitted op (four per mapped row on the emission lane) at no
+        # semantic cost. Slots are cleared before every reuse, so
+        # stale keys from a prior kind cannot leak into an op.
+        OP_BUFFER_KEY = :lutaml_model_leptris_native_emission_op_buffer
+        OP_BUFFER_BASE_KEY =
+          :lutaml_model_leptris_native_emission_op_buffer_base
+
         class << self
           def compatible?(plan)
             !plan[:ordered] && tree_emittable?(plan[:tree])
@@ -49,28 +60,59 @@ module Lutaml
             end
           end
 
+          # len is the logical length of the buffer: slots [base, len) hold
+          # the ops of the emission in progress. base is nonzero when a
+          # user hook re-enters to_xml mid-emission — the inner
+          # emission appends after the outer's written slots instead of
+          # overwriting them. The tail is trimmed after the engine
+          # consumed the result so a pathological document cannot grow
+          # the buffer without bound.
           def emit(instance, plan, register)
-            ops = [{ kind: :element, row_index: ROOT_ROW }]
-            emit_element(ops, instance, plan, register, 0)
-            ops << { kind: :end }
-            compact = plan[:descriptor].serialize(
-              plan[:descriptor].build_result(ops),
-            )
-            ::Leptris::XML.parse(compact).to_xml(indent: 2, no_decl: true)
+            buf = (Thread.current[OP_BUFFER_KEY] ||= [])
+            base = (Thread.current[OP_BUFFER_BASE_KEY] ||= 0)
+            len = base
+            begin
+              op_slot(buf, len)
+              buf[len][:kind] = :element
+              buf[len][:row_index] = ROOT_ROW
+              len = emit_element(buf, len + 1, instance, plan, register, 0)
+              op_slot(buf, len)
+              buf[len][:kind] = :end
+              len += 1
+              compact = plan[:descriptor].serialize(
+                plan[:descriptor].build_result(buf[base, len - base]),
+              )
+              ::Leptris::XML.parse(compact).to_xml(indent: 2, no_decl: true)
+            ensure
+              buf.slice!(len..) if buf.size > len
+              Thread.current[OP_BUFFER_BASE_KEY] = base
+            end
           end
 
           private
 
+          # Cleared slot len of the buffer, reusing the Hash object a
+          # previous emission left there when present. Also publishes
+          # this emission's exclusive end as the fiber-local base: the
+          # walk evaluates user code (model getters, default procs,
+          # registered serializers) between slots, and a re-entrant
+          # to_xml from that code must append after every written op,
+          # never overlap this emission's slots.
+          def op_slot(buf, len)
+            Thread.current[OP_BUFFER_BASE_KEY] = len + 1
+            (buf[len] ||= {}).clear
+          end
+
           # plan_index: this plan's flattened index. The engine's
           # flatten_plan pushes each nested row's child plan exactly
           # once — collection members share that slot — so child flat
           # indices come from a static per-plan layout (relative to
           # this plan's index), never from a runtime counter.
-          def emit_element(ops, instance, plan, register, plan_index)
+          def emit_element(buf, len, instance, plan, register, plan_index)
             my_index = plan_index
             layout = flat_layout_for(plan)
 
-            emit_attributes(ops, instance, plan, my_index, register)
+            len = emit_attributes(buf, len, instance, plan, my_index, register)
 
             plan[:rows].each_with_index do |(rule, attr, kind, _spelling, delegate), row_index|
               value = value_of(instance, attr, delegate)
@@ -83,31 +125,41 @@ module Lutaml
                 # as the DOM lane does.
                 if value.is_a?(::Array)
                   value.each do |item|
-                    ops << scalar_op(my_index, row_index, attr, item, register)
+                    len = scalar_op(buf, len, my_index, row_index, attr, item,
+                                  register)
                   end
                 else
-                  ops << scalar_op(my_index, row_index, attr, value, register)
+                  len = scalar_op(buf, len, my_index, row_index, attr, value,
+                                register)
                 end
               when :collection_native, :collection_cb
                 Array(value).each do |item|
-                  ops << scalar_op(my_index, row_index, attr, item, register)
+                  len = scalar_op(buf, len, my_index, row_index, attr, item,
+                                register)
                 end
               when :nested
                 _tree, child_rel = layout[row_index]
                 next unless child_rel
 
+                child_plans = child_plans_for(plan, row_index)
                 Array(value).each do |item|
-                  child_plan = nested_plans_for(plan)[[item.class, rule.name.to_s]] ||
-                    (nested_plans_for(plan)[[item.class, rule.name.to_s]] =
+                  child_plan = child_plans[item.class] ||
+                    (child_plans[item.class] =
                        PlanCompiler.compile(item.class, register))
-                  ops << { kind: :element, plan_index: my_index,
-                           row_index: row_index }
-                  emit_element(ops, item, child_plan,
-                               register, my_index + child_rel)
-                  ops << { kind: :end }
+                  op_slot(buf, len)
+                  buf[len][:kind] = :element
+                  buf[len][:plan_index] = my_index
+                  buf[len][:row_index] = row_index
+                  len += 1
+                  len = emit_element(buf, len, item, child_plan,
+                                   register, my_index + child_rel)
+                  op_slot(buf, len)
+                  buf[len][:kind] = :end
+                  len += 1
                 end
               end
             end
+            len
           end
 
           # {nested row_index => [child tree, relative flat index]} —
@@ -133,19 +185,50 @@ module Lutaml
             end
           end
 
-          def emit_attributes(ops, instance, plan, plan_index, register)
+          # The name bookkeeping is static per plan — attr_rows and the
+          # tree's attribute rows never vary per instance — so the
+          # name->tree row_index map is memoized on the plan. Only
+          # instances carrying a recorded attribute order (parsed
+          # documents whose XML attribute sequence must be replayed)
+          # take the per-instance path.
+          def emit_attributes(buf, len, instance, plan, plan_index, register)
             recorded = instance.attribute_order
-            attr_rows = plan[:attr_rows]
             if recorded && !recorded.empty?
-              by_name = {}
-              attr_rows.each { |rule, attr, _sp, delegate| by_name[rule.name.to_s] = [rule, attr, delegate] }
-              names = recorded | attr_rows.map { |rule, _a, _s, _d| rule.name.to_s }
-            else
-              names = attr_rows.map { |rule, _a, _s, _d| rule.name.to_s }
-              by_name = {}
-              attr_rows.each { |rule, attr, _sp, delegate| by_name[rule.name.to_s] = [rule, attr, delegate] }
+              emit_attributes_recorded(buf, len, instance, plan, plan_index,
+                                       register, recorded)
+              return len
+            end
+
+            tree_attrs = plan[:tree][:attributes] || []
+            row_indices = attr_row_indices_for(plan, tree_attrs)
+            attr_rows = plan[:attr_rows]
+            attr_rows.each do |rule, attr, _sp, delegate|
+              value = value_of(instance, attr, delegate)
+              next if value.nil?
+
+              name = rule.name.to_s
+              row_index = row_indices[name]
+              next unless row_index
+
+              op_slot(buf, len)
+              buf[len][:kind] = :attr
+              buf[len][:plan_index] = plan_index
+              buf[len][:row_index] = row_index
+              buf[len][:name] = name
+              buf[len][:value] = attr.serialize(value, :xml, register).to_s
+              len += 1
             end
+            len
+          end
+
+          def emit_attributes_recorded(buf, len, instance, plan, plan_index,
+                                       register, recorded)
+            attr_rows = plan[:attr_rows]
+            by_name = {}
+            attr_rows.each { |rule, attr, _sp, delegate| by_name[rule.name.to_s] = [rule, attr, delegate] }
+            names = recorded | attr_rows.map { |rule, _a, _s, _d| rule.name.to_s }
             tree_attrs = plan[:tree][:attributes] || []
+            row_indices = attr_row_indices_for(plan, tree_attrs)
             names.each do |name|
               entry = by_name[name]
               next unless entry
@@ -154,18 +237,40 @@ module Lutaml
               value = value_of(instance, attr, delegate)
               next if value.nil?
 
-              row_index = tree_attrs.index { |a| a[:name] == name }
+              row_index = row_indices[name]
               next unless row_index
 
-              ops << { kind: :attr, plan_index: plan_index,
-                       row_index: row_index, name: name,
-                       value: attr.serialize(value, :xml, register).to_s }
+              op_slot(buf, len)
+              buf[len][:kind] = :attr
+              buf[len][:plan_index] = plan_index
+              buf[len][:row_index] = row_index
+              buf[len][:name] = name
+              buf[len][:value] = attr.serialize(value, :xml, register).to_s
+              len += 1
+            end
+            len
+          end
+
+          # name -> tree_attrs index, first occurrence wins (same match
+          # semantics as the Array#index scan it replaced).
+          def attr_row_indices_for(plan, tree_attrs)
+            return plan[:attr_row_indices] if plan[:attr_row_indices]
+
+            indices = {}
+            tree_attrs.each_with_index do |tree_attr, i|
+              name = tree_attr[:name]
+              indices[name] = i unless indices.key?(name)
             end
+            plan[:attr_row_indices] = indices
           end
 
-          def scalar_op(plan_index, row_index, attr, value, register)
-            { kind: :scalar, plan_index: plan_index, row_index: row_index,
-              value: attr.serialize(value, :xml, register).to_s }
+          def scalar_op(buf, len, plan_index, row_index, attr, value, register)
+            op_slot(buf, len)
+            buf[len][:kind] = :scalar
+            buf[len][:plan_index] = plan_index
+            buf[len][:row_index] = row_index
+            buf[len][:value] = attr.serialize(value, :xml, register).to_s
+            len + 1
           end
 
           def value_of(instance, attr, delegate)
@@ -177,8 +282,11 @@ module Lutaml
             end
           end
 
-          def nested_plans_for(plan)
-            plan[:nested_plans] ||= {}
+          # Compiled child plans per nested row, keyed by row index and
+          # then by member class. Keying through Integers and classes
+          # avoids allocating a [class, name] pair per emitted child.
+          def child_plans_for(plan, row_index)
+            (plan[:nested_plans_by_row] ||= {})[row_index] ||= {}
           end
         end
       end

data/lib/lutaml/xml/mapping.rb

@@ -1556,6 +1556,7 @@ module Lutaml
           @attributes
           @elements
           @processing_instruction_mappings
+          @all_attributes_rule
           @register_elements
           @register_attributes
           @register_element_sequences

data/lib/lutaml/xml/model_transform.rb

@@ -511,9 +511,11 @@ module Lutaml
       end
 
       # #1031: wildcard attribute families. After the explicit attribute
-      # rules have consumed their names, every remaining unprefixed
-      # attribute matching the rule's pattern lands in the target Hash —
-      # names claimed by explicit rules never leak into it.
+      # rules have consumed their names, every remaining attribute
+      # matching the rule's pattern lands in the target Hash — names
+      # claimed by explicit rules never leak into it. The key is the name
+      # as written, prefix included: keyed by its local name, xlink:href
+      # would serialize back as a plain href attribute.
       def apply_all_attributes_deserialization(doc, instance, xml_mapping)
         rule = xml_mapping.all_attributes_rule
         return if rule.nil?
@@ -524,8 +526,9 @@ module Lutaml
         claimed = attribute_names_claimed_by_rules(xml_mapping)
         remainder = {}
         element.attributes.each_value do |attr|
-          name = attr.unprefixed_name.to_s
-          next if claimed.include?(name)
+          next if claimed.include?(attr.unprefixed_name.to_s)
+
+          name = attr.name.to_s
           next if rule.matching && !rule.matching.match?(name)
 
           remainder[name] = attr.value

data/spec/lutaml/model/map_all_attributes_spec.rb

@@ -86,4 +86,35 @@ RSpec.describe "map_all_attributes" do
 
     expect(model.other_attributes).to eq("zeta" => "1")
   end
+
+  it "keeps a prefixed attribute's prefix through a round-trip" do
+    xml = '<mn xmlns:xlink="http://www.w3.org/1999/xlink" name="x" ' \
+          'data-title="T" xlink:href="#t"/>'
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :other_attributes, :hash
+
+      xml do
+        element "mn"
+        map_attribute "name", to: :name
+        map_all_attributes to: :other_attributes
+      end
+    end
+    stub_const("MapAllPrefixedModel", klass)
+
+    model = klass.from_xml(xml)
+
+    expect(model.other_attributes).to eq("data-title" => "T", "xlink:href" => "#t")
+    expect(model.to_xml).to include('xlink:href="#t"')
+    expect(model.to_xml).not_to include(' href="#t"')
+  end
+
+  it "is inherited by a subclass along with the other mappings" do
+    stub_const("MapAllAttributesChild", Class.new(stubbed))
+
+    model = MapAllAttributesChild.from_xml('<mn name="x" data-title="T"/>')
+
+    expect(model.data_attributes).to eq("data-title" => "T")
+    expect(model.to_xml).to include('data-title="T"')
+  end
 end

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -819,4 +819,65 @@ RSpec.describe "XML plan fast path" do
       )
     end
   end
+
+  describe "native emission op buffer" do
+    around do |example|
+      Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+    end
+
+    it "keeps a re-entrant to_xml from a getter from corrupting the outer emission" do
+      inner = Class.new(Lutaml::Model::Serializable) do
+        attribute :v, :string
+
+        xml do
+          element "inner"
+          map_attribute "v", to: :v
+        end
+      end
+      outer = Class.new(Lutaml::Model::Serializable) do
+        attribute :v, :string
+        attribute :items, inner, collection: true
+
+        xml do
+          element "outer"
+          map_attribute "v", to: :v
+          map_element "inner", to: :items
+        end
+
+        define_method(:items) do
+          inner.new(v: "reentrant").to_xml
+          @items
+        end
+      end
+
+      model = outer.new(v: "x", items: [inner.new(v: "1"), inner.new(v: "2")])
+      expected = "<outer v=\"x\">\n  <inner v=\"1\"/>\n  <inner v=\"2\"/>\n</outer>"
+      expect(model.to_xml).to eq(expected)
+      expect(model.to_xml).to eq(expected)
+    end
+
+    it "keeps interleaved emissions of distinct models stable" do
+      alpha = Class.new(Lutaml::Model::Serializable) do
+        attribute :a, :string
+
+        xml do
+          element "alpha"
+          map_attribute "a", to: :a
+        end
+      end
+      beta = Class.new(Lutaml::Model::Serializable) do
+        attribute :b, :integer
+
+        xml do
+          element "beta"
+          map_attribute "b", to: :b
+        end
+      end
+
+      5.times do
+        expect(alpha.new(a: "x").to_xml).to eq("<alpha a=\"x\"/>")
+        expect(beta.new(b: 7).to_xml).to eq("<beta b=\"7\"/>")
+      end
+    end
+  end
 end

metadata

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