leptris 1.9.36 → 1.9.38

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31fdbaa742e583a50409dea1a5bda76e454e3b54ec30429d74101d5438f91b6f
-  data.tar.gz: 6acd554905283d755febf5c6265ce2a97dd8f9ce1ef83c9804363ff2d5bf1000
+  metadata.gz: d6a20a13a634924317b339a27ecae165e6998c4d3de38854edd48d6ca68fa963
+  data.tar.gz: 87fdd1085af203af496cb625f02406073a000c1e5d6f1bcce046222fcc8d9a74
 SHA512:
-  metadata.gz: 7e4c9abd84b07a678394774470b1486ccb2e03146578cda7eded0da2aa42f0b33f3ae682ac5a1881d2661e4a90ddb3bd6e0b3098d411303268867a2bbc1ad0d5
-  data.tar.gz: 35a2088c31974f7dc19beaa0bd4ad5c73515be100b1c0d3b3fd3bc313fa10e7abc28202f3eb7bb3cce6035ad86b0c3f553bde0ca458e08a03110ba0d774ff07a
+  metadata.gz: c635bbd6bff75845204d2e34665003f9652b68dfe834f1484b5da84dd26e4db5992b14bb9b5d51e5cb03d9ee2b8e4ca64d6190aeb3fffa631011fbf9b1316625
+  data.tar.gz: fdef1ebde1f5770b0379242ae258ef8fcc1331353bc25f0ad283a6c13fea23d0df9508fb4623ffd0dffd798298b3b324efc7d92dae3131063436682fa6762d7c

data/CHANGELOG.md

@@ -5,6 +5,58 @@ 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.38] - 2026-08-29
+
+### Changed
+
+- **libleptris 1.9.13 lockstep**: pin bumped; audit 250/250, no
+  new C surface. Engine: document-level whitespace now chains as
+  TEXT children of the document node with libxml2's exact rule
+  (leading prolog ws dropped, ws after a prolog PI dropped, ws
+  after a comment or the root kept, trailing tail trimmed) — a
+  spec pins the rule through `Document#children`; XSLT suite
+  180 -> 181/205.
+- **Element-only SAX handlers ride the element batch** in the
+  DOM-backed dispatcher (round XXIII's path): handlers overriding
+  only element events skip the per-child get_type walk entirely —
+  text/comments/PIs are never fetched. The document node keeps the
+  typed walk (it is not an element handle).
+
+### Meta
+
+- Nokogiri-compat audit against moxml's adapter surface: no gaps
+  (remove_attribute, add_namespace_definition, replace,
+  add_previous/next_sibling all present).
+
+## [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

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.10"
+LIBLEPTRIS_VERSION = "1.9.13"
 
 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.36"
+  VERSION = "1.9.38"
 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

@@ -865,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

@@ -29,7 +29,10 @@ module Leptris::XML::SAX::DomDispatch
   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
+    if doc_node
+      visit_children(doc_node.c_ptr, doc, handler, dispatched,
+                     element_parent: false)
+    end
     handler.end_document if dispatched[:end_document]
     self
   end
@@ -41,10 +44,23 @@ module Leptris::XML::SAX::DomDispatch
   CDATA = Leptris::XML::FFI::NODE_CDATA
   PI = Leptris::XML::FFI::NODE_PI
 
-  def visit_children(c_ptr, doc, handler, dispatched)
+  def visit_children(c_ptr, doc, handler, dispatched, element_parent: true)
     wants_text_kinds = dispatched[:characters] ||
                        dispatched[:comment] ||
                        dispatched[:cdata] || dispatched[:pi]
+    if element_parent && !wants_text_kinds
+      # Element-only handlers under an element: the element batch
+      # hands out element pointers with no per-child get_type
+      # (round XXIII's path) — text/comments/PIs are never fetched.
+      # (The document node is not an element handle — the typed
+      # walk serves it.)
+      Leptris::XML::FFI.fetch_element_children(c_ptr).each do |child_ptr|
+        visit_element(
+          Leptris::XML::Node.wrap(child_ptr, doc, node_type: ELEMENT),
+          handler, dispatched)
+      end
+      return
+    end
     Leptris::XML::FFI.fetch_children(c_ptr).each do |child_ptr|
       case Leptris::XML::FFI.leptris_node_get_type(child_ptr)
       when ELEMENT

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.36
+  version: 1.9.38
 platform: ruby
 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