moxml 0.5.123 → 0.5.125

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aba5868bf7db2136823ceac2c98f825cad89b1c8f7b8e34d9ac1de2c7cbe1e61
-  data.tar.gz: 3b8cdeb8e497d73d0c2d7db37c5f3af95e5a7bc165a6cbad8a68bb2b3cec2913
+  metadata.gz: 29ea7cba280de638af460bd398d4abff8d86cdccdfbb2bb228ed4fda643d362e
+  data.tar.gz: 551bfa7c9ba32d50fccb6d4eac05582794702789eebd05e40969f2864dcb8812
 SHA512:
-  metadata.gz: 92aabda5d25c00d5c2d81fa3103ad4580f1e6774827057541659000cb3344e1e056cd922d4ce96a04975d6c29692fa087948a31c41de7d60cd5227f77aff382b
-  data.tar.gz: 28cfbef33282d28a6eb0f94c248cbf36399cb8911430b468f9c67f890e2be684d8926d2670c346f54ab7aad9cfb0085f87bfc09dbeb9fed83c8b029e79997134
+  metadata.gz: a4717bd664d778f96a0a5362764fb82e01e87b6ea0bdf3708fffdcd42ffc1953c6e0ee3dd7cae74f1072d28e89d69339c6f2099540271500084aaa8e6ff337a7
+  data.tar.gz: a2c1825275657af73727ffb5981fb492459a63a5c32bf82926ae597ea2807e7c1fc09f490986f03128644e817c96fb26d0265dce9199d86750ec9b8bf43e8e49

data/Gemfile

@@ -9,7 +9,7 @@ gemspec
 gem "benchmark"
 gem "benchmark-ips"
 gem "get_process_mem"
-gem "leptris", "~> 1.9.321"
+gem "leptris", "~> 1.9.338"
 gem "libxml-ruby", ">= 5.0"
 gem "nokogiri", "~> 1.18"
 gem "openssl", "~> 3.0"

data/lib/moxml/adapter/base.rb

@@ -84,6 +84,18 @@ module Moxml
           )
         end
 
+        # HTML serialization through the engine's HTML method
+        # (issue #354): void elements slash-less, raw text verbatim,
+        # no declaration. indent:/indent_text: thread the
+        # pretty-print knobs where the adapter's engine carries
+        # them. Adapters without an HTML serializer raise.
+        def serialize_html(_node, _options = {})
+          raise Moxml::AdapterError.new(
+            "HTML serialization is not supported by the #{name.split('::').last} adapter",
+            adapter: name, operation: "serialize_html",
+          )
+        end
+
         # Tolerant HTML4/5 parsing into the standard DOM (engine
         # issue leptris/leptris#659): implied end tags, void elements,
         # case-insensitive lowercased names, the HTML named-entity
@@ -103,6 +115,35 @@ module Moxml
           )
         end
 
+        # WHATWG fragment parsing with a context element (issue
+        # #353, the parse_html_fragment contract): body context by
+        # default; table contexts (td/th/tr/tbody/thead/tfoot/
+        # caption/colgroup/table) where the adapter's engine
+        # carries them. Returns the adapter's native fragment for
+        # HtmlFragment to wrap.
+        def parse_html_fragment(_html, _context_tag = :body, _context = nil)
+          raise Moxml::AdapterError.new(
+            "HTML fragment parsing is not supported by the #{name.split('::').last} adapter",
+            adapter: name, operation: "parse_html_fragment",
+          )
+        end
+
+        # The native fragment's top-level children (native nodes).
+        def fragment_children(_native_fragment)
+          raise Moxml::NotImplementedError.new(
+            "fragment_children not implemented",
+            feature: "fragment_children", adapter: name,
+          )
+        end
+
+        # The native fragment serialized as its children joined.
+        def serialize_fragment(_native_fragment)
+          raise Moxml::NotImplementedError.new(
+            "serialize_fragment not implemented",
+            feature: "serialize_fragment", adapter: name,
+          )
+        end
+
         # Parse XML using SAX (event-driven) parsing
         #
         # SAX parsing provides a memory-efficient way to process XML

data/lib/moxml/adapter/leptris.rb

@@ -161,6 +161,27 @@ module Moxml
         ::Leptris::XML::Document.method_defined?(:absorb) &&
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.311.3")
 
