lutaml-model 0.8.63 → 0.8.65

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e60ce4a1bedec13a3b778b0afea4c9be5c4779f721916bfafeb151e3bd8f8c1e
-  data.tar.gz: b6f519fabe6c9dc9c0c5edeb871d6afcc23d6439eff433b15b74b532b1a633d7
+  metadata.gz: a8bbc0a4da8114a582ee834a333a8614ca1051747296a1e967eb36f47ef68b48
+  data.tar.gz: ec01b4058ae9ce9d400f229ae4f116bcdde25cdd015e3b96ff3e2b39af62ff10
 SHA512:
-  metadata.gz: 646c4cfdfb4dc395f5f339332eb214b0d4cba7bf31710884357e5d8519db8825e0a8e937824f268bac8642ea5d23a7fee75686988b9d3a54923f508e50aaa3c0
-  data.tar.gz: d738e9c618790d6575691acc7349991f1b4f28986947e75a3dc40a883978cbc3ce7f6ef28021b7c85f822037c6c63137ed22f1930fe6aba36dd0b266f84a451b
+  metadata.gz: 494b45969f4e8f67e5f79fe09eb6e1630e5b04109fe46b13210cc8dfe455a11e7b7d7955a91ae2132c037c7e53d21fb09c0462a55899cccaafc4d4e5b609bccd
+  data.tar.gz: 6694a345fda4b371988fab2af07b9311b7eed87f2e61a696eab7c2a247ba04950bbb93439b1019a27903dbfcf8c5815067f2d3449a41affe2cdb21a6a3deb583

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.63"
+    VERSION = "0.8.65"
   end
 end

data/lib/lutaml/xml/adapter/xml_parser.rb

@@ -34,16 +34,22 @@ module Lutaml
         # Recover-mode parsing must never masquerade input truncation as
         # success.
         #
-        # libxml2 (the Nokogiri backend) caps its input buffer at 10 MB;
-        # longer documents trip a fatal "Resource limit exceeded: Buffer
-        # size limit exceeded, try XML_PARSE_HUGE" error mid-input. In
-        # recover mode Nokogiri records that error on the document and
+        # moxml releases before 0.5.84 parsed Nokogiri documents without
+        # XML_PARSE_HUGE, so libxml2 capped its input buffer at 10 MB;
+        # longer documents tripped a fatal "Resource limit exceeded:
+        # Buffer size limit exceeded, try XML_PARSE_HUGE" error mid-input.
+        # In recover mode Nokogiri records that error on the document and
         # returns the partial tree, so every node past the limit silently
         # vanishes (lutaml-model#871). A resource-limit fatal means the
         # engine stopped early with input left — refuse to deserialize the
         # partial document instead of dropping trailing content without a
         # trace.
         #
+        # moxml 0.5.84 and later always pass XML_PARSE_HUGE, so the
+        # Nokogiri path no longer truncates and this guard stays silent;
+        # it remains for older moxml releases and for any other adapter
+        # that reports the resource-limit family.
+        #
         # Other recover-mode fatals (e.g. an XML declaration after leading
         # whitespace) do not drop content and keep the long-standing
         # recover behavior; only the resource-limit family is truncating.

data/lib/lutaml/xml/plan_compiler.rb

@@ -36,6 +36,17 @@ module Lutaml
 
       class << self
         def compile(model_class, register)
+          # A child model's declared lutaml_default_register takes
+          # precedence over the ambient (parent) register — the same
+          # contract the interpretive path applies through
+          # Register.resolve_for_child. Without this, plan compilation
+          # resolves the child's symbol attribute types in the parent
+          # context and raises UnknownTypeError for ids registered only
+          # in the child's own register (#876).
+          register = Lutaml::Model::Register.resolve_for_child(
+            model_class, register
+          )
+
           key = [model_class, register]
           return PLAN_CACHE[key] if PLAN_CACHE.key?(key)
 

data/lib/lutaml/xml/plan_hydrator.rb

@@ -20,11 +20,21 @@ module Lutaml
         # node: the parsed source element (leptris); ordered/mixed
         #   plans rebuild element_order from it and ordered children
         #   hydrate natively against their own nodes
-        def call(model_class, plan, value, parent: nil, node: nil)
+        def call(model_class, plan, value, parent: nil, node: nil,
+                 register: nil)
+          # The child model's declared lutaml_default_register takes
+          # precedence over the ambient register — the same
+          # resolve_for_child contract the interpretive path applies.
+          # Without it, hydration resolves the child's symbol attribute
+          # types in the parent context and raises UnknownTypeError
+          # for ids registered only in the child's register (#876).
+          register = Lutaml::Model::Register.resolve_for_child(
+            model_class, register || Lutaml::Model::Config.default_register
+          )
           buckets = node && plan[:needs_nodes] ? element_buckets(node) : nil
           attr_kwargs = attributes_kwargs(plan, value, node)
           child_kwargs, children, delegates =
