leptris 1.9.10-aarch64-linux → 1.9.12-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: efe9c8c8dcce3172320cb136460cbb5be0cc2ccbecdfc4fc121c0d497dbf1c3e
-  data.tar.gz: 76d3ddb87586fd9bbffe7b6b19d4cce8054d7573f27cec48db41f4c4e16740f5
+  metadata.gz: cf80f624ccd37fd9495e26c150943bc07923b82fd3e96eacb0d115d2a2651f5d
+  data.tar.gz: f7974a661b342dacb962a6e92bc7c9634d3a606b0ab1c2300262c469420b4bd2
 SHA512:
-  metadata.gz: 9693e537dbb31e512481cc007cc9552ae72f0c32e5c529c8c96027fc83bbe89014c84ff60805a90203991c0dbb33e35ac214f9b4460445bb5d493d5538cd7b03
-  data.tar.gz: c810827e0feb0e1f0f5b85f1cf776ec208356149840a0ac7df90dce95113b67c7d7fe36948d4643117dd612c239273d64cd022dc029df727f01a37c857984145
+  metadata.gz: b4524b049a05c7dffe328ccb16742dede857b442b8dc5443ceddb9aad27c9b71ea7ab02bcf7d0d6b6fc724828587b3557d11042b939c15c97727d7ed048384e2
+  data.tar.gz: 74811080bd538e8b9023de303cbca5ade92c6005cb76aebd72e548c44b9504fae44dfa44055b7d34d2e157c5b779a330cc5da2c875fc485574728fcaaf237e26

data/CHANGELOG.md

@@ -5,6 +5,59 @@ 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.12] - 2026-08-27
+
+### Changed
+
+- **NodeSet#each materializes on the first pass**: the lazy batch
+  fetch builds the array while yielding; every later each/[]/length
+  serves from it. Iterating twice without an explicit to_a paid the
+  batch twice — measured 0.220 s -> 0.127 s (42%) on the repeated-
+  iteration loop, now matching the materialized shape.
+- **Leaner memo guard**: `readonly_cached?` checks ivar presence
+  alone — memo presence proves readonly, because every memo site
+  assigns only under readonly and readonly is one-way. Saves a
+  document round-trip on every memoized read; the harness's
+  readonly loops drop another 22-45% (attrs 0.078 -> 0.061 s,
+  namespaces 0.033 -> 0.018 s, content 0.066 -> 0.037 s).
+
+### Measured and rejected
+
+- SAX bulk pointer read for attribute pairs: a bulk read needs a
+- counting pass first, which adds calls to a one-pass walk — no
+  win, withdrawn on inspection.
+- Unconditional writable-content memoization and version-stamp
+  memoization (see the round-X report): invalidation completeness
+  and a compare costing the read, respectively.
+
+## [1.9.11] - 2026-08-26
+
+### Changed
+
+- **Readonly `Element#[]` serves from the memoized attributes
+  hash** (materializing on demand): repeated reads become hash
+  lookups — no FFI dispatch, no lifetime guard. Completes the
+  readonly contract on its hottest member. Writable documents keep
+  the direct path (values can change).
+- **Materialized NodeSets stop re-batching**: `each`, `[]`, and
+  `length` consult the materialized array first; iterating or
+  indexing after `to_a` no longer re-pays the count + fetch + wrap
+  pass. Repeated iteration measures 2.4x faster.
+- **NodeSet negative indexes are consistent**: `ns[-1]` answers the
+  last element for lazy and eager sets alike (Ruby-Array slice
+  semantics, Nokogiri parity); previously only eager sets
+  supported them.
+- **SAX start_element attributes build pairs in one pass** — no
+  intermediate flat string array or each_slice enumerator per
+  event (~13% on the SAX parse loop).
+
+### Measured and rejected
+
+- A compiled-expression cache for ad-hoc xpath (the round's main
+  hypothesis): compiled vs ad-hoc eval measured within 2.5% on
+  500-member loops — the engine's expression parse is effectively
+  free. Killed before implementation.
+
 ## [1.9.10] - 2026-08-26
 
 ### Changed

data/lib/leptris/version.rb

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

data/lib/leptris/xml/element.rb

@@ -32,6 +32,14 @@ class Leptris::XML::Element < Leptris::XML::Node
   end
 
   def [](key)
+    # Readonly: the attributes hash cannot go stale (ADR 0003) and
+    # materializes on demand — repeated reads become hash lookups,
+    # with no dispatch and no lifetime guard (a hash read cannot
+    # use-after-free).
+    if @document&.readonly?
+      cached = attributes[key.to_s]
+      return cached.nil? ? nil : cached.value
+    end
     ensure_alive!
     Leptris::XML::FFI.leptris_element_attribute(@c_ptr, key.to_s)
   end

data/lib/leptris/xml/node.rb

@@ -264,8 +264,11 @@ class Leptris::XML::Node
 
   protected
 
