lutaml-model 0.8.42 → 0.8.44

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cd747883eee7ea6a87aea0c708e6054f1f6cf9f7b06e295b32f1b7ba06a8a75
-  data.tar.gz: 639b21ad4dd77104b3bce40f0ba7bad925a5b608806e6e8979b50cb68f57b70e
+  metadata.gz: 57902ec64a7b7915f601d0525d747ec742c78a18bd7e78469c0af41aa35d2101
+  data.tar.gz: a27ee76ad1f66aaacb324c5ba79f75dca698c3f729c2e61706ed4cbe85c0b255
 SHA512:
-  metadata.gz: 05174a52193320261f496e92ac656b6ddc5a47167db5b98b3682c0397a4c9fb0f2a58f20e8be689d7f35486bea63dc2228d367574c3834587be6d5ba97306cd9
-  data.tar.gz: a6efef58f862390afe6fcf903ce3ff4d829d451079b7a1762990ed0e0bf1c5623c798c712a485d8e81cdc415189a37e9c5f7b1c02dd2d03ad6c17d96b5bac5a0
+  metadata.gz: fd6d918fcd42d655682bc769f9c047860a3bba698258137f638cafd789f7b8ee0e176c89a12c84f09310245aaa227bc33d3c344c255591b14527a691acca6088
+  data.tar.gz: 36bf72d194bc8ed3e5ddb8837c55f5dd3170006ecf37cfc26004f46133fc6684e267d56123577e06b9ca9fe2d3dfcab838a21b6bd3b884409613ea364276329e

data/docs/_guides/advanced-mapping.adoc

@@ -562,3 +562,69 @@ end
 ====
 
 
+
+=== Attribute-value dispatch on a shared element name
+
+When several distinct attributes share one wire element, selected by a
+sibling attribute's value, declare the discriminator with `when_attribute:`
+
+[source,ruby]
+----
+class Requirement < Lutaml::Model::Serializable
+  attribute :guidance, Component, collection: true
+  attribute :purpose, Component, collection: true
+
+  xml do
+    element "requirement"
+    map_element "component", to: :guidance,
+                             when_attribute: { "type" => "guidance" }
+    map_element "component", to: :purpose,
+                             when_attribute: { "type" => "purpose" }
+  end
+end
+----
+
+Each rule hydrates only from the `<component>` occurrences whose `type`
+attribute carries the expected value, in document order; uncovered values
+are ignored by all discriminator rules. On serialization the discriminator
+pair is re-emitted on the element (unless the value's own mapping already
+writes that attribute).
+
+Co-occurrence semantics: several `when_attribute` rules may share the
+element name; each target attribute fills independently, so declare each
+as `collection: true` when the element repeats. A rule without
+`when_attribute` that shares the name only claims occurrences no
+discriminator rule claimed, so every occurrence is captured exactly once.
+
+`when_attribute` and `polymorphic:` are two different dispatch axes over
+the same discriminator idea — pick by what the discriminator selects:
+
+* `polymorphic: { attribute:, class_map: }` — the value selects the
+  **class** each occurrence hydrates into; ONE attribute holds every
+  occurrence. See the polymorphic models tutorial.
+* `when_attribute:` — the value selects **which attribute** claims the
+  occurrence; the declared type stays fixed.
+
+They compose: a rule may partition with `when_attribute` while its
+attribute dispatches classes with `polymorphic`.
+
+Under an `ordered` mapping, serialization preserves the original
+interleaving: `element_order` records each occurrence's attributes, and
+the ordered walk routes every occurrence back to the rule whose
+discriminator it satisfies.
+
+[source,ruby]
+----
+xml do
+  element "requirement"
+  ordered
+  map_element "component", to: :guidance,
+                           when_attribute: { "type" => "guidance" }
+  map_element "component", to: :purpose,
+                           when_attribute: { "type" => "purpose" }
+end
+----
+
+Given `<component type="guidance">`, `<component type="purpose">`,
+`<component type="guidance">` in the source, `to_xml` re-emits exactly
+that guidance, purpose, guidance sequence.

data/docs/_tutorials/polymorphic-models-tutorial.adoc

@@ -9,6 +9,8 @@ nav_order: 8
 
 Polymorphic attributes allow an attribute to accept multiple types of values. This is useful when attributes share common characteristics but have type-specific behaviors.
 
+NOTE: Polymorphism dispatches the *class* of each hydrated item into one attribute. If the discriminator instead needs to route occurrences of a shared element name into *different attributes* (e.g. `component[@type='guidance']` → `guidance`, `component[@type='purpose']` → `purpose`), that is `when_attribute:` in the advanced mapping guide — the two compose on one rule.
+
 == Understanding polymorphism
 
 A polymorphic attribute can accept instances of different classes that share a common base class.

data/lib/lutaml/key_value/mapping.rb

@@ -78,7 +78,8 @@ module Lutaml
         polymorphic: {},
         polymorphic_map: {},
         transform: {},
-        value_map: {}
+        value_map: {},
+        serialize: true
       )
         mapping_name = name_for_mapping(root_mappings, name)
         validate!(mapping_name, to, with, render_nil, render_empty)
@@ -100,6 +101,7 @@ module Lutaml
           polymorphic_map: polymorphic_map,
           transform: transform,
           value_map: value_map,
+          serialize: serialize,
         )
       end
 

data/lib/lutaml/key_value/mapping_rule.rb

@@ -22,7 +22,8 @@ module Lutaml
         polymorphic: {},
         polymorphic_map: {},
         transform: {},
-        value_map: {}
+        value_map: {},
+        serialize: true
       )
         super(
           name,
@@ -41,6 +42,7 @@ module Lutaml
           polymorphic_map: polymorphic_map,
           transform: transform,
           value_map: value_map,
+          serialize: serialize,
         )
 
         @child_mappings = child_mappings
@@ -65,6 +67,7 @@ module Lutaml
           child_mappings: Lutaml::Model::Utils.deep_dup(child_mappings),
           root_mappings: Lutaml::Model::Utils.deep_dup(root_mappings),
           value_map: Lutaml::Model::Utils.deep_dup(@value_map),
+          serialize: serialize?,
         )
       end
 

data/lib/lutaml/key_value/transform.rb

@@ -127,6 +127,8 @@ module Lutaml
       end
 
       def valid_mapping?(rule, options)
+        return false if rule.respond_to?(:serialize?) && !rule.serialize?
+
         only = options[:only]
         except = options[:except]
         name = rule.to

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

@@ -230,6 +230,7 @@ transformation_factory:)
             custom_methods: custom_methods,
             delegate: delegate,
             root_mappings: mapping_rule.root_mappings,
+            serialize: mapping_rule.serialize?,
           )
         end
 
@@ -239,6 +240,8 @@ transformation_factory:)
         # @param options [Hash] Transformation options (may contain :only, :except)
         # @return [Boolean] true if the rule should be applied
         def valid_mapping?(rule, options)
+          return false if rule.option(:serialize) == false
+
           only = options[:only]
           except = options[:except]
           name = rule.attribute_name

data/lib/lutaml/model/collection_handler.rb

@@ -61,7 +61,17 @@ module Lutaml
       # @param register [Symbol, nil] Register for custom-collection type resolution
       # @return [Object] A new collection instance
       def build_collection(*args, register: nil)
-        items = args.flatten
+        # args.flatten allocated a fresh Array even for the dominant
+        # calls: no args, or one already-flat Array from cast_items
+        # (71,949 flatten allocations per ISO-13849 parse).
+        items = if args.empty?
+                  []
+                elsif args.length == 1 && (first = args[0]).is_a?(::Array) &&
+                    first.none?(::Array)
+                  first
+                else
+                  args.flatten
+                end
         unless register && initialize_accepts_register?
           return collection_class.new(items)
         end

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -70,7 +70,9 @@ module Lutaml
         polymorphic: {},
         polymorphic_map: {},
         transform: {},
-        value_map: {}
+        value_map: {},
+        serialize: true,
+        when_attribute: {}
       )
         @name = name
         @to = to
@@ -92,6 +94,11 @@ module Lutaml
         @polymorphic = polymorphic
         @polymorphic_map = polymorphic_map
         @transform = transform
+        @serialize_mapping = serialize
+        # Attribute-value discriminator (lutaml-model#88): select this
+        # rule's wire occurrences by a sibling attribute value, e.g.
+        # `when_attribute: { "type" => "guidance" }`.
+        @when_attribute = (when_attribute || {}).freeze
 
         # Cache whether this rule needs the full deserialize chain.
         # Over 95% of rules are "simple" (no custom method, no delegate).
@@ -174,6 +181,11 @@ module Lutaml
 
       alias from name
       alias render_default? render_default
+
+      # Whether this rule participates in serialization output. False
+      # marks a hydrate-only mapping: consumed by from_* but never
+      # rendered by to_*. (The value callback #serialize is separate.)
+      def serialize? = @serialize_mapping
       alias attribute? attribute
 
       def render?(value, instance = nil, options = {})
@@ -328,6 +340,16 @@ context = nil)
       # each time (240k allocations on the ISO-13849 serialize profile).
       # Rules may be frozen, so no per-instance memo: one to_s instead
       # of two is the frozen-safe diet.
+      # Discriminator pairs this rule selects (and re-emits) on, empty
+      # for an ordinary rule.
+      def when_attribute
+        @when_attribute ||= {}.freeze
+      end
+
+      def when_attribute?
+        !when_attribute.empty?
+      end
+
       def custom_method_only?
         name = attribute_name.to_s
         (name.start_with?("__") && name.end_with?("__")) ||

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

@@ -133,8 +133,13 @@ module Lutaml
             return cached if cached
 
             ensure_imports!(register) if finalized?
-            @merged_attributes_cache[register_id] ||=
-              @attributes.merge(@register_records[register_id][:attributes])
+            # ensure_imports! may re-entrantly run clear_cache (restrict /
+            # import resolution), which nils @merged_attributes_cache —
+            # compute the merge first and re-materialize the memo store
+            # at write time (#815: standalone to_xml on register-bound
+            # models crashed with nil[] here).
+            merged = @attributes.merge(@register_records[register_id][:attributes])
+            (@merged_attributes_cache ||= {})[register_id] = merged
           else
             ensure_imports!(register) if finalized?
             @attributes

data/lib/lutaml/model/serialize.rb

@@ -241,12 +241,21 @@ module Lutaml
       end
 
       def respond_to_missing?(method_name, include_private = false)
-        (method_name.to_s.end_with?("=") && attribute_exist?(method_name)) ||
-          super
+        # Setter probes from non-compiled dispatch land here ~24k times per
+        # ISO-13849 parse; strip the suffix once instead of re-walking
+        # attribute_exist?'s to_s/chomp/to_sym chain.
+        name = method_name.to_s
+        if name.end_with?("=") &&
+            self.class.attributes(lutaml_register)
+                .key?(name.delete_suffix("=").to_sym)
+          return true
+        end
+
+        super
       end
 
       def attribute_exist?(name)
-        name = name.to_s.chomp("=").to_sym if name.end_with?("=")
+        name = name.to_s.delete_suffix("=").to_sym if name.end_with?("=")
 
         self.class.attributes(lutaml_register).key?(name)
       end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.42"
+    VERSION = "0.8.44"
   end
 end

data/lib/lutaml/xml/adapter_element.rb

@@ -302,7 +302,8 @@ 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
         end.each(&:freeze).freeze

data/lib/lutaml/xml/element.rb

@@ -4,7 +4,7 @@ module Lutaml
       include Lutaml::Model::Liquefiable
 
       attr_reader :type, :name, :text_content, :node_type, :namespace_uri,
-                  :namespace_prefix
+                  :namespace_prefix, :attributes
 
       # Create a new Element for order tracking
       #
@@ -14,8 +14,13 @@ module Lutaml
       # @param node_type [Symbol, nil] The node type (:text, :cdata, :element, :comment, :processing_instruction)
       # @param namespace_uri [String, nil] The namespace URI of this element
       # @param namespace_prefix [String, nil] The namespace prefix of this element
+      # @param attributes [::Hash{String=>String}, nil] The element's
+      #   attributes keyed by namespaced name. Only element entries parsed
+      #   from a document carry them, so `when_attribute` rules can tell
+      #   same-name entries apart on ordered serialization.
       def initialize(type, name, text_content: nil, node_type: nil,
-                     namespace_uri: nil, namespace_prefix: nil)
+                     namespace_uri: nil, namespace_prefix: nil,
+                     attributes: nil)
         @type = type # "Text" or "Element" - deprecated, kept for backward compatibility
         @name = name
         # Infer node_type from type for backward compatibility if not provided
