lutaml-model 0.8.30 → 0.8.32

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.30"
+    VERSION = "0.8.32"
   end
 end

data/lib/lutaml/xml/format.rb

@@ -128,6 +128,8 @@ module Lutaml
     autoload :TransformationBuilder, "#{__dir__}/transformation_builder"
     autoload :AdapterLoader, "#{__dir__}/adapter_loader"
     autoload :Element, "#{__dir__}/element"
+    autoload :NestedCollectionAttribute,
+             "#{__dir__}/nested_collection_attribute"
     autoload :ModelTransform, "#{__dir__}/model_transform"
     autoload :ParseSession, "#{__dir__}/parse_session"
     autoload :TypeNamespaceResolver, "#{__dir__}/type_namespace_resolver"
@@ -239,7 +241,21 @@ Lutaml::Model::Serialize.prepend(
 # ModelImportExt override (root?) must land on ClassMethods too. The other
 # two (FormatConversion, InstanceMethods) are already prepended unconditionally
 # above, so Opal's no-double-prepend rule means we don't repeat them here.
-if Lutaml::Model.opal?
+#
+# TruffleRuby (34.0.1) has the same propagation gap, on both the include
+# side and the extend/singleton side — a module prepended into an
+# already-extended module does not reach prior extenders' singleton chains
+# either (https://github.com/truffleruby/truffleruby/issues/4452). Without
+# the include-side re-prepends below, Mml.parse et al. die with
+# "undefined method 'pending_plan_root_element='". The extend side
+# additionally needs FormatConversion re-prepended onto Serializable's
+# singleton: otherwise `model PlainClass` runs the no-op base
+# add_format_specific_model_methods and plain (non-Serialize) model classes
+# never receive their XML accessors (encoding=, element_order=, ordered=,
+# mixed, doctype, xml_declaration, raw_schema_location), so
+# ModelTransform#apply_xml_mapping dies at `instance.encoding = ...` —
+# e.g. every relaton ItemData parse via Relaton::Cli.parse_xml.
+if Lutaml::Model.opal? || RUBY_ENGINE == "truffleruby"
   Lutaml::Model::Serializable.singleton_class.prepend(
     Lutaml::Xml::Serialization::ModelImportExt,
   )
@@ -251,6 +267,14 @@ if Lutaml::Model.opal?
   Lutaml::Model::Serialize::ClassMethods.prepend(
     Lutaml::Xml::Serialization::ModelImportExt,
   )
+
+  # TruffleRuby only: Opal's no-double-prepend rule makes the unconditional
+  # ClassMethods.prepend(FormatConversion) above sufficient there.
+  if RUBY_ENGINE == "truffleruby"
+    Lutaml::Model::Serializable.singleton_class.prepend(
+      Lutaml::Xml::Serialization::FormatConversion,
+    )
+  end
 end
 
 # Register XML-specific attribute override warning names

data/lib/lutaml/xml/mapping_rule.rb

@@ -323,7 +323,13 @@ module Lutaml
         strict_match = uri && ns_info[:prefix] &&
           !ns_info[:unqualified_same_ns] && !ns_info[:via_schema_default]
         if strict_match
-          ["#{uri}:#{name}"].freeze
+          # Type-level qualification stays lenient on parse: a W3C
+          # unprefixed attribute carries no namespace, and 0.8.19 bound
+          # it to the type-qualified rule (lutaml-model#786). Only rule
+          # and schema-level qualification is strictly prefixed-only.
+          names = ["#{uri}:#{name}"]
+          names << name.to_s if ns_info[:via_type_namespace]
+          names.freeze
         else
           namespaced_names(default_namespace)
         end
@@ -471,6 +477,7 @@ form_default = :unqualified)
         if attr && (type_ns_class = attr.type_namespace_class(register)) &&
             type_ns_class != :blank
           result = build_namespace_result_from_class(type_ns_class)
+          result[:via_type_namespace] = true
           # CRITICAL W3C FLAG: Mark when attribute is in same namespace as parent with :unqualified
           # Serialization code will check this to omit prefix per attributeFormDefault
           if type_ns_class.uri == parent_ns_class&.uri && form_default == :unqualified

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
 
@@ -985,9 +1009,41 @@ effective_register = lutaml_register)
           parent_ns_class = nil
           form_default = :unqualified
         end
-        rule.attribute_match_names(attr, effective_register, parent_ns_class,
-                                   form_default,
-                                   options[:default_namespace])
+        names = rule.attribute_match_names(attr, effective_register,
+                                           parent_ns_class, form_default,
+                                           options[:default_namespace])
+
+        # #786 lenient alias (["uri:name", "name"] from a type-qualified
+        # rule): the unprefixed form must not steal the value when a
+        # sibling namespace-less rule owns the bare local name (#744
+        # disjointness). No sibling — the alias keeps 0.8.19 leniency.
+        if names.size == 2 && !names[1].include?(":") &&
+            instance_is_serialize &&
+            unqualified_sibling_attribute_rule?(instance, rule,
+                                                effective_register)
+          names = names.first(1)
+        end
+        names
+      end
+
+      # Whether another attribute rule with the same local name resolves
+      # namespace-less (no rule namespace, no value-type namespace) —
+      # the #744 owner of the unprefixed source form.
+      def unqualified_sibling_attribute_rule?(instance, rule,
+                                              effective_register)
+        mapping = instance.class.mappings_for(:xml, effective_register)
+        return false unless mapping
+
+        attrs = instance.class.attributes(effective_register)
+        mapping.mappings.any? do |sib|
+          next false unless sib.attribute? && !sib.equal?(rule)
+          next false unless sib.name.to_s == rule.name.to_s
+          next false if sib.namespace_set?
+
+          sib_attr = attrs[sib.to]
+          type_ns = sib_attr&.type_namespace_class(effective_register)
+          type_ns.nil? || type_ns == :blank
+        end
       end
 
       # [namespace_class, attribute_form_default] for the instance's model,

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