+  # Memo presence alone proves readonly: every memo site assigns
+  # only under readonly, and readonly is one-way — so the guard
+  # saves the document round-trip on every memoized read.
   def readonly_cached?(ivar)
-    @document&.readonly? && instance_variable_defined?(ivar)
+    instance_variable_defined?(ivar)
   end
 
   def as_element_or_self

data/lib/leptris/xml/node_set.rb

@@ -41,7 +41,8 @@ class Leptris::XML::NodeSet
   end
 
   def length
-    @result_ptr ? Leptris::XML::FFI.leptris_xpath_result_count(@result_ptr) : @array.length
+    return @array.length if @array
+    @result_ptr ? Leptris::XML::FFI.leptris_xpath_result_count(@result_ptr) : 0
   end
   alias_method :size, :length
 
@@ -49,53 +50,63 @@ class Leptris::XML::NodeSet
     length == 0
   end
 
+  # The materialized array (after to_a) is authoritative: every
+  # reader consults it first so a materialized set stops paying the
+  # batch fetch on each iteration or index.
   def [](idx)
+    return @array[idx] if @array
+    # Negative indexes are Ruby-Array semantics (Nokogiri's NodeSet
+    # is slice-like); materialize rather than answer nil
+    # inconsistently with an eager set.
+    return to_a[idx] if idx.negative?
     if @result_ptr
       return nil if idx < 0 || idx >= length
       ptr = Leptris::XML::FFI.leptris_xpath_result_get_node(@result_ptr, idx)
       return nil if ptr.null?
       Leptris::XML::Node.wrap(ptr, @document)
-    else
-      @array[idx]
     end
   end
 
+  # Iteration materializes: the first pass batch-fetches into @array
+  # (yielding as it wraps), and every subsequent reader — each, [],
+  # length — serves from the array. Repeated iteration without an
+  # explicit to_a pays the batch exactly once.
   def each
     return enum_for(:each) unless block_given?
-    if @result_ptr
-      # Batch-fetch all node pointers through the FFI seam
-      # (leptris_xpath_result_get_nodes_ex copies every node kind,
-      # not just elements) and wrap each. Wrappers are cached
-      # per-Document via Node.wrap, so re-iteration of the same
-      # NodeSet hits it.
+    unless @array
+      return self unless @result_ptr
       n = length
       if n > 0
+        # Batch-fetch all node pointers through the FFI seam
+        # (leptris_xpath_result_get_nodes_ex copies every node kind,
+        # not just elements); the batch accessor under-copies
+        # mixed-kind results (upstream leptris#477), so per-index
+        # fetch covers the remainder.
         pointers = Leptris::XML::FFI.fetch_result_nodes(@result_ptr, n)
+        nodes = []
         pointers.each do |ptr|
           next if ptr.null?
-          yield Leptris::XML::Node.wrap(ptr, @document)
+          nodes << Leptris::XML::Node.wrap(ptr, @document)
         end
-        # The batch accessor under-copies mixed-kind results (upstream
-        # leptris#477); fall back to per-index fetch for the remainder.
         (pointers.length...n).each do |i|
           ptr = Leptris::XML::FFI.leptris_xpath_result_get_node(@result_ptr, i)
           next if ptr.null?
-          yield Leptris::XML::Node.wrap(ptr, @document)
+          nodes << Leptris::XML::Node.wrap(ptr, @document)
         end
+        @array = nodes
+      else
+        @array = []
       end
-    else
-      @array.each { |n| yield n }
     end
+    @array.each { |n| yield n }
     self
   end
 
   def to_a
     return @array if @array
     return [] if @result_ptr.nil?
-    out = []
-    each { |n| out << n }
-    @array = out  # memoize so subsequent to_a / each avoids re-fetch
-    out
+    each { |n| }  # materializes @array as a side effect
+    @array
   end
   alias_method :to_ary, :to_a
 

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

@@ -148,8 +148,19 @@ class Leptris::XML::SAX::Parser
   end
 
   # The C `const char** attrs` is a NULL-terminated flat array of
-  # name/value pairs; CStringArray owns the format, we slice into pairs.
+  # name/value pairs. Build the [name, value] pairs in one pass —
+  # no intermediate flat string array, no each_slice enumerator.
   def walk_attr_array(attrs_ptr)
-    Leptris::XML::CStringArray.to_ruby(attrs_ptr).each_slice(2).to_a
+    ptr_size = ::FFI.type_size(:pointer)
+    pairs = []
+    i = 0
+    loop do
+      name_ptr = attrs_ptr.get_pointer(i * ptr_size)
+      break if name_ptr.null?
+      value_ptr = attrs_ptr.get_pointer((i + 1) * ptr_size)
+      pairs << [utf8(name_ptr.read_string), utf8(value_ptr.read_string)]
+      i += 2
+    end
+    pairs
   end
 end

metadata

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