leptris 1.9.26-aarch64-linux → 1.9.28-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ff1e0252cab3e0bf0f626b2561c127325c2540332d1049e0eaec864f5065d29
-  data.tar.gz: 2bc04e7940829b977148af31a56e8044496c1138773858a25e69c0d216b81fee
+  metadata.gz: bc27ce25308956b6f5cbd275686b8872f7082f6c3cea568d127b5655a315fb94
+  data.tar.gz: 6f06edf1df2cf34dfcd40f749d5e5ddc481deec21197e45b0d9e38f6bddf6333
 SHA512:
-  metadata.gz: 902dbd67e428e7efd945017cc2a72e6d80c79250b19eabaeeceeab711c7d00669dbaecf3696778bce1780fe1f613042201eb12042370a767b2705ebc392d06b0
-  data.tar.gz: 5eb92eb2921f786ad97dbebe5131e508d7ae16d205f073fed6010ea91cdbefd0db933457ed0d628f18b54e557ea8c8c2a67f1df4c9bf5c9c3f511700ec53b01d
+  metadata.gz: b8c27e5ce7f4b67a3940e88e369934ed03ad6233f2387c3924f64d0e7c3486968a7a4c3431e6f9d4e23cd11affb657e002537a038f1a0248af7c689188725e1d
+  data.tar.gz: c7ed1e5a92a463ccad6908a039b359cfb640e197717de04865e5e59f3fbcbba6bd843ed61663c6fcaf1917695f997f156a6e50b8e5a7b9ef81f589745083521c

data/CHANGELOG.md

@@ -5,6 +5,52 @@ 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.28] - 2026-08-28
+
+### Changed
+
+- **Element-child reads pay only for elements** — the
+  interest-proportional principle applied to tree navigation:
+  - `#element_children` on element receivers rides the element-only
+    batch (`leptris_element_children`, opportunistic single
+    dispatch on the shared scratch): text/comment children are
+    never wrapped, and every kept element carries the ELEMENT hint
+    so the per-child `get_type` disappears. Cold pass over
+    big.xml's 25,000 items: 160 -> **117 ms per doc (-27%)**.
+    Non-element receivers (the document node) keep the filter.
+  - `#first_element_child` types candidate siblings with one raw
+    `get_type` each — nothing wrapped or cached until the element
+    is found (it previously full-wrapped leading text nodes).
+  - `#last_element_child` on element receivers wraps only the
+    batch's final pointer (it previously materialized every child,
+    text wraps included, to scan backwards). The first/last pair
+    across fresh docs: **-46%**.
+  - The all-kind `#children` path is untouched — the cold full-tree
+    walk battery stays at parity.
+
+## [1.9.27] - 2026-08-28
+
+### Fixed
+
+- **Arity-declared attrs interest in SAX** (round XIX's policy
+  completed): a handler whose `start_element` takes exactly one
+  argument declares name-only — the attribute walk (2N pointer
+  reads + N string pairs per start) never runs. Measured
+  elements-only on big.xml: 116 -> **40 ms per parse (2.9x; the
+  no-walk ceiling is 3.7x)**. This also fixes a crash: 1-argument
+  `start_element` handlers previously raised ArgumentError because
+  the callback always dispatched both arguments (Nokogiri raises
+  there too; we now honor the signature). Optional-argument and
+  splat handlers keep receiving pairs exactly as before.
+
+### Meta
+
+- Upstream check: no libleptris 1.9.8 exists (tarball probe 404s);
+  1.9.7 remains latest. Two perf hypotheses benchmarked and
+  retired this round: `Element#content` is already a memoized
+  one-C-call read, and `Node#traverse`'s C callback dispatch
+  (181 ms) beats Ruby children-recursion (551 ms) 3x — both stay.
+
 ## [1.9.26] - 2026-08-28
 
 ### Added

data/lib/leptris/version.rb

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

data/lib/leptris/xml/ffi.rb

@@ -863,6 +863,32 @@ module Leptris
         buffer.get_array_of_pointer(0, copied)
       end
 