-            children_kwargs(model_class, plan, value, buckets)
+            children_kwargs(model_class, plan, value, buckets, register)
           plan[:collection_defaults].each do |name|
             next if attr_kwargs.key?(name) || child_kwargs.key?(name)
 
@@ -80,7 +90,9 @@ module Lutaml
         # — child instances come back so the caller can decorate
         # parent/root links once the parent exists; delegate values
         # wait for the instance (their target object must exist).
-        def children_kwargs(_model_class, plan, value, buckets = nil)
+        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])
           buckets = nil unless buckets && plan[:needs_nodes]
           kwargs = {}
@@ -126,7 +138,8 @@ module Lutaml
                 child_plan = PlanCompiler.compile(child_type, register)
                 items = buckets.fetch(rule.name.to_s, []).map do |n|
                   call(child_type, child_plan,
-                       child_plan[:descriptor].walk(n), node: n)
+                       child_plan[:descriptor].walk(n), node: n,
+                                                        register: register)
                 end
                 unless items.empty?
                   children.concat(items)
@@ -162,7 +175,7 @@ module Lutaml
               items = grouped.fetch(rule.name.to_s, []).each_with_index
                 .map do |v, i|
                   call(child_type, child_plan, v,
-                       node: cursor && cursor[i])
+                       node: cursor && cursor[i], register: register)
                 end
               next if items.empty?
 

data/lib/lutaml/xml/plan_serializer.rb

@@ -25,16 +25,24 @@ module Lutaml
 
       class << self
         # plan: the compiler's entry for instance's class
-        def call(instance, plan)
+        def call(instance, plan, register = nil)
+          # The child model's declared lutaml_default_register takes
+          # precedence over the ambient register — the resolve_for_child
+          # contract (#876); without it, child plans and attribute
+          # serialization resolve in the parent context.
+          register = Lutaml::Model::Register.resolve_for_child(
+            instance.class,
+            register || Lutaml::Model::Config.default_register,
+          )
           return nil if plan[:ordered] && instance.element_order.nil?
 
           doc = ::Leptris::XML::Document.create
           root = doc.create_element(plan[:tree][:name])
           doc.root = root
           if plan[:ordered]
-            build_ordered(root, instance, plan, doc)
+            build_ordered(root, instance, plan, doc, register)
           else
-            build(root, instance, plan, doc)
+            build(root, instance, plan, doc, register)
           end
           doc.to_xml(indent: 2, no_decl: true)
         end
@@ -54,8 +62,9 @@ module Lutaml
           Lutaml::Model::Config.default_register
         end
 
-        def build(element, instance, plan, doc)
-          write_attributes(element, instance, plan)
+        def build(element, instance, plan, doc, reg = nil)
+          reg ||= register
+          write_attributes(element, instance, plan, reg)
           plan[:rows].each do |rule, attr, kind, spelling, delegate|
             value = value_of(instance, attr, delegate)
             next unless rule.render?(value, instance)
@@ -67,24 +76,25 @@ module Lutaml
               # as the interpretive writer does.
               Array(value).each do |item|
                 add_leaf(element, row_name(rule, spelling),
-                         attr.serialize(item, :xml, register), doc,
+                         attr.serialize(item, :xml, reg), doc,
                          attrs: rule.when_attribute)
               end
             when :collection_native, :collection_cb
               Array(value).each do |item|
                 add_leaf(element, rule.name.to_s,
-                         attr.serialize(item, :xml, register), doc,
+                         attr.serialize(item, :xml, reg), doc,
                          attrs: rule.when_attribute)
               end
             when :nested, :ordered_deferred
               Array(value).each do |item|
-                child_plan = PlanCompiler.compile(item.class, register)
+                child_plan = PlanCompiler.compile(item.class, reg)
                 child = element.create_child(child_plan[:tree][:name])
                 if child_plan[:ordered]
-                  return nil unless build_ordered(child, item, child_plan, doc)
+                  return nil unless build_ordered(child, item, child_plan,
+                                                  doc, reg)
 
                 else
-                  build(child, item, child_plan, doc)
+                  build(child, item, child_plan, doc, reg)
                 end
               end
             when :raw
@@ -103,8 +113,9 @@ module Lutaml
         # the model are reflected; element_order text is the fallback.
         # PIs drop (interpretive parity). Returns nil when a nested
         # ordered child lacks element_order (caller falls back).
-        def build_ordered(element, instance, plan, doc)
-          write_attributes(element, instance, plan)
+        def build_ordered(element, instance, plan, doc, reg = nil)
+          reg ||= register
+          write_attributes(element, instance, plan, reg)
           rows_by_name = {}
           plan[:rows].each do |rule, attr, kind, spelling, delegate|
             next unless rule.name
