leptris 1.9.43-aarch64-linux → 1.9.45-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3585b1f38f17d8a06b370034756a6eeccc78605843c1133f36bed7ff07d92f6f
-  data.tar.gz: 1170564a2c9bd8f49d6828491dae7bd9f803b477cab13bf665e2bc46708e4fa2
+  metadata.gz: bb8f4818b7cf8e077979539e52e40db4bec3463f19366502d810ad326f3e587b
+  data.tar.gz: 06d30447b248bcc443c89897d1b142c3139f92211ee1983eb847f63fb178268a
 SHA512:
-  metadata.gz: 8d1a742167a13771fe76e8c46f3b36b9eb7bc9c02e639f548888e19de588f57e00a727ad4fb645daab0dadba444ec22144e4829ff496a82707efb0c76e30e19e
-  data.tar.gz: ac245cc32da208680784662259db2a625b5f5a9d2ed252b1884fe5f20c31d8e861c6b68bb5d247c9ad7052ed28dd2b10f77bbae354f3007f4114d61d90eaa618
+  metadata.gz: 32c7eef741a89b3fe823b39abe19e6046354a2a63f2e691c6deb4077629330ab84b7e9a449878c099181ffff785283ad5c71843ce5714667109855a8f67bb528
+  data.tar.gz: 361c6ae7a3866cd168924d6898ddadc1e8ec207fcc3a542c0f9b462eff3f96ec4d5e6a4abfc22a2995d6f88d4d95625a276d2c11c5ed5ba0dc1e69bdec7efb54

data/CHANGELOG.md

