lutaml-model 0.7.7 → 0.8.0

data/spec/lutaml/model/mixed_content_spec.rb

@@ -1,18 +1,20 @@
 # spec/lutaml/model/mixed_content_spec.rb
 
 require "spec_helper"
-require "lutaml/model"
-require "lutaml/model/xml/nokogiri_adapter"
-require "lutaml/model/xml/ox_adapter"
-require "lutaml/model/xml/oga_adapter"
+require_relative "../../../lib/lutaml/model"
+require "lutaml/xml/adapter/nokogiri_adapter"
+require "lutaml/xml/adapter/ox_adapter"
+require "lutaml/xml/adapter/oga_adapter"
+require "lutaml/xml/adapter/rexml_adapter"
 require_relative "../../fixtures/sample_model"
+require_relative "../../support/xml_mapping_namespaces"
 
 module MixedContentSpec
   class PlanetaryBody < Lutaml::Model::Serializable
     attribute :name, :string
     attribute :distance_from_earth, :integer
     xml do
-      root "PlanetaryBody"
+      element "PlanetaryBody"
       map_element "Name", to: :name
       map_element "DistanceFromEarth", to: :distance_from_earth
     end
@@ -22,7 +24,7 @@ module MixedContentSpec
     attribute :content, :string
 
     xml do
-      root "source"
+      element "source"
       map_content to: :content
     end
   end
@@ -31,7 +33,7 @@ module MixedContentSpec
     attribute :source, Source
 
     xml do
-      root "element-citation"
+      element "element-citation"
       map_element "source", to: :source
     end
   end
@@ -40,7 +42,7 @@ module MixedContentSpec
     attribute :element_citation, ElementCitation
 
     xml do
-      root "ref"
+      element "ref"
       map_element "element-citation", to: :element_citation
     end
   end
@@ -49,7 +51,7 @@ module MixedContentSpec
     attribute :ref, Ref
 
     xml do
-      root "ref-list"
+      element "ref-list"
       map_element "ref", to: :ref
     end
   end
@@ -58,7 +60,7 @@ module MixedContentSpec
     attribute :ref_list, RefList
 
     xml do
-      root "back"
+      element "back"
       map_element "ref-list", to: :ref_list
     end
   end
@@ -67,7 +69,7 @@ module MixedContentSpec
     attribute :back, Back
 
     xml do
-      root "article"
+      element "article"
       map_element "back", to: :back
     end
   end
@@ -78,7 +80,7 @@ module MixedContentSpec
     attribute :heading, :string
 
     xml do
-      root "note"
+      element "note"
       map_element "to", to: :the
       map_element "from", to: :from
       map_element "heading", to: :heading
@@ -89,16 +91,17 @@ module MixedContentSpec
     attribute :field, :string, collection: true
 
     xml do
-      root "root"
+      element "root"
       map_element "FieldName", to: :field
     end
   end
 
   class SpecialCharContentWithMixedTrue < Lutaml::Model::Serializable
-    attribute :content, :string
+    attribute :content, :string, collection: true
 
     xml do
-      root "SpecialCharContentWithMixedTrue", mixed: true
+      element "SpecialCharContentWithMixedTrue"
+      mixed_content
       map_content to: :content
     end
   end
@@ -107,7 +110,8 @@ module MixedContentSpec
     attribute :special, :string, raw: true
 
     xml do
-      root "SpecialCharContentWithRawOptionAndMixedOption", mixed: true
+      element "SpecialCharContentWithRawOptionAndMixedOption"
+      mixed_content
       map_element :special, to: :special
     end
   end
@@ -117,10 +121,11 @@ module MixedContentSpec
     attribute :bold, :string, collection: true
     attribute :italic, :string, collection: true
     attribute :underline, :string
-    attribute :content, :string
+    attribute :content, :string, collection: true
 
     xml do
-      root "RootMixedContent", mixed: true
+      element "RootMixedContent"
+      mixed_content
       map_attribute :id, to: :id
       map_element :bold, to: :bold
       map_element :italic, to: :italic
@@ -135,10 +140,11 @@ module MixedContentSpec
     attribute :italic, :string, collection: true
     attribute :underline, :string
     attribute :planetary_body, PlanetaryBody
-    attribute :content, :string
+    attribute :content, :string, collection: true
 
     xml do
-      root "RootMixedContentWithModel", mixed: true
+      element "RootMixedContentWithModel"
+      mixed_content
       map_content to: :content
       map_attribute :id, to: :id
       map_element :bold, to: :bold
@@ -150,13 +156,14 @@ module MixedContentSpec
 
   class RootMixedContentNested < Lutaml::Model::Serializable
     attribute :id, :string
-    attribute :text, :string
+    attribute :text, :string, collection: true
     attribute :content, RootMixedContent
     attribute :sup, :string, collection: true
     attribute :sub, :string, collection: true
 
     xml do
-      root "RootMixedContentNested", mixed: true
+      element "RootMixedContentNested"
+      mixed_content
       map_content to: :text
       map_attribute :id, to: :id
       map_element :sup, to: :sup
@@ -167,13 +174,14 @@ module MixedContentSpec
 
   class RootMixedContentNestedWithModel < Lutaml::Model::Serializable
     attribute :id, :string
