moxml 0.1.16 → 0.1.17

data/spec/integration/shared_examples/entity_reference_whitespace.rb

@@ -0,0 +1,122 @@
+# 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 "still filters whitespace between elements" do
+      xml = <<~XML
+        <root>
+          <child1/>
+          <child2/>
+        </root>
+      XML
+
+      doc = context.parse(xml)
+      children = doc.root.children
+
+      expect(children.length).to eq(2)
+      expect(children.all?(Moxml::Element)).to be true
+    end
+  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/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
 

data/spec/moxml/entity_preservation_spec.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Entity preservation across adapters" do
+  shared_examples "consistent entity handling" do
+    describe "text content with entities" do
+      it "preserves single entity in inner_text" do
+        doc = adapter.parse("<root>&copy; 2024</root>")
+        expect(doc.root.inner_text).to eq("&copy; 2024")
+      end
+
+      it "preserves multiple entities in inner_text" do
+        doc = adapter.parse("<root>&copy; text &mdash; end</root>")
+        expect(doc.root.inner_text).to eq("&copy; text &mdash; end")
+      end
+
+      it "preserves entity at start" do
+        doc = adapter.parse("<root>&copy; start</root>")
+        expect(doc.root.inner_text).to include("&copy;")
+      end
+
+      it "preserves entity at end" do
+        doc = adapter.parse("<root>end &copy;</root>")
+        expect(doc.root.inner_text).to include("&copy;")
+      end
+
+      it "does not alter standard entities" do
+        doc = adapter.parse("<root>&amp; &lt; &gt;</root>")
+        expect(doc.root.inner_text).to eq("& < >")
+      end
+    end
+
+    describe "to_xml round-trip" do
+      it "preserves entity in serialized output" do
+        doc = adapter.parse("<root>&copy; 2024</root>")
+        expect(doc.root.to_xml(declaration: false)).to include("&copy;")
+      end
+
+      it "preserves multiple entities in serialized output" do
+        doc = adapter.parse("<root>&copy; text &mdash; end</root>")
+        xml = doc.root.to_xml(declaration: false)
+        expect(xml).to include("&copy;")
+        expect(xml).to include("&mdash;")
+      end
+
+      it "does not double-escape standard entities" do
+        doc = adapter.parse("<root>&amp; test</root>")
+        xml = doc.root.to_xml(declaration: false)
+        expect(xml).not_to include("&amp;amp;")
+      end
+    end
+
+    describe "attribute values with entities" do
+      it "preserves entity in attribute value" do
+        doc = adapter.parse('<root attr="&copy; 2024"/>')
+        expect(doc.root["attr"]).to eq("&copy; 2024")
+      end
+
+      it "preserves entity in attribute via Attribute#value" do
+        doc = adapter.parse('<root attr="&copy; 2024"/>')
+        attr = doc.root.attributes.first
+        expect(attr.value).to eq("&copy; 2024")
+      end
+
+      it "preserves entity in attribute to_xml" do
+        doc = adapter.parse('<root attr="&copy; 2024"/>')
+        xml = doc.root.to_xml(declaration: false)
+        expect(xml).to include('attr="&copy; 2024"')
+      end
+    end
+
+    describe "Text node content" do
+      it "preserves entity in Text#content" do
+        doc = adapter.parse("<root>&copy; text</root>")
+        text_nodes = doc.root.children.grep(Moxml::Text)
+        combined = text_nodes.map(&:content).join
+        expect(combined).to include("&copy;")
+      end
+    end
+  end
+
+  context "with nokogiri adapter" do
+    let(:adapter) { Moxml::Adapter::Nokogiri }
+
+    before { require "moxml/adapter/nokogiri" }
+
+    it_behaves_like "consistent entity handling"
+  end
+
+  context "with oga adapter" do
+    let(:adapter) { Moxml::Adapter::Oga }
+
+    before { require "moxml/adapter/oga" }
+
+    it_behaves_like "consistent entity handling"
+  end
+
+  context "with rexml adapter" do
+    let(:adapter) { Moxml::Adapter::Rexml }
+
+    before { require "moxml/adapter/rexml" }
+
+    it_behaves_like "consistent entity handling"
+  end
+
+  context "with ox adapter" do
+    let(:adapter) { Moxml::Adapter::Ox }
+
+    before { require "moxml/adapter/ox" }
+
+    it_behaves_like "consistent entity handling"
+  end
+
+  context "with headed_ox adapter" do
+    let(:adapter) { Moxml::Adapter::HeadedOx }
+
+    before { require "moxml/adapter/headed_ox" }
+
+    it_behaves_like "consistent entity handling"
+  end
+
+  context "with libxml adapter" do
+    let(:adapter) { Moxml::Adapter::Libxml }
+
+    before { require "moxml/adapter/libxml" }
+
+    it_behaves_like "consistent entity handling"
+  end
+end

