moxml 0.1.16 → 0.1.18

data/spec/integration/all_adapters_spec.rb

@@ -28,6 +28,7 @@ RSpec.describe "Cross-adapter integration" do
     "XPath Examples",
     "Memory Usage Examples",
     "Thread Safety Examples",
+    "Entity Reference Whitespace Preservation",
     "Performance Examples",
   ]
 

data/spec/integration/shared_examples/edge_cases.rb

@@ -32,12 +32,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "malformed content handling" do
     it "handles CDATA with nested markers" do
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't escape the end token"
-      end
-      if context.config.adapter_name == :headed_ox
-        skip "HeadedOx limitation: Ox doesn't escape CDATA end markers. See docs/_pages/headed-ox-limitations.adoc"
-      end
       cdata_text = "]]>]]>]]>"
       doc = context.create_document
       cdata = doc.create_cdata(cdata_text)
@@ -173,6 +167,91 @@ RSpec.shared_examples "Moxml Edge Cases" do
     end
   end
 
+  describe "whitespace text node preservation" do
+    # Ox/HeadedOx do not generate whitespace-only text nodes in their parser,
+    # so these tests only apply to adapters that do (Nokogiri, OGA, REXML, LibXML)
+    let(:preserves_ws) { !%i[ox headed_ox].include?(context.config.adapter_name) }
+
+    it "preserves whitespace-only text nodes between sibling elements" do
+      unless preserves_ws
+        skip "Ox/HeadedOx parser does not generate whitespace-only text nodes"
+      end
+
+      xml = <<~XML
+        <root>
+          <a>1</a>
+          <b>2</b>
+          <c>3</c>
+        </root>
+      XML
+
+      doc = context.parse(xml)
+      children = doc.root.children
+
+      # Should have whitespace text nodes between elements
+      expect(children.size).to be > 3
+
+      # Whitespace text nodes should be Text nodes
+      ws_nodes = children.select { |c| c.is_a?(Moxml::Text) && c.content.strip.empty? }
+      expect(ws_nodes).not_to be_empty
+
+      # Element children should still be accessible
+      elements = children.select { |c| c.is_a?(Moxml::Element) }
+      expect(elements.map(&:name)).to eq(%w[a b c])
+    end
+
+    it "preserves inline whitespace text nodes between text and elements" do
+      xml = "<p>Figure <sub>A</sub>.1</p>"
+      doc = context.parse(xml)
+
+      children = doc.root.children
+      expect(children.size).to eq(3)
+
+      # First child: "Figure " text node
+      expect(children[0]).to be_a(Moxml::Text)
+      expect(children[0].content).to eq("Figure ")
+
+      # Second child: <sub> element
+      expect(children[1]).to be_a(Moxml::Element)
+      expect(children[1].name).to eq("sub")
+      expect(children[1].text).to eq("A")
+
+      # Third child: ".1" text node
+      expect(children[2]).to be_a(Moxml::Text)
+      expect(children[2].content).to eq(".1")
+    end
+
+    it "preserves space-only text node as meaningful content" do
+      xml = "<p>Hello <b>world</b>!</p>"
+      doc = context.parse(xml)
+
+      children = doc.root.children
+      expect(children.size).to eq(3)
+
+      expect(children[0].content).to eq("Hello ")
+      expect(children[1]).to be_a(Moxml::Element)
+      expect(children[2].content).to eq("!")
+    end
+
+    it "distinguishes whitespace text nodes from element children" do
+      unless preserves_ws
+        skip "Ox/HeadedOx parser does not generate whitespace-only text nodes"
+      end
+
+      xml = "<root>  <child/>  </root>"
+      doc = context.parse(xml)
+
+      children = doc.root.children
+      # "  " before child, "  " after child
+      expect(children.size).to eq(3)
+      expect(children[0]).to be_a(Moxml::Text)
+      expect(children[0].content).to eq("  ")
+      expect(children[1]).to be_a(Moxml::Element)
+      expect(children[2]).to be_a(Moxml::Text)
+      expect(children[2].content).to eq("  ")
+    end
+  end
+
   describe "document structure edge cases" do
     it "handles deeply nested elements" do
       doc = context.create_document

