lutaml-model 0.8.56 → 0.8.106

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -33,15 +33,18 @@ RSpec.describe "XML plan fast path" do
   around do |example|
     old = Lutaml::Model::Config.instance.xml_plan_fast_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
   end
 
   # Real-corpus crash (niso-jats): sec-in-sec nesting is a
-  # self-referential model — compile must resolve it to nil instead of
-  # recursing to SystemStackError.
-  it "opts self-referential models out instead of recursing" do
+  # self-referential model — compile must not recurse to
+  # SystemStackError. The cycle point defers the child ROW (per-node
+  # interpretive islands) instead of opting the model out.
+  it "defers the self-referential child row instead of recursing" do
     node = Class.new(Lutaml::Model::Serializable) do
       attribute :text, :string
       xml do
@@ -57,17 +60,21 @@ RSpec.describe "XML plan fast path" do
     end
     stub_const("PlanFastPath::SelfRef", node)
 
-    expect(Lutaml::Xml::PlanCompiler.compile(node, :default)).to be_nil
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(node, :default)
+    expect(plan).not_to be_nil
+    expect(plan[:rows].map { |r| r[2] }).to include(:child_deferred)
 
     xml = "<n>#{'<n>t</n>' * 200}</n>"
     parsed = node.from_xml(xml)
     expect(parsed).to be_a(node)
   end
 
-  # lutaml-model#744: attribute plan rows are local-name keyed — a
-  # type-namespaced attribute (xmi:type vs type) must take the
-  # interpretive matcher, or the namespaced value is silently lost.
-  it "opts models with type-namespaced attributes out to the interpretive path" do
+  # lutaml-model#744/#758: a local name claimed by BOTH a
+  # type-namespaced attribute row and a plain row stays interpretive —
+  # the walk's ns form :none matches any qualification, so the plain
+  # row would capture the qualified spelling too. The interpretive
+  # matcher dispatches the spellings correctly.
+  it "opts shared-local-name attribute claims out to the interpretive path" do
     xmi_ns = Class.new(Lutaml::Xml::Namespace) do
       uri "http://www.omg.org/spec/XMI/20131001"
       prefix_default "xmi"
@@ -94,7 +101,7 @@ RSpec.describe "XML plan fast path" do
 
     expect(parsed.xmi_type).to eq("uml:Parameter")
     expect(parsed.classifier_type).to eq("EAnone_void")
-    expect(Lutaml::Xml::PlanCompiler.compile(parameter, :default)).to be_nil
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(parameter, :default)).to be_nil
   end
 
   it "is on by default and can be disabled" do
@@ -156,7 +163,7 @@ RSpec.describe "XML plan fast path" do
       end
     end
 
-    expect(Lutaml::Xml::PlanCompiler.compile(klass,
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(klass,
                                              Lutaml::Model::Config.default_register)).not_to be_nil
     expect(klass.from_xml("<doc><note>hi</note></doc>").note).to eq("HI")
   end
@@ -223,14 +230,14 @@ RSpec.describe "XML plan fast path" do
       end
     end
 
-    expect(Lutaml::Xml::PlanCompiler.compile(klass,
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(klass,
                                              Lutaml::Model::Config.default_register)).not_to be_nil
     parsed = klass.from_xml("<doc><note>hi</note></doc>")
     expect(parsed.tgt.note).to eq("hi")
   end
 
   it "routes a single collection row natively (hybrid routing)" do
-    plan = Lutaml::Xml::PlanCompiler.compile(
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
       Class.new(Lutaml::Model::Serializable) do
         attribute :xs, :string, collection: true
         attribute :name, :string
@@ -400,7 +407,7 @@ RSpec.describe "XML plan fast path" do
           map_element "para", to: :para
         end
       end
-      plan = Lutaml::Xml::PlanCompiler.compile(
+      plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
         doc_class, Lutaml::Model::Config.default_register
       )
       expect(plan).not_to be_nil
@@ -623,7 +630,7 @@ RSpec.describe "XML plan fast path" do
       expect(req.guidance.map(&:text)).to eq(%w[g1 g2])
       expect(req.purpose.map(&:text)).to eq(["p1"])
 
-      expect(Lutaml::Xml::PlanCompiler.compile(partitioned,
+      expect(Lutaml::Xml::Leptris::PlanCompiler.compile(partitioned,
                                                :default)).to be_nil
     end
 
@@ -688,4 +695,105 @@ RSpec.describe "XML plan fast path" do
       expect(parsed.to_xml).to eq(xml)
     end
   end
+
+  # lutaml-model#847: the plan serializer does not emit namespace
+  # declarations — namespaced models must serialize through the
+  # interpretive writer even standalone, or the element xmlns is lost.
+  it "falls back to the interpretive writer for namespaced models" do
+    ns = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/ord847"
+    end
+    stub_const("PlanFastPath::Ord847Ns", ns)
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :value, :boolean
+      xml do
+        element "updateFields"
+        namespace PlanFastPath::Ord847Ns
+        map_attribute "val", to: :value
+      end
+    end
+    stub_const("PlanFastPath::UpdateFields847", klass)
+
+    expect(klass.new(value: false).to_xml).to include("http://example.com/ord847")
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
+      klass, Lutaml::Model::Config.default_register
+    )
+    expect(plan[:namespaced]).to be(true)
+  end
+
+  # lutaml-model#850: a sole-claimant attribute rule binds any
+  # qualification on the plan path (#754/#790 parity with the
+  # interpretive matcher) — the qualified spelling is read off the
+  # source node when the exact (URI, local) walk capture misses.
+  it "binds qualified spellings to sole-claimant attribute rules" do
+    ns = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/w"
+      prefix_default "w"
+    end
+    stub_const("PlanFastPath::W850Ns", ns)
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :value, :boolean
+      xml do
+        element "b"
+        namespace PlanFastPath::W850Ns
+        map_attribute "val", to: :value
+      end
+    end
+    stub_const("PlanFastPath::Sole850", klass)
+
+    doc = %(<w:b xmlns:w="http://example.com/w" w:val="false"/>)
+    expect(klass.from_xml(doc).value).to be(false)
+    expect(klass.from_xml(
+      %(<b xmlns="http://example.com/w" val="false"/>),
+    ).value).to be(false)
+  end
+
+  # lutaml-model#856: a deferred content row with no captured runs
+  # must still mark its attribute set — the interpretive pipeline
+  # marks every applied rule (model_transform apply). Without the
+  # mark, the serializer's default-suppression drops a mapped reader
+  # that derives content from other attributes.
+  it "renders derived content readers when no text was captured" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :content, :string
+      attribute :revision_date, :string
+      attribute :draft, :string
+
+      xml do
+        element "version"
+        map_content to: :content
+        map_element "revision-date", to: :revision_date
+        map_element "draft", to: :draft
+      end
+
+      define_method(:content) do
+        return @content if @content && !@content.empty?
+
+        parts = [@draft, @revision_date].compact
+        case parts.size
+        when 2 then "#{@draft} (#{@revision_date})"
+        when 1 then parts.first
+        end
+      end
+    end
+    stub_const("PlanFastPath::DerivedContent856", klass)
+
+    parsed = nil
+    Lutaml::Model::Config.with_adapter(xml: :leptris) do
+      parsed = klass.from_xml(
+        "<version><revision-date>1994-01-01</revision-date><draft>PD</draft></version>",
+      )
+      expect(parsed.using_default?(:content)).to be(false)
+      expect(parsed.to_xml).to eq(
+        "<version><revision-date>1994-01-01</revision-date>" \
+        "<draft>PD</draft>PD (1994-01-01)</version>",
+      )
+    end
+    Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      expect(parsed.to_xml).to eq(
+        "<version><revision-date>1994-01-01</revision-date>" \
+        "<draft>PD</draft>PD (1994-01-01)</version>",
+      )
+    end
+  end
 end

data/spec/lutaml/xml/plan_namespaced_serialize_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan serializer: namespaced models" do
+  # lutaml-model#847: the plan path used to refuse namespaced models
+  # outright (the xmlns dropped). The DOM emission now spells prefixed
+  # names, hoists every distinct (prefix, uri) declaration exactly once
+  # onto the output root, and prefixes type-namespaced attribute rows —
+  # byte-equal with the interpretive writer.
+
+  let(:wml_ns) do
+    Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/gate2/wml"
+      prefix_default "w"
+    end
+  end
+
+  let(:val_type) do
+    stub_const("Gate2Ns::WmlNs", wml_ns)
+    type = Class.new(Lutaml::Model::Type::String) do
+      include Lutaml::Xml::Type::Configurable
+
+      xml do
+        namespace Gate2Ns::WmlNs
+      end
+    end
+    stub_const("Gate2Ns::ValType", type)
+    type
+  end
+
+  let(:doc_class) do
+    val_type
+    body_class
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, Gate2Ns::ValType
+      attribute :body, Gate2Ns::Body
+
+      xml do
+        element "document"
+        namespace Gate2Ns::WmlNs
+        map_attribute "name", to: :name
+        map_element "body", to: :body
+      end
+    end
+    stub_const("Gate2Ns::Document", model)
+    model
+  end
+
+  let(:body_class) do
+    val_type
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :text, Gate2Ns::ValType, collection: true
+
+      xml do
+        element "body"
+        namespace Gate2Ns::WmlNs
+        map_element "t", to: :text
+      end
+    end
+    stub_const("Gate2Ns::Body", model)
+    model
+  end
+
+  let(:default_ns_model) do
+    ns = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/gate2/default"
+    end
+    stub_const("Gate2Ns::DefaultNs", ns)
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      xml do
+        element "root"
+        namespace Gate2Ns::DefaultNs
+        map_attribute "name", to: :name
+      end
+    end
+    stub_const("Gate2Ns::DefaultDoc", model)
+    model
+  end
+
+  around do |example|
+    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    Lutaml::Model::Config.instance.xml_plan_fast_path = true
+    Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+  ensure
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old
+  end
+
+  def plan_to_xml(klass, instance)
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
+      klass, Lutaml::Model::Config.default_register
+    )
+    Lutaml::Xml::Leptris::PlanSerializer.call(
+      instance, plan, Lutaml::Model::Config.default_register
+    )
+  end
+
+  it "emits prefixed names with the declaration exactly once" do
+    instance = doc_class.new(
+      name: "d1",
+      body: body_class.new(text: ["hello"]),
+    )
+
+    out = plan_to_xml(doc_class, instance)
+    expect(out).to include(%(xmlns:w="http://example.com/gate2/wml"))
+    expect(out.scan("xmlns:w=").count).to eq(1)
+    expect(out).to include("<w:document")
+    expect(out).to include("w:name=\"d1\"")
+    expect(out).to include("<w:body>")
+    expect(out).to include("<w:t>hello</w:t>")
+  end
+
+  # The plan path spells the type-namespaced attribute w:name=; the
+  # interpretive writer emits name= unprefixed (a long-standing
+  # interpretive serialize gap — the unprefixed form does not rebind
+  # to the (URI, local) rule on reparse). Element tree, declarations,
+  # and values are compared; the attribute spelling divergence is
+  # pinned by the round-trip example below.
+  it "matches the interpretive element tree and declarations" do
+    instance = doc_class.new(
+      name: "d1",
+      body: body_class.new(text: ["hello", "world"]),
+    )
+
+    interpretive = Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      instance.to_xml
+    end
+
+    plan_out = plan_to_xml(doc_class, instance)
+    expect(plan_out.sub(" w:name=\"d1\"", "")).to eq(
+      interpretive.sub(" name=\"d1\"", "").strip,
+    )
+  end
+
+  it "round-trips through the plan parse path" do
+    instance = doc_class.new(
+      name: "d1",
+      body: body_class.new(text: ["hello"]),
+    )
+    xml = plan_to_xml(doc_class, instance)
+
+    reparsed = doc_class.from_xml(xml)
+    expect(reparsed.name).to eq("d1")
+    expect(reparsed.body.text).to eq(["hello"])
+  end
+
+  it "spells default-namespace models unprefixed with xmlns on the root" do
+    instance = default_ns_model.new(name: "plain")
+
+    out = plan_to_xml(default_ns_model, instance)
+    expect(out).to include(%(xmlns="http://example.com/gate2/default"))
+    expect(out).to include("<root")
+    expect(out).not_to include("xmlns:xmlns")
+  end
+end

data/spec/lutaml/xml/plan_ns_less_document_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan fast path: namespace-less models on namespaced documents" do
+  # lutaml-model#932: elements (unlike attributes) inherit the default
+  # xmlns, so the walk's strict no-URI default dropped every child of a
+  # namespaced document for models that declare no namespace. The
+  # ns_lenient flag restores the interpretive matcher's behavior:
+  # children match by local name under any document qualification.
+
+  let(:child_class) do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :fileref, :string
+
+      xml do
+        element "imagedata"
+        map_attribute "fileref", to: :fileref
+      end
+    end
+    stub_const("NsLessDoc::Imagedata", klass)
+    klass
+  end
+
+  def define_parent
+    child_class
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :imagedata, NsLessDoc::Imagedata
+      attribute :content, :string, collection: true
+
+      xml do
+        element "imageobject"
+        map_element "imagedata", to: :imagedata
+        map_content to: :content
+      end
+    end
+    
+  end
+
+  around do |example|
+    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    Lutaml::Model::Config.instance.xml_plan_fast_path = true
+    Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+  ensure
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old
+  end
+
+  it "binds nested children under a default namespace" do
+    parent = define_parent
+    doc = '<imageobject xmlns="http://docbook.org/ns/docbook">' \
+          '<imagedata fileref="x.png"/></imageobject>' 
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "binds nested children under a prefixed namespace" do
+    parent = define_parent
+    doc = '<db:imageobject xmlns:db="http://docbook.org/ns/docbook">' \
+          '<db:imagedata fileref="x.png"/></db:imageobject>' 
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "keeps binding on namespace-less documents" do
+    parent = define_parent
+    doc = %(<imageobject><imagedata fileref="x.png"/></imageobject>)
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "binds nested children of mixed-content models under a default namespace" do
+    parent = define_parent
+    parent.xml do
+      element "imageobject"
+      mixed_content
+      map_content to: :content
+      map_element "imagedata", to: :imagedata
+    end
+    doc = '<imageobject xmlns="http://docbook.org/ns/docbook">' \
+          'text<imagedata fileref="x.png"/>tail</imageobject>' 
+
+    parsed = parent.from_xml(doc)
+    expect(parsed.imagedata.fileref).to eq("x.png")
+    expect(parsed.content).to include("text")
+  end
+end

data/spec/lutaml/xml/plan_partition_spec.rb

@@ -37,7 +37,7 @@ RSpec.describe "Plan fast path with when_attribute partitions" do
   end
 
   it "compiles the partitioned model with row tags" do
-    plan = Lutaml::Xml::PlanCompiler.compile(
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
       model, Lutaml::Model::Config.default_register
     )
     expect(plan).not_to be_nil

data/spec/lutaml/xml/plan_type_ns_attribute_spec.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan fast path: type-namespaced attribute rows" do
+  # Attribute identity is (URI, local) (lutaml-model#744). A map_attribute
+  # whose TYPE carries a namespace class used to opt the whole model out
+  # of the plan path; it now compiles into an exact-URI AttrPlan ns row
+  # (libleptris 1.9.289) with the sole-claimant lenient recovery keeping
+  # the interpretive exact-first-then-any-qualification precedence.
+
+  let(:wml_ns) do
+    Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/type-ns/wml"
+      prefix_default "w"
+    end
+  end
+
+  let(:val_type) do
+    stub_const("PlanTypeNsAttr::WmlNs", wml_ns)
+    type = Class.new(Lutaml::Model::Type::String) do
+      include Lutaml::Xml::Type::Configurable
+
+      xml do
+        namespace PlanTypeNsAttr::WmlNs
+      end
+    end
+    stub_const("PlanTypeNsAttr::ValType", type)
+    type
+  end
+
+  let(:klass) do
+    val_type
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :val, PlanTypeNsAttr::ValType
+
+      xml do
+        element "keepNext"
+        namespace PlanTypeNsAttr::WmlNs
+        map_attribute "val", to: :val
+      end
+    end
+    stub_const("PlanTypeNsAttr::KeepNext", model)
+    model
+  end
+
+  around do |example|
+    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    Lutaml::Model::Config.instance.xml_plan_fast_path = true
+    Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+  ensure
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old
+  end
+
+  it "compiles a model whose attribute type carries a namespace" do
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
+      klass, Lutaml::Model::Config.default_register
+    )
+
+    expect(plan).not_to be_nil
+    ns_row = plan[:tree][:attributes].find { |a| a[:name] == "val" }
+    expect(ns_row[:ns]).to include(exact: "http://example.com/type-ns/wml")
+    expect(ns_row[:ns][:prefix]).to eq("w")
+  end
+
+  it "binds the attribute from the type's namespace" do
+    doc = %(<w:keepNext xmlns:w="http://example.com/type-ns/wml" w:val="yes"/>)
+
+    expect(klass.from_xml(doc).val).to eq("yes")
+  end
+
+  # The interpretive matcher refuses an ambiguous local name outright:
+  # a foreign spelling alongside the canonical one binds nothing. The
+  # exact-URI row mirrors that refusal (lutaml-model#744).
+  it "refuses to bind when a foreign spelling accompanies the canonical one" do
+    doc = '<w:keepNext xmlns:w="http://example.com/type-ns/wml" ' \
+          'xmlns:f="http://example.com/foreign" val="foreign" w:val="canonical"/>'
+
+    expect(klass.from_xml(doc).val).to be_nil
+  end
+
+  # Interpretive parity: the plan path resolves exactly as the
+  # interpretive matcher (nokogiri) does on every spelling shape.
+  it "matches the interpretive path's resolution on all spelling shapes" do
+    canonical = %(<w:keepNext xmlns:w="http://example.com/type-ns/wml" w:val="yes"/>)
+    ambiguous = '<w:keepNext xmlns:w="http://example.com/type-ns/wml" ' \
+                'xmlns:f="http://example.com/foreign" val="foreign" w:val="canonical"/>'
+    foreign_only = '<w:keepNext xmlns:f="http://example.com/foreign" ' \
+                   'xmlns:w="http://example.com/type-ns/wml" val="foreign"/>'
+
+    [canonical, ambiguous, foreign_only].each do |doc|
+      interpretive = Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+        klass.from_xml(doc).val
+      end
+
+      expect(klass.from_xml(doc).val).to eq(interpretive)
+    end
+  end
+
+  # A type declaring alias URI families stays interpretive: the plan row
+  # holds one exact URI and non-sole-claimant alias families have no
+  # plan-side resolution order.
+  it "keeps alias-declaring types on the interpretive path" do
+    aliased_ns = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/type-ns/canonical"
+      uri_aliases "http://example.com/type-ns/alias"
+    end
+    stub_const("PlanTypeNsAttr::AliasedNs", aliased_ns)
+    type = Class.new(Lutaml::Model::Type::String) do
+      include Lutaml::Xml::Type::Configurable
+
+      xml do
+        namespace PlanTypeNsAttr::AliasedNs
+      end
+    end
+    stub_const("PlanTypeNsAttr::AliasedValType", type)
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :val, PlanTypeNsAttr::AliasedValType
+
+      xml do
+        element "keepNext"
+        map_attribute "val", to: :val
+      end
+    end
+    stub_const("PlanTypeNsAttr::AliasedKeepNext", model)
+
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(
+             model, Lutaml::Model::Config.default_register
+           )).to be_nil
+  end
+end