moxml 0.5.148 → 0.5.150

data/spec/consistency/reference_differential_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/input_taxonomy"
+
+# Executable-reference differential (TODO.sota/03): every adapter's
+# answer for each taxonomy input is compared against the pure-Ruby
+# reference implementation (Moxml::Reference), not against another
+# adapter. Faces: document order, children listing, access truth
+# table, attributes, PI/comment data, and serialization round-trip.
+# Cells that differ cite a registered divergence (D-NN) or the
+# adapter is fixed.
+RSpec.describe "executable reference differential" do
+  let(:references) { {} }
+
+  def adapters
+    Moxml::Adapter::AVAILABLE_ADAPTERS.uniq
+  end
+
+  def exempt?(input, face, adapter)
+    InputTaxonomy::EXEMPT.dig(input.id, face, adapter)
+  end
+
+  def reference_for(input)
+    references[input.id] ||= Moxml::Reference.parse(input.xml)
+  end
+
+  def adapter_document(name, xml)
+    Moxml.new(name).parse(xml)
+  rescue Moxml::Error, NotImplementedError, LoadError
+    nil # unavailable in this environment
+  end
+
+  def elements(doc)
+    doc.xpath("//*").to_a
+  end
+
+  def reference_elements(reference)
+    rows = []
+    reference.each_node { |node| rows << node if node.element? }
+    rows
+  end
+
+  def pi_rows(doc)
+    doc.traverse.filter_map do |node|
+      [node.name, node.content] if node.node_type == :processing_instruction
+    end
+  end
+
+  def comment_rows(doc)
+    doc.traverse.filter_map do |node|
+      node.content if node.node_type == :comment
+    end
+  end
+
+  def compact(text)
+    text.to_s.gsub(/\s+/, "")
+  end
+
+  it "answers document order and children listing like the reference" do
+    InputTaxonomy.well_formed.each do |input|
+      ref = reference_for(input)
+      expected_order = Moxml::Reference.element_names(ref)
+      expected_children = Moxml::Reference.child_element_names(ref)
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc # unavailable
+        next if exempt?(input, :nodes, name)
+
+        got_order = elements(doc).map(&:name)
+        expect(got_order).to eq(expected_order),
+                             "#{input.id}/#{name}: document order differs " \
+                             "from the reference: #{got_order.inspect} vs " \
+                             "#{expected_order.inspect}"
+
+        got_children = elements(doc).map do |element|
+          element.children.grep(Moxml::Element).map(&:name)
+        end
+        expect(got_children).to eq(expected_children),
+                                "#{input.id}/#{name}: children listing " \
+                                "differs from the reference: " \
+                                "#{got_children.inspect} vs " \
+                                "#{expected_children.inspect}"
+      end
+    end
+  end
+
+  it "answers element text like the reference" do
+    InputTaxonomy.well_formed.each do |input|
+      expected = Moxml::Reference.element_access_rows(reference_for(input))
+        .map { |(name, text, _content)| [name, text] }
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc
+        next if exempt?(input, :text, name)
+
+        got = elements(doc).map { |element| [element.name, element.text] }
+        expect(got).to eq(expected),
+                       "#{input.id}/#{name}: text face differs from the " \
+                       "reference: #{got.inspect} vs #{expected.inspect}"
+      end
+    end
+  end
+
+  it "answers attribute pairs like the reference" do
+    InputTaxonomy.well_formed.each do |input|
+      expected = reference_elements(reference_for(input)).map(&:attribute_pairs)
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc
+
+        got = elements(doc).map do |element|
+          element.attribute_pairs.map { |(key, value)| [key, value] }
+        end
+        expect(got).to eq(expected),
+                       "#{input.id}/#{name}: attribute face differs from " \
+                       "the reference: #{got.inspect} vs #{expected.inspect}"
+      end
+    end
+  end
+
+  it "answers PI and comment data like the reference" do
+    InputTaxonomy.well_formed.each do |input|
+      ref = reference_for(input)
+      expected_pis = Moxml::Reference.processing_instructions(ref)
+      expected_comments = Moxml::Reference.comments(ref)
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc
+
+        got_pis = pi_rows(doc)
+        expect(got_pis.map(&:first)).to eq(expected_pis.map(&:first)),
+                                        "#{input.id}/#{name}: PI targets " \
+                                        "differ from the reference"
+        unless exempt?(input, :pi_content, name)
+          expect(got_pis).to eq(expected_pis),
+                             "#{input.id}/#{name}: PI data differs " \
+                             "from the reference"
+        end
+        unless exempt?(input, :comment_content, name)
+          expect(comment_rows(doc)).to eq(expected_comments),
+                                       "#{input.id}/#{name}: comment data " \
+                                       "differs from the reference"
+        end
+      end
+    end
+  end
+
+  it "serializes to XML that re-parses to the reference information set" do
+    InputTaxonomy.well_formed.each do |input|
+      ref = reference_for(input)
+      expected_order = Moxml::Reference.element_names(ref)
+      expected_children = Moxml::Reference.child_element_names(ref)
+      expected_text = Moxml::Reference.element_access_rows(ref)
+        .map { |(name, text, _content)| [name, compact(text)] }
+      adapters.each do |name|
+        doc = adapter_document(name, input.xml)
+        next unless doc
+        next if exempt?(input, :serialize, name)
+
+        begin
+          serialized = doc.to_xml(indent: 0)
+        rescue Moxml::Error, NotImplementedError, LoadError
+          next # named engine limit, pinned by its own spec
+        end
+        reparsed = begin
+          Moxml::Reference.parse(serialized)
+        rescue Moxml::ParseError => e
+          raise Moxml::ParseError,
+                "#{input.id}/#{name}: serialized XML is not well-formed: " \
+                "#{e.message}"
+        end
+
+        expect(Moxml::Reference.element_names(reparsed)).to eq(expected_order),
+                                                            "#{input.id}/#{name}: serialized tree lost or reordered elements"
+        expect(Moxml::Reference.child_element_names(reparsed)).to eq(expected_children),
+                                                                  "#{input.id}/#{name}: serialized tree changed nesting"
+        got_text = Moxml::Reference.element_access_rows(reparsed)
+          .map { |(element, text, _content)| [element, compact(text)] }
+        expect(got_text).to eq(expected_text),
+                            "#{input.id}/#{name}: serialized tree changed " \
+                            "text: #{got_text.inspect} vs #{expected_text.inspect}"
+      end
+    end
+  end
+end