data/spec/integration/shared_examples/entity_reference_whitespace.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+RSpec.shared_examples "Entity Reference Whitespace Preservation" do
+  let(:context) { Moxml.new }
+
+  describe "whitespace preservation around entities on parse round-trip" do
+    it "preserves spaces around entity references" do
+      doc = context.parse("<p>A &copy; B &mdash; C</p>")
+      xml = doc.root.to_xml
+
+      expect(xml).to include("A ").and include(" B ").and include(" C")
+    end
+
+    it "preserves entity references in serialized output" do
+      doc = context.parse("<p>Copyright &copy; 2024 &mdash; All rights reserved</p>")
+      xml = doc.root.to_xml
+
+      expect(xml).to include("&copy;")
+      expect(xml).to include("&mdash;")
+      expect(xml).to include("Copyright &copy; 2024 &mdash; All rights reserved")
+    end
+
+    it "preserves whitespace with single entity reference" do
+      doc = context.parse("<p>A &copy; B</p>")
+
+      expect(doc.root.inner_text).to include("A ").and include(" B")
+    end
+
+    it "preserves whitespace with entity at start of text" do
+      doc = context.parse("<p>&copy; start</p>")
+
+      expect(doc.root.inner_text).to include("&copy;")
+      expect(doc.root.inner_text).to include(" start")
+    end
+
+    it "preserves whitespace with entity at end of text" do
+      doc = context.parse("<p>end &copy;</p>")
+
+      expect(doc.root.inner_text).to include("end ")
+      expect(doc.root.inner_text).to include("&copy;")
+    end
+  end
+
+  describe "Builder entity reference whitespace" do
+    # REXML and LibXML store entity references outside the native DOM tree,
+    # so they cannot maintain positional ordering relative to text nodes.
+    before do
+      adapter_name = context.config.adapter.name
+      if adapter_name.include?("Rexml") || adapter_name.include?("Libxml")
+        skip "#{adapter_name} does not support inline entity reference nodes via Builder"
+      end
+    end
+
+    it "preserves spaces around entity references" do
+      doc = Moxml::Builder.new(context).build do
+        element "p" do
+          text "Copyright "
+          entity_reference "copy"
+          text " 2024 "
+          entity_reference "mdash"
+          text " All rights reserved"
+        end
+      end
+
+      xml = doc.root.to_xml
+      expect(xml).to include("Copyright &copy; 2024 &mdash; All rights reserved")
+    end
+
+    it "preserves whitespace-only text nodes adjacent to entity references" do
+      doc = Moxml::Builder.new(context).build do
+        element "p" do
+          entity_reference "copy"
+          text " "
+          entity_reference "mdash"
+        end
+      end
+
+      children = doc.root.children
+      types = children.map(&:class)
+
+      expect(types).to eq([
+                            Moxml::EntityReference,
+                            Moxml::Text,
+                            Moxml::EntityReference,
+                          ])
+      expect(children[1].content).to eq(" ")
+    end
+
+    it "preserves multiple spaces between entity references" do
+      doc = Moxml::Builder.new(context).build do
+        element "p" do
+          text "A"
+          entity_reference "amp"
+          text "  "
+          entity_reference "lt"
+          text "B"
+        end
+      end
+
+      children = doc.root.children
+      expect(children.length).to eq(5)
+      expect(children[2].content).to eq("  ")
+    end
+  end
+
+  describe "structural whitespace filtering" do
+    it "preserves whitespace text nodes between elements" do
+      xml = <<~XML
+        <root>
+          <child1/>
+          <child2/>
+        </root>
+      XML
+
+      doc = context.parse(xml)
+      children = doc.root.children
+
+      # Whitespace text nodes between elements are preserved
+      elements = children.select { |c| c.is_a?(Moxml::Element) }
+      expect(elements.length).to eq(2)
+      expect(elements.map(&:name)).to eq(%w[child1 child2])
+    end
+  end
+end

data/spec/integration/shared_examples/high_level/document_builder_behavior.rb

@@ -32,12 +32,14 @@ RSpec.shared_examples "Moxml::DocumentBuilder" do
 
       expect(doc.root.namespaces.count).to eq(1)
       expect(doc.root.namespaces.first.uri).to eq("http://example.org")
