lutaml-model 0.8.57 → 0.8.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c9021265ddf0425193ec4ce5656b3209e73291534bac83f7863494ca5dd2f55
-  data.tar.gz: d389a3ad85a1d8b72d953df5cf3ff6b0728625aeabc9ebd6563163ee44374071
+  metadata.gz: 9c115914d1bb1d737ad93c4ef3d5ecb9090200d8fd3558309421e23fca5a9171
+  data.tar.gz: a017029e28d68c4eda43e5e4a79733b6f31c4258ccfb47b0969dae50fe9f0107
 SHA512:
-  metadata.gz: 8580ac7ac155d6d72a008b7f29c1f6e8001b45f1e19235c863d53b8f23bf84cf7953b5bbdd2e1b57f9056e583cb49fad114f9487b82eb331172a88a3b071fcd2
-  data.tar.gz: c74e408cc7a50c3b7badc51cd3ca3711a54c41dfe0fdedf2f37f3a3232a6ec615a92539befc891b9d3235c0ed873aadc674f58fcc8d542032da03d436baba9a6
+  metadata.gz: 5a9f912ee3bdd11d2fe2266b2de6880553fe64ab95cc6891a5184bf067205a9ab76fc61faee3812ded44af10dcc430f5b7aa6acc6051c6dfdcd622c5276127cc
+  data.tar.gz: 61b39b97fe5c532f4aa367b2c7c9d5efe5b43acc786bfe192832d3379f8b8f7b253538550478028f676ea7b8c5e31f5dea5cda189374318bcab7ea0f1c441a32

data/lib/lutaml/model/version.rb

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

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

@@ -713,4 +713,31 @@ RSpec.describe "XML plan fast path" do
     )
     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.57
+  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