lutaml-model 0.8.105 → 0.8.106

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c9d133a4a89e51d9a1ed811bd992faeac4f0a8513e283b46f079707bcc083f7e
-  data.tar.gz: e4df7bb98a1f7518bdd9f2194934e91feea5367bbf536f75aa4353a067b65049
+  metadata.gz: cc1bb0f95876011fac44764d7ea55c334d24ea2a20911e46f4200448cf50cc1e
+  data.tar.gz: 23f02dbcf3dac25a19a50f4a8bf75b81d642b64514c0aeb9a820d727be63406f
 SHA512:
-  metadata.gz: 7040ad58b0a31222207e14245293f8f20eb674180dcd55936de938151f16fc5260615f5ec3244769e4644af0bd6f02c9262e87717cbdff9d578a6b1365bbbb3a
-  data.tar.gz: f5d38407f6e5ad1b87bad426f68398a6e1249b57c928aa1a94f0585b144517542f0565c38ad2f53b31bc2c80bdaf63a5425968ba883c9d222508940f9b8b1c17
+  metadata.gz: 8d649b8eef84ef0cfa60ec5fec9e70b0fa45cdc44508325f12c7a17d66e3ca437535c3bf56bc725217f73d305046c9102d7dba067148f4efdec8996d2f2f8ec2
+  data.tar.gz: d81707bac3fb9bf9ebc3091c421253e3b9b8abd085891e03debcd19674af75ae5e6dc5f1b724fbb05e160847694dcc8752e9eb1fb17425a394c1babc67777273

data/lib/lutaml/model/version.rb

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

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

@@ -15,6 +15,10 @@ module Lutaml
       # (their values echo name and type_tag; native collection values
       # echo neither — leptris-ruby#220).
       module PlanHydrator
+        # Row kinds whose child type/plan resolve once per plan (see
+        # child_row_plans).
+        CHILD_ROW_KINDS = %i[nested ordered_deferred].freeze
+
         class << self
           # plan: the compiled plan entry for model_class
           # value: the walk root PlanValue (element)
@@ -51,8 +55,8 @@ module Lutaml
             # TODO.max-perf/33: the bulk constructor — allocate +
             # compiled writers, from_hash semantics — measured ~30x on
             # hydration-heavy corpora versus the generic constructor.
-            instance = model_class.instantiate(attr_kwargs.merge(child_kwargs),
-                                               register)
+            attr_kwargs.update(child_kwargs)
+            instance = model_class.instantiate(attr_kwargs, register)
             instance.lutaml_parent = parent if parent
             instance.lutaml_root ||= parent&.lutaml_root || parent
             # Root prefix fidelity (the interpretive transform records
@@ -244,10 +248,13 @@ module Lutaml
             # the block-backed Hash is a fresh object per hydrated row.
             spellings = nil
             row_tags = plan[:row_tags]
+            wire_names = row_wire_names(plan)
+            row_memo = child_row_plans(plan, register)
             # 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|
+            plan[:rows].each_with_index do |(rule, attr, kind, spelling, delegate, _row_type), idx|
               tag = row_tags&.[](idx)
+              name = wire_names[idx]
               case kind
               when :scalar
                 # Raw passthrough: the model constructor is the single
@@ -265,7 +272,7 @@ module Lutaml
                   first = if tag
                             tagged[tag]&.first
                           else
-                            grouped.dig(rule.name.to_s, 0)
+                            grouped.dig(name, 0)
                           end
                   v = first&.string_value
                   v = mapped_empty_value(rule) if v.nil? && first
@@ -293,15 +300,13 @@ module Lutaml
                 # walk against its own node + element_order from the
                 # node's children. Without one (direct PlanHydrator
                 # use), the subtree fragment-parses interpretively.
-                if buckets
-                  child_type = row_type || attr.type(register)
-                  child_plan = PlanCompiler.compile(child_type, register)
-                  selected, = child_bucket(buckets, rule, child_plan,
-                                            contested_name?(plan, rule))
+                if buckets && row_memo[idx]
+                  child_type, child_plan, child_register, contested = row_memo[idx]
+                  selected = child_selection(buckets, name, child_plan, contested)
                   items = (selected || []).map do |n|
                     call(child_type, child_plan,
                          child_plan[:descriptor].walk(n), node: n,
-                                                          register: register)
+                                                          register: child_register)
                   end
                   unless items.empty?
                     children.concat(items)
@@ -314,10 +319,10 @@ module Lutaml
                 # source node casts through the attribute — the full
                 # interpretive machinery on the bridged island,
                 # identical semantics to the interpretive path.
-                contested_uri = if plan[:contested_names]&.include?(rule.name.to_s)
+                contested_uri = if plan[:contested_names]&.include?(name)
                                   child_type_uri(attr, register)
                                 end
-                elements = deferred_elements(value, rule, buckets,
+                elements = deferred_elements(value, name, buckets,
                                              contested_uri)
                 next if elements.empty?
 
@@ -330,7 +335,7 @@ module Lutaml
                          attr.collection? ? results : results.first)
                 end
               when :collection_cb
-                values = grouped[rule.name.to_s].to_a.map do |item|
+                values = grouped[name].to_a.map do |item|
                   item&.string_value
                 end
                 values = mapped_capture_values(values, rule)
@@ -344,7 +349,7 @@ module Lutaml
                 values = if tag
                            tagged[tag].to_a.map(&:string_value)
                          else
-                           native_collection(value, rule.name.to_s)
+                           native_collection(value, name)
                          end
                 values = mapped_capture_values(values, rule) unless values.nil?
                 unless values.nil?
@@ -354,28 +359,26 @@ module Lutaml
                 spellings ||= Hash.new { |h, k| h[k] = [] }
                 spellings[[rule, attr]] << grouped[spelling.to_s].to_a
               when :nested
-                child_type = row_type || attr.type(register)
-                child_plan = PlanCompiler.compile(child_type, register)
-                selected, = child_bucket(buckets, rule, child_plan,
-                                            contested_name?(plan, rule))
-                if selected && plan[:contested_names]&.include?(rule.name.to_s)
+                child_type, child_plan, child_register, contested = row_memo[idx]
+                selected = child_selection(buckets, name, child_plan, contested)
+                if selected && contested
                   # Contested name: the walk's grouped values cross-echo
                   # every same-name element into every row — dispatch
                   # per source node instead (the walk is row-scoped).
                   items = selected.map do |n|
                     call(child_type, child_plan,
                          child_plan[:descriptor].walk(n), node: n,
-                                                          register: register)
+                                                          register: child_register)
                   end
                 else
-                  values = grouped.fetch(rule.name.to_s, [])
+                  values = grouped.fetch(name, [])
                   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: register)
+                           node: cursor && cursor[i], register: child_register)
                     end
                 end
                 next if items.empty?
@@ -411,7 +414,11 @@ module Lutaml
           # hydration). Ordered children only land here without a node.
           def interpret_deferred(model_class, plan, value, instance, node = nil,
                                  buckets = nil)
-            plan[:rows].each do |rule, attr, kind, _spelling, _delegate|
+            plan[:rows].each_with_index do |row, idx|
+              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)
@@ -437,13 +444,13 @@ module Lutaml
                 # concatenated).
                 instance.public_send(:"#{attr.name}=", runs.join)
               when :raw
-                raws = raw_strings(value, rule)
+                raws = raw_strings(value, wire_name)
                 next if raws.empty?
 
                 instance.public_send(:"#{attr.name}=",
                                      attr.collection? ? raws : raws.first)
               when :custom_method
-                elements = deferred_elements(value, rule, buckets)
+                elements = deferred_elements(value, wire_name, buckets)
                 next if elements.empty?
 
                 args = attr.collection? ? elements : elements.first
@@ -453,7 +460,7 @@ module Lutaml
               when :ordered_deferred
                 next if node # hydrated natively in children_kwargs
 
-                results = deferred_elements(value, rule, buckets).map do |element|
+                results = deferred_elements(value, wire_name, buckets).map do |element|
                   attr.cast(element, :xml, register,
                             lutaml_parent: instance,
                             lutaml_root: instance.lutaml_root || instance)
@@ -496,7 +503,7 @@ module Lutaml
                   attr.collection? ? results : results.first,
                 )
               when :polymorphic