@@ -26,6 +31,7 @@ module Lutaml
         @text_content ||= name if text? || cdata?
         @namespace_uri = namespace_uri
         @namespace_prefix = namespace_prefix
+        @attributes = attributes&.freeze
       end
 
       # Check if this is a text content node (not CDATA)

data/lib/lutaml/xml/mapping.rb

@@ -527,6 +527,7 @@ module Lutaml
                nil),
       transform: {},
       value_map: {},
+      when_attribute: {},
       form: nil,
       documentation: nil,
       xsd_type: (xsd_type_provided = false
@@ -537,6 +538,8 @@ module Lutaml
           name, to, with, render_nil, render_empty, type: TYPES[:element]
         )
 
+        validate_when_attribute!(when_attribute) unless when_attribute.empty?
+
         # Warn if prefix parameter is provided
         if prefix_provided != false
           warn "[DEPRECATED] The prefix parameter on map_element is deprecated. " \
@@ -584,6 +587,7 @@ module Lutaml
           form: form,
           documentation: documentation,
           raw: raw,
+          when_attribute: when_attribute,
         )
         # Store rules with the same element name in an array to support
         # multiple mapping rules for the same element name with different target types
@@ -607,6 +611,20 @@ module Lutaml
         end
       end
 
+      # lutaml-model#88: attribute-value discriminator. Keys are wire
+      # attribute names, values the expected string value.
+      def validate_when_attribute!(when_attribute)
+        when_attribute.each do |k, v|
+          next if (k.is_a?(::String) || k.is_a?(::Symbol)) &&
+            (v.is_a?(::String) || v.is_a?(::Symbol))
+
+          raise Lutaml::Model::IncorrectMappingArgumentsError,
+                "when_attribute expects string/symbol attribute names " \
+                "mapped to string/symbol values, got " \
+                "#{k.inspect} => #{v.inspect}"
+        end
+      end
+
       def map_attribute(
         name,
       to: nil,
@@ -1150,7 +1168,8 @@ module Lutaml
           grouped = {}
           mappings(reg_key).each do |r|
             next if r.attribute? || r.raw_mapping? || r.content_mapping? ||
-              r.cdata || r.has_custom_method_for_deserialization? ||
+              r.cdata || r.when_attribute? ||
+              r.has_custom_method_for_deserialization? ||
               (r.transform.is_a?(Hash) && !r.transform.empty?) ||
               r.transform.is_a?(Class)
 

data/lib/lutaml/xml/mapping_rule.rb

@@ -16,7 +16,7 @@ module Lutaml
       # Writers for deep_dup (preserves exact object references)
       attr_accessor :namespace, :prefix, :namespace_class
 
-      def initialize(
+      def initialize( # rubocop:disable Metrics/ParameterLists -- mirrors the DSL surface
         name,
       to:,
       render_nil: false,
@@ -37,6 +37,7 @@ module Lutaml
       polymorphic_map: {},
       transform: {},
       value_map: {},
+      when_attribute: {},
       as_list: nil,
       delimiter: nil,
       form: nil,
@@ -59,6 +60,7 @@ module Lutaml
           polymorphic_map: polymorphic_map,
           transform: transform,
           value_map: value_map,
+          when_attribute: when_attribute,
         )
 
         # Store original namespace parameter to preserve :inherit symbol
@@ -225,6 +227,15 @@ module Lutaml
         end
       end
 
+      # Whether a parsed element satisfies this rule's when_attribute
+      # discriminator: every expected attribute value matches.
+      def matches_when_attribute?(element)
+        when_attribute.all? do |name, expected|
+          actual = element.find_attribute_value(name.to_s)
+          !actual.nil? && actual.to_s == expected.to_s
+        end
+      end
+
       def deep_dup
         # Preserve @namespace_param exactly as it was (string, Class, :inherit, or nil)
         # This ensures the duplicate has the same internal state as the original
@@ -261,6 +272,7 @@ module Lutaml
           form: @form,
           documentation: @documentation,
           raw: @raw,
+          when_attribute: when_attribute,
         ).tap do |dup_rule|
           # Manually preserve the exact @namespace_class object to avoid
           # recreating anonymous classes (which would have different object_ids)

data/lib/lutaml/xml/model_transform.rb

@@ -40,6 +40,10 @@ module Lutaml
       # Performance: Frozen empty hash to reduce allocations
       EMPTY_HASH = {}.freeze
 
+      # ":".getbyte(0) — getbyte comparisons avoid the per-candidate
+      # string slice in namespace-prefix checks on the lenient paths.
+      COLON_BYTE = 58
+
       def data_to_model(data, _format, options = {})
         # Use child's own default register if it has one
         # This ensures versioned schemas (e.g., MML v2 with lutaml_default_register = :mml_v2)
@@ -600,6 +604,21 @@ _effective_register)
       def convert_rule_name_to_attribute_name(doc, rule_name, session: nil)
         return nil unless rule_name.include?(":")
 