@@ -162,7 +173,7 @@ module Lutaml
 
                 element_indices[object.name] += 1
                 add_leaf(element, object.name,
-                         attr.serialize(items[index], :xml, register), doc)
+                         attr.serialize(items[index], :xml, reg), doc)
               when :nested, :ordered_deferred
                 item = if attr.collection?
                          index = element_indices[object.name]
@@ -173,18 +184,19 @@ module Lutaml
                        end
                 next unless item
 
-                child_plan = PlanCompiler.compile(item.class, register)
+                child_plan = PlanCompiler.compile(item.class, reg)
                 child = element.create_child(child_plan[:tree][:name])
                 if child_plan[:ordered]
-                  return nil unless build_ordered(child, item, child_plan, doc)
+                  return nil unless build_ordered(child, item, child_plan,
+                                                  doc, reg)
                 else
-                  build(child, item, child_plan, doc)
+                  build(child, item, child_plan, doc, reg)
                 end
               when :raw
                 element.add_child(value.to_s) unless value.nil?
               when :scalar
                 add_leaf(element, object.name,
-                         attr.serialize(value, :xml, register), doc)
+                         attr.serialize(value, :xml, reg), doc)
               end
             end
           end
@@ -193,7 +205,7 @@ module Lutaml
 
         # Attributes in document order when the instance recorded it
         # (parsed models), else plan row order.
-        def write_attributes(element, instance, plan)
+        def write_attributes(element, instance, plan, _reg = nil)
           recorded = instance.attribute_order
           if recorded && !recorded.empty?
             by_name = {}
@@ -213,7 +225,7 @@ module Lutaml
           end
         end
 
-        def write_attribute(element, instance, name, entry)
+        def write_attribute(element, instance, name, entry, reg = nil)
           return unless entry
 
           _rule, attr, delegate = entry
@@ -221,7 +233,7 @@ module Lutaml
           return if value.nil?
 
           element.set_attribute(name,
-                                attr.serialize(value, :xml, register).to_s)
+                                attr.serialize(value, :xml, reg || register).to_s)
         end
 
         # Partition rows (#88) re-emit their discriminator: the wire

data/lutaml-model.gemspec

@@ -38,7 +38,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency "canon"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
-  spec.add_dependency "moxml", "~> 0.5.56"
+  # 0.5.84 always passes XML_PARSE_HUGE to libxml2: very large documents
+  # parse completely instead of being silently truncated at the 10 MB
+  # input-buffer cap (lutaml-model#871).
+  spec.add_dependency "moxml", "~> 0.5.84"
   spec.add_dependency "ostruct"
   spec.add_dependency "rubyzip", "~> 3.4"
   spec.add_dependency "thor"

data/spec/lutaml/xml/adapter/{recovered_fatal_parse_spec.rb → over_cap_parse_spec.rb}

@@ -6,15 +6,16 @@ require "lutaml/model"
 require "lutaml/xml"
 require "lutaml/xml/adapter/nokogiri_adapter"
 
-# Regression tests for lutaml-model#871.
+# Regression coverage for lutaml-model#871: very large documents must
+# deserialize completely, with no silent truncation and no data loss.
 #
-# libxml2 (the Nokogiri backend) caps its input buffer at 10 MB. Parsing a
-# longer document in recover mode records a FATAL "Resource limit exceeded:
-# Buffer size limit exceeded, try XML_PARSE_HUGE" error on the document and
-# returns the partial tree, so every node past the cap silently vanishes.
-# XmlParser now refuses documents whose parse_errors carry a fatal error
-# instead of deserializing the truncated input.
-RSpec.describe "recovered fatal parse errors" do
+# libxml2's default mode caps its input buffer at 10 MB and, in recover
+# mode, silently drops every node past the cap. moxml 0.5.84 always
+# passes XML_PARSE_HUGE, so the Nokogiri path now parses past the cap.
+# XmlParser additionally refuses recovered parses that report the
+# resource-limit fatal family, which still protects moxml releases that
+# truncate.
+RSpec.describe "parsing documents past libxml2's 10 MB buffer cap" do
   let(:annex_class) do
     Class.new(Lutaml::Model::Serializable) do
       attribute :id, :string
@@ -56,23 +57,28 @@ RSpec.describe "recovered fatal parse errors" do
     build_document(chunk_count: 6, chunk_size: 1_700_000, with_tail: true)
   end
 
-  it "hits the libxml2 buffer cap in recover mode past 10 MB" do
+  it "confirms libxml2's default mode still trips the buffer cap past 10 MB" do
     errors = Nokogiri::XML(over_cap_document) { |config| config.recover.nonet }.errors
 
     expect(errors.map(&:message).join("\n")).to match(/\bFATAL:/)
   end
 
-  it "raises instead of silently truncating on the nokogiri path" do
+  it "parses over-cap documents completely on the nokogiri path" do
     Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
