lutaml-model 0.8.42 → 0.8.44

data/lib/lutaml/xml/transformation/order_reconciler.rb

@@ -220,25 +220,40 @@ module Lutaml
         # accepts a nil rule namespace, namespace aliases and name aliases.
         # When more than one rule would claim the entry, reconciling would
         # feed the value to the wrong rule, so leave the rule alone.
+        # Rules distinguished by `when_attribute` are separate rules: their
+        # inserted entries carry the discriminator attributes, so they
+        # resolve back correctly.
         def unambiguous?(rule, element_rules)
+          discriminator = rule_discriminator(rule)
           matches = element_rules.select do |candidate|
             matches_element_rule?(candidate, rule.serialized_name,
-                                  rule.namespace_class&.uri)
+                                  rule.namespace_class&.uri) &&
+              rule_discriminator(candidate) == discriminator
           end
 
           matches == [rule]
         end
 
         def new_order_entry(rule)
+          discriminator = rule_discriminator(rule)
           ::Lutaml::Xml::Element.new(
             "Element",
             rule.serialized_name,
             node_type: :element,
             namespace_uri: rule.namespace_class&.uri,
             namespace_prefix: nil,
+            attributes: discriminator && discriminator_attributes(discriminator),
           )
         end
 
+        # The discriminator pairs as order-entry attributes, so an inserted
+        # entry routes back to its own rule at emit time and re-parses.
+        def discriminator_attributes(pairs)
+          pairs.each_with_object({}) do |(name, value), attrs|
+            attrs[name.to_s] = value.to_s
+          end
+        end
+
         # Where a rule's new entries go:
         # - after the last entry that already resolves to it, so extra
         #   collection items follow the existing ones and any interleaved

data/lib/lutaml/xml/transformation/ordered_applier.rb

@@ -122,6 +122,14 @@ model_class, register_id)
 
         # Find the mapping rule for an element from element_order
         #
+        # Same-name entries under different `when_attribute` discriminators
+        # (all `<component>`s, distinguished by `type="guidance"` vs
+        # `type="purpose"`) route to the rule whose discriminator pairs the
+        # entry's recorded attributes satisfy. Entries carrying no
+        # attributes — built before the entry format carried them, or
+        # inserted by hand — fall back to the first plain rule, which is
+        # the pre-discriminator behavior.
+        #
         # @param object [Xml::Element] Element from element_order
         # @param compiled_rules [Array<CompiledRule>] The compiled rules
         # @return [CompiledRule, nil] The matching rule or nil
@@ -131,11 +139,23 @@ model_class, register_id)
 
           object_ns_uri = object.namespace_uri # nil if old element_order (backward compat)
 
-          compiled_rules.find do |r|
-            r.is_a?(::Lutaml::Model::CompiledRule) &&
+          first = nil
+          shared_name = false
+          compiled_rules.each do |r|
+            next unless r.is_a?(::Lutaml::Model::CompiledRule) &&
               r.option(:mapping_type) == :element &&
               matches_element_rule?(r, object.name, object_ns_uri)
+
+            if first.nil?
+              first = r
+            else
+              shared_name = true
+              break
+            end
           end
+          return first unless shared_name
+
+          resolve_shared_name_rule(object, compiled_rules, object_ns_uri)
         end
 
         private
@@ -175,6 +195,57 @@ model_class, register_id)
           rule.matches_name?(name) && rule_ns_matches
         end
 