-    attribute :text, :string
+    attribute :text, :string, collection: true
     attribute :content, RootMixedContentWithModel
     attribute :sup, :string, collection: true
     attribute :sub, :string, collection: true
 
     xml do
-      root "RootMixedContentNestedWithModel", mixed: true
+      element "RootMixedContentNestedWithModel"
+      mixed_content
 
       map_content to: :text
       map_attribute :id, to: :id
@@ -187,7 +195,7 @@ module MixedContentSpec
     attribute :value, :string
 
     xml do
-      root "TextualSupport"
+      element "TextualSupport"
 
       map_element :value, to: :value
     end
@@ -197,10 +205,76 @@ module MixedContentSpec
     attribute :content, :string
 
     xml do
-      root "HexCode"
+      element "HexCode"
       map_content to: :content
     end
   end
+
+  module PrefixedElements
+    class Annotation < Lutaml::Model::Serializable
+      attribute :content, :string
+
+      xml do
+        element "annotation"
+        namespace ExampleSchemaNamespace
+
+        map_content to: :content
+      end
+    end
+
+    class Element < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :status, :string
+      attribute :annotation, Annotation
+
+      xml do
+        element "element"
+        mixed_content
+
+        namespace ExampleSchemaNamespace
+
+        map_attribute :name, to: :name
+        map_attribute :status, to: :status
+        map_element :annotation, to: :annotation
+      end
+    end
+
+    class Schema < Lutaml::Model::Serializable
+      attribute :element, Element, collection: true
+
+      xml do
+        element "schema"
+        namespace ExampleSchemaNamespace
+
+        map_element :element, to: :element
+      end
+    end
+  end
+
+  # Models for mutation-after-deserialization tests (issue #630)
+  class MiElement < Lutaml::Model::Serializable
+    attribute :value, :string, collection: true
+    attribute :mathvariant, :string
+
+    xml do
+      root "mi"
+      mixed_content
+      map_content to: :value
+      map_attribute "mathvariant", to: :mathvariant
+    end
+  end
+
+  class ParaMixedContent < Lutaml::Model::Serializable
+    attribute :content, :string, collection: true
+    attribute :bold, :string
+
+    xml do
+      root "p"
+      mixed_content
+      map_content to: :content
+      map_element "b", to: :bold
+    end
+  end
 end
 
 RSpec.describe "MixedContent" do
@@ -246,7 +320,7 @@ RSpec.describe "MixedContent" do
 
           # due to the difference in capturing
           # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::Xml::OxAdapter
+          if adapter_class == Lutaml::Xml::Adapter::OxAdapter
             expected_output = expected_output.gsub(/\n\s*/, " ")
           end
 
@@ -254,7 +328,17 @@ RSpec.describe "MixedContent" do
         end
 
         serialized = parsed.to_xml
-        expect(serialized).to be_equivalent_to(xml)
+
+        # Ox normalizes whitespace in mixed content per XML spec (semantically equivalent)
+        # Canon can't compare whitespace-normalized XML, so we normalize both sides for Ox
+        if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+          normalize = ->(str) {
+            str.gsub(/\s+/, " ").gsub(/\s*</, "<").gsub(/>\s*/, ">").strip
+          }
+          expect(normalize.call(serialized)).to eq(normalize.call(xml))
+        else
+          expect(serialized).to be_xml_equivalent_to(xml)
+        end
       end
     end
 
@@ -297,7 +381,7 @@ RSpec.describe "MixedContent" do
 
           # due to the difference in capturing
           # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::Xml::OxAdapter
+          if adapter_class == Lutaml::Xml::Adapter::OxAdapter
             expected_output = expected_output.gsub(/\n\s*/, " ")
           end
 
@@ -308,7 +392,17 @@ RSpec.describe "MixedContent" do
         expect(parsed.planetary_body.distance_from_earth).to eq(384400)
 
         serialized = parsed.to_xml
-        expect(serialized).to be_equivalent_to(xml)
+
+        # Ox normalizes whitespace in mixed content per XML spec (semantically equivalent)
+        # Canon can't compare whitespace-normalized XML, so we normalize both sides for Ox
+        if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+          normalize = ->(str) {
+            str.gsub(/\s+/, " ").gsub(/\s*</, "<").gsub(/>\s*/, ">").strip
+          }
+          expect(normalize.call(serialized)).to eq(normalize.call(xml))
+        else
+          expect(serialized).to be_xml_equivalent_to(xml)
+        end
       end
     end
 
@@ -339,6 +433,12 @@ RSpec.describe "MixedContent" do
           ".\n    Ain't that ",
           "?\n  ",
         ]
+        expected_nokogiri_content = [
+          "\n    The Earth's Moon rings like a bell when struck by\n",
+          "    meteroids. Distanced from the Earth by 384,400 km,\n",
+          "    its surface is covered in craters.\n",
+          "    Ain't that cool?\n  ",
+        ].join
 
         expect(parsed.id).to eq("outer123")
         expect(parsed.sup).to eq(["1", "2"])
@@ -348,20 +448,33 @@ RSpec.describe "MixedContent" do
         expect(parsed.content.italic).to eq(["384,400 km"])
         expect(parsed.content.underline).to eq("craters")
 