data/spec/consistency/xpath_idioms_spec.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+# Processing model §Names and namespaces (normative): pinned here.
+# Processing model §XPath evaluation (normative): pinned here.
+
 require "spec_helper"
 
 # Cross-adapter XPath idioms that nokogiri consumers rely on:
@@ -39,11 +42,6 @@ RSpec.describe "XPath idioms across adapters" do
             Gem::Version.new(Leptris::VERSION) < Gem::Version.new("1.9.359.0")
           skip "binding #{Leptris::VERSION} predates the xmlns: fix (1.9.359)"
         end
-        if adapter_name == :oga
-          # oga's own Ruby XPath engine has no xmlns: default-ns
-          # support (third-party; explicit bindings work).
-          skip "D-01: oga's XPath engine does not implement the xmlns: idiom"
-        end
       end
 
       it "matches default-namespaced elements via the xmlns: prefix" do
@@ -59,6 +57,14 @@ RSpec.describe "XPath idioms across adapters" do
         expect(targets).to be_empty
       end
 
+      it "addresses the no-namespace default with an empty xmlns binding" do
+        doc = ctx.parse(
+          '<root xmlns="urn:a"><child xmlns="urn:b"><leaf xmlns=""/></child></root>',
+        )
+        leaf = doc.at_xpath("//xmlns:leaf", "xmlns" => "")
+        expect(leaf&.name).to eq("leaf")
+      end
+
       it "resolves attribute-terminal steps in every path position" do
         doc = ctx.parse(plain_xml)
         expect(doc.xpath("//a/@id").first&.value).to eq("x")
@@ -107,6 +113,29 @@ RSpec.describe "XPath idioms across adapters" do
         expect(doc.at_xpath("/*")&.name).to eq("r")
         expect(doc.at_xpath("/r")&.name).to eq("r")
       end