-      expect(doc.root.children[0]).to be_a(Moxml::Comment)
-      expect(doc.root.children[1]).to be_a(Moxml::Element)
-      expect(doc.root.children[1].name).to eq("child")
-      expect(doc.root.children[1]["id"]).to eq("1")
-      expect(doc.root.children[1].children.first).to be_a(Moxml::Cdata)
-      expect(doc.root.children[2]).to be_a(Moxml::ProcessingInstruction)
+      # Whitespace text nodes are preserved between elements
+      non_ws_children = doc.root.children.reject { |c| c.is_a?(Moxml::Text) && c.content.strip.empty? }
+      expect(non_ws_children[0]).to be_a(Moxml::Comment)
+      expect(non_ws_children[1]).to be_a(Moxml::Element)
+      expect(non_ws_children[1].name).to eq("child")
+      expect(non_ws_children[1]["id"]).to eq("1")
+      expect(non_ws_children[1].children.find { |c| c.is_a?(Moxml::Cdata) }).to be_a(Moxml::Cdata)
+      expect(non_ws_children[2]).to be_a(Moxml::ProcessingInstruction)
     end
   end
 end

data/spec/integration/shared_examples/integration_workflows.rb

@@ -113,7 +113,7 @@ RSpec.shared_examples "Moxml Integration" do
       expect(attr).to eq("value")
 
       # Test namespace override
-      deeper = a_element.children.first
+      deeper = a_element.children.find { |c| c.is_a?(Moxml::Element) }
       expect(deeper.namespace.uri).to eq("http://other.org")
     end
   end

data/spec/integration/shared_examples/node_wrappers/cdata_behavior.rb

@@ -36,13 +36,6 @@ RSpec.shared_examples "Moxml::Cdata" do
     end
 
     it "escapes CDATA end marker" do
-      # pending for Ox: https://github.com/ohler55/ox/issues/377
-      if context.config.adapter_name == :ox
-        pending "Ox doesn't escape the end token"
-      end
-      if context.config.adapter_name == :headed_ox
-        skip "HeadedOx limitation: Ox doesn't escape CDATA end markers. See docs/_pages/headed-ox-limitations.adoc"
-      end
       cdata.content = "content]]>more"
       expect(cdata.to_xml).to eq("<![CDATA[content]]]]><![CDATA[>more]]>")
     end

data/spec/integration/shared_examples/node_wrappers/namespace_behavior.rb

@@ -88,6 +88,141 @@ RSpec.shared_examples "Moxml::Namespace" do
       end
     end
 
