leptris 1.9.34 → 1.9.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0445600493fa886524c162f270e55bccb3550d2c8b9463fe0a7ce305687a7ae
-  data.tar.gz: 878c7ecdcb828d80e3a25c0a05932113ce33030ccf163aea3896453fa0fc0bb8
+  metadata.gz: 31fdbaa742e583a50409dea1a5bda76e454e3b54ec30429d74101d5438f91b6f
+  data.tar.gz: 6acd554905283d755febf5c6265ce2a97dd8f9ce1ef83c9804363ff2d5bf1000
 SHA512:
-  metadata.gz: e9ab5ca5b140e729066e27a1afa5882639c7e18b6a10a94be06eccca5723ce0bf4547dd70940f367277548802caaca4a76d874148153fd55131ba5bb1d20aeb2
-  data.tar.gz: c8c62d53ff231fb9eedf7f8aa5a3d96774517bf26b347cc4b833ee8d149d9c80a37e014b1f4833bd2a7074eae4944d13819d89c292c8a0ccf0ead4b147101ff2
+  metadata.gz: 7e4c9abd84b07a678394774470b1486ccb2e03146578cda7eded0da2aa42f0b33f3ae682ac5a1881d2661e4a90ddb3bd6e0b3098d411303268867a2bbc1ad0d5
+  data.tar.gz: 35a2088c31974f7dc19beaa0bd4ad5c73515be100b1c0d3b3fd3bc313fa10e7abc28202f3eb7bb3cce6035ad86b0c3f553bde0ca458e08a03110ba0d774ff07a

data/CHANGELOG.md

@@ -5,6 +5,84 @@ All notable changes to Leptris will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.36] - 2026-08-29
+
+### Fixed
+
+- **SAX attribute corruption (leptris-ruby#95)** — fixed fully in
+  the binding. The engine's streaming attribute buffer loses
+  leading attribute pairs when several nested ancestor levels each
+  carry attributes; all THREE streaming surfaces are affected (the
+  callback transport, the recorder's arena, and pull attrs — each
+  verified on the issue fixture, which also yields run-varying
+  uninitialized bytes), while the DOM parser reads the same bytes
+  correctly. `SAX::Parser` now delivers from a DOM parse by
+  default (`SAX::DomDispatch`): one parse, then a lean walk
+  reproducing the streaming call shapes exactly —
+  attach-only-overridden kinds, one-arg arity dispatch, QName
+  element names, UTF-8, PI-data normalization. The issue fixture
+  is a regression spec (all 7 image attributes intact; the entire
+  existing SAX suite passes byte-identically through the new
+  path). The engine transports remain available via
+  `Parser.new(handler, streaming: true)` — and return as the
+  default the moment the engine fix lands. Correctness-first tax,
+  measured on big.xml: all-events 375 ms (engine 112, nokogiri
+  130); the bisection (not positional, not attribute length;
+  trigger = nested attr-carrying ancestors; all three surfaces
+  share the buffer) is filed upstream for the C fix.
+
+### Added
+
+- **libleptris 1.9.10 lockstep**: pin bumped; audit 250/250 with
+  `leptris_sax_recorder_reset` attached. `SAX::Recorder#reset` —
+  reuse one recorder across documents (upstream #594's
+  one-document-per-instance finding): fresh parser state, record/
+  arena buffers retained.
+
+### Meta
+
+- Memory battery (first measurement, 10 x big.xml held): leptris
+  **17.5 MB/doc vs nokogiri 31.3** (1.8x lighter); both free
+  cleanly.
+
+## [1.9.35] - 2026-08-28
+
+### Added
+
+- **libleptris 1.9.9 lockstep**: pin bumped; symbol audit 249/249
+  with `leptris_document_remove_pi` and
+  `leptris_document_serialize_ext` attached. Engine fixes ride
+  along: CDATA `]]>` runs split across node boundaries, XSLT
+  suite 144 -> 152/205, attribute-axis entity expansion.
+- **Document-level PIs fully mutable (leptris-ruby#92, upstream
+  #612)**: parse-created document-level PIs carry document
+  linkage — `target=`/`data=` work like on any tree PI (the
+  1.9.32 contract-error mapping is removed). `PI#unlink` on a
+  document-level PI routes through the new document-level removal,
+  identity-matched by index so the right same-target PI comes out.
+  New `Document#remove_pi(target_or_index)` — by target or 0-based
+  index, returns the removed (pool-owned) PI or nil.
+- **`Document#to_xml(indent_text: true)`** — display-form
+  serialization (upstream #129): text and mixed content indent;
+  output is display-oriented and not round-trip-guaranteed.
+
+### Changed
+
+- **Inline memo on `Element#[]`**: the external battery caught
+  attribute reads ~1.6x behind Nokogiri — six method dispatches
+  per read through the attributes/memo_hit? tower. The guard is
+  now spelled inline over a values hash materialized alongside the
+  Attr objects (same ADR-0003 semantics, misses included).
+
+### Meta
+
+- External head-to-head battery vs Nokogiri 1.19.4 (big.xml):
+  parse 12.3x, css 4.8x, xpath nodeset 3.0x, serialize 2.3x,
+  at_css 1.4x, SAX both shapes (round XXVI). Two shapes remain
+  behind and are C-side-bound: cold full walk 1.4x (needs
+  node_children out_kinds to skip per-node get_type — filing
+  upstream) and scalar xpath 1.5x (engine-side scalar eval).
+
 ## [1.9.34] - 2026-08-28
 
 ### Changed

data/Rakefile

@@ -8,7 +8,7 @@ RSpec::Core::RakeTask.new(:spec)
 # Pin for `rake compile` and the platform-gem builds. Keep in lockstep
 # with .github/workflows/build.yml (which calls `rake compile`) and the
 # CHANGELOG when libleptris releases.
-LIBLEPTRIS_VERSION = "1.9.8"
+LIBLEPTRIS_VERSION = "1.9.10"
 
 CMAKE_FLAGS = %w[
   -DCMAKE_BUILD_TYPE=Release

data/lib/leptris/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Leptris
-  VERSION = "1.9.34"
+  VERSION = "1.9.36"
 end

data/lib/leptris/xml/document.rb

@@ -266,9 +266,16 @@ class Leptris::XML::Document
   end
   alias_method :internal_subset, :doctype
 
-  def to_xml(indent: 0, no_decl: false, encoding: nil)
+  # indent_text: true selects the display form (libleptris 1.9.9,
+  # #129): text and mixed content indent too — the output is
+  # display-oriented and not round-trip-guaranteed.
+  def to_xml(indent: 0, no_decl: false, encoding: nil, indent_text: false)
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
     return "" if @c_ptr.nil?
+    if indent_text
+      return Leptris::XML::Serialization.to_xml_display(
+        @c_ptr, indent: indent, no_decl: no_decl, encoding: encoding)
+    end
     Leptris::XML::Serialization.to_xml(
       Leptris::XML::FFI.method(:leptris_document_serialize_into), @c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)
@@ -338,6 +345,25 @@ class Leptris::XML::Document
     result
   end
 
+  # Removes a document-level processing instruction — by target
+  # (String/Symbol) or by 0-based index among the document's PIs
+  # (Integer) (libleptris 1.9.9, upstream #612). Returns the removed
+  # PI — pool-owned and valid until #free — or nil when nothing
+  # matched.
+  def remove_pi(target_or_index)
+    raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
+    if target_or_index.is_a?(Integer)
+      ptr = Leptris::XML::FFI.leptris_document_remove_pi(
+        @c_ptr, nil, target_or_index)
+    else
+      ptr = Leptris::XML::FFI.leptris_document_remove_pi(
+        @c_ptr, target_or_index.to_s, 0)
+    end
+    return nil if ptr.null?
+    @version += 1
+    Leptris::XML::Node.wrap(ptr, self)
+  end
+
   # Append a document-level processing instruction. Returns self.
   def add_pi(target, data = "")
     witness = Leptris::XML::FFI.leptris_document_add_pi(

data/lib/leptris/xml/element.rb

@@ -44,8 +44,18 @@ class Leptris::XML::Element < Leptris::XML::Node
     # written prefix never matters — the hash cannot answer them.
     name = key.to_s
     if @document && !name.include?(":")
-      cached = attributes[name]
-      return cached.nil? ? nil : cached.value
+      # The hottest read in the library: the memo guard is spelled
+      # INLINE rather than through attributes/#memo_hit? — six
+      # method dispatches per read was ~40% of the read cost, and
+      # the external head-to-head (nokogiri's one C call) was
+      # winning on it. Same three-line memo semantics (ADR 0003),
+      # incl. the nil-miss — the hash answers misses too.
+      values = @attr_values
+      unless values && @attributes_version == @document.version
+        attributes
+        values = @attr_values
+      end
+      return values[name]
     end
     ensure_alive!
     Leptris::XML::FFI.leptris_element_attribute(@c_ptr, name)
@@ -133,9 +143,14 @@ class Leptris::XML::Element < Leptris::XML::Node
   def attributes
     return @attributes if memo_hit?(@attributes_version)
     result = {}
-    each_attribute { |attr| result[attr.name] = attr }
+    values = {}
+    each_attribute do |attr|
+      result[attr.name] = attr
+      values[attr.name] = attr.value
+    end
     if @document
       @attributes = result
+      @attr_values = values
       @attributes_version = @document.version
     end
     result

data/lib/leptris/xml/ffi.rb

@@ -72,6 +72,12 @@ module Leptris
           :encoding, :pointer
       end
 
+      # LeptrisSerializeExtOptions (1.9.9, #129): display-form
+      # serialization knobs beyond the ABI-frozen options struct.
+      class SerializeExtStruct < ::FFI::Struct
+        layout :indent_text, :int
+      end
+
       # Mirrors LeptrisParseOptions (libleptris >= 1.9.0 carries the
       # recover field; earlier fields unchanged since v1.6.0).
       class ParseOptionsStruct < ::FFI::Struct
@@ -156,6 +162,11 @@ module Leptris
         [:leptris_document, :size_t], :string
       attach_function :leptris_document_pi_data,
         [:leptris_document, :size_t], :string
+      # Document-level PI removal by target or index (1.9.9, #612):
+      # unlinks from the child chain; the node is pool-owned and
+      # stays valid until document free.
+      attach_function :leptris_document_remove_pi,
+        [:leptris_document, :string, :size_t], :leptris_node_ref
       attach_function :leptris_document_add_pi,
         [:leptris_document, :string, :string], :pointer
       # Document-level comments (libleptris 1.9.3, #578): parsed
@@ -550,6 +561,11 @@ module Leptris
         [:leptris_sax_recorder, :pointer], :pointer
       attach_function :leptris_sax_recorder_arena,
         [:leptris_sax_recorder, :pointer], :pointer
+      # Reuse across documents (1.9.10, #594): swaps in fresh parser
+      # state, RETAINS the record/arena buffers — a
+      # one-document-per-parse loop stops paying new/free churn.
+      attach_function :leptris_sax_recorder_reset,
+        [:leptris_sax_recorder], :int
       attach_function :leptris_sax_recorder_free,
         [:leptris_sax_recorder], :void
       attach_function :leptris_sax_parser_free,
@@ -611,6 +627,11 @@ module Leptris
       # (leptris#541). buf=NULL is a size query; the size-query +
       # fill pair reuses one serialization through a per-document
       # cache invalidated on mutation.
+      # Display-form variant (1.9.9, #129): the ext struct carries
+      # indent_text; returns an OWNED string — read via
+      # read_owned_string (the seam frees it).
+      attach_function :leptris_document_serialize_ext,
+        [:leptris_document, :pointer, :pointer], :pointer
       attach_function :leptris_document_serialize_into,
         [:leptris_document, :pointer, :size_t, :pointer, :pointer], :size_t
       attach_function :leptris_document_get_dtd,

data/lib/leptris/xml/node.rb

@@ -263,12 +263,8 @@ class Leptris::XML::Node
 
   def unlink
     ensure_writable!
-    rc = Leptris::XML::FFI.leptris_node_unlink(@c_ptr)
-    if rc == Leptris::XML::FFI::LEPTRIS_ERROR_NOT_FOUND && processing_instruction?
-      raise Leptris::XML::Error,
-        Leptris::XML::ProcessingInstruction::READ_ONLY_NATIVE
-    end
-    Leptris::XML::FFI.check_status(rc)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_node_unlink(@c_ptr))
     @parent = nil
     self
   end

data/lib/leptris/xml/processing_instruction.rb

@@ -25,34 +25,58 @@ class Leptris::XML::ProcessingInstruction < Leptris::XML::Node
     result
   end
 
-  # Parse-created document-level PIs carry no document linkage in
-  # libleptris (leptris-ruby#92): the C setters reject them with
-  # INVALID_ARG while tree-level and Document#add_pi PIs mutate
-  # fine. Map that failure to the contract instead of a bare
-  # "Invalid argument".
-  READ_ONLY_NATIVE =
-    "this PI is a parse-created document-level PI — its node has " \
-    "no document linkage in libleptris, so target/data cannot be " \
-    "written and it cannot be unlinked (leptris-ruby#92); " \
-    "tree-level and Document#add_pi PIs are mutable"
-
+  # Since libleptris 1.9.9 (#612) parse-created document-level PIs
+  # carry document linkage — the setters work on them like on any
+  # tree-level PI.
   def target=(new_target)
     ensure_writable!
-    rc = Leptris::XML::FFI.leptris_pi_node_set_target(
-      @c_ptr, new_target.to_s)
-    raise Leptris::XML::Error, READ_ONLY_NATIVE if
-      rc == Leptris::XML::FFI::LEPTRIS_ERROR_INVALID_ARG
-    Leptris::XML::FFI.check_status(rc)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_pi_node_set_target(@c_ptr, new_target.to_s))
     new_target
   end
 
   def data=(new_data)
     ensure_writable!
-    rc = Leptris::XML::FFI.leptris_pi_node_set_data(
-      @c_ptr, new_data.to_s)
-    raise Leptris::XML::Error, READ_ONLY_NATIVE if
-      rc == Leptris::XML::FFI::LEPTRIS_ERROR_INVALID_ARG
-    Leptris::XML::FFI.check_status(rc)
+    Leptris::XML::FFI.check_status(
+      Leptris::XML::FFI.leptris_pi_node_set_data(@c_ptr, new_data.to_s))
     new_data
   end
+
+  # Document-level PIs have no tree parent for leptris_node_unlink
+  # — route through the document-level removal (libleptris 1.9.9,
+  # #612), identity-matched by index so the right same-target PI
+  # comes out.
+  def unlink
+    ensure_writable!
+    rc = Leptris::XML::FFI.leptris_node_unlink(@c_ptr)
+    if rc == Leptris::XML::FFI::LEPTRIS_ERROR_NOT_FOUND
+      index = document_pi_index
+      if index.negative?
+        raise Leptris::XML::Error,
+          "PI not found in its document — already removed?"
+      end
+      removed = @document.remove_pi(index)
+      unless removed && removed.c_ptr == @c_ptr
+        raise Leptris::XML::Error, "document-level PI removal missed"
+      end
+      @parent = nil
+      return self
+    end
+    Leptris::XML::FFI.check_status(rc)
+    @parent = nil
+    self
+  end
+
+  private
+
+  # This PI's 0-based index among the document's PIs (document
+  # order — the same enumeration leptris_document_remove_pi uses).
+  def document_pi_index
+    pi_index = -1
+    @document.children.each do |child|
+      pi_index += 1 if child.pi?
+      return pi_index if child.c_ptr == @c_ptr
+    end
+    -1
+  end
 end

data/lib/leptris/xml/sax/dom_dispatch.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+# DOM-backed SAX dispatch (leptris-ruby#95): the engine's streaming
+# attribute buffer corrupts leading attribute pairs when several
+# nested ancestor levels each carry attributes — the callback
+# transport, the recorder's packed arena, AND the pull parser all
+# deliver the loss on the issue fixture (verified), while the DOM
+# parser reads the same bytes correctly. Until the engine fix
+# lands, SAX::Parser delivers from a DOM parse: same call shapes as
+# the streaming transports — attach-only-overridden kinds,
+# one-argument start_element arity, QName element names ("p:a"),
+# UTF-8 strings, PI-data normalization.
+#
+# The walk is lean by construction: elements wrap (identity, name
+# and prefix memos); every other child kind is read straight from
+# its pointer — content getters per node type, never a wrapper.
+module Leptris::XML::SAX::DomDispatch
+  module_function
+
+  def parse(handler, dispatched, string)
+    doc = Leptris::XML::Document.parse(string)
+    begin
+      dispatch(handler, dispatched, doc)
+    ensure
+      doc.free
+    end
+  end
+
+  def dispatch(handler, dispatched, doc)
+    handler.start_document if dispatched[:start_document]
+    doc_node = doc.node
+    visit_children(doc_node.c_ptr, doc, handler, dispatched) if doc_node
+    handler.end_document if dispatched[:end_document]
+    self
+  end
+
+  NODE = Leptris::XML::FFI
+  ELEMENT = Leptris::XML::FFI::NODE_ELEMENT
+  TEXT = Leptris::XML::FFI::NODE_TEXT
+  COMMENT = Leptris::XML::FFI::NODE_COMMENT
+  CDATA = Leptris::XML::FFI::NODE_CDATA
+  PI = Leptris::XML::FFI::NODE_PI
+
+  def visit_children(c_ptr, doc, handler, dispatched)
+    wants_text_kinds = dispatched[:characters] ||
+                       dispatched[:comment] ||
+                       dispatched[:cdata] || dispatched[:pi]
+    Leptris::XML::FFI.fetch_children(c_ptr).each do |child_ptr|
+      case Leptris::XML::FFI.leptris_node_get_type(child_ptr)
+      when ELEMENT
+        visit_element(
+          Leptris::XML::Node.wrap(child_ptr, doc, node_type: ELEMENT),
+          handler, dispatched)
+      when TEXT
+        if dispatched[:characters]
+          handler.characters(utf8(NODE.leptris_text_node_get_content(child_ptr)))
+        end
+      when CDATA
+        if dispatched[:cdata]
+          handler.cdata_block(utf8(NODE.leptris_cdata_node_get_content(child_ptr)))
+        end
+      when COMMENT
+        if dispatched[:comment]
+          handler.comment(utf8(NODE.leptris_comment_node_get_content(child_ptr)))
+        end
+      when PI
+        if dispatched[:pi]
+          handler.processing_instruction(
+            utf8(NODE.leptris_pi_node_get_target(child_ptr)),
+            Leptris::XML::FFI.read_pi_data(
+              utf8(NODE.leptris_pi_node_get_data(child_ptr))))
+        end
+      end
+    end
+  end
+
+  def visit_element(element, handler, dispatched)
+    qname = element.prefix ? "#{element.prefix}:#{element.name}" : element.name
+    if dispatched[:start_prefix]
+      element.namespace_definitions.each do |ns|
+        handler.start_prefix_mapping(ns.prefix.to_s, ns.href.to_s)
+      end
+    end
+    if dispatched[:start_element]
+      if dispatched[:start_element] == :one_arg
+        handler.start_element(qname)
+      else
+        handler.start_element(qname, attr_pairs(element.c_ptr))
+      end
+    end
+    visit_children(element.c_ptr, element.document, handler, dispatched)
+    handler.end_element(qname) if dispatched[:end_element]
+    if dispatched[:end_prefix]
+      element.namespace_definitions.reverse_each do |ns|
+        handler.end_prefix_mapping(ns.prefix.to_s)
+      end
+    end
+  end
+
+  # [name, value] pairs in source order, read straight from the
+  # attribute chain — no Attr objects, no hash.
+  def attr_pairs(c_ptr)
+    pairs = []
+    attr = Leptris::XML::FFI.leptris_element_first_attribute(c_ptr)
+    until attr.nil? || attr.null?
+      pairs << [utf8(Leptris::XML::FFI.leptris_attribute_get_name(attr)),
+                utf8(Leptris::XML::FFI.leptris_attribute_get_value(
+                  c_ptr, attr))]
+      attr = Leptris::XML::FFI.leptris_attribute_next(attr)
+    end
+    pairs
+  end
+
+  def utf8(str)
+    str.nil? ? nil : str.force_encoding(Encoding::UTF_8)
+  end
+end

data/lib/leptris/xml/sax/parser.rb

@@ -8,9 +8,18 @@ class Leptris::XML::SAX::Parser
 
   attr_reader :document, :encoding
 
-  def initialize(handler = Leptris::XML::SAX::Document.new, encoding = nil)
+  # streaming: false (default) delivers from a DOM parse —
+  # leptris-ruby#95: the engine's streaming SAX transports corrupt
+  # attribute state on nested attribute-heavy shapes while the DOM
+  # parser reads the same bytes correctly. streaming: true opts
+  # back into the engine transports (bulk/callback by override
+  # weight) once the engine fix lands, or for consumers that
+  # accept the risk.
+  def initialize(handler = Leptris::XML::SAX::Document.new,
+                 encoding = nil, streaming: false)
     @document = handler
     @encoding = encoding
+    @streaming = streaming
   end
 
   # Swapping the handler invalidates the memoized callback struct so
@@ -41,6 +50,11 @@ class Leptris::XML::SAX::Parser
 
   def parse_memory(string)
     string = string.dup.force_encoding("UTF-8")
+    unless @streaming
+      Leptris::XML::SAX::DomDispatch.parse(
+        @document, dispatched_kinds, string)
+      return self
+    end
     if bulk_dispatch?
       parse_memory_bulk(string)
     else
@@ -133,6 +147,10 @@ class Leptris::XML::SAX::Parser
   end
 
   def parse_io(io)
+    unless @streaming
+      parse_memory(io.read)
+      return self
+    end
     handler_struct = self.handler_struct
     parser_ptr = Leptris::XML::FFI.leptris_sax_parser_create(
       handler_struct.pointer, nil)
@@ -159,7 +177,11 @@ class Leptris::XML::SAX::Parser
   end
 
   def parse_file(path)
-    File.open(path, "r") { |f| parse_io(f) }
+    if @streaming
+      File.open(path, "r") { |f| parse_io(f) }
+    else
+      parse_memory(File.read(path))
+    end
   end
 
   private

data/lib/leptris/xml/sax/recorder.rb

@@ -69,6 +69,18 @@ class Leptris::XML::SAX::Recorder
     @handle = nil
   end
 
+  # Resets a finished recorder for the next document (libleptris
+  # 1.9.10, upstream #594): fresh parser state, record/arena
+  # buffers retained — a one-document-per-parse loop reuses ONE
+  # recorder without new/free churn. Records restart empty.
+  def reset
+    rc = Leptris::XML::FFI.leptris_sax_recorder_reset(@handle)
+    if rc != 0
+      raise Leptris::XML::Error, "leptris_sax_recorder_reset failed"
+    end
+    self
+  end
+
   # Feed one chunk; records/arena reset at feed entry, so drain
   # after every feed. Returns self.
   def feed(chunk, final: false)

data/lib/leptris/xml/sax.rb

@@ -8,6 +8,7 @@ module Leptris
       autoload :Document, "leptris/xml/sax/document"
       autoload :Parser, "leptris/xml/sax/parser"
       autoload :Recorder, "leptris/xml/sax/recorder"
+      autoload :DomDispatch, "leptris/xml/sax/dom_dispatch"
     end
   end
 end

data/lib/leptris/xml/serialization.rb

@@ -33,6 +33,25 @@ module Leptris::XML::Serialization
     Leptris::XML::FFI.serialize_into_string(ffi_function, c_ptr, opts.pointer)
   end
 
+  # Display-form document serialization (libleptris 1.9.9, #129):
+  # the ext struct's indent_text hands ALL whitespace to the
+  # formatter — text and mixed content indent too. Display-oriented:
+  # the output is NOT guaranteed to round-trip byte-exactly.
+  INDENT_TEXT_EXT = begin
+    ext = Leptris::XML::FFI::SerializeExtStruct.new
+    ext[:indent_text] = 1
+    ext
+  end
+  private_constant :INDENT_TEXT_EXT
+
+  def self.to_xml_display(c_ptr, indent: 0, no_decl: false, encoding: nil)
+    opts, encoding_anchor = build_options(
+      indent: indent, no_decl: no_decl, encoding: encoding)
+    str_ptr = Leptris::XML::FFI.leptris_document_serialize_ext(
+      c_ptr, opts.pointer, INDENT_TEXT_EXT.pointer)
+    Leptris::XML::FFI.read_owned_string(str_ptr)
+  end
+
   # +ffi_function+ is a bound FFI function taking
   # (c_ptr, version, mode, ns_ptr, flags): leptris_c14n_canonicalize_ex
   # or leptris_c14n_canonicalize_subtree_ex.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.34
+  version: 1.9.36
 platform: ruby
 authors:
 - Ribose Inc.
@@ -98,6 +98,7 @@ files:
 - lib/leptris/xml/pull.rb
 - lib/leptris/xml/sax.rb
 - lib/leptris/xml/sax/document.rb
+- lib/leptris/xml/sax/dom_dispatch.rb
 - lib/leptris/xml/sax/parser.rb
 - lib/leptris/xml/sax/recorder.rb
 - lib/leptris/xml/searchable.rb