+
+      it "answers scalar XPath functions unwrapped and uniform" do
+        doc = ctx.parse(plain_xml)
+        expect(doc.xpath("count(//a)")).to eq(1.0)
+        expect(doc.xpath("string(//a/@id)")).to eq("x")
+        expect(doc.xpath("boolean(//b)")).to be(true)
+        expect(doc.at_xpath("count(//a)")).to eq(1.0)
+      end
+
+      # The live-tree contract: a sibling inserted after an XPath
+      # evaluation must be visible to at_xpath and xpath. leptris's
+      # node-set lane caches a document index that sibling insertions
+      # do not rebuild (engine bug, tracked upstream); the adapter
+      # routes such documents to the reference engine until a child
+      # insertion rebuilds the index.
+      it "answers at_xpath and xpath from the live tree after a sibling insertion" do
+        doc = ctx.parse("<r><a><b/></a></r>")
+        doc.xpath("//a")
+        doc.at("//a").next = "<c/>"
+        expect(doc.at("//c")&.name).to eq("c")
+        expect(doc.xpath("//c").map(&:name)).to eq(["c"])
+        expect(doc.at_xpath("count(//c)")).to eq(1.0)
+      end
     end
   end
 end

data/spec/consistency/xslt_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §XSLT (normative): pinned here.
+
 require "spec_helper"
 require "moxml/c14n"
 

data/spec/integration/shared_examples/edge_cases.rb

@@ -80,15 +80,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
 
   describe "namespace edge cases" do
     it "handles default namespace changes" do
-      if context.config.adapter_name == :headed_ox
-        skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
-      end
-      if context.config.adapter_name == :libxml
-        skip "LibXML cannot query empty default namespace with XPath (documented limitation)"
-      end
-      if context.config.adapter_name == :nokogiri
-        skip "Nokogiri XPath does not support querying empty namespace with xmlns prefix mapping"
-      end
       xml = <<~XML
         <root xmlns="http://default1.org">
           <child xmlns="http://default2.org">
@@ -103,10 +94,6 @@ RSpec.shared_examples "Moxml Edge Cases" do
     end
 
     it "handles recursive namespace definitions" do
-      if context.config.adapter_name == :headed_ox
-        skip "HeadedOx limitation: Namespace methods not implemented in adapter. Requires Ox namespace API enhancement. See docs/_pages/headed-ox-limitations.adoc"
-      end
-
       xml = <<~XML
         <root xmlns:a="http://a.org">
           <a:child xmlns:a="http://b.org">

data/spec/moxml/adapter/leptris_attribute_snapshot_spec.rb

@@ -5,10 +5,13 @@ require "spec_helper"
 # moxml#375 — element hydration through the binding's
 # attributes_snapshot face (libleptris 1.9.353, engine
 # leptris#1689): one crossing for every attribute instead of one
-# per attribute. The output contract is stride-identical to the
-# binding's per-attribute face: qualified names, document order,
-# fresh values.
+# per attribute. The facade listing face is bare names (uniform with
+# every adapter, and with Attribute#name), document order, fresh
+# values.
 RSpec.describe "leptris element-attribute snapshot hydration" do
+  def bare(pairs)
+    pairs.map { |(name, value)| [name.split(":", 2).last, value] }
+  end
   let(:ctx) { Moxml.new(:leptris) }
 
   context "when the snapshot face is armed (>= 1.9.353.0)" do
@@ -23,11 +26,11 @@ RSpec.describe "leptris element-attribute snapshot hydration" do
         '<root a="1" xml:lang="en" xmlns:ns="urn:u" ns:p="v"/>',
       )
       binding_element = Moxml::Adapter::Leptris.to_binding(doc.root)
-      expected = binding_element.attribute_pairs
+      expected = bare(binding_element.attribute_pairs)
 
       expect(doc.root.attribute_pairs).to eq(expected)
       expect(doc.root.attribute_pairs).to eq(
-        [["a", "1"], ["xml:lang", "en"], ["ns:p", "v"]],
+        [["a", "1"], ["lang", "en"], ["p", "v"]],
       )
     end
 
