lutaml-model 0.8.31 → 0.8.32

data/lib/lutaml/xml/model_transform.rb

@@ -12,6 +12,8 @@ module Lutaml
     # - Used by model's serialization pipeline via Transform.for(:xml)
     #
     class ModelTransform < ::Lutaml::Model::Transform
+      include NestedCollectionAttribute
+
       # Performance: Frozen empty hash to reduce allocations
       EMPTY_HASH = {}.freeze
 
@@ -361,6 +363,13 @@ module Lutaml
           value = normalize_xml_value(value, rule, attr, new_opts,
                                       effective_register)
           value = rule.transform_value(attr, value, :from, :xml)
+          # An over-count is normally left for `.validate` to report. A mapped
+          # PORO has no `.validate`, so deferring there would discard the
+          # violation entirely — check it while there is still someone to tell.
+          if !instance_is_serialize && attr && !attr.collection? &&
+              !rule.content_mapping?
+            attr.valid_collection!(value, context)
+          end
           rule.deserialize(instance, value, attributes, context)
 
           instance.value_set_for(rule_to)
@@ -773,6 +782,10 @@ _effective_register)
         rule_has_custom_method = rule.has_custom_method_for_deserialization?
         if rule_has_custom_method || attr_type == ::Lutaml::Model::Type::Hash
           return_child = attr_type == ::Lutaml::Model::Type::Hash || !attr.collection? if attr
+          # A custom `from:` receives the over-count in the same shape a custom
+          # `to:` already gets for a collection.
+          return children if attr && !attr.collection? && children.size > 1
+
           return return_child ? children.first : children
         end
 
@@ -797,12 +810,20 @@ _effective_register)
         base_cast_options[:lutaml_root] = instance.lutaml_root || instance
         base_cast_options[:resolved_type] = attr_type
 
+        nested_mapping = nested_collection_attribute_mapping(attr, attr_type, effective_register)
+
         children.each do |child|
           if !rule_has_custom_method &&
               (attr_type_is_serializable ||
                 (attr&.union? && ::Lutaml::Model::Type::Union.xml_structured?(child)))
+            cast_child = if attr_type_is_serializable
+                           nested_collection_attribute_node(child, nested_mapping)
+                         else
+                           child
+                         end
+
             # Performance: Build cast_options efficiently (dup + []= cheaper than merge)
-            cast_options = if (child_namespace_uri = child.namespace_uri)
+            cast_options = if (child_namespace_uri = cast_child.namespace_uri)
                              ns_type = attr.type_with_namespace(effective_register,
                                                                 child_namespace_uri)
                              cast_options = base_cast_options.dup
@@ -813,7 +834,7 @@ _effective_register)
                              base_cast_options
                            end
 
-            cast_result = attr.cast(child, :xml, effective_register,
+            cast_result = attr.cast(cast_child, :xml, effective_register,
                                     cast_options)
 
             # Track original namespace prefix for doubly-defined namespace support.
@@ -821,10 +842,7 @@ _effective_register)
             # we need to preserve which prefix was used for round-trip fidelity.
             # Store on the PARENT model instance keyed by attribute name.
             # Set for ALL attributes (both Serializable and non-Serializable).
-            ns_prefix = if child.namespace_prefix_explicit &&
-                child.namespace_prefix
-                          child.namespace_prefix
-                        end
+            ns_prefix = explicit_namespace_prefix(child)
             if ns_prefix && instance_is_serialize
               prefixes = instance.xml_ns_prefixes || {}
               prefixes[attr.name] = ns_prefix
@@ -835,7 +853,7 @@ _effective_register)
             # When parsing XML with alias URIs (e.g., "http://.../") against a namespace
             # class with canonical URI (e.g., "http://.../reqif.xsd"), store the original
             # alias URI so it can be serialized back correctly.
-            child_uri = child.namespace_uri
+            child_uri = cast_child.namespace_uri
             if child_uri && attr_type_is_serializable
               child_mapping = cast_result.class.mappings_for(:xml)
               child_ns_class = child_mapping&.namespace_class
@@ -858,8 +876,10 @@ _effective_register)
             # - Nil/empty: doubly-defined case -> set @__xml_namespace_prefix on child
             # - Set: mixed content case -> don't set (child has its own namespace)
             # Performance: Use cached parent_ns_prefix instead of re-fetching
-            if attr_type_is_serializable && ns_prefix && (parent_ns_prefix.nil? || parent_ns_prefix.to_s.empty?)
-              cast_result.xml_namespace_prefix = ns_prefix
+            cast_child_ns_prefix = nested_collection_attribute_prefix(child, cast_child, ns_prefix)
+            if attr_type_is_serializable && cast_child_ns_prefix &&
+                (parent_ns_prefix.nil? || parent_ns_prefix.to_s.empty?)
+              cast_result.xml_namespace_prefix = cast_child_ns_prefix
             end
 
             values << cast_result
@@ -922,6 +942,10 @@ _effective_register)
         return [] if attr&.collection? && [[nil], [""]].include?(values)
         return values if attr&.collection?
 
+        # Keep the over-count (don't collapse via .first) so it reaches the
+        # attribute slot and `.validate` can report the cardinality violation.
+        return values if values.is_a?(Array) && values.size > 1
+
         values.is_a?(Array) ? values.first : values
       end
 

data/lib/lutaml/xml/nested_collection_attribute.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module NestedCollectionAttribute
+      private
+
+      def nested_collection_attribute_mapping(attr, attr_type, register)
+        return unless nested_collection_attribute?(attr, attr_type)
+
+        collection_mapping = attr_type.mappings_for(:xml, register)
+        root_name = collection_mapping&.element_name ||
+          collection_mapping&.root_element
+        return if root_name.nil?
+
+        root_name = root_name.to_s
+        return if root_name.empty?
+
+        [root_name, collection_mapping]
+      end
+
+      def nested_collection_attribute_node(child, nested_collection_mapping)
+        return child unless nested_collection_mapping
+
+        root_name, collection_mapping = nested_collection_mapping
+        return child if xml_element_matches_name?(child, root_name,
+                                                  collection_mapping)
+
+        child.element_children.find do |nested_child|
+          xml_element_matches_name?(nested_child, root_name,
+                                    collection_mapping)
+        end || child
+      end
+
+      def nested_collection_attribute_prefix(child, cast_child, ns_prefix)
+        return ns_prefix if cast_child.equal?(child)
+
+        explicit_namespace_prefix(cast_child)
+      end
+
+      def nested_collection_attribute_element?(rule, value, child_element)
+        nested_collection_attribute_value?(rule, value) &&
+          rule.serialized_name != child_element.name
+      end
+
+      def nested_collection_attribute_value?(rule, value)
+        value.is_a?(::Lutaml::Model::Collection) &&
+          nested_collection_attribute_type?(rule.attribute_type) &&
+          !rule.collection?
+      end
+
+      def nested_collection_wrapper_prefix(rule, options)
+        parent_model = options[:current_model]
+        return unless parent_model.is_a?(::Lutaml::Model::Serialize)
+
+        prefix = parent_model.xml_ns_prefixes&.[](rule.attribute_name)
+        prefix unless prefix.to_s.empty?
+      end
+
+      def explicit_namespace_prefix(element)
+        return unless element.namespace_prefix_explicit &&
+          element.namespace_prefix
+
+        element.namespace_prefix
+      end
+
+      def nested_collection_attribute?(attr, attr_type)
+        attr&.singular? && nested_collection_attribute_type?(attr_type)
+      end
+
+      def nested_collection_attribute_type?(attr_type)
+        attr_type.is_a?(Class) &&
+          attr_type <= ::Lutaml::Model::Collection
+      end
+
+      def xml_element_matches_name?(element, name, mapping)
+        element.unprefixed_name == name &&
+          xml_element_matches_namespace?(element.namespace_uri, mapping)
+      end
+
+      def xml_element_matches_namespace?(namespace_uri, mapping)
+        namespace_class = mapping&.namespace_class
+        mapping_uri = mapping&.namespace_uri
+        return namespace_uri.nil? unless namespace_class || mapping_uri
+        return true if mapping_uri && namespace_uri == mapping_uri
+
+        if namespace_class.respond_to?(:all_uris)
+          namespace_class.all_uris.include?(namespace_uri)
+        else
+          namespace_uri == namespace_class&.uri
+        end
+      end
+    end
+  end
+end