-        parsed.content.content.each_with_index do |content, index|
-          expected_output = expected_content[index]
+        if parsed.content.content.is_a?(Array)
+          parsed.content.content.each_with_index do |content, index|
+            expected_output = expected_content[index]
 
-          # due to the difference in capturing
-          # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::Xml::OxAdapter
-            expected_output = expected_output.gsub(/\n\s*/, " ")
-          end
+            # due to the difference in capturing
+            # newlines in ox and nokogiri adapters
+            if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+              expected_output = expected_output.gsub(/\n\s*/, " ")
+            end
 
-          expect(content).to eq(expected_output)
+            expect(content).to eq(expected_output)
+          end
+        else
+          expect(parsed.content.content).to eq(expected_nokogiri_content)
         end
-
         serialized = parsed.to_xml
-        expect(serialized).to be_equivalent_to(xml)
+
+        # Ox normalizes whitespace in mixed content per XML spec (semantically equivalent)
+        # Canon can't compare whitespace-normalized XML, so we normalize both sides for Ox
+        if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+          normalize = ->(str) {
+            str.gsub(/\s+/, " ").gsub(/\s*</, "<").gsub(/>\s*/, ">").strip
+          }
+          expect(normalize.call(serialized)).to eq(normalize.call(xml))
+        else
+          expect(serialized).to be_xml_equivalent_to(xml)
+        end
       end
     end
 
@@ -398,6 +511,17 @@ RSpec.describe "MixedContent" do
           "?\n    ",
           "\n    NOTE: The above model content is to be formatted as a table.\n  ",
         ]
+        expected_nokogiri_content = [
+          "\n    The Earth's Moon rings like a bell when struck by\n",
+          "    meteroids. Distanced from the Earth by 384,400 km,\n",
+          "    its surface is covered in craters.\n",
+          "    Ain't that cool?\n",
+          "    \n",
+          "      Moon\n",
+          "      384400\n",
+          "    \n",
+          "    NOTE: The above model content is to be formatted as a table.\n  ",
+        ].join
 
         expect(parsed.id).to eq("outer123")
         expect(parsed.sup).to eq(["1", "2"])
@@ -407,23 +531,37 @@ RSpec.describe "MixedContent" do
         expect(parsed.content.italic).to eq(["384,400 km"])
         expect(parsed.content.underline).to eq("craters")
 
-        parsed.content.content.each_with_index do |content, index|
-          expected_output = expected_content[index]
+        if parsed.content.content.is_a?(Array)
+          parsed.content.content.each_with_index do |content, index|
+            expected_output = expected_content[index]
 
-          # due to the difference in capturing
-          # newlines in ox and nokogiri adapters
-          if adapter_class == Lutaml::Model::Xml::OxAdapter
-            expected_output = expected_output.gsub(/\n\s*/, " ")
-          end
+            # due to the difference in capturing
+            # newlines in ox and nokogiri adapters
+            if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+              expected_output = expected_output.gsub(/\n\s*/, " ")
+            end
 
-          expect(content).to eq(expected_output)
+            expect(content).to eq(expected_output)
+          end
+        else
+          expect(parsed.content.content).to eq(expected_nokogiri_content)
         end
 
         expect(parsed.content.planetary_body.name).to eq("Moon")
         expect(parsed.content.planetary_body.distance_from_earth).to eq(384400)
 
         serialized = parsed.to_xml
-        expect(serialized).to be_equivalent_to(xml)
+
+        # Ox normalizes whitespace in mixed content per XML spec (semantically equivalent)
+        # Canon can't compare whitespace-normalized XML, so we normalize both sides for Ox
+        if adapter_class == Lutaml::Xml::Adapter::OxAdapter
+          normalize = ->(str) {
+            str.gsub(/\s+/, " ").gsub(/\s*</, "<").gsub(/>\s*/, ">").strip
+          }
+          expect(normalize.call(serialized)).to eq(normalize.call(xml))
+        else
+          expect(serialized).to be_xml_equivalent_to(xml)
+        end
       end
     end
 
@@ -434,7 +572,7 @@ RSpec.describe "MixedContent" do
             attribute :id, :string
 
             xml do
-              root "Invalid"
+              element "Invalid"
               map_element :id, to: :id, mixed: true
             end
           end
@@ -449,7 +587,7 @@ RSpec.describe "MixedContent" do
             attribute :id, :string
 
             xml do
-              root "Invalid"
+              element "Invalid"
               map_attribute :id, to: :id, mixed: true
             end
           end
@@ -473,7 +611,7 @@ RSpec.describe "MixedContent" do
 
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithMixedTrue.from_xml(xml)
-          expect(parsed.content.strip).to eq(expected_content)
+          expect(parsed.content.join.strip).to eq(expected_content)
         end
       end
 
@@ -527,7 +665,11 @@ RSpec.describe "MixedContent" do
 
       describe ".from_xml" do
         let(:expected_nokogiri_content) do
