lutaml-model 0.8.56 → 0.8.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eaff3e9ef7cbf71d8cd5adbf05161b81c43399c92a1c741023005722c190025
-  data.tar.gz: bd4383a644f8878226034c191215780c38b5f1beee2cdf196e26d31067908878
+  metadata.gz: 9c115914d1bb1d737ad93c4ef3d5ecb9090200d8fd3558309421e23fca5a9171
+  data.tar.gz: a017029e28d68c4eda43e5e4a79733b6f31c4258ccfb47b0969dae50fe9f0107
 SHA512:
-  metadata.gz: 00453571fbb8c6b2540f3d545fe53d0c664fa18301797e5192699a6dded982ca9280a4ac39dcc2a7c60f03746ee0dc986e9571c05f9f387f503ba6ab2b522d5c
-  data.tar.gz: bdf133791492a00bb00babcc2b1037366918e6eba7bb05001d4b5748152249c7e45c47c0dbd099c72e0f99acf949febf8ae36f43bb99b43b35874112da3f6312
+  metadata.gz: 5a9f912ee3bdd11d2fe2266b2de6880553fe64ab95cc6891a5184bf067205a9ab76fc61faee3812ded44af10dcc430f5b7aa6acc6051c6dfdcd622c5276127cc
+  data.tar.gz: 61b39b97fe5c532f4aa367b2c7c9d5efe5b43acc786bfe192832d3379f8b8f7b253538550478028f676ea7b8c5e31f5dea5cda189374318bcab7ea0f1c441a32

data/lib/lutaml/model/serialize/format_conversion.rb

@@ -103,7 +103,8 @@ module Lutaml
 
           register = Lutaml::Model::Config.default_register
           plan = Lutaml::Xml::PlanCompiler.compile(self, register)
-          return nil unless plan && Lutaml::Xml::PlanSerializer.serializable?(plan)
+          return nil unless plan && !plan[:namespaced] &&
+            Lutaml::Xml::PlanSerializer.serializable?(plan)
 
           Lutaml::Xml::PlanSerializer.call(instance, plan)
         end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.56"
+    VERSION = "0.8.58"
   end
 end

data/lib/lutaml/xml/plan_compiler.rb

@@ -213,6 +213,12 @@ module Lutaml
 
           row_tags = partition_row_tags!(compiled, rows, tag)
 
+          # The plan serializer does not emit namespace declarations —
+          # namespaced models serialize through the interpretive
+          # writer (lutaml-model#847: standalone to_xml under leptris
+          # dropped the element xmlns entirely).
+          namespaced = !model_ns.nil? || rows.any? { |r| r[:ns] }
+
           flags = []
           flags << :cdata if cdata
           flags << :mixed_content if mixed_content
@@ -233,7 +239,7 @@ module Lutaml
 
           { descriptor: descriptor, tree: tree, rows: compiled,
             attr_rows: attr_rows, mapping: mapping,
-            row_tags: row_tags,
+            row_tags: row_tags, namespaced: namespaced,
             ordered: mapping.ordered? || mapping.mixed_content?,
             needs_nodes: needs_nodes,
             collection_defaults: collection_defaults }

data/lib/lutaml/xml/plan_hydrator.rb

@@ -22,7 +22,7 @@ module Lutaml
         #   hydrate natively against their own nodes
         def call(model_class, plan, value, parent: nil, node: nil)
           buckets = node && plan[:needs_nodes] ? element_buckets(node) : nil
-          attr_kwargs = attributes_kwargs(plan, value)
+          attr_kwargs = attributes_kwargs(plan, value, node)
           child_kwargs, children, delegates =
             children_kwargs(model_class, plan, value, buckets)
           plan[:collection_defaults].each do |name|
@@ -53,10 +53,18 @@ module Lutaml
           Lutaml::Model::Config.default_register
         end
 
-        def attributes_kwargs(plan, value)
+        def attributes_kwargs(plan, value, node = nil)
           kwargs = {}
+          sole_claimants = sole_claimant_names(plan)
           plan[:attr_rows].each do |rule, attr|
             v = value.attribute(rule.name.to_s)
+            if v.nil? && node && sole_claimants.include?(rule.name.to_s)
+              # #754/#790 parity: a sole-claimant attribute rule binds
+              # any qualification (the interpretive matcher's lenient
+              # recovery). The walk captures exact (URI, local) matches
+              # only, so the qualified spelling is read off the node.
+              v = lenient_node_attribute(node, rule.name.to_s)
+            end
             next if v.nil?
 
             v = v.split(rule.delimiter) if rule.delimiter
@@ -331,6 +339,31 @@ module Lutaml
           Lutaml::Xml::Adapter::LeptrisAdapter.parse(raw).root
         end
 
+        # Attribute names claimed by exactly one attr row — the only
+        # names eligible for #754/#790 lenient binding (multi-claimant
+        # names stay exact; per #841 leniency is sole-claimant-only).
+        def sole_claimant_names(plan)
+          plan[:attr_rows].map { |rule, _attr| rule.name.to_s }
+            .tally
+            .select { |_n, c| c == 1 }
+            .keys
+        end
+
+        # Local-name attribute lookup on the source node, qualified
+        # spellings included (w:val matches rule "val").
+        def lenient_node_attribute(node, local_name)
+          return nil unless node.respond_to?(:attributes)
+
+          node.attributes.each_value do |attr|
+            # Leptris::XML::Attr carries the raw (possibly prefixed)
+            # name; strip the prefix for the local-name comparison.
+            name = attr.name.to_s
+            name = name.split(":").last if name.include?(":")
+            return attr.value if name == local_name
+          end
+          nil
+        end
+
         def group_children(value, row_tags = nil)
           grouped = {}
           tagged = {}

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -688,4 +688,56 @@ 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::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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.56
+  version: 0.8.58
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-23 00:00:00.000000000 Z
+date: 2026-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64