lutaml-model 0.8.30 → 0.8.32

data/lib/lutaml/xml/serialization/instance_methods.rb

@@ -266,8 +266,8 @@ module Lutaml
         # Append XSD schema errors (validate_xml_with macro) to the
         # standard validation errors. No-op unless schemas are configured.
         #
-        # @see Lutaml::Model::Validation#validate
-        def validate(register: Lutaml::Model::Config.default_register)
+        # @see Lutaml::Model::Validation#collect_validation_errors
+        def collect_validation_errors(register)
           errors = super
           return errors if self.class.xml_schema_paths.empty?
 

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

@@ -12,6 +12,7 @@ module Lutaml
       # - Simple value serialization
       module ElementBuilder
         include ValueSerializer
+        include ::Lutaml::Xml::NestedCollectionAttribute
 
         # Create an element for a value
         #
@@ -140,9 +141,25 @@ parent_element_form_default)
           actual_class = resolve_polymorphic_class(rule, value, is_polymorphic,
                                                    is_polymorphic_subtype)
 
+          # Dispatch on value's actual class when it is a Serializable that
+          # differs from the declared attribute_type. This covers ad-hoc
+          # polymorphism (caller assigns an unrelated Serializable to a typed
+          # slot) and prevents the wrong transformation being applied
+          # silently. Subsumes is_polymorphic_subtype; preserved here for
+          # the resolve_polymorphic_class call above.
+          union || is_polymorphic ||
+            (value.is_a?(Lutaml::Model::Serialize) &&
+             value.class != rule.attribute_type)
+
           # Get transformation for the actual class. Unions resolve the member
           # from the value's own class, like polymorphism.
-          child_transformation = if union
+          # Unions and unrelated Serializables dispatch on the value's
+          # own class (subsumes the subtype case); polymorphic config
+          # keeps its resolved-class dispatch (the class_map target).
+          child_transformation = if union ||
+              (!is_polymorphic &&
+               value.is_a?(Lutaml::Model::Serialize) &&
+               value.class != rule.attribute_type)
                                    value.class.transformation_for(:xml,
                                                                   register)
                                  elsif is_polymorphic || is_polymorphic_subtype
@@ -233,6 +250,9 @@ child_transformation)
             prefixes = parent_model.xml_ns_prefixes
             ns_prefix = prefixes[rule.attribute_name] if prefixes
           end
+          ns_prefix_present = ns_prefix && !ns_prefix.empty?
+          nested_collection_attribute =
+            nested_collection_attribute_value?(rule, value)
           child_self_declared_ns = child_ns_class &&
             parent_ns_class &&
             child_ns_class != parent_ns_class
@@ -252,18 +272,24 @@ child_transformation)
           # This preserves the dual-namespace behavior (w:rPr inside m:r) while preventing
           # stale prefixes (dcterms prefix leaking to children that should use default ns).
           dual_namespace_applies = child_self_declared_ns && ns_prefix_valid
+          parent_prefix_applies_to_child =
+            !nested_collection_attribute &&
+            ns_prefix_present &&
+            !child_self_declared_ns &&
+            (parent_ns_class.nil? ||
+              (child_ns_class && child_ns_class.uri == parent_ns_class.uri) ||
+              dual_namespace_applies)
           # Parent has no ns OR child shares parent's URI (and child doesn't self-declare ns)
           # OR dual-namespace case where child's ns_prefix matches its namespace expectation
-          if (parent_ns_class.nil? || (child_ns_class && child_ns_class.uri == parent_ns_class.uri) ||
-              dual_namespace_applies) &&
-              !child_self_declared_ns && ns_prefix && !ns_prefix.empty?
-            value.xml_namespace_prefix = ns_prefix
-          end
+          value.xml_namespace_prefix = ns_prefix if parent_prefix_applies_to_child
+
+          dual_namespace_prefix_applies =
+            !nested_collection_attribute &&
+            dual_namespace_applies &&
+            ns_prefix_present
           # For dual-namespace case: set @__xml_namespace_prefix on model so it can be
           # transferred to XmlElement at lines 282-289 for prefix preservation.
-          if dual_namespace_applies && ns_prefix && !ns_prefix.empty?
-            value.xml_namespace_prefix = ns_prefix
-          end
+          value.xml_namespace_prefix = ns_prefix if dual_namespace_prefix_applies
 
           child_element = child_transformation.transform(value, child_options)
 
@@ -301,6 +327,16 @@ child_transformation)
             child_element.xml_namespace_prefix = nil
           end
 
+          if nested_collection_attribute_element?(rule, value, child_element)
+            return create_nested_collection_wrapper_element(
+              rule,
+              child_element,
+              options,
+              parent_ns_class,
+              parent_element_form_default,
+            )
+          end
+
           # Use parent's mapping name, not child's root name
           if rule.serialized_name != child_element.name
             child_element.name = rule.serialized_name
@@ -314,6 +350,33 @@ child_transformation)
           child_element
         end
 
+        def create_nested_collection_wrapper_element(
+          rule,
+          child_element,
+          options,
+          parent_ns_class,
+          parent_element_form_default
+        )
+          element_namespace_class = determine_element_namespace(
+            rule,
+            parent_ns_class,
+            parent_element_form_default,
+          )
+          element = ::Lutaml::Xml::DataModel::XmlElement.new(
+            rule.serialized_name,
+            element_namespace_class,
+          )
+
+          ns_prefix = nested_collection_wrapper_prefix(rule, options)
+          element.xml_namespace_prefix = ns_prefix if ns_prefix
+
+          propagate_form(element, rule)
+          apply_unqualified_form_default(
+            element, rule, parent_ns_class, parent_element_form_default
+          )
+          element.add_child(child_element)
+        end
+
         # Check if a prefix is valid for a namespace class by verifying it maps to the same URI.
         # This ensures we only use ns_prefix from @__xml_ns_prefixes when it actually matches
         # the child's expected namespace prefix.

data/lib/lutaml/yaml/adapter/document.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "lutaml/key_value/document"
+
 module Lutaml
   module Yaml
     module Adapter

data/lib/lutaml/yaml/adapter/standard_adapter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "document"
+
 require "date"
 require "yaml"
 

data/lib/lutaml/yaml/adapter/yeptris_adapter.rb

@@ -36,9 +36,13 @@ module Lutaml
                                       @attributes
                                     end
 
-          require "yeptris"
-          require "yeptris/yaml"
-          Yeptris::YAML.dump(attributes_to_serialize)
+          # Generation must match the standard (Psych) adapter's output
+          # byte-for-byte: document separator, quoting of digit-leading
+          # strings, flow styles. The neutral Yeptris::YAML.dump is
+          # deliberately headerless, so parity goes through the
+          # Psych-compatible face of the same engine.
+          require "yeptris/psych"
+          Yeptris::Psych.dump(attributes_to_serialize)
         end
       end
     end

data/spec/lutaml/model/attribute_collection_spec.rb

@@ -27,6 +27,68 @@ module AttributeCollection
       title_parts.to_s
     end
   end
+
+  class NestedTitle < Lutaml::Model::Serializable
+    attribute :content, :string
+
+    xml do
+      element "artifact"
+      map_element "content", to: :content
+    end
+  end
+
+  class NestedTitleCollection < Lutaml::Model::Collection
+    instances :items, NestedTitle
+
+    xml do
+      element "title-group"
+      map_element "artifact", to: :items
+    end
+  end
+
+  class NestedBibliographicItem < Lutaml::Model::Serializable
+    attribute :titles, NestedTitleCollection
+
+    xml do
+      element "bibitem"
+      map_element "titles", to: :titles
+    end
+  end
+
+  class NestedTitleNamespace < Lutaml::Xml::Namespace
+    uri "http://example.com/nested-title"
+    uri_aliases "http://example.com/nested-title-alias"
+    prefix_default "nt"
+  end
+
+  class NamespacedNestedTitle < Lutaml::Model::Serializable
+    attribute :content, :string
+
+    xml do
+      element "artifact"
+      namespace NestedTitleNamespace
+      map_element "content", to: :content
+    end
+  end
+
+  class NamespacedNestedTitleCollection < Lutaml::Model::Collection
+    instances :items, NamespacedNestedTitle
+
+    xml do
+      element "title-group"
+      namespace NestedTitleNamespace
+      map_element "artifact", to: :items
+    end
+  end
+
+  class NamespacedNestedBibliographicItem < Lutaml::Model::Serializable
+    attribute :titles, NamespacedNestedTitleCollection
+
+    xml do
+      element "bibitem"
+      map_element "titles", to: :titles
+    end
+  end
 end
 
 RSpec.describe AttributeCollection do
@@ -101,4 +163,98 @@ RSpec.describe AttributeCollection do
       expect(bib_item.title_parts.parts).to eq(["Custom One", "Custom Two"])
     end
   end
+
+  describe "BibliographicItem with nested collection element" do
+    let(:nested_xml_data) do
+      <<~XML
+        <bibitem>
+          <titles>
+            <title-group>
+              <artifact>
+                <content>Title One</content>
+              </artifact>
+              <artifact>
+                <content>Title Two</content>
+              </artifact>
+              <artifact>
+                <content>Title Three</content>
+              </artifact>
+            </title-group>
+          </titles>
+        </bibitem>
+      XML
+    end
+
+    it "deserializes the collection from its nested root element" do
+      bib_item = AttributeCollection::NestedBibliographicItem.from_xml(
+        nested_xml_data,
+      )
+
+      expect(bib_item.titles).to be_a(AttributeCollection::NestedTitleCollection)
+      expect(bib_item.titles.items.map(&:content)).to eq(
+        ["Title One", "Title Two", "Title Three"],
+      )
+    end
+
+    it "serializes the collection under the mapped parent element" do
+      titles = AttributeCollection::NestedTitleCollection.new(
+        [
+          AttributeCollection::NestedTitle.new(content: "Title One"),
+          AttributeCollection::NestedTitle.new(content: "Title Two"),
+          AttributeCollection::NestedTitle.new(content: "Title Three"),
+        ],
+      )
+      bib_item = AttributeCollection::NestedBibliographicItem.new(
+        titles: titles,
+      )
+
+      expect(bib_item.to_xml).to be_xml_equivalent_to(nested_xml_data)
+    end
+
+    it "does not unwrap a matching collection root from the wrong namespace" do
+      xml = <<~XML
+        <bibitem xmlns:nt="http://example.com/nested-title"
+                 xmlns:other="http://example.com/other-title">
+          <titles>
+            <other:title-group>
+              <other:artifact>
+                <other:content>Wrong namespace</other:content>
+              </other:artifact>
+            </other:title-group>
+            <nt:title-group>
+              <nt:artifact>
+                <nt:content>Right namespace</nt:content>
+              </nt:artifact>
+            </nt:title-group>
+          </titles>
+        </bibitem>
+      XML
+
+      bib_item = AttributeCollection::NamespacedNestedBibliographicItem.from_xml(
+        xml,
+      )
+
+      expect(bib_item.titles.items.map(&:content)).to eq(["Right namespace"])
+    end
+
+    it "accepts namespace aliases for the nested collection root" do
+      xml = <<~XML
+        <bibitem xmlns:alias="http://example.com/nested-title-alias">
+          <titles>
+            <alias:title-group>
+              <alias:artifact>
+                <alias:content>Alias namespace</alias:content>
+              </alias:artifact>
+            </alias:title-group>
+          </titles>
+        </bibitem>
+      XML
+
+      bib_item = AttributeCollection::NamespacedNestedBibliographicItem.from_xml(
+        xml,
+      )
+
+      expect(bib_item.titles.items.map(&:content)).to eq(["Alias namespace"])
+    end
+  end
 end

data/spec/lutaml/model/attribute_spec.rb

@@ -43,7 +43,7 @@ RSpec.describe Lutaml::Model::Attribute do
     expect { obj.image = Pathname.new("avatar.png") }
       .to change { obj.image }
       .from(nil)
-      .to("avatar.png")
+      .to(["avatar.png"])
   end
 
   it "raises error if both type and method_name are not given" do