-          "B <p>R&amp;C</p>\n    C <p>J&#x2014;C</p>\n    O <p>A &amp; B </p>\n    F <p>Z &#xA9;S</p>"
+          # Moxml resolves numeric character references (&#x2014;, &#xA9;) to
+          # their Unicode characters, matching Oga/Rexml behavior. Raw Nokogiri
+          # preserved numeric refs via native serialization, but the resolved
+          # form is semantically identical.
+          "B <p>R&amp;C</p>\n    C <p>J\u{2014}C</p>\n    O <p>A &amp; B </p>\n    F <p>Z \u{A9}S</p>"
         end
         let(:expected_ox_content) do
           "B <p>R&amp;C</p> C <p>J—C</p> O <p>A &amp; B </p> F <p>Z ©S</p>"
@@ -535,11 +677,14 @@ RSpec.describe "MixedContent" do
         let(:expected_oga_content) do
           "B <p>R&amp;C</p>\n    C <p>J—C</p>\n    O <p>A &amp; B </p>\n    F <p>Z ©S</p>"
         end
+        let(:expected_rexml_content) do
+          "B <p>R&amp;C</p>\n    C <p>J—C</p>\n    O <p>A &amp; B </p>\n    F <p>Z ©S</p>"
+        end
 
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithRawAndMixedOption.from_xml(xml)
           expected_content = public_send(:"expected_#{adapter_class.type}_content")
-          parsed.special.force_encoding("UTF-8") unless adapter_class == Lutaml::Model::Xml::NokogiriAdapter
+          parsed.special.force_encoding("UTF-8") unless adapter_class == Lutaml::Xml::Adapter::NokogiriAdapter
 
           expect(parsed.special.strip).to eq(expected_content)
         end
@@ -550,7 +695,7 @@ RSpec.describe "MixedContent" do
           <<~XML
             <SpecialCharContentWithRawOptionAndMixedOption><special>
                 B <p>R&amp;C</p>
-                C <p>J—C</p>
+                C <p>J&#x2014;C</p>
                 O <p>A &amp; B </p>
                 F <p>Z ©S</p>
               </special></SpecialCharContentWithRawOptionAndMixedOption>
@@ -581,11 +726,34 @@ RSpec.describe "MixedContent" do
           XML
         end
 
+        let(:expected_rexml_xml) do
+          <<~XML
+            <SpecialCharContentWithRawOptionAndMixedOption>
+              <special> B <p>R&amp;C</p>
+                C <p>J—C</p>
+                O <p>A &amp; B </p>
+                F <p>Z ©S</p>
+              </special>
+            </SpecialCharContentWithRawOptionAndMixedOption>
+          XML
+        end
+
         it "serializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithRawAndMixedOption.from_xml(xml)
           serialized = parsed.to_xml
 
-          expect(serialized).to be_equivalent_to(send(:"expected_#{adapter_class.type}_xml"))
+          expected_xml = send(:"expected_#{adapter_class.type}_xml")
+
+          # Ox and Oga normalize whitespace in mixed content per XML spec (semantically equivalent)
+          # Canon can't compare whitespace-normalized XML, so we normalize both sides
+          if [Lutaml::Xml::Adapter::OxAdapter, Lutaml::Xml::Adapter::OgaAdapter].include?(adapter_class)
+            normalize = ->(str) {
+              str.gsub(/\s+/, " ").gsub(/\s*</, "<").gsub(/>\s*/, ">").strip
+            }
+            expect(normalize.call(serialized)).to eq(normalize.call(expected_xml))
+          else
+            expect(serialized).to be_xml_equivalent_to(expected_xml)
+          end
         end
       end
     end
@@ -595,28 +763,29 @@ RSpec.describe "MixedContent" do
         <<~XML
           <SpecialCharContentWithRawAndMixedOption>
             <special>
-              B <p>R&C</p>
+              B <p>R&amp;C</p>
             </special>
           </SpecialCharContentWithRawAndMixedOption>
         XML
       end
 
       describe ".from_xml" do
-        let(:expected_nokogiri_content) { "B <p>R</p>" }
+        let(:expected_nokogiri_content) { "B <p>R&amp;C</p>" }
         let(:expected_ox_content) { "B <p>R&amp;C</p>" }
 
         it "deserializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithRawAndMixedOption.from_xml(xml)
 
-          expected_output = adapter_class == Lutaml::Model::Xml::NokogiriAdapter ? expected_nokogiri_content : expected_ox_content
+          expected_output = adapter_class == Lutaml::Xml::Adapter::NokogiriAdapter ? expected_nokogiri_content : expected_ox_content
           expect(parsed.special.strip).to eq(expected_output)
         end
       end
 
       describe ".to_xml" do
-        let(:expected_nokogiri_xml) { "B <p>R</p>" }
-        let(:expected_oga_xml) { "B <p>R&amp;C</p>" }
+        let(:expected_nokogiri_xml) { "B <p>R&amp;C</p>" }
         let(:expected_ox_xml) { "B <p>R&amp;C</p>" }
+        let(:expected_oga_xml) { "B <p>R&amp;C</p>" }
+        let(:expected_rexml_xml) { "B <p>R&amp;C</p>" }
 
         it "serializes special char mixed content correctly" do
           parsed = MixedContentSpec::SpecialCharContentWithRawAndMixedOption.from_xml(xml)
