leptris 1.9.53-x86_64-linux → 1.9.55-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d9ea2c66283a8f4b985f250d908e407098c78db6582e6747376ceba6ccbb2c7a
-  data.tar.gz: 6040c9e9b2b3b76f2e098005294d5d149122354f8d3fa8958f30c390341fe711
+  metadata.gz: 166f46bd7874e3160fbe3131115c32e1695354d5d503fc6684076d6723a8f4f3
+  data.tar.gz: e203358c5847147d46de10c52950d9b3a81cd4e3610b4b59ce6e4a396e7b79ff
 SHA512:
-  metadata.gz: 16b683f6eceb1f573f951c6d68862fd431abac982a97e24104c0e14d7cf85d223916c08d663983f69f639f155062d22bb4ee8f08df0e04bd365598ffcab62c59
-  data.tar.gz: 4e4e56d4037cc817c6071e215ab127d0d8302827872c3c4c1c059f9732c8bbd8904e4298588ae1b74fdb4b81172bc50c3c75957a9280324571a409b32b95d8e4
+  metadata.gz: ccf26a2227f5fcdca9a639f676a2388b58c294c710795662522264a5ded8c07e6adcbb188133ed12b92bc766fc00b1c54d6726456d057c9d21b1b8f5797765fd
+  data.tar.gz: 9730c0d093216b2f96befd533a5360af1fe0124337b373392f77509cc4ccef6538b72b787ae7da1967b86f4dacdd2c261b65b6f3e87f987eaadf16392298ebe6

data/CHANGELOG.md

@@ -5,6 +5,88 @@ 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
+
+- **Lockstep with libleptris 1.9.49** (1.9.47 → 1.9.49; no new C
+  surface — the audit holds at 255/255 attached == exported):
+  - 1.9.47: `leptris_element_copy` keeps namespaces (#721) —
+    prefixes, declarations, and resolution on the copied subtree;
+    sequence-use `xsl:key` (#720, use-after-free + each item
+    indexes).
+  - 1.9.48: `xsl:on-completion` sees the final iterate params
+    (#729); merge-level `xsl:merge-key` fallback (#731); #730/#732
+    triaged against Saxon (quoted `xpath="'$p'"` is the dynamic
+    with-param form; multi-top-level results serialize fully —
+    libxslt parity).
+  - 1.9.49: `xs:` atomic constructors (`xs:integer`/`xs:double`/
+    `xs:decimal`/`xs:boolean`/`xs:string`/`xs:anyURI`) resolve in
+    any expression — standalone `#xpath` included, specced against
+    the Saxon ground truth (`xs:integer('42') + 1` = 43).
+  - All three pending specs un-pending (#729/#730/#731); #730
+    rewritten as the Saxon-correct pair (quoted form evaluates,
+    unquoted raises); sequence-use keys and the constructors
+    specced.
+
+### Changed
+
+- **`dup` reverted to the C copy** (the payoff of #721's fix):
+  `Node#dup`/`Element#dup` and the element indent-unit path drop
+  the serialize → re-parse round-trip adopted in 1.9.50 — the C
+  copy now preserves every child kind, prefixed names, and
+  namespace declarations byte-for-byte, and is attached as the
+  fresh document's root so the tree is fully navigable (~436 µs
+  vs ~1.2 ms per dup of a 300-element subtree on this bench).
+  A new C-level spec pins the namespace fidelity.
+
 ## [1.9.53] - 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.46"
+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.53"
+  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

@@ -251,15 +251,16 @@ class Leptris::XML::Element < Leptris::XML::Node
     self
   end
 
-  # Deep copy in a NEW document, via serialization round-trip:
-  # leptris_element_copy drops namespace prefixes and declarations
-  # outright (leptris/leptris#721; its comment/PI child drop was
-  # #696, fixed upstream in 1.9.39) — the serializer preserves
-  # every child kind, prefixed names, and namespace declarations,
-  # and re-parsing rebuilds them all.
+  # Deep copy in a NEW document via the C copy (both engine gaps
+  # closed: comment/PI children in 1.9.39, namespaces in 1.9.47 —
+  # leptris/leptris#696, #721), attached as the fresh document's
+  # root so the tree is fully navigable.
   def dup
     ensure_alive!
-    Leptris::XML::Document.parse(to_xml).root
+    new_doc = Leptris::XML::Document.create
+    copy = Leptris::XML::FFI.leptris_element_copy(@c_ptr, new_doc.c_ptr)
+    raise Leptris::XML::Error, "leptris_element_copy failed" if copy.null?
+    new_doc.root = Leptris::XML::Node.wrap(copy, new_doc)
   end
   alias_method :clone, :dup
 
@@ -348,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
@@ -376,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/node.rb

@@ -369,17 +369,18 @@ class Leptris::XML::Node
     result
   end
 
-  # Deep copy in a NEW document. Rounds through serialization
-  # rather than leptris_element_copy: the C copy drops namespace
-  # prefixes and declarations outright (leptris/leptris#721; the
-  # comment/PI child drop was #696, fixed upstream in 1.9.39) —
-  # the serializer preserves every child kind, prefixed names, and
-  # namespace declarations, and re-parsing rebuilds them all.
+  # Deep copy in a NEW document via the C copy (both engine gaps
+  # closed: comment/PI children in 1.9.39, namespaces in 1.9.47 —
+  # leptris/leptris#696, #721). The copy is attached as the fresh
+  # document's root so the tree is fully navigable.
   def dup
     ensure_alive!
     elem_ptr = Leptris::XML::FFI.leptris_node_as_element(@c_ptr)
     raise Leptris::XML::Error, "dup is only supported for element nodes" if elem_ptr.null?
-    Leptris::XML::Document.parse(to_xml).root
+    new_doc = Leptris::XML::Document.create
+    copy = Leptris::XML::FFI.leptris_element_copy(elem_ptr, new_doc.c_ptr)
+    raise Leptris::XML::Error, "leptris_element_copy failed" if copy.null?
+    new_doc.root = Leptris::XML::Node.wrap(copy, new_doc)
   end
   alias_method :clone, :dup
 

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:
@@ -97,14 +115,17 @@ module Leptris::XML::Serialization
 
   # Element-face indent unit (leptris-ruby#109 residual 2): no
   # element-level ext-serialize entry exists yet, so the unit path
-  # rounds the subtree through serialization into a fresh document
-  # (leptris_element_copy drops namespaces — leptris/leptris#721)
-  # and serializes that document without a declaration — identical
-  # output to the element serializer for the standard layout, with
-  # the unit and every child kind intact.
+  # C-copies the subtree into a fresh document (the copy keeps
+  # every child kind and namespace since leptris 1.9.47 — #696,
+  # #721) and serializes that document without a declaration —
+  # identical output to the element serializer for the standard
+  # layout, with the unit and every child kind intact.
   def self.to_xml_element_unit(element, unit, indent: 0)
-    document = Leptris::XML::Document.parse(element.to_xml)
+    document = Leptris::XML::Document.create
     begin
+      copy = Leptris::XML::FFI.leptris_element_copy(element.c_ptr, document.c_ptr)
+      raise Leptris::XML::Error, "leptris_element_copy failed" if copy.null?
+      document.root = Leptris::XML::Node.wrap(copy, document)
       to_xml_indent_unit(document.c_ptr, unit,
                          indent: indent, no_decl: true)
     ensure

metadata

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