moxml 0.5.142 → 0.5.143

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c55a66ba735b6d8f170ad9f83a95faeb16717520d2fd30f767e1dc56914914b
-  data.tar.gz: 74f3c07cdccc077e78fbef88d9d8e8f83310f5f9cdc1175221bf719a3a864146
+  metadata.gz: c7ef456b1833d080915877e15238d23fd1e3d38bd638a434711bc98d423b78fc
+  data.tar.gz: 680fe1bbe7097895d5fdb46c29e5e2c624b13ed29792be2ffa941ef3c8bbe3bb
 SHA512:
-  metadata.gz: 2b8a163b9601f4da9d2c9a96b1d5ef35eb0d874c27ec5d6c608283cd7ca27c9d801fa9065724a8989406423bd0844100d914cb2ee0de07a2a8f51f0212eb4ab4
-  data.tar.gz: 153852b30839c08744fbd29558af04ba07a1c7c27979fa5cfd0ab6fbf48185a1186a33b7989b4aaf07e477942a3c9c215aa6b25b9225dff5670def94a71aa563
+  metadata.gz: 01e458bb31733bbb8a9bf379d37ba30b4d5b30d1670eceffbfad5ae953afa85f1dc272ce3cc99cf719808417a13035dadf00e14fdb6a01d5cce3f4bcc855e8ac
+  data.tar.gz: e0eae403141507dcc8dd23e3b6962935cac3481382ef268a41105ae919e014fc53e657e4b44d261cdb8e59799678dc0a2f1f103937580ee6bb7b8f4e93372667

data/lib/moxml/adapter/base.rb

@@ -89,6 +89,15 @@ module Moxml
         # no declaration. indent:/indent_text: thread the
         # pretty-print knobs where the adapter's engine carries
         # them. Adapters without an HTML serializer raise.
