lutaml-model 0.8.54 → 0.8.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffb19b7e87ec763167dc806fb0fd0b37a1ca292e7627333ba1238f06c3e5f17e
-  data.tar.gz: 340c6f96fb82f0d972ca654f548db51bdef12155bc94ae95e3eaf6eacf96af29
+  metadata.gz: c16452c0371017c525543d5fcd948d4eaf9680dcff5ec2b193d2e9fabe43f86a
+  data.tar.gz: 1853acc8790ddc2e1b53cfc8c1a68b750f695fc01f474d608e5d29cfbe269a57
 SHA512:
-  metadata.gz: d79e2b5b7fce4f6ba3115cdb190365b8a1fc1212922f00cabf2e9855fa85c2350808c0844f78c55015de4e8c8cf480cbdf5390e8afaa0a401f01ad6e2a1d93a3
-  data.tar.gz: c6a29c349be599ddfcbcb53087c17178de7de17aa1afa46fb5e2fc6eb2b3c4b0c0189b68a26aa77d0e2d561966c4001c0bd04abacf2d6e987d8846185b6add29
+  metadata.gz: 6ac74cd346e28f14990ae94ef0921bce2f75bc92252e82a6d7a16059683b25a5e2645e4227a3a72479880921c9a831d69faa951cb6eb20600f29a41ba010e9c8
+  data.tar.gz: 9f30ab7f585db43c6d0e94425c9e4fe3e9895a02c28c7a7f3f5888ef5dc8a6ea4dee287cfb58c2300edcd23e0d6f92a9a792f602a0696f0a76c35334362add79

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.54"
+    VERSION = "0.8.55"
   end
 end

data/lib/lutaml/xml/plan_compiler.rb

@@ -95,6 +95,21 @@ module Lutaml
             return nil if attr.nil?
             return nil if attr.derived?
 
+            # Partition rows (TODO 34 step 2) ride native predicates
+            # only in the plain-capture shape; any other when_attribute
+            # shape stays interpretive (the suite pins nested-target
+            # partitions to the interpretive path).
+            unless rule.when_attribute.empty?
+              t = attr.type(register)
+              plain_partition = !rule.delegate &&
+                !rule.has_custom_method_for_deserialization? &&
+                !rule.polymorphic_mapping? &&
+                !attr.polymorphic? && !attr.union? &&
+                !(t.is_a?(Class) &&
+                  t.include?(::Lutaml::Model::Serialize))
+              return nil unless plain_partition
+            end
+
             # Interpretive hydration materializes every mapped
             # collection, present or not; the fast path mirrors with
             # constructor-time empty arrays.
@@ -178,6 +193,10 @@ module Lutaml
 
                 row = { name: rule.name.to_s }
                 row[:ns] = child_ns(rule, model_ns) if rule.namespace_set?