+    describe "namespace_definitions" do
+      it "returns only namespace declarations, not regular attributes" do
+        element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        element["id"] = "test-id"
+        element["class"] = "foo"
+
+        ns_defs = element.namespaces
+        prefixes = ns_defs.map(&:prefix)
+
+        expect(prefixes).to include("xs")
+        expect(prefixes).not_to include("id", "class")
+        expect(ns_defs.size).to eq(1)
+      end
+
+      it "returns multiple prefixed namespace declarations" do
+        element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        element.add_namespace("xsi", "http://www.w3.org/2001/XMLSchema-instance")
+        element.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+        element["id"] = "test-id"
+
+        ns_defs = element.namespaces
+        prefixes = ns_defs.map(&:prefix)
+
+        expect(prefixes).to contain_exactly("xs", "xsi", "dc")
+      end
+
+      it "returns both default and prefixed namespace declarations" do
+        element.add_namespace(nil, "http://example.org/default")
+        element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        element["attr"] = "value"
+
+        ns_defs = element.namespaces
+        prefixes = ns_defs.map(&:prefix)
+
+        expect(ns_defs.size).to eq(2)
+        expect(prefixes).to include("xs")
+        expect(ns_defs.find { |ns| ns.prefix.nil? }).not_to be_nil
+      end
+
+      it "does not include namespaces from ancestor elements" do
+        root = doc.create_element("root")
+        root.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        child = doc.create_element("child")
+        child.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+        root.add_child(child)
+
+        ns_defs = child.namespaces
+        prefixes = ns_defs.map(&:prefix)
+
+        expect(prefixes).to contain_exactly("dc")
+        expect(prefixes).not_to include("xs")
+      end
+    end
+
+    describe "in_scope_namespaces" do
+      it "returns namespaces declared on the element itself" do
+        element.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        element.add_namespace("xsi", "http://www.w3.org/2001/XMLSchema-instance")
+
+        in_scope = element.in_scope_namespaces
+        prefixes = in_scope.map(&:prefix)
+        uris = in_scope.map(&:uri)
+
+        expect(prefixes).to include("xs", "xsi")
+        expect(uris).to include(
+          "http://www.w3.org/2001/XMLSchema",
+          "http://www.w3.org/2001/XMLSchema-instance",
+        )
+      end
+
+      it "inherits namespaces from ancestor elements" do
+        root = doc.create_element("root")
+        root.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        child = doc.create_element("child")
+        root.add_child(child)
+
+        in_scope = child.in_scope_namespaces
+        prefixes = in_scope.map(&:prefix)
+
+        expect(prefixes).to include("xs")
+      end
+
+      it "collects namespaces from multiple ancestor levels" do
+        root = doc.create_element("root")
+        root.add_namespace("xs", "http://www.w3.org/2001/XMLSchema")
+        middle = doc.create_element("middle")
+        middle.add_namespace("dc", "http://purl.org/dc/elements/1.1/")
+        root.add_child(middle)
+        leaf = doc.create_element("leaf")
+        middle.add_child(leaf)
+
+        in_scope = leaf.in_scope_namespaces
+        prefixes = in_scope.map(&:prefix)
+
+        expect(prefixes).to include("xs", "dc")
+      end
+
+      it "closest ancestor wins for duplicate prefixes" do
+        root = doc.create_element("root")
+        root.add_namespace("ns", "http://example.org/old")
+        child = doc.create_element("child")
+        child.add_namespace("ns", "http://example.org/new")
+        root.add_child(child)
+
+        in_scope = child.in_scope_namespaces
+        ns_match = in_scope.find { |ns| ns.prefix == "ns" }
+
+        expect(ns_match.uri).to eq("http://example.org/new")
+      end
+
+      it "includes default namespace" do
+        root = doc.create_element("root")
+        root.add_namespace(nil, "http://example.org/default")
+        child = doc.create_element("child")
+        root.add_child(child)
+
+        in_scope = child.in_scope_namespaces
+        default_ns = in_scope.find { |ns| ns.prefix.nil? }
+
+        expect(default_ns).not_to be_nil
+        expect(default_ns.uri).to eq("http://example.org/default")
+      end
+
+      it "returns empty array for element with no namespaces" do
+        lonely = doc.create_element("lonely")
+        expect(lonely.in_scope_namespaces).to eq([])
+      end
+
+      it "returns empty array for document root with no namespace declarations" do
+        root = doc.create_element("root")
+        doc.add_child(root)
+        expect(root.in_scope_namespaces).to eq([])
+      end
+    end
+
     describe "inheritance" do
       it "does not inherit parent namespaces" do
         # https://stackoverflow.com/a/67347081

data/spec/integration/shared_examples/node_wrappers/node_behavior.rb

@@ -109,9 +109,6 @@ RSpec.shared_examples "Moxml::Node" do
         if context.config.adapter_name == :ox
           pending "Ox doesn't have a native XPath"
         end
-        if context.config.adapter_name == :headed_ox
-          skip "HeadedOx limitation: Text content access from nested elements needs investigation. See docs/_pages/headed-ox-limitations.adoc"
-        end
 
         node = doc.at_xpath("//b")
         expect(node.text).to eq("1")

data/spec/integration/shared_examples/node_wrappers/node_set_behavior.rb

@@ -41,7 +41,9 @@ RSpec.shared_examples "Moxml::NodeSet" do
       end
 
       it "compares nodes" do
-        expect(doc.xpath("//child")).to eq(doc.root.children)
+        xpath_results = doc.xpath("//child")
+        element_children = doc.root.children.select { |c| c.is_a?(Moxml::Element) }
+        expect(xpath_results.map(&:native)).to eq(element_children.map(&:native))
       end
     end
 

