leptris 1.9.57 → 1.9.58

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9fe43887876480fe4a97b6133facd465257fd25dc8e0304e97057c1a59bf909d
-  data.tar.gz: a3aa3e2010b04f08ae53c2fc3efeade0b8a07640610cc549dfeaa0e329f03746
+  metadata.gz: 159f07010d3dd22a62761daef970c4090a47ee9d7ba6471099380410119dadf2
+  data.tar.gz: b80e233d06f4d3af6bb14cc1cbf157ce88dfd7c745ffe7c936bc333d77b7e92d
 SHA512:
-  metadata.gz: 96c857442e1b239c4740f061b0a656dec46f6f09ec1501609d2c095e088f214c8b7d1b495a72f3848548621a40764bb1b16ed3ece3e0986d7a31dcd3583d409f
-  data.tar.gz: 89a40a7423ce40ded296919d5bb8532bf5e7bfc252bf301a71bee12f7f5e275134494853ae5d08d1728627c2b2d0b32b68ffcc4dd6304cbdc79dcd2b8869cbbc
+  metadata.gz: c2a1504b697e82a0eddeb8966597f2e39ba27362fa6ebdff2edf9dae2258f5a6cf5757b7088c144f69309ca5016297cba39513fe3a1a901b709029d82a45e88f
+  data.tar.gz: 4314c5cf903efe548acaec50494a40578e543f31268ffa9fcdee9e0bd9a069efa152bb8889ad86f6c43b638bd48ad7d554428e9ea9c48b1970301913aa905d66

data/CHANGELOG.md

@@ -5,6 +5,63 @@ 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.58] - 2026-09-03
+
+### Added
+
+- **Lockstep with libleptris 1.9.75** (1.9.68 → 1.9.75, eight
+  releases). One new C symbol attached (audit 260/260):
+  - **`Leptris::XML.parse_html`** (1.9.75, leptris/leptris#659 —
+    the last Nokogiri capability gap): tolerant HTML4/5 into the
+    STANDARD DOM — implied end tags, void elements, raw-text
+    script/style, lowercased names, minimized/unquoted attributes,
+    HTML named entities; html/head/body synthesized (Nokogiri::HTML
+    parity), tbody never implied; malformed markup degrades to
+    text. Eight specs; README HTML section; the migration list
+    drops "No Nokogiri::HTML".
+  - **XPath 2.0 ledger** (1.9.69/1.9.73, closes most of the #683
+    grammar list): value comparators (`eq`/`gt`/…), quantifiers
+    (`some`/`every`), set algebra (`intersect`/`except`), node
+    identity (`is`) — all standalone from `#xpath`, specced.
+  - **XQuery windows and typeswitch** (1.9.69/1.9.70): tumbling
+    and sliding `window` clauses, `typeswitch` dispatch, the error
+    code model (`try/catch` reaches its catch arm — the #790
+    cast-error piece landed). Specced.
+  - **Sequence items are readable**: `for … return`, sequence
+    literals, and XQuery constructor results arrive as
+    `Leptris::XML::ResultText` (new) — `#content` serves the value
+    directly, captured at result materialization through
+    `leptris_xpath_result_node_value` (the only accessor that can
+    read the engine's synthetic sequence carriers). The
+    "consume through an aggregate" caveat is retired.
+- Upstream perf work adopted: AVT compile cache, keyed mutation
+  tail caches, fragment-output tail caches (1.9.71/1.9.72).
+
+### Fixed
+
+- **#130 closed** (dup degradation): the monotonic per-cycle rise
+    lived in the C-copy path — `dup` reverts to the serialization
+    round-trip (see #812 below) and the repro runs flat (~95 µs
+    per copy across 20 rounds × 15 copies).
+- **#790 mostly fixed upstream** (1.9.68): constructor-as-return
+  parses (items arrive as readable serialized strings),
+  where/at-in-function-argument parses, cast errors reach
+  try/catch. Follow-up found and reported: the `where` clause is
+  silently IGNORED in the function-argument position (bare FLWOR
+  filters, wrapped does not) — one pending spec holds the correct
+  expectation.
+- **leptris/leptris#812 filed** (1.9.74 copy rewrite regresses
+  #721): `leptris_element_copy` drops declarations used only by
+  descendants and resolution returns NULL on the copied subtree —
+  `dup` and the indent-unit path revert to the serialization
+  round-trip (byte-exact) until it lands.
+- **leptris/leptris#815 filed** (from #131): the indenting
+  DOCUMENT serializer intermittently emits unescaped `<` in text
+  (invalid XML out) for ~5-7% of parses under allocation churn —
+  localized to the engine (all three C serialization paths corrupt;
+  `indent: 0` and the element face are clean). #131 stays open as
+  the tracker.
+
 ## [1.9.57] - 2026-09-03
 
 ### Changed

data/README.adoc

@@ -106,6 +106,26 @@ doc.root                                # => nil
 Leptris::XML::FFI.leptris_last_error    # => "..."
 ----
 
+== HTML parsing
+
+`Leptris::XML.parse_html(html)` parses tolerant HTML4/5 into a
+standard Document — the same nodes, pool, serializer, and
+XPath/XSLT/XQuery machinery as XML (libleptris 1.9.75, the last
+Nokogiri capability gap):
+
+[source,ruby]
+----
+doc = Leptris::XML.parse_html(%(<ul><li>a<li>b</ul>))
+doc.at_css("body").inner_html   # => "<ul><li>a</li><li>b</li></ul>"
+----
+
+Implied end tags (`p`/`li`/`td`/`tr`/...), void elements, raw-text
+`<script>`/`<style>`, case-insensitive lowercased names,
+minimized/unquoted attributes, and the HTML named entities all
+parse; `html`/`head`/`body` are synthesized (Nokogiri::HTML parity)
+but `tbody` is never implied. Malformed markup degrades to text
+rather than raising.
+
 == Reading nodes
 
 [horizontal]
@@ -247,17 +267,21 @@ doc.xpath("[10, 20, 30]?2")                          # 3.1 arrays
 doc.xpath(%q{serialize(parse-json('{"b":"beta"}'), map { 'method': 'json' })})
 doc.xpath("function($x) { $x + 1 }(41)")             # 3.1 function items
 doc.xpath("fold-left(1 to 4, 0, function($a, $b) { $a + $b })")
+doc.xpath("count(//a) eq 2")                        # 2.0 value comparators
+doc.xpath("some $a in //a satisfies $a/@v > 1")     # 2.0 quantifiers
+doc.xpath("count(//a except //a[@v = 1])")          # 2.0 set algebra
+----
+
+Sequence and constructor items arrive as `Leptris::XML::ResultText`
+objects — `#content` serves the value directly:
+
+[source,ruby]
+----
+doc.xpath("for $w in //a return string($w/@v)").map(&:content)  # => ["1", "2"]
 ----
 
-Two caveats: `for … return` sequences come back as opaque result
-nodes — consume them through an aggregate (`count(...)`,
-`string-join(...)`) until the engine materializes readable sequence
-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, `intersect`/`except`, string templates — and XQuery
-itself are
-https://github.com/leptris/leptris/issues/683[tracked upstream].
+Remaining grammar gaps (https://github.com/leptris/leptris/issues/683[tracked
+upstream]): 3.1 string templates, XQuery beyond the 1.0 core.
 
 === Supported CSS selectors
 
@@ -585,7 +609,9 @@ Notable differences:
   Nokogiri is silent on this — migrating code that holds Node references
   past Document disposal will see the error; silence-replace-UAF patterns
   from Nokogiri do not apply.
-* No `Nokogiri::HTML` or `Nokogiri::CSS` parser. Leptris is XML-only.
+* No `Nokogiri::CSS` parser. HTML parsing is supported
+  (`Leptris::XML.parse_html`, libleptris 1.9.75); Nokogiri's
+  HTML-specific node subclasses have no equivalent.
 * No RelaxNG / DTD validation, no schema caching (XSLT 1.0–3.0
   and an XQuery 1.0 core are supported — see above).
 * No built-in JRuby / TruffleRuby support — only CRuby via `ffi`.

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.67"
+LIBLEPTRIS_VERSION = "1.9.75"
 
 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.57"
+  VERSION = "1.9.58"
 end

data/lib/leptris/xml/element.rb

@@ -251,16 +251,12 @@ class Leptris::XML::Element < Leptris::XML::Node
     self
   end
 
-  # 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.
+  # Deep copy in a NEW document via serialization round-trip
+  # (leptris/leptris#812: the 1.9.74 copy rewrite drops
+  # descendant-used declarations; the serializer is byte-exact).
   def dup
     ensure_alive!
-    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)
+    Leptris::XML::Document.parse(to_xml).root
   end
   alias_method :clone, :dup
 

data/lib/leptris/xml/ffi.rb

@@ -133,7 +133,16 @@ module Leptris
       attach_function :leptris_version, [], :string
       attach_function :leptris_version_components, [:pointer, :pointer, :pointer], :void
 
-      attach_function :leptris_parse_string,
+            # Tolerant HTML4/5 parse into the STANDARD DOM (libleptris
+      # 1.9.75, #659): implied end tags, void elements, raw-text
+      # script/style, case-insensitive (lowercased) names, the HTML
+      # named-entity table. Document shape — html/head/body
+      # synthesized; no implied tbody. Malformed input never fails
+      # the parse; only an entirely empty result is an error.
+      attach_function :leptris_parse_html_string,
+        [:string, :size_t, :pointer], :leptris_document
+
+attach_function :leptris_parse_string,
         [:string, :size_t, :pointer], :leptris_document
       attach_function :leptris_parse_string_flags,
         [:string, :size_t, :uint, :pointer], :leptris_document
@@ -780,6 +789,11 @@ module Leptris
       NODE_COMMENT = 2
       NODE_CDATA = 3
       NODE_PI = 4
+      # Internal XPath-synthetic text node (leptris/types.h): the
+      # carrier for sequence/map/array items in result nodesets —
+      # readable only through the result handle, so the binding
+      # captures the value at materialization (ResultText).
+      NODE_SYNTHETIC_TEXT = 8
       NODE_DOCTYPE = 5
       NODE_ATTRIBUTE = 6
 
@@ -1070,15 +1084,19 @@ module Leptris
       # get_type in the wrapper. Returns [pointers, element_hints].
       XPATH_KIND_HINT = { XPATH_NODE_ELEMENT => NODE_ELEMENT }.freeze
 
+      # Returns [pointers, element_hints, raw_kinds] — the raw
+      # XPATH_NODE-space kinds ride along so the materializer can
+      # spot TEXT items (synthetic sequence carriers) and capture
+      # their values while the result handle is alive.
       def self.fetch_result_nodes(result_ptr, count)
-        return [[], nil] if count.zero?
+        return [[], nil, nil] if count.zero?
         buffer = scratch_pointers(count)
         kinds = scratch_ints(count)
         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]
+        raw = kinds.get_array_of_int(0, copied)
+        hints = raw.map { |k| XPATH_KIND_HINT[k] }
+        [buffer.get_array_of_pointer(0, copied), hints, raw]
       end
 
       # Fragment parse with the status out-param read: returns

data/lib/leptris/xml/node.rb

@@ -15,7 +15,7 @@ class Leptris::XML::Node
   # 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)
+  def self.wrap(c_ptr, document, parent: nil, node_type: nil, result_value: 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
@@ -37,6 +37,11 @@ class Leptris::XML::Node
         Leptris::XML::Element.new(c_ptr, document, parent: parent, node_type: node_type)
       when Leptris::XML::FFI::NODE_TEXT
         Leptris::XML::Text.new(c_ptr, document, parent: parent, node_type: node_type)
+      when Leptris::XML::FFI::NODE_SYNTHETIC_TEXT
+        # Sequence/map/array items: value captured by the NodeSet at
+        # materialization (only the result handle can read them).
+        Leptris::XML::ResultText.new(
+          c_ptr, document, result_value, parent: parent, node_type: node_type)
       when Leptris::XML::FFI::NODE_COMMENT
         Leptris::XML::Comment.new(c_ptr, document, parent: parent, node_type: node_type)
       when Leptris::XML::FFI::NODE_CDATA
@@ -369,18 +374,17 @@ class Leptris::XML::Node
     result
   end
 
-  # 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.
+  # Deep copy in a NEW document. Rounds through serialization: the
+  # 1.9.74 copy rewrite (#653 perf lane) drops declarations used
+  # only by descendants — resolution on the copied subtree resolves
+  # NULL (leptris/leptris#812, an #721 regression) — while the
+  # serializer preserves every child kind, prefixed name, and
+  # declaration byte-for-byte.
   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?
-    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)
+    Leptris::XML::Document.parse(to_xml).root
   end
   alias_method :clone, :dup
 

data/lib/leptris/xml/node_set.rb

@@ -62,10 +62,21 @@ class Leptris::XML::NodeSet
     if @result_ptr
       ptr = Leptris::XML::FFI.leptris_xpath_result_get_node(@result_ptr, idx)
       return nil if ptr.null?
-      Leptris::XML::Node.wrap(ptr, @document)
+      Leptris::XML::Node.wrap(
+        ptr, @document,
+        result_value: text_item_value(
+          Leptris::XML::FFI.leptris_xpath_result_node_kind(@result_ptr, idx), idx))
     end
   end
 
+  # Sequence/map/array items ride synthetic text nodes whose value
+  # only the live result handle can serve — capture it now.
+  def text_item_value(kind, index)
+    return nil unless kind == Leptris::XML::FFI::XPATH_NODE_TEXT
+    Leptris::XML::FFI.leptris_xpath_result_node_value(@result_ptr, index)
+  end
+  private :text_item_value
+
   # Iteration materializes: the first pass batch-fetches into @array
   # (yielding as it wraps), and every subsequent reader — each, [],
   # length — serves from the array. Repeated iteration without an
@@ -81,16 +92,21 @@ 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, kinds = Leptris::XML::FFI.fetch_result_nodes(@result_ptr, n)
+        pointers, kinds, raw = Leptris::XML::FFI.fetch_result_nodes(@result_ptr, n)
         nodes = []
         pointers.each_with_index do |ptr, i|
           next if ptr.null?
-          nodes << Leptris::XML::Node.wrap(ptr, @document, node_type: kinds[i])
+          nodes << Leptris::XML::Node.wrap(
+            ptr, @document, node_type: kinds[i],
+            result_value: text_item_value(raw[i], i))
         end
         (pointers.length...n).each do |i|
           ptr = Leptris::XML::FFI.leptris_xpath_result_get_node(@result_ptr, i)
           next if ptr.null?
-          nodes << Leptris::XML::Node.wrap(ptr, @document)
+          nodes << Leptris::XML::Node.wrap(
+            ptr, @document,
+            result_value: text_item_value(
+              Leptris::XML::FFI.leptris_xpath_result_node_kind(@result_ptr, i), i))
         end
         @array = nodes
       else

data/lib/leptris/xml/result_text.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Text-kind item from an XPath/XQuery sequence result: the engine
+# materializes sequence, map, and array items as synthetic text
+# nodes (leptris/types.h's internal kind 8) whose value is readable
+# only through the live result handle — the node-pointer accessors
+# return nothing for them. The NodeSet therefore captures the string
+# value at materialization time and hands it to this wrapper.
+#
+#     doc.xpath("for $w in //a return string($w/@v)").map(&:content)
+#     # => ["1", "2"]
+#
+class Leptris::XML::ResultText < Leptris::XML::Node
+  def initialize(c_ptr, document, value, parent: nil, node_type: nil)
+    super(c_ptr, document, parent: parent, node_type: node_type)
+    @value = value
+  end
+
+  def name
+    "text"
+  end
+
+  # The captured string: safe to read even after the owning result
+  # set has been collected (unlike pointer-backed reads).
+  def content
+    @value
+  end
+
+  def to_s
+    @value
+  end
+
+  def text?
+    true
+  end
+end

data/lib/leptris/xml/serialization.rb

@@ -115,17 +115,14 @@ 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
-  # 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.
+  # rounds the subtree through serialization into a fresh document
+  # (the 1.9.74 C copy drops descendant-used declarations —
+  # leptris/leptris#812) 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.create
+    document = Leptris::XML::Document.parse(element.to_xml)
     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

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 :ResultText, "leptris/xml/result_text"
     autoload :XSLT, "leptris/xml/xslt"
     autoload :XQuery, "leptris/xml/xquery"
     autoload :Pull, "leptris/xml/pull"
@@ -44,6 +45,24 @@ module Leptris
         string, string.bytesize) != 0
     end
 
+    # Tolerant HTML4/5 parse into a standard Document (libleptris
+    # 1.9.75): implied end tags, void elements, raw-text script and
+    # style, lowercased names, minimized/unquoted attributes, and
+    # the HTML named entities. Document shape — html/head/body are
+    # synthesized (Nokogiri::HTML parity), but NO implied tbody.
+    # Malformed input degrades to text rather than raising; only an
+    # entirely empty result is an error.
+    def self.parse_html(html)
+      html = html.to_s
+      raw = Leptris::XML::FFI.leptris_parse_html_string(
+        html, html.bytesize, nil)
+      if raw.null?
+        raise Leptris::XML::ParseError,
+          "HTML parse failed: #{Leptris::XML::FFI.leptris_last_error}"
+      end
+      Leptris::XML::Document.wrap(raw)
+    end
+
     def self.parse_file(path)
       Document.parse_file(path)
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: leptris
 version: !ruby/object:Gem::Version
-  version: 1.9.57
+  version: 1.9.58
 platform: ruby
 authors:
 - Ribose Inc.
@@ -96,6 +96,7 @@ files:
 - lib/leptris/xml/parse_options.rb
 - lib/leptris/xml/processing_instruction.rb
 - lib/leptris/xml/pull.rb
+- lib/leptris/xml/result_text.rb
 - lib/leptris/xml/sax.rb
 - lib/leptris/xml/sax/document.rb
 - lib/leptris/xml/sax/dom_dispatch.rb