leptris 1.9.16-aarch64-linux → 1.9.19-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6960184588bed5ebd9fa8fbf64fe97bb8476b433ba43b5176568f20b9dd561b
-  data.tar.gz: 739e787fbd3c921bcb2ac4cdf776b3f85bc7ec2fe870b8f94f9366cd3aacc710
+  metadata.gz: c17a17ac9f4c53847365c8e9eedfaa025713970e9d7831d3a5ada65941bbcffe
+  data.tar.gz: 889a3d367d1fed900d5ae12d0afaa12b4fe7f4125f8c32be11cba127460e2e8a
 SHA512:
-  metadata.gz: 2588d661f45aec8859681b381fffd2fb05b4600f2888c826ad86a1c43f8ad86d7a8fc95b8ce4d5ae803772275066e4f43e67f09bf0592d5648d732383081168e
-  data.tar.gz: d01eb46bdd19bbdfdf26c6fb278111291f8713439d088f205f7985ba46f31696c344c864f8d95229d4e389c7bc857bdfaae25721cf49d8475c71936c2344b8e1
+  metadata.gz: 59f1415e49d63285c56dac59891d83c08364146b40d221c05255cb141fe57dd23314288fb9ab997620fe3b3e0e7ae75d3db78b078ab0f6cbfe8aeab706c7f6da
+  data.tar.gz: 44d6c18f3866c5bdc769b095ebe1ef62c1aa7a47956c892e3562b5756b9d50191b4b516c88a33ebb75a642356ab984e8a8cc6588c36c6f68b2eec15b9baba80b

data/CHANGELOG.md

