leptris 1.9.35-aarch64-linux → 1.9.37-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a5d2cc0c763678c71c93628564323985c5e55f27ea126aa9f003319e4a7a7524
-  data.tar.gz: 8545c65e4579fe342f87938cf4f24f63dd02b7900bbf4bad7e040934a35b750e
+  metadata.gz: ec92a3dcbcfe8ff73e97968df81833ac687ac7f2dd25d067bd4f16cccecbb19c
+  data.tar.gz: cc6b3233de37a3cf732ff3b1e007548e9a22e07a1f6f928da61202053f99dd94
 SHA512:
-  metadata.gz: 4c936cd0a55e640174407bcbc38a774679949d327c00dfd36ac058828094033405bdf5e9960f87d4e390c67b8ae58aea9aa2dd7f3a61adbae626f41488fadb8b
-  data.tar.gz: 84e79fc4a1bb6d563aefee5a44ae7b78e19488e3991a167221f20bbaff441cd289bf5c3e459d0ddfdec1d00f67429705e77aec5175169360496fce29f8fa84bf
+  metadata.gz: 716b5a27e519fb75c622065bf0d1c6588cf11dbafb13418de2f8a72409ce475a2434d97bcebae932669f79a7f095e6645aef6e81c59fc27ef8f2ded1f66fe4bd
+  data.tar.gz: 190f571def471b9351a21ec3e856577175a018efe36626fc20091df9e02fb06708ba46e49384dcb6d6e345e058f021fa53c93eadaeb2968160f67d550a822243

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.37] - 2026-08-29
+
+### Added
+
+- **`Element#inner_html`** (Nokogiri parity): the serialized
+  children — elements through the engine serializer, text
+  XML-escaped at the seam (`& < >` and CR → `&#xD;`, libxml2's
+  rules), comments/CDATA/PIs in literal forms. Well-formed by
+  construction: a spec re-parses the output to the same children.
+  (Nokogiri's inner_html HTML-serializes XML documents — SGML-style
+  PI closes, bare CDATA content — and its output does not
+  re-parse.) Measured 21 µs/element vs Nokogiri 15 — a first cut
+  on a new API with correct forms as the contract.
+- **libleptris 1.9.12 lockstep** (with 1.9.11): pure XSLT
+  conformance upstream (libxslt suite 152 -> 180/205 — template
+  priority, xsl:number, attribute sets, namespace-declaration
+  ordering, strip/preserve-space, copy semantics); audit 250/250,
+  no new C surface.
+
+### Changed
+
+- **Serialize byte-scratch**: the size+fill serialization pair
+  allocated and freed a MemoryPointer per call — inner_html
+  serializes each child, and the allocation dominated per-child
+  cost. A grow-only thread-local byte scratch (the pointer-scratch
+  discipline) now serves every serialize call. Serialized output
+  is also forced UTF-8 at the seam (previously true only by
+  accident of ASCII-only content comparisons).
+
+## [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

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.9"
+LIBLEPTRIS_VERSION = "1.9.12"
 
 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.35"
+  VERSION = "1.9.37"
 end

data/lib/leptris/xml/element.rb

@@ -336,6 +336,28 @@ class Leptris::XML::Element < Leptris::XML::Node
     scopes
   end
 
+  # The serialized children (Nokogiri parity): elements serialize
+  # through the engine (correct escaping), text is XML-escaped,
+  # comments/CDATA/PIs render their literal forms. The complement
+  # of #inner_text, which returns the unescaped text content.
+  def inner_html
+    children.map do |child|
+      case child
+      when Leptris::XML::Element then child.to_xml
+      when Leptris::XML::CDATA # before Text: CDATA subclasses it
+        "<![CDATA[#{child.content}]]>"
+      when Leptris::XML::Text
+        Leptris::XML::Serialization.escape_text(child.content)
+      when Leptris::XML::Comment then "<!--#{child.content}-->"
+      when Leptris::XML::ProcessingInstruction
+        data = child.content
+        data.empty? ? "<?#{child.name}?>" : "<?#{child.name} #{data}?>"
+      else
+        Leptris::XML::Serialization.escape_text(child.content.to_s)
+      end
+    end.join
+  end
+
   def to_xml(indent: 0, no_decl: false, encoding: nil)
     Leptris::XML::Serialization.to_xml(
       Leptris::XML::FFI.method(:leptris_element_serialize_into), @c_ptr,

data/lib/leptris/xml/ffi.rb

@@ -561,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,
@@ -860,13 +865,24 @@ module Leptris
       def self.serialize_into_string(ffi_function, c_ptr, options)
         need = ffi_function.call(c_ptr, nil, 0, nil, options)
         return "" if need.zero?
-        buffer = ::FFI::MemoryPointer.new(:char, need)
-        begin
-          ffi_function.call(c_ptr, buffer, need, nil, options)
-          buffer.read_string
-        ensure
-          buffer.free
+        buffer = scratch_bytes(need)
+        ffi_function.call(c_ptr, buffer, need, nil, options)
+        buffer.read_string.force_encoding(Encoding::UTF_8)
+      end
+
+      # Byte scratch for serialize-into cycles: the size+fill pair
+      # allocated and freed a buffer per call — inner_html
+      # serializes each child, and the allocation was most of the
+      # per-child cost. Grows to the largest serialization seen;
+      # no Ruby reentrancy during a serialize call.
+      def self.scratch_bytes(need)
+        scratch = (Thread.current[:leptris_scratch] ||= {})
+        ptr = scratch[:bytes]
+        if ptr.nil? || ptr.size < need
+          ptr&.free
+          ptr = scratch[:bytes] = ::FFI::MemoryPointer.new(:char, need)
         end
+        ptr
       end
 
       # All-kind child handle batch (libleptris 1.7.0). Opportunistic

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

@@ -62,6 +62,19 @@ module Leptris::XML::Serialization
     Leptris::XML::FFI.read_owned_string(str_ptr)
   end
 
+  # XML-escapes text content for inner_html: & first, then < >
+  # and CR (libxml2 emits &#xD; for a bare carriage return).
+  ESCAPE_TEXT = {
+    "&" => "&amp;", "<" => "&lt;", ">" => "&gt;", "\r" => "&#xD;",
+  }.freeze
+  private_constant :ESCAPE_TEXT
+  ESCAPE_TEXT_RE = /[&<>\r]/.freeze
+  private_constant :ESCAPE_TEXT_RE
+
+  def self.escape_text(string)
+    string.gsub(ESCAPE_TEXT_RE, ESCAPE_TEXT)
+  end
+
   # Builds a SerializeOptions struct. Returns [opts, encoding_anchor];
   # the anchor must stay referenced while opts is in an FFI call.
   def self.build_options(indent: 0, no_decl: false, encoding: nil)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.35
+  version: 1.9.37
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-28 00:00:00.000000000 Z
+date: 2026-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -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