+      # Element-only child batch (the mirror of fetch_children over
+      # leptris_element_children): element receivers skip wrapping —
+      # and paying for — the text/comment children they will filter
+      # out anyway; every wrap carries the ELEMENT hint so the
+      # per-child get_type dispatch disappears too.
+      def self.fetch_element_children(el_ptr)
+        scratch = (Thread.current[:leptris_scratch] ||= {})
+        buffer = scratch[:pointers]
+        if buffer.nil?
+          buffer = scratch[:pointers] =
+            ::FFI::MemoryPointer.new(:pointer, FETCH_INITIAL)
+        end
+        cap = buffer.size / PTR_BYTES
+        copied = leptris_element_children(el_ptr, buffer, cap)
+        if copied == cap
+          total = leptris_element_children(el_ptr, nil, 0)
+          if total > cap
+            buffer.free
+            buffer = scratch[:pointers] =
+              ::FFI::MemoryPointer.new(:pointer, total)
+            copied = leptris_element_children(el_ptr, buffer, total)
+          end
+        end
+        buffer.get_array_of_pointer(0, copied)
+      end
+
       # XPath result-set batch (leptris_xpath_result_get_nodes_ex):
       # the call fills out_kinds in the 4-value XPATH_NODE space
       # (ELEMENT/ATTRIBUTE/TEXT/OTHER). ELEMENT is the only value

data/lib/leptris/xml/node.rb

@@ -190,12 +190,17 @@ class Leptris::XML::Node
   def first_element_child
     return @first_element_child if memo_hit?(@first_element_child_version)
     ensure_alive!
+    # Raw pointer scan: non-element siblings are typed with one C
+    # call each — never wrapped, never cached — and the found
+    # element carries the ELEMENT hint into the wrap.
     ptr = Leptris::XML::FFI.leptris_node_first_child(@c_ptr)
     result = nil
     until ptr.nil? || ptr.null?
-      node = Leptris::XML::Node.wrap(ptr, @document, parent: as_element_or_self)
-      if node.element?
-        result = node
+      if Leptris::XML::FFI.leptris_node_get_type(ptr) ==
+          Leptris::XML::FFI::NODE_ELEMENT
+        result = Leptris::XML::Node.wrap(
+          ptr, @document, parent: as_element_or_self,
+          node_type: Leptris::XML::FFI::NODE_ELEMENT)
         break
       end
       ptr = Leptris::XML::FFI.leptris_node_next_sibling(ptr)
@@ -208,12 +213,34 @@ class Leptris::XML::Node
   end
 
   def last_element_child
+    # Element receivers: the element-only batch fetches pointers
+    # without wrapping any text child; only the last is wrapped.
+    if is_a?(Leptris::XML::Element)
+      kids = Leptris::XML::FFI.fetch_element_children(@c_ptr)
+      return nil if kids.empty?
+      return Leptris::XML::Node.wrap(
+        kids.last, @document, parent: self,
+        node_type: Leptris::XML::FFI::NODE_ELEMENT)
+    end
     children.reverse_each.find(&:element?)
   end
 
   def element_children
     return @element_children if memo_hit?(@element_children_version)
-    result = children.select(&:element?)
+    ensure_alive!
+    # Element receivers ride the element-only batch: text/comment
+    # children are never wrapped (nor their get_type paid — the
+    # ELEMENT hint rides along). Other nodes keep the filter.
+    result =
+      if is_a?(Leptris::XML::Element)
+        parent = as_element_or_self
+        Leptris::XML::FFI.fetch_element_children(@c_ptr).map do |ptr|
+          Leptris::XML::Node.wrap(ptr, @document, parent: parent,
+                                  node_type: Leptris::XML::FFI::NODE_ELEMENT)
+        end
+      else
+        children.select(&:element?)
+      end
     if @document
       @element_children = result
       @element_children_version = @document.version

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

@@ -105,9 +105,21 @@ class Leptris::XML::SAX::Parser
     end
 
     if overridden?(:start_element)
-      s[:start_element] = callback(:void, [:pointer, :string, :pointer]) do |_, name, attrs_ptr|
-        attrs = walk_attr_array(attrs_ptr)
-        handler.start_element(utf8(name), attrs)
+      # Arity-declared interest: a start_element that takes exactly
+      # one argument declares name-only — the attr walk (2N pointer
+      # reads + N string pairs per start; 3.7x of an elements-only
+      # parse on the 1.9 MB stream) never runs. It is also the only
+      # way a 1-arg handler can receive events: the two-argument
+      # call raises ArgumentError.
+      if @document.method(:start_element).arity == 1
+        s[:start_element] = callback(:void, [:pointer, :string, :pointer]) do |_, name, _|
+          handler.start_element(utf8(name))
+        end
+      else
+        s[:start_element] = callback(:void, [:pointer, :string, :pointer]) do |_, name, attrs_ptr|
+          attrs = walk_attr_array(attrs_ptr)
+          handler.start_element(utf8(name), attrs)
+        end
       end
     end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.26
+  version: 1.9.28
 platform: aarch64-linux
 authors:
 - Ribose Inc.