@@ -36,7 +39,7 @@ RSpec.describe "leptris element-attribute snapshot hydration" do
         '<root z="9" xmlns:m="urn:m" m:x="8" k="7"/>',
       )
       expect(doc.root.attribute_pairs.map(&:first)).to eq(
-        %w[z m:x k],
+        %w[z x k],
       )
     end
 
@@ -71,7 +74,7 @@ RSpec.describe "leptris element-attribute snapshot hydration" do
       )
       binding_element = Moxml::Adapter::Leptris.to_binding(doc.root)
       expect(doc.root.attribute_pairs).to eq(
-        binding_element.attribute_pairs,
+        bare(binding_element.attribute_pairs),
       )
     end
   end

data/spec/moxml/adapter/leptris_spec.rb

@@ -184,12 +184,14 @@ RSpec.describe Moxml::Adapter::Leptris do
       end
     end
 
-    it "keeps comments in element serialization with tab units (leptris-ruby#115)" do
+    it "keeps comments in indented serialization with tab units (leptris-ruby#115)" do
       skip "requires the element unit fix (leptris 1.9.50+)" unless described_class::ELEMENT_UNIT_COMMENTS
 
+      # Element-level indentation is loud on this engine (D-09); the
+      # document lane exercises the same generator's unit handling.
       doc = ctx.parse(%(<r><a/><!-- c --></r>))
-      expect(doc.root.to_xml(indent: 1, indent_text: "\t"))
-        .to eq("<r>\n\t<a></a>\n\t<!-- c -->\n</r>")
+      expect(doc.to_xml(indent: 1, indent_text: "\t"))
+        .to eq("<r>\n\t<a></a>\n\t<!-- c -->\n</r>\n")
     end
 
     it "round-trips document-level PI mutations through serialization" do
@@ -846,4 +848,22 @@ RSpec.describe Moxml::Adapter::Leptris do
       expect(first.next_sibling.parent).to eq(doc.root)
     end
   end
+
+  describe "stale-index guard retirement (leptris-ruby#519)" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    it "auto-retires the guard when the engine invalidates its index" do
+      skip "requires an engine whose node-set index survives sibling insertion (leptris-ruby#519)" unless described_class.native_xpath_index_fixed?
+
+      doc = ctx.parse("<r><a/><b/></r>")
+      root = doc.root
+      _ = root.xpath("child::*") # populate the engine node-set index
+      b = root.children.to_a[1]
+      b.add_previous_sibling(doc.create_element("c"))
+
+      native = described_class.native_xpath(root.native, "child::*", nil)
+      expect(native).not_to be_nil
+      expect(native.to_a.map { |n| n.name.to_s }).to eq(%w[a c b])
+    end
+  end
 end

data/spec/moxml/adapter/ox_spec.rb

@@ -94,7 +94,7 @@ RSpec.describe Moxml::Adapter::Ox do
 
       it "fails loudly on ox_mode: :hash (the adapter walks a tree, not a Hash)" do
         expect { described_class.parse("<r><t> x </t></r>", ox_mode: :hash) }
-          .to raise_error(RuntimeError, /must be a String or Ox::Node/)
+          .to raise_error(Moxml::ParseError, /must be a String or Ox::Node/)
       end
 
       it "surfaces an invalid ox_skip as Moxml::ParseError" do

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -457,10 +457,6 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
-        if described_class.name.include?("Ox")
-          skip("Ox does not support namespace-aware XPath queries (documented limitation)")
-        end
-
         # Parse original XML
         doc = described_class.parse(xml).native
 
@@ -513,10 +509,6 @@ RSpec.shared_examples "xml adapter" do
       end
 
       it "preserves and correctly handles multiple namespaces" do
-        if described_class.name.include?("Ox")
-          skip("Ox does not support namespace-aware XPath queries (documented limitation)")
-        end
-
         # Parse original XML
         doc = described_class.parse(xml).native
 

data/spec/moxml/attribute_resolver_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Access semantics (normative): pinned here.
+
 require "spec_helper"
 
 RSpec.describe Moxml::AttributeResolver do