@@ -659,8 +828,7 @@ RSpec.describe "MixedContent" do
         it "serializes special char mixed content correctly" do
           parsed = MixedContentSpec::TextualSupport.from_xml(xml)
           serialized = parsed.to_xml
-          expected = adapter_class.type == "oga" ? expected_oga_xml : expected_xml
-          expect(serialized.strip).to include(expected)
+          expect(serialized.strip).to be_xml_equivalent_to(expected_xml.strip)
         end
       end
     end
@@ -702,7 +870,9 @@ RSpec.describe "MixedContent" do
 
         context "when encoding: nil xml" do
           let(:expected_encoding_nil_nokogiri_xml) do
-            "&#x2211;computer security&#x220F; type of &#x200B; operation specified &#xB5; by an access right"
+            # Moxml resolves numeric character references to Unicode,
+            # matching Oga/Rexml behavior (see expected_encoding_nil_oga_xml).
+            "\u{2211}computer security\u{220F} type of \u{200B} operation specified \u{B5} by an access right"
           end
           let(:expected_encoding_nil_ox_xml) do
             "<HexCode> \xE2\x88\x91computer security\xE2\x88\x8F type of \xE2\x80\x8B operation specified \xC2\xB5 by an access right </HexCode>\n".force_encoding("ASCII-8BIT")
@@ -715,9 +885,9 @@ RSpec.describe "MixedContent" do
             parsed = MixedContentSpec::HexCode.from_xml(xml, encoding: nil)
             serialized = parsed.to_xml(encoding: nil)
 
-            expected_output = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
+            expected_output = if adapter_class == Lutaml::Xml::Adapter::NokogiriAdapter
                                 expected_encoding_nil_nokogiri_xml
-                              elsif adapter_class == Lutaml::Model::Xml::OxAdapter
+                              elsif adapter_class == Lutaml::Xml::Adapter::OxAdapter
                                 expected_encoding_nil_ox_xml
                               else
                                 expected_encoding_nil_oga_xml
@@ -726,7 +896,7 @@ RSpec.describe "MixedContent" do
             expect(parsed.encoding).to be_nil
             expect(serialized.strip).to include(expected_output.strip)
 
-            if adapter_class == Lutaml::Model::Xml::OxAdapter
+            if adapter_class == Lutaml::Xml::Adapter::OxAdapter
               expect(serialized.encoding.to_s).to eq("ASCII-8BIT")
             else
               expect(serialized.encoding.to_s).to eq("UTF-8")
@@ -748,13 +918,10 @@ RSpec.describe "MixedContent" do
           end
 
           it "deserializes SHIFT encoded content correctly with explicit encoding option" do
-            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
+            parsed = MixedContentSpec::Shift.from_xml(fixture,
+                                                      encoding: "Shift_JIS")
 
-            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
-                                 "手書き英字１"
-                               else
-                                 "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
-                               end
+            expected_content = "手書き英字１"
 
             expect(parsed.field).to include(expected_content)
           end
@@ -762,11 +929,7 @@ RSpec.describe "MixedContent" do
           it "deserializes SHIFT encoded content incorrectly without explicit encoding option" do
             parsed = MixedContentSpec::Shift.from_xml(fixture)
 
-            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
-                                 "手書き英字１"
-                               else
-                                 "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
-                               end
+            expected_content = "手書き英字１"
 
             expect(parsed.encoding).to eq("Shift_JIS")
             expect(parsed.field).to include(expected_content)
@@ -775,90 +938,54 @@ RSpec.describe "MixedContent" do
 
         describe ".to_xml" do
           it "serializes SHIFT-JIS encoding content correctly reading from file" do
-            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
+            parsed = MixedContentSpec::Shift.from_xml(fixture,
+                                                      encoding: "Shift_JIS")
             serialized = parsed.to_xml
-            expected = adapter_class.type == "oga" ? fixture.gsub(/\s+/, "") : fixture.strip
+            expected = if adapter_class.type == "oga"
+                         fixture.gsub(/\s+/, "")
+                       else
+                         fixture.strip
+                       end
             expect(serialized.strip).to eq(expected)
           end
 
-          it "serializes SHIFT encoded content correctly with explicit encoding option both in parsing and deserializing" do
-            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
-            serialized = parsed.to_xml(encoding: "UTF-8")
-
-            parsed_xml = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
-                           "手書き英字１"
-                         else
-                           "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
-                         end
-
-            expect(parsed.field).to include(parsed_xml)
-            expect(parsed.encoding).to eq("Shift_JIS")
-
-            expect(serialized).to include("手書き英字１")
-            expect(serialized.encoding.to_s).to eq("UTF-8")
-          end
-
-          it "serializes SHIFT encoded content correctly with explicit encoding option" do
-            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
+          it "serializes SHIFT-JIS encoding content correctly reading from string" do
+            xml = "<root><FieldName>手書き英字１</FieldName><FieldName>123456</FieldName></root>".encode("Shift_JIS")
+            parsed = MixedContentSpec::Shift.from_xml(xml,
+                                                      encoding: "Shift_JIS")
             serialized = parsed.to_xml(encoding: "Shift_JIS")
 