+                # lutaml-model#88: same-name rows partitioned by the
+                # rule's discriminator ride the engine's exclusive
+                # predicate match (leptris 1.9.221+, #1272).
+                row[:when] = rule.when_attribute unless rule.when_attribute.empty?
 
                 if attr.collection?
                   compiled << [rule, attr, :collection_native, nil,
@@ -192,6 +211,8 @@ module Lutaml
             end
           end
 
+          row_tags = partition_row_tags!(compiled, rows, tag)
+
           flags = []
           flags << :cdata if cdata
           flags << :mixed_content if mixed_content
@@ -212,6 +233,7 @@ module Lutaml
 
           { descriptor: descriptor, tree: tree, rows: compiled,
             attr_rows: attr_rows, mapping: mapping,
+            row_tags: row_tags,
             ordered: mapping.ordered? || mapping.mixed_content?,
             needs_nodes: needs_nodes,
             collection_defaults: collection_defaults }
@@ -219,14 +241,45 @@ module Lutaml
 
         def compilable_mapping?(mapping)
           mapping.root_element &&
-            !(mapping.respond_to?(:root_mappings) && mapping.root_mappings) &&
-            # lutaml-model#88: when_attribute partitions route same-name
-            # occurrences by attribute value — name-keyed plan rows would
-            # hydrate every occurrence into EVERY partition attribute
-            # (verified double-capture under the flag). The interpretive
-            # filter is the only correct path until the descriptor ABI
-            # grows row predicates.
-            mapping.mappings.none?(&:when_attribute?)
+            !(mapping.respond_to?(:root_mappings) && mapping.root_mappings)
+        end
+
+        # Partition bookkeeping for when_attribute rows (#88, TODO
+        # 34 step 2): the engine matches same-name rows exclusively —
+        # first matching row wins — so predicate rows must PRECEDE any
+        # plain sibling on the same name (a plain-first order
+        # double-captures: the plain row takes everything and the
+        # predicates still claim their matches). Every row of a
+        # partitioned name gets a distinct type_tag; plan values echo
+        # it back, giving the hydrator row-exact routing with no
+        # per-occurrence re-derivation. Returns {compiled_index =>
+        # tag} (nil when the model has no partitions). compiled and
+        # rows are parallel and stay in lockstep through the reorder.
+        def partition_row_tags!(compiled, rows, tag)
+          by_name = rows.each_with_index
+            .group_by { |(row, _)| row[:name] }
+            .select { |_name, pairs| pairs.any? { |(row, _)| row[:when] } }
+          return nil if by_name.empty?
+
+          permutation = by_name.each_value.flat_map do |pairs|
+            pairs.sort_by { |(row, i)| [row[:when] ? 0 : 1, i] }
+              .map(&:last)
+          end
+          remaining = (0...rows.length).to_a - permutation
+          permutation.concat(remaining)
+
+          row_tags = {}
+          permutation.each_with_index do |old_index, new_index|
+            row = rows[old_index]
+            next unless by_name.key?(row[:name])
+
+            tag += 1
+            row[:type_tag] = tag
+            row_tags[new_index] = tag
+          end
+          rows.replace(permutation.map { |i| rows[i] })
+          compiled.replace(permutation.map { |i| compiled[i] })
+          row_tags
         end
 
         # Attribute for a rule — delegate rules resolve against their

data/lib/lutaml/xml/plan_hydrator.rb

@@ -73,19 +73,32 @@ module Lutaml
         # parent/root links once the parent exists; delegate values
         # wait for the instance (their target object must exist).
         def children_kwargs(_model_class, plan, value, buckets = nil)
-          grouped = group_children(value)
+          grouped, tagged = group_children(value, plan[:row_tags])
           buckets = nil unless buckets && plan[:needs_nodes]
           kwargs = {}
           children = []
           delegates = []
           spellings = Hash.new { |h, k| h[k] = [] }
-          plan[:rows].each do |rule, attr, kind, spelling, delegate|
+          row_tags = plan[:row_tags]
+          plan[:rows].each_with_index do |(rule, attr, kind, spelling, delegate), idx|
+            tag = row_tags&.[](idx)
             case kind
             when :scalar
               # Raw passthrough: the model constructor is the single
               # cast authority — pre-casting here doubled every cast.
               # Class transforms still apply before assignment.
-              v = grouped.dig(rule.name.to_s, 0)&.string_value
+              if tag && (vals = tagged[tag]) && vals.size > 1
+                # Interpretive parity: several captures into a
+                # non-collection attribute arrive as the full array.
+                v = vals.map(&:string_value)
+              else
+                first = if tag
+                          tagged[tag]&.first
+                        else
+                          grouped.dig(rule.name.to_s, 0)
+                        end
+                v = first&.string_value
+              end
               unless v.nil?
                 v = rule.transform_value(attr, v, :from, :xml) if rule.transform.is_a?(Class)
                 assign(kwargs, delegates, delegate, rule, attr, v)
@@ -122,7 +135,11 @@ module Lutaml
                 assign(kwargs, delegates, delegate, rule, attr, values)
               end
             when :collection_native
-              values = native_collection(value, rule.name.to_s)
+              values = if tag
+                         tagged[tag].to_a.map(&:string_value)
+                       else
+                         native_collection(value, rule.name.to_s)
+                       end
               unless values.nil?
                 assign(kwargs, delegates, delegate, rule, attr, values)
               end
@@ -314,15 +331,20 @@ module Lutaml
           Lutaml::Xml::Adapter::LeptrisAdapter.parse(raw).root
         end
 
-        def group_children(value)
+        def group_children(value, row_tags = nil)
           grouped = {}
+          tagged = {}
+          want_tags = !row_tags.nil?
           value.count.times do |i|
             child = value.at(i)
             next if child.name.nil? # content runs, read separately
 
             (grouped[child.name] ||= []) << child
+            if want_tags && child.type_tag != 0
+              (tagged[child.type_tag] ||= []) << child
+            end
           end
-          grouped
+          [grouped, tagged]
         end
 
         # Element children bucketed by local name, document order

data/lib/lutaml/xml/plan_serializer.rb

@@ -62,12 +62,19 @@ module Lutaml
 
             case kind
             when :scalar
-              add_leaf(element, row_name(rule, spelling),
-                       attr.serialize(value, :xml, register), doc)
+              # Multi-capture parity: an attribute that collected
+              # several occurrences serializes one element per item,
+              # as the interpretive writer does.
+              Array(value).each do |item|
+                add_leaf(element, row_name(rule, spelling),
+                         attr.serialize(item, :xml, register), doc,
+                         attrs: rule.when_attribute)
+              end
             when :collection_native, :collection_cb
               Array(value).each do |item|
                 add_leaf(element, rule.name.to_s,
-                         attr.serialize(item, :xml, register), doc)
+                         attr.serialize(item, :xml, register), doc,
+                         attrs: rule.when_attribute)
               end
             when :nested, :ordered_deferred
               Array(value).each do |item|