+      # Document#to_html indent kwargs (issue #354, engine
+      # leptris#1637 via leptris-ruby#421): the nested HTML layout
+      # (indent_html ext option — libxml2 format-mode shape). The
+      # parameter probe pairs the version gate: a pre-#421 binding's
+      # to_html takes no kwargs and would raise ArgumentError from
+      # the pass-through.
+      HTML_SERIALIZE_INDENT =
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.338.0") &&
+        defined?(::Leptris::XML::Document) &&
+        ::Leptris::XML::Document.method_defined?(:to_html) &&
+        ::Leptris::XML::Document.instance_method(:to_html)
+          .parameters.any? { |_, key| key == :indent }
+
+      # Leptris::HTML.parse_fragment (leptris-ruby#422, engine
+      # in-body drops leptris#1638): the WHATWG fragment semantics
+      # composed over the binding's WHATWG lane. The face probe
+      # gates the ride — older bindings raise a named error.
+      HTML_FRAGMENT =
+        defined?(::Leptris::HTML) &&
+        ::Leptris::HTML.respond_to?(:parse_fragment)
+
       # Markup-accumulating builder face (leptris-ruby#374 lever 2,
       # binding 1.9.313): the DSL accumulates markup in a plain
       # String and ONE native crossing (parse + attach) flushes the
@@ -1077,6 +1098,45 @@ module Moxml
           end
         end
 
+        def serialize_html(node, options = {})
+          kwargs = options.slice(:indent, :indent_text).compact
+          if kwargs.empty?
+            return node.to_html
+          end
+          unless HTML_SERIALIZE_INDENT
+            raise Moxml::AdapterError.new(
+              "HTML serialization with indent options requires leptris >= 1.9.338.0 " \
+              "(got #{::Leptris::VERSION})",
+              adapter: name, operation: "serialize_html",
+            )
+          end
+          node.to_html(**kwargs)
+        end
+
+        def parse_html_fragment(html, context_tag = :body, _context = nil)
+          unless HTML_FRAGMENT
+            raise Moxml::AdapterError.new(
+              "HTML fragment parsing requires leptris >= 1.9.338.0 " \
+              "(got #{::Leptris::VERSION})",
+              adapter: name, operation: "parse_html_fragment",
+            )
+          end
+          begin
+            ::Leptris::HTML.parse_fragment(html, context: context_tag)
+          rescue ::ArgumentError => e
+            raise Moxml::AdapterError.new(e.message,
+                                          adapter: name, operation: "parse_html_fragment")
+          end
+        end
+
+        def fragment_children(native_fragment)
+          native_fragment.children
+        end
+
+        def serialize_fragment(native_fragment)
+          native_fragment.to_html
+        end
+
         def parse_html(html, _options = {}, _context = nil)
           html_string = html.is_a?(IO) || html.is_a?(StringIO) ? html.read : html.to_s
           native_doc = begin

data/lib/moxml/adapter/nokogiri.rb

@@ -159,6 +159,40 @@ module Moxml
           Wrappers::Document.new(native_doc, _context || Context.new(:nokogiri))
         end
 
+        # HTML method pass-through: the engine's own bytes (libxml2
+        # HTML serializer; the HTML5/gumbo serializer ignores indent
+        # kwargs — pass-through parity with direct Nokogiri calls,
+        # which is the byte contract of this adapter's to_html).
+        def serialize_html(node, options = {})
+          kwargs = {}
+          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.to_html(**kwargs)
+        end
+
+        # WHATWG fragment parse through Nokogiri::HTML5.fragment
+        # (issue #353) — the same tree construction the leptris
+        # lane composes over its WHATWG engine.
+        def parse_html_fragment(html, context_tag = :body, _context = nil)
+          unless context_tag == :body
+            raise Moxml::AdapterError.new(
+              "nokogiri fragment contexts beyond :body are not supported " \
+              "(got #{context_tag.inspect})",
+              adapter: name, operation: "parse_html_fragment",
+            )
+          end
+          ::Nokogiri::HTML5.fragment(html)
+        end
+
+        def fragment_children(native_fragment)
+          native_fragment.children.to_a
+        end
+
+        def serialize_fragment(native_fragment)
+          native_fragment.children.map(&:to_html).join
+        end
+
         # Nokogiri parses with `config.recover` unless strict, so
         # recoverable syntax errors land on `doc.errors` instead of
         # raising (issue #147).