@@ -29,6 +31,39 @@ RSpec.describe Moxml::AttributeResolver do
       expect(described_class.resolve(element, "z:type")).to be_nil
       expect(described_class.resolve(element, "xmlns:q")).to be_nil
     end
+
+    # Namespaces 1.0 §5.2: the default namespace never applies to
+    # attributes. Engines that resolve unprefixed attributes against
+    # the default namespace must answer nil for it, or bare-name reads
+    # miss on every element under a default namespace.
+    it "never treats bare attributes as default-namespace members" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        d = Moxml.new(adapter_name).parse(%(<r xmlns="urn:a"><e id="1"/></r>))
+        e = d.root.children.find(&:element?)
+        expect(e["id"]).to eq("1"), "#{adapter_name}: bare read"
+        expect(e.attribute("id")&.value).to eq("1"),
+                                            "#{adapter_name}: resolver"
+        expect(e.attribute("id")&.namespace).to be_nil,
+                                                "#{adapter_name}: attribute namespace"
+      end
+    end
+
+    it "keeps bare reads on programmatically built default-namespaced trees" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        ctx = Moxml.new(adapter_name)
+        d = ctx.create_document
+        root = d.create_element("root")
+        root.add_namespace(nil, "urn:a")
+        d.add_child(root)
+        e = d.create_element("item")
+        e["id"] = "123"
+        root.add_child(e)
+
+        expect(e["id"]).to eq("123"), "#{adapter_name}: bare read"
+        expect(d.xpath('//xmlns:item[@id="123"]').to_a.size).to eq(1),
+                                                                "#{adapter_name}: xmlns predicate"
+      end
+    end
   end
 
   describe ".assign" do

data/spec/moxml/c14n/adapter_delegation_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# Processing model §Canonicalization (normative): pinned here.
+
 require "spec_helper"
 require "moxml/c14n"
 
@@ -57,20 +59,47 @@ RSpec.describe "Moxml::C14n cross-adapter canonicalization" do
   end
 
   describe "document-level nodes keep document order" do
-    # oga surfaces the XML declaration as a <?xml?> PI and keeps the
-    # separator space in PI content (D-04); ox/headed_ox drop PI
-    # content on parse (D-05). Both are pre-existing parse-layer
-    # divergences, out of scope here.
-    let(:adapters) { Moxml::Adapter::AVAILABLE_ADAPTERS - %i[oga ox headed_ox] }
+    # ox/headed_ox drop PI content at parse (D-05), so content-bearing
+    # document-level PIs are pinned on the remaining adapters; the
+    # separator/newline rule itself is pinned on every adapter below
+    # (comments and empty-data PIs are common across all of them).
+    let(:content_adapters) do
+      Moxml::Adapter::AVAILABLE_ADAPTERS - %i[ox headed_ox]
+    end
 
     it "canonicalizes a leading PI before the root element" do
-      adapters.each do |adapter_name|
+      content_adapters.each do |adapter_name|
         doc = Moxml.new(adapter_name)
           .parse(%(<?xml version="1.0"?><?render mode="x"?><doc><e/></doc>))
         expect(Moxml::C14n.canonicalize(doc))
           .to eq(%(<?render mode="x"?>\n<doc><e></e></doc>))
       end
     end
+
+    it "uses exactly one newline between document-level nodes" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name)
+          .parse(%(<?pi?><?pi2?><!--a--><doc/><!--b--><?pi3?>))
+        expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+          .to eq(%(<?pi?>\n<?pi2?>\n<!--a-->\n<doc></doc>\n<!--b-->\n<?pi3?>))
+      end
+    end
+
+    it "never emits the XML declaration" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name)
+          .parse(%(<?xml version="1.0" encoding="UTF-8"?><doc/>))
+        expect(Moxml::C14n.canonicalize(doc)).to eq("<doc></doc>")
+      end
+    end
+
+    it "collapses PI separator whitespace to one space" do
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name).parse(%(<?pi  a  b?><doc/>))
+        expect(Moxml::C14n.canonicalize(doc))
+          .to eq(%(<?pi a  b?>\n<doc></doc>))
+      end
+    end
   end
 
   describe "native delegation" do

