lutaml-model 0.8.94 → 0.8.96

data/spec/lutaml/xml/plan_type_ns_attribute_spec.rb

@@ -0,0 +1,142 @@
+# 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
+
+  # Engines older than the AttrPlan ns form (libleptris 1.9.289) keep
+  # the opt-out — the existing version-gate protocol.
+  it "opts out when the engine predates attribute ns rows" do
+    allow(Lutaml::Xml::Leptris).to receive(:attr_ns_rows_compatible?)
+      .and_return(false)
+
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(
+             klass, Lutaml::Model::Config.default_register
+           )).to be_nil
+  end
+end

data/spec/lutaml/xml/plan_wildcard_any_spec.rb

@@ -0,0 +1,105 @@
+# 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
+
+  it "compiles under engines without wildcard rows to nil" do
+    allow(Lutaml::Xml::Leptris).to receive(:wildcard_rows_compatible?)
+      .and_return(false)
+
+    expect(Lutaml::Xml::Leptris::PlanCompiler.compile(
+             host_class, Lutaml::Model::Config.default_register
+           )).to be_nil
+  end
+end

data/spec/person_spec.rb

@@ -115,12 +115,13 @@ RSpec.describe Person do
     expect(model.to_yaml).to eq(attributes_yaml.to_yaml)
   end
 
-  # yeptris misparses time-only scalars ("07:00:00" anchors to a fixed
-  # date at midnight) — pending the engine fix, this example cannot
-  # pass under the in-suite-detected engine.
-  # rubocop:disable RSpec/PendingWithoutReason -- yeptris misparses time-only
-  # scalars (fixed-date midnight anchor); engine fix pending upstream.
-  xit "deserializes from YAML" do
+  # yeptris 0.6.29.x regressed the time-only scalar anchor: "07:00:00"
+  # comes back as a fixed 2025-07-19 00:00 instead of today-07:00
+  # (psych answers exactly; verified on the psych path). Re-pended
+  # until the yeptris typed-materialize ships the fix — evidence on
+  # moxml#336. 873a67bd un-pended these on the premise that the
+  # 0.6.28.x behavior held; it did not survive the 0.6.29 cut.
+  xit "deserializes from YAML" do # rubocop:disable RSpec/PendingWithoutReason -- yeptris time-only misparse; engine fix pending.
     yaml = attributes_yaml.to_yaml
     person = described_class.from_yaml(yaml)
     expect(person.first_name).to eq("John")
@@ -133,7 +134,7 @@ RSpec.describe Person do
   end
 
   # Same yeptris time-only scalar misparse as above.
-  xit "deserializes from YAML array" do
+  xit "deserializes from YAML array" do # rubocop:disable RSpec/PendingWithoutReason -- yeptris time-only misparse; engine fix pending.
     yaml = [attributes_yaml.dup, attributes_yaml.dup].to_yaml
 
     persons = described_class.from_yaml(yaml)
@@ -154,5 +155,4 @@ RSpec.describe Person do
     expect(persons[1].wakeup_time).to eq(Time.parse("07:00:00"))
     expect(persons[1].active).to be true
   end
-  # rubocop:enable RSpec/PendingWithoutReason
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.94
+  version: 0.8.96
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -184,6 +184,7 @@ files:
 - bench/bench_alloc_audit.rb
 - bench/bench_common.rb
 - bench/bench_compare.rb
+- bench/bench_merge_attempts.rb
 - bench/bench_mml.rb
 - bench/bench_niso.rb
 - bench/bench_sts.rb
@@ -206,6 +207,7 @@ files:
 - docs/_guides/creating-xsd.adoc
 - docs/_guides/custom-methods.adoc
 - docs/_guides/document-validation.adoc
+- docs/_guides/grammar-backed-formats.adoc
 - docs/_guides/index.adoc
 - docs/_guides/jsonld-serialization.adoc
 - docs/_guides/keyvalue-serialization.adoc
@@ -1810,6 +1812,7 @@ files:
 - spec/lutaml/model/serializable_instantiate_spec.rb
 - spec/lutaml/model/serializable_spec.rb
 - spec/lutaml/model/serializable_validation_spec.rb
+- spec/lutaml/model/serialize/attribute_definition_block_form_spec.rb
 - spec/lutaml/model/serialize/builder_spec.rb
 - spec/lutaml/model/serialize_perf_guard_spec.rb
 - spec/lutaml/model/services/transformer_spec.rb
@@ -1985,8 +1988,12 @@ files:
 - spec/lutaml/xml/pipeline_integration_spec.rb
 - spec/lutaml/xml/plain_model_accessors_spec.rb
 - spec/lutaml/xml/plan_fast_path_spec.rb
+- spec/lutaml/xml/plan_namespaced_serialize_spec.rb
+- spec/lutaml/xml/plan_ns_less_document_spec.rb
 - spec/lutaml/xml/plan_partition_spec.rb
+- spec/lutaml/xml/plan_type_ns_attribute_spec.rb
 - spec/lutaml/xml/plan_walk_spec.rb
+- spec/lutaml/xml/plan_wildcard_any_spec.rb
 - spec/lutaml/xml/prefix_control_spec.rb
 - spec/lutaml/xml/register_spec.rb
 - spec/lutaml/xml/reusable_mapping_spec.rb