data/spec/moxml/adapter/entity_restoration_spec.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Adapters that use DocumentBuilder for parse (entity restoration during parsing works)
+DBUILD_ADAPTERS = %i[oga rexml].freeze
+
+# All adapters with entity reference support
+ENTITY_ADAPTERS = %i[nokogiri oga ox rexml].freeze
+
+RSpec.shared_examples "standard entity preservation" do |adapter_name|
+  context "with #{adapter_name}", adapter: adapter_name do
+    it "preserves amp entity through round-trip" do
+      ctx = Moxml.new(adapter_name) { |c| c.restore_entities = true }
+      doc = ctx.parse("<p>a &amp; b</p>")
+      expect(doc.to_xml).to include("&amp;")
+    end
+
+    it "preserves lt entity through round-trip" do
+      ctx = Moxml.new(adapter_name) { |c| c.restore_entities = true }
+      doc = ctx.parse("<p>a &lt; b</p>")
+      expect(doc.to_xml).to include("&lt;")
+    end
+
+    it "preserves gt entity through round-trip" do
+      ctx = Moxml.new(adapter_name) { |c| c.restore_entities = true }
+      doc = ctx.parse("<p>a &gt; b</p>")
+      expect(doc.to_xml).to include("&gt;")
+    end
+
+    it "produces valid XML through round-trip" do
+      ctx = Moxml.new(adapter_name) { |c| c.restore_entities = true }
+      doc = ctx.parse("<p>&amp; text &amp;</p>")
+      output = doc.to_xml
+      expect { ctx.parse(output) }.not_to raise_error
+    end
+  end
+end
+
+RSpec.shared_examples "non-standard entity restoration via DocumentBuilder" do |adapter_name|
+  context "with #{adapter_name}", adapter: adapter_name do
+    let(:ctx) { Moxml.new(adapter_name) { |c| c.restore_entities = true } }
+
+    it "restores nbsp (U+00A0) from bundled W3C entity set" do
+      doc = ctx.parse("<p>\u00A0</p>")
+      expect(doc.to_xml).to include("&nbsp;")
+    end
+
+    it "restores copy (U+00A9) from bundled W3C entity set" do
+      doc = ctx.parse("<p>\u00A9</p>")
+      expect(doc.to_xml).to include("&copy;")
+    end
+
+    it "restores mdash (U+2014) from bundled W3C entity set" do
+      doc = ctx.parse("<p>\u2014</p>")
+      expect(doc.to_xml).to include("&mdash;")
+    end
+
+    it "restores multiple entities in a single text node" do
+      doc = ctx.parse("<p>before\u00A0middle\u00A9end</p>")
+      output = doc.to_xml
+      expect(output).to include("&nbsp;")
+      expect(output).to include("&copy;")
+    end
+  end
+end
+
+RSpec.shared_examples "restore_entities disabled" do |adapter_name|
+  context "with #{adapter_name}", adapter: adapter_name do
+    let(:ctx) { Moxml.new(adapter_name) { |c| c.restore_entities = false } }
+
+    it "does not create EntityReference nodes for standard entities" do
+      doc = ctx.parse("<p>a &amp; b</p>")
+      entity_children = doc.root.children.grep(Moxml::EntityReference)
+      expect(entity_children).to be_empty
+    end
+
+    it "does not create EntityReference nodes for non-standard characters" do
+      doc = ctx.parse("<p>\u00A0</p>")
+      entity_children = doc.root.children.grep(Moxml::EntityReference)
+      expect(entity_children).to be_empty
+    end
+  end
+end
+
+RSpec.describe "Entity restoration" do
+  ENTITY_ADAPTERS.each do |adapter_name|
+    it_behaves_like "standard entity preservation", adapter_name
+  end
+
+  DBUILD_ADAPTERS.each do |adapter_name|
+    it_behaves_like "non-standard entity restoration via DocumentBuilder",
+                    adapter_name
+
+    it_behaves_like "restore_entities disabled", adapter_name
+  end
+end

data/spec/moxml/builder_spec.rb

@@ -266,7 +266,22 @@ RSpec.describe Moxml::Builder do
             builder.title("Hello") { builder.child }
           end
         end
-      end.to raise_error(ArgumentError, /title: cannot combine text content with a block/)
+      end.to raise_error(ArgumentError,
+                         /title: cannot combine text content with a block/)
+    end
+  end
+
+  describe "#entity_reference" do
+    it "creates entity references via DSL" do
+      doc = described_class.new(context).build do
+        element "p" do
+          entity_reference "nbsp"
+        end
+      end
+      ref = doc.root.children.first
+      expect(ref).to be_a(Moxml::EntityReference)
+      expect(ref.name).to eq("nbsp")
+      expect(doc.to_xml).to include(" ")
     end
   end