@@ -217,8 +224,12 @@ module Lutaml
                                 attr.serialize(value, :xml, register).to_s)
         end
 
-        def add_leaf(element, name, value, doc)
+        # Partition rows (#88) re-emit their discriminator: the wire
+        # element carries the when_attribute pairs so the round trip
+        # re-routes to the same attribute on reparse.
+        def add_leaf(element, name, value, doc, attrs: nil)
           child = element.create_child(name)
+          attrs&.each { |k, v| child[k.to_s] = v.to_s }
           child.add_child(doc.create_text_node(value.to_s)) unless value.nil?
           child
         end

data/spec/lutaml/xml/plan_partition_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/xml"
+
+# The plan fast path rides when_attribute partitions (TODO 34 step 2,
+# leptris 1.9.221+ #1272 predicate rows): same-name rows claim their
+# occurrences exclusively, the plain sibling takes the unclaimed, and
+# serialization re-stamps the discriminators. All lanes must agree —
+# plan and interpretive — on parse AND round trip, including the
+# multi-capture edge (several unclaimed occurrences into a scalar
+# attribute arrive as the full array, interpretive parity).
+RSpec.describe "Plan fast path with when_attribute partitions" do
+  before do
+    require "leptris/xml"
+  rescue LoadError
+    skip "leptris not available"
+  end
+
+  let(:model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :a_val, :string
+      attribute :b_val, :string
+      attribute :other, :string
+
+      xml do
+        root "part"
+        map_element "item", to: :a_val, when_attribute: { "type" => "a" }
+        map_element "item", to: :b_val, when_attribute: { "type" => "b" }
+        map_element "item", to: :other
+      end
+    end
+  end
+
+  let(:doc) do
+    %(<part><item type="a">A</item><item type="b">B</item><item>plain</item><item type="x">X</item></part>)
+  end
+
+  it "compiles the partitioned model with row tags" do
+    plan = Lutaml::Xml::PlanCompiler.compile(
+      model, Lutaml::Model::Config.default_register
+    )
+    expect(plan).not_to be_nil
+    expect(plan[:row_tags].length).to eq(3)
+  end
+
+  it "routes occurrences exclusively and matches the interpretive parse" do
+    fast = model.from_xml(doc)
+    slow = Lutaml::Model::Config.instance.tap { |c| c.xml_plan_fast_path = false }
+      .then { model.from_xml(doc) }
+    Lutaml::Model::Config.instance.xml_plan_fast_path = true
+
+    expect(fast.a_val).to eq("A")
+    expect(fast.b_val).to eq("B")
+    expect(fast.other).to eq(["plain", "X"])
+    expect(fast.a_val).to eq(slow.a_val)
+    expect(fast.b_val).to eq(slow.b_val)
+    expect(fast.other).to eq(slow.other)
+  end
+
+  it "round-trips through the serializer with discriminator stamps" do
+    round = model.from_xml(model.from_xml(doc).to_xml)
+    expect(round.a_val).to eq("A")
+    expect(round.b_val).to eq("B")
+    expect(round.other).to eq(["plain", "X"])
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.54
+  version: 0.8.55
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-22 00:00:00.000000000 Z
+date: 2026-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1970,6 +1970,7 @@ 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_partition_spec.rb
 - spec/lutaml/xml/plan_walk_spec.rb
 - spec/lutaml/xml/prefix_control_spec.rb
 - spec/lutaml/xml/register_spec.rb