lutaml-model 0.8.106 → 0.8.108

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc1bb0f95876011fac44764d7ea55c334d24ea2a20911e46f4200448cf50cc1e
-  data.tar.gz: 23f02dbcf3dac25a19a50f4a8bf75b81d642b64514c0aeb9a820d727be63406f
+  metadata.gz: 50f81556cebfd601f3ff6ede463ed9f20d31a0e2c12e8c1362c655b5dd9408e8
+  data.tar.gz: c9ec847109db4b87bbb4e4e46fde663eb83d7b9eae54d43f55e1c04024345013
 SHA512:
-  metadata.gz: 8d649b8eef84ef0cfa60ec5fec9e70b0fa45cdc44508325f12c7a17d66e3ca437535c3bf56bc725217f73d305046c9102d7dba067148f4efdec8996d2f2f8ec2
-  data.tar.gz: d81707bac3fb9bf9ebc3091c421253e3b9b8abd085891e03debcd19674af75ae5e6dc5f1b724fbb05e160847694dcc8752e9eb1fb17425a394c1babc67777273
+  metadata.gz: cbce6698e13f0d52da843a92c4bae8ca69db7f11cdbd654f1dd924cd171f31ad227da0a610557a17de11856de2030460d5b497a248c3b37b7de76ca286398520
+  data.tar.gz: d4113a27b55316ad49f5a9263ac3b1d15616c3c7c65408faa1b0a4741ed1966fcd173a8519d85b19dec66a406ce168caf6439703b5e687318ae74dc586ee586d

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/json/adapter/yeptris_adapter.rb

@@ -26,6 +26,17 @@ module Lutaml
         end
         private_class_method :require_engine
 
+        # True where the yeptris engine loads (libyeptris present for
+        # this platform). Idempotent; a missing or broken install
+        # reports false instead of raising, so optional-engine callers
+        # can gate on it.
+        def self.available?
+          require_engine
+          true
+        rescue LoadError
+          false
+        end
+
         # The parse-error contract is the standard adapter's: invalid
         # input raises JSON::ParserError regardless of the engine, so
         # consumers' rescue ladders (and this gem's own

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,11 @@ module Lutaml
         @conversion_cache = nil
         @configured = false
         @xml_plan_fast_path = true
-        @xml_plan_ordered_path = false
+# Opt-in until leptris#1743 lands: the native ordered lane
+# runs away (28+ CPU-min / 14GB RSS on sts-ruby's
+# ISO_13849-1 document) — flipping this on by default regressed
+# the sts bench cell from 4m41s to a 10-minute kill.
+@xml_plan_ordered_path = false
         @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.108"
   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/lib/lutaml/yaml/adapter/yeptris_adapter.rb

@@ -40,6 +40,17 @@ module Lutaml
         end
         private_class_method :require_engine
 
+        # True where the yeptris engine loads (libyeptris present for
+        # this platform). Idempotent; a missing or broken install
+        # reports false instead of raising, so optional-engine callers
+        # can gate on it.
+        def self.available?
+          require_engine
+          true
+        rescue LoadError
+          false
+        end
+
         # The parse-error contract is the standard adapter's: invalid
         # input raises Psych::SyntaxError regardless of the engine, so
         # consumers' rescue ladders (and this gem's own

data/spec/lutaml/json/yeptris_adapter_spec.rb

@@ -1,16 +1,9 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-begin
-  require "lutaml/json/adapter/yeptris_adapter"
-rescue LoadError
-  # yeptris ships no platform gem here (e.g. Windows): every example skips.
-end
-
-YEPTRIS_AVAILABLE = defined?(Yeptris)
+require "lutaml/json/adapter/yeptris_adapter"
 
-RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Json::Adapter::YeptrisAdapter : Object) do
-  before { skip "yeptris is not available on this platform" unless YEPTRIS_AVAILABLE }
+RSpec.describe Lutaml::Json::Adapter::YeptrisAdapter do
+  before { skip "yeptris is not available on this platform" unless described_class.available? }
 
   let(:attributes) { { "name" => "John", "age" => 30, "roles" => %w[admin dev] } }
 

data/spec/lutaml/model/adapter_resolver_configured_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
+require "open3"
 
 RSpec.describe Lutaml::Model::AdapterResolver, ".adapter_for with a configured type" do
   after do
@@ -22,17 +23,39 @@ RSpec.describe Lutaml::Model::AdapterResolver, ".adapter_for with a configured t
     expect(adapter.name).to include("Json::Standard")
   end
 
+  # Runs in a subprocess: whether the engine is already loaded is a
+  # process-global fact, so any in-process assertion would depend on
+  # spec file order (the yeptris adapter faces load it).
   it "does not load the optional yeptris engine when a standard adapter is configured" do
-    skip "yeptris already loaded by an earlier spec" if Object.const_defined?(:Yeptris)
+    probe = <<~RUBY
+      require "lutaml/model"
 
-    Lutaml::Model::Config.configure do |config|
-      config.yaml_adapter_type = :standard
-      config.json_adapter_type = :standard
-    end
+      Lutaml::Model::Config.configure do |config|
+        config.yaml_adapter_type = :standard
+        config.json_adapter_type = :standard
+      end
+
+      adapter_yaml = Lutaml::Model::AdapterResolver.adapter_for(:yaml)
+      adapter_json = Lutaml::Model::AdapterResolver.adapter_for(:json)
 
-    described_class.adapter_for(:yaml)
-    described_class.adapter_for(:json)
+      # Parsing through the configured adapters must likewise stay on
+      # the standard engines.
+      adapter_yaml.parse("a: 1")
+      adapter_json.parse('{"a":1}')
+
+      exit(Object.const_defined?(:Yeptris) ? 1 : 0)
+    RUBY
+
+    _stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-I", "lib", "-e", probe)
+    expect(status).to be_success, stderr
+  end
+end
 
-    expect(Object.const_defined?(:Yeptris)).to be(false)
+RSpec.describe "plan lane defaults" do
+  it "ships the ordered plan lane opt-in until leptris#1743 is fixed" do
+    # The native ordered lane runs away on sts-ruby's ISO_13849-1
+    # document (leptris#1743): 28+ CPU-min / 14 GB RSS vs 6.36s on the
+    # same parse with the lane off. Opt-in until the engine fix ships.
+    expect(Lutaml::Model::Config.instance.xml_plan_ordered_path).to be(false)
   end
 end

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

data/spec/lutaml/yaml/yeptris_adapter_spec.rb

@@ -1,16 +1,9 @@
 # frozen_string_literal: true
 
-require "spec_helper"
-begin
-  require "lutaml/yaml/adapter/yeptris_adapter"
-rescue LoadError
-  # yeptris ships no platform gem here (e.g. Windows): every example skips.
-end
-
-YEPTRIS_AVAILABLE = defined?(Yeptris)
+require "lutaml/yaml/adapter/yeptris_adapter"
 
-RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Yaml::Adapter::YeptrisAdapter : Object) do
-  before { skip "yeptris is not available on this platform" unless YEPTRIS_AVAILABLE }
+RSpec.describe Lutaml::Yaml::Adapter::YeptrisAdapter do
+  before { skip "yeptris is not available on this platform" unless described_class.available? }
 
   let(:attributes) { { "name" => "John", "roles" => %w[admin dev] } }
 

metadata

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