leptris 1.9.17-aarch64-linux → 1.9.20-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb75550db96ee7caa7354e9e6c15560218a24aaa78876b6a394fb2749df32926
-  data.tar.gz: 4d944de7936ec570782375e1605ea5d452425fae6bfefeca5588c6aced95248b
+  metadata.gz: f771cd132406876908f1fd005de0fb47dc6c39ab1c92e7af8bd0bf44e813262b
+  data.tar.gz: cffb7a6bf701d9d9dbbf3eaca31e29fda0f4645ad9f3579ccb95df8873936649
 SHA512:
-  metadata.gz: 813314f3f5fb49ef7871b3bbd95206f7080757c686fc0ffd252444719ee9427252c579d2a2293a6d2a2eeb4c820b731234ea936b483562f9e58508d6d9eaa96d
-  data.tar.gz: 29f50102bf31307bd6afa07d3856f3a00b72d8b5d7264143d24ba436c8b8683387846932f1ca3d49905fac003713c76952bad50d45ad9eb3a58aa26376fea12c
+  metadata.gz: b8ce9c02cf8c7bbdf86ba36f061a17847060b7f82064e8c95a354b2310b8ebe8fff1deaf13ddcc9351d201a5059a3c281483371e96b10727502abb3a12f10bbc
+  data.tar.gz: 3fee7ac669e47714269df9821d32b99b3d9ca96d91b03caf4457b4f73ed8fef4180b4daf598a7fbc870fdd9cfde8208c42560ced83b1a59d2341ccfecef070f9

data/CHANGELOG.md

@@ -5,6 +5,66 @@ 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.20] - 2026-08-27
+
+### Changed
+
+- **Pull event loop allocation trim**: `Parser#next_event` reads the
+  event's type/name/text through layout-derived offsets
+  (`PullEventStruct.offset_of` — the struct stays the ABI's single
+  source of truth) instead of allocating a struct wrapper per event;
+  `capture_attrs` builds its hash without the enumerator machinery
+  and answers nil for zero attributes. Streaming a 300-element
+  document: 2.9 ms -> 2.3 ms per parse (**-20%**). The remaining
+  per-event cost is FFI dispatch — the batch ask is filed upstream
+  (leptris/leptris#589).
+
+### Meta
+
+- Streaming-path benchmarks added to the round's report: pull with
+  events measured 145x slower than DOM-parsing the same bytes
+  (dispatch-dominated); iterparse's 60% system-time signature
+  documented on leptris/leptris#563 (C-side release churn).
+
+## [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

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.17"
+  VERSION = "1.9.20"
 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

data/lib/leptris/xml/pull.rb

@@ -60,6 +60,14 @@ module Leptris::XML::Pull
       self
     end
 
+    # Hot-loop offsets: derived from PullEventStruct's layout (the
+    # struct stays the single source of truth for the ABI), read via
+    # get_int/get_pointer so the per-event struct-wrapper allocation
+    # disappears from streaming loops.
+    NAME_OFFSET = Leptris::XML::FFI::PullEventStruct.offset_of(:name)
+    TEXT_OFFSET = Leptris::XML::FFI::PullEventStruct.offset_of(:text)
+    private_constant :NAME_OFFSET, :TEXT_OFFSET
+
     # Advances the cursor and returns the next Event, or nil after the
     # end of the document. Attribute values are captured during
     # start_element because the C accessors are valid only for the
@@ -67,26 +75,31 @@ module Leptris::XML::Pull
     def next_event
       raw = Leptris::XML::FFI.leptris_pull_next(@handle)
       return nil if raw.null?
-      event = Leptris::XML::FFI::PullEventStruct.new(raw)
-      type = TYPES[event[:type]]
-      name = read_owned(event[:name])
-      text = read_owned(event[:text])
+      type = TYPES[raw.get_int(0)]
+      name_ptr = raw.get_pointer(NAME_OFFSET)
+      text_ptr = raw.get_pointer(TEXT_OFFSET)
       attrs = type == :start_element ? capture_attrs : nil
-      Event.new(type: type, name: name, text: text, attrs: attrs)
+      Event.new(
+        type: type,
+        name: name_ptr.null? ? nil : name_ptr.read_string.force_encoding(Encoding::UTF_8),
+        text: text_ptr.null? ? nil : text_ptr.read_string.force_encoding(Encoding::UTF_8),
+        attrs: attrs
+      )
     end
 
     private
 
-    def read_owned(ptr)
-      ptr.null? ? nil : ptr.read_string.force_encoding(Encoding::UTF_8)
-    end
-
     def capture_attrs
       count = Leptris::XML::FFI.leptris_pull_attr_count(@handle)
-      count.times.each_with_object({}) do |i, hash|
+      return nil if count.zero?
+      hash = {}
+      i = 0
+      while i < count
         hash[Leptris::XML::FFI.leptris_pull_attr_name(@handle, i)] =
           Leptris::XML::FFI.leptris_pull_attr_value(@handle, i)
+        i += 1
       end
+      hash
     end
   end
 

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.17
+  version: 1.9.20
 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: