lutaml-model 0.8.56 → 0.8.106

data/spec/lutaml/xml/plan_uri_exact_dispatch_spec.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan fast path: (URI, local) dispatch and W3C xml:* attributes" do
+  # Same-name element rows in different namespaces must dispatch by
+  # the child type's exact URI — the interpretive matcher's
+  # typed-element identity. The w14/w15 docId shape (OOXML
+  # settings.xml) collapsed to name-only binding: one row captured
+  # both elements and the other stayed empty, so round-trips lost a
+  # docId and downstream reconcilers regenerated it.
+  let(:w14_ns_class) do
+    klass = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://schemas.microsoft.com/office/word/2010/wordml"
+      prefix_default "w14"
+      attribute_form_default :qualified
+    end
+    stub_const("PlanUriLocal::W14Ns", klass)
+    klass
+  end
+
+  let(:w15_ns_class) do
+    klass = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://schemas.microsoft.com/office/word/2012/wordml"
+      prefix_default "w15"
+      attribute_form_default :qualified
+    end
+    stub_const("PlanUriLocal::W15Ns", klass)
+    klass
+  end
+
+  let(:w_ns_class) do
+    klass = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+      prefix_default "w"
+    end
+    stub_const("PlanUriLocal::WNs", klass)
+    klass
+  end
+
+  let(:w14_doc_id_class) do
+    w14_ns_class
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :val, :string
+
+      xml do
+        element "docId"
+        namespace PlanUriLocal::W14Ns
+        map_attribute "val", to: :val
+      end
+    end
+    stub_const("PlanUriLocal::W14DocId", klass)
+    klass
+  end
+
+  let(:w15_doc_id_class) do
+    w15_ns_class
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :val, :string
+
+      xml do
+        element "docId"
+        namespace PlanUriLocal::W15Ns
+        map_attribute "val", to: :val
+      end
+    end
+    stub_const("PlanUriLocal::W15DocId", klass)
+    klass
+  end
+
+  def define_settings_class
+    w_ns_class
+    w14_doc_id_class
+    w15_doc_id_class
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :w14_doc_id, PlanUriLocal::W14DocId
+      attribute :w15_doc_id, PlanUriLocal::W15DocId
+
+      xml do
+        element "settings"
+        namespace PlanUriLocal::WNs
+        namespace_scope [
+          { namespace: PlanUriLocal::W14Ns, declare: :always },
+          { namespace: PlanUriLocal::W15Ns, declare: :always },
+        ]
+        map_element "docId", to: :w14_doc_id, render_nil: false
+        map_element "docId", to: :w15_doc_id, render_nil: false
+      end
+    end
+  end
+
+  def settings_xml(body)
+    "<w:settings xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" " \
+      "xmlns:w14=\"http://schemas.microsoft.com/office/word/2010/wordml\" " \
+      "xmlns:w15=\"http://schemas.microsoft.com/office/word/2012/wordml\">#{body}</w:settings>"
+  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 same-name rows by exact URI regardless of document order" do
+    settings_class = define_settings_class
+
+    [%(<w14:docId w14:val="{A}"/><w15:docId w15:val="{B}"/>),
+     %(<w15:docId w15:val="{B}"/><w14:docId w14:val="{A}"/>)].each do |body|
+      settings = settings_class.from_xml(settings_xml(body))
+
+      expect(settings.w14_doc_id&.val).to eq("{A}")
+      expect(settings.w15_doc_id&.val).to eq("{B}")
+    end
+  end
+
+  it "leaves the absent-namespace row unset for single-docId documents" do
+    settings_class = define_settings_class
+
+    only_w14 = settings_class.from_xml(
+      settings_xml(%(<w14:docId w14:val="{A}"/>)),
+    )
+    expect(only_w14.w14_doc_id&.val).to eq("{A}")
+    expect(only_w14.w15_doc_id).to be_nil
+
+    only_w15 = settings_class.from_xml(
+      settings_xml(%(<w15:docId w15:val="{B}"/>)),
+    )
+    expect(only_w15.w14_doc_id).to be_nil
+    expect(only_w15.w15_doc_id&.val).to eq("{B}")
+  end
+
+  it "emits each docId under its own namespace on serialize" do
+    settings_class = define_settings_class
+    settings = settings_class.from_xml(
+      settings_xml(%(<w14:docId w14:val="{A}"/><w15:docId w15:val="{B}"/>)),
+    )
+
+    output = settings.to_xml
+    expect(output).to include("<w14:docId w14:val=\"{A}\"/>")
+    expect(output).to include("<w15:docId w15:val=\"{B}\"/>")
+  end
+
+  # Exact-URI attribute rows capture by (URI, local): a prefixed rule
+  # spelling with a namespaced type (xlink:href over XlinkHrefType)
+  # binds its local part under the row's URI — the full raw name
+  # matched nothing and the attribute was dropped.
+  it "binds prefixed attribute rules with namespaced types by (URI, local)" do
+    text_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :xlink_href, Lutaml::Xml::W3c::XlinkHrefType
+
+      xml do
+        element "link"
+        map_attribute "xlink:href", to: :xlink_href
+      end
+    end
+    stub_const("PlanUriLocal::Xlink", text_class)
+
+    source = '<link xmlns:xlink="http://www.w3.org/1999/xlink" ' \
+             'xlink:href="https://example.com"/>'
+    link = text_class.from_xml(source)
+
+    expect(link.xlink_href).to eq("https://example.com")
+  end
+
+  # The xml prefix is implicit (W3C-reserved): xml:* attribute rules
+  # bind by raw name and must not be qualified under the model's
+  # namespace by attribute form defaults (w:t's xml:space under a
+  # :qualified WML mapping dropped the attribute entirely).
+  it "round-trips xml:space through the plan lane" do
+    w_ns_class
+    text_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :content, :string
+      attribute :xml_space, :string
+
+      xml do
+        element "t"
+        namespace PlanUriLocal::WNs
+        map_content to: :content
+        map_attribute "xml:space", to: :xml_space
+      end
+    end
+    stub_const("PlanUriLocal::Text", text_class)
+
+    source = '<w:t xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" ' \
+             'xml:space="preserve">hi </w:t>'
+    text = text_class.from_xml(source)
+
+    expect(text.xml_space).to eq("preserve")
+    expect(text.content).to eq("hi ")
+    expect(text.to_xml).to include('xml:space="preserve"')
+  end
+
+  # Writer-added values sit outside the parse-built element_order.
+  # The ordered serialize lane reconciles them at the interpretive
+  # anchors — but only for instances a writer has touched; pristine
+  # parsed instances skip the reconciliation scan entirely.
+  it "emits writer-added children after parse and skips the scan when pristine" do
+    w_ns_class
+    w14_doc_id_class
+    zoom_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :percent, :string
+
+      xml do
+        element "zoom"
+        namespace PlanUriLocal::WNs
+        map_attribute "percent", to: :percent
+      end
+    end
+    stub_const("PlanUriLocal::Zoom", zoom_class)
+    settings_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :zoom, PlanUriLocal::Zoom
+      attribute :w14_doc_id, PlanUriLocal::W14DocId
+
+      xml do
+        element "settings"
+        namespace PlanUriLocal::WNs
+        map_element "zoom", to: :zoom
+        map_element "docId", to: :w14_doc_id
+      end
+    end
+    stub_const("PlanUriLocal::Settings", settings_class)
+
+    source = settings_xml(%(<w:zoom w:percent="100"/>))
+    pristine = settings_class.from_xml(source)
+    expect(pristine.zoom.percent).to eq("100")
+    expect(pristine.to_xml).not_to include("docId")
+
+    mutated = settings_class.from_xml(source)
+    mutated.w14_doc_id = w14_doc_id_class.new(val: "{A}")
+    output = mutated.to_xml
+    expect(output).to include("<docId")
+    expect(output).to include('val="{A}"')
+    expect(output.index("zoom")).to be < output.index("docId")
+  end
+
+  # Root declaration-plan parity: plan-hydrated roots carry the same
+  # import_declaration_plan state the interpretive parse records, so
+  # consumers and the interpretive serialize fallback see in-scope
+  # declarations (#872).
+  it "records the source declaration plan on plan-hydrated roots" do
+    settings_class = define_settings_class
+    settings = settings_class.from_xml(
+      settings_xml(%(<w14:docId w14:val="{A}"/>)),
+    )
+
+    plan = settings.import_declaration_plan
+    expect(plan).to be_a(Lutaml::Xml::DeclarationPlan)
+    hoisted = plan.root_node.hoisted_declarations
+    expect(hoisted["w14"]).to eq("http://schemas.microsoft.com/office/word/2010/wordml")
+
+    skipped = settings_class.from_xml(
+      settings_xml(%(<w14:docId w14:val="{A}"/>)),
+      import_declaration_plan: :skip,
+    )
+    expect(skipped.import_declaration_plan).to be_nil
+  end
+
+  # Processing-instruction mappings (rfcxml's <?rfc toc?>) have no
+  # plan-row spelling: compiling the model silently dropped
+  # pi_settings. The compiler refuses such models — the interpretive
+  # path owns PIs.
+  it "opts models with processing-instruction mappings out of the plan path" do
+    rfc_class = Class.new(Lutaml::Model::Serializable) do
+      attribute :pi_settings, :hash
+      attribute :version, :string
+
+      xml do
+        element "rfc"
+        map_processing_instruction "rfc", to: :pi_settings
+        map_attribute "version", to: :version
+      end
+    end
+    stub_const("PlanUriLocal::Rfc", rfc_class)
+
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
+      rfc_class, Lutaml::Model::Config.default_register
+    )
+    expect(plan).to be_nil
+
+    source = %(<?rfc toc="yes"?>\n<rfc version="3"/>)
+    rfc = rfc_class.from_xml(source)
+    expect(rfc.version).to eq("3")
+    expect(rfc.pi_settings["toc"]).to eq("yes")
+  end
+end

data/spec/lutaml/xml/plan_walk_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require "spec_helper"
-require "lutaml/xml/plan_walk"
+require "lutaml/xml/leptris/plan_walk"
 
 RSpec.describe "XML PlanWalk consumer surface" do
   around do |example|
@@ -25,7 +25,7 @@ RSpec.describe "XML PlanWalk consumer surface" do
 
   it "hydrates equal to the interpretive path on a single-row document" do
     xml = %(<row id="7"><name>Alice</name><tags>x</tags><tags>y</tags></row>)
-    walked = Lutaml::Xml::PlanWalk.call(item_class, xml)
+    walked = Lutaml::Xml::Leptris::PlanWalk.call(item_class, xml)
     expected = item_class.from_xml(xml)
 
     expect(walked).to be_a(item_class)
@@ -46,7 +46,7 @@ RSpec.describe "XML PlanWalk consumer surface" do
       end
     end
 
-    walked = Lutaml::Xml::PlanWalk.call(root_class, xml)
+    walked = Lutaml::Xml::Leptris::PlanWalk.call(root_class, xml)
     expected = root_class.from_xml(xml)
 
     expect(walked.item).to be_an(Array)
@@ -71,7 +71,7 @@ RSpec.describe "XML PlanWalk consumer surface" do
       end
     end
 
-    walked = Lutaml::Xml::PlanWalk.call(root_class, xml)
+    walked = Lutaml::Xml::Leptris::PlanWalk.call(root_class, xml)
     interpretive = root_class.from_xml(xml)
     expect(walked.item.size).to eq(interpretive.item.size)
     expect(walked.item.map(&:id)).to eq(interpretive.item.map(&:id))
@@ -94,9 +94,9 @@ RSpec.describe "XML PlanWalk consumer surface" 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(Lutaml::Xml::PlanWalk.call(klass, "<doc><note>x</note></doc>").tgt.note)
+    expect(Lutaml::Xml::Leptris::PlanWalk.call(klass, "<doc><note>x</note></doc>").tgt.note)
       .to eq("x")
   end
 end

data/spec/lutaml/xml/plan_wildcard_any_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan fast path: map_any_element catch-all" do
+  # leptris#1552: the wildcard child row rides a two-pass walk where
+  # named rows take precedence; the hydrator bridges the unclaimed
+  # remainder in document order and casts it through the attribute —
+  # the interpretive pass's contract for map_any_element.
+
+  let(:host_class) do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :title, :string
+      attribute :others, :string, collection: true
+
+      xml do
+        element "host"
+        map_element "title", to: :title
+        map_any_element to: :others
+      end
+    end
+    stub_const("Gate4Any::Host", klass)
+    klass
+  end
+
+  let(:typed_class) do
+    item = Class.new(Lutaml::Model::Serializable) do
+      attribute :content, :string
+
+      xml do
+        element "item"
+        map_content to: :content
+      end
+    end
+    stub_const("Gate4Any::Item", item)
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :label, :string
+      attribute :items, Gate4Any::Item, collection: true
+
+      xml do
+        element "bag"
+        map_element "label", to: :label
+        map_any_element to: :items
+      end
+    end
+    stub_const("Gate4Any::Bag", 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
+
+  # Members flow through the attribute's cast exactly as the
+  # interpretive pass does: String attributes stringify the wrapper
+  # (both paths identically), Serializable attributes build instances.
+  def member_shapes(elements)
+    elements.map { |e| e.class.name.split("::").last }
+  end
+
+  it "captures unclaimed children in document order" do
+    doc = "<host><title>t</title><extra1>a</extra1>" \
+          "<extra2>b</extra2></host>"
+
+    parsed = host_class.from_xml(doc)
+    expect(parsed.title).to eq("t")
+    expect(parsed.others.size).to eq(2)
+    expect(member_shapes(parsed.others)).to eq(%w[String String])
+  end
+
+  it "captures typed members as model instances" do
+    doc = "<bag><label>L</label><item>one</item><item>two</item></bag>"
+
+    parsed = typed_class.from_xml(doc)
+    expect(parsed.label).to eq("L")
+    expect(parsed.items.map(&:content)).to eq(%w[one two])
+  end
+
+  it "matches the interpretive path's capture" do
+    doc = "<host><title>t</title><extra1>a</extra1><extra2>b</extra2></host>"
+
+    interpretive = Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      host_class.from_xml(doc)
+    end
+
+    parsed = host_class.from_xml(doc)
+    expect(parsed.others.size).to eq(interpretive.others.size)
+    expect(member_shapes(parsed.others)).to eq(
+      member_shapes(interpretive.others).map { |n| n.sub("Nokogiri", "Leptris") },
+    )
+  end
+end

data/spec/lutaml/yaml/yeptris_adapter_spec.rb

@@ -30,6 +30,30 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Yaml::Adapter::YeptrisAdapter : Objec
       expect(described_class.parse("d: 2020-01-01\n"))
         .to eq("d" => Date.new(2020, 1, 1))
     end
+
+    it "raises Psych::SyntaxError for invalid YAML, like the standard adapter" do
+      expect { described_class.parse("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Psych::SyntaxError)
+    end
+
+    it "raises Psych::SyntaxError for a mapping value inside a plain scalar" do
+      # The dependent-CI shape: one line, a second "key:" colon after a
+      # plain scalar run. Psych rejects it with "mapping values are not
+      # allowed in this context"; the engine must surface under the
+      # same class so downstream rescue ladders hold.
+      expect { described_class.parse('name: test\n  invalid: [unclosed') }
+        .to raise_error(Psych::SyntaxError)
+    end
+
+    it "carries the engine's position on the syntax error" do
+      expect { described_class.parse("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Psych::SyntaxError) do |error|
+        expect(error.line).to be >= 1
+        expect(error.problem).to be_a(String)
+        expect(error.problem).not_to be_empty
+        expect(error.message).to include("at line #{error.line}")
+      end
+    end
   end
 
   describe "#to_yaml" do
@@ -59,5 +83,10 @@ RSpec.describe(YEPTRIS_AVAILABLE ? Lutaml::Yaml::Adapter::YeptrisAdapter : Objec
       expect(model.roles).to eq(%w[admin dev])
       expect(model_class.from_yaml(model.to_yaml).roles).to eq(%w[admin dev])
     end
+
+    it "surfaces invalid YAML as InvalidFormatError" do
+      expect { model_class.from_yaml("name: test\n  invalid: [unclosed\n") }
+        .to raise_error(Lutaml::Model::InvalidFormatError)
+    end
   end
 end

data/spec/person_spec.rb

@@ -115,6 +115,13 @@ RSpec.describe Person do
     expect(model.to_yaml).to eq(attributes_yaml.to_yaml)
   end
 
+  # Root cause of the long-pended time-only misparse: psych resolves an
+  # unquoted hh:mm:ss scalar as a YAML 1.1 sexagesimal integer (25200
+  # for "07:00:00"), and the :time cast fed that integer through
+  # Time.parse, which reads "25200" as a date (the fixed 2025-07-19
+  # garbage). The cast now reads sexagesimal integers as seconds since
+  # midnight — both the psych and yeptris paths answer today-07:00.
+  # Evidence chain: moxml#336, yeptris-ruby#265.
   it "deserializes from YAML" do
     yaml = attributes_yaml.to_yaml
     person = described_class.from_yaml(yaml)
@@ -127,6 +134,7 @@ RSpec.describe Person do
     expect(person.active).to be true
   end
 
+  # Same sexagesimal time-only scalar as above.
   it "deserializes from YAML array" do
     yaml = [attributes_yaml.dup, attributes_yaml.dup].to_yaml