+        # Pure function of (element attributes, spelling) — the same
+        # conversions repeat per rule application (~450k find/slice
+        # allocations per ISO-13849 parse before this memo).
+        conversions = session&.rule_name_resolution(doc.root)
+        if conversions
+          return conversions[rule_name] if conversions.key?(rule_name)
+
+          converted = convert_rule_name_uncached(doc, rule_name, session)
+          conversions[rule_name] = converted
+        else
+          convert_rule_name_uncached(doc, rule_name, session)
+        end
+      end
+
+      def convert_rule_name_uncached(doc, rule_name, session)
         # URI-vs-prefix detection works on the whole rule name: the
         # namespace part is a prefix of rule_name, so "://" anywhere in
         # the name means a URI-form namespace, and a "urn:" namespace
@@ -620,10 +639,13 @@ _effective_register)
             candidates = session.element_local_attribute_index(doc.root)[local_name]
             # No candidate carries this local name: nothing in the
             # element can match, the scan is skipped entirely.
+            # getbyte, not a [i] slice — the slice allocated one
+            # string per probed candidate (~380k per ISO-13849 parse).
             matched = candidates&.find do |attr|
               ns = attr.namespace
               next false if ns.nil? || ns.length > last_colon_index
-              next false unless rule_name.start_with?(ns) && rule_name[ns.length] == ":"
+              next false unless rule_name.start_with?(ns) &&
+                rule_name.getbyte(ns.length) == COLON_BYTE
 
               attr.unprefixed_name == local_name
             end
@@ -631,7 +653,8 @@ _effective_register)
             matched = doc.root.attributes.each_value.find do |attr|
               ns = attr.namespace
               next false if ns.nil? || ns.length > last_colon_index
-              next false unless rule_name.start_with?(ns) && rule_name[ns.length] == ":"
+              next false unless rule_name.start_with?(ns) &&
+                rule_name.getbyte(ns.length) == COLON_BYTE
 
               attr.unprefixed_name == local_name
             end
@@ -661,13 +684,27 @@ _effective_register)
       def find_attribute_by_local_name(doc, rule_names,
                                        flexible_local: false, session: nil)
         root_index = session&.element_local_attribute_index(doc.root)
+        # Matched VALUE per (element, spelling, flexible flag) — pure
+        # while the element is parse-frozen.
+        memo = if session
+                 session.lenient_local_matches(doc.root,
+                                                                      flexible_local)
+               else
+                 nil
+               end
 
         rule_names.each do |rule_name|
           next unless rule_name.include?(":")
 
-          resolved = match_attribute_by_local_name(
-            doc, rule_name, root_index, flexible_local
-          )
+          resolved = if memo&.key?(rule_name)
+                       memo[rule_name]
+                     else
+                       match = match_attribute_by_local_name(
+                         doc, rule_name, root_index, flexible_local
+                       )
+                       memo[rule_name] = match if memo
+                       match
+                     end
           return resolved if resolved
         end
         nil
@@ -686,6 +723,11 @@ _effective_register)
         local_name, rule_uri = parts
 
         candidates = root_index&.[](local_name)
+        # The index carries every local form of every attribute on the
+        # element — a miss means no attribute can match, so the full
+        # each_value scan below is dead whenever the index exists.
+        return nil if root_index && !candidates
+
         matched_attr = if candidates
                          candidates.find do |attr|
                            local_name_match?(attr, local_name, rule_uri,
@@ -1009,6 +1051,28 @@ _effective_register)
           end
         end
 