-            expected_xml = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
-                             "手書き英字１"
-                           else
-                             "\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS")
-                           end
-
-            expect(parsed.field).to include(expected_xml)
-            expect(parsed.encoding).to eq("Shift_JIS")
-
-            expect(serialized).to include("\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P".force_encoding("Shift_JIS"))
-            expect(serialized.encoding.to_s).to eq("Shift_JIS")
-          end
-
-          it "serializes SHIFT encoded content correctly with declaration: true" do
-            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
-            serialized = parsed.to_xml(declaration: true, encoding: "Shift_JIS")
-
-            expected_xml = "<?xml version=\"1.0\" encoding=\"Shift_JIS\"?>\n<root>\n  <FieldName>\x8E\xE8\x8F\x91\x82\xAB\x89p\x8E\x9A\x82P</FieldName>\n  <FieldName>123456</FieldName>\n</root>"
-
-            expect(serialized).to be_equivalent_to(expected_xml)
-            expect(serialized.encoding.to_s).to eq("Shift_JIS")
+            # Strip XML declaration that declares Shift_JIS encoding before transcoding
+            serialized_no_decl = serialized.sub(/^<\?xml.*?\?>\s*/, "")
+            xml_no_decl = xml.sub(/^<\?xml.*?\?>\s*/, "")
+            expect(serialized_no_decl.encode("UTF-8")).to be_xml_equivalent_to(xml_no_decl.encode("UTF-8"))
           end
 
           it "serializes SHIFT-JIS content correctly bcz xml.encoding used during parsing" do
             parsed = MixedContentSpec::Shift.from_xml(fixture)
             serialized = parsed.to_xml(encoding: "Shift_JIS")
 
-            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
-                                 "<root>\n  <FieldName>手書き英字１</FieldName>\n  <FieldName>123456</FieldName>\n</root>".encode("Shift_JIS")
-                               elsif adapter_class == Lutaml::Model::Xml::OxAdapter
-                                 "<root>\n  <FieldName>手書き英字１</FieldName>\n  <FieldName>123456</FieldName>\n</root>\n".encode("Shift_JIS")
+            expected_content = if adapter_class == Lutaml::Xml::Adapter::NokogiriAdapter
+                                 "<root>\n  <FieldName>手書き英字１</FieldName>\n  <FieldName>123456</FieldName>\n</root>"
+                               elsif adapter_class == Lutaml::Xml::Adapter::OxAdapter
+                                 "<root>\n  <FieldName>手書き英字１</FieldName>\n  <FieldName>123456</FieldName>\n</root>"
                                else
-                                 "<root><FieldName>手書き英字１</FieldName><FieldName>123456</FieldName></root>".encode("Shift_JIS")
+                                 "<root><FieldName>手書き英字１</FieldName><FieldName>123456</FieldName></root>"
                                end
 
-            expect(serialized).to eq(expected_content)
-          end
-
-          it "serializes SHIFT-JIS encoding content correctly reading from string" do
-            xml = "<root><FieldName>手書き英字１</FieldName><FieldName>123456</FieldName></root>".encode("Shift_JIS")
-            parsed = MixedContentSpec::Shift.from_xml(xml, encoding: "Shift_JIS")
-            serialized = parsed.to_xml(encoding: "Shift_JIS")
-
-            expect(serialized).to be_equivalent_to(xml)
-          end
-
-          it "serializes SHIFT-JIS encoding content correctly" do
-            parsed = MixedContentSpec::Shift.from_xml(fixture, encoding: "Shift_JIS")
-            serialized = parsed.to_xml(encoding: "Shift_JIS")
-
-            expect(serialized).to be_equivalent_to(fixture)
+            # Strip XML declaration before transcoding
+            serialized_no_decl = serialized.sub(/^<\?xml.*?\?>\s*/, "")
+            expected_no_decl = expected_content.sub(/^<\?xml.*?\?> */, "")
+            expect(serialized_no_decl.encode("UTF-8")).to be_xml_equivalent_to(expected_no_decl.encode("UTF-8"))
           end
         end
       end
 
-      context "when use LATIN (ISO-8859-1) encoding" do
-        let(:fixture) { File.read(fixture_path("xml/latin_encoding.xml"), encoding: "ISO-8859-1") }
+      context "when use latin (ISO-8859-1) encoding" do
+        let(:fixture) do
+          File.read(fixture_path("xml/latin_encoding.xml"),
+                    encoding: "ISO-8859-1")
+        end
 
         describe ".from_xml" do
           it "verifies the encoding of file read" do
@@ -866,65 +993,248 @@ RSpec.describe "MixedContent" do
           end
 
           it "deserializes latin encoded content correctly" do
-            parsed = MixedContentSpec::Latin.from_xml(fixture, encoding: "ISO-8859-1")
-
-            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
-                                 ["Müller", "José"]
-                               else
-                                 ["M\xFCller".force_encoding("ISO-8859-1"), "Jos\xE9".force_encoding("ISO-8859-1")]
-                               end
+            parsed = MixedContentSpec::Latin.from_xml(fixture,
+                                                      encoding: "ISO-8859-1")
 
             expect(parsed.encoding).to eq("ISO-8859-1")
