moxml 0.5.12 → 0.5.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7f702d6c51c5df49bdb2bf0ac5189d3fe0716d94093ced7decdb743dcf87fa5d
-  data.tar.gz: 56316b016c8865d6290033873477d9dcc92b04e1e16ae77716626398bd976ad3
+  metadata.gz: 8302b1a98c08b34619df4a30d5b84733fa9125eebeeaf1b39b5ba82d0e8fa625
+  data.tar.gz: e96034377b072b1ee9058ced4a4dd0347e819f6354011810831b07a06e88e138
 SHA512:
-  metadata.gz: a1e503460e2b5d645cd4147d4164d2a67c254e8e2174b145fbf4f17dab222d1eae03216b7a35dca18a800684c3c904daf9633140f262195f212d9dd235ccc675
-  data.tar.gz: 4cf7957e370339230fc4d184a7fd6b9312bd3f5e8f9e843984ed4e56967e33597d18abef6479de69cde47af781a65703427349cdaff16eaf317cdb39ba8cd135
+  metadata.gz: bbe5b80c8b6a656e14b45307bf9b41d1ba1a384c33906ed11fc7d861c2f8fbfad33fb08f2b091ea8b295608c025b5045bc6d0ff73927420e07a23635750fec38
+  data.tar.gz: 994ca51d9e27649ef6d70d2f225408dafdd73e35d5948903e33c978b75c5523d5c11ce889c361ded3c7af74473fe75b107168df5f6ab88ec4af5841f5f530ebf

data/.rubocop.yml

@@ -18,3 +18,12 @@ AllCops:
     - 'tmp/**/*'
     - 'spec/consistency/round_trip_spec.rb'
     - 'lib/compat/**/*'
+
+# materialize_fields yields the eight record fields positionally —
+# the zero-allocation streaming form (issue #143). One parameter per
+# record key is the interface; a shorter list would need a wrapper
+# object, which is the allocation the API exists to avoid.
+Metrics/ParameterLists:
+  Exclude:
+    - 'lib/moxml/materializer.rb'
+    - 'spec/moxml/materializer_spec.rb'

data/docs/_pages/adapter-protocol.adoc

@@ -0,0 +1,117 @@
+---
+title: Adapter protocol
+nav_order: 46
+---
+
+= The adapter protocol
+
+The seam between moxml's wrapper layer (`Moxml::Node` and friends) and the
+engine adapters. Every adapter is a class under `Moxml::Adapter` implementing
+class methods over its library's native nodes; wrappers dispatch through
+`context.config.adapter` and never touch a native directly.
+
+The contract is pinned by the shared example groups under
+`spec/moxml/adapter/shared_examples/` (the adapter contract) and the
+consistency suite — behavior there is authoritative when this page and the
+code disagree.
+
+== Method groups
+
+Parse and document lifecycle::
+`parse(xml, options, context)`, `create_document`, `create` factories
+(`create_native_element`, `create_native_text`, `create_native_cdata`,
+`create_native_comment`, `create_native_processing_instruction`,
+`create_native_declaration`, `create_native_doctype`,
+`create_native_entity_reference`, `create_native_namespace`),
+`free_document` (#134; no-op on GC-managed engines), `parse_errors`
+(#147; recover-mode diagnostics — `[]` on clean parses; engines with
+an error channel map it here, e.g. Nokogiri's `doc.errors`).
+
+Tree navigation::
+`children`, `parent`, `next_sibling`, `previous_sibling`, `root`,
+`set_root`, `document`, `duplicate_node`. `children` on a document
+lists document-level parts in document order where the engine exposes
+them (Nokogiri-shaped contract).
+
+Node typing and names::
+`node_type`, `node_name`, `set_node_name`, `attribute_name`.
+
+Attributes::
+`get_attribute` / `get_attribute_value` (the raw layer beneath
+`Moxml::AttributeResolver` — expanded-name resolution lives above the
+adapter), `set_attribute_value`, `remove_attribute`,
+`patch_node`/`unpatch_node` for engines needing wrapper natives
+(libxml, ox).
+
+Namespaces::
+`namespace`, `namespace_definitions` (the element's own declarations),
+`in_scope_namespaces`, `set_namespace`, `remove_namespace`.
+
+Mutation::
+`add_child`, `add_next_sibling`, `add_previous_sibling`, `remove`,
+`replace`, `replace_children`. Return contract: methods that can swap
+the native (`set_attribute_name`, `set_namespace`, adoptions) return
+the tracked native; wrappers re-key through `refresh_native!`.
+
+Serialization::
+`serialize(node, options)`. Options: `indent`, `encoding`,
+`declaration`, `no_declaration`, `expand_empty`, `line_ending`.
+Entity-marker restoration is owned by the wrapper layer
+(`Node#to_xml`), guarded by `entity_bearing?`.
+
+XPath::
+`xpath(expression, namespaces)`. Engines without a native engine use
+moxml's pure-Ruby XPath 1.0 engine (`Moxml::XPath`).
+
+== Capability predicates
+
+The wrapper layer probes adapters rather than assuming:
+
+`patches_children?`::
+True when `children` results need per-child `patch_node` rewriting
+(libxml, ox). Others skip the identity map over every child list.
+
+`wrappers_recyclable?`::
+False for engines that mint fresh Ruby objects per access (libxml) —
+the context's wrapper identity map opts out.
+
+`entity_bearing?(native)`::
+Whether the subtree can contain entity markers; gates the
+post-serialize restore scan.
+
+`bulk_materialize?`::
+Whether the adapter offers a bulk path for `Moxml::Materializer`;
+`materialize_fields` fills the reused flat buffers and yields the
+eight record fields per node, returning nil falls back to the
+generic wrapper walk. Leptris walks raw C pointers with the batch
+`leptris_node_children` call — no wrappers, no per-node callback.
+
+Constants like `DOC_NODE_SUPPORTED` / `DTDATTR_SUPPORTED` /
+`BULK_FIELD_READS` (Leptris) follow the same idea: one probe
+per engine capability, computed at load.
+
+== Return shapes
+
+* Mutations return the tracked native (or nil when not applicable) —
+  never a wrapper.
+* `children` returns an array of natives; the wrapper layer builds the
+  `NodeSet`.
+* `xpath` returns `Array<native>` or a scalar for non-node results.
+* Marker-bearing text (leptris) is split by the adapter into
+  text/entity-reference pseudo-natives before the wrapper sees it.
+
+== Writing an adapter
+
+Subclass `Moxml::Adapter::Base`, implement the groups above, and
+include the shared examples:
+
+[source,ruby]
+----
+RSpec.describe Moxml::Adapter::Mine do
+  it_behaves_like "xml adapter"
+  it_behaves_like "adapter contract"
+end
+----
+
+The contract suite is the test surface: if it passes, the wrapper
+layer's behavior is covered.

data/docs/_pages/adapters/index.adoc

@@ -14,15 +14,21 @@ how to choose the right adapter for your needs.
 === What are adapters?
 
 Moxml uses an adapter pattern to provide a unified interface over different
-XML processing libraries. Each adapter wraps a specific XML library (Nokogiri,
-LibXML, Oga, REXML, or Ox) and provides consistent behavior through Moxml's
-API.
+XML processing libraries. Each adapter wraps a specific XML library (Leptris,
+Nokogiri, LibXML, Oga, REXML, or Ox) and provides consistent behavior through
+Moxml's API. See link:../adapter-protocol[the adapter protocol] for the seam
+itself.
 
 === Available adapters
 
+link:leptris[Leptris adapter]::
+Pure-C99 XML engine, the default on CRuby when the installed binding
+supports programmatic documents — fastest on every measured operation,
+with native XPath 1.0, SAX, and deterministic memory release.
+
 link:nokogiri[Nokogiri adapter]::
-Industry standard XML library with excellent performance and full XPath 1.0
-support. Recommended for most use cases.
+The industry-standard XML library and the fallback default when Leptris
+is not installed. Excellent performance with full XPath 1.0 support.
 
 link:libxml[LibXML adapter]::
 Alternative to Nokogiri using native libxml2 bindings. Excellent performance

data/docs/_pages/adapters/leptris.adoc

@@ -0,0 +1,74 @@
+---
+title: Leptris
+parent: Adapters
+nav_order: 1
+---
+
+== Leptris adapter
+
+Leptris is a pure-C99 XML 1.0 parser with an FFI binding (the
+https://github.com/leptris/leptris-ruby[leptris-ruby] gem). It is the
+preferred default on CRuby: fastest on every measured moxml operation,
+with a native XPath 1.0 engine, SAX, and canonicalization.
+
+== Default resolution
+
+Leptris becomes the default when the installed binding supports
+programmatic document construction (`Leptris::XML::Document.create`,
+leptris >= 1.3). Otherwise the default falls back to Nokogiri. Under
+Opal the default is rexml (stock oga requires its C extension and
+libleptris does not build for Opal).
+
+[source,ruby]
+----
+Moxml.new                     # => Leptris context when capable
+ctx.config.adapter_name        # => :leptris / :nokogiri / :rexml (Opal)
+----
+
+== Parse options
+
+`readonly: true`::
+The binding memoizes every read and refuses mutations — the
+parse-and-read lifecycle for multi-pass consumers (comparison, diff,
+signatures). Repeat attribute reads on a large element drop by
+orders of magnitude. Builder documents stay read-write.
+
+`dtdattr: true`::
+Materialize DTD `<!ATTLIST>` defaults. Off by default, matching
+libxml2/Nokogiri/REXML semantics (libleptris >= 1.9.8).
+
+`strict: true`::
+Raise `Moxml::ParseError` on malformed input instead of returning an
+empty document.
+
+== Lifecycle
+
+`Document#free` releases the C tree deterministically — batch
+workloads parsing thousands of documents otherwise hold native memory
+until GC finalizers run. Access after `#free` raises the binding's
+use-after-free error.
+
+== Document model
+
+Documents expose the libxml2-shaped document node: prolog PIs and
+comments, the root element, epilog PIs and comments, in document
+order (leptris >= 1.9.26). The DOCTYPE round-trips with its internal
+subset. See link:../conversion-apis[Conversion and memory lifecycle APIs]
+for `materialize` — the flattened-record conversion path with a bulk
+implementation over one `leptris_node_traverse` call.
+
+== Known limitations (tracked upstream)
+
+* Tab indentation (`indent_text`) needs a serialize-time parameter in
+  libleptris; post-hoc rewriting would corrupt mixed content.
+* Child PIs serialize inline (engine emits `<r>\n<?pi x?>  <e/>`
+  rather than libxml2's one-PI-per-indented-line layout); safe
+  post-hoc rewriting is impossible in mixed content.
+* DOCTYPE internal subsets serialize inline; libxml2 separates the
+  declarations with newlines.
+* Document-level PIs are read-only natives (`target=`/`data=`/
+  `unlink` rejected); write-through and removal are pending C
+  surface (leptris/leptris#612).
+* A PI preceding the DOCTYPE reorders on serialization — libleptris
+  normalizes DOCTYPE-first and the document node does not record its
+  relative position.

data/docs/_pages/adapters/libxml.adoc

@@ -1,7 +1,7 @@
 ---
 title: LibXML
 parent: Adapters
-nav_order: 2
+nav_order: 4
 ---
 
 == LibXML adapter

data/docs/_pages/adapters/nokogiri.adoc

@@ -1,7 +1,7 @@
 ---
 title: Nokogiri
 parent: Adapters
-nav_order: 1
+nav_order: 3
 ---
 
 == Nokogiri adapter

data/docs/_pages/conversion-apis.adoc

@@ -0,0 +1,103 @@
+---
+title: Conversion and memory lifecycle APIs
+nav_order: 45
+---
+
+= Conversion and Memory Lifecycle APIs
+
+Scanned streaming (`materialize`), deterministic release (`Document#free`), and parse-lifecycle options (`readonly:`, `dtdattr:`) — the seams for conversion-heavy and batch workloads.
+
+== Bulk materialization — `materialize` (issue #132)
+
+Flattened, post-order records for a subtree with no `Moxml::Node`
+allocation — the conversion path for consumers that build their own
+tree from a document:
+
+[source,ruby]
+----
+context.materialize(xml) { |record| ... }   # parse + flatten
+document.materialize.each                    # Enumerator, root subtree
+any_element.materialize                      # any subtree
+----
+
+Record shape (all eight keys on every record):
+
+[source,ruby]
+----
+{ kind: :element|:text|:cdata|:comment|:processing_instruction|:entity_reference,
+  qname: "tag"|"pi-target"|nil,
+  prefix: "p"|nil,
+  namespace_uri: "urn:x"|nil,
+  namespaces: [[prefix, uri], ...],              # element's OWN declarations; nil prefix = default
+  attributes: [[name, value, namespace_uri, prefix], ...],
+  text: String|nil,
+  depth: Integer }
+----
+
+* Post-order: children arrive before their parent — build with a stack.
+* `Document#materialize` yields exactly the root subtree (issue #140); document-level parts (prolog/epilog PIs and comments, DOCTYPE) stay enumerable via `children`.
+* Every record is an independent Hash snapshot — safe to retain.
+* Entity-bearing documents fall back to the generic walk so entity references still split.
+
+=== The streaming form — `materialize_fields` (issue #143)
+
+The conversion hot path: the same walk with zero per-record
+allocation. The block receives the eight fields positionally, and the
+two list arguments are flat, reused buffers:
+
+[source,ruby]
+----
+context.materialize_fields(xml) do |kind, qname, prefix, uri,
+                                namespaces, attributes, text, depth|
+  # namespaces: flat [prefix, uri, ...]            (stride 2)
+  # attributes: flat [name, value, uri, prefix, ...] (stride 4)
+end
+----
+
+The buffers are refilled per element record — valid only inside the
+block. Copy what you keep, or use `materialize` (which layers a fresh
+Hash snapshot on this same stream). On CRuby + leptris the walk runs
+over raw C pointers with the batch `leptris_node_children` call — no
+wrapper objects, no per-node FFI callback, no depth bookkeeping;
+measured ~1.2x faster than an equivalent raw-Nokogiri DOM walk.
+Requires a block (raises `ArgumentError` otherwise).
+
+== Deterministic release — `Document#free` (issue #134)
+
+Adapters backed by C trees hold native memory until a GC finalizer runs. Batch workloads (parse → convert → discard, thousands of documents) release it deterministically:
+
+[source,ruby]
+----
+doc = context.parse(xml)
+doc.free            # C tree released now; attachments swept
+doc.root            # => raises the engine's use-after-free error (leptris)
+----
+
+`#free` is a no-op on GC-managed engines (nokogiri, oga, ox, rexml). Normally-scoped documents keep working via the finalizer either way. Measured with GC disabled, 1000 × ~115KB parses: +1.2GB RSS without `#free` vs +121MB with it.
+
+== Parse-lifecycle options
+
+Both options pass through `Context#parse` to the engine and are no-ops where the concept does not apply:
+
+* `readonly: true` (issue #133, leptris) — memoized reads, refused mutations. The parse-and-read lifecycle for multi-pass consumers (comparison, diff, signature): repeat attribute reads on a 100-attribute element drop from ~99µs to ~0.15µs (680×). Builder documents stay read-write.
+
+* `dtdattr: true` (libleptris 1.9.8+, leptris/leptris#606) — materialize DTD `<!ATTLIST>` defaults. Off by default, matching libxml2/Nokogiri/REXML semantics:
+
+[source,ruby]
+----
+context.parse(dtd_xml)                     # plain: ATTLIST defaults excluded
+context.parse(dtd_xml, dtdattr: true)      # opt-in: attr="default" materialized
+----
+
+== Pretty-print parity (issue #129)
+
+Through the leptris adapter, byte-identical output to raw Nokogiri:
+
+[source,ruby]
+----
+context.parse(src).to_xml(
+  indent: 2, declaration: true, expand_empty: false, encoding: "UTF-8",
+) == Nokogiri::XML(src).to_xml(indent: 2, encoding: "UTF-8")   # => true
+----
+
+Known residual divergences (engine-level, tracked upstream): tab indentation needs a serialize-time parameter in libleptris, and a PI preceding the DOCTYPE reorders (the engine normalizes DOCTYPE-first).

data/docs/_pages/index.adoc

@@ -28,6 +28,12 @@ Compare features, performance, and compatibility across adapters.
 link:configuration[Configuration]::
 Configure Moxml for your application's requirements.
 
+link:conversion-apis[Conversion and memory lifecycle APIs]::
+Bulk materialization, deterministic document release, and parse-lifecycle options for conversion-heavy workloads.
+
+link:adapter-protocol[The adapter protocol]::
+The seam between the wrapper layer and engine adapters — method groups, capability predicates, return shapes, and how to add an adapter.
+
 link:error-handling[Error handling]::
 Comprehensive guide to Moxml's error classes and debugging.
 

data/lib/compat/opal/moxml_boot.rb

@@ -24,6 +24,7 @@ require "moxml/namespace"
 require "moxml/doctype"
 require "moxml/entity_reference"
 require "moxml/entity_registry"
+require "moxml/entity_registry_opal_data"
 require "moxml/entity"
 require "moxml/entity/restorer"
 require "moxml/entity/reference"

data/lib/moxml/adapter/base.rb

@@ -190,14 +190,19 @@ namespace_validation_mode: :strict)
         end
 
         # Whether the engine offers a bulk materialization path for
-        # Materializer (issue #132). When true, materialize_records
-        # yields flattened records for the subtree; returning nil
-        # (e.g. for document shapes the bulk path cannot express)
-        # falls back to the generic wrapper walk.
+        # Materializer (issue #132). When true, the adapter gets
+        # #materialize_fields(native, buffers, &block) — fill the
+        # reused flat buffers and yield the eight record fields per
+        # node. Returning nil (e.g. for document shapes the bulk path
+        # cannot express) falls back to the generic wrapper walk.
         def bulk_materialize?
           false
         end
 
+        def materialize_fields(_native, _buffers)
+          nil
+        end
+
         # Deterministic native-memory release for adapters backed by
         # C trees (issue #134). GC-managed engines no-op; released
         # documents raise the engine's use-after-free error on
@@ -206,6 +211,15 @@ namespace_validation_mode: :strict)
           nil
         end
 
+        # Recover-mode parse diagnostics (issue #147): the error
+        # messages the engine recorded while parsing, [] when the
+        # parse was clean. Engines with a native recover channel
+        # (Nokogiri's `doc.errors`) or a non-strict path that loses
+        # the raised error (leptris) override this.
+        def parse_errors(_native_doc)
+          []
+        end
+
         # Check if the native document has an XML declaration
         # @param native_doc the native document object
         # @param wrapper [Moxml::Document] the wrapper with has_xml_declaration flag

data/lib/moxml/adapter/leptris/document_parts.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Adapter
+    class Leptris
+      module DocumentParts
+        # Issue #134: deterministic release of the C tree. The binding
+        # clears its wrapper cache and raises UseAfterFreeError on
+        # later access; moxml-side attachments for the document are
+        # swept too (the context wrapper identity map self-cleans via
+        # its size valve).
+        DOCUMENT_ATTACHMENT_KEYS = %i[
+          entity_markers doc_pi_nodes declaration doctype
+          had_source_declaration document_text
+        ].freeze
+
+        def free_document(native)
+          DOCUMENT_ATTACHMENT_KEYS.each { |key| attachments.delete(native, key) }
+          native.free
+          nil
+        end
+
+        def assemble_document_children(doc)
+          children = []
+
+          native_doctype = doc.doctype
+          children << native_doctype if native_doctype
+
+          doctype_wrapper = attachments.get(doc, :doctype)
+          children << doctype_wrapper if doctype_wrapper
+
+          if DOC_NODE_SUPPORTED
+            # The libxml2-model document node lists prolog PIs/comments,
+            # the root, and epilog PIs/comments in document order —
+            # the Nokogiri-shaped contract, epilog anchoring included
+            # (issue #130). Built (programmatic) documents are not yet
+            # fully reflected by the node (binding gap: an attached
+            # root does not appear); document_node_children answers
+            # nil there for the legacy parts path.
+            doc_children = document_node_children(doc)
+            if doc_children
+              children.concat(doc_children)
+            else
+              children.concat(document_pi_nodes(doc))
+              children << doc.root if doc.root
+            end
+          else
+            # Legacy path: document-level PIs live outside the element
+            # tree in a flat pre-root list (libleptris < 1.9.7 C
+            # model); epilog anchoring is not representable there.
+            children.concat(document_pi_nodes(doc))
+
+            children << doc.root if doc.root
+          end
+
+          texts = attachments.get(doc, :document_text)
+          children.concat(texts) if texts
+          children
+        end
+
+        # Document-level PI pseudo-nodes, materialized once from the C
+        # list and cached per document: children and serialization read
+        # the same objects, so wrapper mutations round-trip. Build the
+        # cache BEFORE appending a PI with add_pi, or the C-side
+        # addition would be double-counted.
+        # The document node's children, or nil when the node does not
+        # reflect reality: parsed documents always list the root
+        # element among their children, but programmatically built
+        # ones do not (binding gap) — those keep the legacy parts
+        # path.
+        def document_node_children(doc)
+          doc_children = doc.children.to_a
+          has_root = doc_children.any?(::Leptris::XML::Element)
+          return doc_children if has_root
+          return doc_children if doc.root.nil?
+
+          nil
+        end
+
+        def document_pi_nodes(doc)
+          attachments.get(doc, :doc_pi_nodes) || begin
+            nodes = doc.processing_instructions.map do |(target, data)|
+              CustomizedLeptris::DocumentPI.new(target, data, doc)
+            end
+            attachments.set(doc, :doc_pi_nodes, nodes)
+            nodes
+          end
+        end
+
+        def add_document_child(doc, child)
+          case child
+          when CustomizedLeptris::Declaration
+            child.parent_doc = doc
+            attachments.set(doc, :declaration, child)
+          when CustomizedLeptris::Doctype
+            child.parent_doc = doc
+            attachments.set(doc, :doctype, child)
+          when ::Leptris::XML::DocType
+            raise Moxml::DocumentStructureError.new(
+              "libleptris does not support attaching a native DocType to a document",
+            )
+          when ::Leptris::XML::Element
+            doc.root = child
+          when ::Leptris::XML::ProcessingInstruction
+            document_pi_nodes(doc)
+            doc.add_pi(child.target, child.content.to_s)
+            document_pi_nodes(doc) << CustomizedLeptris::DocumentPI.new(
+              child.target, child.content.to_s, doc
+            )
+          when CustomizedLeptris::DocumentPI
+            document_pi_nodes(doc)
+            doc.add_pi(child.target, child.data)
+            document_pi_nodes(doc) << child
+          when ::Leptris::XML::Text
+            texts = attachments.get(doc, :document_text) || []
+            texts << child
+            attachments.set(doc, :document_text, texts)
+            child
+          else
+            raise Moxml::DocumentStructureError.new(
+              "Unsupported document child: #{child.class}",
+            )
+          end
+          child
+        end
+
+        # Documents compose from their parts: the native serializer
+        # only walks the root subtree, so declaration, DOCTYPE, PIs and
+        # document-level text are assembled around it explicitly.
+        def serialize_document(doc, options)
+          # Nokogiri's document shape: every top-level part is
+          # newline-terminated, at any indent — declaration, DOCTYPE,
+          # document PIs, the root element, trailing newline after it.
+          # Document-level text is content, not structure: no added
+          # newline.
+          parts = []
+
+          include_decl = !options[:no_declaration] && options.fetch(:declaration) do
+            document_has_declaration?(doc)
+          end
+          if include_decl
+            declaration = attachments.get(doc, :declaration)
+            parts << (declaration ? declaration.to_xml : default_declaration_xml(doc, options)) << "\n"
+          end
+
+          doctype = attachments.get(doc, :doctype)
+          parts << doctype.to_xml << "\n" if doctype
+
+          native = native_doctype_xml(doc)
+          parts << native << "\n" if native
+
+          if DOC_NODE_SUPPORTED
+            # The libxml2-model document node: prolog PIs/comments,
+            # the root, epilog PIs/comments — in document order, so
+            # epilog parts serialize after the root (issue #130).
+            doc_children = document_node_children(doc)
+            if doc_children
+              doc_children.each { |child| parts << raw_serialize(child, options) << "\n" }
+            else
+              document_pi_nodes(doc).each { |pi| parts << pi.to_xml << "\n" }
+              parts << raw_serialize(doc.root, options) << "\n" if doc.root
+            end
+          else
+            document_pi_nodes(doc).each { |pi| parts << pi.to_xml << "\n" }
+
+            parts << raw_serialize(doc.root, options) << "\n" if doc.root
+          end
+
+          texts = attachments.get(doc, :document_text)
+          texts&.each { |text| parts << XmlEmitter.escape_text(text.content.to_s) }
+
+          parts.join
+        end
+
+        def native_doctype_xml(doc)
+          dt = doc.doctype
+          return nil unless dt
+
+          subset = dt.internal_subset if dt.class.method_defined?(:internal_subset)
+          XmlEmitter.doctype_xml(dt.root_name, dt.public_id, dt.system_id, subset)
+        end
+
+        def default_declaration_xml(doc, options)
+          encoding = options[:encoding] || doc.encoding
+          encoding = "UTF-8" if encoding.to_s.empty?
+          XmlEmitter.declaration_xml("1.0", encoding, nil)
+        end
+
+        def document_has_declaration?(native)
+          return false unless native.is_a?(::Leptris::XML::Document)
+
+          return true if attachments.get(native, :declaration)
+
+          attachments.get(native, :had_source_declaration) ? true : false
+        end
+
+        def marker_text_for(parent, name)
+          return nil unless parent.is_a?(::Leptris::XML::Element)
+
+          marker = "#{Entity::MARKER}#{name};"
+          parent.children.to_a.find do |child|
+            child.is_a?(::Leptris::XML::Text) && child.content == marker
+          end
+        end
+      end
+    end
+  end
+end