lutaml-model 0.8.106 → 0.8.107

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc1bb0f95876011fac44764d7ea55c334d24ea2a20911e46f4200448cf50cc1e
-  data.tar.gz: 23f02dbcf3dac25a19a50f4a8bf75b81d642b64514c0aeb9a820d727be63406f
+  metadata.gz: 1bcd55c9589b05b0eb9c4c9e0231a8e92b9063c3c34a5f9c76da5fc99e2c28f9
+  data.tar.gz: eb53b700df96a27985ff448b264fc9c4f022200d0efc8ebb313db635c6618f49
 SHA512:
-  metadata.gz: 8d649b8eef84ef0cfa60ec5fec9e70b0fa45cdc44508325f12c7a17d66e3ca437535c3bf56bc725217f73d305046c9102d7dba067148f4efdec8996d2f2f8ec2
-  data.tar.gz: d81707bac3fb9bf9ebc3091c421253e3b9b8abd085891e03debcd19674af75ae5e6dc5f1b724fbb05e160847694dcc8752e9eb1fb17425a394c1babc67777273
+  metadata.gz: 3e865d6c056755e187437ebf83d2423b9027df62f0f91822ff85f52541b935219869fb76e3cdd5f98c7422aef828ecea618c454259e82f0c86fa9457ca4e43dc
+  data.tar.gz: 65b581acd3765958cbf7d0e2f1607dfc552d60b441ea42d85bbd247a5c04b4487957cd951853c1fc822b3bd79ad701e6c02820476b022af5f73398d7dc8191e4

data/Gemfile

@@ -49,7 +49,7 @@ gem "rexml"
 # exact-URI attribute rows, nested-attribute capture, wildcard rows,
 # walk-side ns retention and leniency, :unqualified rows, and the
 # address-based text attach all ride it.
-gem "leptris", ">= 1.9.336.0"
+gem "leptris", ">= 1.9.351.1"
 gem "teptris"
 gem "yeptris" unless Gem.win_platform?
 # TODO: revert rng branch to main when lutaml/rng#32 is merged

data/lib/lutaml/model/attribute.rb

@@ -389,12 +389,18 @@ module Lutaml
 
       def cast_value(value, register)
         if list_like?(value)
-          build_collection(cast_items(value, register), register: register)
+          items = cast_items(value, register)
         elsif coerce_to_collection?(value)
-          build_collection(cast_items([value], register), register: register)
+          items = cast_items([value], register)
         else
-          cast_element(value, register)
+          return cast_element(value, register)
         end
+        # cast_items already returns a fresh array, so the plain-Array
+        # collection needs no re-wrap — build_collection's
+        # collection_class.new would copy it again.
+        return items if !custom_collection? && collection_class == ::Array
+
+        build_collection(items, register: register)
       end
 
       # Plain Arrays count as list input. On singular attributes

data/lib/lutaml/model/configuration.rb

@@ -37,7 +37,7 @@ module Lutaml
         @conversion_cache = nil
         @configured = false
         @xml_plan_fast_path = true
-        @xml_plan_ordered_path = false
+        @xml_plan_ordered_path = true
         @element_order_tracking = true
       end
 

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

@@ -223,6 +223,7 @@ module Lutaml
           # Clear memoized attribute merge (see .attributes)
           @merged_attributes_cache = nil
           @instantiate_writers = nil
+          @instantiate_attr_pairs = nil
 
           # Clear per-Attribute type caches (stale entries from GC'd TypeContext objects)
           class_attributes.each_value(&:clear_type_cache)
@@ -402,7 +403,10 @@ module Lutaml
           attrs_by = attributes(register_id)
           writers = instantiate_writers(register_id)
           given = 0
-          attrs_by.each do |name, attr|
+          # Memoized pair array: Hash#each mints a [name, attr] pair
+          # per attribute per instance (~5 allocs/instance on
+          # hydration-heavy corpora); Array#each reuses its elements.
+          instantiate_attr_pairs(register_id).each do |name, attr|
             next if attr.derived?
 
             # Symbol keys hit directly (native-extension callers);
@@ -468,6 +472,14 @@ module Lutaml
             end
         end
 
+        # [name, attr] pairs in attributes order — instantiate's loop
+        # iterates this instead of the attributes Hash so the per-call
+        # pair array disappears (see the instantiate comment).
+        def instantiate_attr_pairs(register_id = nil)
+          (@instantiate_attr_pairs ||= {})[register_id] ||=
+            attributes(register_id).to_a.freeze
+        end
+
         # Define register-specific attribute methods on the class itself.
         #
         # Called once per (class, register) combination. Replaces per-instance

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.106"
+    VERSION = "0.8.107"
   end
 end

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