+        # lutaml-model#88: attribute-value discriminator — among the
+        # name-matched occurrences, keep only those whose sibling
+        # attributes carry the expected values. A plain rule sharing the
+        # name with discriminator rules gets the complement — occurrences
+        # no discriminator claimed — so each occurrence is captured
+        # exactly once, mirroring ordered-serialization routing.
+        if rule.when_attribute?
+          children = children.select do |child|
+            rule.matches_when_attribute?(child)
+          end
+        else
+          siblings = session.when_attribute_siblings_by_name
+          unless siblings.empty?
+            claimed = rule_names.filter_map { |n| siblings[n] }.flatten
+            unless claimed.empty?
+              children = children.reject do |child|
+                claimed.any? { |sibling| sibling.matches_when_attribute?(child) }
+              end
+            end
+          end
+        end
+
         # Performance: Cache rule method check before loop to avoid repeated method calls
         rule_has_custom_method = rule.has_custom_method_for_deserialization?
         if rule_has_custom_method || attr_type == ::Lutaml::Model::Type::Hash

data/lib/lutaml/xml/parse_session.rb

@@ -29,8 +29,17 @@ module Lutaml
       # functions of the element and the name; ISO-13849-shaped
       # documents repeat the same resolutions per rule application, so
       # the computed answer is memoized per element for the parse.
-      def rule_name_resolution
-        @rule_name_resolution ||= {}
+      def rule_name_resolution(element)
+        @rule_name_resolution ||= {}.compare_by_identity
+        @rule_name_resolution[element] ||= {}
+      end
+
+      # Lenient local-name fallback matches, per (element, flexible_local):
+      # spelling -> matched attribute VALUE. Same purity argument as
+      # rule_name_resolution — elements are parse-frozen.
+      def lenient_local_matches(element, flexible_local)
+        @lenient_local_matches ||= {}.compare_by_identity
+        (@lenient_local_matches[element] ||= {})[flexible_local] ||= {}
       end
 
       # Local-name -> [attributes] index over one element's attributes,
@@ -56,6 +65,28 @@ module Lutaml
         end
       end
 
+      # lutaml-model#88: element wire names partitioned by `when_attribute`
+      # rules, as name -> discriminator rules. A plain rule on a
+      # partitioned name captures only occurrences no discriminator
+      # claimed — the mirror of ordered-serialization routing, so each
+      # occurrence is captured exactly once instead of double-captured by
+      # the plain rule and its discriminator sibling. Empty unless the
+      # mapping uses when_attribute at all; non-Serialize custom models
+      # have no mappings to partition.
+      def when_attribute_siblings_by_name
+        @when_attribute_siblings_by_name ||=
+          if instance_is_serialize && (mapping = xml_mapping)
+            mapping.mappings.each_with_object({}) do |rule, index|
+              pairs = rule.when_attribute
+              next if pairs.nil? || pairs.empty?
+
+              (index[rule.name.to_s] ||= []) << rule
+            end
+          else
+            {}
+          end
+      end
+
       def model_class
         @model_class ||= instance.class
       end

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

@@ -42,12 +42,31 @@ register_id, register)
                 rule.attribute_type < Lutaml::Model::Serialize
             end
 
-          if is_nested_model
-            create_nested_model_element(rule, value, options, register,
-                                        union: union)
-          else
-            create_simple_value_element(rule, value, options, model_class,
-                                        register_id)
+          element = if is_nested_model
+                      create_nested_model_element(rule, value, options,
+                                                  register, union: union)
+                    else
+                      create_simple_value_element(rule, value, options,
+                                                  model_class, register_id)
+                    end
+          apply_when_attribute(element, rule)
+          element
+        end
+
+        # lutaml-model#88: re-emit the discriminator attributes on the
+        # element created for this rule, unless the value's own mapping
+        # already wrote them.
+        def apply_when_attribute(element, rule)
+          pairs = rule.option(:when_attribute)
+          return if pairs.nil? || pairs.empty?
+          return if element.nil?
+
+          pairs.each do |name, expected|
+            next if element.attributes.any? { |a| a.name == name.to_s }
+
+            element.attributes << ::Lutaml::Xml::DataModel::XmlAttribute.new(
+              name.to_s, expected.to_s
+            )
           end
         end