moxml 0.5.142 → 0.5.145

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c55a66ba735b6d8f170ad9f83a95faeb16717520d2fd30f767e1dc56914914b
-  data.tar.gz: 74f3c07cdccc077e78fbef88d9d8e8f83310f5f9cdc1175221bf719a3a864146
+  metadata.gz: 042f6cd21672a36e869b19c158819a3624d3a79a53de1fd083e83a377b577442
+  data.tar.gz: 7cacbfbd44bb9a87aa252a638b8ac9d25fb5cb67b6e3845c8fdf9c5cf943df24
 SHA512:
-  metadata.gz: 2b8a163b9601f4da9d2c9a96b1d5ef35eb0d874c27ec5d6c608283cd7ca27c9d801fa9065724a8989406423bd0844100d914cb2ee0de07a2a8f51f0212eb4ab4
-  data.tar.gz: 153852b30839c08744fbd29558af04ba07a1c7c27979fa5cfd0ab6fbf48185a1186a33b7989b4aaf07e477942a3c9c215aa6b25b9225dff5670def94a71aa563
+  metadata.gz: 507216b5acdf26ae9cd5b4d69c12d2519b949fbe2017c39a804954a04659780c5432b4fe8b11262642ca1699e09eb453af08e230a653a9b530f55404b6d6f5f1
+  data.tar.gz: 5d19c7d3d7e1ad18864d13b0b3eaf69f481b5f1a0c68fd652f29cd9bff4e7b9f95f4adf57698d77849371bc635f9ba3ef36c945f12a1b63e2a350e50fc886bbb

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
@@ -209,7 +227,21 @@ module Moxml
       self
     end
 
+    # Relative name-test paths on the document resolve laxly, as
+    # descendant-or-self anchored at the root — Nokogiri's own
+    # Document#at/#search semantics (moxml#393; its #xpath/#at_xpath are
+    # strict document-context, where the only element child is the root,
+    # and the adapters disagree there anyway: leptris's engine returns []
+    # for every relative path — leptris-ruby#502 — while Nokogiri's
+    # #at/#xpath disagree with each other). Every strict match survives
+    # the lax rewrite (the only strict-matchable first step is the root
+    # itself), so this is purely additive. Non-name-test expressions
+    # (axes, node types, ".", "..") keep document context.
+    RELATIVE_NAME_TEST = /\A\s*(\*|[A-Za-z_][\w.-]*)(\s*\[|\s*\||\z|\/)/
+
     def xpath(expression, namespaces = nil)
+      expression = lax_document_path(expression) if relative_name_test?(expression)
+
       result = adapter.xpath(@native, expression, namespaces)
 
       # Handle different result types:
@@ -228,6 +260,8 @@ module Moxml
     end
 
     def at_xpath(expression, namespaces = nil)
+      expression = lax_document_path(expression) if relative_name_test?(expression)
+
       if (native_node = adapter.at_xpath(@native, expression, namespaces))
         Moxml::Node.wrap(native_node, context)
       end
@@ -250,5 +284,44 @@ module Moxml
     def find_all(xpath)
       xpath(xpath).to_a
     end
+
+    private
+
+    def relative_name_test?(expression)
+      expression.match?(RELATIVE_NAME_TEST)
+    end
+
+    # Anchor every top-level union branch at the document root
+    # ("//"= descendant-or-self): "a/b | c" -> "//a/b | //c" — one
+    # adapter call, engine document order preserved, and the
+    # attribute-terminal idiom (pinned below) stays intact, which the
+    # ".//" form does not (libxml2 rejects .//r/a/@id).
+    def lax_document_path(expression)
+      split_top_level_unions(expression)
+        .map { |branch| "//#{branch.strip}" }
+        .join(" | ")
+    end
+
+    def split_top_level_unions(expression)
+      branches = [+""]
+      depth = 0
+      quote = nil
+      expression.each_char do |ch|
+        if quote
+          quote = nil if ch == quote
+        elsif ["'", '"'].include?(ch)
+          quote = ch
+        elsif ["(", "["].include?(ch)
+          depth += 1
+        elsif [")", "]"].include?(ch)
+          depth -= 1
+        elsif ch == "|" && depth.zero?
+          branches << +""
+          next
+        end
+        branches.last << ch
+      end
+      branches
+    end
   end
 end

data/lib/moxml/version.rb

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

data/spec/consistency/xpath_idioms_spec.rb

@@ -53,9 +53,28 @@ RSpec.describe "XPath idioms across adapters" do
         expect(doc.xpath("//a/@id").first&.value).to eq("x")
         expect(doc.xpath("//@id").first&.value).to eq("x")
         expect(doc.xpath("r/a/@id").first&.value).to eq("x")
-        expect(
-          doc.xpath("//*[local-name()='a']/@id").first&.value,
-        ).to eq("x")
+        expect(doc.xpath("//*[local-name()='a']/@id").first&.value).to eq("x")
+      end
+
+      # moxml#393: a relative name-test path on the DOCUMENT resolves
+      # laxly, descendant-anchored at the root — Nokogiri's own
+      # Document#at/#search semantics, now pinned for every adapter.
+      # Axes, node types and "." keep strict document context.
+      it "resolves document-context relative name-test paths from the root" do
+        doc = ctx.parse(plain_xml)
+        expect(doc.at("a/b")&.name).to eq("b")
+        expect(doc.at_xpath("a/b")&.name).to eq("b")
+        expect(doc.xpath("a/b").map(&:name)).to eq(["b"])
+        expect(doc.xpath("a | r").map(&:name).sort).to eq(%w(a r))
+        expect(doc.xpath("missing").map(&:name)).to eq([])
+        expect(doc.at_xpath("missing")).to be_nil
+      end
+
+      it "keeps non-name-test expressions in document context" do
+        doc = ctx.parse(plain_xml)
+        expect(doc.at_xpath(".")).to be_truthy
+        expect(doc.at_xpath("/*")&.name).to eq("r")
+        expect(doc.at_xpath("/r")&.name).to eq("r")
       end
     end
   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.145
 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