@@ -45,7 +45,7 @@ module Lutaml
                         element_buckets(node, plan[:contested_names])
                       end
             attr_kwargs = attributes_kwargs(plan, value, node)
-            child_kwargs, children, delegates =
+            child_kwargs, children, delegates, run_children =
               children_kwargs(model_class, plan, value, buckets, register)
             plan[:collection_defaults].each do |name|
               next if attr_kwargs.key?(name) || child_kwargs.key?(name)
@@ -88,7 +88,8 @@ module Lutaml
               child.lutaml_parent = instance
               child.lutaml_root ||= instance.lutaml_root || instance
             end
-            interpret_deferred(model_class, plan, value, instance, node, buckets)
+            interpret_deferred(model_class, plan, value, instance, node,
+                               buckets, run_children)
             route_delegates(delegates, instance)
             instance
           end
@@ -148,8 +149,12 @@ module Lutaml
             kwargs = {}
             sole_claimants = sole_claimant_names(plan)
             ns_attr_names = plan[:ns_attr_names]
-            plan_attr_rows(plan).each do |rule, attr, name|
-              v = value.attribute(name)
+            rows = plan_attr_rows(plan)
+            # #1670 batch face (leptris 1.9.351.1): one FFI crossing
+            # per node instead of one per (node x attribute name).
+            bound = value.attributes_snapshot
+            rows.each do |rule, attr, name|
+              v = bound[name]
               if v.nil? && node && sole_claimants.include?(name)
                 # #754/#790 parity: a sole-claimant attribute rule binds
                 # any qualification (the interpretive matcher's lenient
@@ -239,7 +244,8 @@ module Lutaml
           def children_kwargs(_model_class, plan, value, buckets = nil,
                               register = nil)
             register ||= Lutaml::Model::Config.default_register
-            grouped, tagged = group_children(value, plan[:row_tags])
+            grouped, tagged, run_children = group_children(value,
+                                                           plan[:row_tags])
             buckets = nil unless buckets && plan[:needs_nodes]
             kwargs = {}
             children = []
@@ -250,9 +256,17 @@ module Lutaml
             row_tags = plan[:row_tags]
             wire_names = row_wire_names(plan)
             row_memo = child_row_plans(plan, register)
+            # Array#each with a top-of-loop counter: each_with_index
+            # mints an enumerator per hydrated node — 14.7K allocations
+            # per parse on the pnas guardrail — and next must keep its
+            # continue semantics.
+            rows = plan[:rows]
+            idx = -1
             # rubocop:disable Metrics/BlockLength -- one row-kind
             # dispatch table; splitting it would scatter the contract
-            plan[:rows].each_with_index do |(rule, attr, kind, spelling, delegate, _row_type), idx|
+            rows.each do |row|
+              idx += 1
+              rule, attr, kind, spelling, delegate, _row_type = row
               tag = row_tags&.[](idx)
               name = wire_names[idx]
               case kind
@@ -284,7 +298,7 @@ module Lutaml
               when :wildcard_any
                 # interpreted post-instance (interpret_deferred)
               when :content
-                runs = content_runs(value)
+                runs = content_runs(value, run_children)
                 if runs.empty? && !attr.collection?
                   # An empty element's content binds through the rule's
                   # value map for scalar content attributes: "" for the
@@ -375,11 +389,17 @@ module Lutaml
                   cursor = if child_plan[:needs_nodes] && buckets
                              selected
                            end
-                  items = values.each_with_index
-                    .map do |v, i|
-                      call(child_type, child_plan, v,
-                           node: cursor && cursor[i], register: child_register)
-                    end
+                  # Indexed loop: each_with_index.map mints an
+                  # enumerator per node with nested rows.
+                  count = values.size
+                  items = Array.new(count)
+                  pos = 0
+                  while pos < count
+                    items[pos] = call(child_type, child_plan, values[pos],
+                                      node: cursor && cursor[pos],
+                                      register: child_register)
+                    pos += 1
+                  end
                 end
                 next if items.empty?
 
@@ -402,7 +422,7 @@ module Lutaml
                        attr.collection? ? values : values.first)
               end
             end
-            [kwargs, children, delegates]
+            [kwargs, children, delegates, run_children]
           end
 
           # Deferred islands: raw subtrees become wrapper elements via a