+        # Pick among rules sharing a serialized name when the entry's
+        # recorded attributes are the only thing that tells them apart.
+        #
+        # A discriminator rule whose pairs the entry satisfies wins over
+        # any plain rule regardless of declaration order, because a plain
+        # rule would claim EVERY same-name entry including discriminated
+        # ones. Entries matching no discriminator pair — an unknown value,
+        # or an entry without attributes — fall back to the first plain
+        # rule.
+        def resolve_shared_name_rule(object, compiled_rules, object_ns_uri)
+          plain = nil
+          compiled_rules.each do |r|
+            next unless r.is_a?(::Lutaml::Model::CompiledRule) &&
+              r.option(:mapping_type) == :element &&
+              matches_element_rule?(r, object.name, object_ns_uri)
+
+            pairs = rule_discriminator(r)
+            return r if pairs && entry_matches_when_attribute?(object, pairs)
+
+            plain ||= r if pairs.nil?
+          end
+          plain
+        end
+
+        # The rule's `when_attribute` discriminator pairs, or nil for a
+        # plain rule. Shared by OrderedApplier and OrderReconciler since
+        # both run on the same transform host.
+        #
+        # @param rule [CompiledRule]
+        # @return [::Hash, nil]
+        def rule_discriminator(rule)
+          pairs = rule.option(:when_attribute)
+          pairs && !pairs.empty? ? pairs : nil
+        end
+
+        # Whether an order entry's recorded attributes satisfy a rule's
+        # discriminator pairs. Mirrors Xml::MappingRule#matches_when_attribute?
+        # — non-nil and string-equal — against the namespaced-name keying
+        # the entries record.
+        def entry_matches_when_attribute?(object, pairs)
+          return false unless object.is_a?(::Lutaml::Xml::Element)
+
+          attrs = object.attributes
+          return false if attrs.nil?
+
+          pairs.all? do |name, expected|
+            actual = attrs[name.to_s]
+            !actual.nil? && actual.to_s == expected.to_s
+          end
+        end
+
         def process_element_order_item(object, root, model_instance, options,
 compiled_rules, _mapping, element_indices,
 content_rule = nil, text_node_index = 0,

data/lib/lutaml/xml/transformation/rule_compiler.rb

@@ -337,6 +337,7 @@ register_id, register, attr_name, custom_methods_value)
             value_map: value_map,
             custom_methods: custom_methods_value,
             polymorphic: mapping_rule.polymorphic,
+            when_attribute: mapping_rule.when_attribute,
             form: mapping_rule.form,
             delegate_from: delegate_target,
           )
@@ -417,6 +418,7 @@ register_id, register, custom_methods_value)
             value_map: value_map,
             custom_methods: custom_methods_value,
             polymorphic: mapping_rule.polymorphic,
+            when_attribute: mapping_rule.when_attribute,
             form: mapping_rule.form,
             alias_names: alias_names,
           )

data/lib/lutaml/xml/xml_element.rb

@@ -284,11 +284,30 @@ module Lutaml
             Lutaml::Xml::Element.new("Element", child.unprefixed_name,
                                      node_type: :element,
                                      namespace_uri: child.namespace_uri,
-                                     namespace_prefix: child.namespace_prefix)
+                                     namespace_prefix: child.namespace_prefix,
+                                     attributes: order_entry_attributes(child))
           end
         end.each(&:freeze).freeze
       end
 
+      # The attributes an element-order entry records, keyed by namespaced
+      # name — the same key find_attribute_value indexes. Same-name entries
+      # under different `when_attribute` discriminators need them to route
+      # back to the right rule on ordered serialization. nil for attribute-
+      # less children keeps the common entry allocation-free.
+      #
+      # @param child [XmlElement] An element child of this node
+      # @return [::Hash{String=>String}, nil]
+      def order_entry_attributes(child)
+        return if child.attributes.empty?
+
+        attrs = {}
+        child.attributes.each_value do |attr|
+          attrs[attr.namespaced_name] = attr.value
+        end
+        attrs.freeze
+      end
+
       def root
         self
       end

data/spec/lutaml/key_value/transformation/rule_compiler_spec.rb

@@ -137,26 +137,36 @@ RSpec.describe Lutaml::KeyValue::Transformation::RuleCompiler do
   end
 
   describe "#valid_mapping?" do
-    let(:rule) { double("CompiledRule", attribute_name: :name) }
+    def compiled_rule(serialize: true)
+      Lutaml::Model::CompiledRule.new(
+        attribute_name: :name,
+        serialized_name: "name",
+        serialize: serialize,
+      )
+    end
 
     it "returns true when no only/except options" do
-      expect(compiler.valid_mapping?(rule, {})).to be true
+      expect(compiler.valid_mapping?(compiled_rule, {})).to be true
     end
 
     it "returns true when attribute is in only list" do
-      expect(compiler.valid_mapping?(rule, { only: [:name] })).to be true
+      expect(compiler.valid_mapping?(compiled_rule, { only: [:name] })).to be true
     end
 
     it "returns false when attribute is not in only list" do
-      expect(compiler.valid_mapping?(rule, { only: [:age] })).to be false
+      expect(compiler.valid_mapping?(compiled_rule, { only: [:age] })).to be false
     end
 
     it "returns true when attribute is not in except list" do
-      expect(compiler.valid_mapping?(rule, { except: [:age] })).to be true
+      expect(compiler.valid_mapping?(compiled_rule, { except: [:age] })).to be true
     end
 
     it "returns false when attribute is in except list" do
-      expect(compiler.valid_mapping?(rule, { except: [:name] })).to be false
+      expect(compiler.valid_mapping?(compiled_rule, { except: [:name] })).to be false
+    end
+
+    it "returns false for a hydrate-only rule (serialize: false)" do
+      expect(compiler.valid_mapping?(compiled_rule(serialize: false), {})).to be false
     end
   end
 

data/spec/lutaml/key_value/transformation_spec.rb

@@ -283,7 +283,10 @@ RSpec.describe Lutaml::KeyValue::Transformation do
 
       expect(transformation).to be_frozen
 
-      rule = instance_double(Lutaml::Model::CompiledRule, attribute_name: :name)
+      rule = Lutaml::Model::CompiledRule.new(
+        attribute_name: :name,
+        serialized_name: "name",
+      )
       expect do
         transformation.send(:valid_mapping?, rule, {})
       end.not_to raise_error

