leptris 1.9.39 → 1.9.40

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 21a0f9d2bf7f1c6758b6e2e31dcb66e0e5a11bf40580608cb02834cf80685785
-  data.tar.gz: a7581350e1b5838a4d3d2c35e4ed6b73b3944709b9ff8e171dcdcc0d1d67181c
+  metadata.gz: 63ca61bcacf68aee02e3fb94c53f84d64af4474cf5b250482135a632b5ac2009
+  data.tar.gz: 269dd93a547a099a5eb0685f9d58ecfa2d281d373f969cc8e69a7cd6aece5614
 SHA512:
-  metadata.gz: 5a824a978fbe93bee62dd9cf760305e320dbf0c537a764be413368f2ff77203c777b33dc9e27fb09c6252e0583084e1b4488d91050a47204ce0c6963b01a80cc
-  data.tar.gz: e96ca075b15efc6dccc627ee01413cc4fb98be27ab351599e7e1348a1b833023fdc2ce04cae5fedf8ccd1b26b0066c140b831f89ccf9cc7e044ff988cd3d89ca
+  metadata.gz: d908e6a85d409bae57e50703a87be059e984a67af44139769475f6baa82631894d9cbd26390442f32af54d2987242fee8bc528f70f52e0284692fd522cb2ea23
+  data.tar.gz: 9826c4922df24a0703eca6e39b8b6f62fe5c6deccdf5212b7e8bcc76897b74ce4cc587add6a95aa60324dcff538087cdc5bb5ba35e421a37ce0bc26a18237bad

data/CHANGELOG.md

@@ -5,6 +5,38 @@ 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.40] - 2026-08-30
+
+### Changed
+
+- **SAX delivers through the engine transports again** — the #95
+  attribute corruption is fixed upstream (libleptris 1.9.18,
+  verified on the issue fixture through both engine transports:
+  all 7 image attributes intact). `SAX::Parser` defaults to
+  `streaming: true`; `streaming: false` keeps the DOM-backed
+  dispatcher as a fallback for older engines. The correctness tax
+  is gone: all-events 119 ms and text-only 21.6 ms per big.xml
+  parse vs Nokogiri's 131/130 ms — SAX wins every shape outright
+  again, with correct data.
+- **libleptris 1.9.14–1.9.18 lockstep** (audit 253/253, three new
+  symbols): fixes for everything we were tracking upstream —
+  #625 (SAX attrs), #626 (MSVC non-ASCII names; the Windows spec
+  gate is removed), #627/#628/#630 (XSLT unknown fns and last();
+  relative namespaced descendant paths — spec added), #613
+  (latin-1), #608 (combined ns+vars eval; attached), #617
+  (node_children out_kinds; wired), #633 (pretty-print parity),
+  #635 (xmlns interleave; wired).
+- **Children batches carry kinds** (`leptris_node_children_ex`):
+  `#children` and the fragment/dispatch walks wrap with the kind
+  hint — no per-child get_type dispatch. Measured: the cold
+  full-tree walk's remaining gap vs Nokogiri (1.5x) is the Ruby
+  wrapper allocation floor, not type dispatch; noted for the
+  record.
+- **Exact xmlns interleave** (`leptris_element_attributes_raw`):
+  the DOM-backed fallback now reproduces the streaming contract's
+  byte-positioned declarations; the #99 spec is upgraded from
+  set-equality to exact order equality.
+
 ## [1.9.39] - 2026-08-29
 
 ### 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.13"