data/lib/moxml/context.rb

@@ -133,6 +133,29 @@ module Moxml
       config.adapter.parse_html(html, options, self)
     end
 
+    # WHATWG fragment parse (issue #353): the parsed top-level
+    # nodes with fragment semantics — the context element's
+    # insertion mode governs tree construction (:body default keeps
+    # head-swept elements at fragment top level; the table
+    # contexts take the in-table rules). Returns an
+    # Moxml::HtmlFragment whose #children are the moxml-wrapped
+    # top-level nodes.
+    #
+    # @param html [String, IO] the fragment source
+    # @param context_tag [Symbol] :body (default) or a table
+    #   context (:td, :th, :tr, :tbody, :thead, :tfoot, :caption,
+    #   :colgroup, :table)
+    # @return [Moxml::HtmlFragment]
+    # @raise [Moxml::AdapterError] on adapters without fragment
+    #   support or an unknown context tag
+    def parse_html_fragment(html, context_tag: :body)
+      html_string = html.is_a?(IO) || html.is_a?(StringIO) ? html.read : html.to_s
+      HtmlFragment.new(
+        config.adapter.parse_html_fragment(html_string, context_tag, self),
+        self,
+      )
+    end
+
     # Compile an XSLT stylesheet with this context's adapter
     # (implementation-agnostic; nokogiri/libxslt and leptris ship
     # engines, leptris covering XSLT 2.0/3.0 per its engine). Apply

data/lib/moxml/document.rb

@@ -119,6 +119,22 @@ module Moxml
       adapter.parse_errors(@native)
     end
 
+    # HTML serialization (issue #354): documents parsed through
+    # parse_html — and XML documents alike — serialize through the
+    # adapter's HTML method: void elements slash-less, raw text
+    # (script/style) verbatim, no XML declaration.
+    #
+    # indent: N (spaces per level) and indent_text: unit (e.g. "\t")
+    # thread the pretty-print knobs on adapters that carry them
+    # (leptris >= the #354 ride; nokogiri passes them to the
+    # engine). Adapters without the knob raise Moxml::AdapterError.
+    def to_html(options = {})
+      result = adapter.serialize_html(@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/element.rb

@@ -184,22 +184,55 @@ module Moxml
 
     # Nokogiri-compatible: children= replaces the entire child list
     def children=(node_or_nodes)
+      source_docs = nil
       natives = case node_or_nodes
                 when String
                   wrapper = "_moxml_children_#{Process.pid}_#{object_id}"
-                  context.parse("<#{wrapper}>#{node_or_nodes}</#{wrapper}>")
-                    .root.children.map(&:native)
-                when Moxml::Node then [node_or_nodes.native]
-                when Array, NodeSet then node_or_nodes.map(&:native)
+                  wrapper_doc = context.parse("<#{wrapper}>#{node_or_nodes}</#{wrapper}>")
+                  # #355: engines that move/copy across documents by
+                  # reference (leptris absorb) leave the attached
+                  # nodes pool-owned by the SOURCE document; the
+                  # wrapper is otherwise unreferenced and its free
+                  # can dangle the attached subtree (windows GC
+                  # timing). Retain it for this element's lifetime.
+                  source_docs = [wrapper_doc]
+                  wrapper_doc.root.children.map(&:native)
+                when Moxml::Node
+                  retain_children_source(node_or_nodes.document)
+                  [node_or_nodes.native]
+                when Array, NodeSet
+                  node_or_nodes.each { |n| retain_children_source(n.document) }
+                  node_or_nodes.map(&:native)
                 else
                   raise ArgumentError, "children= accepts String, Node, or Array"
                 end
       adapter.replace_children(@native, natives)
+      retain_children_source_docs(source_docs) if source_docs
       @text = nil
       context.bump_children_generation
       invalidate_children_cache!
     end
 
+    # #355: keep every distinct source document whose nodes were
+    # attached here reachable for as long as this element lives —
+    # absorbed/moved pools must not be freed out from under the
+    # tree. Accumulates: a pool absorbed by this document stays
+    # referenced even after later children= calls replace the
+    # nodes that came from it.
+    def retain_children_source(source_doc)
+      retain_children_source_docs([source_doc])
+    end
+
+    def retain_children_source_docs(docs)
+      docs = docs.compact.uniq
+      docs.delete_if { |d| d.equal?(document) }
+      return if docs.empty?
+
+      existing = adapter.attachments.get(@native, :children_source_docs)
+      merged = existing ? (existing + docs).uniq : docs
+      adapter.attachments.set(@native, :children_source_docs, merged)
+    end
+
     def remove_attribute(name)
       # Both remove paths end in invalidate_attribute_cache!, which
       # bumps the generation.

data/lib/moxml/html_fragment.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Moxml
+  # An HTML fragment (issue #353): the parsed top-level nodes of a
+  # WHATWG fragment parse with a context element (body by default).
+  # Not a Node — no parent, no document of its own; the adapter's
+  # native fragment owns the parsed tree's lifetime.
+  class HtmlFragment
+    include Enumerable
+
+    def initialize(native_fragment, context)
+      @native_fragment = native_fragment
+      @context = context
+    end
+
+    # The top-level nodes, moxml-wrapped, in tree order.
+    def children
+      children_natives.map { |n| Node.wrap(n, @context) }
+    end
+
+    def each(&block)
+      children.each(&block)
+    end
+
+    def size
+      children_natives.size
+    end
+
+    def empty?
+      children_natives.empty?
+    end
+
+    def to_html(_options = {})
+      @context.config.adapter.serialize_fragment(@native_fragment)
+    end
+
+    private
+
+    def children_natives
+      @context.config.adapter.fragment_children(@native_fragment)
+    end
+  end
+end

data/lib/moxml/version.rb

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

data/lib/moxml.rb

@@ -83,6 +83,7 @@ module Moxml
   autoload :Doctype, "moxml/doctype"
   autoload :EntityReference, "moxml/entity_reference"
   autoload :DocumentBuilder, "moxml/document_builder"
+  autoload :HtmlFragment, "moxml/html_fragment"
   autoload :Builder, "moxml/builder"
   autoload :Entity, "moxml/entity"
   autoload :EntityRegistry, "moxml/entity_registry"

data/spec/moxml/children_source_retention_spec.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #355: children= attaches nodes whose engine storage may be
+# pool-owned by a SOURCE document (leptris absorbs/moves across
+# documents by reference). The String branch's wrapper document is
+# otherwise unreferenced — collected, its free can dangle the
+# attached subtree (windows GC timing, standoc#1272). The element
+# retains every distinct foreign source document for its lifetime.
+RSpec.describe "children= source retention (#355)" do
+  %i[leptris nokogiri].each do |adapter_name|
+    describe "on #{adapter_name}" do
+      let(:ctx) { Moxml.new(adapter_name) }
+
+      it "retains the String branch's wrapper document" do
+        el = ctx.parse("<bibitem><t>old</t></bibitem>").at("//bibitem")
+        el.children = "<contributor><role>author</role></contributor>"
+        sources = ctx.config.adapter.attachments.get(el.native, :children_source_docs)
+        expect(sources).not_to be_nil
+        expect(sources.size).to eq(1)
+        GC.start
+        expect(el.to_xml).to include("author")
+      end
+
+      it "retains cross-document sources from the Array branch" do
+        el = ctx.parse("<r/>").root
+        other = ctx.parse("<other><deep>v</deep></other>")
+        el.children = other.root.children.to_a
+        sources = ctx.config.adapter.attachments.get(el.native, :children_source_docs)
+        expect(sources).to eq([other])
+        GC.start
+        expect(el.to_xml).to include("deep")
+      end
+
+      it "accumulates distinct sources across repeated children= calls" do
+        el = ctx.parse("<r/>").root
+        other_a = ctx.parse("<a><x/></a>")
+        other_b = ctx.parse("<b><y/></b>")
+        el.children = other_a.root.children.to_a
+        el.children = other_b.root.children.to_a
+        sources = ctx.config.adapter.attachments.get(el.native, :children_source_docs)
+        expect(sources).to contain_exactly(other_a, other_b)
+      end
+
+      it "does not retain the element's own document" do
+        doc = ctx.parse("<r><x/></r>")
+        el = doc.root
+        el.children = el.children.to_a
+        expect(
+          ctx.config.adapter.attachments.get(el.native, :children_source_docs),
+        ).to be_nil
+      end
+    end
+  end
+end

data/spec/moxml/html_fragment_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Context#parse_html_fragment (#353): WHATWG fragment semantics on
+# the moxml surface — head-swept elements stay at fragment top
+# level, table-structure tags follow the in-body rules, whitespace
+# is preserved. The leptris lane composes over the binding's
+# fragment face (leptris-ruby#422); nokogiri maps to
+# Nokogiri::HTML5.fragment.
+RSpec.describe "Context#parse_html_fragment" do
+  describe "nokogiri" do
+    let(:ctx) { Moxml.new(:nokogiri) }
+
+    it "keeps head-swept elements at fragment top level" do
+      frag = ctx.parse_html_fragment("<title>T</title><p>x</p>")
+      expect(frag.children.map(&:name)).to eq(%w[title p])
+      expect(frag.children.first).to be_element
+    end
+
+    it "drops table-structure elements, keeping their text" do
+      frag = ctx.parse_html_fragment("<td>cell</td>")
+      expect(frag.children.map(&:name)).to eq(["text"])
+      expect(frag.children.first.text).to eq("cell")
+    end
+
+    it "preserves whitespace-only text" do
+      frag = ctx.parse_html_fragment("  <p>lead ws</p>  ")
+      expect(frag.children.map(&:name).first).to eq("text")
+    end
+
+    it "is enumerable and serializes as children joined" do
+      frag = ctx.parse_html_fragment("<p>a</p>tail")
+      expect(frag.size).to eq(2)
+      expect(frag.to_html).to eq("<p>a</p>tail")
+      expect(frag).not_to be_empty
+      expect(ctx.parse_html_fragment("")).to be_empty
+    end
+
+    it "wraps children with the context" do
+      frag = ctx.parse_html_fragment("<p>x</p>")
+      expect(frag.children.first.context).to eq(ctx)
+    end
+  end
+
+  describe "leptris" do
+    let(:ctx) { Moxml.new(:leptris) }
+
+    before do
+      unless Moxml::Adapter::Leptris::HTML_FRAGMENT
+        skip "binding #{Leptris::VERSION} predates the #353 fragment face"
+      end
+    end
+
+    it "keeps head-swept elements at fragment top level" do
+      frag = ctx.parse_html_fragment("<title>T</title><p>x</p>")
+      expect(frag.children.map(&:name)).to eq(%w[title p])
+    end
+
+    it "parses inside a table context" do
+      frag = ctx.parse_html_fragment("<b>x</b>", context_tag: :td)
+      expect(frag.children.map(&:name)).to eq(%w[b])
+    end
+
+    it "raises a named error for unknown context tags" do
+      expect { ctx.parse_html_fragment("<p/>", context_tag: :nope) }
+        .to raise_error(Moxml::AdapterError, /table context/)
+    end
+
+    it "drops table-structure elements, keeping their text" do
+      frag = ctx.parse_html_fragment("<td>cell</td>")
+      expect(frag.children.map(&:name)).to eq(["text"])
+      expect(frag.children.first.text).to eq("cell")
+    end
+
+    it "serializes as children joined" do
+      expect(ctx.parse_html_fragment("<p>a</p>tail").to_html).to eq("<p>a</p>tail")
+    end
+  end
+
+  describe "adapters without fragment support" do
+    it "raise a named AdapterError" do
+      expect { Moxml.new(:rexml).parse_html_fragment("<p>x</p>") }
+        .to raise_error(Moxml::AdapterError, /HTML fragment parsing/)
+    end
+  end
+end

data/spec/moxml/to_html_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Document#to_html (issue #354): HTML-method serialization with the
+# pretty-print knobs. The byte contract is per-engine pass-through —
+# the leptris nested layout (engine leptris#1637) and Nokogiri's own
+# serializer bytes — not cross-adapter byte equality.
+RSpec.describe "Moxml::Document#to_html" do
+  let(:src) do
+    "<html><head><title>T</title></head><body><div id=\"a\"><p>x</p>" \
+      "<span>y</span></div><script>if (a < b) { c(); }</script></body></html>"
+  end
+
+  describe "nokogiri" do
+    let(:doc) { Moxml.new(:nokogiri).parse_html(src) }
+
+    it "serializes the engine's HTML bytes by default" do
+      expect(doc.to_html).to eq(Nokogiri::HTML(src).to_html)
+    end
+
+    it "threads indent through to the engine" do
+      expect(doc.to_html(indent: 2))
+        .to eq(Nokogiri::HTML(src).to_html(indent: 2))
+    end
+
+    it "threads the indent unit through to the engine" do
+      expect(doc.to_html(indent: 1, indent_text: "\t"))
+        .to eq(Nokogiri::HTML(src).to_html(indent: 1, indent_text: "\t"))
+    end
+  end
+
+  describe "leptris" do
+    let(:doc) { Moxml.new(:leptris).parse_html(src) }
+
+    it "serializes single-line without kwargs" do
+      expect(doc.to_html).to eq(doc.native.to_html)
+      expect(doc.to_html).to start_with("<html>")
+    end
+
+    context "with the indent ride armed (binding >= 1.9.338.0)" do
+      before do
+        unless Moxml::Adapter::Leptris::HTML_SERIALIZE_INDENT
+          skip "binding #{Leptris::VERSION} predates the #354 ride"
+        end
+      end
+
+      it "nests block children with space leads" do
+        expect(doc.to_html(indent: 2)).to eq(
+          "<html>\n  " \
+          "<head><title>T</title></head>\n  " \
+          "<body>\n    " \
+          "<div id=\"a\">\n      " \
+          "<p>x</p>\n      " \
+          "<span>y</span>\n    " \
+          "</div>\n    " \
+          "<script>if (a < b) { c(); }</script>\n  " \
+          "</body>\n" \
+          "</html>",
+        )
+      end
+
+      it "nests with the indent_text unit" do
+        expect(doc.to_html(indent: 1, indent_text: "\t")).to include(
+          "<body>\n\t\t<div id=\"a\">\n\t\t\t<p>x</p>",
+        )
+      end
+    end
+
+    context "when the binding predates the ride" do
+      before do
+        if Moxml::Adapter::Leptris::HTML_SERIALIZE_INDENT
+          skip "binding #{Leptris::VERSION} carries the ride"
+        end
+      end
+
+      it "raises a named AdapterError instead of silently degrading" do
+        expect { doc.to_html(indent: 2) }.to raise_error(Moxml::AdapterError, /indent/)
+      end
+    end
+  end
+
+  describe "adapters without an HTML serializer" do
+    it "raise a named AdapterError" do
+      doc = Moxml.new(:rexml).parse("<r><a>x</a></r>")
+      expect { doc.to_html }
+        .to raise_error(Moxml::AdapterError, /HTML serialization/)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.123
+  version: 0.5.125
 platform: ruby
 authors:
 - Ribose Inc.
@@ -214,6 +214,7 @@ files:
 - lib/moxml/entity_registry.rb
 - lib/moxml/entity_registry_opal_data.rb
 - lib/moxml/error.rb
+- lib/moxml/html_fragment.rb
 - lib/moxml/lazy_node_set.rb
 - lib/moxml/materializer.rb
 - lib/moxml/namespace.rb
@@ -482,6 +483,7 @@ files:
 - spec/moxml/c14n/w3c_examples_spec.rb
 - spec/moxml/c14n/xml_attributes_spec.rb
 - spec/moxml/cdata_spec.rb
+- spec/moxml/children_source_retention_spec.rb
 - spec/moxml/comment_spec.rb
 - spec/moxml/config_spec.rb
 - spec/moxml/context_spec.rb
@@ -500,6 +502,7 @@ files:
 - spec/moxml/entity_registry_spec.rb
 - spec/moxml/entity_spec.rb
 - spec/moxml/error_spec.rb
+- spec/moxml/html_fragment_spec.rb
 - spec/moxml/lazy_parse_spec.rb
 - spec/moxml/materializer_spec.rb
 - spec/moxml/moxml_spec.rb
@@ -543,6 +546,7 @@ files:
 - spec/moxml/struct_plan_spec.rb
 - spec/moxml/struct_plan_typed_spec.rb
 - spec/moxml/text_spec.rb
+- spec/moxml/to_html_spec.rb
 - spec/moxml/version_spec.rb
 - spec/moxml/xml_emitter_spec.rb
 - spec/moxml/xml_utils/.gitkeep