@@ -5,6 +5,61 @@ 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.19] - 2026-08-27
+
+Lockstep with libleptris 1.9.3 — unblocks the 1.9.18 release
+(v1.9.2 did not compile on musl, upstream #582).
+
+### Added
+
+- **`Document#comments`**: document-level comments — parsed
+  `<!-- ... -->` outside the root, prolog then epilog, in document
+  order (upstream #578). UTF-8, version-memoized like the PI list;
+  the companion reader to `#processing_instructions`.
+
+### Fixed
+
+- Rides the engine's v1.9.3 fixes: dataless PIs parse correctly
+  (#577 — `<?pi?>` no longer clobbers its closing `?`), epilog
+  comments are kept and serialize after the root (#578), and
+  attribute values normalize per XML 1.0 §3.3.3 (#576 — whitespace
+  collapsing and entity decoding in attribute values).
+
+## [1.9.18] - 2026-08-27
+
+Lockstep with libleptris 1.9.2 (covers 1.9.1 — the XSLT engine — and
+1.9.2, the options-struct ABI freeze; the binding's three-field
+SerializeOptions layout is the frozen shape, so no binding change was
+required for the fix).
+
+### Added
+
+- **`Leptris::XML::XSLT` — XSLT 1.0 transforms**: the engine compiles
+  a stylesheet ONCE into an immutable instruction forest, then applies
+  it to any number of documents. `XSLT.parse(xml)` /
+  `XSLT.parse_file(path)` (resolves §2.7 embedded stylesheets);
+  `Stylesheet#apply_to(doc)` returns the result as an owning,
+  queryable Document; `Stylesheet#serialize(doc)` keeps top-level
+  text nodes and result fragments. Bad select expressions are
+  rejected at COMPILE time. The custom XPath-function handler seam
+  attaches mirror-only until a use case arrives.
+
+## [1.9.17] - 2026-08-27
+
+### Changed
+
+- **Element-hinted batch materialization**: the XPath result-set
+  batch (`leptris_xpath_result_get_nodes_ex`) fills an out_kinds
+  array the binding discarded; `Node.wrap` now accepts a known
+  `node_type:` so element entries skip the per-node get_type
+  dispatch. ELEMENT is the only hintable value — XPath's data
+  model reports CDATA as TEXT, so a TEXT hint cannot distinguish
+  Text from CDATA (different content getters); comments/CDATA/PIs
+  keep the get_type fallback. Cold 500-element materialization:
+  0.131 s -> 0.110 s (~15%). Upstream note: a full-type out_kinds
+  (or kinds on `leptris_node_children`) belongs to the #560/#562
+  ask family.
+
 ## [1.9.16] - 2026-08-27
 
 ### Changed

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.0"
+LIBLEPTRIS_VERSION = "1.9.3"
 
 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.16"
+  VERSION = "1.9.19"
 end

data/lib/leptris/xml/document.rb

@@ -311,6 +311,21 @@ class Leptris::XML::Document
     @freed.state == :freed || @c_ptr.nil?
   end
 
+  # Document-level comments — parsed <!-- ... --> outside the
+  # root element, prolog then epilog, in document order (the
+  # companion reader to #processing_instructions; libleptris
+  # 1.9.3, upstream #578). Version-memoized like the PI list.
+  def comments
+    return @comments if @comments_version == @version
+    count = Leptris::XML::FFI.leptris_document_comment_count(@c_ptr)
+    result = Array.new(count) do |i|
+      Leptris::XML::FFI.leptris_document_comment_content(@c_ptr, i)
+    end
+    @comments = result
+    @comments_version = @version
+    result
+  end
+
   # The thread-global last-failure [line, column] (1-based), or nil
   # when no error is recorded — the position companion to
   # Document#last_error; populated by recover parses.

data/lib/leptris/xml/ffi.rb

@@ -42,6 +42,7 @@ module Leptris
       typedef :pointer, :leptris_xpath_result
       typedef :pointer, :leptris_xpath_ns_set
       typedef :pointer, :leptris_xpath_compiled
+      typedef :pointer, :leptris_xslt
       typedef :pointer, :leptris_pull_parser
       typedef :pointer, :leptris_iterparse
       typedef :pointer, :leptris_xpath_var_set
@@ -124,6 +125,13 @@ module Leptris
         [:leptris_document, :size_t], :string
       attach_function :leptris_document_add_pi,
         [:leptris_document, :string, :string], :pointer
+      # Document-level comments (libleptris 1.9.3, #578): parsed
+      # <!-- ... --> outside the root, prolog then epilog, in
+      # document order. Read-only surface (no add_comment yet).
+      attach_function :leptris_document_comment_count,
+        [:leptris_document], :size_t
+      attach_function :leptris_document_comment_content,
+        [:leptris_document, :size_t], :string
       # Options-struct parse (v1.6.0): supersedes the flags variants;
       # the flags path remains bound for compatibility.
       attach_function :leptris_parse_string_ex,
@@ -478,7 +486,11 @@ module Leptris
       attach_function :leptris_xpath_compiled_eval_vars,
         [:leptris_xpath_compiled, :leptris_document, :leptris_element,
          :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
       attach_function :leptris_xpath_compiled_free,
+
         [:leptris_xpath_compiled], :void
 
       attach_function :leptris_sax_parse,
@@ -539,7 +551,23 @@ module Leptris
         [:leptris_element, :pointer, :size_t, :pointer, :pointer], :size_t
       attach_function :leptris_document_save_file,
         [:leptris_document, :string, :pointer], :leptris_status
+      # XSLT 1.0 engine (libleptris 1.9.1): compile once, apply many.
+      attach_function :leptris_xslt_parse,
+        [:string, :size_t], :leptris_xslt
+      attach_function :leptris_xslt_parse_file,
+        [:string], :leptris_xslt
+      attach_function :leptris_xslt_free,
+        [:leptris_xslt], :void
+      # Result tree is a document (free with document_free); errors
+      # surface via document_last_error on NULL.
+      attach_function :leptris_xslt_apply,
+        [:leptris_xslt, :leptris_document], :leptris_document
+      # apply + serialize in one call, keeping top-level text nodes
+      # and result fragments the tree API would flatten.
+      attach_function :leptris_xslt_apply_string,
+        [:leptris_xslt, :leptris_document], :pointer
       attach_function :leptris_c14n_canonicalize,
+
         [:leptris_document, :int, :int], :pointer
       attach_function :leptris_c14n_canonicalize_subtree,
         [:leptris_element, :int, :int], :pointer
@@ -648,6 +676,7 @@ module Leptris
         leptris_status_string leptris_last_error
         leptris_document_last_error leptris_document_encoding
         leptris_document_pi_target leptris_document_pi_data
+        leptris_document_comment_content
         leptris_element_name leptris_element_text leptris_element_prefix
         leptris_element_namespace
         leptris_element_attribute leptris_element_attribute_ns
@@ -747,14 +776,27 @@ module Leptris
       end
 
       # XPath result-set batch (leptris_xpath_result_get_nodes_ex):
-      # copies all node kinds into a caller buffer and hands back
-      # the pointer array.
+      # the call fills out_kinds in the 4-value XPATH_NODE space
+      # (ELEMENT/ATTRIBUTE/TEXT/OTHER). ELEMENT is the only value
+      # that maps unambiguously — XPath's data model reports CDATA
+      # as TEXT, so a TEXT hint cannot distinguish Text from CDATA
+      # (different content getters) — everything else falls back to
+      # get_type in the wrapper. Returns [pointers, element_hints].
+      XPATH_KIND_HINT = { XPATH_NODE_ELEMENT => NODE_ELEMENT }.freeze
+
       def self.fetch_result_nodes(result_ptr, count)
-        return [] if count.zero?
+        return [[], nil] if count.zero?
         with_pointer_buffer(count) do |buffer|
-          copied = leptris_xpath_result_get_nodes_ex(
-            result_ptr, buffer, nil, count)
-          buffer.get_array_of_pointer(0, copied)
+          kinds = ::FFI::MemoryPointer.new(:int, count)
+          begin
+            copied = leptris_xpath_result_get_nodes_ex(
+              result_ptr, buffer, kinds, count)
+            hints = kinds.get_array_of_int(0, copied)
+              .map { |k| XPATH_KIND_HINT[k] }
+            [buffer.get_array_of_pointer(0, copied), hints]
+          ensure
+            kinds.free
+          end
         end
       end
 

data/lib/leptris/xml/node.rb

@@ -12,7 +12,10 @@ class Leptris::XML::Node
     @node_type = node_type
   end
 
-  def self.wrap(c_ptr, document, parent: nil)
+  # node_type: callers holding a batch-fetched kind (the XPath
+  # result-set batch fills out_kinds) pass it so the wrap skips the
+  # get_type dispatch; nil (the default) dispatches as before.
+  def self.wrap(c_ptr, document, parent: nil, node_type: nil)
     # Per-document weak-ref cache. Returns the existing wrapper when the
     # same c_ptr is wrapped twice (common in children/sibling walks,
     # repeated xpath queries, traverse-then-access patterns). The cache
@@ -21,7 +24,7 @@ class Leptris::XML::Node
       return cached
     end
 
-    node_type = Leptris::XML::FFI.leptris_node_get_type(c_ptr)
+    node_type ||= Leptris::XML::FFI.leptris_node_get_type(c_ptr)
     node =
       case node_type
       when Leptris::XML::FFI::NODE_ELEMENT

data/lib/leptris/xml/node_set.rb

@@ -81,11 +81,11 @@ class Leptris::XML::NodeSet
         # 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)
+        pointers, kinds = Leptris::XML::FFI.fetch_result_nodes(@result_ptr, n)
         nodes = []
-        pointers.each do |ptr|
+        pointers.each_with_index do |ptr, i|
           next if ptr.null?
-          nodes << Leptris::XML::Node.wrap(ptr, @document)
+          nodes << Leptris::XML::Node.wrap(ptr, @document, node_type: kinds[i])
         end
         (pointers.length...n).each do |i|
           ptr = Leptris::XML::FFI.leptris_xpath_result_get_node(@result_ptr, i)

data/lib/leptris/xml/xslt.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "ffi"
+
+module Leptris::XML::XSLT
+  module_function
+
+  def parse(stylesheet_xml)
+    Stylesheet.parse(stylesheet_xml)
+  end
+
+  def parse_file(path)
+    Stylesheet.parse_file(path)
+  end
+
+  # A compiled XSLT 1.0 stylesheet (libleptris 1.9.1): the stylesheet
+  # parses ONCE into an immutable instruction forest — patterns to
+  # XPath ASTs, selects through the compiled-XPath path — then applies
+  # to any number of documents with no re-parsing.
+  #
+  #     style = Leptris::XML::XSLT.parse(<<~XSL)
+  #       <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+  #         <xsl:template match="/"><out><xsl:value-of select="count(//item)"/></out></xsl:template>
+  #       </xsl:stylesheet>
+  #     XSL
+  #     style.apply_to(doc)      # => result Document (queryable tree)
+  #     style.serialize(doc)     # => String (fragments and top-level
+  #                              #    text nodes preserved)
+  #
+  class Stylesheet
+    # GC-managed compiled handle.
+    class Handle < ::FFI::AutoPointer
+      def self.release(ptr)
+        Leptris::XML::FFI.leptris_xslt_free(ptr)
+      end
+    end
+
+    # Compile a stylesheet. Raises XPathError on a stylesheet syntax
+    # error (detail on the thread-global last error).
+    def self.parse(stylesheet_xml)
+      raw = Leptris::XML::FFI.leptris_xslt_parse(
+        stylesheet_xml.to_s, stylesheet_xml.to_s.bytesize)
+      if raw.null?
+        raise Leptris::XML::XPathError,
+          "stylesheet parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+      end
+      new(Handle.new(raw))
+    end
+
+    # Compile from a file. Resolves §2.7 embedded stylesheets
+    # (xml-stylesheet PI with an href="#id" fragment) when the file's
+    # root is not itself a stylesheet.
+    def self.parse_file(path)
+      raw = Leptris::XML::FFI.leptris_xslt_parse_file(path.to_s)
+      if raw.null?
+        raise Leptris::XML::XPathError,
+          "stylesheet parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+      end
+      new(Handle.new(raw))
+    end
+
+    def initialize(handle)
+      @handle = handle
+    end
+
+    # Apply to +document+ (not modified) and return the result tree
+    # as an owning Document — query it with xpath/css like any other.
+    def apply_to(document)
+      raw = Leptris::XML::FFI.leptris_xslt_apply(@handle, document.c_ptr)
+      if raw.null?
+        raise Leptris::XML::XPathError,
+          "transform failed: #{document.last_error || Leptris::XML::FFI.leptris_last_error}"
+      end
+      Leptris::XML::Document.wrap(raw)
+    end
+
+    # Apply and serialize in one call — keeps top-level text nodes and
+    # result fragments that the tree API would flatten.
+    def serialize(document)
+      str_ptr = Leptris::XML::FFI.leptris_xslt_apply_string(
+        @handle, document.c_ptr)
+      Leptris::XML::FFI.read_owned_string(str_ptr)
+    end
+  end
+end

data/lib/leptris/xml.rb

@@ -22,6 +22,7 @@ module Leptris
     autoload :Serialization, "leptris/xml/serialization"
     autoload :SAX, "leptris/xml/sax"
     autoload :XPath, "leptris/xml/xpath"
+    autoload :XSLT, "leptris/xml/xslt"
     autoload :Pull, "leptris/xml/pull"
     autoload :Iterparse, "leptris/xml/iterparse"
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.16
+  version: 1.9.19
 platform: aarch64-linux
 authors:
 - Ribose Inc.
@@ -103,6 +103,7 @@ files:
 - lib/leptris/xml/serialization.rb
 - lib/leptris/xml/text.rb
 - lib/leptris/xml/xpath.rb
+- lib/leptris/xml/xslt.rb
 - lib/libleptris.so
 homepage: https://github.com/leptris/leptris-ruby
 licenses: