lutaml-model 0.8.46 → 0.8.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2f28f3c9d10541b92778ec5ab996c7b41110bb5784b4832d08e650a758db5f8
-  data.tar.gz: 22b516d73a1b76acf9421226b3f00204c3dec0cc46e4e1a9f1531ee979b1f8a2
+  metadata.gz: a482362c928135d0733413ae200b20e5a9a7f05af8faf57696bc4461b093d691
+  data.tar.gz: 3b22e8a6881ad4a832d90a6b064d6999a5e5b8a969d507fd467d44c66f7c0279
 SHA512:
-  metadata.gz: 779f779b5b3d76947306eec00d8652c4d8ca5e41a1a5846df1b34d5b52c03cc7e6302a53a4280d921aaddc96172daed52e1476b0662b60af40ea49558cba87f5
-  data.tar.gz: 1e19049f5e0e8a57218bdd2d6a3366f018c37b53a773c6f660d18eb071fa7736db3521762040314097b0ab8b0d9507bd2a778a06af17719935c013639854ff82
+  metadata.gz: a6047ddb9f43fa9a7012e794070891a0d997ca261f2c76f324223a1c1414bab39f1f05b5f627ecde1e21a083b971c4cc002d15928db410e97411b5dcca9a5b97
+  data.tar.gz: b849ae1daa34c19f6f570d1389a2ea43cf3af5ffba5db32bdef33e53a0b7ba960736b511ecfc5f520a926690134a4247227b1fa7a437923a8774a511569f6e88

data/README.adoc

@@ -2693,6 +2693,41 @@ references:
 ====
 
 
+==== Attribute-value dispatch on a shared name (`when_attribute`)
+
+Polymorphism selects the *class* of each item. The other dispatch axis
+selects *which attribute* an occurrence belongs to, keyed by a sibling
+value — every `<component>` below goes to a different attribute by its
+`type`:
+
+[source,ruby]
+----
+class Requirement < Lutaml::Model::Serializable
+  attribute :guidance, Component, collection: true
+  attribute :purpose, Component, collection: true
+
+  xml do
+    element "requirement"
+    map_element "component", when_attribute: "type",
+                             to: { "guidance" => :guidance,
+                                   "purpose" => :purpose }
+  end
+end
+----
+
+The same declaration works for key-value formats (`json`/`yaml`/`toml`/
+`hsh` blocks use `map`), where the discriminator is an object key's
+value. Every occurrence is captured exactly once, the discriminator is
+re-emitted on serialization, `unmatched: :raise` fails the parse on
+values no rule claims, and `ordered` XML mappings round-trip the
+original interleaving. The two axes compose on one rule — partition by
+value while dispatching classes with `polymorphic`.
+
+See
+link:docs/_guides/advanced-mapping.adoc[the advanced mapping guide]
+for the full semantics.
+
+
 
 === Union attributes
 

data/docs/_guides/advanced-mapping.adoc

@@ -566,7 +566,8 @@ 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:`
+sibling attribute's value, declare the discriminator key with
+`when_attribute:` and map each value to its attribute:
 
 [source,ruby]
 ----
@@ -576,14 +577,30 @@ class Requirement < Lutaml::Model::Serializable
 
   xml do
     element "requirement"
-    map_element "component", to: :guidance,
-                             when_attribute: { "type" => "guidance" }
-    map_element "component", to: :purpose,
-                             when_attribute: { "type" => "purpose" }
+    map_element "component", when_attribute: "type",
+                             to: { "guidance" => :guidance,
+                                   "purpose" => :purpose }
   end
 end
 ----
 
+That one declaration expands, at DSL time, to one rule per value —
+identical to writing each rule by hand:
+
+[source,ruby]
+----
+xml do
+  element "requirement"
+  map_element "component", to: :guidance,
+                           when_attribute: { "type" => "guidance" }
+  map_element "component", to: :purpose,
+                           when_attribute: { "type" => "purpose" }
+end
+----
+
+Use the per-rule form when a partition is partial (only some values
+claimed) or a rule needs several pairs — multiple pairs mean AND.
+
 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
@@ -607,8 +624,8 @@ everything left, so the strict policy never fires when one is present.
 ----
 xml do
   element "requirement"
-  map_element "component", to: :guidance,
-                           when_attribute: { "type" => "guidance" },
+  map_element "component", when_attribute: "type",
+                           to: { "guidance" => :guidance },
                            unmatched: :raise
 end
 ----
@@ -635,10 +652,9 @@ discriminator it satisfies.
 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", when_attribute: "type",
+                           to: { "guidance" => :guidance,
+                                 "purpose" => :purpose }
 end
 ----
 
@@ -660,10 +676,8 @@ class KvRequirement < Lutaml::Model::Serializable
   attribute :purpose, Component, collection: true
 
   json do
-    map "component", to: :guidance,
-                     when_attribute: { "type" => "guidance" }
-    map "component", to: :purpose,
-                     when_attribute: { "type" => "purpose" }
+    map "component", when_attribute: "type",
+                     to: { "guidance" => :guidance, "purpose" => :purpose }
   end
 end
 ----

data/docs/_guides/index.adoc

@@ -23,6 +23,10 @@ Task-oriented guides for accomplishing specific goals with Lutaml::Model.
 * link:../keyvalue-serialization[Key-Value Serialization] - JSON/YAML/TOML/Hash
 * link:../collection-serialization[Collection Serialization] - JSONL and YAML Stream
 
+== Advanced mapping
+
+* link:../advanced-mapping[Advanced Attribute Mapping] - Same-name dispatch on attribute values (`when_attribute`), grouped declarations, custom methods, delegation
+
 == Performance
 
 * link:../native-engines[Native engines (leptris / yeptris / teptris)] - Drop-in XML/YAML/JSON/TOML engine upgrades via bundle opt-in

data/docs/_guides/keyvalue-serialization.adoc

@@ -116,6 +116,40 @@ desc: A ceramic with a navy blue color and clear glaze.
 ----
 ====
 
+=== Dispatching a shared key by a discriminator value
+
+When one wire key holds a list of objects distinguished by a sibling
+key's value, `when_attribute` routes each item to its own attribute —
+one declaration covers the whole partition:
+
+[source,ruby]
+----
+class Requirement < Lutaml::Model::Serializable
+  attribute :guidance, Component, collection: true
+  attribute :purpose, Component, collection: true
+
+  json do
+    map "component", when_attribute: "type",
+                     to: { "guidance" => :guidance, "purpose" => :purpose }
+  end
+end
+----
+
+[source,json]
+----
+{ "component": [
+  { "type": "guidance", "text": "g1" },
+  { "type": "purpose",  "text": "p1" }
+] }
+----
+
+`guidance` holds `g1`, `purpose` holds `p1`. Serialization merges the
+items back under the one key, each stamped with its discriminator.
+`unmatched: :raise` fails the parse on items no rule claims. Works for
+all key-value formats. See
+link:advanced-mapping.adoc[the advanced mapping guide] for the full
+semantics, including the per-rule form.
+
 === Specific format mappings
 
 Specific key value formats can be mapping independently of other formats.

data/lib/lutaml/key_value/mapping.rb

@@ -85,6 +85,39 @@ module Lutaml
       )
         mapping_name = name_for_mapping(root_mappings, name)
         validate!(mapping_name, to, with, render_nil, render_empty)
+
+        # lutaml-model#88: grouped form — `when_attribute: "type"` plus
+        # `to: { value => attribute }` expands to one rule per value at
+        # DSL time; the compiled rules are identical to the per-rule
+        # form, so parse/serialize behavior and speed are unchanged.
+        if when_attribute.is_a?(::String) || when_attribute.is_a?(::Symbol)
+          when_attribute_group(when_attribute, to).each do |value, target|
+            map(
+              name,
+              to: target,
+              render_nil: render_nil,
+              render_default: render_default,
+              render_empty: render_empty,
+              treat_nil: treat_nil,
+              treat_empty: treat_empty,
+              treat_omitted: treat_omitted,
+              with: with,
+              delegate: delegate,
+              child_mappings: child_mappings,
+              root_mappings: root_mappings,
+              polymorphic: polymorphic,
+              polymorphic_map: polymorphic_map,
+              transform: transform,
+              value_map: value_map,
+              when_attribute: { when_attribute.to_s => value.to_s },
+              unmatched: unmatched,
+              serialize: serialize,
+            )
+          end
+          return
+        end
+        reject_ambiguous_when_attribute!(when_attribute, to)
+
         validate_when_attribute!(when_attribute) unless when_attribute.empty?
         validate_unmatched!(unmatched, when_attribute)
         if !when_attribute.empty? && (!with.empty? || delegate)

data/lib/lutaml/key_value/transform.rb

@@ -5,9 +5,12 @@ module Lutaml
         # Use child's own default register if it has one
         # This ensures versioned schemas (e.g., MML v2 with lutaml_default_register = :mml_v2)
         # are instantiated with their native context
-        child_register = Lutaml::Model::Register.resolve_for_child(
-          model_class, lutaml_register
-        )
+        # TODO.max-perf/32: constant per (model class, register) — the
+        # transform itself is cached per that pair, so resolve once.
+        child_register = @kv_child_register ||= Lutaml::Model::Register
+          .resolve_for_child(
+            model_class, lutaml_register
+          )
 
         if model_class.include?(Lutaml::Model::Serialize)
           instance = model_class.new(lutaml_register: child_register)
@@ -449,7 +452,7 @@ partition = nil)
         if partitioned.nil? && (plan = kv_rule_plan(format, rule, attr)) &&
             (value = kv_fast_extract(doc, plan))
           rule.deserialize(instance, kv_fast_cast(value, plan, instance),
-                           attributes, self, options[:context])
+                           attributes, self, options[:context], pre_cast: true)
           return
         end
 
@@ -485,6 +488,10 @@ partition = nil)
         if attr.collection? || !instance.is_a?(Lutaml::Model::Serialize)
           attr.valid_collection!(value, context)
         end
+        # No pre_cast here: the interpretive attr.cast is not the full
+        # cast chain — whole-value Type policies (e.g. a custom
+        # Type::Value that receives the whole hash) are shaped by the
+        # setter's cast_value, which must still run.
         rule.deserialize(instance, value, attributes, self,
                          options[:context])
       end

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

@@ -136,6 +136,47 @@ module Lutaml
               "unmatched only applies to rules declared with when_attribute"
       end
 
+      # lutaml-model#88: grouped discriminator form.
+      # `when_attribute: "type"` names the discriminator key; `to:` maps
+      # each wire value to its target attribute. Validates the shape and
+      # returns the group pairs — the DSL then expands one rule per
+      # value, so the compiled rules are identical to the per-rule form.
+      def when_attribute_group(when_attribute, to)
+        if when_attribute.to_s.empty?
+          raise Lutaml::Model::IncorrectMappingArgumentsError,
+                "when_attribute group key cannot be empty"
+        end
+        unless to.is_a?(::Hash) && !to.empty?
+          raise Lutaml::Model::IncorrectMappingArgumentsError,
+                "when_attribute: #{when_attribute.inspect} is the grouped " \
+                "form and requires to: { value => attribute }, got " \
+                "to: #{to.inspect}"
+        end
+
+        to.each do |value, target|
+          next if (value.is_a?(::String) || value.is_a?(::Symbol)) &&
+            (target.is_a?(::String) || target.is_a?(::Symbol))
+
+          raise Lutaml::Model::IncorrectMappingArgumentsError,
+                "when_attribute group expects string/symbol values mapped " \
+                "to string/symbol attribute names, got " \
+                "#{value.inspect} => #{target.inspect}"
+        end
+        to
+      end
+
+      # The per-rule `{ name => value }` form maps ONE attribute; a Hash
+      # `to:` only makes sense with the grouped form.
+      def reject_ambiguous_when_attribute!(when_attribute, to)
+        return unless when_attribute.is_a?(::Hash) && !when_attribute.empty? &&
+          to.is_a?(::Hash)
+
+        raise Lutaml::Model::IncorrectMappingArgumentsError,
+              "to: must name a single attribute when when_attribute is the " \
+              "per-rule { name => value } form; the grouped form is " \
+              'when_attribute: "key", to: { value => attribute }'
+      end
+
       def register(register_id = nil)
         register_id ||= Lutaml::Model::Config.default_register
         Lutaml::Model::GlobalRegister.lookup(register_id)

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

@@ -324,13 +324,15 @@ module Lutaml
       end
 
       def deserialize(model, value, attributes, mapper_class = nil,
-context = nil)
+context = nil, pre_cast: false)
         if @needs_full_deserialize
           handle_custom_method(model, value, mapper_class, context) ||
             handle_delegate(model, value, attributes) ||
-            handle_transform_method(model, value, attributes, context)
+            handle_transform_method(model, value, attributes, context,
+                                    pre_cast: pre_cast)
         else
-          handle_transform_method(model, value, attributes, context)
+          handle_transform_method(model, value, attributes, context,
+                                  pre_cast: pre_cast)
         end
       end
 
@@ -446,6 +448,24 @@ context = nil)
       # :import — hash/proc transformers go through ImportTransformer.
       TRANSFORM_DISPATCH = {}.compare_by_identity
 
+      def self.parsed_assign_writer(model_class, target)
+        key = [model_class, target]
+        writer = PARSED_ASSIGN_WRITERS[key]
+        return writer unless writer.nil?
+
+        name = :"__assign_parsed_#{target}="
+        writer = model_class.method_defined?(name) ? name : false
+        PARSED_ASSIGN_WRITERS[key] = writer
+        writer
+      end
+
+      # [model class, target] -> the parsed-assign writer compiled for
+      # that class's attribute, or nil when only a casting writer
+      # exists (custom writers, reflective names, enum shorthands).
+      # Class-level because mapping rules may be frozen (see the
+      # name-string note above TRANSFORM_DISPATCH).
+      PARSED_ASSIGN_WRITERS = {}.compare_by_identity
+
       def self.transform_dispatch(rule, attr)
         per_attr = TRANSFORM_DISPATCH[rule]
         if per_attr.nil?
@@ -556,7 +576,8 @@ context = nil)
                           attributes[delegate].type(model.lutaml_register).new)
       end
 
-      def handle_transform_method(model, value, attributes, context = nil)
+      def handle_transform_method(model, value, attributes, context = nil,
+pre_cast: false)
         attr = attributes[to]
         # The transform verdict (none / class-based already applied /
         # hash-proc via ImportTransformer) is static per (rule, attr) —
@@ -566,12 +587,28 @@ context = nil)
           transformed = ImportTransformer.call(value, self, attr,
                                                context: context)
           assign_value(model, transformed)
+        elsif pre_cast && collection_shaped?(value, attr) &&
+            (writer = self.class.parsed_assign_writer(model.class, to))
+          # TODO.max-perf/31: the deserializing transform already cast
+          # the value through the format-aware path — assign without
+          # repeating the cast. Custom writers and reflective names
+          # resolve nil here and keep the casting setter.
+          model.public_send(writer, value)
         else
           assign_value(model, value)
         end
         true
       end
 
+      # Whether the value already carries the attribute's final shape:
+      # a bare single occurrence still owes the setter's one-element
+      # collection coercion, so only collection instances (and every
+      # singular value, whose cast is complete) take the no-recast lane.
+      def collection_shaped?(value, attr)
+        attr.nil? || !attr.collection? || value.is_a?(::Array) ||
+          value.is_a?(Lutaml::Model::Collection)
+      end
+
       def assign_value(model, value)
         model.public_send(@setter_name, value)
       end

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

@@ -297,6 +297,21 @@ module Lutaml
                 end
                 record_mutation_collection(:#{name}, value)
               end
+
+              # TODO.max-perf/31: the deserialization transforms already
+              # cast through the format-aware path; this writer skips the
+              # setter's re-cast while keeping value_set_for marking and
+              # mutation recording. Public assignment keeps the caster.
+              def __assign_parsed_#{name}=(value)
+                value_set_for(:#{name})
+                current = @#{name}
+                if current.equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION) &&
+                    (value.nil? || Lutaml::Model::Utils.uninitialized?(value))
+                else
+                  @#{name} = value
+                end
+                record_mutation_collection(:#{name}, value)
+              end
             RUBY
           else
             class_eval(<<~RUBY, __FILE__, __LINE__ + 1) # rubocop:disable Style/DocumentDynamicEvalDefinition
@@ -306,6 +321,13 @@ module Lutaml
                 @#{name} = value
                 record_mutation(:#{name}, value)
               end
+
+              # TODO.max-perf/31: see the collection branch above.
+              def __assign_parsed_#{name}=(value)
+                value_set_for(:#{name})
+                @#{name} = value
+                record_mutation(:#{name}, value)
+              end
             RUBY
           end
         end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.46"
+    VERSION = "0.8.48"
   end
 end

data/lib/lutaml/xml/mapping.rb

@@ -539,6 +539,48 @@ module Lutaml
           name, to, with, render_nil, render_empty, type: TYPES[:element]
         )
 
+        # lutaml-model#88: grouped form — `when_attribute: "type"` plus
+        # `to: { value => attribute }` expands to one rule per value at
+        # DSL time, so the compiled rules are identical to the per-rule
+        # form and nothing downstream changes.
+        if when_attribute.is_a?(::String) || when_attribute.is_a?(::Symbol)
+          # These locals are `false` when their kwarg default ran and
+          # nil when the caller passed the kwarg explicitly (planned
+          # locals read as nil, so defined? is useless here).
+          if namespace_set.nil? || prefix_provided.nil? ||
+              xsd_type_provided.nil?
+            raise Lutaml::Model::IncorrectMappingArgumentsError,
+                  "namespace/prefix/xsd_type are not supported in the " \
+                  "grouped when_attribute form; declare rules individually"
+          end
+
+          when_attribute_group(when_attribute, to).each do |value, target|
+            map_element(
+              name,
+              to: target,
+              render_nil: render_nil,
+              render_default: render_default,
+              render_empty: render_empty,
+              treat_nil: treat_nil,
+              treat_empty: treat_empty,
+              treat_omitted: treat_omitted,
+              with: with,
+              delegate: delegate,
+              cdata: cdata,
+              polymorphic: polymorphic,
+              transform: transform,
+              value_map: value_map,
+              when_attribute: { when_attribute.to_s => value.to_s },
+              unmatched: unmatched,
+              form: form,
+              documentation: documentation,
+              raw: raw,
+            )
+          end
+          return
+        end
+        reject_ambiguous_when_attribute!(when_attribute, to)
+
         validate_when_attribute!(when_attribute) unless when_attribute.empty?
         validate_unmatched!(unmatched, when_attribute)
 

data/lib/lutaml/xml/model_transform.rb

@@ -48,9 +48,12 @@ module Lutaml
         # Use child's own default register if it has one
         # This ensures versioned schemas (e.g., MML v2 with lutaml_default_register = :mml_v2)
         # are instantiated with their native context
-        child_register = Lutaml::Model::Register.resolve_for_child(
-          model_class, lutaml_register
-        )
+        # TODO.max-perf/32: constant per (model class, register) — the
+        # transform itself is cached per that pair, so resolve once.
+        child_register = @xml_child_register ||= Lutaml::Model::Register
+          .resolve_for_child(
+            model_class, lutaml_register
+          )
 
         instance_is_serialize = model_class.include?(::Lutaml::Model::Serialize)
         if instance_is_serialize

data/spec/lutaml/key_value/when_attribute_spec.rb

@@ -285,6 +285,86 @@ RSpec.describe "when_attribute for key-value formats" do
     end
   end
 
+  describe "grouped form" do
+    let(:grouped) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :guidance, KvWhenComponent, collection: true
+        attribute :purpose, KvWhenComponent, collection: true
+
+        json do
+          map "component", when_attribute: "type",
+                           to: { guidance: :guidance, purpose: :purpose },
+                           unmatched: :raise
+        end
+
+        hsh do
+          map "component", when_attribute: "type",
+                           to: { guidance: :guidance, purpose: :purpose }
+        end
+      end
+    end
+
+    it "expands to one rule per value with identical behavior" do
+      stub_const("KvWhen::Grouped", grouped)
+      req = grouped.from_json(payload.to_json)
+
+      expect(req.guidance.map(&:text)).to eq(%w[g1 g2])
+      expect(req.purpose.map(&:text)).to eq(["p1"])
+      expect(JSON.parse(req.to_json)["component"]).to eq([
+                                                           { "type" => "guidance", "text" => "g1" },
+                                                           { "type" => "guidance", "text" => "g2" },
+                                                           { "type" => "purpose", "text" => "p1" },
+                                                         ])
+
+      rules = grouped.mappings_for(:json).mappings.select { |r| r.name == "component" }
+      expect(rules.map(&:when_attribute)).to eq(
+        [{ "type" => "guidance" }, { "type" => "purpose" }],
+      )
+    end
+
+    it "works through the hash format" do
+      stub_const("KvWhen::Grouped", grouped)
+      req = grouped.from_hash(
+        "component" => [{ type: "purpose", text: "p1" }],
+      )
+
+      expect(req.purpose.map(&:text)).to eq(["p1"])
+      expect(req.guidance).to be_empty
+    end
+
+    it "forwards the unmatched policy to every rule" do
+      stub_const("KvWhen::Grouped", grouped)
+
+      expect do
+        grouped.from_json({ "component" => [{ "type" => "nope" }] }.to_json)
+      end.to raise_error(Lutaml::Model::UnknownDiscriminatorError, /type="nope"/)
+    end
+
+    it "rejects the grouped form without a to: map" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :x, :string
+
+          json do
+            map "x", to: :x, when_attribute: "type"
+          end
+        end
+      end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError, /to:/)
+    end
+
+    it "rejects a Hash to: with the per-rule form" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :x, :string
+
+          json do
+            map "x", when_attribute: { "type" => "a" }, to: { "a" => :x }
+          end
+        end
+      end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError, /single attribute/)
+    end
+  end
+
   describe "DSL validation" do
     it "rejects non-string/symbol pairs" do
       expect do

data/spec/lutaml/xml/when_attribute_spec.rb

@@ -131,6 +131,99 @@ RSpec.describe "when_attribute discriminator mappings" do
     end.to raise_error(ArgumentError)
   end
 
+  describe "grouped form" do
+    let(:grouped) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :guidance, WhenAttrComponent, collection: true
+        attribute :purpose, WhenAttrComponent, collection: true
+
+        xml do
+          element "requirement"
+          map_element "component", when_attribute: "type",
+                                   to: { "guidance" => :guidance,
+                                         "purpose" => :purpose },
+                                   unmatched: :raise
+        end
+      end
+    end
+
+    let(:grouped_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>
+        </requirement>
+      XML
+    end
+
+    it "expands to one rule per value with identical behavior" do
+      stub_const("WhenAttr::Grouped", grouped)
+      req = grouped.from_xml(grouped_xml)
+
+      expect(req.guidance.map(&:text)).to eq(%w[g1 g2])
+      expect(req.purpose.map(&:text)).to eq(["p1"])
+      expect(req.to_xml).to include('type="guidance"')
+
+      rules = grouped.mappings_for(:xml).mappings.select { |r| r.name == "component" }
+      expect(rules.map(&:when_attribute)).to eq(
+        [{ "type" => "guidance" }, { "type" => "purpose" }],
+      )
+    end
+
+    it "forwards the unmatched policy to every rule" do
+      stub_const("WhenAttr::Grouped", grouped)
+
+      expect do
+        grouped.from_xml(
+          '<requirement><component type="other"><text>x</text></component></requirement>',
+        )
+      end.to raise_error(Lutaml::Model::UnknownDiscriminatorError, /type="other"/)
+    end
+
+    it "rejects the grouped form without a to: map" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :x, :string
+
+          xml do
+            element "x"
+            map_element "x", to: :x, when_attribute: "type"
+          end
+        end
+      end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError, /to:/)
+    end
+
+    it "rejects a Hash to: with the per-rule form" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :x, :string
+
+          xml do
+            element "x"
+            map_element "x", when_attribute: { "type" => "a" },
+                             to: { "a" => :x }
+          end
+        end
+      end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError, /single attribute/)
+    end
+
+    it "rejects namespace in the grouped form" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :x, :string
+
+          xml do
+            element "x"
+            map_element "x", when_attribute: "type",
+                             to: { "a" => :x },
+                             namespace: "https://example.com"
+          end
+        end
+      end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError, /grouped/)
+    end
+  end
+
   # Orthogonality guard: `when_attribute` partitions occurrences across
   # attributes; `polymorphic` dispatches the class of each hydrated item.
   # Different axes over the same discriminator concept — they compose on

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.46
+  version: 0.8.48
 platform: ruby
 authors:
 - Ribose Inc.