@@ -413,15 +433,20 @@ module Lutaml
           # node (no fragment parse — the reparse dominated deferred
           # hydration). Ordered children only land here without a node.
           def interpret_deferred(model_class, plan, value, instance, node = nil,
-                                 buckets = nil)
-            plan[:rows].each_with_index do |row, idx|
+                                 buckets = nil, run_children = nil)
+            # Array#each + top counter: no per-node enumerator (see
+            # children_kwargs).
+            rows = plan[:rows]
+            idx = -1
+            rows.each do |row|
+              idx += 1
               rule = row[0]
               attr = row[1]
               kind = row[2]
               wire_name = row_wire_names(plan)[idx]
               case kind
               when :content_deferred
-                runs = content_runs(value)
+                runs = content_runs(value, run_children)
                 if runs.empty?
                   # The interpretive pipeline classifies the raw ""
                   # through the rule's value map: the :empty directive
@@ -587,15 +612,14 @@ module Lutaml
             end
           end
 
-          def content_runs(value)
-            out = []
-            value.count.times do |i|
-              c = value.at(i)
-              next unless c.name.nil? && c.kind == :collection
-
-              out.concat(Array.new(c.count) { |j| c.at(j).string_value })
+          # Content runs ride the children snapshot: the nil-name
+          # entries ARE the :collection run groups (one crossing per
+          # node via group_children, none here). The per-group
+          # at/count crossings are the drain itself.
+          def content_runs(_value, run_children)
+            (run_children || []).flat_map do |group|
+              Array.new(group.count) { |j| group.at(j).string_value }
             end
-            out
           end
 
           # Native collection rows echo their producing row's name
@@ -663,8 +687,14 @@ module Lutaml
             grouped = {}
             want_tags = !row_tags.nil?
             tagged = want_tags ? {} : nil
+            run_children = nil
             names.each_with_index do |name, i|
-              next if name.nil? # content runs, read separately
+              if name.nil?
+                # Content runs: same snapshot pass — at()/count() per
+                # child cost a crossing and a wrapper each.
+                (run_children ||= []) << children[i]
+                next
+              end
 
               child = children[i]
               (grouped[name] ||= []) << child
@@ -672,7 +702,7 @@ module Lutaml
                 (tagged[tags[i]] ||= []) << child
               end
             end
-            [grouped, tagged]
+            [grouped, tagged, run_children]
           end
 
           # Element children bucketed by local name, document order

data/lib/lutaml/xml/leptris.rb

@@ -8,16 +8,18 @@ module Lutaml
     # reference leptris types directly (the moxml adapters and the
     # interpretive path never enter here).
     module Leptris
-      # Single capability floor (leptris 1.9.336.0): the child-handles
+      # Single capability floor (leptris 1.9.351.1): the child-handles
       # snapshot (1.9.273), exact-URI attribute rows (#1486, 1.9.289),
       # nested-attribute capture (#1563, 1.9.313), wildcard rows
       # (#1552, 1.9.313), child-row ns_uri retention and qualified
       # attribute leniency (#1585/#1586, 1.9.320), the :unqualified ns
-      # form (#1560, 1.9.323), and build_result with the address-based
-      # text attach (#408, 1.9.334/1.9.336). Bundles resolving an
-      # older gem keep the interpretive path — PlanCompiler.compile
-      # answers nil — the opt-out protocol.
-      MIN_LEPTRIS_VERSION = "1.9.336.0"
+      # form (#1560, 1.9.323), build_result with the address-based
+      # text attach (#408, 1.9.334/1.9.336), and the plan-value
+      # attributes batch face (PlanValue#attributes_snapshot,
+      # leptris-ruby#447). Bundles resolving an older gem keep the
+      # interpretive path — PlanCompiler.compile answers nil — the
+      # opt-out protocol.
+      MIN_LEPTRIS_VERSION = "1.9.351.1"
 
       # Memoized: the compiler consults this on every cache hit (per
       # child row per node), and the comparison minted a Gem::Version

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -31,13 +31,14 @@ RSpec.describe "XML plan fast path" do
   let(:root_class) { classes[1] }
 
   around do |example|
-    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    old_fast = Lutaml::Model::Config.instance.xml_plan_fast_path
+    old_ordered = Lutaml::Model::Config.instance.xml_plan_ordered_path
     Lutaml::Model::Config.instance.xml_plan_fast_path = true
     Lutaml::Model::Config.instance.xml_plan_ordered_path = true
     example.run
   ensure
-    Lutaml::Model::Config.instance.xml_plan_fast_path = old
-    Lutaml::Model::Config.instance.xml_plan_ordered_path = false
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old_fast
+    Lutaml::Model::Config.instance.xml_plan_ordered_path = old_ordered
   end
 
   # Real-corpus crash (niso-jats): sec-in-sec nesting is a

metadata

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