@@ -5,6 +5,64 @@ 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.45] - 2026-08-31
+
+### Added
+
+- **Element-face indent unit (leptris-ruby#109 residual 2)**:
+  `Element#to_xml(indent: 2, indent_text: "\t")` — the unit with
+  Nokogiri's element semantics, byte-identical to Nokogiri's
+  `Element#to_xml` on the same input. No element-level
+  ext-serialize entry exists yet, so the path copies the element
+  C-side into a fresh document (one pool allocation) and
+  serializes through the document ext entry without a declaration.
+  `indent_text: true` raises ArgumentError on elements — the
+  display form stays document-level. The element default is
+  unchanged.
+- **libleptris 1.9.23 lockstep**: XPath 2.0+ expression core
+  upstream (if/then/else, for-return, `to` ranges); audit 255/255,
+  no new C surface.
+
+### Known issue
+
+- **#109 residual 1 (text-bearing leaves lose the unit) is
+  engine-side and filed as leptris/leptris#658**: the fused-leaf
+  fast path (serialize.c ~1193) computes `indent * indent_spaces`
+  directly, bypassing `buffer_append_indent`'s unit branch — every
+  mixed-content leaf's line indent falls back to spaces while
+  element-only subtrees get the unit. Two-line C fix (route the
+  fused lead through the unit); the binding adopts it in the next
+  lockstep.
+
+## [1.9.44] - 2026-08-31
+
+### Added
+
+- **libleptris 1.9.19–1.9.22 lockstep** (audit 255/255, three new
+  symbols): the #653 hold is lifted — the reported parse
+  "regression" was an ill-formed fixture (stray `</y>`) plus a
+  stale-build bisect artifact; forced-clean rebuilds show 1.9.18
+  and 1.9.21+ identical on every well-formed shape (verified and
+  withdrawn on the issue).
+- **`Node#visit`** (upstream #645a, `leptris_node_visit`): one C
+  call over the subtree — elements yield `(node, true/false,
+  depth)` enter/leave pairs, other kinds once, depth from the
+  receiver; the document node walks the document chain. No
+  NodeSet, pointer array, or children memo per level — the leanest
+  full-subtree iteration the binding offers (#645a's walk lever;
+  consumers can now beat the children-recursion allocation floor).
+- **Indent unit with Nokogiri semantics (leptris-ruby#109,
+  upstream #633)**: `to_xml(indent: 2, indent_text: "\t")` — the
+  unit string replaces the default spaces, repeated `indent`
+  times per depth level, standard layout otherwise
+  (byte-identical to Nokogiri's output modulo their trailing
+  newline, which moxml normalizes). `indent_text: true` keeps the
+  display form; `false` the default. Wired through the sized
+  ext-serialize entry (PR #107's substance — the audit requires it
+  attached with the lockstep, so it rides here; the engine emits
+  one unit copy per level and the binding multiplies unit x indent
+  to reach Nokogiri's repeat count).
+
 ## [1.9.43] - 2026-08-31
 
 ### Fixed

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.18"
+LIBLEPTRIS_VERSION = "1.9.23"
 
 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.43"
+  VERSION = "1.9.45"
 end

data/lib/leptris/xml/document.rb

@@ -266,13 +266,21 @@ class Leptris::XML::Document
   end
   alias_method :internal_subset, :doctype
 
-  # indent_text: true selects the display form (libleptris 1.9.9,
-  # #129): text and mixed content indent too — the output is
-  # display-oriented and not round-trip-guaranteed.
+  # indent_text selects the ext-serializer knob (libleptris 1.9.22):
+  # a STRING is the indent unit with Nokogiri's semantics — the unit
+  # replaces the default spaces, one copy per depth level, standard
+  # layout (requires indent > 0); true selects the display form
+  # (1.9.9 #129 — text and mixed content indent too; output is
+  # display-oriented and not round-trip-guaranteed).
   def to_xml(indent: 0, no_decl: false, encoding: nil, indent_text: false)
     raise Leptris::XML::UseAfterFreeError if @freed.state == :freed
     return "" if @c_ptr.nil?
-    if indent_text
+    case indent_text
+    when String
+      return Leptris::XML::Serialization.to_xml_indent_unit(
+        @c_ptr, indent_text, indent: indent, no_decl: no_decl,
+        encoding: encoding)
+    when true
       return Leptris::XML::Serialization.to_xml_display(
         @c_ptr, indent: indent, no_decl: no_decl, encoding: encoding)
     end

data/lib/leptris/xml/element.rb

@@ -358,7 +358,18 @@ class Leptris::XML::Element < Leptris::XML::Node
     end.join
   end
 
-  def to_xml(indent: 0, no_decl: false, encoding: nil)
+  # indent_text: a STRING is the indent unit with Nokogiri's
+  # semantics (leptris-ruby#109; via a C-side copy into a fresh
+  # document — no element-level ext entry exists yet). true is NOT
+  # supported here: the display form is document-level.
+  def to_xml(indent: 0, no_decl: false, encoding: nil, indent_text: false)
+    if indent_text == true
+      raise ArgumentError,
+        "indent_text: true (display form) is document-level — " \
+        "pass the unit string for elements"
+    end
+    return Leptris::XML::Serialization.to_xml_element_unit(
+      self, indent_text, indent: indent) if indent_text.is_a?(String)
     Leptris::XML::Serialization.to_xml(
       Leptris::XML::FFI.method(:leptris_element_serialize_into), @c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)

data/lib/leptris/xml/ffi.rb

@@ -72,10 +72,13 @@ module Leptris
           :encoding, :pointer
       end
 
-      # LeptrisSerializeExtOptions (1.9.9, #129): display-form
-      # serialization knobs beyond the ABI-frozen options struct.
+      # LeptrisSerializeExtOptions (1.9.9 #129 display form; 1.9.22
+      # #633/#109 indent unit): knobs beyond the ABI-frozen options
+      # struct. MAY grow — always pass its size through the sized
+      # entry.
       class SerializeExtStruct < ::FFI::Struct
-        layout :indent_text, :int
+        layout :indent_text, :int,
+               :indent_unit, :pointer
       end
 
       # Mirrors LeptrisParseOptions (libleptris >= 1.9.0 carries the
@@ -154,6 +157,12 @@ module Leptris
       # 1.9.7, upstream #580; the libxml2 model).
       attach_function :leptris_document_node,
         [:leptris_document], :leptris_node_ref
+      # Wrap-free subtree visitation (1.9.20, upstream #645a):
+      # enter/leave pairs for elements, depth from the walk's root,
+      # one C call — no NodeSet/Array churn per level. The document
+      # node walks the document child chain.
+      attach_function :leptris_node_visit,
+        [:leptris_node_ref, :pointer, :pointer], :void
       # Document-level PIs (v1.6.0): not tree nodes — enumerate via
       # these accessors only.
       attach_function :leptris_document_pi_count,
@@ -646,6 +655,11 @@ module Leptris
       # read_owned_string (the seam frees it).
       attach_function :leptris_document_serialize_ext,
         [:leptris_document, :pointer, :pointer], :pointer
+      # Sized variant (1.9.19, upstream #644 — leptris-ruby PR #107):
+      # passing our ext-struct size keeps the engine from reading
+      # past this binding's allocation (the MSVC segfault).
+      attach_function :leptris_document_serialize_ext_sized,
+        [:leptris_document, :pointer, :pointer, :size_t], :pointer
       attach_function :leptris_document_serialize_into,
         [:leptris_document, :pointer, :size_t, :pointer, :pointer], :size_t
       attach_function :leptris_document_get_dtd,

data/lib/leptris/xml/node.rb

@@ -273,6 +273,31 @@ class Leptris::XML::Node
   end
   alias_method :remove, :unlink
 
+  # Visits the subtree with ONE C call (leptris_node_visit,
+  # libleptris 1.9.20 — upstream #645a): elements yield twice —
+  # (node, true, depth) before their children, (node, false, depth)
+  # after the subtree completes — every other kind once with
+  # entering=true; depth counts element levels from the receiver.
+  # No NodeSet, pointer array, or children memo per level: the
+  # leanest full-subtree iteration the binding offers (a document
+  # receiver walks the document child chain). The walk is read-only
+  # — mutate only between visits.
+  #
+  #     root.visit { |node, entering, depth| ... }
+  def visit(&block)
+    return enum_for(:visit) unless block
+    ensure_alive!
+    document = @document
+    visitor = ::FFI::Function.new(
+      :void, [:pointer, :pointer, :int, :int], blocking: true) do |_, node_ptr, entering, depth|
+      block.call(
+        Leptris::XML::Node.wrap(node_ptr, document),
+        entering == 1, depth)
+    end
+    Leptris::XML::FFI.leptris_node_visit(@c_ptr, visitor, nil)
+    self
+  end
+
   # Walks the subtree in post-order DFS (matches Nokogiri's
   # semantics): the receiver, its descendants, nothing else.
   #

data/lib/leptris/xml/serialization.rb

@@ -47,8 +47,28 @@ module Leptris::XML::Serialization
   def self.to_xml_display(c_ptr, indent: 0, no_decl: false, encoding: nil)
     opts, encoding_anchor = build_options(
       indent: indent, no_decl: no_decl, encoding: encoding)
-    str_ptr = Leptris::XML::FFI.leptris_document_serialize_ext(
-      c_ptr, opts.pointer, INDENT_TEXT_EXT.pointer)
+    str_ptr = Leptris::XML::FFI.leptris_document_serialize_ext_sized(
+      c_ptr, opts.pointer, INDENT_TEXT_EXT.pointer, INDENT_TEXT_EXT.size)
+    Leptris::XML::FFI.read_owned_string(str_ptr)
+  end
+
+  # Indent-unit serialization (libleptris 1.9.22, #633 —
+  # leptris-ruby#109): Nokogiri's indent_text semantics — the unit
+  # string replaces the default spaces, repeated `indent` times per
+  # depth level, standard layout otherwise. The engine emits ONE
+  # copy of the unit string per level (options->indent is ignored
+  # when a unit is set), so the binding multiplies unit x indent to
+  # reach Nokogiri's repeat count.
+  def self.to_xml_indent_unit(c_ptr, unit, indent: 0, no_decl: false,
+                              encoding: nil)
+    opts, encoding_anchor = build_options(
+      indent: indent, no_decl: no_decl, encoding: encoding)
+    ext = Leptris::XML::FFI::SerializeExtStruct.new
+    unit_anchor = ::FFI::MemoryPointer.from_string(
+      indent.positive? ? unit.to_s * indent : unit.to_s)
+    ext[:indent_unit] = unit_anchor
+    str_ptr = Leptris::XML::FFI.leptris_document_serialize_ext_sized(
+      c_ptr, opts.pointer, ext.pointer, ext.size)
     Leptris::XML::FFI.read_owned_string(str_ptr)
   end
 
@@ -75,6 +95,28 @@ module Leptris::XML::Serialization
     string.gsub(ESCAPE_TEXT_RE, ESCAPE_TEXT)
   end
 
+  # Element-face indent unit (leptris-ruby#109 residual 2): no
+  # element-level ext-serialize entry exists yet, so the unit path
+  # copies the element into a fresh document (C-side copy, one
+  # pool allocation), serializes that document without a
+  # declaration, and returns the subtree — identical output to the
+  # element serializer for the standard layout, with the unit.
+  def self.to_xml_element_unit(element, unit, indent: 0)
+    document = Leptris::XML::Document.create
+    begin
+      copy_ptr = Leptris::XML::FFI.leptris_element_copy(
+        element.c_ptr, document.c_ptr)
+      if copy_ptr.null?
+        raise Leptris::XML::Error, "leptris_element_copy failed"
+      end
+      document.root = Leptris::XML::Node.wrap(copy_ptr, document)
+      to_xml_indent_unit(document.c_ptr, unit,
+                         indent: indent, no_decl: true)
+    ensure
+      document.free
+    end
+  end
+
   # Builds a SerializeOptions struct. Returns [opts, encoding_anchor];
   # the anchor must stay referenced while opts is in an FFI call.
   def self.build_options(indent: 0, no_decl: false, encoding: nil)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.43
+  version: 1.9.45
 platform: aarch64-linux
 authors:
 - Ribose Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-30 00:00:00.000000000 Z
+date: 2026-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi