leptris 1.9.35 → 1.9.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 81d0ccc67839cd649fce63e998598f641e731492085d5fd09f5d6f5be226c743
-  data.tar.gz: f6914705968260382baa876b12f864d712544919a1186ef90cc0ba76857a8f86
+  metadata.gz: 31fdbaa742e583a50409dea1a5bda76e454e3b54ec30429d74101d5438f91b6f
+  data.tar.gz: 6acd554905283d755febf5c6265ce2a97dd8f9ce1ef83c9804363ff2d5bf1000
 SHA512:
-  metadata.gz: 70235b9639261a967137bc78694b0cbe447f8165c95819e7d28db24c4f37775fb67aca769e05462231ecd8bdf14f542a42cdd3b73159546c36232aaaf14fc848
-  data.tar.gz: 053d1e08b23283d82d83c7276417623358e4f29207eaf77fec9f71d319c4dc48ac5f6ad8d5ff038190d5a29b4e9956202abde97b2bb708a256837cbc5b67c21f
+  metadata.gz: 7e4c9abd84b07a678394774470b1486ccb2e03146578cda7eded0da2aa42f0b33f3ae682ac5a1881d2661e4a90ddb3bd6e0b3098d411303268867a2bbc1ad0d5
+  data.tar.gz: 35a2088c31974f7dc19beaa0bd4ad5c73515be100b1c0d3b3fd3bc313fa10e7abc28202f3eb7bb3cce6035ad86b0c3f553bde0ca458e08a03110ba0d774ff07a

data/CHANGELOG.md

@@ -5,6 +5,46 @@ 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

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.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.35"
+  VERSION = "1.9.36"
 end

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,

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.35
+  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