+        # XHTML-shaped serialization (issue #390): void elements
+        # self-closed, non-void paired, indent knobs composing.
+        # Adapters with an HTML engine answer this; the default
+        # raises so consumers get a named error, not mangled bytes.
+        def serialize_xhtml(_node, _options = {})
+          raise Moxml::NotImplementedError,
+                "XHTML serialization requires an adapter with an HTML engine"
+        end
+
         def serialize_html(_node, _options = {})
           raise Moxml::AdapterError.new(
             "HTML serialization is not supported by the #{name.split('::').last} adapter",

data/lib/moxml/adapter/leptris.rb

@@ -1212,6 +1212,16 @@ module Moxml
           node.to_html(**kwargs)
         end
 
+        # XHTML shape (issue #390): the binding's XML method on an
+        # HTML document — void elements short-form (<br/>), non-void
+        # paired, raw text escaped, no declaration. The indent knobs
+        # thread the #354 machinery.
+        def serialize_xhtml(node, options = {})
+          node.to_xml(no_decl: true, **options.slice(:indent,
+                                                     :indent_text, :encoding)
+                                                     .compact)
+        end
+
         def parse_html_fragment(html, context_tag = :body, _context = nil)
           unless HTML_FRAGMENT
             raise Moxml::AdapterError.new(

data/lib/moxml/adapter/nokogiri.rb

@@ -189,6 +189,22 @@ module Moxml
           node.to_html(**kwargs)
         end
 
+        # Nokogiri's AS_XHTML save flag is the byte reference for the
+        # XHTML shape (issue #390): FORMAT layout, self-closed voids,
+        # no declaration.
+        def serialize_xhtml(node, options = {})
+          save_with = ::Nokogiri::XML::Node::SaveOptions::FORMAT |
+            ::Nokogiri::XML::Node::SaveOptions::AS_XHTML |
+            ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+          io = StringIO.new
+          kwargs = { save_with: save_with }
+          kwargs[:indent] = options[:indent] if options[:indent]
+          kwargs[:indent_text] = options[:indent_text] if options[:indent_text]
+          kwargs[:encoding] = options[:encoding] if options[:encoding]
+          node.write_to(io, **kwargs)
+          io.string
+        end
+
         # WHATWG fragment parse through Nokogiri::HTML5.fragment
         # (issue #353) — the same tree construction the leptris
         # lane composes over its WHATWG engine.

data/lib/moxml/document.rb

@@ -129,12 +129,30 @@ module Moxml
     # (leptris >= the #354 ride; nokogiri passes them to the
     # engine). Adapters without the knob raise Moxml::AdapterError.
     def to_html(options = {})
+      return to_xhtml(options) if options[:xhtml]
+
       result = adapter.serialize_html(@native, options)
       apply_line_ending(result,
                         options.fetch(:line_ending, Config::LINE_ENDING_LF))
       result
     end
 
+    # XHTML-shaped serialization (issue #390): void elements
+    # self-closed (<br/>), non-void elements paired, raw text
+    # escaped (the XML method's §16.2-compatible escaping), no
+    # declaration unless asked. Composes with the indent knobs.
+    # Also selected by to_html(xhtml: true).
+    #
+    # Byte reference: Nokogiri's FORMAT | AS_XHTML | NO_DECLARATION
+    # save flag; canon pins engine-vs-Nokogiri parity on its display
+    # corpus before flipping its lane.
+    def to_xhtml(options = {})
+      result = adapter.serialize_xhtml(@native, options)
+      apply_line_ending(result,
+                        options.fetch(:line_ending, Config::LINE_ENDING_LF))
+      result
+    end
+
     def create_element(name)
       Wrappers::Element.new(adapter.create_element(name, owner_doc: @native), context)
     end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.142"
+  VERSION = "0.5.143"
 end

data/spec/consistency/xslt_spec.rb

@@ -13,7 +13,7 @@ SUPPORTED = %i[nokogiri leptris].select do |name|
   Moxml::Adapter::AVAILABLE_ADAPTERS.include?(name)
 end.freeze
 
-CORPUS = {
+XSLT_CORPUS = {
   "value-of with count" => [
     <<~XSL,
       <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
@@ -82,7 +82,7 @@ RSpec.describe "Moxml::XSLT cross-engine agreement" do
         output.sub(/\A<\?xml[^>]*\?>\s*/, "")
       end
 
-      CORPUS.each do |label, (sheet_xml, input, expected_re)|
+      XSLT_CORPUS.each do |label, (sheet_xml, input, expected_re)|
         it "transforms #{label}" do
           sheet = ctx.xslt(sheet_xml)
           doc = ctx.parse(input)
@@ -97,7 +97,7 @@ RSpec.describe "Moxml::XSLT cross-engine agreement" do
     return unless SUPPORTED.size == 2
 
     first, second = SUPPORTED.map { |name| Moxml.new(name) }
-    CORPUS.each do |label, (sheet_xml, input, _)|
+    XSLT_CORPUS.each do |label, (sheet_xml, input, _)|
       a = first.xslt(sheet_xml).apply_to_string(first.parse(input))
       b = second.xslt(sheet_xml).apply_to_string(second.parse(input))
       expect(Moxml::C14n.equivalent?(a, b))

data/spec/moxml/c14n/adapter_delegation_spec.rb

@@ -3,7 +3,7 @@
 require "spec_helper"
 require "moxml/c14n"
 
-CORPUS = {
+C14N_DELEGATION_CORPUS = {
   "cdata content becomes escaped text" => [
     "<doc><![CDATA[a < b]]>tail</doc>",
     "<doc>a &lt; btail</doc>",
@@ -45,7 +45,7 @@ RSpec.describe "Moxml::C14n cross-adapter canonicalization" do
       context "with the #{adapter_name} adapter" do
         let(:ctx) { Moxml.new(adapter_name) }
 
-        CORPUS.each do |label, (input, expected)|
+        C14N_DELEGATION_CORPUS.each do |label, (input, expected)|
           it "canonicalizes #{label}" do
             root = ctx.parse(input).root
             expect(Moxml::C14n.canonicalize_inclusive10(root)).to eq(expected)

data/spec/moxml/c14n/subset_spec.rb

@@ -9,7 +9,7 @@ ENVELOPED_DOC = %(<env><payload id="p1">data &amp; more</payload>#{SIG}<tail/></
 ENVELOPED_EXCLUDE = '//*[not(ancestor-or-self::*[local-name()="Signature"])]'
 SIGNATURE_XPATH = '//*[local-name()="Signature"]'
 
-CORPUS = [
+C14N_SUBSET_CORPUS = [
   ["apex attraction + text",
    %(<a xml:lang="en"><b id="1"><c>t</c></b><d/></a>), "//b",
    %(<b id="1" xml:lang="en"></b>)],
@@ -59,7 +59,7 @@ RSpec.describe "Moxml::C14n subset canonicalization" do
       context "with the #{adapter_name} adapter" do
         let(:ctx) { Moxml.new(adapter_name) }
 
-        CORPUS.each do |label, xml, xpath, expected|
+        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

data/spec/moxml/xhtml_output_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Issue #390: XHTML-shaped serialization — void elements self-closed
+# (<br/>), non-void elements paired, raw text escaped, no XML
+# declaration. Composes with the #354 indent knobs. Nokogiri's
+# FORMAT | AS_XHTML | NO_DECLARATION save flag is the byte
+# reference; canon's fixture_ready display lane rides the face.
+RSpec.describe "XHTML output mode" do
+  let(:doc) do
+    Moxml.new(ENV.fetch("XHTML_ADAPTER", :leptris)).parse_html(
+      '<!DOCTYPE html><html><body><p>a<br>b</p><img src="x.png">' \
+      "<hr></body></html>",
+    )
+  end
+
+  describe "Document#to_xhtml" do
+    it "self-closes void elements with the XHTML slash" do
+      out = doc.to_xhtml
+      expect(out).not_to include("<br>")
+      expect(out).to include("<br/>")
+      expect(out).to include('<img src="x.png"/>')
+      expect(out).to include("<hr/>")
+    end
+
+    it "pairs non-void elements" do
+      out = doc.to_xhtml
+      expect(out).to include("<p>a<br/>b</p>")
+      expect(out).not_to include("<p/>")
+    end
+
+    it "omits the XML declaration" do
+      expect(doc.to_xhtml).not_to start_with("<?xml")
+    end
+
+    it "keeps the doctype as document content" do
+      expect(doc.to_xhtml).to include("<!DOCTYPE html>")
+    end
+
+    it "composes with the indent knobs" do
+      out = doc.to_xhtml(indent: 2)
+      expect(out).to include("\n  <body>")
+      expect(out).to include("\n    <p>a<br/>b</p>")
+    end
+
+    it "escapes raw text per the XML method" do
+      doc = Moxml.new(ENV.fetch("XHTML_ADAPTER", :leptris)).parse_html(
+        "<!DOCTYPE html><html><body><script>if (a < b) { x(); }</script>" \
+        "</body></html>",
+      )
+      out = doc.to_xhtml
+      expect(out).not_to include("a < b")
+      expect(out).to include("&lt;") if out.include?("script")
+    end
+  end
+
+  describe "Document#to_html(xhtml: true)" do
+    it "selects the same shape" do
+      expect(doc.to_html(xhtml: true)).to eq(doc.to_xhtml)
+    end
+
+    it "still serves the HTML shape without the flag" do
+      expect(doc.to_html).to include("<br>")
+      expect(doc.to_html).not_to include("<br/>")
+    end
+  end
+
+  describe "adapter coverage" do
+    it "serves the nokogiri lane (the byte reference)" do
+      doc = Moxml.new(:nokogiri).parse_html(
+        "<!DOCTYPE html><html><body><p>a<br>b</p></body></html>",
+      )
+      out = doc.to_xhtml
+      expect(out).to include("<br/>")
+      expect(out).to include("<p>a<br/>b</p>")
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.142
+  version: 0.5.143
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-18 00:00:00.000000000 Z
+date: 2026-10-19 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -560,6 +560,7 @@ files:
 - spec/moxml/text_spec.rb
 - spec/moxml/to_html_spec.rb
 - spec/moxml/version_spec.rb
+- spec/moxml/xhtml_output_spec.rb
 - spec/moxml/xml_emitter_spec.rb
 - spec/moxml/xml_utils/.gitkeep
 - spec/moxml/xml_utils/encoder_spec.rb