leptris 1.9.33-aarch64-linux → 1.9.35-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 179f524963c6e09db30ac71cd0a6c20cee7a2b38f8bcd268bd1c551ccc3b25dd
-  data.tar.gz: 2d1c23f938f82cf6c052c3b008c0d79309522d53f5284aaba18807ed52cc7a4f
+  metadata.gz: a5d2cc0c763678c71c93628564323985c5e55f27ea126aa9f003319e4a7a7524
+  data.tar.gz: 8545c65e4579fe342f87938cf4f24f63dd02b7900bbf4bad7e040934a35b750e
 SHA512:
-  metadata.gz: f525496783584c2eec01c84ff0e8845a07f9b05e61e918042caa133ec7a464aae61b3ed8b9be449e4a015af0255629014054dc6101ae8376a1e5c3e0d40f7c79
-  data.tar.gz: 60402a2294e25dffd28f416b09ba1f74325acc76b2e00cdf7c6fa6573d7ba6b17fd8edcecafaecf0449a53dc87cdc07669c382bf7a4bb8f1eba0f2c641ee6abc
+  metadata.gz: 4c936cd0a55e640174407bcbc38a774679949d327c00dfd36ac058828094033405bdf5e9960f87d4e390c67b8ae58aea9aa2dd7f3a61adbae626f41488fadb8b
+  data.tar.gz: 84e79fc4a1bb6d563aefee5a44ae7b78e19488e3991a167221f20bbaff441cd289bf5c3e459d0ddfdec1d00f67429705e77aec5175169360496fce29f8fa84bf

data/CHANGELOG.md

@@ -5,6 +5,75 @@ 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.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
+
+- **SAX fully wins every shape** (leptris-ruby's parity-not-win,
+  upstream #594's framing): on the all-events handler profile the
+  binding previously LOST to Nokogiri by 14% (170 vs 149 ms per
+  1.9 MB parse) — the ffi gem's per-event callback trampoline
+  could not match a compiled C extension. Two things changed:
+  - The engine's C-side recorder cost no longer scales with
+    element count (~12 ms per 250k-event document now), so a bulk
+    transport can win.
+  - New `SAX::Recorder#dispatch(handler, kinds)` — the two-level
+    drain driving handler METHOD calls with the callback
+    transport's exact shapes (pairs arrays, one-arg arity
+    dispatch, UTF-8, PI normalization). `SAX::Parser` picks the
+    transport by override weight (characters 0.6, start/end 0.2;
+    ≥ 0.8 → bulk): one overridden hot kind stays on callbacks
+    (the engine skips C-side emission for unattached kinds:
+    text-only 23 ms vs 43 ms), two or more go bulk (start+end+chars
+    167 → **122 ms**, ahead of Nokogiri's 142 ms on the same
+    machine; head-to-head 123 vs 133). Handlers cannot tell which
+    transport served them — spec-pinned byte-identical call
+    sequences.
+  - Drain repairs that made it possible: kind-strip two-level
+    drain (no more 2.25M-Integer unpack array per single-feed
+    drain), `FFI::Struct.size` hoisted out of the loop (250k
+    layout lookups per parse), unused fields yield nil instead of
+    empty-String allocations, a characters fast path in the drain
+    loop.
+
 ## [1.9.33] - 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.9"
 
 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.33"
+  VERSION = "1.9.35"
 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
@@ -611,6 +622,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/parser.rb

@@ -18,6 +18,7 @@ class Leptris::XML::SAX::Parser
   def document=(handler)
     @document = handler
     @handler_struct = nil
+    @dispatched_kinds = nil
   end
 
   # The handler struct (eleven FFI::Function callbacks + the C
@@ -40,16 +41,97 @@ class Leptris::XML::SAX::Parser
 
   def parse_memory(string)
     string = string.dup.force_encoding("UTF-8")
-    handler_struct = self.handler_struct
-    rc = Leptris::XML::FFI.leptris_sax_parse(
-      string, string.bytesize, handler_struct.pointer, nil)
-    if rc != 0
-      raise Leptris::XML::ParseError,
-        "leptris_sax_parse failed (rc=#{rc})"
+    if bulk_dispatch?
+      parse_memory_bulk(string)
+    else
+      handler_struct = self.handler_struct
+      rc = Leptris::XML::FFI.leptris_sax_parse(
+        string, string.bytesize, handler_struct.pointer, nil)
+      if rc != 0
+        raise Leptris::XML::ParseError,
+          "leptris_sax_parse failed (rc=#{rc})"
+      end
     end
     self
   end
 
+  # Bulk transport for many-override handlers: record the whole
+  # document C-side (~12ms per 250k events), then dispatch through
+  # the recorder's drain — 250k ffi callback trampolines cost
+  # ~150ms, so this wins outright for handlers that consume most of
+  # the event stream (and beats Nokogiri's C extension on the same
+  # shape). The delivered call shapes are IDENTICAL to the callback
+  # transport (pairs arrays, arity dispatch, UTF-8, PI-data
+  # normalization) — the transports are interchangeable to the
+  # handler.
+  #
+  # Transport choice, from the round-XXVI crossover measurements:
+  # ONE overridden hot kind pays less through the callbacks (the
+  # engine skips C-side emission for unattached kinds entirely:
+  # text-only 23ms vs 43ms), while two or more hot kinds win through
+  # the recorder (start+chars 138 -> 99ms, start+end+chars 167 ->
+  # 122ms vs Nokogiri's 142ms). The weights are document-shape
+  # priors — text-heavy documents with tagged structure.
+  HOT_KIND_WEIGHTS = {
+    characters: 0.6, start_element: 0.2, end_element: 0.2,
+  }.freeze
+  private_constant :HOT_KIND_WEIGHTS
+  DISPATCH_WEIGHT_THRESHOLD = 0.8
+  private_constant :DISPATCH_WEIGHT_THRESHOLD
+
+  def parse_memory_bulk(string)
+    recorder = Leptris::XML::SAX::Recorder.open
+    begin
+      rc = recorder.feed(string, final: true)
+      recorder.dispatch(@document, dispatched_kinds)
+      if rc != 0
+        raise Leptris::XML::ParseError,
+          "leptris_sax_parse failed (rc=#{rc})"
+      end
+    ensure
+      recorder.free
+    end
+    self
+  end
+
+  # The handler's overridden-kind map — the same decisions
+  # build_handler_struct makes, in dispatch form. Memoized with the
+  # handler struct; document= invalidates both.
+  def dispatched_kinds
+    @dispatched_kinds ||= begin
+      kinds = {}
+      {
+        start_document: :start_document,
+        end_document: :end_document,
+        start_element: :start_element,
+        end_element: :end_element,
+        characters: :characters,
+        comment: :comment,
+        cdata_block: :cdata,
+        processing_instruction: :pi,
+        start_prefix_mapping: :start_prefix,
+        end_prefix_mapping: :end_prefix,
+        error: :error,
+      }.each do |method_name, kind|
+        next unless overridden?(method_name)
+        kinds[kind] =
+          if method_name == :start_element &&
+              @document.method(:start_element).arity == 1
+            :one_arg
+          else
+            true
+          end
+      end
+      kinds
+    end
+  end
+
+  def bulk_dispatch?
+    dispatched_kinds.keys.sum do |kind|
+      HOT_KIND_WEIGHTS.fetch(kind, 0.0)
+    end >= DISPATCH_WEIGHT_THRESHOLD
+  end
+
   def parse_io(io)
     handler_struct = self.handler_struct
     parser_ptr = Leptris::XML::FFI.leptris_sax_parser_create(

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

@@ -88,6 +88,161 @@ class Leptris::XML::SAX::Recorder
     each_event(*Array(kinds), &block)
   end
 
+  # Which kinds carry each string field (the record layout leaves
+  # the other at offset 0 / length 0): slicing a zero-length run
+  # allocates a wasted empty String per event — 150k+ of them on a
+  # text-heavy document. Unused fields yield nil (the callback
+  # transport delivers no name for characters either).
+  HAS_NAME = {
+    start_element: true, end_element: true,
+    pi: true, start_prefix: true, end_prefix: true,
+  }.freeze
+  HAS_TEXT = {
+    characters: true, comment: true, cdata: true,
+    pi: true, start_prefix: true, error: true,
+  }.freeze
+
+  # Layout offsets (the struct stays the ABI's single source of
+  # truth) and per-count kind-strip templates: one byte per record,
+  # skipping the stride — the kind codes are 0..10, so the strip
+  # unpacks to cache-resident Fixnums, unlike the old whole-record
+  # unpack whose 2.25M-Integer array for a single-feed drain was
+  # most of the loop's allocation profile.
+  RECORD = Leptris::XML::FFI::SaxEventRecord
+  NAME_OFF = RECORD.offset_of(:name_off)
+  NAME_LEN = RECORD.offset_of(:name_len)
+  TEXT_OFF = RECORD.offset_of(:text_off)
+  TEXT_LEN = RECORD.offset_of(:text_len)
+  ATTRS_OFF = RECORD.offset_of(:attrs_off)
+  ATTR_COUNT = RECORD.offset_of(:attr_count)
+  LINE_OFF = RECORD.offset_of(:line)
+  COLUMN_OFF = RECORD.offset_of(:column)
+  RECORD_STRIDE = RECORD.size
+  SAX_EVENT_CHARACTERS_CODE = Leptris::XML::FFI::SAX_EVENT_CHARACTERS
+  NUL = "\0".freeze
+  KIND_TEMPLATE_FOR = ::Hash.new do |cache, count|
+    cache[count] = ("C x#{RECORD_STRIDE - 1}" * count)
+  end
+
+  # Dispatch drain: delivers the recorded events as handler method
+  # calls with the CALLBACK transport's exact shapes — pairs arrays
+  # (not hashes), one-argument start_element arity dispatch, UTF-8
+  # strings, PI-data whitespace normalization. +dispatched+ maps
+  # kind symbols to true for the kinds the handler overrides (the
+  # attach-only-overridden policy carried onto the bulk transport:
+  # other records cost one strip read). The C recorder costs ~12ms
+  # per 250k-event document while 250k ffi callback trampolines
+  # cost ~150ms — this is how a many-override handler beats the
+  # callback transport (and Nokogiri's C extension) outright.
+  def dispatch(handler, dispatched)
+    count_ptr = ::FFI::MemoryPointer.new(:size_t)
+    len_ptr = ::FFI::MemoryPointer.new(:size_t)
+    begin
+      records_ptr = Leptris::XML::FFI.leptris_sax_recorder_records(
+        @handle, count_ptr)
+      return self if records_ptr.null? || count_ptr.read_uint64.zero?
+      arena_ptr = Leptris::XML::FFI.leptris_sax_recorder_arena(
+        @handle, len_ptr)
+      arena = arena_ptr.read_bytes(len_ptr.read_uint64)
+      count = count_ptr.read_uint64
+      records = records_ptr.read_bytes(count * RECORD_STRIDE)
+      kinds = records.unpack(KIND_TEMPLATE_FOR[count])
+
+      one_arg_start = dispatched[:start_element] == :one_arg
+      i = 0
+      while i < count
+        code = kinds[i]
+        kind = KIND_BY_CODE[code]
+        if kind && dispatched[kind]
+          base = i * RECORD_STRIDE
+          case kind
+          when :characters
+            handler.characters(slice(arena,
+              records_ptr.get_uint32(base + TEXT_OFF),
+              records_ptr.get_uint32(base + TEXT_LEN)))
+          when :start_element
+            name = slice(arena,
+              records_ptr.get_uint32(base + NAME_OFF),
+              records_ptr.get_uint32(base + NAME_LEN))
+            if one_arg_start
+              handler.start_element(name)
+            else
+              handler.start_element(name, attrs_pairs(arena,
+                records_ptr.get_uint32(base + ATTRS_OFF),
+                records_ptr.get_uint32(base + ATTR_COUNT)))
+            end
+          when :end_element
+            handler.end_element(slice(arena,
+              records_ptr.get_uint32(base + NAME_OFF),
+              records_ptr.get_uint32(base + NAME_LEN)))
+          when :comment
+            handler.comment(slice(arena,
+              records_ptr.get_uint32(base + TEXT_OFF),
+              records_ptr.get_uint32(base + TEXT_LEN)))
+          when :cdata
+            handler.cdata_block(slice(arena,
+              records_ptr.get_uint32(base + TEXT_OFF),
+              records_ptr.get_uint32(base + TEXT_LEN)))
+          when :pi
+            handler.processing_instruction(slice(arena,
+              records_ptr.get_uint32(base + NAME_OFF),
+              records_ptr.get_uint32(base + NAME_LEN)),
+              Leptris::XML::FFI.read_pi_data(slice(arena,
+                records_ptr.get_uint32(base + TEXT_OFF),
+                records_ptr.get_uint32(base + TEXT_LEN))))
+          when :start_prefix
+            handler.start_prefix_mapping(slice(arena,
+              records_ptr.get_uint32(base + NAME_OFF),
+              records_ptr.get_uint32(base + NAME_LEN)),
+              slice(arena,
+                records_ptr.get_uint32(base + TEXT_OFF),
+                records_ptr.get_uint32(base + TEXT_LEN)))
+          when :end_prefix
+            handler.end_prefix_mapping(slice(arena,
+              records_ptr.get_uint32(base + NAME_OFF),
+              records_ptr.get_uint32(base + NAME_LEN)))
+          when :error
+            handler.error(slice(arena,
+              records_ptr.get_uint32(base + TEXT_OFF),
+              records_ptr.get_uint32(base + TEXT_LEN)),
+              records_ptr.get_uint32(base + LINE_OFF),
+              records_ptr.get_uint32(base + COLUMN_OFF))
+          when :start_document
+            handler.start_document
+          when :end_document
+            handler.end_document
+          end
+        end
+        i += 1
+      end
+    ensure
+      count_ptr.free
+      len_ptr.free
+    end
+    self
+  end
+
+  # attrs as [name, value] pairs in source order — the callback
+  # transport's shape (walk_attr_array).
+  def attrs_pairs(arena, off, count)
+    return [] if count.zero?
+    pairs = []
+    pos = off
+    nul = NUL
+    utf8 = Encoding::UTF_8
+    while count > 0
+      name_end = arena.index(nul, pos)
+      name = arena.byteslice(pos, name_end - pos).force_encoding(utf8)
+      pos = name_end + 1
+      value_end = arena.index(nul, pos)
+      pairs << [name,
+        arena.byteslice(pos, value_end - pos).force_encoding(utf8)]
+      pos = value_end + 1
+      count -= 1
+    end
+    pairs
+  end
+
   # Drains the current chunk's records: bulk-reads the record array
   # and the packed arena (two FFI calls), then slices every string
   # from the arena in Ruby — no per-string FFI. With +kinds+, records
@@ -108,27 +263,48 @@ class Leptris::XML::SAX::Recorder
       arena = arena_ptr.read_bytes(len_ptr.read_uint64)
       count = count_ptr.read_uint64
 
-      # The whole record block in ONE read: read_bytes + String#unpack
-      # (C-fast) — two FFI calls per chunk total (records + arena),
-      # the true bulk discipline. Template per record: kind byte,
-      # 7 pad, then the eight uint32 fields (little-endian hosts —
-      # the layout the header freezes for FFI mirrors).
-      stride = Leptris::XML::FFI::SaxEventRecord.size
-      fields = records_ptr.read_bytes(count * stride)
-        .unpack("C x7 V8" * count)
+      # Two-level drain: ONE bulk read + kind-strip unpack decides
+      # which records to touch, then each yielded event's fields are
+      # read individually (get_uint32 at layout offsets) — an
+      # unwanted record costs one strip read, an unused FIELD costs
+      # nothing, and no per-chunk field array is ever built.
+      records = records_ptr.read_bytes(count * RECORD_STRIDE)
+      kinds = records.unpack(KIND_TEMPLATE_FOR[count])
 
+      has_name = HAS_NAME
+      has_text = HAS_TEXT
+      drain = wanted.nil?
       i = 0
       while i < count
-        kind = KIND_BY_CODE[fields[i * 9]]
-        if kind && (wanted.nil? || wanted[kind])
-          base = i * 9 + 1
-          text = slice(arena, fields[base + 2], fields[base + 3])
-          text = Leptris::XML::FFI.read_pi_data(text) if kind == :pi
-          yield kind,
-                slice(arena, fields[base], fields[base + 1]),
-                text,
-                attrs_from(arena, fields[base + 4], fields[base + 5]),
-                fields[base + 6], fields[base + 7]
+        code = kinds[i]
+        base = i * RECORD_STRIDE
+        if code == SAX_EVENT_CHARACTERS_CODE && drain
+          # The dominant branch (text-heavy documents): no name, no
+          # attrs, no per-kind gate lookups — kind, text, position.
+          yield :characters, nil,
+                slice(arena, records_ptr.get_uint32(base + TEXT_OFF),
+                             records_ptr.get_uint32(base + TEXT_LEN)),
+                nil,
+                records_ptr.get_uint32(base + LINE_OFF),
+                records_ptr.get_uint32(base + COLUMN_OFF)
+        else
+          kind = KIND_BY_CODE[code]
+          if kind && (drain || wanted[kind])
+            name = if has_name[kind]
+                     slice(arena, records_ptr.get_uint32(base + NAME_OFF),
+                                  records_ptr.get_uint32(base + NAME_LEN))
+                   end
+            text = if has_text[kind]
+                     slice(arena, records_ptr.get_uint32(base + TEXT_OFF),
+                                  records_ptr.get_uint32(base + TEXT_LEN))
+                   end
+            text = Leptris::XML::FFI.read_pi_data(text) if kind == :pi
+            yield kind, name, text,
+                  attrs_from(arena, records_ptr.get_uint32(base + ATTRS_OFF),
+                                    records_ptr.get_uint32(base + ATTR_COUNT)),
+                  records_ptr.get_uint32(base + LINE_OFF),
+                  records_ptr.get_uint32(base + COLUMN_OFF)
+          end
         end
         i += 1
       end
@@ -153,9 +329,9 @@ class Leptris::XML::SAX::Recorder
     kinds.each_with_object({}) { |kind, set| set[kind] = true }
   end
 
-  # Zero-length slices are empty strings, not nil — the default
-  # namespace prefix is legitimately "" (START_PREFIX: name may be
-  # ""), matching the callback transport's delivery.
+  # The default-namespace prefix is legitimately "" (START_PREFIX:
+  # name may be zero-length) — zero-length slices stay "" where the
+  # field is carried (unused fields never reach here).
   def slice(arena, off, len)
     arena.byteslice(off, len).force_encoding(Encoding::UTF_8)
   end
@@ -166,15 +342,17 @@ class Leptris::XML::SAX::Recorder
     return nil if count.zero?
     hash = {}
     pos = off
-    count.times do
-      name_end = arena.index("\0", pos)
-      name = arena.byteslice(pos, name_end - pos)
+    nul = NUL
+    utf8 = Encoding::UTF_8
+    while count > 0
+      name_end = arena.index(nul, pos)
+      name = arena.byteslice(pos, name_end - pos).force_encoding(utf8)
       pos = name_end + 1
-      value_end = arena.index("\0", pos)
-      value = arena.byteslice(pos, value_end - pos)
+      value_end = arena.index(nul, pos)
+      hash[name] =
+        arena.byteslice(pos, value_end - pos).force_encoding(utf8)
       pos = value_end + 1
-      hash[name.force_encoding(Encoding::UTF_8)] =
-        value.force_encoding(Encoding::UTF_8)
+      count -= 1
     end
     hash
   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.33
+  version: 1.9.35
 platform: aarch64-linux
 authors:
 - Ribose Inc.