+LIBLEPTRIS_VERSION = "1.9.18"
 
 CMAKE_FLAGS = %w[
   -DCMAKE_BUILD_TYPE=Release
@@ -30,7 +30,17 @@ task :compile do
   mkdir_p(build)
   url = "https://api.github.com/repos/leptris/leptris/tarball/v#{version}"
   sh "curl -sL #{url} | tar xz -C #{build} --strip-components=1"
-  sh "cmake -B #{build}/build -S #{build} #{CMAKE_FLAGS.join(' ')}"
+  # libleptris 1.9.18's xslt_functions.c:270 assigns LeptrisElement
+  # to LeptrisNodeRef — GCC 14 (Alpine/musl) makes incompatible
+  # pointer types an error by default and the musl platform gems
+  # fail to build; clang toolchains only warn. Downgrade to warning
+  # until the upstream fix (leptris/leptris#640).
+  # No quoting: the flag carries no spaces, and single quotes are
+  # literal on Windows shells (they broke the MSVC build).
+  # GCC-family only — MSVC's cl rejects the flag outright (D8021).
+  cflags = Gem.win_platform? ? "" : "-Wno-error=incompatible-pointer-types"
+  sh "cmake -B #{build}/build -S #{build} " \
+     "#{CMAKE_FLAGS.join(' ')} #{cflags.empty? ? '' : "-DCMAKE_C_FLAGS=#{cflags}"}"
   sh "cmake --build #{build}/build --config Release -j 4"
   # Windows names the shared library leptris.dll (no "lib" prefix);
   # vendoring under the uniform libleptris.* name keeps the FFI

data/lib/leptris/version.rb

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

data/lib/leptris/xml/document_fragment.rb

@@ -25,8 +25,9 @@ class Leptris::XML::DocumentFragment
   end
 
   def children
-    nodes = Leptris::XML::FFI.fetch_children(@c_ptr).map do |ptr|
-      Leptris::XML::Node.wrap(ptr, @document)
+    pointers, kinds = Leptris::XML::FFI.fetch_children(@c_ptr)
+    nodes = Array.new(pointers.size) do |i|
+      Leptris::XML::Node.wrap(pointers[i], @document, node_type: kinds[i])
     end
     Leptris::XML::NodeSet.new(@document, nodes)
   end

data/lib/leptris/xml/ffi.rb

@@ -225,8 +225,17 @@ module Leptris
       # count-only query returning the TOTAL across every child kind.
       attach_function :leptris_node_children,
         [:leptris_node_ref, :pointer, :size_t], :size_t
+      # Children with out_kinds (1.9.18, upstream #617): the kind
+      # rides the batch, so wrappers skip the per-child get_type.
+      attach_function :leptris_node_children_ex,
+        [:leptris_node_ref, :pointer, :pointer, :size_t], :size_t
       # Element-only batch; mirror-only — fetch_children rides the
       # all-kind node_children above.
+      # Raw qname-ordered attribute list INCLUDING xmlns
+      # declarations at their byte positions (1.9.18, upstream
+      # #635) — the streaming SAX contract's mixed view.
+      attach_function :leptris_element_attributes_raw,
+        [:leptris_element, :pointer, :pointer, :size_t], :size_t
       attach_function :leptris_element_children,
         [:leptris_element, :pointer, :size_t], :size_t
       attach_function :leptris_node_as_element,
@@ -538,6 +547,11 @@ module Leptris
       attach_function :leptris_xpath_compiled_eval_vars,
         [:leptris_xpath_compiled, :leptris_document, :leptris_element,
          :leptris_xpath_var_set], :leptris_xpath_result
+      # Combined namespaces + variables (1.9.18, upstream #608).
+      attach_function :leptris_xpath_compiled_eval_ns_vars,
+        [:leptris_xpath_compiled, :leptris_document, :leptris_element,
+         :leptris_xpath_ns_set, :leptris_xpath_var_set],
+        :leptris_xpath_result
       # Source text of a compiled expression (owned by the handle).
       attach_function :leptris_xpath_compiled_text,
         [:leptris_xpath_compiled], :string
@@ -893,6 +907,9 @@ module Leptris
       FETCH_INITIAL = 32
       private_constant :FETCH_INITIAL
 
+      # Returns [pointers, kinds] — the kinds ride the batch
+      # (leptris_node_children_ex, 1.9.18 #617) so wrappers skip
+      # the per-child get_type dispatch.
       def self.fetch_children(c_ptr)
         scratch = (Thread.current[:leptris_scratch] ||= {})
         buffer = scratch[:pointers]
@@ -900,18 +917,57 @@ module Leptris
           buffer = scratch[:pointers] =
             ::FFI::MemoryPointer.new(:pointer, FETCH_INITIAL)
         end
+        # size the kinds buffer from the POINTERS buffer's capacity —
+        # it may have grown past FETCH_INITIAL on earlier use, and C
+        # writes one kind per copied child
         cap = buffer.size / PTR_BYTES
-        copied = leptris_node_children(c_ptr, buffer, cap)
+        kinds = scratch_ints(cap)
+        copied = leptris_node_children_ex(c_ptr, buffer, kinds, cap)
         if copied == cap
-          total = leptris_node_children(c_ptr, nil, 0)
+          total = leptris_node_children_ex(c_ptr, nil, nil, 0)
           if total > cap
             buffer.free
             buffer = scratch[:pointers] =
               ::FFI::MemoryPointer.new(:pointer, total)
-            copied = leptris_node_children(c_ptr, buffer, total)
+            kinds = scratch_ints(total)
+            copied = leptris_node_children_ex(c_ptr, buffer, kinds, total)
           end
         end
-        buffer.get_array_of_pointer(0, copied)
+        [buffer.get_array_of_pointer(0, copied),
+         kinds.get_array_of_int(0, copied)]
+      end
+
+      # Raw qname-ordered attribute pairs INCLUDING xmlns at their
+      # byte positions (leptris_element_attributes_raw, 1.9.18
+      # #635) — the streaming SAX contract's mixed view.
+      def self.fetch_attributes_raw(el_ptr)
+        total = leptris_element_attributes_raw(el_ptr, nil, nil, 0)
+        return [] if total.zero?
+        scratch = (Thread.current[:leptris_scratch] ||= {})
+        names = scratch[:attr_names]
+        if names.nil? || names.size / PTR_BYTES < total
+          names&.free
+          names = scratch[:attr_names] =
+            ::FFI::MemoryPointer.new(:pointer, total)
+        end
+        values = scratch[:attr_values]
+        if values.nil? || values.size / PTR_BYTES < total
+          values&.free
+          values = scratch[:attr_values] =
+            ::FFI::MemoryPointer.new(:pointer, total)
+        end
+        copied = leptris_element_attributes_raw(
+          el_ptr, names, values, total)
+        Array.new(copied) do |i|
+          [utf8(names.get_pointer(i * PTR_BYTES).read_string),
+           utf8(values.get_pointer(i * PTR_BYTES).read_string)]
+        end
+      end
+
+      # Attribute strings cross the seam UTF-8 on both faces
+      # (ADR-0002).
+      def self.utf8(str)
+        str.nil? ? nil : str.force_encoding(Encoding::UTF_8)
       end
 
       # Element-only child batch (the mirror of fetch_children over

data/lib/leptris/xml/node.rb

@@ -156,12 +156,15 @@ class Leptris::XML::Node
 
   def children
     # Immutable in readonly mode: the batch fetch plus wrapper
-    # construction is paid once.
+    # construction is paid once. The kinds ride the batch
+    # (leptris_node_children_ex), so no per-child get_type.
     return @children if memo_hit?(@children_version)
     ensure_alive!
     parent = as_element_or_self
-    nodes = Leptris::XML::FFI.fetch_children(@c_ptr).map do |ptr|
-      Leptris::XML::Node.wrap(ptr, @document, parent: parent)
+    pointers, kinds = Leptris::XML::FFI.fetch_children(@c_ptr)
+    nodes = Array.new(pointers.size) do |i|
+      Leptris::XML::Node.wrap(pointers[i], @document,
+                              parent: parent, node_type: kinds[i])
     end
     result = Leptris::XML::NodeSet.new(@document, nodes)
     if @document

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

@@ -61,8 +61,9 @@ module Leptris::XML::SAX::DomDispatch
       end
       return
     end
-    Leptris::XML::FFI.fetch_children(c_ptr).each do |child_ptr|
-      case Leptris::XML::FFI.leptris_node_get_type(child_ptr)
+    pointers, kinds = Leptris::XML::FFI.fetch_children(c_ptr)
+    pointers.each_with_index do |child_ptr, i|
+      case kinds[i]
       when ELEMENT
         visit_element(
           Leptris::XML::Node.wrap(child_ptr, doc, node_type: ELEMENT),
@@ -115,19 +116,12 @@ module Leptris::XML::SAX::DomDispatch
 
   # start_element's pairs with xmlns declarations carried — the
   # engine's streaming contract reports declarations among the
-  # attribute pairs (canon-style namespace-aware consumers split
-  # them). The DOM model stores declarations and attributes
-  # separately, so the exact byte-level interleave is unrecoverable
-  # here: declarations emit first in declaration order (default as
-  # "xmlns", prefixed as "xmlns:prefix"), then the attributes in
-  # source order (leptris-ruby#99).
+  # attribute pairs at their byte positions. Since libleptris
+  # 1.9.18 (upstream #635, closing leptris-ruby#99's documented
+  # difference), the raw qname-ordered list reproduces the exact
+  # interleave.
   def declared_pairs(element)
-    defs = element.namespace_definitions
-    return attr_pairs(element.c_ptr) if defs.empty?
-    pairs = defs.map do |ns|
-      [ns.prefix ? "xmlns:#{ns.prefix}" : "xmlns", ns.href]
-    end
-    pairs.concat(attr_pairs(element.c_ptr))
+    Leptris::XML::FFI.fetch_attributes_raw(element.c_ptr)
   end
 
   # [name, value] pairs in source order, read straight from the

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

@@ -8,15 +8,15 @@ class Leptris::XML::SAX::Parser
 
   attr_reader :document, :encoding
 
-  # streaming: false (default) delivers from a DOM parse —
-  # leptris-ruby#95: the engine's streaming SAX transports corrupt
-  # attribute state on nested attribute-heavy shapes while the DOM
-  # parser reads the same bytes correctly. streaming: true opts
-  # back into the engine transports (bulk/callback by override
-  # weight) once the engine fix lands, or for consumers that
-  # accept the risk.
+  # streaming: true (default, since 1.9.40) delivers through the
+  # engine transports — bulk/callback picked by override weight
+  # (leptris-ruby#95's attribute corruption is fixed upstream in
+  # libleptris 1.9.18, verified on the issue fixture). streaming:
+  # false delivers from a DOM parse (SAX::DomDispatch) — the
+  # correctness-first fallback kept for engines older than 1.9.18
+  # and for consumers wanting the DOM view's shapes.
   def initialize(handler = Leptris::XML::SAX::Document.new,
-                 encoding = nil, streaming: false)
+                 encoding = nil, streaming: true)
     @document = handler
     @encoding = encoding
     @streaming = streaming

metadata

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