-            expect(parsed.from).to eq(expected_content[0])
-            expect(parsed.the).to eq(expected_content[1])
+            expect(parsed.the).to eq("José")
+            expect(parsed.from).to eq("Müller")
+            expect(parsed.heading).to eq("Reminder")
           end
 
           it "deserializes latin encoded content correctly, bcz xml.encoding used for parsing" do
             parsed = MixedContentSpec::Latin.from_xml(fixture)
 
-            expected_content = if adapter_class == Lutaml::Model::Xml::NokogiriAdapter
-                                 ["Müller", "José"]
-                               else
-                                 ["M\xFCller".force_encoding("ISO-8859-1"), "Jos\xE9".force_encoding("ISO-8859-1")]
-                               end
-
             expect(parsed.encoding).to eq("ISO-8859-1")
-            expect(parsed.from).to eq(expected_content[0])
-            expect(parsed.the).to eq(expected_content[1])
+
+            expect(parsed.the).to eq("José")
+            expect(parsed.from).to eq("Müller")
+            expect(parsed.heading).to eq("Reminder")
           end
         end
 
         describe ".to_xml" do
           it "serializes latin encoded content correctly" do
-            parsed = MixedContentSpec::Latin.from_xml(fixture, encoding: "ISO-8859-1")
+            parsed = MixedContentSpec::Latin.from_xml(fixture,
+                                                      encoding: "ISO-8859-1")
             serialized = parsed.to_xml
-            expected_xml = if adapter_class == Lutaml::Model::Xml::OgaAdapter
-                             "<note><to>Jos\xE9</to><from>M\xFCller</from><heading>Reminder</heading></note>"
+            expected_xml = if adapter_class == Lutaml::Xml::Adapter::OgaAdapter
+                             "<note><to>José</to><from>Müller</from><heading>Reminder</heading></note>"
                            else
-                             "<note>\n  <to>Jos\xE9</to>\n  <from>M\xFCller</from>\n  <heading>Reminder</heading>\n</note>"
+                             "<note>\n  <to>José</to>\n  <from>Müller</from>\n  <heading>Reminder</heading>\n</note>"
                            end
-            expect(serialized.strip).to eq(expected_xml.force_encoding("ISO-8859-1"))
+            expect(serialized.encode("UTF-8").strip).to be_xml_equivalent_to(expected_xml.encode("UTF-8"))
           end
         end
       end
     end
+
+    context "when mixed: true is set for prefixed elements" do
+      let(:xml) do
+        <<~XML
+          <examplecom:schema xmlns:examplecom="http://example.com/schema">
+            <examplecom:element>
+              <examplecom:annotation>Testing annotation examplecom</examplecom:annotation>
+            </examplecom:element>
+          </examplecom:schema>
+        XML
+      end
+
+      it "deserializes and serializes mixed prefixed elements correctly for round-trip elements" do
+        serialized = MixedContentSpec::PrefixedElements::Schema.from_xml(xml,
+                                                                         import_declaration_plan: :eager).to_xml
+        expected_xml = xml
+        # Format preservation: Output maintains prefix format from input
+
+        expect(serialized).to be_xml_equivalent_to(expected_xml)
+      end
+
+      it "deserializes and serializes mixed prefixed elements correctly when asked to have default prefix" do
+        serialized = MixedContentSpec::PrefixedElements::Schema.from_xml(xml).to_xml(prefix: true)
+        # `prefix: true` uses namespace's prefix_default value as prefix
+        expected_xml = <<~XML
+          <xsd:schema xmlns:xsd="http://example.com/schema">
+            <xsd:element>
+              <xsd:annotation>Testing annotation examplecom</xsd:annotation>
+            </xsd:element>
+          </xsd:schema>
+        XML
+
+        expect(serialized).to be_xml_equivalent_to(expected_xml)
+      end
+
+      it "deserializes and serializes mixed prefixed elements correctly when asked to have no prefix" do
+        serialized = MixedContentSpec::PrefixedElements::Schema.from_xml(xml).to_xml(prefix: nil)
+        # `prefix: nil` gives uses default namespace instead of prefix
+        expected_xml = <<~XML
+          <schema xmlns="http://example.com/schema">
+            <element>
+              <annotation>Testing annotation examplecom</annotation>
+            </element>
+          </schema>
+        XML
+
+        expect(serialized).to be_xml_equivalent_to(expected_xml)
+      end
+    end
+
+    describe "each_mixed_content" do
+      let(:xml) do
+        <<~XML
+          <RootMixedContent id="123">
+            Hello <bold>world</bold> and <italic>others</italic>!
+          </RootMixedContent>
+        XML
+      end
+
+      it "yields text and model objects in document order" do
+        parsed = MixedContentSpec::RootMixedContent.from_xml(xml)
+
+        results = []
+        parsed.each_mixed_content { |node| results << node }
+
+        # Should yield text and string values in order
+        # Note: RootMixedContent stores bold/italic as strings, not model objects
+        text_results = results.grep(String)
+        expect(text_results.length).to eq(5)
+        expect(text_results[0]).to include("Hello")
+        expect(text_results[1]).to eq("world")
+        expect(text_results[2]).to include("and")
+        expect(text_results[3]).to eq("others")
+        expect(text_results[4]).to include("!")
+      end
+
+      it "returns enumerator when called without block" do
+        parsed = MixedContentSpec::RootMixedContent.from_xml(xml)
+        enum = parsed.each_mixed_content
+
+        expect(enum).to be_a(Enumerator)
+      end
+
+      it "skips whitespace-only text nodes" do
+        parsed = MixedContentSpec::RootMixedContent.from_xml(xml)
+
+        results = []
+        parsed.each_mixed_content do |node|
+          results << node if node.is_a?(String) && node.strip.empty?
+        end
+
+        expect(results).to eq([])
+      end
+
+      context "with ordered-only content (no mixed)" do
+        # Test that ordered content (elements only, no text) works
+        let(:xml) do
+          <<~XML
+            <RootMixedContentNested id="outer">
+              <MixedContent id="inner">
+                <bold>first</bold><italic>second</italic>
+              </MixedContent>
+            </RootMixedContentNested>
+          XML
+        end
+
+        it "yields element objects in document order" do
+          parsed = MixedContentSpec::RootMixedContentNested.from_xml(xml)
+
+          results = []
+          parsed.content.each_mixed_content { |node| results << node }
+
+          # Should yield element objects in order (bold, italic strings)
+          string_results = results.grep(String)
+          expect(string_results.length).to eq(2)
+        end
+      end
+
+      context "with plain content (no mixed, no ordered)" do
+        it "returns empty enumerator" do
+          parsed = MixedContentSpec::Source.from_xml("<source>plain text</source>")
+          expect(parsed.each_mixed_content.to_a).to eq([])
+        end
+      end
+    end
+
+    # Issue #630: Mutation after deserialization should update serialization output
+    context "when content-mapped attribute is mutated after deserialization" do
+      context "with collection content attribute" do
+        it "reflects updated value in to_xml" do
+          mi = MixedContentSpec::MiElement.from_xml('<mi mathvariant="normal">m</mi>')
+          expect(mi.value).to eq(["m"])
+
+          mi.value = ["mm"]
+          xml = mi.to_xml
+          expect(xml).to include(">mm<")
+          expect(xml).not_to include(">m<")
+        end
+
+        it "preserves attributes in mutated output" do
+          mi = MixedContentSpec::MiElement.from_xml('<mi mathvariant="normal">m</mi>')
+          mi.mathvariant = "bold"
+          mi.value = ["x"]
+          xml = mi.to_xml
+          expect(xml).to include('mathvariant="bold"')
+          expect(xml).to include(">x<")
+        end
+
+        it "preserves round-trip when not mutated" do
+          mi = MixedContentSpec::MiElement.from_xml('<mi mathvariant="normal">m</mi>')
+          xml = mi.to_xml
+          expect(xml).to include('mathvariant="normal"')
+          expect(xml).to include(">m<")
+        end
+      end
+
+      context "with collection content attribute" do
+        it "reflects updated collection values in to_xml" do
+          para = MixedContentSpec::ParaMixedContent.from_xml("<p>Hello <b>world</b> there</p>")
+          expect(para.content).to eq(["Hello ", " there"])
+
+          para.content = ["Goodbye", "everyone"]
+          xml = para.to_xml
+          expect(xml).to include("Goodbye")
+          expect(xml).to include("everyone")
+          expect(xml).to include("<b>world</b>")
+        end
+
+        it "preserves round-trip when not mutated" do
+          xml = "<p>Hello <b>world</b> there</p>"
+          para = MixedContentSpec::ParaMixedContent.from_xml(xml)
+          expect(para.to_xml).to eq(xml)
+        end
+      end
+    end
   end
 
-  describe Lutaml::Model::Xml::NokogiriAdapter do
+  describe Lutaml::Xml::Adapter::NokogiriAdapter do
     it_behaves_like "mixed content behavior", described_class
 
     it "raises error when serializes special char content with false encoding: 'ABC'" do
       parsed = MixedContentSpec::HexCode.from_xml("<HexCode>&#x2211;computer security</HexCode>")
 
-      expect { parsed.to_xml(encoding: "ABC") }.to raise_error(StandardError, "unknown encoding name - ABC")
+      expect do
+        parsed.to_xml(encoding: "ABC")
+      end.to raise_error(StandardError, /ABC/)
     end
   end
 
-  describe Lutaml::Model::Xml::OxAdapter do
-    it_behaves_like "mixed content behavior", described_class
+  describe Lutaml::Xml::Adapter::OxAdapter do
+    if TestAdapterConfig.adapter_enabled?(:ox)
+      it_behaves_like "mixed content behavior",
+                      described_class
+    end
   end
 
-  describe Lutaml::Model::Xml::OgaAdapter do
-    it_behaves_like "mixed content behavior", described_class
+  describe Lutaml::Xml::Adapter::OgaAdapter do
+    if TestAdapterConfig.adapter_enabled?(:oga)
+      it_behaves_like "mixed content behavior",
+                      described_class
+    end
+  end
+
+  describe Lutaml::Xml::Adapter::RexmlAdapter do
+    if TestAdapterConfig.adapter_enabled?(:rexml)
+      it_behaves_like "mixed content behavior",
+                      described_class
+    end
   end
 end