leptris 1.9.31 → 1.9.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 61af1b12021e7a1cf22f04004ea36d27df6f740ff135d039854c51497abf87f3
-  data.tar.gz: 0a842331a02a988b8bfce2920f8878b87c5ff5fdbd4c471f2f04694f4a1b3465
+  metadata.gz: '01791cd8ecc5e2c7b472ac0333ae89ab338d6fa8872a55f724cafe708f866f2b'
+  data.tar.gz: 00d0115424789446417bce8b22d35a8b1f23883c17dd135f4a4e8d0d8ba19aa1
 SHA512:
-  metadata.gz: e832da72a4e2fe0ddede057023c1e981705a41f196d85e7d7e5d61051d524bddfc2305065fef940ef60af48b87e978bc46be7e61030d598de83fb916db8bba3e
-  data.tar.gz: 7a266c15d5983229591bf414ad0dde95cc93018ba01388bf721f98977c026c164797e1dc805fc9a46625a6b2037c7709a65cb0e0640ca5ed6c46f40614dd37c0
+  metadata.gz: a8d17f3f61f0317d9165a57e6ecf134cb22751c23f5fd39a669e9df7f6fa414e780a52ab55f7bd549c1ea10ae8cfa6d0fad6fe44f9b092ac581974d391cfa521
+  data.tar.gz: 2842e82675cba9aad3bc4bb859e1a85a78043b3b81b4eebf2d7c0afab4df3abacb01ddc56144d0bec96bd3473d5ad31bff9dc4beef31c2639282c9f7c55b84f1

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.33] - 2026-08-28
+
+### Changed
+
+- **Cached namespace binding sets**: every namespaced query
+  previously built its binding set from scratch (flatten the hash,
+  allocate the CStringArray wire format, `ns_set_new_from_pairs`,
+  eval, free) — ~6.7 µs of construction, 2.6× the same query
+  without namespaces on a small document. The XPath VM reads the
+  set as a const map during evaluation (vm.c) and never mutates
+  it, so sets are now cached per distinct prefix/URI vocabulary and
+  shared across queries and threads. Measured: namespaced
+  `//x:rect` 10.9 -> **6.9 µs per query (-38%)**; `at_xpath` -26%.
+  Single-pair key fast path; failed builds raise before caching;
+  symbol- and string-keyed hashes share one entry. The remaining
+  gap vs no-namespace queries is the VM's prefix resolution.
+
+## [1.9.32] - 2026-08-28
+
+### Fixed
+
+- **traverse is subtree-bounded (leptris-ruby#89)**: the C walker
+  was never bounded — after visiting the receiver it pushed the
+  receiver's next sibling and continued to the end of the document
+  chain, so `element.traverse` swept following siblings and their
+  subtrees, and `root.traverse` swept the epilog. In post-order the
+  receiver is the LAST node of its own subtree, so the callback now
+  returns non-zero at self — the C loop honors it and the walk
+  stops exactly at the boundary.
+- **traverse re-raises callback exceptions (leptris-ruby#90)**: a
+  rescue inside the FFI callback stashes the exception and returns
+  non-zero (aborting the walk); the stashed exception is re-raised
+  after `leptris_node_traverse` returns. Previously the dispatch
+  silently swallowed Ruby exceptions and the walk continued with
+  partially processed data.
+- **built documents list the attached root (leptris-ruby#91)**:
+  libleptris's `document_set_root` does not register the root into
+  the document node's child chain, so `Document#children` missed it
+  until another document mutation refreshed the chain. `#children`
+  now splices the attached root in: a replaced root's stale chain
+  entry is dropped and the new root inherits its position (the
+  prolog/epilog split follows the old slot); on rootless chains
+  placement falls back to document-order comparison. Parsed and
+  built documents read the same.
+- **document-level PI writes name the contract (leptris-ruby#92)**:
+  parse-created document-level PIs carry no document linkage in
+  libleptris, so `target=`/`data=` fail INVALID_ARG and `unlink`
+  NOT_FOUND while tree-level and `Document#add_pi` PIs mutate fine.
+  Those failures now raise a descriptive error naming the contract
+  (mutable alternatives included) instead of a bare "Invalid
+  argument". Full write-through and a remove API need C surface
+  (filed upstream); the binding cannot supply them.
+
 ## [1.9.31] - 2026-08-28
 
 ### Fixed

data/lib/leptris/version.rb

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

data/lib/leptris/xml/document.rb

@@ -166,9 +166,44 @@ class Leptris::XML::Document
   # The document's children, via the document node: prolog
   # comments/PIs, the root element, epilog comments/PIs, in
   # document order (Nokogiri-parity shape).
+  #
+  # On programmatically built documents the C document node's chain
+  # misses a root attached via #root= until some other document
+  # mutation refreshes it (leptris-ruby#91 — libleptris's
+  # document_set_root does not register into the chain). The merge
+  # below splices the attached root in by document order whenever
+  # the chain lacks it, so parsed and built documents read the
+  # same. Prolog/epilog placement uses node_compare against the
+  # root.
   def children
     doc_node = node
-    doc_node ? doc_node.children : Leptris::XML::NodeSet.new(self, [])
+    return Leptris::XML::NodeSet.new(self, []) if doc_node.nil?
+    kids = doc_node.children.to_a
+    root_ptr = Leptris::XML::FFI.leptris_document_root(@c_ptr)
+    return kids if root_ptr.null?
+    return kids if kids.any? { |child| child.c_ptr == root_ptr }
+    root = Leptris::XML::Node.wrap(root_ptr, self)
+    # A replaced root stays in the C chain until another document
+    # mutation refreshes it — the chain's element slots other than
+    # the current root are stale old roots. The new root inherits
+    # the first stale slot's position (the prolog/epilog split
+    # follows where the old root sat); with no stale element
+    # (programmatically built documents) placement falls back to
+    # document-order comparison.
+    stale = kids.select do |child|
+      child.element? && child.c_ptr != root_ptr
+    end
+    if stale.any?
+      kept = kids.reject { |child| stale.include?(child) }
+      slot = kids.index(stale.first)
+      kept.insert(slot, root)
+      Leptris::XML::NodeSet.new(self, kept)
+    else
+      prolog, epilog = kids.partition do |child|
+        Leptris::XML::FFI.leptris_node_compare(child.c_ptr, root_ptr).negative?
+      end
+      Leptris::XML::NodeSet.new(self, prolog + [root] + epilog)
+    end
   end
 
   # Attach +element+ as the document's root element. The element must

data/lib/leptris/xml/ffi.rb

@@ -800,21 +800,37 @@ module Leptris
 
       # Namespace-binding lifecycle, written once: flatten the
       # prefix/URI hash into the alternating CStringArray wire
-      # format, build the caller-owned set, yield it, free it under
-      # all outcomes. Every eval variant uses this; none of them
-      # knows how a set is born or dies.
+      # format and build the C set. Sets are cached per distinct
+      # vocabulary: the XPath VM reads the set as a const map
+      # during evaluation (vm.c) and never mutates it, so one set
+      # serves the process across queries and threads — building
+      # the wire format plus a C set per query cost ~6.7 µs, 2.6×
+      # a no-namespace query on a small document. Cached sets are
+      # never freed (bounded by the process's distinct namespace
+      # vocabularies — the same trade the CSS translation cache
+      # makes). Failed builds raise before caching.
+      NS_SET_CACHE = {}
+
       def self.with_ns_set(hash)
-        flat = hash.flat_map { |prefix, uri| [prefix.to_s, uri.to_s] }
-        buffer, _anchors = Leptris::XML::CStringArray.to_c(flat)
-        set = leptris_xpath_ns_set_new_from_pairs(buffer, flat.length / 2)
-        if set.null?
-          raise Leptris::XML::Error,
-            "leptris_xpath_ns_set_new_from_pairs failed"
-        end
-        begin
-          yield set
-        ensure
-          leptris_xpath_ns_set_free(set)
+        yield ns_set_for(hash)
+      end
+
+      def self.ns_set_for(hash)
+        pairs = hash.map { |prefix, uri| [prefix.to_s, uri.to_s] }
+        key = if pairs.size == 1
+                "#{pairs[0][0]}\x00#{pairs[0][1]}"
+              else
+                pairs.sort.join("\x00")
+              end
+        NS_SET_CACHE.fetch(key) do
+          flat = pairs.flatten
+          buffer, _anchors = Leptris::XML::CStringArray.to_c(flat)
+          set = leptris_xpath_ns_set_new_from_pairs(buffer, flat.length / 2)
+          if set.null?
+            raise Leptris::XML::Error,
+              "leptris_xpath_ns_set_new_from_pairs failed"
+          end
+          NS_SET_CACHE[key] = set
         end
       end
 

data/lib/leptris/xml/node.rb

@@ -263,27 +263,56 @@ class Leptris::XML::Node
 
   def unlink
     ensure_writable!
-    Leptris::XML::FFI.check_status(
-      Leptris::XML::FFI.leptris_node_unlink(@c_ptr))
+    rc = Leptris::XML::FFI.leptris_node_unlink(@c_ptr)
+    if rc == Leptris::XML::FFI::LEPTRIS_ERROR_NOT_FOUND && processing_instruction?
+      raise Leptris::XML::Error,
+        Leptris::XML::ProcessingInstruction::READ_ONLY_NATIVE
+    end
+    Leptris::XML::FFI.check_status(rc)
     @parent = nil
     self
   end
   alias_method :remove, :unlink
 
-  # Walks the subtree in post-order DFS (matches Nokogiri's semantics).
+  # Walks the subtree in post-order DFS (matches Nokogiri's
+  # semantics): the receiver, its descendants, nothing else.
   #
   # One FFI call dispatches the whole walk; the C engine invokes the
   # callback once per visited node (the only per-node cost is the
   # C-to-Ruby callback dispatch, not FFI round-trips).
+  #
+  # Subtree-bounded by abort-at-self (leptris-ruby#89): the C
+  # walker was never bounded — after visiting the receiver it
+  # pushes the receiver's NEXT SIBLING and continues to the end of
+  # the document chain. In post-order the receiver is the LAST
+  # node of its own subtree, so returning non-zero at self stops
+  # the walk exactly at the boundary (the C loop honors a non-zero
+  # callback return). The self comparison is by address; the
+  # receiver's handle is stable for the walk's duration.
+  #
+  # Exceptions raised by the block are re-raised after the walk
+  # (leptris-ruby#90): a rescue inside the callback stashes the
+  # exception and returns non-zero, aborting the C walk — without
+  # it the FFI dispatch silently swallowed the exception and the
+  # walk continued with partially processed data.
   def traverse
     return enum_for(:traverse) unless block_given?
     ensure_alive!
+    error = nil
+    self_address = @c_ptr.address
     callback = ::FFI::Function.new(:int, [:pointer, :pointer], blocking: true) do |node_ptr, _|
-      yield Leptris::XML::Node.wrap(node_ptr, @document)
-      0
+      begin
+        yield Leptris::XML::Node.wrap(node_ptr, @document)
+        node_ptr.address == self_address ? 1 : 0
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        error = e
+        1
+      end
     end
     Leptris::XML::FFI.leptris_node_traverse(
       @c_ptr, Leptris::XML::FFI::TRAVERSE_POST_ORDER, callback, nil)
+    raise error if error
+    self
   end
 
   def path

data/lib/leptris/xml/processing_instruction.rb

@@ -25,17 +25,34 @@ class Leptris::XML::ProcessingInstruction < Leptris::XML::Node
     result
   end
 
+  # Parse-created document-level PIs carry no document linkage in
+  # libleptris (leptris-ruby#92): the C setters reject them with
+  # INVALID_ARG while tree-level and Document#add_pi PIs mutate
+  # fine. Map that failure to the contract instead of a bare
+  # "Invalid argument".
+  READ_ONLY_NATIVE =
+    "this PI is a parse-created document-level PI — its node has " \
+    "no document linkage in libleptris, so target/data cannot be " \
+    "written and it cannot be unlinked (leptris-ruby#92); " \
+    "tree-level and Document#add_pi PIs are mutable"
+
   def target=(new_target)
     ensure_writable!
-    Leptris::XML::FFI.check_status(
-      Leptris::XML::FFI.leptris_pi_node_set_target(@c_ptr, new_target.to_s))
+    rc = Leptris::XML::FFI.leptris_pi_node_set_target(
+      @c_ptr, new_target.to_s)
+    raise Leptris::XML::Error, READ_ONLY_NATIVE if
+      rc == Leptris::XML::FFI::LEPTRIS_ERROR_INVALID_ARG
+    Leptris::XML::FFI.check_status(rc)
     new_target
   end
 
   def data=(new_data)
     ensure_writable!
-    Leptris::XML::FFI.check_status(
-      Leptris::XML::FFI.leptris_pi_node_set_data(@c_ptr, new_data.to_s))
+    rc = Leptris::XML::FFI.leptris_pi_node_set_data(
+      @c_ptr, new_data.to_s)
+    raise Leptris::XML::Error, READ_ONLY_NATIVE if
+      rc == Leptris::XML::FFI::LEPTRIS_ERROR_INVALID_ARG
+    Leptris::XML::FFI.check_status(rc)
     new_data
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.31
+  version: 1.9.33
 platform: ruby
 authors:
 - Ribose Inc.