data/spec/lutaml/model/attributes_memo_clear_race_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#815: standalone `SomeModel.new.to_xml` crashed on 0.8.42 when
+# the model's attributes are merged through register records whose imports
+# clear @merged_attributes_cache re-entrantly from inside ensure_imports! —
+# the memo store was materialized before ensure_imports! and the write after
+# it hit nil[].
+RSpec.describe "attributes memo across import-triggered cache clears" do
+  let(:namespace_class) do
+    Class.new(Lutaml::Xml::W3c::XmlNamespace) do
+      uri "https://example.com/ns815"
+    end
+  end
+
+  let(:register) do
+    Lutaml::Model::Register.new(:attrs815, fallback: [:default]).tap do |reg|
+      reg.bind_namespace(namespace_class)
+    end
+  end
+
+  let(:base_model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :shared, :string
+
+      xml do
+        element "Base815"
+        namespace namespace_class
+        map_element "shared", to: :shared
+      end
+    end
+  end
+
+  let(:consumer_model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :own, :string
+
+      xml do
+        element "Consumer815"
+        namespace namespace_class
+        map_element "own", to: :own
+      end
+    end
+  end
+
+  before do
+    stub_const("Attrs815::NamespaceClass", namespace_class)
+    Lutaml::Model::GlobalContext.reset!
+    Lutaml::Model::GlobalRegister.instance.register(register)
+    # Populate @register_records through the import the parse path uses.
+    base_model.import_model_attributes(consumer_model, register.id)
+  end
+
+  after do
+    Lutaml::Model::GlobalContext.reset!
+  end
+
+  it "serializes a register-bound model as its own document root" do
+    instance = base_model.new(shared: "x")
+    expect(instance.to_xml).to include("<shared>x</shared>")
+  end
+
+  it "merges register attributes after an import-triggered cache clear" do
+    instance = consumer_model.new(own: "y")
+    expect(instance.to_xml).to include("<own>y</own>")
+  end
+
+  it "keeps answering attributes() from the memo after imports" do
+    first = consumer_model.attributes(:attrs815)
+    expect(consumer_model.attributes(:attrs815)).to equal(first)
+  end
+
+  it "survives a re-entrant cache clear from inside ensure_imports!" do
+    # uniword's register-bound models (#815): choice/restrict resolution
+    # runs clear_cache while ensure_imports! is still on the stack, which
+    # nils @merged_attributes_cache after the reader materialized it.
+    reentrant = Class.new(base_model) do
+      def self.finalized? = true
+
+      def self.ensure_format_mapping_imports!(_register = nil)
+        clear_cache
+        super
+      end
+    end
+
+    expect { reentrant.attributes(:attrs815) }.not_to raise_error
+    expect(reentrant.attributes(:attrs815)[:shared].name).to eq(:shared)
+  end
+end

data/spec/lutaml/model/hydrate_only_mapping_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "../../../lib/lutaml/model"
+
+module HydrateOnlyMapping
+  class Message < Lutaml::Model::Serializable
+    attribute :body, :string
+    attribute :source_offset, :integer
+
+    key_value do
+      map "body", to: :body
+      map "source_offset", to: :source_offset, serialize: false
+    end
+  end
+end
+
+RSpec.describe "hydrate-only mappings (serialize: false)" do
+  let(:input) { { "body" => "hello", "source_offset" => 42 } }
+
+  it "hydrates the attribute from input" do
+    message = HydrateOnlyMapping::Message.from_hash(input)
+
+    expect(message.body).to eq("hello")
+    expect(message.source_offset).to eq(42)
+  end
+
+  it "omits the attribute from serialized output" do
+    message = HydrateOnlyMapping::Message.from_hash(input)
+
+    expect(message.to_hash).to eq("body" => "hello")
+  end
+
+  it "round-trips through JSON without the hidden key" do
+    message = HydrateOnlyMapping::Message.from_json(input.to_json)
+
+    expect(JSON.parse(message.to_json)).to eq("body" => "hello")
+  end
+
+  it "keeps the mapping through deep-copied mappings" do
+    mapping = HydrateOnlyMapping::Message.mappings_for(:hash)
+    rule = mapping.mappings.find { |r| r.to == :source_offset }
+
+    expect(mapping.deep_dup.mappings.find { |r| r.to == :source_offset }
+      .serialize?).to eq(rule.serialize?)
+  end
+end

data/spec/lutaml/xml/when_attribute_ordered_spec.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#88: `when_attribute` partitioning under `ordered` mappings.
+# The ordered walk routes each element_order entry by its recorded
+# attributes, so `<component type="guidance">` and `<component
+# type="purpose">` interleave on to_xml exactly as the source document did.
+class WhenOrderedComponent < Lutaml::Model::Serializable
+  attribute :text, :string
+
+  xml do
+    element "component"
+    map_element "text", to: :text
+  end
+end
+
+class WhenOrderedRequirement < Lutaml::Model::Serializable
+  attribute :guidance, WhenOrderedComponent, collection: true
+  attribute :purpose, WhenOrderedComponent, collection: true
+  attribute :test_method, WhenOrderedComponent, collection: true
+
+  xml do
+    element "requirement"
+    ordered
+    map_element "component", to: :guidance,
+                             when_attribute: { "type" => "guidance" }
+    map_element "component", to: :purpose,
+                             when_attribute: { "type" => "purpose" }
+    map_element "component", to: :test_method,
+                             when_attribute: { type: "test-method" }
+  end
+end
+
+RSpec.describe "when_attribute under ordered mappings" do
+  before do
+    stub_const("WhenOrdered::Component", WhenOrderedComponent)
+    stub_const("WhenOrdered::Requirement", WhenOrderedRequirement)
+  end
+
+  let(:xml) do
+    <<~XML
+      <requirement>
+        <component type="guidance"><text>g1</text></component>
+        <component type="purpose"><text>p1</text></component>
+        <component type="guidance"><text>g2</text></component>
+        <component type="test-method"><text>t1</text></component>
+      </requirement>
+    XML
+  end
+
+  def serialized_types(doc)
+    doc.scan(/<component type="([^"]+)">/).flatten
+  end
+
+  it "parses partitioned values" do
+    req = WhenOrderedRequirement.from_xml(xml)
+
+    expect(req.guidance.map(&:text)).to eq(%w[g1 g2])
+    expect(req.purpose.map(&:text)).to eq(["p1"])
+    expect(req.test_method.map(&:text)).to eq(["t1"])
+  end
+
+  it "records the discriminator attributes on element_order entries" do
+    req = WhenOrderedRequirement.from_xml(xml)
+    entries = req.element_order.select { |e| e.type == "Element" }
+
+    expect(entries.map(&:attributes)).to eq([
+                                              { "type" => "guidance" },
+                                              { "type" => "purpose" },
+                                              { "type" => "guidance" },
+                                              { "type" => "test-method" },
+                                            ])
+  end
+
+  it "round-trips the original interleaving" do
+    round = WhenOrderedRequirement.from_xml(xml).to_xml
+
+    expect(serialized_types(round)).to eq(
+      %w[guidance purpose guidance test-method],
+    )
+  end
+
+  it "survives a re-parse of the ordered output" do
+    once = WhenOrderedRequirement.from_xml(xml)
+    twice = WhenOrderedRequirement.from_xml(once.to_xml)
+
+    expect(twice.guidance.map(&:text)).to eq(%w[g1 g2])
+    expect(twice.purpose.map(&:text)).to eq(["p1"])
+    expect(twice.test_method.map(&:text)).to eq(["t1"])
+  end
+
+  it "routes appended items to the right attribute on ordered output" do
+    req = WhenOrderedRequirement.from_xml(xml)
+    req.guidance << WhenOrderedComponent.new(text: "g3")
+
+    out = req.to_xml
+    # Reconciliation places new entries after the rule's last existing
+    # occurrence (the OrderReconciler contract), not at document end.
+    expect(serialized_types(out)).to eq(
+      %w[guidance purpose guidance guidance test-method],
+    )
+
+    reparsed = WhenOrderedRequirement.from_xml(out)
+    expect(reparsed.guidance.map(&:text)).to eq(%w[g1 g2 g3])
+    expect(reparsed.purpose.map(&:text)).to eq(["p1"])
+  end
+
+  it "drops occurrences with an unknown discriminator from ordered output" do
+    with_unknown = WhenOrderedRequirement.from_xml(<<~XML)
+      <requirement>
+        <component type="guidance"><text>g1</text></component>
+        <component type="unknown"><text>x</text></component>
+        <component type="purpose"><text>p1</text></component>
+      </requirement>
+    XML
+
+    expect(with_unknown.guidance.map(&:text)).to eq(["g1"])
+    expect(with_unknown.purpose.map(&:text)).to eq(["p1"])
+    expect(serialized_types(with_unknown.to_xml)).to eq(%w[guidance purpose])
+  end
+
+  it "falls back to the plain rule for legacy attribute-less entries" do
+    both = Class.new(Lutaml::Model::Serializable) do
+      attribute :plain, :string
+      attribute :special, :string
+
+      xml do
+        element "holder"
+        ordered
+        map_element "item", to: :plain
+        map_element "item", to: :special, when_attribute: { "kind" => "special" }
+      end
+    end
+    stub_const("WhenOrdered::Holder", both)
+
+    doc = both.from_xml(
+      "<holder><item>a</item><item kind=\"special\">b</item></holder>",
+    )
+
+    expect(doc.plain).to eq("a")
+    expect(doc.special).to eq("b")
+
+    out = doc.to_xml
+    expect(out.scan(%r{<item[^>]*>([^<]*)</item>})).to eq([["a"], ["b"]])
+    expect(out).to include('kind="special"')
+  end
+end