-                results = deferred_elements(value, rule, buckets).map do |element|
+                results = deferred_elements(value, wire_name, buckets).map do |element|
                   attr.cast(element, :xml, register,
                             polymorphic: rule.polymorphic,
                             lutaml_parent: instance,
@@ -515,16 +522,16 @@ module Lutaml
           # construction only, no parse), falling back to a fragment
           # parse of the captured subtree when no node is available.
           # Both lists are document-ordered for the row's name.
-          def deferred_elements(value, rule, buckets, contested_uri = nil)
-            return raw_strings(value, rule).map { |raw| fragment_element(raw) } unless buckets
+          def deferred_elements(value, name, buckets, contested_uri = nil)
+            return raw_strings(value, name).map { |raw| fragment_element(raw) } unless buckets
 
-            nodes = buckets[rule.name.to_s]
+            nodes = buckets[name]
             return [] unless nodes
 
             if contested_uri
               # Contested name: bind only the (URI, local) matches —
               # the type's own mapping namespace is the row identity.
-              nodes = buckets[[contested_uri, rule.name.to_s]] || []
+              nodes = buckets[[contested_uri, name]] || []
             end
             nodes.map { |n| bridge_element(n) }
           end
@@ -603,11 +610,11 @@ module Lutaml
             nil
           end
 
-          def raw_strings(value, rule)
+          def raw_strings(value, name)
             out = []
             value.count.times do |idx|
               child = value.at(idx)
-              if child.name == rule.name.to_s && child.kind == :raw
+              if child.name == name && child.kind == :raw
                 out << child.string_value
               end
             end
@@ -693,27 +700,46 @@ module Lutaml
             buckets
           end
 
-          # (URI, local) child identity — the interpretive matcher's
-          # typed-element dispatch: same-name rows in different
-          # namespaces bind by the child type's exact URI (w14:docId vs
-          # w15:docId under one model). Only CONTESTED names dispatch
-          # exactly — a uniquely-named row binds the whole name bucket
-          # leniently (any qualification), and the uri-keyed view is
-          # built only for plans that carry contested names. Returns
-          # [selected, all] where all is the name bucket (aligned with
-          # the walk's grouped values for position filtering).
-          def child_bucket(buckets, rule, child_plan, contested)
-            name = rule.name.to_s
-            all = buckets ? buckets[name] : nil
-            return [all, all] unless buckets && all && contested
+          # Selected source nodes for a child row: contested names
+          # dispatch by (URI, local); every other row binds the whole
+          # name bucket leniently (any qualification). The pair form
+          # this replaces allocated a fresh array per row per node on
+          # the ordered walk (niso gate).
+          def child_selection(buckets, name, child_plan, contested)
+            all = buckets && buckets[name]
+            return all unless buckets && all && contested
 
             tree_ns = child_plan[:tree][:ns]
             exact_uri = tree_ns.is_a?(Hash) ? tree_ns[:exact] : tree_ns
-            if exact_uri
-              qualified = buckets[[exact_uri, name]]
-              return [qualified || [], all]
+            exact_uri ? (buckets[[exact_uri, name]] || []) : all
+          end
+
+          # Per-(plan, register) child-row tuples, computed once and
+          # reused across every node the walk hands this plan: the
+          # per-node type lookup, compile hit, child register
+          # resolution, and contested flag were each a measurable slice
+          # of the ordered-lane allocation profile (niso gate).
+          def child_row_plans(plan, register)
+            plan[:child_row_memo] ||= {}
+            plan[:child_row_memo][register] ||= plan[:rows].map do |rule, attr, kind, _spelling, _delegate, row_type|
+              next nil unless CHILD_ROW_KINDS.include?(kind)
+
+              child_type = row_type || attr.type(register)
+              child_plan = PlanCompiler.compile(child_type, register)
+              child_register = Lutaml::Model::Register.resolve_for_child(
+                child_type, register
+              )
+              [child_type, child_plan, child_register,
+               contested_name?(plan, rule)]
+            end
+          end
+
+          # Plan-frozen wire names: rule.name.to_s minted a fresh string
+          # per row per node in the hot loop.
+          def row_wire_names(plan)
+            plan[:row_wire_names] ||= plan[:rows].map do |rule, _attr, _kind, _spelling, _delegate, _row_type|
+              rule.name.to_s
             end
-            [all, all]
           end
         end
       end

data/lib/lutaml/xml/leptris.rb

@@ -19,11 +19,20 @@ module Lutaml
       # answers nil — the opt-out protocol.
       MIN_LEPTRIS_VERSION = "1.9.336.0"
 
+      # Memoized: the compiler consults this on every cache hit (per
+      # child row per node), and the comparison minted a Gem::Version
+      # per call — visible in the niso ordered-lane allocation profile.
+      # The loaded gem cannot change mid-process.
       def self.plan_path_compatible?
-        return false unless defined?(Gem)
+        return @plan_path_compatible if defined?(@plan_path_compatible)
 
-        spec = Gem.loaded_specs["leptris"]
-        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_VERSION)
+        @plan_path_compatible =
+          if defined?(Gem)
+            spec = Gem.loaded_specs["leptris"]
+            spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_VERSION)
+          else
+            false
+          end
       end
 
       autoload :NativeEmission, "lutaml/xml/leptris/native_emission"

data/spec/lutaml/xml/adapter/empty_document_diagnostics_spec.rb

@@ -10,15 +10,24 @@ require "lutaml/xml/adapter/nokogiri_adapter"
 # must surface in the raised message — otherwise the error names the
 # input's emptiness while the input is neither empty nor the problem
 # (lutaml-model#956).
+#
+# moxml#369 changed the recoverable-malformation contract: the leptris
+# adapter's non-strict parse now RECOVERS (the engine's recover mode,
+# leptris#1660) and returns the best-effort tree instead of failing —
+# a mismatched closer yields a document, not a raise. Only inputs with
+# nothing to recover into (whitespace-only) still reach the guard,
+# carrying the recovery diagnostic.
 RSpec.describe "empty-document errors surface engine parse diagnostics" do
   describe Lutaml::Xml::Adapter::LeptrisAdapter do
-    it "appends the engine diagnostic when the parse failed" do
-      expect do
-        described_class.parse("<root><a>x</b></root>")
-      end.to raise_error(Lutaml::Model::InvalidFormatError) do |error|
-        expect(error.message).to include("the XML engine reported:")
-        expect(error.message).to include("XML parse error at byte 14")
+    it "returns a recovered tree for recoverable malformations (moxml#369)" do
+      version = Gem.loaded_specs.fetch("moxml").version
+      recovered = version >= Gem::Version.new("0.5.131")
+      unless recovered
+        skip "moxml predates the recover-mode wiring (0.5.131)"
       end
+
+      doc = described_class.parse("<root><a>x</b></root>")
+      expect(doc.root.name).to eq("root")
     end
 
     it "reports the engine diagnostic for whitespace-only input" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.105
+  version: 0.8.106
 platform: ruby
 authors:
 - Ribose Inc.