lutaml-model 0.8.31 → 0.8.33

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)
@@ -460,7 +469,31 @@ _effective_register)
         end
       end
 
-      def value_for_xml_attribute(doc, rule, rule_names)
+      # Whether no OTHER attribute rule in the mapping claims the same
+      # local name. A sole claimant is namespace-flexible on the local-
+      # name fallback: real-world documents qualify such attributes in
+      # the element's namespace, a foreign extension namespace, or not
+      # at all (OOXML w:val on w15: elements — lutaml-model#790). When
+      # a sibling claims the name, matching stays strict so each rule
+      # keeps its own namespace (#744, #758).
+      def attribute_rule_sole_local_claimant?(instance, rule,
+                                              effective_register)
+        klass = instance.class
+        return true unless klass.include?(Lutaml::Model::Serialize)
+
+        mapping = klass.mappings_for(:xml, effective_register)
+        return true unless mapping
+
+        expected = Array(rule.name).map(&:to_s)
+        mapping.mappings.none? do |sib|
+          next false unless sib.attribute? && !sib.equal?(rule)
+
+          Array(sib.name).map(&:to_s) == expected
+        end
+      end
+
+      def value_for_xml_attribute(doc, rule, rule_names,
+                                  flexible_local: false)
         # For attributes, rule_names may contain namespaced names, but find_attribute_value
         # expects prefix:name or just name, so we need to convert namespaced names to prefix format.
         #
@@ -487,7 +520,8 @@ _effective_register)
         # This handles the case where the namespace prefix is not declared in the document
         # (e.g., v:ext without xmlns:v="...").
         if value.nil? && rule_names.any? { |rn| rn.include?(":") }
-          value = find_attribute_by_local_name(doc, rule_names)
+          value = find_attribute_by_local_name(doc, rule_names,
+                                               flexible_local: flexible_local)
         end
 
         value = value&.split(rule.delimiter) if rule.delimiter
@@ -550,7 +584,8 @@ _effective_register)
       # @param doc [XmlElement] the parsed XML document root
       # @param rule_names [Array<String>] the rule names to match
       # @return [String, nil] the attribute value or nil
-      def find_attribute_by_local_name(doc, rule_names)
+      def find_attribute_by_local_name(doc, rule_names,
+                                       flexible_local: false)
         rule_names.each do |rn|
           next unless rn.include?(":")
 
@@ -570,7 +605,12 @@ _effective_register)
             # namespaced sibling attribute (lutaml-model#758). An
             # XmlAttribute with a resolved namespace has namespaced_name
             # "URI:local", so this comparison is allocation-free.
-            if attr.namespace.nil?
+            if flexible_local
+              # Sole claimant: any qualification of the local name binds
+              # (element namespace, foreign extension namespace, none).
+              attr.unprefixed_name == local_name ||
+                ((colon = attr.name.rindex(":")) ? attr.name[(colon + 1)..] : attr.name) == local_name
+            elsif attr.namespace.nil?
               next false if attr.namespace_prefix.nil? &&
                 !attr.name.include?(":")
 
@@ -621,7 +661,14 @@ _effective_register)
         # return the same children again.
         rule_names = rule_names.concat(extra_rule_names).uniq if extra_rule_names
 
-        return value_for_xml_attribute(doc, rule, rule_names) if rule.attribute?
+        if rule.attribute?
+          return value_for_xml_attribute(
+            doc, rule, rule_names,
+            flexible_local: attribute_rule_sole_local_claimant?(
+              instance, rule, effective_register
+            )
+          )
+        end
 
         # Performance: Pre-compute type-related values used in the hot loop
         attr_type_is_serializable = attr_type && attr_type <= ::Lutaml::Model::Serialize
@@ -773,6 +820,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 +848,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 +872,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 +880,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 +891,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 +914,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 +980,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