leptris 1.9.54-aarch64-linux-musl → 1.9.55-aarch64-linux-musl

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 31bc8930a3a87af45d528ce6c16f32936b4611e4f3af60d69c832c748f3e5867
-  data.tar.gz: 54514f015892ea6ee58374a5428407fc2052aaa6adcac9f1ebcc8e2556dfe7de
+  metadata.gz: 8f9792c5d017627b5beb09770a879bb870a5b3dc724fcdb5f07561ad83a339ba
+  data.tar.gz: 7eba8cd00b0e1d3bdbf6f0201a6c03b36953094ee7cd17cc6c168202e2fb9aa1
 SHA512:
-  metadata.gz: cc0498478f1047bfd67c594d70908e2c258021e04932fe57cd507347f3328cd48e3193e8283654969c5a05f1859c44f0e036b337547aff6bcae20da74be86213
-  data.tar.gz: 3fc40de161220b069356c0b9278e28bebcd2d9203226b691f9a1a191116ee97651e281b4494a9fbfdf10befec61b46712511b3528d709f0fb8d75153f1aa8820
+  metadata.gz: cf7e5708b4d6f42b918bc7417a02764388097761decc97c40a8733c8e90c8f9d1f9c3ef253354b185fe08cd2eb0da4c867462252124673cc6acb3007a25800bd
+  data.tar.gz: 869ad36b1498a374986d137011c2bd40587f8979095e08e65df37bb40ba9d84f76d72989dcaabbb73e58dd6b67040c6964f3ea42833f07732b349d25d45b7ad4

data/CHANGELOG.md

@@ -5,6 +5,53 @@ 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.55] - 2026-09-02
+
+### Changed
+
+- **Lockstep with libleptris 1.9.50**: XPath 2.0 type operators —
+  `instance of`, `castable as`, `cast as`, `treat as` with
+  SequenceType v1 (`node()`, `item()`, occurrence `*`/`+`) —
+  resolving standalone from `#xpath`, specced against the Saxon
+  ground truth including the falsifiable negative
+  (`'x' castable as xs:integer` = false, `1.9 cast as xs:integer`
+  = 1). No new C surface (audit 255/255).
+- **README**: the standalone-subset example block grows the type
+  operators; the #683 gap list drops sequence types (still out:
+  value comparators, quantifiers, `intersect`/`except`, string
+  templates, XQuery).
+
+### Improved
+
+- **Serialize + inner_html, one dispatch instead of two**: the
+  `_serialize_into` contract is snprintf-like (the return is
+  always the bytes needed incl. NUL; the copy happens only when
+  the buffer fits), so `serialize_into_string` now fills the
+  grow-only byte scratch opportunistically and probes the size
+  only when a child outgrows it — previously every call paid a
+  size-probe dispatch before the fill. The bound serializer
+  methods are hoisted to constants (`Element#to_xml` and
+  `Document#to_xml` allocated a Method object per call), and
+  `inner_html` serializes element children through a dedicated
+  default-options fast path (no kwargs, no options rebuild).
+  Measured on a 1.0 MB / 42k-element document: document serialize
+  1.1x → **3.2x faster** than Nokogiri 1.19.4; `inner_html` 0.8x →
+  **4.4x faster** (4.2 ms → 1.1 ms per 200 elements). Parse (11x),
+  attr reads (9x), text aggregation (11x), and element_children
+  walks (parity) all hold.
+
+### Fixed
+
+- **#120 closed with a guard**: text ampersands escape on
+  serialize — byte-parity specs (parse-and-serialize round-trip
+  plus a `content=` write path) now run on every CI leg including
+  both Linuxes, so a platform-build serializer divergence fails CI
+  instead of shipping. The 1.9.50 Linux build was superseded per
+  the verification on the issue.
+- **#124 filed upstream** (leptris/leptris#745): the C-side
+  non-standard-entity pre-scan entry — the moxml +61% parse → ~+2%
+  case. The binding attaches and wraps it the day it lands.
+
 ## [1.9.54] - 2026-09-02
 
 ### Changed

data/README.adoc

@@ -239,6 +239,9 @@ doc.xpath("count(1 to 4)")                           # => 4.0
 doc.xpath("//book => count()")                       # 3.1 arrow
 doc.xpath("//title ! string(.)")                     # 3.1 simple map
 doc.xpath("'v' || count(//book)")                    # 3.1 concat
+doc.xpath("'42' castable as xs:integer")             # 2.0 type ops
+doc.xpath("1.9 cast as xs:integer")                  # => 1.0 (truncates)
+doc.xpath("//title instance of node()+")             # 2.0 sequence types
 ----
 
 Two caveats: `for … return` sequences come back as opaque result
@@ -247,8 +250,8 @@ nodes — consume them through an aggregate (`count(...)`,
 items; and XQuery-only syntax (`order by`, `try/catch`, map
 constructors) raises `XPathError` rather than evaluating silently
 wrong. The remaining grammar gaps — value comparators (`eq`),
-quantifiers, sequence types (`instance of`), `intersect`/`except`,
-string templates — and XQuery itself are
+quantifiers, `intersect`/`except`, string templates — and XQuery
+itself are
 https://github.com/leptris/leptris/issues/683[tracked upstream].
 
 === Supported CSS selectors

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.49"
+LIBLEPTRIS_VERSION = "1.9.50"
 
 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.54"
+  VERSION = "1.9.55"
 end

data/lib/leptris/xml/document.rb

@@ -285,7 +285,7 @@ class Leptris::XML::Document
         @c_ptr, indent: indent, no_decl: no_decl, encoding: encoding)
     end
     Leptris::XML::Serialization.to_xml(
-      Leptris::XML::FFI.method(:leptris_document_serialize_into), @c_ptr,
+      Leptris::XML::Serialization::DOCUMENT_SERIALIZE_INTO, @c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
   alias_method :to_s, :to_xml

data/lib/leptris/xml/element.rb

@@ -349,7 +349,8 @@ class Leptris::XML::Element < Leptris::XML::Node
   def inner_html
     children.map do |child|
       case child
-      when Leptris::XML::Element then child.to_xml
+      when Leptris::XML::Element
+        Leptris::XML::Serialization.element_xml_default(child.c_ptr)
       when Leptris::XML::CDATA # before Text: CDATA subclasses it
         "<![CDATA[#{child.content}]]>"
       when Leptris::XML::Text
@@ -377,7 +378,7 @@ class Leptris::XML::Element < Leptris::XML::Node
     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,
+      Leptris::XML::Serialization::ELEMENT_SERIALIZE_INTO, @c_ptr,
       indent: indent, no_decl: no_decl, encoding: encoding)
   end
 

data/lib/leptris/xml/ffi.rb

@@ -894,12 +894,29 @@ module Leptris
       # leptris_element_serialize_into. The buffer holds the
       # serialization + NUL and XML output is NUL-free, so the
       # bounded read is exact.
+      # snprintf contract (leptris.h #535): the return is ALWAYS the
+      # bytes needed incl. the NUL; the copy happens only when the
+      # buffer fits. So the size probe is paid only when the child
+      # outgrows the grow-only scratch — one dispatch per call on
+      # the fast path instead of two (inner_html serializes each
+      # child; the probe was most of the per-child FFI cost).
+      SERIALIZE_INITIAL = 256
+      private_constant :SERIALIZE_INITIAL
+
       def self.serialize_into_string(ffi_function, c_ptr, options)
-        need = ffi_function.call(c_ptr, nil, 0, nil, options)
-        return "" if need.zero?
-        buffer = scratch_bytes(need)
-        ffi_function.call(c_ptr, buffer, need, nil, options)
-        buffer.read_string.force_encoding(Encoding::UTF_8)
+        scratch = (Thread.current[:leptris_scratch] ||= {})
+        buffer = scratch[:bytes]
+        if buffer.nil?
+          buffer = scratch[:bytes] =
+            ::FFI::MemoryPointer.new(:char, SERIALIZE_INITIAL)
+        end
+        needed = ffi_function.call(c_ptr, buffer, buffer.size, nil, options)
+        if needed > buffer.size
+          buffer = scratch_bytes(needed)
+          needed = ffi_function.call(c_ptr, buffer, buffer.size, nil, options)
+        end
+        return "" if needed <= 1
+        buffer.read_string(needed - 1).force_encoding(Encoding::UTF_8)
       end
 
       # Byte scratch for serialize-into cycles: the size+fill pair

data/lib/leptris/xml/serialization.rb

@@ -18,6 +18,16 @@ module Leptris::XML::Serialization
   end
   private_constant :DEFAULT_OPTIONS
 
+  # Bound serializer entries, hoisted: Element#to_xml and the
+  # inner_html per-child loop passed FFI.method(:...) — one Method
+  # allocation per serialized child.
+  ELEMENT_SERIALIZE_INTO =
+    Leptris::XML::FFI.method(:leptris_element_serialize_into)
+  DOCUMENT_SERIALIZE_INTO =
+    Leptris::XML::FFI.method(:leptris_document_serialize_into)
+  # Public within the library: Element#to_xml and Document#to_xml
+  # pass the hoisted bound methods straight through.
+
   # +ffi_function+ is a bound _serialize_into function. The buffer
   # cycle lives at the FFI seam (FFI.serialize_into_string); this
   # module owns only options selection and construction.
@@ -33,6 +43,14 @@ module Leptris::XML::Serialization
     Leptris::XML::FFI.serialize_into_string(ffi_function, c_ptr, opts.pointer)
   end
 
+  # Default-options element serialization for inner_html's per-child
+  # loop: no kwargs, no options rebuild, no method allocation —
+  # one FFI fast-path dispatch per child.
+  def self.element_xml_default(c_ptr)
+    Leptris::XML::FFI.serialize_into_string(
+      ELEMENT_SERIALIZE_INTO, c_ptr, DEFAULT_OPTIONS.pointer)
+  end
+
   # Display-form document serialization (libleptris 1.9.9, #129):
   # the ext struct's indent_text hands ALL whitespace to the
   # formatter — text and mixed content indent too. Display-oriented:

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.54
+  version: 1.9.55
 platform: aarch64-linux-musl
 authors:
 - Ribose Inc.