-      expect { root_class.from_xml(over_cap_document) }
-        .to raise_error(Lutaml::Model::InvalidFormatError, /resource limit.*truncated/m)
+      model = root_class.from_xml(over_cap_document)
+
+      expect(model.annexes.map(&:id)).to eq(
+        ["annex0", "annex1", "annex2", "annex3", "annex4", "annex5",
+         "annex-tail-marker"],
+      )
     end
   end
 
-  it "raises from the adapter layer directly" do
+  it "returns the complete tree from the adapter layer" do
     Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
-      expect { Lutaml::Xml::Adapter::NokogiriAdapter.parse(over_cap_document) }
-        .to raise_error(Lutaml::Model::InvalidFormatError, /XML_PARSE_HUGE/)
+      document = Lutaml::Xml::Adapter::NokogiriAdapter.parse(over_cap_document)
+
+      expect(document.root.children.count).to eq(7)
     end
   end
 
@@ -86,7 +92,7 @@ RSpec.describe "recovered fatal parse errors" do
     end
   end
 
-  it "still parses smaller documents without any fatal-error handling" do
+  it "keeps parsing smaller documents unchanged" do
     Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
       model = root_class.from_xml(
         build_document(chunk_count: 2, chunk_size: 500_000, with_tail: true),

data/spec/lutaml/xml/cross_register_plan_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Cross-register embedding on the plan paths (#876)" do
+  before do
+    stub_const("CrossRegister876", Module.new)
+    stub_const("CrossRegister876::Part", part_class)
+    stub_const("CrossRegister876::Widget", widget_class)
+    stub_const("Host876", host_class)
+
+    ctx = Lutaml::Model::GlobalContext.create_context(
+      id: :crossregister876, registry: Lutaml::Model::TypeRegistry.new,
+    )
+    ctx.registry.register(:part, CrossRegister876::Part)
+    ctx.registry.register(:widget, CrossRegister876::Widget)
+  end
+
+  let(:part_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      def self.lutaml_default_register
+        :crossregister876
+      end
+
+      xml do
+        element "part"
+      end
+    end
+  end
+
+  let(:widget_class) do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      def self.lutaml_default_register
+        :crossregister876
+      end
+
+      attribute :part_value, :part, collection: true
+
+      xml do
+        element "widget"
+        ordered
+        map_element "part", to: :part_value
+      end
+    end
+    klass
+  end
+
+  let(:host_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :widget, CrossRegister876::Widget
+
+      xml do
+        element "host"
+        map_element "widget", to: :widget
+      end
+    end
+  end
+
+  let(:xml) { "<host><widget><part/></widget></host>" }
+
+  it "resolves the child's symbol types through the child register" do
+    model = Host876.from_xml(xml)
+    expect(model.widget.part_value.first).to be_a(CrossRegister876::Part)
+  end
+
+  it "round-trips through both the plan serializer and back" do
+    model = Host876.from_xml(xml)
+    xml_out = model.to_xml
+    expect(xml_out).to include("<widget>")
+    expect(xml_out).to include("<part/>")
+
+    reparsed = Host876.from_xml(xml_out)
+    expect(reparsed.widget.part_value.first).to be_a(CrossRegister876::Part)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.63
+  version: 0.8.65
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-25 00:00:00.000000000 Z
+date: 2026-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -92,14 +92,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.56
+        version: 0.5.84
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.56
+        version: 0.5.84
 - !ruby/object:Gem::Dependency
   name: ostruct
   requirement: !ruby/object:Gem::Requirement
@@ -1901,8 +1901,8 @@ files:
 - spec/lutaml/xml/adapter/nokogiri_adapter_spec.rb
 - spec/lutaml/xml/adapter/oga_adapter_spec.rb
 - spec/lutaml/xml/adapter/order_spec.rb
+- spec/lutaml/xml/adapter/over_cap_parse_spec.rb
 - spec/lutaml/xml/adapter/ox_adapter_spec.rb
-- spec/lutaml/xml/adapter/recovered_fatal_parse_spec.rb
 - spec/lutaml/xml/adapter/rexml_adapter_spec.rb
 - spec/lutaml/xml/adapter/xml_namespace_spec.rb
 - spec/lutaml/xml/adapter_loader_spec.rb
@@ -1916,6 +1916,7 @@ files:
 - spec/lutaml/xml/conformance/xml_schema_instance_spec.rb
 - spec/lutaml/xml/content_model_validation_spec.rb
 - spec/lutaml/xml/cross_class_dispatch_spec.rb
+- spec/lutaml/xml/cross_register_plan_spec.rb
 - spec/lutaml/xml/data_model_spec.rb
 - spec/lutaml/xml/decisions/decision_engine_spec.rb
 - spec/lutaml/xml/decisions/decision_spec.rb