data/spec/moxml/entity_reference_spec.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.shared_examples "entity reference node" do |adapter_name|
+  context "with #{adapter_name} adapter", adapter: adapter_name do
+    let(:ctx) { Moxml.new(adapter_name) }
+
+    describe "creating entity references" do
+      it "creates an entity reference node" do
+        doc = ctx.create_document
+        ref = doc.create_entity_reference("nbsp")
+        expect(ref).to be_a(Moxml::EntityReference)
+        expect(ref.name).to eq("nbsp")
+      end
+
+      it "creates standard XML entity references" do
+        doc = ctx.create_document
+        %w[amp lt gt quot apos].each do |name|
+          ref = doc.create_entity_reference(name)
+          expect(ref.name).to eq(name)
+        end
+      end
+
+      it "raises ValidationError for invalid names" do
+        doc = ctx.create_document
+        expect do
+          doc.create_entity_reference("123invalid")
+        end.to raise_error(Moxml::ValidationError)
+      end
+
+      it "raises ValidationError for empty name" do
+        doc = ctx.create_document
+        expect do
+          doc.create_entity_reference("")
+        end.to raise_error(Moxml::ValidationError)
+      end
+    end
+
+    describe "node properties" do
+      it "has empty text content" do
+        doc = ctx.create_document
+        ref = doc.create_entity_reference("amp")
+        expect(ref.text).to eq("")
+        expect(ref.content).to eq("")
+      end
+
+      it "is recognized as entity_reference type" do
+        doc = ctx.create_document
+        ref = doc.create_entity_reference("copy")
+        expect(ref.entity_reference?).to be true
+      end
+    end
+
+    describe "serialization" do
+      it "serializes to entity syntax" do
+        doc = ctx.create_document
+        ref = doc.create_entity_reference("mdash")
+        expect(ref.to_xml).to eq("—")
+      end
+
+      it "serializes standard entities" do
+        doc = ctx.create_document
+        ref = doc.create_entity_reference("amp")
+        expect(ref.to_xml).to eq("&")
+      end
+    end
+
+    describe "adding to document" do
+      it "survives add_child and retrieval" do
+        doc = ctx.create_document
+        root = doc.create_element("p")
+        doc.root = root
+        ref = doc.create_entity_reference("nbsp")
+        root.add_child(ref)
+        children = root.children
+        expect(children.size).to be >= 1
+        entity_child = children.find { |c| c.is_a?(Moxml::EntityReference) }
+        expect(entity_child).not_to be_nil
+        expect(entity_child.name).to eq("nbsp")
+      end
+
+      it "serializes within a document" do
+        doc = ctx.create_document
+        root = doc.create_element("p")
+        doc.root = root
+        root.add_child(doc.create_text("before"))
+        root.add_child(doc.create_entity_reference("nbsp"))
+        root.add_child(doc.create_text("after"))
+        output = doc.to_xml
+        expect(output).to include(" ")
+      end
+
+      it "preserves multiple entity references in sequence" do
+        doc = ctx.create_document
+        root = doc.create_element("p")
+        doc.root = root
+        root.add_child(doc.create_entity_reference("nbsp"))
+        root.add_child(doc.create_entity_reference("copy"))
+        root.add_child(doc.create_entity_reference("mdash"))
+        output = doc.to_xml
+        expect(output).to include(" ")
+        expect(output).to include("©")
+        expect(output).to include("—")
+      end
+    end
+  end
+end
+
+RSpec.describe Moxml::EntityReference do
+  %i[nokogiri oga ox rexml].each do |adapter_name|
+    it_behaves_like "entity reference node", adapter_name
+  end
+end