leptris 1.9.31-x86_64-linux → 1.9.32-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd0e0707b4347bc6678ac23d73051751a9c5f6103491f1b3289ad125555416b6
-  data.tar.gz: b3bb1712dd508747336326e9fc7d32ed031c5e13f3b77993b288ae6379c48d75
+  metadata.gz: e0126843719aa5ffea0bfe6d60e13a57f6a4e8dc1ac0cd92f0c91b203ee5853a
+  data.tar.gz: 50678d08aa8cba33138d447731cd267e0a3ca7be7df4f7a5a9121a5e7bc98de8
 SHA512:
-  metadata.gz: b9fcbf20769ee53bc6b6586491c47bcc8f72ba870aeb260c62c0bba7b2b55b6c0c937cc0e9873345d7997e8842455d50078ff7618231010d2fc958c1233734ef
-  data.tar.gz: 9286711bda1ce1609ff52b7c9edf7c97871380f341b84b15f0ecad0101a63244779aa32b042b2c02e541208f4a0e14ea89d4e0ca49175473a82d1058100757e2
+  metadata.gz: 33976c129c10325e338a9fcfb0df286cb99bbcb5a5fe5541fdf0b310d2a7c42babc5704cc60f7dce61eb5bbe399fd65d059cbee97f0e91303bb580ba1ff8fbc3
+  data.tar.gz: 5939d862df5f8e412815219962d7261dbf533d8ed0ee3d038cd4a0961d4c97d8ac8addf67c58db80f5b64fbd5e753eac0ee36323aabfb3938a0558fd550b643c

data/CHANGELOG.md

@@ -5,6 +5,42 @@ 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.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.32"
 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/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.32
 platform: x86_64-linux
 authors:
 - Ribose Inc.