data/spec/moxml/c14n/character_encoding_spec.rb

@@ -12,25 +12,19 @@ LATIN1_XML = (+"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?><r>caf\xE9</r>").
 BOM_XML = (+"\xEF\xBB\xBF<r/>").force_encoding("UTF-8")
 NFC_XML = (+"<r>caf\xC3\xA9</r>").force_encoding("UTF-8")
 
-# oga's parse layer leaks the declaration as a PI node and the BOM as
-# text (pre-existing, documented in the W3C examples spec).
-OGA_LEAK = %i[oga].freeze
-
 RSpec.describe "Moxml character encoding at the parse boundary" do
   Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
     context "with the #{adapter_name} adapter" do
       let(:ctx) { Moxml.new(adapter_name) }
 
-      unless OGA_LEAK.include?(adapter_name)
-        it "transcodes declared Latin-1 to UTF-8 bytes" do
-          doc = ctx.parse(LATIN1_XML.dup)
-          expect(Moxml::C14n.canonicalize(doc).bytes).to eq(CAF_E_UTF8)
-        end
+      it "transcodes declared Latin-1 to UTF-8 bytes" do
+        doc = ctx.parse(LATIN1_XML.dup)
+        expect(Moxml::C14n.canonicalize(doc).bytes).to eq(CAF_E_UTF8)
+      end
 
-        it "strips a leading UTF-8 BOM" do
-          doc = ctx.parse(BOM_XML.dup)
-          expect(Moxml::C14n.canonicalize(doc)).to eq("<r></r>")
-        end
+      it "strips a leading UTF-8 BOM" do
+        doc = ctx.parse(BOM_XML.dup)
+        expect(Moxml::C14n.canonicalize(doc)).to eq("<r></r>")
       end
 
       it "passes NFC content through without normalization" do

data/spec/moxml/c14n/comments_pis_spec.rb

@@ -48,18 +48,45 @@ RSpec.describe "C14N comments and PIs" do
   end
 
   describe "PIs at document level" do
-    # TODO.c14n/09: Document-level PIs (outside the document element) are
-    # not yet rendered correctly. The moxml PI parser mis-parses document-level
-    # PIs, and the DataModel.from_document path drops them. Fixing requires
-    # adapter-level work and is tracked separately.
-    it "renders PIs outside the document element (KNOWN LIMITATION)" do
-      skip "D-08: document-level PI rendering not yet implemented"
+    it "renders PIs outside the document element in document order" do
+      doc = ctx.parse(%(<?pi before?><root><?pi inner?></root><?pi after?>))
+      expect(Moxml::C14n.canonicalize(doc))
+        .to eq(%(<?pi before?>\n<root><?pi inner?></root>\n<?pi after?>))
+    end
+
+    it "uses exactly one newline between document-level nodes" do
+      doc = ctx.parse(%(<?pi a?><?pi b?><root/><?pi c?>))
+      expect(Moxml::C14n.canonicalize(doc))
+        .to eq(%(<?pi a?>\n<?pi b?>\n<root></root>\n<?pi c?>))
+    end
+
+    it "ignores whitespace between document-level nodes" do
+      # rexml retains the text node (D-15); the canonical form never
+      # includes whitespace outside the document element.
+      Moxml::Adapter::AVAILABLE_ADAPTERS.each do |adapter_name|
+        doc = Moxml.new(adapter_name).parse(%(<?pi?>\n<root/>\n<!--c-->))
+        expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+          .to eq(%(<?pi?>\n<root></root>\n<!--c-->)), adapter_name.to_s
+      end
+    end
+
+    it "omits the XML declaration from the canonical form" do
+      doc = ctx.parse(%(<?xml version="1.0" encoding="UTF-8"?><root/>))
+      expect(Moxml::C14n.canonicalize(doc)).to eq("<root></root>")
     end
   end
 
   describe "comments at document level" do
-    it "renders document-level comments when with_comments: true (KNOWN LIMITATION)" do
-      skip "D-08: document-level comment rendering not yet implemented"
+    it "renders document-level comments when with_comments: true" do
+      doc = ctx.parse(%(<!--lead--><root><!--inner--></root><!--trail-->))
+      expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+        .to eq(%(<!--lead-->\n<root><!--inner--></root>\n<!--trail-->))
+    end
+
+    it "keeps exactly one newline between a document-level PI and comment" do
+      doc = ctx.parse(%(<?pi x?><!--lead--><root/>))
+      expect(Moxml::C14n.canonicalize(doc, with_comments: true))
+        .to eq(%(<?pi x?>\n<!--lead-->\n<root></root>))
     end
   end
 end

data/spec/moxml/c14n/subset_spec.rb

@@ -43,9 +43,6 @@ COMMENTS_EXCLUDED_CASE = [
 ].freeze
 
 COMMENTS_PADDING_LOSS = %i[ox headed_ox].freeze
-# rexml's adapter xpath does not return comment()/text() node results
-# (pre-existing capability gap, same family for both axes).
-COMMENT_SELECTION_GAP = %i[rexml].freeze
 
 RSpec.describe "Moxml::C14n subset canonicalization" do
   # Node-set semantics follow the enveloped-signature interop
@@ -60,11 +57,6 @@ RSpec.describe "Moxml::C14n subset canonicalization" do
         let(:ctx) { Moxml.new(adapter_name) }
 
         C14N_SUBSET_CORPUS.each do |label, xml, xpath, expected|
-          next if label == "text selection" && adapter_name == :rexml
-
-          # rexml's adapter xpath does not return text nodes for
-          # text() node tests (D-07, pre-existing capability gap).
-
           it "canonicalizes #{label}" do
             doc = ctx.parse(xml)
             expect(Moxml::C14n.canonicalize_subset(doc, xpath)).to eq(expected)
@@ -73,10 +65,8 @@ RSpec.describe "Moxml::C14n subset canonicalization" do
 
         # ox/headed_ox strip comment content padding at the parse
         # layer (D-06, pre-existing, same family as their PI content
-        # loss); only the rendered-comment case depends on it. rexml's
-        # comment() selection gap (D-07) also only affects this case.
-        unless COMMENTS_PADDING_LOSS.include?(adapter_name) ||
-            COMMENT_SELECTION_GAP.include?(adapter_name)
+        # loss); only the rendered-comment case depends on it.
+        unless COMMENTS_PADDING_LOSS.include?(adapter_name)
           it COMMENTS_CASE[0] do
             doc = ctx.parse(COMMENTS_CASE[1])
             expect(Moxml::C14n.canonicalize_subset(doc, COMMENTS_CASE[2],

data/spec/moxml/c14n/w3c_examples_spec.rb

@@ -13,7 +13,6 @@ require "moxml/c14n"
 # Documented parse-layer divergences (skipped rows):
 # - ox/headed_ox expand 
 to LF, strip inter-element whitespace
 #   and comment padding at parse (out of scope here)
-# - oga keeps the target/content separator space in PI data
 W3C_FULL_FORMS = [
   ["attribute-value whitespace collapses to single spaces",
    "<doc>\n   <e   attr1=\"v1\"\n        attr2   =   \"v2\"\n    >   content   </e>\n</doc>",
@@ -55,11 +54,9 @@ RSpec.describe "Moxml::C14n W3C REC-xml-c14n examples" do
 
       W3C_FULL_FORMS.each_with_index do |(label, xml, expected), idx|
         # ox/headed_ox strip inter-element whitespace, expand &#xD;
-        # and pad comments at parse (D-05, D-06); oga keeps the PI
-        # separator space (D-04).
+        # and pad comments at parse (D-05, D-06).
         skip_shapes = { ox: [0, CR_SHAPE, PI_SHAPE],
-                        headed_ox: [0, CR_SHAPE, PI_SHAPE],
-                        oga: [PI_SHAPE] }[adapter_name] || []
+                        headed_ox: [0, CR_SHAPE, PI_SHAPE] }[adapter_name] || []
         next if skip_shapes.include?(idx)
 
         it "canonicalizes #{label}" do